348 lines
8.6 KiB
C++
348 lines
8.6 KiB
C++
#include "audiostream.h"
|
|
#if USE_ALSA
|
|
#include <alsa/asoundlib.h>
|
|
#include "cfg/cfg.h"
|
|
|
|
static snd_pcm_t *handle;
|
|
static bool pcm_blocking = true;
|
|
static snd_pcm_uframes_t buffer_size;
|
|
static snd_pcm_uframes_t period_size;
|
|
static snd_pcm_t *handle_record;
|
|
|
|
static void alsa_init()
|
|
{
|
|
snd_pcm_hw_params_t *params;
|
|
|
|
std::string device = cfgLoadStr("alsa", "device", "");
|
|
|
|
int rc = -1;
|
|
if (device.empty() || device == "auto")
|
|
{
|
|
INFO_LOG(AUDIO, "ALSA: trying to determine audio device");
|
|
|
|
// trying default device
|
|
device = "default";
|
|
rc = snd_pcm_open(&handle, device.c_str(), SND_PCM_STREAM_PLAYBACK, 0);
|
|
|
|
// "default" didn't work, try first device
|
|
if (rc < 0)
|
|
{
|
|
device = "plughw:0,0,0";
|
|
rc = snd_pcm_open(&handle, device.c_str(), SND_PCM_STREAM_PLAYBACK, 0);
|
|
|
|
if (rc < 0)
|
|
{
|
|
device = "plughw:0,0";
|
|
rc = snd_pcm_open(&handle, device.c_str(), SND_PCM_STREAM_PLAYBACK, 0);
|
|
}
|
|
}
|
|
|
|
// first didn't work, try second
|
|
if (rc < 0)
|
|
{
|
|
device = "plughw:1,0";
|
|
rc = snd_pcm_open(&handle, device.c_str(), SND_PCM_STREAM_PLAYBACK, 0);
|
|
}
|
|
|
|
// try pulse audio backend
|
|
if (rc < 0)
|
|
{
|
|
device = "pulse";
|
|
rc = snd_pcm_open(&handle, device.c_str(), SND_PCM_STREAM_PLAYBACK, 0);
|
|
}
|
|
|
|
if (rc < 0)
|
|
INFO_LOG(AUDIO, "ALSA: unable to automatically determine audio device.");
|
|
}
|
|
else {
|
|
rc = snd_pcm_open(&handle, device.c_str(), SND_PCM_STREAM_PLAYBACK, 0);
|
|
}
|
|
|
|
if (rc < 0)
|
|
{
|
|
WARN_LOG(AUDIO, "ALSA: unable to open PCM device %s: %s", device.c_str(), snd_strerror(rc));
|
|
return;
|
|
}
|
|
|
|
INFO_LOG(AUDIO, "ALSA: Successfully initialized \"%s\"", device.c_str());
|
|
|
|
/* Allocate a hardware parameters object. */
|
|
snd_pcm_hw_params_alloca(¶ms);
|
|
|
|
/* Fill it in with default values. */
|
|
rc=snd_pcm_hw_params_any(handle, params);
|
|
if (rc < 0)
|
|
{
|
|
WARN_LOG(AUDIO, "ALSA: Error:snd_pcm_hw_params_any %s", snd_strerror(rc));
|
|
return;
|
|
}
|
|
|
|
/* Set the desired hardware parameters. */
|
|
|
|
/* Interleaved mode */
|
|
rc=snd_pcm_hw_params_set_access(handle, params, SND_PCM_ACCESS_RW_INTERLEAVED);
|
|
if (rc < 0)
|
|
{
|
|
WARN_LOG(AUDIO, "ALSA: Error:snd_pcm_hw_params_set_access %s", snd_strerror(rc));
|
|
return;
|
|
}
|
|
|
|
/* Signed 16-bit little-endian format */
|
|
rc=snd_pcm_hw_params_set_format(handle, params, SND_PCM_FORMAT_S16_LE);
|
|
if (rc < 0)
|
|
{
|
|
WARN_LOG(AUDIO, "ALSA: Error:snd_pcm_hw_params_set_format %s", snd_strerror(rc));
|
|
return;
|
|
}
|
|
|
|
/* Two channels (stereo) */
|
|
rc=snd_pcm_hw_params_set_channels(handle, params, 2);
|
|
if (rc < 0)
|
|
{
|
|
WARN_LOG(AUDIO, "ALSA: Error:snd_pcm_hw_params_set_channels %s", snd_strerror(rc));
|
|
return;
|
|
}
|
|
|
|
// 44100 samples/second
|
|
rc = snd_pcm_hw_params_set_rate(handle, params, 44100, 0);
|
|
if (rc < 0)
|
|
{
|
|
WARN_LOG(AUDIO, "ALSA: Error:snd_pcm_hw_params_set_rate %s", snd_strerror(rc));
|
|
return;
|
|
}
|
|
|
|
// Sample buffer size
|
|
buffer_size = settings.aica.BufferSize;
|
|
rc = snd_pcm_hw_params_set_buffer_size_near(handle, params, &buffer_size);
|
|
if (rc < 0)
|
|
{
|
|
WARN_LOG(AUDIO, "ALSA: Error:snd_pcm_hw_params_set_buffer_size_near %s", snd_strerror(rc));
|
|
return;
|
|
}
|
|
INFO_LOG(AUDIO, "ALSA: buffer size set to %ld", buffer_size);
|
|
|
|
// Period size (1024)
|
|
period_size = 1024;
|
|
rc = snd_pcm_hw_params_set_period_size_near(handle, params, &period_size, nullptr);
|
|
if (rc < 0)
|
|
{
|
|
WARN_LOG(AUDIO, "ALSA: Error:snd_pcm_hw_params_set_periods_near %s", snd_strerror(rc));
|
|
return;
|
|
}
|
|
INFO_LOG(AUDIO, "ALSA: period size set to %zd", (size_t)period_size);
|
|
|
|
/* Write the parameters to the driver */
|
|
rc = snd_pcm_hw_params(handle, params);
|
|
if (rc < 0)
|
|
{
|
|
WARN_LOG(AUDIO, "ALSA: Unable to set hw parameters: %s", snd_strerror(rc));
|
|
return;
|
|
}
|
|
}
|
|
|
|
static bool alsa_init_record(u32 sampling_freq)
|
|
{
|
|
int err;
|
|
if ((err = snd_pcm_open(&handle_record, "default", SND_PCM_STREAM_CAPTURE, 0)) < 0)
|
|
{
|
|
INFO_LOG(AUDIO, "ALSA: Cannot open default audio capture device: %s", snd_strerror(err));
|
|
return false;
|
|
}
|
|
snd_pcm_hw_params_t *hw_params;
|
|
if ((err = snd_pcm_hw_params_malloc(&hw_params)) < 0)
|
|
{
|
|
INFO_LOG(AUDIO, "ALSA: Cannot allocate hardware parameter structure: %s", snd_strerror(err));
|
|
snd_pcm_close(handle_record);
|
|
return false;
|
|
}
|
|
if ((err = snd_pcm_hw_params_any(handle_record, hw_params)) < 0)
|
|
{
|
|
INFO_LOG(AUDIO, "ALSA: Cannot initialize hardware parameter structure: %s", snd_strerror(err));
|
|
snd_pcm_hw_params_free(hw_params);
|
|
snd_pcm_close(handle_record);
|
|
return false;
|
|
}
|
|
if ((err = snd_pcm_hw_params_set_access(handle_record, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0)
|
|
{
|
|
INFO_LOG(AUDIO, "ALSA: Cannot set access type: %s\n", snd_strerror(err));
|
|
snd_pcm_hw_params_free(hw_params);
|
|
snd_pcm_close(handle_record);
|
|
return false;
|
|
}
|
|
if ((err = snd_pcm_hw_params_set_format(handle_record, hw_params, SND_PCM_FORMAT_S16_LE)) < 0)
|
|
{
|
|
INFO_LOG(AUDIO, "ALSA: Cannot set sample format: %s", snd_strerror(err));
|
|
snd_pcm_hw_params_free(hw_params);
|
|
snd_pcm_close(handle_record);
|
|
return false;
|
|
}
|
|
if ((err = snd_pcm_hw_params_set_rate(handle_record, hw_params, sampling_freq, 0)) < 0)
|
|
{
|
|
INFO_LOG(AUDIO, "ALSA: Cannot set sample rate to %d Hz: %s", sampling_freq, snd_strerror(err));
|
|
snd_pcm_hw_params_free(hw_params);
|
|
snd_pcm_close(handle_record);
|
|
return false;
|
|
}
|
|
if ((err = snd_pcm_hw_params_set_channels(handle_record, hw_params, 1)) < 0)
|
|
{
|
|
INFO_LOG(AUDIO, "ALSA: Cannot set channel count: %s", snd_strerror(err));
|
|
snd_pcm_hw_params_free(hw_params);
|
|
snd_pcm_close(handle_record);
|
|
return false;
|
|
}
|
|
if ((err = snd_pcm_hw_params(handle_record, hw_params)) < 0)
|
|
{
|
|
INFO_LOG(AUDIO, "ALSA: Cannot set parameters: %s", snd_strerror(err));
|
|
snd_pcm_hw_params_free(hw_params);
|
|
snd_pcm_close(handle_record);
|
|
return false;
|
|
}
|
|
snd_pcm_hw_params_free(hw_params);
|
|
snd_pcm_nonblock(handle_record, 1);
|
|
if ((err = snd_pcm_prepare(handle_record)) < 0)
|
|
{
|
|
INFO_LOG(AUDIO, "ALSA: Cannot prepare device: %s", snd_strerror(err));
|
|
snd_pcm_close(handle_record);
|
|
return false;
|
|
}
|
|
INFO_LOG(AUDIO, "ALSA: Successfully initialized capture device");
|
|
|
|
return true;
|
|
}
|
|
|
|
static void alsa_term_record()
|
|
{
|
|
snd_pcm_close(handle_record);
|
|
}
|
|
|
|
static u32 alsa_record(void* frame, u32 samples)
|
|
{
|
|
int err = snd_pcm_readi(handle_record, frame, samples);
|
|
if (err < (int)samples)
|
|
{
|
|
if (err < 0)
|
|
{
|
|
DEBUG_LOG(AUDIO, "ALSA: Recording error: %s", snd_strerror(err));
|
|
err = 0;
|
|
err = snd_pcm_prepare(handle_record);
|
|
}
|
|
u8 *buffer = (u8 *)frame + err;
|
|
memset(buffer, 0, (samples - err) * 2);
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
static u32 alsa_push(const void* frame, u32 samples, bool wait)
|
|
{
|
|
if (wait != pcm_blocking) {
|
|
snd_pcm_nonblock(handle, wait ? 0 : 1);
|
|
pcm_blocking = wait;
|
|
}
|
|
|
|
int rc = snd_pcm_writei(handle, frame, samples);
|
|
if (rc == -EPIPE)
|
|
{
|
|
/* EPIPE means underrun */
|
|
snd_pcm_prepare(handle);
|
|
// Write some silence then our samples
|
|
const size_t silence_size = buffer_size - period_size;
|
|
void *silence = alloca(silence_size * 4);
|
|
memset(silence, 0, silence_size * 4);
|
|
snd_pcm_writei(handle, silence, silence_size);
|
|
snd_pcm_writei(handle, frame, samples);
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
static void alsa_term()
|
|
{
|
|
snd_pcm_drop(handle);
|
|
snd_pcm_close(handle);
|
|
}
|
|
|
|
static std::vector<std::string> alsa_get_devicelist()
|
|
{
|
|
std::vector<std::string> result;
|
|
|
|
char **hints;
|
|
int err = snd_device_name_hint(-1, "pcm", (void***)&hints);
|
|
|
|
// Error initializing ALSA
|
|
if (err != 0)
|
|
return result;
|
|
|
|
// special value to automatically detect on initialization
|
|
result.emplace_back("auto");
|
|
|
|
char** n = hints;
|
|
while (*n != NULL)
|
|
{
|
|
// Get the type (NULL/Input/Output)
|
|
char *type = snd_device_name_get_hint(*n, "IOID");
|
|
char *name = snd_device_name_get_hint(*n, "NAME");
|
|
|
|
if (name != NULL)
|
|
{
|
|
// We only want output or special devices (like "default" or "pulse")
|
|
// TODO Only those with type == NULL?
|
|
if (type == NULL || strcmp(type, "Output") == 0)
|
|
{
|
|
// TODO Check if device works (however we need to hash the resulting list then)
|
|
/*snd_pcm_t *handle;
|
|
int rc = snd_pcm_open(&handle, name, SND_PCM_STREAM_PLAYBACK, 0);
|
|
|
|
if (rc == 0)
|
|
{
|
|
result.push_back(name);
|
|
snd_pcm_close(handle);
|
|
}
|
|
*/
|
|
|
|
result.emplace_back(name);
|
|
}
|
|
|
|
}
|
|
|
|
if (type != NULL)
|
|
free(type);
|
|
|
|
if (name != NULL)
|
|
free(name);
|
|
|
|
n++;
|
|
}
|
|
|
|
snd_device_name_free_hint((void**)hints);
|
|
|
|
return result;
|
|
}
|
|
|
|
static audio_option_t* alsa_audio_options(int* option_count)
|
|
{
|
|
*option_count = 1;
|
|
static audio_option_t result[1];
|
|
|
|
result[0].cfg_name = "device";
|
|
result[0].caption = "Device";
|
|
result[0].type = list;
|
|
result[0].list_callback = alsa_get_devicelist;
|
|
|
|
return result;
|
|
}
|
|
|
|
static audiobackend_t audiobackend_alsa = {
|
|
"alsa", // Slug
|
|
"Advanced Linux Sound Architecture", // Name
|
|
&alsa_init,
|
|
&alsa_push,
|
|
&alsa_term,
|
|
&alsa_audio_options,
|
|
&alsa_init_record,
|
|
&alsa_record,
|
|
&alsa_term_record
|
|
};
|
|
|
|
static bool alsa = RegisterAudioBackend(&audiobackend_alsa);
|
|
#endif
|