mirror of
https://github.com/obsproject/obs-studio.git
synced 2024-09-20 04:42:18 +02:00
libobs: Add Pulseaudio audio monitoring support
Checks if the system has Pulseaudio and enables support via the HAVE_PULSEAUDIO flag. Closes jp9000/obs-studio#940
This commit is contained in:
parent
b1f2b72628
commit
b6042d91ea
@ -12,12 +12,20 @@ if (NOT "${FFMPEG_AVCODEC_LIBRARIES}" STREQUAL "")
|
||||
endif()
|
||||
|
||||
if(UNIX)
|
||||
find_package(PulseAudio)
|
||||
if (NOT "${PULSEAUDIO_LIBRARY}" STREQUAL "")
|
||||
message(STATUS "Found PulseAudio - Audio Monitor enabled")
|
||||
set(HAVE_PULSEAUDIO "1")
|
||||
else()
|
||||
set(HAVE_PULSEAUDIO "0")
|
||||
endif()
|
||||
find_package(DBus QUIET)
|
||||
if (NOT APPLE)
|
||||
find_package(X11_XCB REQUIRED)
|
||||
endif()
|
||||
else()
|
||||
set(HAVE_DBUS "0")
|
||||
set(HAVE_PULSEAUDIO "0")
|
||||
endif()
|
||||
|
||||
find_package(ImageMagick QUIET COMPONENTS MagickCore)
|
||||
@ -145,12 +153,22 @@ elseif(UNIX)
|
||||
util/threading-posix.c
|
||||
util/pipe-posix.c
|
||||
util/platform-nix.c)
|
||||
|
||||
set(libobs_PLATFORM_HEADERS
|
||||
util/threading-posix.h)
|
||||
set(libobs_audio_monitoring_SOURCES
|
||||
audio-monitoring/null/null-audio-monitoring.c
|
||||
)
|
||||
|
||||
if(HAVE_PULSEAUDIO)
|
||||
set(libobs_audio_monitoring_HEADERS
|
||||
audio-monitoring/pulse/pulseaudio-wrapper.h)
|
||||
|
||||
set(libobs_audio_monitoring_SOURCES
|
||||
audio-monitoring/pulse/pulseaudio-wrapper.c
|
||||
audio-monitoring/pulse/pulseaudio-enum-devices.c
|
||||
audio-monitoring/pulse/pulseaudio-output.c)
|
||||
else()
|
||||
set(libobs_audio_monitoring_SOURCES
|
||||
audio-monitoring/null/null-audio-monitoring.c)
|
||||
endif()
|
||||
if(DBUS_FOUND)
|
||||
set(libobs_PLATFORM_SOURCES ${libobs_PLATFORM_SOURCES}
|
||||
util/platform-nix-dbus.c)
|
||||
@ -168,6 +186,12 @@ elseif(UNIX)
|
||||
${libobs_PLATFORM_DEPS}
|
||||
${X11_XCB_LIBRARIES})
|
||||
|
||||
if(HAVE_PULSEAUDIO)
|
||||
set(libobs_PLATFORM_DEPS
|
||||
${libobs_PLATFORM_DEPS}
|
||||
${PULSEAUDIO_LIBRARY})
|
||||
endif()
|
||||
|
||||
if(${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD")
|
||||
# use the sysinfo compatibility library on bsd
|
||||
find_package(Libsysinfo REQUIRED)
|
||||
@ -358,7 +382,9 @@ set(libobs_SOURCES
|
||||
${libobs_graphics_SOURCES}
|
||||
${libobs_mediaio_SOURCES}
|
||||
${libobs_util_SOURCES}
|
||||
${libobs_libobs_SOURCES})
|
||||
${libobs_libobs_SOURCES}
|
||||
${libobs_audio_monitoring_SOURCES}
|
||||
)
|
||||
|
||||
set(libobs_HEADERS
|
||||
${libobs_config_HEADERS}
|
||||
@ -367,7 +393,6 @@ set(libobs_HEADERS
|
||||
${libobs_mediaio_HEADERS}
|
||||
${libobs_util_HEADERS}
|
||||
${libobs_libobs_HEADERS}
|
||||
${libobs_audio_monitoring_SOURCES}
|
||||
${libobs_audio_monitoring_HEADERS}
|
||||
)
|
||||
|
||||
|
@ -1,4 +1,4 @@
|
||||
#include "../../obs-internal.h"
|
||||
#include <obs-internal.h>
|
||||
|
||||
void obs_enum_audio_monitoring_devices(obs_enum_audio_device_cb cb, void *data)
|
||||
{
|
||||
|
33
libobs/audio-monitoring/pulse/pulseaudio-enum-devices.c
Normal file
33
libobs/audio-monitoring/pulse/pulseaudio-enum-devices.c
Normal file
@ -0,0 +1,33 @@
|
||||
#include <obs-internal.h>
|
||||
#include "pulseaudio-wrapper.h"
|
||||
|
||||
static void pulseaudio_output_info(pa_context *c, const pa_source_info *i,
|
||||
int eol, void *userdata)
|
||||
{
|
||||
UNUSED_PARAMETER(c);
|
||||
if (eol != 0 || i->monitor_of_sink == PA_INVALID_INDEX)
|
||||
goto skip;
|
||||
|
||||
struct enum_cb *ecb = (struct enum_cb *) userdata;
|
||||
if (ecb->cont)
|
||||
ecb->cont = ecb->cb(ecb->data, i->description, i->name);
|
||||
|
||||
skip:
|
||||
pulseaudio_signal(0);
|
||||
}
|
||||
|
||||
void obs_enum_audio_monitoring_devices(obs_enum_audio_device_cb cb,
|
||||
void *data)
|
||||
{
|
||||
struct enum_cb *ecb = bzalloc(sizeof(struct enum_cb));
|
||||
ecb->cb = cb;
|
||||
ecb->data = data;
|
||||
ecb->cont = 1;
|
||||
|
||||
pulseaudio_init();
|
||||
pa_source_info_cb_t pa_cb = pulseaudio_output_info;
|
||||
pulseaudio_get_source_info_list(pa_cb, (void *) ecb);
|
||||
pulseaudio_unref();
|
||||
|
||||
bfree(ecb);
|
||||
}
|
469
libobs/audio-monitoring/pulse/pulseaudio-output.c
Normal file
469
libobs/audio-monitoring/pulse/pulseaudio-output.c
Normal file
@ -0,0 +1,469 @@
|
||||
#include "obs-internal.h"
|
||||
#include "pulseaudio-wrapper.h"
|
||||
|
||||
#define PULSE_DATA(voidptr) struct audio_monitor *data = voidptr;
|
||||
#define blog(level, msg, ...) blog(level, "pulse-am: " msg, ##__VA_ARGS__)
|
||||
|
||||
struct audio_monitor {
|
||||
obs_source_t *source;
|
||||
pa_stream *stream;
|
||||
char *device;
|
||||
|
||||
enum speaker_layout speakers;
|
||||
pa_sample_format_t format;
|
||||
uint_fast32_t samples_per_sec;
|
||||
uint_fast32_t bytes_per_frame;
|
||||
uint_fast8_t channels;
|
||||
|
||||
uint_fast32_t packets;
|
||||
uint_fast64_t frames;
|
||||
|
||||
struct circlebuf new_data;
|
||||
audio_resampler_t *resampler;
|
||||
size_t buffer_size;
|
||||
size_t bytesRemaining;
|
||||
|
||||
size_t bytes_per_channel;
|
||||
bool ignore;
|
||||
pthread_mutex_t playback_mutex;
|
||||
};
|
||||
|
||||
static enum speaker_layout pulseaudio_channels_to_obs_speakers(
|
||||
uint_fast32_t channels)
|
||||
{
|
||||
if ((channels >= 1 && channels <= 6) || channels == 8)
|
||||
return (enum speaker_layout) channels;
|
||||
return SPEAKERS_UNKNOWN;
|
||||
}
|
||||
|
||||
static enum audio_format pulseaudio_to_obs_audio_format(
|
||||
pa_sample_format_t format)
|
||||
{
|
||||
switch (format) {
|
||||
case PA_SAMPLE_U8:
|
||||
return AUDIO_FORMAT_U8BIT;
|
||||
case PA_SAMPLE_S16LE:
|
||||
return AUDIO_FORMAT_16BIT;
|
||||
case PA_SAMPLE_S32LE:
|
||||
return AUDIO_FORMAT_32BIT;
|
||||
case PA_SAMPLE_FLOAT32LE:
|
||||
return AUDIO_FORMAT_FLOAT;
|
||||
default:
|
||||
return AUDIO_FORMAT_UNKNOWN;
|
||||
}
|
||||
}
|
||||
|
||||
static void process_byte(void *p, size_t frames, size_t channels, float vol)
|
||||
{
|
||||
register char *cur = (char *) p;
|
||||
register char *end = cur + frames * channels;
|
||||
|
||||
while (cur < end)
|
||||
*(cur++) *= vol;
|
||||
}
|
||||
|
||||
static void process_short(void *p, size_t frames, size_t channels, float vol)
|
||||
{
|
||||
register short *cur = (short *) p;
|
||||
register short *end = cur + frames * channels;
|
||||
|
||||
while (cur < end)
|
||||
*(cur++) *= vol;
|
||||
}
|
||||
|
||||
static void process_float(void *p, size_t frames, size_t channels, float vol)
|
||||
{
|
||||
register float *cur = (float *) p;
|
||||
register float *end = cur + frames * channels;
|
||||
|
||||
while (cur < end)
|
||||
*(cur++) *= vol;
|
||||
}
|
||||
|
||||
void process_volume(const struct audio_monitor *monitor, float vol,
|
||||
uint8_t *const *resample_data, uint32_t resample_frames)
|
||||
{
|
||||
switch (monitor->bytes_per_channel) {
|
||||
case 1:
|
||||
process_byte(resample_data[0], resample_frames,
|
||||
monitor->channels, vol);
|
||||
break;
|
||||
case 2:
|
||||
process_short(resample_data[0], resample_frames,
|
||||
monitor->channels, vol);
|
||||
break;
|
||||
default:
|
||||
process_float(resample_data[0], resample_frames,
|
||||
monitor->channels, vol);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
static void do_stream_write(void *param)
|
||||
{
|
||||
PULSE_DATA(param);
|
||||
uint8_t *buffer = NULL;
|
||||
|
||||
while (data->new_data.size >= data->buffer_size &&
|
||||
data->bytesRemaining > 0) {
|
||||
size_t bytesToFill = data->buffer_size;
|
||||
|
||||
if (bytesToFill > data->bytesRemaining)
|
||||
bytesToFill = data->bytesRemaining;
|
||||
|
||||
pa_stream_begin_write(data->stream, (void **) &buffer,
|
||||
&bytesToFill);
|
||||
|
||||
circlebuf_pop_front(&data->new_data, buffer, bytesToFill);
|
||||
|
||||
pulseaudio_lock();
|
||||
pa_stream_write(data->stream, buffer, bytesToFill, NULL,
|
||||
0LL, PA_SEEK_RELATIVE);
|
||||
pulseaudio_unlock();
|
||||
|
||||
data->bytesRemaining -= bytesToFill;
|
||||
}
|
||||
}
|
||||
|
||||
static void on_audio_playback(void *param, obs_source_t *source,
|
||||
const struct audio_data *audio_data, bool muted)
|
||||
{
|
||||
struct audio_monitor *monitor = param;
|
||||
float vol = source->user_volume;
|
||||
size_t bytes;
|
||||
|
||||
uint8_t *resample_data[MAX_AV_PLANES];
|
||||
uint32_t resample_frames;
|
||||
uint64_t ts_offset;
|
||||
bool success;
|
||||
|
||||
if (pthread_mutex_trylock(&monitor->playback_mutex) != 0)
|
||||
return;
|
||||
|
||||
if (os_atomic_load_long(&source->activate_refs) == 0)
|
||||
goto unlock;
|
||||
|
||||
success = audio_resampler_resample(monitor->resampler, resample_data,
|
||||
&resample_frames, &ts_offset,
|
||||
(const uint8_t *const *) audio_data->data,
|
||||
(uint32_t) audio_data->frames);
|
||||
|
||||
if (!success)
|
||||
goto unlock;
|
||||
|
||||
bytes = monitor->bytes_per_frame * resample_frames;
|
||||
|
||||
if (muted) {
|
||||
memset(resample_data[0], 0, bytes);
|
||||
} else {
|
||||
if (!close_float(vol, 1.0f, EPSILON)) {
|
||||
process_volume(monitor, vol, resample_data,
|
||||
resample_frames);
|
||||
}
|
||||
}
|
||||
|
||||
circlebuf_push_back(&monitor->new_data, resample_data[0], bytes);
|
||||
monitor->packets++;
|
||||
monitor->frames += resample_frames;
|
||||
|
||||
unlock:
|
||||
pthread_mutex_unlock(&monitor->playback_mutex);
|
||||
do_stream_write(param);
|
||||
}
|
||||
|
||||
static void pulseaudio_stream_write(pa_stream *p, size_t nbytes, void *userdata)
|
||||
{
|
||||
UNUSED_PARAMETER(p);
|
||||
PULSE_DATA(userdata);
|
||||
|
||||
pthread_mutex_lock(&data->playback_mutex);
|
||||
data->bytesRemaining += nbytes;
|
||||
pthread_mutex_unlock(&data->playback_mutex);
|
||||
|
||||
pulseaudio_signal(0);
|
||||
}
|
||||
|
||||
static void pulseaudio_server_info(pa_context *c, const pa_server_info *i,
|
||||
void *userdata)
|
||||
{
|
||||
UNUSED_PARAMETER(c);
|
||||
UNUSED_PARAMETER(userdata);
|
||||
|
||||
blog(LOG_INFO, "Server name: '%s %s'", i->server_name,
|
||||
i->server_version);
|
||||
|
||||
pulseaudio_signal(0);
|
||||
}
|
||||
|
||||
static void pulseaudio_source_info(pa_context *c, const pa_source_info *i,
|
||||
int eol, void *userdata)
|
||||
{
|
||||
UNUSED_PARAMETER(c);
|
||||
PULSE_DATA(userdata);
|
||||
// An error occured
|
||||
if (eol < 0) {
|
||||
data->format = PA_SAMPLE_INVALID;
|
||||
goto skip;
|
||||
}
|
||||
// Terminating call for multi instance callbacks
|
||||
if (eol > 0)
|
||||
goto skip;
|
||||
|
||||
blog(LOG_INFO, "Audio format: %s, %"PRIu32" Hz, %"PRIu8" channels",
|
||||
pa_sample_format_to_string(i->sample_spec.format),
|
||||
i->sample_spec.rate, i->sample_spec.channels);
|
||||
|
||||
pa_sample_format_t format = i->sample_spec.format;
|
||||
if (pulseaudio_to_obs_audio_format(format) == AUDIO_FORMAT_UNKNOWN) {
|
||||
format = PA_SAMPLE_S16LE;
|
||||
|
||||
blog(LOG_INFO, "Sample format %s not supported by OBS,"
|
||||
"using %s instead for recording",
|
||||
pa_sample_format_to_string(
|
||||
i->sample_spec.format),
|
||||
pa_sample_format_to_string(format));
|
||||
}
|
||||
|
||||
uint8_t channels = i->sample_spec.channels;
|
||||
if (pulseaudio_channels_to_obs_speakers(channels) == SPEAKERS_UNKNOWN) {
|
||||
channels = 2;
|
||||
|
||||
blog(LOG_INFO, "%c channels not supported by OBS,"
|
||||
"using %c instead for recording",
|
||||
i->sample_spec.channels,
|
||||
channels);
|
||||
}
|
||||
|
||||
data->format = format;
|
||||
data->samples_per_sec = i->sample_spec.rate;
|
||||
data->channels = channels;
|
||||
skip:
|
||||
pulseaudio_signal(0);
|
||||
}
|
||||
|
||||
static void pulseaudio_stop_playback(struct audio_monitor *monitor)
|
||||
{
|
||||
if (monitor->stream) {
|
||||
pa_stream_disconnect(monitor->stream);
|
||||
pa_stream_unref(monitor->stream);
|
||||
monitor->stream = NULL;
|
||||
}
|
||||
|
||||
blog(LOG_INFO, "Stopped Monitoring in '%s'", monitor->device);
|
||||
blog(LOG_INFO, "Got %"PRIuFAST32" packets with %"PRIuFAST64" frames",
|
||||
monitor->packets, monitor->frames);
|
||||
|
||||
monitor->packets = 0;
|
||||
monitor->frames = 0;
|
||||
}
|
||||
|
||||
static bool audio_monitor_init(struct audio_monitor *monitor,
|
||||
obs_source_t *source)
|
||||
{
|
||||
pthread_mutex_init_value(&monitor->playback_mutex);
|
||||
|
||||
monitor->source = source;
|
||||
|
||||
const char *id = obs->audio.monitoring_device_id;
|
||||
if (!id)
|
||||
return false;
|
||||
|
||||
if (source->info.output_flags & OBS_SOURCE_DO_NOT_SELF_MONITOR) {
|
||||
obs_data_t *s = obs_source_get_settings(source);
|
||||
const char *s_dev_id = obs_data_get_string(s, "device_id");
|
||||
bool match = devices_match(s_dev_id, id);
|
||||
obs_data_release(s);
|
||||
|
||||
if (match) {
|
||||
monitor->ignore = true;
|
||||
blog(LOG_INFO, "Prevented feedback-loop in '%s'",
|
||||
s_dev_id);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
pulseaudio_init();
|
||||
|
||||
if (strcmp(id, "default") == 0)
|
||||
get_default_id(&monitor->device);
|
||||
else
|
||||
monitor->device = bstrdup(id);
|
||||
|
||||
if (!monitor->device)
|
||||
return false;
|
||||
|
||||
if (pulseaudio_get_server_info(pulseaudio_server_info,
|
||||
(void *) monitor) < 0) {
|
||||
blog(LOG_ERROR, "Unable to get server info !");
|
||||
return false;
|
||||
}
|
||||
|
||||
if (pulseaudio_get_source_info(pulseaudio_source_info, monitor->device,
|
||||
(void *) monitor) < 0) {
|
||||
blog(LOG_ERROR, "Unable to get source info !");
|
||||
return false;
|
||||
}
|
||||
if (monitor->format == PA_SAMPLE_INVALID) {
|
||||
blog(LOG_ERROR,
|
||||
"An error occurred while getting the source info!");
|
||||
return false;
|
||||
}
|
||||
|
||||
pa_sample_spec spec;
|
||||
spec.format = monitor->format;
|
||||
spec.rate = (uint32_t) monitor->samples_per_sec;
|
||||
spec.channels = monitor->channels;
|
||||
|
||||
if (!pa_sample_spec_valid(&spec)) {
|
||||
blog(LOG_ERROR, "Sample spec is not valid");
|
||||
return false;
|
||||
}
|
||||
|
||||
const struct audio_output_info *info = audio_output_get_info(
|
||||
obs->audio.audio);
|
||||
|
||||
struct resample_info from = {
|
||||
.samples_per_sec = info->samples_per_sec,
|
||||
.speakers = info->speakers,
|
||||
.format = AUDIO_FORMAT_FLOAT_PLANAR
|
||||
};
|
||||
struct resample_info to = {
|
||||
.samples_per_sec = (uint32_t) monitor->samples_per_sec,
|
||||
.speakers = pulseaudio_channels_to_obs_speakers(
|
||||
monitor->channels),
|
||||
.format = pulseaudio_to_obs_audio_format
|
||||
(monitor->format)
|
||||
};
|
||||
|
||||
monitor->resampler = audio_resampler_create(&to, &from);
|
||||
if (!monitor->resampler) {
|
||||
blog(LOG_WARNING, "%s: %s", __FUNCTION__,
|
||||
"Failed to create resampler");
|
||||
return false;
|
||||
}
|
||||
|
||||
monitor->bytes_per_channel = get_audio_bytes_per_channel(
|
||||
pulseaudio_to_obs_audio_format(monitor->format));
|
||||
monitor->speakers = pulseaudio_channels_to_obs_speakers(spec.channels);
|
||||
monitor->bytes_per_frame = pa_frame_size(&spec);
|
||||
|
||||
monitor->stream = pulseaudio_stream_new(
|
||||
obs_source_get_name(monitor->source), &spec, NULL);
|
||||
if (!monitor->stream) {
|
||||
blog(LOG_ERROR, "Unable to create stream");
|
||||
return false;
|
||||
}
|
||||
|
||||
pa_buffer_attr attr;
|
||||
attr.fragsize = (uint32_t) -1;
|
||||
attr.maxlength = (uint32_t) -1;
|
||||
attr.minreq = (uint32_t) -1;
|
||||
attr.prebuf = (uint32_t) -1;
|
||||
attr.tlength = pa_usec_to_bytes(25000, &spec);
|
||||
|
||||
monitor->buffer_size =
|
||||
monitor->bytes_per_frame * pa_usec_to_bytes(100, &spec);
|
||||
|
||||
pa_stream_flags_t flags = PA_STREAM_ADJUST_LATENCY;
|
||||
|
||||
if (pthread_mutex_init(&monitor->playback_mutex, NULL) != 0) {
|
||||
blog(LOG_WARNING, "%s: %s", __FUNCTION__,
|
||||
"Failed to init mutex");
|
||||
return false;
|
||||
}
|
||||
|
||||
int_fast32_t ret = pulseaudio_connect_playback(monitor->stream,
|
||||
monitor->device, &attr, flags);
|
||||
if (ret < 0) {
|
||||
pulseaudio_stop_playback(monitor);
|
||||
blog(LOG_ERROR, "Unable to connect to stream");
|
||||
return false;
|
||||
}
|
||||
|
||||
blog(LOG_INFO, "Started Monitoring in '%s'", monitor->device);
|
||||
return true;
|
||||
}
|
||||
|
||||
static void audio_monitor_init_final(struct audio_monitor *monitor)
|
||||
{
|
||||
if (monitor->ignore)
|
||||
return;
|
||||
|
||||
obs_source_add_audio_capture_callback(monitor->source,
|
||||
on_audio_playback, monitor);
|
||||
|
||||
pulseaudio_write_callback(monitor->stream, pulseaudio_stream_write,
|
||||
(void *) monitor);
|
||||
}
|
||||
|
||||
static inline void audio_monitor_free(struct audio_monitor *monitor)
|
||||
{
|
||||
if (monitor->ignore)
|
||||
return;
|
||||
|
||||
if (monitor->source)
|
||||
obs_source_remove_audio_capture_callback(monitor->source,
|
||||
on_audio_playback, monitor);
|
||||
|
||||
audio_resampler_destroy(monitor->resampler);
|
||||
circlebuf_free(&monitor->new_data);
|
||||
|
||||
if (monitor->stream)
|
||||
pulseaudio_stop_playback(monitor);
|
||||
pulseaudio_unref();
|
||||
|
||||
bfree(monitor->device);
|
||||
}
|
||||
|
||||
struct audio_monitor *audio_monitor_create(obs_source_t *source)
|
||||
{
|
||||
struct audio_monitor monitor = {0};
|
||||
struct audio_monitor *out;
|
||||
|
||||
if (!audio_monitor_init(&monitor, source))
|
||||
goto fail;
|
||||
|
||||
out = bmemdup(&monitor, sizeof(monitor));
|
||||
|
||||
pthread_mutex_lock(&obs->audio.monitoring_mutex);
|
||||
da_push_back(obs->audio.monitors, &out);
|
||||
pthread_mutex_unlock(&obs->audio.monitoring_mutex);
|
||||
|
||||
audio_monitor_init_final(out);
|
||||
return out;
|
||||
|
||||
fail:
|
||||
audio_monitor_free(&monitor);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void audio_monitor_reset(struct audio_monitor *monitor)
|
||||
{
|
||||
struct audio_monitor new_monitor = {0};
|
||||
bool success;
|
||||
audio_monitor_free(monitor);
|
||||
|
||||
pthread_mutex_lock(&monitor->playback_mutex);
|
||||
success = audio_monitor_init(&new_monitor, monitor->source);
|
||||
pthread_mutex_unlock(&monitor->playback_mutex);
|
||||
|
||||
if (success) {
|
||||
*monitor = new_monitor;
|
||||
audio_monitor_init_final(monitor);
|
||||
} else {
|
||||
audio_monitor_free(&new_monitor);
|
||||
}
|
||||
}
|
||||
|
||||
void audio_monitor_destroy(struct audio_monitor *monitor)
|
||||
{
|
||||
if (monitor) {
|
||||
audio_monitor_free(monitor);
|
||||
|
||||
pthread_mutex_lock(&obs->audio.monitoring_mutex);
|
||||
da_erase_item(obs->audio.monitors, &monitor);
|
||||
pthread_mutex_unlock(&obs->audio.monitoring_mutex);
|
||||
|
||||
bfree(monitor);
|
||||
}
|
||||
}
|
330
libobs/audio-monitoring/pulse/pulseaudio-wrapper.c
Normal file
330
libobs/audio-monitoring/pulse/pulseaudio-wrapper.c
Normal file
@ -0,0 +1,330 @@
|
||||
/*
|
||||
Copyright (C) 2014 by Leonhard Oelke <leonhard@in-verted.de>
|
||||
Copyright (C) 2017 by Fabio Madia <admshao@gmail.com>
|
||||
|
||||
This program is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include <pthread.h>
|
||||
|
||||
#include <pulse/thread-mainloop.h>
|
||||
|
||||
#include <util/base.h>
|
||||
#include <obs.h>
|
||||
|
||||
#include "pulseaudio-wrapper.h"
|
||||
|
||||
/* global data */
|
||||
static uint_fast32_t pulseaudio_refs = 0;
|
||||
static pthread_mutex_t pulseaudio_mutex = PTHREAD_MUTEX_INITIALIZER;
|
||||
static pa_threaded_mainloop *pulseaudio_mainloop = NULL;
|
||||
static pa_context *pulseaudio_context = NULL;
|
||||
|
||||
static void pulseaudio_default_devices(pa_context *c, const pa_server_info *i,
|
||||
void *userdata)
|
||||
{
|
||||
UNUSED_PARAMETER(c);
|
||||
struct pulseaudio_default_output *d =
|
||||
(struct pulseaudio_default_output *) userdata;
|
||||
d->default_sink_name = bstrdup(i->default_sink_name);
|
||||
pulseaudio_signal(0);
|
||||
}
|
||||
|
||||
void get_default_id(char **id)
|
||||
{
|
||||
pulseaudio_init();
|
||||
struct pulseaudio_default_output *pdo = bzalloc(
|
||||
sizeof(struct pulseaudio_default_output));
|
||||
pulseaudio_get_server_info(
|
||||
(pa_server_info_cb_t) pulseaudio_default_devices,
|
||||
(void *) pdo);
|
||||
*id = bzalloc(strlen(pdo->default_sink_name) + 9);
|
||||
strcat(*id, pdo->default_sink_name);
|
||||
strcat(*id, ".monitor");
|
||||
bfree(pdo->default_sink_name);
|
||||
bfree(pdo);
|
||||
pulseaudio_unref();
|
||||
}
|
||||
|
||||
bool devices_match(const char *id1, const char *id2)
|
||||
{
|
||||
bool match;
|
||||
char *name1 = NULL;
|
||||
char *name2 = NULL;
|
||||
|
||||
if (!id1 || !id2)
|
||||
return false;
|
||||
|
||||
if (strcmp(id1, "default") == 0) {
|
||||
get_default_id(&name1);
|
||||
id1 = name1;
|
||||
}
|
||||
if (strcmp(id2, "default") == 0) {
|
||||
get_default_id(&name2);
|
||||
id2 = name2;
|
||||
}
|
||||
|
||||
match = strcmp(id1, id2) == 0;
|
||||
bfree(name1);
|
||||
bfree(name2);
|
||||
return match;
|
||||
}
|
||||
|
||||
/**
|
||||
* context status change callback
|
||||
*
|
||||
* @todo this is currently a noop, we want to reconnect here if the connection
|
||||
* is lost ...
|
||||
*/
|
||||
static void pulseaudio_context_state_changed(pa_context *c, void *userdata)
|
||||
{
|
||||
UNUSED_PARAMETER(userdata);
|
||||
UNUSED_PARAMETER(c);
|
||||
|
||||
pulseaudio_signal(0);
|
||||
}
|
||||
|
||||
/**
|
||||
* get the default properties
|
||||
*/
|
||||
static pa_proplist *pulseaudio_properties()
|
||||
{
|
||||
pa_proplist *p = pa_proplist_new();
|
||||
|
||||
pa_proplist_sets(p, PA_PROP_APPLICATION_NAME, "OBS");
|
||||
pa_proplist_sets(p, PA_PROP_APPLICATION_ICON_NAME, "obs");
|
||||
pa_proplist_sets(p, PA_PROP_MEDIA_ROLE, "production");
|
||||
|
||||
return p;
|
||||
}
|
||||
|
||||
/**
|
||||
* Initialize the pulse audio context with properties and callback
|
||||
*/
|
||||
static void pulseaudio_init_context()
|
||||
{
|
||||
pulseaudio_lock();
|
||||
|
||||
pa_proplist *p = pulseaudio_properties();
|
||||
pulseaudio_context = pa_context_new_with_proplist(
|
||||
pa_threaded_mainloop_get_api(pulseaudio_mainloop),
|
||||
"OBS-Monitor", p);
|
||||
|
||||
pa_context_set_state_callback(pulseaudio_context,
|
||||
pulseaudio_context_state_changed, NULL);
|
||||
|
||||
pa_context_connect(pulseaudio_context, NULL, PA_CONTEXT_NOAUTOSPAWN,
|
||||
NULL);
|
||||
pa_proplist_free(p);
|
||||
|
||||
pulseaudio_unlock();
|
||||
}
|
||||
|
||||
/**
|
||||
* wait for context to be ready
|
||||
*/
|
||||
static int_fast32_t pulseaudio_context_ready()
|
||||
{
|
||||
pulseaudio_lock();
|
||||
|
||||
if (!PA_CONTEXT_IS_GOOD(pa_context_get_state(pulseaudio_context))) {
|
||||
pulseaudio_unlock();
|
||||
return -1;
|
||||
}
|
||||
|
||||
while (pa_context_get_state(pulseaudio_context) != PA_CONTEXT_READY)
|
||||
pulseaudio_wait();
|
||||
|
||||
pulseaudio_unlock();
|
||||
return 0;
|
||||
}
|
||||
|
||||
int_fast32_t pulseaudio_init()
|
||||
{
|
||||
pthread_mutex_lock(&pulseaudio_mutex);
|
||||
|
||||
if (pulseaudio_refs == 0) {
|
||||
pulseaudio_mainloop = pa_threaded_mainloop_new();
|
||||
pa_threaded_mainloop_start(pulseaudio_mainloop);
|
||||
|
||||
pulseaudio_init_context();
|
||||
}
|
||||
|
||||
pulseaudio_refs++;
|
||||
|
||||
pthread_mutex_unlock(&pulseaudio_mutex);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void pulseaudio_unref()
|
||||
{
|
||||
pthread_mutex_lock(&pulseaudio_mutex);
|
||||
|
||||
if (--pulseaudio_refs == 0) {
|
||||
pulseaudio_lock();
|
||||
if (pulseaudio_context != NULL) {
|
||||
pa_context_disconnect(pulseaudio_context);
|
||||
pa_context_unref(pulseaudio_context);
|
||||
pulseaudio_context = NULL;
|
||||
}
|
||||
pulseaudio_unlock();
|
||||
|
||||
if (pulseaudio_mainloop != NULL) {
|
||||
pa_threaded_mainloop_stop(pulseaudio_mainloop);
|
||||
pa_threaded_mainloop_free(pulseaudio_mainloop);
|
||||
pulseaudio_mainloop = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
pthread_mutex_unlock(&pulseaudio_mutex);
|
||||
}
|
||||
|
||||
void pulseaudio_lock()
|
||||
{
|
||||
pa_threaded_mainloop_lock(pulseaudio_mainloop);
|
||||
}
|
||||
|
||||
void pulseaudio_unlock()
|
||||
{
|
||||
pa_threaded_mainloop_unlock(pulseaudio_mainloop);
|
||||
}
|
||||
|
||||
void pulseaudio_wait()
|
||||
{
|
||||
pa_threaded_mainloop_wait(pulseaudio_mainloop);
|
||||
}
|
||||
|
||||
void pulseaudio_signal(int wait_for_accept)
|
||||
{
|
||||
pa_threaded_mainloop_signal(pulseaudio_mainloop, wait_for_accept);
|
||||
}
|
||||
|
||||
void pulseaudio_accept()
|
||||
{
|
||||
pa_threaded_mainloop_accept(pulseaudio_mainloop);
|
||||
}
|
||||
|
||||
int_fast32_t pulseaudio_get_source_info_list(pa_source_info_cb_t cb,
|
||||
void *userdata)
|
||||
{
|
||||
if (pulseaudio_context_ready() < 0)
|
||||
return -1;
|
||||
|
||||
pulseaudio_lock();
|
||||
|
||||
pa_operation *op = pa_context_get_source_info_list(
|
||||
pulseaudio_context, cb, userdata);
|
||||
if (!op) {
|
||||
pulseaudio_unlock();
|
||||
return -1;
|
||||
}
|
||||
while (pa_operation_get_state(op) == PA_OPERATION_RUNNING)
|
||||
pulseaudio_wait();
|
||||
pa_operation_unref(op);
|
||||
|
||||
pulseaudio_unlock();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int_fast32_t pulseaudio_get_source_info(pa_source_info_cb_t cb,
|
||||
const char *name, void *userdata)
|
||||
{
|
||||
if (pulseaudio_context_ready() < 0)
|
||||
return -1;
|
||||
|
||||
pulseaudio_lock();
|
||||
|
||||
pa_operation *op = pa_context_get_source_info_by_name(
|
||||
pulseaudio_context, name, cb, userdata);
|
||||
if (!op) {
|
||||
pulseaudio_unlock();
|
||||
return -1;
|
||||
}
|
||||
while (pa_operation_get_state(op) == PA_OPERATION_RUNNING)
|
||||
pulseaudio_wait();
|
||||
pa_operation_unref(op);
|
||||
|
||||
pulseaudio_unlock();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int_fast32_t pulseaudio_get_server_info(pa_server_info_cb_t cb, void *userdata)
|
||||
{
|
||||
if (pulseaudio_context_ready() < 0)
|
||||
return -1;
|
||||
|
||||
pulseaudio_lock();
|
||||
|
||||
pa_operation *op = pa_context_get_server_info(
|
||||
pulseaudio_context, cb, userdata);
|
||||
if (!op) {
|
||||
pulseaudio_unlock();
|
||||
return -1;
|
||||
}
|
||||
while (pa_operation_get_state(op) == PA_OPERATION_RUNNING)
|
||||
pulseaudio_wait();
|
||||
pa_operation_unref(op);
|
||||
|
||||
pulseaudio_unlock();
|
||||
return 0;
|
||||
}
|
||||
|
||||
pa_stream *pulseaudio_stream_new(const char *name, const pa_sample_spec *ss,
|
||||
const pa_channel_map *map)
|
||||
{
|
||||
if (pulseaudio_context_ready() < 0)
|
||||
return NULL;
|
||||
|
||||
pulseaudio_lock();
|
||||
|
||||
pa_proplist *p = pulseaudio_properties();
|
||||
pa_stream *s = pa_stream_new_with_proplist(
|
||||
pulseaudio_context, name, ss, map, p);
|
||||
pa_proplist_free(p);
|
||||
|
||||
pulseaudio_unlock();
|
||||
return s;
|
||||
}
|
||||
|
||||
int_fast32_t pulseaudio_connect_playback(pa_stream *s, const char *name,
|
||||
const pa_buffer_attr *attr, pa_stream_flags_t flags)
|
||||
{
|
||||
if (pulseaudio_context_ready() < 0)
|
||||
return -1;
|
||||
|
||||
size_t dev_len = strlen(name) - 8;
|
||||
char device[dev_len];
|
||||
memcpy(device, name, dev_len);
|
||||
device[dev_len] = '\0';
|
||||
|
||||
pulseaudio_lock();
|
||||
int_fast32_t ret = pa_stream_connect_playback(s, device, attr, flags,
|
||||
NULL, NULL);
|
||||
pulseaudio_unlock();
|
||||
return ret;
|
||||
}
|
||||
|
||||
void pulseaudio_write_callback(pa_stream *p, pa_stream_request_cb_t cb,
|
||||
void *userdata)
|
||||
{
|
||||
if (pulseaudio_context_ready() < 0)
|
||||
return;
|
||||
|
||||
pulseaudio_lock();
|
||||
pa_stream_set_write_callback(p, cb, userdata);
|
||||
pulseaudio_unlock();
|
||||
}
|
175
libobs/audio-monitoring/pulse/pulseaudio-wrapper.h
Normal file
175
libobs/audio-monitoring/pulse/pulseaudio-wrapper.h
Normal file
@ -0,0 +1,175 @@
|
||||
/*
|
||||
Copyright (C) 2014 by Leonhard Oelke <leonhard@in-verted.de>
|
||||
Copyright (C) 2017 by Fabio Madia <admshao@gmail.com>
|
||||
|
||||
This program is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include <inttypes.h>
|
||||
#include <pulse/stream.h>
|
||||
#include <pulse/context.h>
|
||||
#include <pulse/introspect.h>
|
||||
|
||||
#pragma once
|
||||
|
||||
struct pulseaudio_default_output {
|
||||
char *default_sink_name;
|
||||
};
|
||||
|
||||
struct enum_cb {
|
||||
obs_enum_audio_device_cb cb;
|
||||
void *data;
|
||||
int cont;
|
||||
};
|
||||
|
||||
void get_default_id(char **id);
|
||||
|
||||
bool devices_match(const char *id1, const char *id2);
|
||||
|
||||
/**
|
||||
* Initialize the pulseaudio mainloop and increase the reference count
|
||||
*/
|
||||
int_fast32_t pulseaudio_init();
|
||||
|
||||
/**
|
||||
* Unreference the pulseaudio mainloop, when the reference count reaches
|
||||
* zero the mainloop will automatically be destroyed
|
||||
*/
|
||||
void pulseaudio_unref();
|
||||
|
||||
/**
|
||||
* Lock the mainloop
|
||||
*
|
||||
* In order to allow for multiple threads to use the same mainloop pulseaudio
|
||||
* provides it's own locking mechanism. This function should be called before
|
||||
* using any pulseaudio function that is in any way related to the mainloop or
|
||||
* context.
|
||||
*
|
||||
* @note use of this function may cause deadlocks
|
||||
*
|
||||
* @warning do not use with pulseaudio_ wrapper functions
|
||||
*/
|
||||
void pulseaudio_lock();
|
||||
|
||||
/**
|
||||
* Unlock the mainloop
|
||||
*
|
||||
* @see pulseaudio_lock()
|
||||
*/
|
||||
void pulseaudio_unlock();
|
||||
|
||||
/**
|
||||
* Wait for events to happen
|
||||
*
|
||||
* This function should be called when waiting for an event to happen.
|
||||
*/
|
||||
void pulseaudio_wait();
|
||||
|
||||
/**
|
||||
* Wait for accept signal from calling thread
|
||||
*
|
||||
* This function tells the pulseaudio mainloop wheter the data provided to
|
||||
* the callback should be retained until the calling thread executes
|
||||
* pulseaudio_accept()
|
||||
*
|
||||
* If wait_for_accept is 0 the function returns and the data is freed.
|
||||
*/
|
||||
void pulseaudio_signal(int wait_for_accept);
|
||||
|
||||
/**
|
||||
* Signal the waiting callback to return
|
||||
*
|
||||
* This function is used in conjunction with pulseaudio_signal()
|
||||
*/
|
||||
void pulseaudio_accept();
|
||||
|
||||
/**
|
||||
* Request source information
|
||||
*
|
||||
* The function will block until the operation was executed and the mainloop
|
||||
* called the provided callback function.
|
||||
*
|
||||
* @return negative on error
|
||||
*
|
||||
* @note The function will block until the server context is ready.
|
||||
*
|
||||
* @warning call without active locks
|
||||
*/
|
||||
int_fast32_t pulseaudio_get_source_info_list(pa_source_info_cb_t cb,
|
||||
void *userdata);
|
||||
|
||||
/**
|
||||
* Request source information from a specific source
|
||||
*
|
||||
* The function will block until the operation was executed and the mainloop
|
||||
* called the provided callback function.
|
||||
*
|
||||
* @param cb pointer to the callback function
|
||||
* @param name the source name to get information for
|
||||
* @param userdata pointer to userdata the callback will be called with
|
||||
*
|
||||
* @return negative on error
|
||||
*
|
||||
* @note The function will block until the server context is ready.
|
||||
*
|
||||
* @warning call without active locks
|
||||
*/
|
||||
int_fast32_t pulseaudio_get_source_info(pa_source_info_cb_t cb,
|
||||
const char *name, void *userdata);
|
||||
|
||||
/**
|
||||
* Request server information
|
||||
*
|
||||
* The function will block until the operation was executed and the mainloop
|
||||
* called the provided callback function.
|
||||
*
|
||||
* @return negative on error
|
||||
*
|
||||
* @note The function will block until the server context is ready.
|
||||
*
|
||||
* @warning call without active locks
|
||||
*/
|
||||
int_fast32_t pulseaudio_get_server_info(pa_server_info_cb_t cb, void *userdata);
|
||||
|
||||
/**
|
||||
* Create a new stream with the default properties
|
||||
*
|
||||
* @note The function will block until the server context is ready.
|
||||
*
|
||||
* @warning call without active locks
|
||||
*/
|
||||
pa_stream *pulseaudio_stream_new(const char *name, const pa_sample_spec *ss,
|
||||
const pa_channel_map *map);
|
||||
|
||||
/**
|
||||
* Connect to a pulseaudio playback stream
|
||||
*
|
||||
* @param s pa_stream to connect to. NULL for default
|
||||
* @param attr pa_buffer_attr
|
||||
* @param name Device name. NULL for default device
|
||||
* @param flags pa_stream_flags_t
|
||||
* @return negative on error
|
||||
*/
|
||||
int_fast32_t pulseaudio_connect_playback(pa_stream *s, const char *name,
|
||||
const pa_buffer_attr *attr, pa_stream_flags_t flags);
|
||||
|
||||
/**
|
||||
* Sets a callback function for when data can be written to the stream
|
||||
*
|
||||
* @param p pa_stream to connect to. NULL for default
|
||||
* @param cb pa_stream_request_cb_t
|
||||
* @param userdata pointer to userdata the callback will be called with
|
||||
*/
|
||||
void pulseaudio_write_callback(pa_stream *p, pa_stream_request_cb_t cb,
|
||||
void *userdata);
|
@ -1903,7 +1903,7 @@ bool obs_set_audio_monitoring_device(const char *name, const char *id)
|
||||
if (!obs || !name || !id || !*name || !*id)
|
||||
return false;
|
||||
|
||||
#ifdef _WIN32
|
||||
#if defined(_WIN32) || HAVE_PULSEAUDIO
|
||||
pthread_mutex_lock(&obs->audio.monitoring_mutex);
|
||||
|
||||
if (strcmp(id, obs->audio.monitoring_device_id) == 0) {
|
||||
|
@ -17,3 +17,4 @@
|
||||
#define OBS_UNIX_STRUCTURE @OBS_UNIX_STRUCTURE@
|
||||
#define BUILD_CAPTIONS @BUILD_CAPTIONS@
|
||||
#define HAVE_DBUS @HAVE_DBUS@
|
||||
#define HAVE_PULSEAUDIO @HAVE_PULSEAUDIO@
|
||||
|
Loading…
Reference in New Issue
Block a user