obs-studio/plugins/linux-alsa/alsa-input.c

600 lines
13 KiB
C
Raw Normal View History

/*
Copyright (C) 2015. Guillermo A. Amaral B. <g@maral.me>
Based on Pulse Input plugin by Leonhard Oelke.
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 <util/bmem.h>
#include <util/platform.h>
#include <util/threading.h>
#include <obs-module.h>
#include <alsa/asoundlib.h>
#include <alsa/pcm.h>
#include <pthread.h>
#define blog(level, msg, ...) blog(level, "alsa-input: " msg, ##__VA_ARGS__)
#define NSEC_PER_SEC 1000000000LL
#define NSEC_PER_MSEC 1000000L
#define STARTUP_TIMEOUT_NS (500 * NSEC_PER_MSEC)
#define REOPEN_TIMEOUT 1000UL
#define SHUTDOWN_ON_DEACTIVATE false
struct alsa_data {
obs_source_t *source;
#if SHUTDOWN_ON_DEACTIVATE
bool active;
#endif
/* user settings */
char *device;
/* pthread */
pthread_t listen_thread;
pthread_t reopen_thread;
os_event_t *abort_event;
volatile bool listen;
volatile bool reopen;
/* alsa */
snd_pcm_t *handle;
snd_pcm_format_t format;
snd_pcm_uframes_t period_size;
unsigned int channels;
unsigned int rate;
unsigned int sample_size;
uint8_t *buffer;
uint64_t first_ts;
};
static const char * alsa_get_name(void *);
static obs_properties_t * alsa_get_properties(void *);
static void * alsa_create(obs_data_t *, obs_source_t *);
static void alsa_destroy(void *);
static void alsa_activate(void *);
static void alsa_deactivate(void *);
static void alsa_get_defaults(obs_data_t *);
static void alsa_update(void *, obs_data_t *);
struct obs_source_info alsa_input_capture = {
.id = "alsa_input_capture",
.type = OBS_SOURCE_TYPE_INPUT,
.output_flags = OBS_SOURCE_AUDIO,
.create = alsa_create,
.destroy = alsa_destroy,
#if SHUTDOWN_ON_DEACTIVATE
.activate = alsa_activate,
.deactivate = alsa_deactivate,
#endif
.update = alsa_update,
.get_defaults = alsa_get_defaults,
.get_name = alsa_get_name,
.get_properties = alsa_get_properties
};
static bool _alsa_try_open(struct alsa_data *);
static bool _alsa_open(struct alsa_data *);
static void _alsa_close(struct alsa_data *);
static bool _alsa_configure(struct alsa_data *);
static void _alsa_start_reopen(struct alsa_data *);
static void _alsa_stop_reopen(struct alsa_data *);
static void * _alsa_listen(void *);
static void * _alsa_reopen(void *);
static enum audio_format _alsa_to_obs_audio_format(snd_pcm_format_t);
static enum speaker_layout _alsa_channels_to_obs_speakers(unsigned int);
/*****************************************************************************/
void * alsa_create(obs_data_t *settings, obs_source_t *source)
{
struct alsa_data *data = bzalloc(sizeof(struct alsa_data));
data->source = source;
#if SHUTDOWN_ON_DEACTIVATE
data->active = false;
#endif
data->buffer = NULL;
data->device = NULL;
data->first_ts = 0;
data->handle = NULL;
data->listen = false;
data->reopen = false;
data->listen_thread = 0;
data->reopen_thread = 0;
data->device = bstrdup(obs_data_get_string(settings, "device_id"));
data->rate = obs_data_get_int(settings, "rate");
if (os_event_init(&data->abort_event, OS_EVENT_TYPE_MANUAL) != 0) {
blog(LOG_ERROR, "Abort event creation failed!");
goto cleanup;
}
#if !SHUTDOWN_ON_DEACTIVATE
_alsa_try_open(data);
#endif
return data;
cleanup:
if (data->device)
bfree(data->device);
bfree(data);
return NULL;
}
void alsa_destroy(void *vptr)
{
struct alsa_data *data = vptr;
if (data->handle)
_alsa_close(data);
os_event_destroy(data->abort_event);
bfree(data->device);
bfree(data);
}
#if SHUTDOWN_ON_DEACTIVATE
void alsa_activate(void *vptr)
{
struct alsa_data *data = vptr;
data->active = true;
_alsa_try_open(data);
}
void alsa_deactivate(void *vptr)
{
struct alsa_data *data = vptr;
_alsa_stop_reopen(data);
_alsa_close(data);
data->active = false;
}
#endif
void alsa_update(void *vptr, obs_data_t *settings)
{
struct alsa_data *data = vptr;
const char *device;
unsigned int rate;
bool reset = false;
device = obs_data_get_string(settings, "device_id");
if (strcmp(data->device, device) != 0) {
bfree(data->device);
data->device = bstrdup(device);
reset = true;
}
rate = obs_data_get_int(settings, "rate");
if (data->rate != rate) {
data->rate = rate;
reset = true;
}
#if SHUTDOWN_ON_DEACTIVATE
if (reset && data->handle)
_alsa_close(data);
if (data->active && !data->handle)
_alsa_try_open(data);
#else
if (reset) {
if (data->handle)
_alsa_close(data);
_alsa_try_open(data);
}
#endif
}
const char * alsa_get_name(void *unused)
{
UNUSED_PARAMETER(unused);
return obs_module_text("AlsaInput");
}
void alsa_get_defaults(obs_data_t *settings)
{
obs_data_set_default_string(settings, "device_id", "default");
obs_data_set_default_int(settings, "rate", 44100);
}
obs_properties_t * alsa_get_properties(void *unused)
{
void **hints;
void **hint;
char *name = NULL;
char *descr = NULL;
char *io = NULL;
char *descr_i;
obs_properties_t *props;
obs_property_t *devices;
obs_property_t *rate;
UNUSED_PARAMETER(unused);
props = obs_properties_create();
devices = obs_properties_add_list(props, "device_id",
obs_module_text("Device"), OBS_COMBO_TYPE_LIST,
OBS_COMBO_FORMAT_STRING);
obs_property_list_add_string(devices, "Default", "default");
rate = obs_properties_add_list(props, "rate",
obs_module_text("Rate"), OBS_COMBO_TYPE_LIST,
OBS_COMBO_FORMAT_INT);
obs_property_list_add_int(rate, "32000 Hz", 32000);
obs_property_list_add_int(rate, "44100 Hz", 44100);
obs_property_list_add_int(rate, "48000 Hz", 48000);
if (snd_device_name_hint(-1, "pcm", &hints) < 0)
return props;
hint = hints;
while (*hint != NULL) {
/* check if we're dealing with an Input */
io = snd_device_name_get_hint(*hint, "IOID");
if (io != NULL && strcmp(io, "Input") != 0)
goto next;
name = snd_device_name_get_hint(*hint, "NAME");
if (name == NULL || strstr(name, "front:") == NULL)
goto next;
descr = snd_device_name_get_hint(*hint, "DESC");
if (!descr)
goto next;
descr_i = descr;
while (*descr_i) {
if (*descr_i == '\n') {
*descr_i = '\0';
break;
}
else ++descr_i;
}
obs_property_list_add_string(devices, descr, name);
next:
if (name != NULL)
free(name), name = NULL;
if (descr != NULL)
free(descr), descr = NULL;
if (io != NULL)
free(io), io = NULL;
++hint;
}
snd_device_name_free_hint(hints);
return props;
}
/*****************************************************************************/
bool _alsa_try_open(struct alsa_data *data)
{
_alsa_stop_reopen(data);
if (_alsa_open(data))
return true;
_alsa_start_reopen(data);
return false;
}
bool _alsa_open(struct alsa_data *data)
{
pthread_attr_t attr;
int err;
err = snd_pcm_open(&data->handle, data->device,
SND_PCM_STREAM_CAPTURE, 0);
if (err < 0) {
blog(LOG_ERROR, "Failed to open '%s': %s",
data->device, snd_strerror(err));
return false;
}
if (!_alsa_configure(data))
goto cleanup;
if (snd_pcm_state(data->handle) != SND_PCM_STATE_PREPARED) {
blog(LOG_ERROR, "Device not prepared: '%s'",
data->device);
goto cleanup;
}
/* start listening */
err = snd_pcm_start(data->handle);
if (err < 0) {
blog(LOG_ERROR, "Failed to start '%s': %s",
data->device, snd_strerror(err));
goto cleanup;
}
/* create capture thread */
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
err = pthread_create(&data->listen_thread, &attr, _alsa_listen, data);
if (err) {
pthread_attr_destroy(&attr);
blog(LOG_ERROR,
"Failed to create capture thread for device '%s'.",
data->device);
goto cleanup;
}
pthread_attr_destroy(&attr);
return true;
cleanup:
_alsa_close(data);
return false;
}
void _alsa_close(struct alsa_data *data)
{
if (data->listen_thread) {
os_atomic_set_bool(&data->listen, false);
pthread_join(data->listen_thread, NULL);
data->listen_thread = 0;
}
if (data->handle) {
snd_pcm_drop(data->handle);
snd_pcm_close(data->handle), data->handle = NULL;
}
if (data->buffer)
bfree(data->buffer), data->buffer = NULL;
}
bool _alsa_configure(struct alsa_data *data)
{
snd_pcm_hw_params_t *hwparams;
int err;
int dir;
snd_pcm_hw_params_alloca(&hwparams);
err = snd_pcm_hw_params_any(data->handle, hwparams);
if (err < 0) {
blog(LOG_ERROR,
"snd_pcm_hw_params_any failed: %s",
snd_strerror(err));
return false;
}
err = snd_pcm_hw_params_set_access(data->handle, hwparams,
SND_PCM_ACCESS_RW_INTERLEAVED);
if (err < 0) {
blog(LOG_ERROR,
"snd_pcm_hw_params_set_access failed: %s",
snd_strerror(err));
return false;
}
data->format = SND_PCM_FORMAT_S16;
err = snd_pcm_hw_params_set_format(data->handle, hwparams,
data->format);
if (err < 0) {
blog(LOG_ERROR,
"snd_pcm_hw_params_set_format failed: %s",
snd_strerror(err));
return false;
}
err = snd_pcm_hw_params_set_rate_near(data->handle, hwparams,
&data->rate, 0);
if (err < 0) {
blog(LOG_ERROR,
"snd_pcm_hw_params_set_rate_near failed: %s",
snd_strerror(err));
return false;
}
blog(LOG_INFO, "PCM '%s' rate set to %d", data->device, data->rate);
err = snd_pcm_hw_params_get_channels(hwparams, &data->channels);
if (err < 0)
data->channels = 2;
err = snd_pcm_hw_params_set_channels_near(data->handle, hwparams,
&data->channels);
if (err < 0) {
blog(LOG_ERROR,
"snd_pcm_hw_params_set_channels_near failed: %s",
snd_strerror(err));
return false;
}
blog(LOG_INFO, "PCM '%s' channels set to %d",
data->device, data->channels);
err = snd_pcm_hw_params(data->handle, hwparams);
if (err < 0) {
blog(LOG_ERROR, "snd_pcm_hw_params failed: %s",
snd_strerror(err));
return false;
}
err = snd_pcm_hw_params_get_period_size(hwparams, &data->period_size,
&dir);
if (err < 0) {
blog(LOG_ERROR,
"snd_pcm_hw_params_get_period_size failed: %s",
snd_strerror(err));
return false;
}
data->sample_size = (data->channels
* snd_pcm_format_physical_width(data->format)) / 8;
if (data->buffer)
bfree(data->buffer);
data->buffer = bzalloc(data->period_size * data->sample_size);
return true;
}
void _alsa_start_reopen(struct alsa_data *data)
{
pthread_attr_t attr;
int err;
if (os_atomic_load_bool(&data->reopen))
return;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
err = pthread_create(&data->reopen_thread, &attr, _alsa_reopen, data);
if (err) {
blog(LOG_ERROR,
"Failed to create reopen thread for device '%s'.",
data->device);
}
pthread_attr_destroy(&attr);
}
void _alsa_stop_reopen(struct alsa_data *data)
{
if (os_atomic_load_bool(&data->reopen))
os_event_signal(data->abort_event);
if (data->reopen_thread) {
pthread_join(data->reopen_thread, NULL);
data->reopen_thread = 0;
}
os_event_reset(data->abort_event);
}
void * _alsa_listen(void *attr)
{
struct alsa_data *data = attr;
struct obs_source_audio out;
blog(LOG_DEBUG, "Capture thread started.");
out.data[0] = data->buffer;
out.format = _alsa_to_obs_audio_format(data->format);
out.speakers = _alsa_channels_to_obs_speakers(data->channels);
out.samples_per_sec = data->rate;
os_atomic_set_bool(&data->listen, true);
do {
snd_pcm_sframes_t frames = snd_pcm_readi(data->handle,
data->buffer, data->period_size);
if (!os_atomic_load_bool(&data->listen))
break;
if (frames <= 0) {
frames = snd_pcm_recover(data->handle, frames, 0);
if (frames <= 0) {
snd_pcm_wait(data->handle, 100);
continue;
}
}
out.frames = frames;
out.timestamp = os_gettime_ns()
- ((frames * NSEC_PER_SEC) / data->rate);
if (!data->first_ts)
data->first_ts = out.timestamp + STARTUP_TIMEOUT_NS;
if (out.timestamp > data->first_ts)
obs_source_output_audio(data->source, &out);
} while (os_atomic_load_bool(&data->listen));
blog(LOG_DEBUG, "Capture thread is about to exit.");
pthread_exit(NULL);
return NULL;
}
void * _alsa_reopen(void *attr)
{
struct alsa_data *data = attr;
unsigned long timeout = REOPEN_TIMEOUT;
blog(LOG_DEBUG, "Reopen thread started.");
os_atomic_set_bool(&data->reopen, true);
while (os_event_timedwait(data->abort_event, timeout) == ETIMEDOUT) {
if (_alsa_open(data))
break;
if (timeout < (REOPEN_TIMEOUT * 5))
timeout += REOPEN_TIMEOUT;
}
os_atomic_set_bool(&data->reopen, false);
blog(LOG_DEBUG, "Reopen thread is about to exit.");
pthread_exit(NULL);
return NULL;
}
enum audio_format _alsa_to_obs_audio_format(snd_pcm_format_t format)
{
switch (format) {
case SND_PCM_FORMAT_U8: return AUDIO_FORMAT_U8BIT;
case SND_PCM_FORMAT_S16_LE: return AUDIO_FORMAT_16BIT;
case SND_PCM_FORMAT_S32_LE: return AUDIO_FORMAT_32BIT;
case SND_PCM_FORMAT_FLOAT_LE: return AUDIO_FORMAT_FLOAT;
default: break;
}
return AUDIO_FORMAT_UNKNOWN;
}
enum speaker_layout _alsa_channels_to_obs_speakers(unsigned int channels)
{
switch(channels) {
case 1: return SPEAKERS_MONO;
case 2: return SPEAKERS_STEREO;
case 3: return SPEAKERS_2POINT1;
case 4: return SPEAKERS_SURROUND;
case 5: return SPEAKERS_4POINT1;
case 6: return SPEAKERS_5POINT1;
case 8: return SPEAKERS_7POINT1;
}
return SPEAKERS_UNKNOWN;
}