static gint
set_rates (alsa_driver *d, guint channels, guint format)
{
guint ratemin, ratemax;
snd_pcm_uframes_t bufsizemin, bufsizemax;
gint err;
if((err = snd_pcm_hw_params_set_channels(d->soundfd, d->hwparams, channels)) < 0) {
alsa_error(N_("Unable to set channles number"), err);
return -1;
}
if((err = snd_pcm_hw_params_get_rate_min(d->hwparams, &ratemin, 0)) < 0) {
alsa_error(N_("Unable to get minimal sample rate"), err);
return -1;
}
d->devcap[format].minfreq = MAX(ratemin, 8000);
if((err = snd_pcm_hw_params_get_rate_max(d->hwparams, &ratemax, 0)) < 0) {
alsa_error(N_("Unable to get maximal sample rate"), err);
return -1;
}
d->devcap[format].maxfreq = MIN(ratemax, 96000);
if((err = snd_pcm_hw_params_get_buffer_size_min(d->hwparams, &bufsizemin)) < 0) {
alsa_error(N_("Unable to get minimal buffer size"), err);
return -1;
}
d->devcap[format].minbufsize = MAX(bufsizemin, 256);
if((err = snd_pcm_hw_params_get_buffer_size_max(d->hwparams, &bufsizemax)) < 0) {
alsa_error(N_("Unable to get maximal buffer size"), err);
return -1;
}
d->devcap[format].maxbufsize = bufsizemax;
return 0;
}
/**
* ags_devout_pcm_info:
* @soundcard: the #AgsSoundcard
* @card_id: alsa identifier
* @channels_min: minimum channels supported
* @channels_max: maximum channels supported
* @rate_min: minimum samplerate supported
* @rate_max: maximum samplerate supported
* @buffer_size_min: minimum buffer size supported
* @buffer_size_max maximum buffer size supported
* @error: on success %NULL
*
* List soundcard settings.
*
* Since: 0.4
*/
void
ags_devout_pcm_info(AgsSoundcard *soundcard,
char *card_id,
guint *channels_min, guint *channels_max,
guint *rate_min, guint *rate_max,
guint *buffer_size_min, guint *buffer_size_max,
GError **error)
{
int rc;
snd_pcm_t *handle;
snd_pcm_hw_params_t *params;
unsigned int val;
int dir;
snd_pcm_uframes_t frames;
int err;
/* Open PCM device for playback. */
handle = NULL;
rc = snd_pcm_open(&handle, card_id, SND_PCM_STREAM_PLAYBACK, 0);
if(rc < 0) {
g_message("unable to open pcm device: %s\n\0", snd_strerror(rc));
g_set_error(error,
AGS_DEVOUT_ERROR,
AGS_DEVOUT_ERROR_LOCKED_SOUNDCARD,
"unable to open pcm device: %s\n\0",
snd_strerror(rc));
return;
}
/* Allocate a hardware parameters object. */
snd_pcm_hw_params_alloca(¶ms);
/* Fill it in with default values. */
snd_pcm_hw_params_any(handle, params);
/* channels */
snd_pcm_hw_params_get_channels_min(params, &val);
*channels_min = val;
snd_pcm_hw_params_get_channels_max(params, &val);
*channels_max = val;
/* samplerate */
dir = 0;
snd_pcm_hw_params_get_rate_min(params, &val, &dir);
*rate_min = val;
dir = 0;
snd_pcm_hw_params_get_rate_max(params, &val, &dir);
*rate_max = val;
/* buffer size */
dir = 0;
snd_pcm_hw_params_get_buffer_size_min(params, &frames);
*buffer_size_min = frames;
dir = 0;
snd_pcm_hw_params_get_buffer_size_max(params, &frames);
*buffer_size_max = frames;
snd_pcm_close(handle);
}
av_cold int ff_alsa_open(AVFormatContext *ctx, snd_pcm_stream_t mode,
unsigned int *sample_rate,
int channels, enum AVCodecID *codec_id)
{
AlsaData *s = ctx->priv_data;
const char *audio_device;
int res, flags = 0;
snd_pcm_format_t format;
snd_pcm_t *h;
snd_pcm_hw_params_t *hw_params;
snd_pcm_uframes_t buffer_size, period_size;
uint64_t layout = ctx->streams[0]->codecpar->channel_layout;
if (ctx->filename[0] == 0) audio_device = "default";
else audio_device = ctx->filename;
if (*codec_id == AV_CODEC_ID_NONE)
*codec_id = DEFAULT_CODEC_ID;
format = codec_id_to_pcm_format(*codec_id);
if (format == SND_PCM_FORMAT_UNKNOWN) {
av_log(ctx, AV_LOG_ERROR, "sample format 0x%04x is not supported\n", *codec_id);
return AVERROR(ENOSYS);
}
s->frame_size = av_get_bits_per_sample(*codec_id) / 8 * channels;
if (ctx->flags & AVFMT_FLAG_NONBLOCK) {
flags = SND_PCM_NONBLOCK;
}
res = snd_pcm_open(&h, audio_device, mode, flags);
if (res < 0) {
av_log(ctx, AV_LOG_ERROR, "cannot open audio device %s (%s)\n",
audio_device, snd_strerror(res));
return AVERROR(EIO);
}
res = snd_pcm_hw_params_malloc(&hw_params);
if (res < 0) {
av_log(ctx, AV_LOG_ERROR, "cannot allocate hardware parameter structure (%s)\n",
snd_strerror(res));
goto fail1;
}
res = snd_pcm_hw_params_any(h, hw_params);
if (res < 0) {
av_log(ctx, AV_LOG_ERROR, "cannot initialize hardware parameter structure (%s)\n",
snd_strerror(res));
goto fail;
}
res = snd_pcm_hw_params_set_access(h, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED);
if (res < 0) {
av_log(ctx, AV_LOG_ERROR, "cannot set access type (%s)\n",
snd_strerror(res));
goto fail;
}
res = snd_pcm_hw_params_set_format(h, hw_params, format);
if (res < 0) {
av_log(ctx, AV_LOG_ERROR, "cannot set sample format 0x%04x %d (%s)\n",
*codec_id, format, snd_strerror(res));
goto fail;
}
res = snd_pcm_hw_params_set_rate_near(h, hw_params, sample_rate, 0);
if (res < 0) {
av_log(ctx, AV_LOG_ERROR, "cannot set sample rate (%s)\n",
snd_strerror(res));
goto fail;
}
res = snd_pcm_hw_params_set_channels(h, hw_params, channels);
if (res < 0) {
av_log(ctx, AV_LOG_ERROR, "cannot set channel count to %d (%s)\n",
channels, snd_strerror(res));
goto fail;
}
snd_pcm_hw_params_get_buffer_size_max(hw_params, &buffer_size);
buffer_size = FFMIN(buffer_size, ALSA_BUFFER_SIZE_MAX);
/* TODO: maybe use ctx->max_picture_buffer somehow */
res = snd_pcm_hw_params_set_buffer_size_near(h, hw_params, &buffer_size);
if (res < 0) {
av_log(ctx, AV_LOG_ERROR, "cannot set ALSA buffer size (%s)\n",
snd_strerror(res));
goto fail;
}
snd_pcm_hw_params_get_period_size_min(hw_params, &period_size, NULL);
if (!period_size)
period_size = buffer_size / 4;
res = snd_pcm_hw_params_set_period_size_near(h, hw_params, &period_size, NULL);
if (res < 0) {
av_log(ctx, AV_LOG_ERROR, "cannot set ALSA period size (%s)\n",
snd_strerror(res));
goto fail;
}
s->period_size = period_size;
res = snd_pcm_hw_params(h, hw_params);
if (res < 0) {
av_log(ctx, AV_LOG_ERROR, "cannot set parameters (%s)\n",
snd_strerror(res));
goto fail;
}
snd_pcm_hw_params_free(hw_params);
if (channels > 2 && layout) {
if (find_reorder_func(s, *codec_id, layout, mode == SND_PCM_STREAM_PLAYBACK) < 0) {
char name[128];
av_get_channel_layout_string(name, sizeof(name), channels, layout);
av_log(ctx, AV_LOG_WARNING, "ALSA channel layout unknown or unimplemented for %s %s.\n",
name, mode == SND_PCM_STREAM_PLAYBACK ? "playback" : "capture");
}
if (s->reorder_func) {
s->reorder_buf_size = buffer_size;
s->reorder_buf = av_malloc(s->reorder_buf_size * s->frame_size);
if (!s->reorder_buf)
goto fail1;
}
}
s->h = h;
return 0;
fail:
snd_pcm_hw_params_free(hw_params);
fail1:
snd_pcm_close(h);
return AVERROR(EIO);
}
av_cold int ff_alsa_open(AVFormatContext *ctx, snd_pcm_stream_t mode,
unsigned int *sample_rate,
int channels, enum CodecID *codec_id)
{
AlsaData *s = ctx->priv_data;
const char *audio_device;
int res, flags = 0;
snd_pcm_format_t format;
snd_pcm_t *h;
snd_pcm_hw_params_t *hw_params;
snd_pcm_uframes_t buffer_size, period_size;
if (ctx->filename[0] == 0) audio_device = "default";
else audio_device = ctx->filename;
if (*codec_id == CODEC_ID_NONE)
*codec_id = DEFAULT_CODEC_ID;
format = codec_id_to_pcm_format(*codec_id);
if (format == SND_PCM_FORMAT_UNKNOWN) {
av_log(ctx, AV_LOG_ERROR, "sample format 0x%04x is not supported\n", *codec_id);
return AVERROR(ENOSYS);
}
s->frame_size = av_get_bits_per_sample(*codec_id) / 8 * channels;
if (ctx->flags & AVFMT_FLAG_NONBLOCK) {
flags = SND_PCM_NONBLOCK;
}
res = snd_pcm_open(&h, audio_device, mode, flags);
if (res < 0) {
av_log(ctx, AV_LOG_ERROR, "cannot open audio device %s (%s)\n",
audio_device, snd_strerror(res));
return AVERROR_IO;
}
res = snd_pcm_hw_params_malloc(&hw_params);
if (res < 0) {
av_log(ctx, AV_LOG_ERROR, "cannot allocate hardware parameter structure (%s)\n",
snd_strerror(res));
goto fail1;
}
res = snd_pcm_hw_params_any(h, hw_params);
if (res < 0) {
av_log(ctx, AV_LOG_ERROR, "cannot initialize hardware parameter structure (%s)\n",
snd_strerror(res));
goto fail;
}
res = snd_pcm_hw_params_set_access(h, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED);
if (res < 0) {
av_log(ctx, AV_LOG_ERROR, "cannot set access type (%s)\n",
snd_strerror(res));
goto fail;
}
res = snd_pcm_hw_params_set_format(h, hw_params, format);
if (res < 0) {
av_log(ctx, AV_LOG_ERROR, "cannot set sample format 0x%04x %d (%s)\n",
*codec_id, format, snd_strerror(res));
goto fail;
}
res = snd_pcm_hw_params_set_rate_near(h, hw_params, sample_rate, 0);
if (res < 0) {
av_log(ctx, AV_LOG_ERROR, "cannot set sample rate (%s)\n",
snd_strerror(res));
goto fail;
}
res = snd_pcm_hw_params_set_channels(h, hw_params, channels);
if (res < 0) {
av_log(ctx, AV_LOG_ERROR, "cannot set channel count to %d (%s)\n",
channels, snd_strerror(res));
goto fail;
}
snd_pcm_hw_params_get_buffer_size_max(hw_params, &buffer_size);
/* TODO: maybe use ctx->max_picture_buffer somehow */
res = snd_pcm_hw_params_set_buffer_size_near(h, hw_params, &buffer_size);
if (res < 0) {
av_log(ctx, AV_LOG_ERROR, "cannot set ALSA buffer size (%s)\n",
snd_strerror(res));
goto fail;
}
snd_pcm_hw_params_get_period_size_min(hw_params, &period_size, NULL);
res = snd_pcm_hw_params_set_period_size_near(h, hw_params, &period_size, NULL);
if (res < 0) {
av_log(ctx, AV_LOG_ERROR, "cannot set ALSA period size (%s)\n",
snd_strerror(res));
goto fail;
}
s->period_size = period_size;
res = snd_pcm_hw_params(h, hw_params);
if (res < 0) {
av_log(ctx, AV_LOG_ERROR, "cannot set parameters (%s)\n",
snd_strerror(res));
goto fail;
}
snd_pcm_hw_params_free(hw_params);
s->h = h;
return 0;
fail:
snd_pcm_hw_params_free(hw_params);
fail1:
snd_pcm_close(h);
return AVERROR_IO;
}
bool CAESinkALSA::InitializeHW(AEAudioFormat &format)
{
snd_pcm_hw_params_t *hw_params;
snd_pcm_hw_params_alloca(&hw_params);
memset(hw_params, 0, snd_pcm_hw_params_sizeof());
snd_pcm_hw_params_any(m_pcm, hw_params);
snd_pcm_hw_params_set_access(m_pcm, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED);
unsigned int sampleRate = format.m_sampleRate;
unsigned int channelCount = format.m_channelLayout.Count();
snd_pcm_hw_params_set_rate_near (m_pcm, hw_params, &sampleRate, NULL);
snd_pcm_hw_params_set_channels_near(m_pcm, hw_params, &channelCount);
/* ensure we opened X channels or more */
if (format.m_channelLayout.Count() > channelCount)
{
CLog::Log(LOGERROR, "CAESinkALSA::InitializeHW - Unable to open the required number of channels");
return false;
}
/* update the channelLayout to what we managed to open */
format.m_channelLayout.Reset();
for (unsigned int i = 0; i < channelCount; ++i)
format.m_channelLayout += ALSAChannelMap[i];
snd_pcm_format_t fmt = AEFormatToALSAFormat(format.m_dataFormat);
if (fmt == SND_PCM_FORMAT_UNKNOWN)
{
/* if we dont support the requested format, fallback to float */
format.m_dataFormat = AE_FMT_FLOAT;
fmt = SND_PCM_FORMAT_FLOAT;
}
/* try the data format */
if (snd_pcm_hw_params_set_format(m_pcm, hw_params, fmt) < 0)
{
/* if the chosen format is not supported, try each one in decending order */
CLog::Log(LOGINFO, "CAESinkALSA::InitializeHW - Your hardware does not support %s, trying other formats", CAEUtil::DataFormatToStr(format.m_dataFormat));
for (enum AEDataFormat i = AE_FMT_MAX; i > AE_FMT_INVALID; i = (enum AEDataFormat)((int)i - 1))
{
if (AE_IS_RAW(i) || i == AE_FMT_MAX)
continue;
if (m_passthrough && i != AE_FMT_S16BE && i != AE_FMT_S16LE)
continue;
fmt = AEFormatToALSAFormat(i);
if (fmt == SND_PCM_FORMAT_UNKNOWN || snd_pcm_hw_params_set_format(m_pcm, hw_params, fmt) < 0)
{
fmt = SND_PCM_FORMAT_UNKNOWN;
continue;
}
int fmtBits = CAEUtil::DataFormatToBits(i);
int bits = snd_pcm_hw_params_get_sbits(hw_params);
if (bits != fmtBits)
{
/* if we opened in 32bit and only have 24bits, pack into 24 */
if (fmtBits == 32 && bits == 24)
i = AE_FMT_S24NE4;
else
continue;
}
/* record that the format fell back to X */
format.m_dataFormat = i;
CLog::Log(LOGINFO, "CAESinkALSA::InitializeHW - Using data format %s", CAEUtil::DataFormatToStr(format.m_dataFormat));
break;
}
/* if we failed to find a valid output format */
if (fmt == SND_PCM_FORMAT_UNKNOWN)
{
CLog::Log(LOGERROR, "CAESinkALSA::InitializeHW - Unable to find a suitable output format");
return false;
}
}
unsigned int periods;
snd_pcm_uframes_t periodSize, bufferSize;
snd_pcm_hw_params_get_buffer_size_max(hw_params, &bufferSize);
bufferSize = std::min(bufferSize, (snd_pcm_uframes_t)8192);
periodSize = bufferSize / ALSA_PERIODS;
periods = ALSA_PERIODS;
CLog::Log(LOGDEBUG, "CAESinkALSA::InitializeHW - Request: periodSize %lu, periods %u, bufferSize %lu", periodSize, periods, bufferSize);
/* work on a copy of the hw params */
snd_pcm_hw_params_t *hw_params_copy;
snd_pcm_hw_params_alloca(&hw_params_copy);
/* try to set the buffer size then the period size */
snd_pcm_hw_params_copy(hw_params_copy, hw_params);
snd_pcm_hw_params_set_buffer_size_near(m_pcm, hw_params_copy, &bufferSize);
snd_pcm_hw_params_set_period_size_near(m_pcm, hw_params_copy, &periodSize, NULL);
snd_pcm_hw_params_set_periods_near (m_pcm, hw_params_copy, &periods , NULL);
if (snd_pcm_hw_params(m_pcm, hw_params_copy) != 0)
{
/* try to set the period size then the buffer size */
snd_pcm_hw_params_copy(hw_params_copy, hw_params);
snd_pcm_hw_params_set_period_size_near(m_pcm, hw_params_copy, &periodSize, NULL);
snd_pcm_hw_params_set_buffer_size_near(m_pcm, hw_params_copy, &bufferSize);
snd_pcm_hw_params_set_periods_near (m_pcm, hw_params_copy, &periods , NULL);
if (snd_pcm_hw_params(m_pcm, hw_params_copy) != 0)
{
/* try to just set the buffer size */
snd_pcm_hw_params_copy(hw_params_copy, hw_params);
snd_pcm_hw_params_set_buffer_size_near(m_pcm, hw_params_copy, &bufferSize);
snd_pcm_hw_params_set_periods_near (m_pcm, hw_params_copy, &periods , NULL);
if (snd_pcm_hw_params(m_pcm, hw_params_copy) != 0)
{
/* try to just set the period size */
snd_pcm_hw_params_copy(hw_params_copy, hw_params);
snd_pcm_hw_params_set_period_size_near(m_pcm, hw_params_copy, &periodSize, NULL);
snd_pcm_hw_params_set_periods_near (m_pcm, hw_params_copy, &periods , NULL);
if (snd_pcm_hw_params(m_pcm, hw_params_copy) != 0)
{
CLog::Log(LOGERROR, "CAESinkALSA::InitializeHW - Failed to set the parameters");
return false;
}
}
}
}
snd_pcm_hw_params_get_period_size(hw_params_copy, &periodSize, NULL);
snd_pcm_hw_params_get_buffer_size(hw_params_copy, &bufferSize);
CLog::Log(LOGDEBUG, "CAESinkALSA::InitializeHW - Got: periodSize %lu, periods %u, bufferSize %lu", periodSize, periods, bufferSize);
/* set the format parameters */
format.m_sampleRate = sampleRate;
format.m_frames = periodSize;
format.m_frameSamples = periodSize * format.m_channelLayout.Count();
format.m_frameSize = snd_pcm_frames_to_bytes(m_pcm, 1);
m_bufferSize = (unsigned int)bufferSize;
m_timeout = std::ceil((double)(bufferSize * 1000) / (double)sampleRate);
CLog::Log(LOGDEBUG, "CAESinkALSA::InitializeHW - Setting timeout to %d ms", m_timeout);
return true;
}
static int
laudio_alsa_open(void)
{
snd_pcm_hw_params_t *hw_params;
snd_pcm_uframes_t bufsize;
int ret;
hw_params = NULL;
ret = snd_pcm_open(&hdl, card_name, SND_PCM_STREAM_PLAYBACK, 0);
if (ret < 0)
{
DPRINTF(E_LOG, L_LAUDIO, "Could not open playback device: %s\n", snd_strerror(ret));
return -1;
}
/* HW params */
ret = snd_pcm_hw_params_malloc(&hw_params);
if (ret < 0)
{
DPRINTF(E_LOG, L_LAUDIO, "Could not allocate hw params: %s\n", snd_strerror(ret));
goto out_fail;
}
ret = snd_pcm_hw_params_any(hdl, hw_params);
if (ret < 0)
{
DPRINTF(E_LOG, L_LAUDIO, "Could not retrieve hw params: %s\n", snd_strerror(ret));
goto out_fail;
}
ret = snd_pcm_hw_params_set_access(hdl, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED);
if (ret < 0)
{
DPRINTF(E_LOG, L_LAUDIO, "Could not set access method: %s\n", snd_strerror(ret));
goto out_fail;
}
ret = snd_pcm_hw_params_set_format(hdl, hw_params, SND_PCM_FORMAT_S16_LE);
if (ret < 0)
{
DPRINTF(E_LOG, L_LAUDIO, "Could not set S16LE format: %s\n", snd_strerror(ret));
goto out_fail;
}
ret = snd_pcm_hw_params_set_channels(hdl, hw_params, 2);
if (ret < 0)
{
DPRINTF(E_LOG, L_LAUDIO, "Could not set stereo output: %s\n", snd_strerror(ret));
goto out_fail;
}
ret = snd_pcm_hw_params_set_rate(hdl, hw_params, 44100, 0);
if (ret < 0)
{
DPRINTF(E_LOG, L_LAUDIO, "Hardware doesn't support 44.1 kHz: %s\n", snd_strerror(ret));
goto out_fail;
}
ret = snd_pcm_hw_params_get_buffer_size_max(hw_params, &bufsize);
if (ret < 0)
{
DPRINTF(E_LOG, L_LAUDIO, "Could not get max buffer size: %s\n", snd_strerror(ret));
goto out_fail;
}
DPRINTF(E_DBG, L_LAUDIO, "Max buffer size is %lu samples\n", bufsize);
ret = snd_pcm_hw_params_set_buffer_size_max(hdl, hw_params, &bufsize);
if (ret < 0)
{
DPRINTF(E_LOG, L_LAUDIO, "Could not set buffer size to max: %s\n", snd_strerror(ret));
goto out_fail;
}
DPRINTF(E_DBG, L_LAUDIO, "Buffer size is %lu samples\n", bufsize);
ret = snd_pcm_hw_params(hdl, hw_params);
if (ret < 0)
{
DPRINTF(E_LOG, L_LAUDIO, "Could not set hw params: %s\n", snd_strerror(ret));
goto out_fail;
}
snd_pcm_hw_params_free(hw_params);
hw_params = NULL;
pcm_pos = 0;
pcm_last_error = 0;
pcm_recovery = 0;
pcm_buf_threshold = (bufsize / AIRTUNES_V2_PACKET_SAMPLES) * AIRTUNES_V2_PACKET_SAMPLES;
ret = mixer_open();
if (ret < 0)
{
DPRINTF(E_LOG, L_LAUDIO, "Could not open mixer\n");
goto out_fail;
}
update_status(LAUDIO_OPEN);
return 0;
out_fail:
if (hw_params)
snd_pcm_hw_params_free(hw_params);
snd_pcm_close(hdl);
hdl = NULL;
return -1;
}
bool AlsaLayer::alsa_set_params(snd_pcm_t *pcm_handle)
{
#define TRY(call, error) do { \
if (ALSA_CALL(call, error) < 0) \
return false; \
} while(0)
snd_pcm_hw_params_t *hwparams;
snd_pcm_hw_params_alloca(&hwparams);
const unsigned SFL_ALSA_PERIOD_SIZE = 160;
const unsigned SFL_ALSA_NB_PERIOD = 8;
const unsigned SFL_ALSA_BUFFER_SIZE = SFL_ALSA_PERIOD_SIZE * SFL_ALSA_NB_PERIOD;
snd_pcm_uframes_t period_size = SFL_ALSA_PERIOD_SIZE;
snd_pcm_uframes_t buffer_size = SFL_ALSA_BUFFER_SIZE;
unsigned int periods = SFL_ALSA_NB_PERIOD;
snd_pcm_uframes_t period_size_min = 0;
snd_pcm_uframes_t period_size_max = 0;
snd_pcm_uframes_t buffer_size_min = 0;
snd_pcm_uframes_t buffer_size_max = 0;
#define HW pcm_handle, hwparams /* hardware parameters */
TRY(snd_pcm_hw_params_any(HW), "hwparams init");
TRY(snd_pcm_hw_params_set_access(HW, SND_PCM_ACCESS_RW_INTERLEAVED), "access type");
TRY(snd_pcm_hw_params_set_format(HW, SND_PCM_FORMAT_S16_LE), "sample format");
TRY(snd_pcm_hw_params_set_rate_resample(HW, 0), "hardware sample rate"); /* prevent software resampling */
TRY(snd_pcm_hw_params_set_rate_near(HW, &audioFormat_.sample_rate, nullptr), "sample rate");
// TODO: use snd_pcm_query_chmaps or similar to get hardware channel num
audioFormat_.nb_channels = 2;
TRY(snd_pcm_hw_params_set_channels_near(HW, &audioFormat_.nb_channels), "channel count");
snd_pcm_hw_params_get_buffer_size_min(hwparams, &buffer_size_min);
snd_pcm_hw_params_get_buffer_size_max(hwparams, &buffer_size_max);
snd_pcm_hw_params_get_period_size_min(hwparams, &period_size_min, nullptr);
snd_pcm_hw_params_get_period_size_max(hwparams, &period_size_max, nullptr);
DEBUG("Buffer size range from %lu to %lu", buffer_size_min, buffer_size_max);
DEBUG("Period size range from %lu to %lu", period_size_min, period_size_max);
buffer_size = buffer_size > buffer_size_max ? buffer_size_max : buffer_size;
buffer_size = buffer_size < buffer_size_min ? buffer_size_min : buffer_size;
period_size = period_size > period_size_max ? period_size_max : period_size;
period_size = period_size < period_size_min ? period_size_min : period_size;
TRY(snd_pcm_hw_params_set_buffer_size_near(HW, &buffer_size), "Unable to set buffer size for playback");
TRY(snd_pcm_hw_params_set_period_size_near(HW, &period_size, nullptr), "Unable to set period size for playback");
TRY(snd_pcm_hw_params_set_periods_near(HW, &periods, nullptr), "Unable to set number of periods for playback");
TRY(snd_pcm_hw_params(HW), "hwparams");
snd_pcm_hw_params_get_buffer_size(hwparams, &buffer_size);
snd_pcm_hw_params_get_period_size(hwparams, &period_size, nullptr);
snd_pcm_hw_params_get_rate(hwparams, &audioFormat_.sample_rate, nullptr);
snd_pcm_hw_params_get_channels(hwparams, &audioFormat_.nb_channels);
DEBUG("Was set period_size = %lu", period_size);
DEBUG("Was set buffer_size = %lu", buffer_size);
if (2 * period_size > buffer_size) {
ERROR("buffer to small, could not use");
return false;
}
#undef HW
DEBUG("%s using format %s",
(snd_pcm_stream(pcm_handle) == SND_PCM_STREAM_PLAYBACK) ? "playback" : "capture",
audioFormat_.toString().c_str() );
snd_pcm_sw_params_t *swparams = NULL;
snd_pcm_sw_params_alloca(&swparams);
#define SW pcm_handle, swparams /* software parameters */
snd_pcm_sw_params_current(SW);
TRY(snd_pcm_sw_params_set_start_threshold(SW, period_size * 2), "start threshold");
TRY(snd_pcm_sw_params(SW), "sw parameters");
#undef SW
return true;
#undef TRY
}
bool CAESinkALSA::InitializeHW(AEAudioFormat &format)
{
snd_pcm_hw_params_t *hw_params;
snd_pcm_hw_params_alloca(&hw_params);
memset(hw_params, 0, snd_pcm_hw_params_sizeof());
snd_pcm_hw_params_any(m_pcm, hw_params);
snd_pcm_hw_params_set_access(m_pcm, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED);
unsigned int sampleRate = format.m_sampleRate;
unsigned int channelCount = format.m_channelLayout.Count();
snd_pcm_hw_params_set_rate_near (m_pcm, hw_params, &sampleRate, NULL);
snd_pcm_hw_params_set_channels_near(m_pcm, hw_params, &channelCount);
/* ensure we opened X channels or more */
if (format.m_channelLayout.Count() > channelCount)
{
CLog::Log(LOGINFO, "CAESinkALSA::InitializeHW - Unable to open the required number of channels");
}
/* update the channelLayout to what we managed to open */
format.m_channelLayout.Reset();
for (unsigned int i = 0; i < channelCount; ++i)
format.m_channelLayout += ALSAChannelMap[i];
snd_pcm_format_t fmt = AEFormatToALSAFormat(format.m_dataFormat);
if (fmt == SND_PCM_FORMAT_UNKNOWN)
{
/* if we dont support the requested format, fallback to float */
format.m_dataFormat = AE_FMT_FLOAT;
fmt = SND_PCM_FORMAT_FLOAT;
}
/* try the data format */
if (snd_pcm_hw_params_set_format(m_pcm, hw_params, fmt) < 0)
{
/* if the chosen format is not supported, try each one in decending order */
CLog::Log(LOGINFO, "CAESinkALSA::InitializeHW - Your hardware does not support %s, trying other formats", CAEUtil::DataFormatToStr(format.m_dataFormat));
for (enum AEDataFormat i = AE_FMT_MAX; i > AE_FMT_INVALID; i = (enum AEDataFormat)((int)i - 1))
{
if (AE_IS_RAW(i) || i == AE_FMT_MAX)
continue;
if (m_passthrough && i != AE_FMT_S16BE && i != AE_FMT_S16LE)
continue;
fmt = AEFormatToALSAFormat(i);
if (fmt == SND_PCM_FORMAT_UNKNOWN || snd_pcm_hw_params_set_format(m_pcm, hw_params, fmt) < 0)
{
fmt = SND_PCM_FORMAT_UNKNOWN;
continue;
}
int fmtBits = CAEUtil::DataFormatToBits(i);
int bits = snd_pcm_hw_params_get_sbits(hw_params);
if (bits != fmtBits)
{
/* if we opened in 32bit and only have 24bits, pack into 24 */
if (fmtBits == 32 && bits == 24)
i = AE_FMT_S24NE4;
else
continue;
}
/* record that the format fell back to X */
format.m_dataFormat = i;
CLog::Log(LOGINFO, "CAESinkALSA::InitializeHW - Using data format %s", CAEUtil::DataFormatToStr(format.m_dataFormat));
break;
}
/* if we failed to find a valid output format */
if (fmt == SND_PCM_FORMAT_UNKNOWN)
{
CLog::Log(LOGERROR, "CAESinkALSA::InitializeHW - Unable to find a suitable output format");
return false;
}
}
snd_pcm_uframes_t periodSize, bufferSize;
snd_pcm_hw_params_get_buffer_size_max(hw_params, &bufferSize);
snd_pcm_hw_params_get_period_size_max(hw_params, &periodSize, NULL);
/*
We want to make sure, that we have max 200 ms Buffer with
a periodSize of approx 50 ms. Choosing a higher bufferSize
will cause problems with menu sounds. Buffer will be increased
after those are fixed.
*/
periodSize = std::min(periodSize, (snd_pcm_uframes_t) sampleRate / 20);
bufferSize = std::min(bufferSize, (snd_pcm_uframes_t) sampleRate / 5);
/*
According to upstream we should set buffer size first - so make sure it is always at least
4x period size to not get underruns (some systems seem to have issues with only 2 periods)
*/
periodSize = std::min(periodSize, bufferSize / 4);
CLog::Log(LOGDEBUG, "CAESinkALSA::InitializeHW - Request: periodSize %lu, bufferSize %lu", periodSize, bufferSize);
snd_pcm_hw_params_t *hw_params_copy;
snd_pcm_hw_params_alloca(&hw_params_copy);
snd_pcm_hw_params_copy(hw_params_copy, hw_params); // copy what we have and is already working
// Make sure to not initialize too large to not cause underruns
snd_pcm_uframes_t periodSizeMax = bufferSize / 3;
if(snd_pcm_hw_params_set_period_size_max(m_pcm, hw_params_copy, &periodSizeMax, NULL) != 0)
{
snd_pcm_hw_params_copy(hw_params_copy, hw_params); // restore working copy
CLog::Log(LOGDEBUG, "CAESinkALSA::InitializeHW - Request: Failed to limit periodSize to %lu", periodSizeMax);
}
// first trying bufferSize, PeriodSize
// for more info see here:
// http://mailman.alsa-project.org/pipermail/alsa-devel/2009-September/021069.html
// the last three tries are done as within pulseaudio
// backup periodSize and bufferSize first. Restore them after every failed try
snd_pcm_uframes_t periodSizeTemp, bufferSizeTemp;
periodSizeTemp = periodSize;
bufferSizeTemp = bufferSize;
if (snd_pcm_hw_params_set_buffer_size_near(m_pcm, hw_params_copy, &bufferSize) != 0
|| snd_pcm_hw_params_set_period_size_near(m_pcm, hw_params_copy, &periodSize, NULL) != 0
|| snd_pcm_hw_params(m_pcm, hw_params_copy) != 0)
{
bufferSize = bufferSizeTemp;
periodSize = periodSizeTemp;
// retry with PeriodSize, bufferSize
snd_pcm_hw_params_copy(hw_params_copy, hw_params); // restore working copy
if (snd_pcm_hw_params_set_period_size_near(m_pcm, hw_params_copy, &periodSize, NULL) != 0
|| snd_pcm_hw_params_set_buffer_size_near(m_pcm, hw_params_copy, &bufferSize) != 0
|| snd_pcm_hw_params(m_pcm, hw_params_copy) != 0)
{
// try only periodSize
periodSize = periodSizeTemp;
snd_pcm_hw_params_copy(hw_params_copy, hw_params); // restore working copy
if(snd_pcm_hw_params_set_period_size_near(m_pcm, hw_params_copy, &periodSize, NULL) != 0
|| snd_pcm_hw_params(m_pcm, hw_params_copy) != 0)
{
// try only BufferSize
bufferSize = bufferSizeTemp;
snd_pcm_hw_params_copy(hw_params_copy, hw_params); // restory working copy
if (snd_pcm_hw_params_set_buffer_size_near(m_pcm, hw_params_copy, &bufferSize) != 0
|| snd_pcm_hw_params(m_pcm, hw_params_copy) != 0)
{
// set default that Alsa would choose
CLog::Log(LOGWARNING, "CAESinkAlsa::IntializeHW - Using default alsa values - set failed");
if (snd_pcm_hw_params(m_pcm, hw_params) != 0)
{
CLog::Log(LOGDEBUG, "CAESinkALSA::InitializeHW - Could not init a valid sink");
return false;
}
}
}
// reread values when alsa default was kept
snd_pcm_get_params(m_pcm, &bufferSize, &periodSize);
}
}
CLog::Log(LOGDEBUG, "CAESinkALSA::InitializeHW - Got: periodSize %lu, bufferSize %lu", periodSize, bufferSize);
/* set the format parameters */
format.m_sampleRate = sampleRate;
format.m_frames = periodSize;
format.m_frameSamples = periodSize * format.m_channelLayout.Count();
format.m_frameSize = snd_pcm_frames_to_bytes(m_pcm, 1);
m_bufferSize = (unsigned int)bufferSize;
m_timeout = std::ceil((double)(bufferSize * 1000) / (double)sampleRate);
CLog::Log(LOGDEBUG, "CAESinkALSA::InitializeHW - Setting timeout to %d ms", m_timeout);
return true;
}
void info(char *dev_name, snd_pcm_stream_t stream) {
snd_pcm_hw_params_t *hw_params;
int err;
snd_pcm_t *handle;
unsigned int max;
unsigned int min;
unsigned int val;
unsigned int dir;
snd_pcm_uframes_t frames;
if ((err = snd_pcm_open (&handle, dev_name, stream, 0)) < 0) {
fprintf (stderr, "cannot open audio device %s (%s)\n",
dev_name,
snd_strerror (err));
return;
}
if ((err = snd_pcm_hw_params_malloc (&hw_params)) < 0) {
fprintf (stderr, "cannot allocate hardware parameter structure (%s)\n",
snd_strerror (err));
exit (1);
}
if ((err = snd_pcm_hw_params_any (handle, hw_params)) < 0) {
fprintf (stderr, "cannot initialize hardware parameter structure (%s)\n",
snd_strerror (err));
exit (1);
}
if ((err = snd_pcm_hw_params_get_channels_max(hw_params, &max)) < 0) {
fprintf (stderr, "cannot (%s)\n",
snd_strerror (err));
exit (1);
}
printf("max channels %d\n", max);
if ((err = snd_pcm_hw_params_get_channels_min(hw_params, &min)) < 0) {
fprintf (stderr, "cannot get channel info (%s)\n",
snd_strerror (err));
exit (1);
}
printf("min channels %d\n", min);
/*
if ((err = snd_pcm_hw_params_get_sbits(hw_params)) < 0) {
fprintf (stderr, "cannot get bits info (%s)\n",
snd_strerror (err));
exit (1);
}
printf("bits %d\n", err);
*/
if ((err = snd_pcm_hw_params_get_rate_min(hw_params, &val, &dir)) < 0) {
fprintf (stderr, "cannot get min rate (%s)\n",
snd_strerror (err));
exit (1);
}
printf("min rate %d hz\n", val);
if ((err = snd_pcm_hw_params_get_rate_max(hw_params, &val, &dir)) < 0) {
fprintf (stderr, "cannot get max rate (%s)\n",
snd_strerror (err));
exit (1);
}
printf("max rate %d hz\n", val);
if ((err = snd_pcm_hw_params_get_period_time_min(hw_params, &val, &dir)) < 0) {
fprintf (stderr, "cannot get min period time (%s)\n",
snd_strerror (err));
exit (1);
}
printf("min period time %d usecs\n", val);
if ((err = snd_pcm_hw_params_get_period_time_max(hw_params, &val, &dir)) < 0) {
fprintf (stderr, "cannot get max period time (%s)\n",
snd_strerror (err));
exit (1);
}
printf("max period time %d usecs\n", val);
if ((err = snd_pcm_hw_params_get_period_size_min(hw_params, &frames, &dir)) < 0) {
fprintf (stderr, "cannot get min period size (%s)\n",
snd_strerror (err));
exit (1);
}
printf("min period size in frames %d\n", frames);
if ((err = snd_pcm_hw_params_get_period_size_max(hw_params, &frames, &dir)) < 0) {
fprintf (stderr, "cannot get max period size (%s)\n",
snd_strerror (err));
exit (1);
}
printf("max period size in frames %d\n", frames);
if ((err = snd_pcm_hw_params_get_periods_min(hw_params, &val, &dir)) < 0) {
fprintf (stderr, "cannot get min periods (%s)\n",
snd_strerror (err));
exit (1);
}
printf("min periods per buffer %d\n", val);
if ((err = snd_pcm_hw_params_get_periods_max(hw_params, &val, &dir)) < 0) {
fprintf (stderr, "cannot get min periods (%s)\n",
snd_strerror (err));
exit (1);
}
printf("max periods per buffer %d\n", val);
if ((err = snd_pcm_hw_params_get_buffer_time_min(hw_params, &val, &dir)) < 0) {
fprintf (stderr, "cannot get min buffer time (%s)\n",
snd_strerror (err));
exit (1);
}
printf("min buffer time %d usecs\n", val);
if ((err = snd_pcm_hw_params_get_buffer_time_max(hw_params, &val, &dir)) < 0) {
fprintf (stderr, "cannot get max buffer time (%s)\n",
snd_strerror (err));
exit (1);
}
printf("max buffer time %d usecs\n", val);
if ((err = snd_pcm_hw_params_get_buffer_size_min(hw_params, &frames)) < 0) {
fprintf (stderr, "cannot get min buffer size (%s)\n",
snd_strerror (err));
exit (1);
}
printf("min buffer size in frames %d\n", frames);
if ((err = snd_pcm_hw_params_get_buffer_size_max(hw_params, &frames)) < 0) {
fprintf (stderr, "cannot get max buffer size (%s)\n",
snd_strerror (err));
exit (1);
}
printf("max buffer size in frames %d\n", frames);
}
/**************************************************************************
* ALSA_TraceParameters [internal]
*
* used to trace format changes, hw and sw parameters
*/
void ALSA_TraceParameters(snd_pcm_hw_params_t * hw_params, snd_pcm_sw_params_t * sw, int full)
{
int err;
snd_pcm_format_t format;
snd_pcm_access_t access;
#define X(x) ((x)? "true" : "false")
if (full)
TRACE("FLAGS: sampleres=%s overrng=%s pause=%s resume=%s syncstart=%s batch=%s block=%s double=%s "
"halfd=%s joint=%s\n",
X(snd_pcm_hw_params_can_mmap_sample_resolution(hw_params)),
X(snd_pcm_hw_params_can_overrange(hw_params)),
X(snd_pcm_hw_params_can_pause(hw_params)),
X(snd_pcm_hw_params_can_resume(hw_params)),
X(snd_pcm_hw_params_can_sync_start(hw_params)),
X(snd_pcm_hw_params_is_batch(hw_params)),
X(snd_pcm_hw_params_is_block_transfer(hw_params)),
X(snd_pcm_hw_params_is_double(hw_params)),
X(snd_pcm_hw_params_is_half_duplex(hw_params)),
X(snd_pcm_hw_params_is_joint_duplex(hw_params)));
#undef X
err = snd_pcm_hw_params_get_access(hw_params, &access);
if (err >= 0)
{
TRACE("access=%s\n", snd_pcm_access_name(access));
}
else
{
snd_pcm_access_mask_t * acmask;
acmask = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, snd_pcm_access_mask_sizeof());
snd_pcm_hw_params_get_access_mask(hw_params, acmask);
for ( access = SND_PCM_ACCESS_MMAP_INTERLEAVED; access <= SND_PCM_ACCESS_LAST; access++)
if (snd_pcm_access_mask_test(acmask, access))
TRACE("access=%s\n", snd_pcm_access_name(access));
HeapFree( GetProcessHeap(), 0, acmask );
}
err = snd_pcm_hw_params_get_format(hw_params, &format);
if (err >= 0)
{
TRACE("format=%s\n", snd_pcm_format_name(format));
}
else
{
snd_pcm_format_mask_t * fmask;
fmask = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, snd_pcm_format_mask_sizeof());
snd_pcm_hw_params_get_format_mask(hw_params, fmask);
for ( format = SND_PCM_FORMAT_S8; format <= SND_PCM_FORMAT_LAST ; format++)
if ( snd_pcm_format_mask_test(fmask, format) )
TRACE("format=%s\n", snd_pcm_format_name(format));
HeapFree( GetProcessHeap(), 0, fmask );
}
do {
int err=0;
unsigned int val=0;
err = snd_pcm_hw_params_get_channels(hw_params, &val);
if (err<0) {
unsigned int min = 0;
unsigned int max = 0;
err = snd_pcm_hw_params_get_channels_min(hw_params, &min),
err = snd_pcm_hw_params_get_channels_max(hw_params, &max);
TRACE("channels_min=%u, channels_min_max=%u\n", min, max);
} else {
TRACE("channels=%d\n", val);
}
} while(0);
do {
int err=0;
snd_pcm_uframes_t val=0;
err = snd_pcm_hw_params_get_buffer_size(hw_params, &val);
if (err<0) {
snd_pcm_uframes_t min = 0;
snd_pcm_uframes_t max = 0;
err = snd_pcm_hw_params_get_buffer_size_min(hw_params, &min),
err = snd_pcm_hw_params_get_buffer_size_max(hw_params, &max);
TRACE("buffer_size_min=%lu, buffer_size_min_max=%lu\n", min, max);
} else {
TRACE("buffer_size=%lu\n", val);
}
} while(0);
#define X(x) do { \
int err=0; \
int dir=0; \
unsigned int val=0; \
err = snd_pcm_hw_params_get_##x(hw_params,&val, &dir); \
if (err<0) { \
unsigned int min = 0; \
unsigned int max = 0; \
err = snd_pcm_hw_params_get_##x##_min(hw_params, &min, &dir); \
err = snd_pcm_hw_params_get_##x##_max(hw_params, &max, &dir); \
TRACE(#x "_min=%u " #x "_max=%u\n", min, max); \
} else \
TRACE(#x "=%d\n", val); \
} while(0)
X(rate);
X(buffer_time);
X(periods);
do {
int err=0;
int dir=0;
snd_pcm_uframes_t val=0;
err = snd_pcm_hw_params_get_period_size(hw_params, &val, &dir);
if (err<0) {
snd_pcm_uframes_t min = 0;
snd_pcm_uframes_t max = 0;
err = snd_pcm_hw_params_get_period_size_min(hw_params, &min, &dir),
err = snd_pcm_hw_params_get_period_size_max(hw_params, &max, &dir);
TRACE("period_size_min=%lu, period_size_min_max=%lu\n", min, max);
} else {
TRACE("period_size=%lu\n", val);
}
} while(0);
X(period_time);
#undef X
if (!sw)
return;
}
int init_alsa(unsigned int channels, unsigned sample_rate,
snd_pcm_format_t format)
{
int ret;
snd_pcm_hw_params_t *hw_params;
playback_handle = NULL;
ret = snd_pcm_open(&playback_handle, "default", SND_PCM_STREAM_PLAYBACK,
0);
if (ret < 0) {
fprintf(stderr, "can NOT open soundcard\n");
goto fail;
}
ret = snd_pcm_hw_params_malloc(&hw_params);
if (ret < 0) {
fprintf(stderr, "can NOT allocate hardware paramter structure (%s)\n",
snd_strerror(ret));
goto fail;
}
ret = snd_pcm_hw_params_any(playback_handle, hw_params);
if (ret < 0) {
fprintf(stderr, "can NOT initialize hardware paramter structure (%s)\n",
snd_strerror(ret));
goto fail;
}
ret = snd_pcm_hw_params_set_access(playback_handle, hw_params,
SND_PCM_ACCESS_RW_INTERLEAVED);
if (ret < 0) {
fprintf(stderr, "can NOT set access type (%s)\n", snd_strerror(ret));
goto fail;
}
ret = snd_pcm_hw_params_set_format(playback_handle, hw_params, format);
if (ret < 0) {
fprintf(stderr, "can NOT set sample format (%s)\n", snd_strerror(ret));
goto fail;
}
ret = snd_pcm_hw_params_set_rate_near(playback_handle, hw_params,
&sample_rate, 0);
if (ret < 0) {
fprintf(stderr, "can NOT set sample rate (%s)\n", snd_strerror(ret));
goto fail;
}
ret = snd_pcm_hw_params_set_channels(playback_handle, hw_params, channels);
if (ret < 0) {
fprintf(stderr, "can NOT set channels (%s)\n", snd_strerror(ret));
goto fail;
}
snd_pcm_hw_params_get_buffer_size_max(hw_params, &buffer_size);
buffer_size = buffer_size < ALSA_BUFFER_SIZE_MAX ?
buffer_size : ALSA_BUFFER_SIZE_MAX;
ret = snd_pcm_hw_params_set_buffer_size_near(playback_handle, hw_params,
&buffer_size);
if (ret < 0) {
fprintf(stderr, "can NOT set alsa buffer size (%s)\n", snd_strerror(ret));
goto fail;
}
snd_pcm_hw_params_get_period_size_min(hw_params, &period_size, NULL);
if (!period_size)
period_size = buffer_size / 4;
ret = snd_pcm_hw_params_set_period_size_near(playback_handle, hw_params,
&period_size, NULL);
if (ret < 0) {
fprintf(stderr, "can NOT set alsa period size (%s)\n", snd_strerror(ret));
goto fail;
}
ret = snd_pcm_hw_params(playback_handle, hw_params);
if (ret < 0) {
fprintf(stderr, "can NOT set parameters (%s)\n", snd_strerror(ret));
goto fail;
}
snd_pcm_hw_params_free(hw_params);
audio_channels = channels;
audio_sample_rate = sample_rate;
audio_format = format;
ret = 0;
return ret;
fail:
if (playback_handle) {
snd_pcm_close(playback_handle);
playback_handle = NULL;
}
return ret;
}
/**
* Set up the snd_pcm_t object which was opened by the caller. Set up
* the configured settings and the audio format.
*/
static bool
alsa_setup(struct alsa_data *ad, struct audio_format *audio_format,
GError **error)
{
snd_pcm_hw_params_t *hwparams;
snd_pcm_sw_params_t *swparams;
unsigned int sample_rate = audio_format->sample_rate;
unsigned int channels = audio_format->channels;
snd_pcm_uframes_t alsa_buffer_size;
snd_pcm_uframes_t alsa_period_size;
int err;
const char *cmd = NULL;
int retry = MPD_ALSA_RETRY_NR;
unsigned int period_time, period_time_ro;
unsigned int buffer_time;
period_time_ro = period_time = ad->period_time;
configure_hw:
/* configure HW params */
snd_pcm_hw_params_alloca(&hwparams);
cmd = "snd_pcm_hw_params_any";
err = snd_pcm_hw_params_any(ad->pcm, hwparams);
if (err < 0)
goto error;
if (ad->use_mmap) {
err = snd_pcm_hw_params_set_access(ad->pcm, hwparams,
SND_PCM_ACCESS_MMAP_INTERLEAVED);
if (err < 0) {
g_warning("Cannot set mmap'ed mode on ALSA device \"%s\": %s\n",
alsa_device(ad), snd_strerror(-err));
g_warning("Falling back to direct write mode\n");
ad->use_mmap = false;
} else
ad->writei = snd_pcm_mmap_writei;
}
if (!ad->use_mmap) {
cmd = "snd_pcm_hw_params_set_access";
err = snd_pcm_hw_params_set_access(ad->pcm, hwparams,
SND_PCM_ACCESS_RW_INTERLEAVED);
if (err < 0)
goto error;
ad->writei = snd_pcm_writei;
}
err = alsa_output_setup_format(ad->pcm, hwparams, audio_format);
if (err < 0) {
g_set_error(error, alsa_output_quark(), err,
"ALSA device \"%s\" does not support format %s: %s",
alsa_device(ad),
sample_format_to_string(audio_format->format),
snd_strerror(-err));
return false;
}
err = snd_pcm_hw_params_set_channels_near(ad->pcm, hwparams,
&channels);
if (err < 0) {
g_set_error(error, alsa_output_quark(), err,
"ALSA device \"%s\" does not support %i channels: %s",
alsa_device(ad), (int)audio_format->channels,
snd_strerror(-err));
return false;
}
audio_format->channels = (int8_t)channels;
err = snd_pcm_hw_params_set_rate_near(ad->pcm, hwparams,
&sample_rate, NULL);
if (err < 0 || sample_rate == 0) {
g_set_error(error, alsa_output_quark(), err,
"ALSA device \"%s\" does not support %u Hz audio",
alsa_device(ad), audio_format->sample_rate);
return false;
}
audio_format->sample_rate = sample_rate;
snd_pcm_uframes_t buffer_size_min, buffer_size_max;
snd_pcm_hw_params_get_buffer_size_min(hwparams, &buffer_size_min);
snd_pcm_hw_params_get_buffer_size_max(hwparams, &buffer_size_max);
unsigned buffer_time_min, buffer_time_max;
snd_pcm_hw_params_get_buffer_time_min(hwparams, &buffer_time_min, 0);
snd_pcm_hw_params_get_buffer_time_max(hwparams, &buffer_time_max, 0);
g_debug("buffer: size=%u..%u time=%u..%u",
(unsigned)buffer_size_min, (unsigned)buffer_size_max,
buffer_time_min, buffer_time_max);
snd_pcm_uframes_t period_size_min, period_size_max;
snd_pcm_hw_params_get_period_size_min(hwparams, &period_size_min, 0);
snd_pcm_hw_params_get_period_size_max(hwparams, &period_size_max, 0);
unsigned period_time_min, period_time_max;
snd_pcm_hw_params_get_period_time_min(hwparams, &period_time_min, 0);
snd_pcm_hw_params_get_period_time_max(hwparams, &period_time_max, 0);
g_debug("period: size=%u..%u time=%u..%u",
(unsigned)period_size_min, (unsigned)period_size_max,
period_time_min, period_time_max);
if (ad->buffer_time > 0) {
buffer_time = ad->buffer_time;
cmd = "snd_pcm_hw_params_set_buffer_time_near";
err = snd_pcm_hw_params_set_buffer_time_near(ad->pcm, hwparams,
&buffer_time, NULL);
if (err < 0)
goto error;
} else {
err = snd_pcm_hw_params_get_buffer_time(hwparams, &buffer_time,
NULL);
if (err < 0)
buffer_time = 0;
}
if (period_time_ro == 0 && buffer_time >= 10000) {
period_time_ro = period_time = buffer_time / 4;
g_debug("default period_time = buffer_time/4 = %u/4 = %u",
buffer_time, period_time);
}
if (period_time_ro > 0) {
period_time = period_time_ro;
cmd = "snd_pcm_hw_params_set_period_time_near";
err = snd_pcm_hw_params_set_period_time_near(ad->pcm, hwparams,
&period_time, NULL);
if (err < 0)
goto error;
}
cmd = "snd_pcm_hw_params";
err = snd_pcm_hw_params(ad->pcm, hwparams);
if (err == -EPIPE && --retry > 0 && period_time_ro > 0) {
period_time_ro = period_time_ro >> 1;
goto configure_hw;
} else if (err < 0)
static int
laudio_alsa_open(void)
{
snd_pcm_hw_params_t *hw_params;
snd_pcm_uframes_t bufsize;
snd_pcm_uframes_t period_size;
int ret;
hw_params = NULL;
ret = snd_pcm_open(&hdl, card_name, SND_PCM_STREAM_PLAYBACK, 0);
if (ret < 0)
{
DPRINTF(E_LOG, L_LAUDIO, "Could not open playback device: %s\n", snd_strerror(ret));
return -1;
}
/* HW params */
ret = snd_pcm_hw_params_malloc(&hw_params);
if (ret < 0)
{
DPRINTF(E_LOG, L_LAUDIO, "Could not allocate hw params: %s\n", snd_strerror(ret));
goto out_fail;
}
ret = snd_pcm_hw_params_any(hdl, hw_params);
if (ret < 0)
{
DPRINTF(E_LOG, L_LAUDIO, "Could not retrieve hw params: %s\n", snd_strerror(ret));
goto out_fail;
}
ret = snd_pcm_hw_params_set_access(hdl, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED);
if (ret < 0)
{
DPRINTF(E_LOG, L_LAUDIO, "Could not set access method: %s\n", snd_strerror(ret));
goto out_fail;
}
ret = snd_pcm_hw_params_set_format(hdl, hw_params, SND_PCM_FORMAT_S16_LE);
if (ret < 0)
{
DPRINTF(E_LOG, L_LAUDIO, "Could not set S16LE format: %s\n", snd_strerror(ret));
goto out_fail;
}
ret = snd_pcm_hw_params_set_channels(hdl, hw_params, 2);
if (ret < 0)
{
DPRINTF(E_LOG, L_LAUDIO, "Could not set stereo output: %s\n", snd_strerror(ret));
goto out_fail;
}
ret = snd_pcm_hw_params_set_rate(hdl, hw_params, 44100, 0);
if (ret < 0)
{
DPRINTF(E_LOG, L_LAUDIO, "Hardware doesn't support 44.1 kHz: %s\n", snd_strerror(ret));
goto out_fail;
}
ret = snd_pcm_hw_params_get_buffer_size_max(hw_params, &bufsize);
if (ret < 0)
{
DPRINTF(E_LOG, L_LAUDIO, "Could not get max buffer size: %s\n", snd_strerror(ret));
goto out_fail;
}
DPRINTF(E_DBG, L_LAUDIO, "Max buffer size is %lu samples\n", bufsize);
ret = snd_pcm_hw_params_set_buffer_size_max(hdl, hw_params, &bufsize);
if (ret < 0)
{
DPRINTF(E_LOG, L_LAUDIO, "Could not set buffer size to max: %s\n", snd_strerror(ret));
goto out_fail;
}
// With a small period size we seem to get underruns because the period time
// passes before we manage to feed with samples (if the player is slightly
// behind - especially critical during startup when the buffer is low)
// Internet suggests period_size should be /2 bufsize, but default seems to be
// much lower, so compromise on /4 (but not more than 65536 frames = almost 2 sec).
period_size = bufsize / 4;
if (period_size > 65536)
period_size = 65536;
ret = snd_pcm_hw_params_set_period_size_near(hdl, hw_params, &period_size, NULL);
if (ret < 0)
{
DPRINTF(E_LOG, L_LAUDIO, "Could not set period size: %s\n", snd_strerror(ret));
goto out_fail;
}
DPRINTF(E_DBG, L_LAUDIO, "Buffer size is %lu samples, period size is %lu samples\n", bufsize, period_size);
ret = snd_pcm_hw_params(hdl, hw_params);
if (ret < 0)
{
DPRINTF(E_LOG, L_LAUDIO, "Could not set hw params: %s\n", snd_strerror(ret));
goto out_fail;
}
snd_pcm_hw_params_free(hw_params);
hw_params = NULL;
pcm_pos = 0;
pcm_last_error = 0;
pcm_recovery = 0;
pcm_buf_threshold = ((bufsize - period_size) / AIRTUNES_V2_PACKET_SAMPLES) * AIRTUNES_V2_PACKET_SAMPLES;
pcm_period_size = period_size;
ret = mixer_open();
if (ret < 0)
{
DPRINTF(E_LOG, L_LAUDIO, "Could not open mixer\n");
goto out_fail;
}
update_status(LAUDIO_OPEN);
return 0;
out_fail:
if (hw_params)
snd_pcm_hw_params_free(hw_params);
snd_pcm_close(hdl);
hdl = NULL;
return -1;
}
int play_sound(char* filename,int rate,int bits,int channel,int order)
{
long loops;
int rc,size,dir;
snd_pcm_t *handle;
snd_pcm_hw_params_t *params;
snd_pcm_uframes_t frames,periodsize;
snd_mixer_t *mixer;
snd_mixer_elem_t *pcm_element;
char *buffer;
unsigned int val;
FILE *fp = fopen(filename,"rb");
rc = snd_pcm_open(&handle,"default",SND_PCM_STREAM_PLAYBACK,0);
snd_pcm_hw_params_alloca(¶ms);
snd_pcm_hw_params_any(handle,params);
snd_pcm_hw_params_set_access(handle,params,SND_PCM_ACCESS_RW_INTERLEAVED);
switch(order){
case 1:
snd_pcm_hw_params_set_format(handle,params,SND_PCM_FORMAT_S16_LE);
break;
case 2:
snd_pcm_hw_params_set_format(handle,params,SND_PCM_FORMAT_S16_BE);
break;
defualt:
break;
}
snd_pcm_hw_params_set_channels(handle,params,channel);
val = rate;
snd_pcm_hw_params_set_rate_near(handle,params,&val,0);
snd_pcm_hw_params_get_buffer_size_max(params,&frames);
frames = frames < ALSA_MAX_BUF_SIZE? frames:ALSA_MAX_BUF_SIZE;
rc = snd_pcm_hw_params_set_buffer_size_near(handle,params,&frames);
snd_pcm_hw_params_get_period_size_min(params,&periodsize,NULL);
if(!periodsize){
periodsize=size/4;
}
rc = snd_pcm_hw_params_set_period_size_near(handle,params,&periodsize,NULL);
rc = snd_pcm_hw_params(handle,params);
snd_mixer_open(&mixer,0);
snd_mixer_attach(mixer,"default");
snd_mixer_selem_register(mixer,NULL,NULL);
snd_mixer_load(mixer);
for(pcm_element = snd_mixer_first_elem(mixer);pcm_element;pcm_element=snd_mixer_elem_next(pcm_element))
{
if(snd_mixer_elem_get_type(pcm_element)==SND_MIXER_ELEM_SIMPLE && snd_mixer_selem_is_active(pcm_element))
{
if(!strcmp(snd_mixer_selem_get_name(pcm_element),"Master"))
{
snd_mixer_selem_set_playback_volume_range(pcm_element,0,100);
snd_mixer_selem_set_playback_volume_all(pcm_element,(long)100);
}
}
}
buffer = (char*)malloc(size);
while(1)
{
rc = fread(buffer,1,size,fp);
if(0== rc)
break;
while((rc = snd_pcm_writei(handle,buffer,size))<0)
{
usleep(200);
if(-EPIPE == rc)
snd_pcm_prepare(handle);
else if(0 > rc)
printf("error fomr writei\n");
}
}
snd_pcm_drain(handle);
snd_pcm_close(handle);
free(buffer);
snd_mixer_close(mixer);
fclose(fp);
return 0;
}
static snd_pcm_t *alsa_open(char *dev, int rate, int channels)
{
snd_pcm_hw_params_t *hwp;
snd_pcm_sw_params_t *swp;
snd_pcm_t *h;
int r;
int dir;
snd_pcm_uframes_t period_size_min;
snd_pcm_uframes_t period_size_max;
snd_pcm_uframes_t buffer_size_min;
snd_pcm_uframes_t buffer_size_max;
snd_pcm_uframes_t period_size;
snd_pcm_uframes_t buffer_size;
if ((r = snd_pcm_open(&h, dev, SND_PCM_STREAM_PLAYBACK, 0) < 0))
return NULL;
hwp = alloca(snd_pcm_hw_params_sizeof());
memset(hwp, 0, snd_pcm_hw_params_sizeof());
snd_pcm_hw_params_any(h, hwp);
snd_pcm_hw_params_set_access(h, hwp, SND_PCM_ACCESS_RW_INTERLEAVED);
snd_pcm_hw_params_set_format(h, hwp, SND_PCM_FORMAT_S16_LE);
snd_pcm_hw_params_set_rate(h, hwp, rate, 0);
snd_pcm_hw_params_set_channels(h, hwp, channels);
/* Configurue period */
dir = 0;
snd_pcm_hw_params_get_period_size_min(hwp, &period_size_min, &dir);
dir = 0;
snd_pcm_hw_params_get_period_size_max(hwp, &period_size_max, &dir);
period_size = 1024;
dir = 0;
r = snd_pcm_hw_params_set_period_size_near(h, hwp, &period_size, &dir);
if (r < 0) {
fprintf(stderr, "audio: Unable to set period size %lu (%s)\n",
period_size, snd_strerror(r));
snd_pcm_close(h);
return NULL;
}
dir = 0;
r = snd_pcm_hw_params_get_period_size(hwp, &period_size, &dir);
if (r < 0) {
fprintf(stderr, "audio: Unable to get period size (%s)\n",
snd_strerror(r));
snd_pcm_close(h);
return NULL;
}
/* Configurue buffer size */
snd_pcm_hw_params_get_buffer_size_min(hwp, &buffer_size_min);
snd_pcm_hw_params_get_buffer_size_max(hwp, &buffer_size_max);
buffer_size = period_size * 4;
dir = 0;
r = snd_pcm_hw_params_set_buffer_size_near(h, hwp, &buffer_size);
if (r < 0) {
fprintf(stderr, "audio: Unable to set buffer size %lu (%s)\n",
buffer_size, snd_strerror(r));
snd_pcm_close(h);
return NULL;
}
r = snd_pcm_hw_params_get_buffer_size(hwp, &buffer_size);
if (r < 0) {
fprintf(stderr, "audio: Unable to get buffer size (%s)\n",
snd_strerror(r));
snd_pcm_close(h);
return NULL;
}
/* write the hw params */
r = snd_pcm_hw_params(h, hwp);
if (r < 0) {
fprintf(stderr, "audio: Unable to configure hardware parameters (%s)\n",
snd_strerror(r));
snd_pcm_close(h);
return NULL;
}
/*
* Software parameters
*/
swp = alloca(snd_pcm_sw_params_sizeof());
memset(hwp, 0, snd_pcm_sw_params_sizeof());
snd_pcm_sw_params_current(h, swp);
r = snd_pcm_sw_params_set_avail_min(h, swp, period_size);
if (r < 0) {
fprintf(stderr, "audio: Unable to configure wakeup threshold (%s)\n",
snd_strerror(r));
snd_pcm_close(h);
return NULL;
}
snd_pcm_sw_params_set_start_threshold(h, swp, 0);
if (r < 0) {
fprintf(stderr, "audio: Unable to configure start threshold (%s)\n",
snd_strerror(r));
snd_pcm_close(h);
return NULL;
}
r = snd_pcm_sw_params(h, swp);
if (r < 0) {
fprintf(stderr, "audio: Cannot set soft parameters (%s)\n",
snd_strerror(r));
snd_pcm_close(h);
return NULL;
}
r = snd_pcm_prepare(h);
if (r < 0) {
fprintf(stderr, "audio: Cannot prepare audio for playback (%s)\n",
snd_strerror(r));
snd_pcm_close(h);
return NULL;
}
return h;
}
static void *alsa_thread_init(const char *device,
unsigned rate, unsigned latency)
{
snd_pcm_uframes_t buffer_size;
snd_pcm_format_t format;
snd_pcm_hw_params_t *params = NULL;
snd_pcm_sw_params_t *sw_params = NULL;
const char *alsa_dev = device ? device : "default";
unsigned latency_usec = latency * 1000 / 2;
unsigned channels = 2;
unsigned periods = 4;
alsa_thread_t *alsa = (alsa_thread_t*)
calloc(1, sizeof(alsa_thread_t));
if (!alsa)
return NULL;
TRY_ALSA(snd_pcm_open(&alsa->pcm, alsa_dev, SND_PCM_STREAM_PLAYBACK, 0));
TRY_ALSA(snd_pcm_hw_params_malloc(¶ms));
alsa->has_float = alsathread_find_float_format(alsa->pcm, params);
format = alsa->has_float ? SND_PCM_FORMAT_FLOAT : SND_PCM_FORMAT_S16;
TRY_ALSA(snd_pcm_hw_params_any(alsa->pcm, params));
TRY_ALSA(snd_pcm_hw_params_set_access(
alsa->pcm, params, SND_PCM_ACCESS_RW_INTERLEAVED));
TRY_ALSA(snd_pcm_hw_params_set_format(alsa->pcm, params, format));
TRY_ALSA(snd_pcm_hw_params_set_channels(alsa->pcm, params, channels));
TRY_ALSA(snd_pcm_hw_params_set_rate(alsa->pcm, params, rate, 0));
TRY_ALSA(snd_pcm_hw_params_set_buffer_time_near(
alsa->pcm, params, &latency_usec, NULL));
TRY_ALSA(snd_pcm_hw_params_set_periods_near(
alsa->pcm, params, &periods, NULL));
TRY_ALSA(snd_pcm_hw_params(alsa->pcm, params));
/* Shouldn't have to bother with this,
* but some drivers are apparently broken. */
if (snd_pcm_hw_params_get_period_size(params, &alsa->period_frames, NULL))
snd_pcm_hw_params_get_period_size_min(
params, &alsa->period_frames, NULL);
RARCH_LOG("ALSA: Period size: %d frames\n", (int)alsa->period_frames);
if (snd_pcm_hw_params_get_buffer_size(params, &buffer_size))
snd_pcm_hw_params_get_buffer_size_max(params, &buffer_size);
RARCH_LOG("ALSA: Buffer size: %d frames\n", (int)buffer_size);
alsa->buffer_size = snd_pcm_frames_to_bytes(alsa->pcm, buffer_size);
alsa->period_size = snd_pcm_frames_to_bytes(alsa->pcm, alsa->period_frames);
TRY_ALSA(snd_pcm_sw_params_malloc(&sw_params));
TRY_ALSA(snd_pcm_sw_params_current(alsa->pcm, sw_params));
TRY_ALSA(snd_pcm_sw_params_set_start_threshold(
alsa->pcm, sw_params, buffer_size / 2));
TRY_ALSA(snd_pcm_sw_params(alsa->pcm, sw_params));
snd_pcm_hw_params_free(params);
snd_pcm_sw_params_free(sw_params);
alsa->fifo_lock = slock_new();
alsa->cond_lock = slock_new();
alsa->cond = scond_new();
alsa->buffer = fifo_new(alsa->buffer_size);
if (!alsa->fifo_lock || !alsa->cond_lock || !alsa->cond || !alsa->buffer)
goto error;
alsa->worker_thread = sthread_create(alsa_worker_thread, alsa);
if (!alsa->worker_thread)
{
RARCH_ERR("error initializing worker thread");
goto error;
}
return alsa;
error:
RARCH_ERR("ALSA: Failed to initialize...\n");
if (params)
snd_pcm_hw_params_free(params);
if (sw_params)
snd_pcm_sw_params_free(sw_params);
alsa_thread_free(alsa);
return NULL;
}
bool AlsaRenderer::SetupHwParams()
{
snd_pcm_hw_params_t* params;
/* allocate a hardware parameters object */
snd_pcm_hw_params_malloc(¶ms);
/* choose all parameters */
snd_pcm_hw_params_any(m_PcmHandle, params);
/* enable hardware resampling */
snd_pcm_hw_params_set_rate_resample(m_PcmHandle, params, m_Resample);
/* set the interleaved read/write format */
snd_pcm_hw_params_set_access(m_PcmHandle, params, SND_PCM_ACCESS_RW_INTERLEAVED);
/* signed 16-bit little-endian format */
snd_pcm_hw_params_set_format(m_PcmHandle, params, SND_PCM_FORMAT_S16_LE);
/* set the count of channels */
snd_pcm_hw_params_get_channels_max(params, &m_Channels.max);
snd_pcm_hw_params_get_channels_min(params, &m_Channels.min);
if (m_Channels.val < m_Channels.min || m_Channels.val > m_Channels.max)
m_Channels.val = m_Channels.min;
snd_pcm_hw_params_set_channels(m_PcmHandle, params, m_Channels.val);
/* set the stream rate */
snd_pcm_hw_params_get_rate_max(params, &m_SampleRate.max, &m_Dir);
snd_pcm_hw_params_get_rate_min(params, &m_SampleRate.min, &m_Dir);
if (m_SampleRate.val < m_SampleRate.min || m_SampleRate.val > m_SampleRate.max)
m_SampleRate.val = m_SampleRate.min;
printf("sample rate max:%d, min:%d, val:%d\n",
m_SampleRate.max, m_SampleRate.min, m_SampleRate.val);
snd_pcm_hw_params_set_rate(m_PcmHandle, params, m_SampleRate.val, m_Dir);
/* we can set period and buffer by size or time */
/* by default we use "size" (count of frames) */
/* set how many frames in a buffer (a buffer cantains several periods) */
snd_pcm_hw_params_get_buffer_size_max(params, &m_BufferSize.max);
snd_pcm_hw_params_get_buffer_size_min(params, &m_BufferSize.min);
/* detect period time and buffer time range */
snd_pcm_hw_params_get_buffer_time_max(params, &m_BufferTime.max, &m_Dir);
snd_pcm_hw_params_get_buffer_time_min(params, &m_BufferTime.min, &m_Dir);
m_BufferTime.val = std::max(m_BufferTime.max / 2, m_BufferTime.min);
//m_BufferTime.val = m_BufferTime.min + (m_BufferTime.max - m_BufferTime.min) /2;
printf("buffer time max:%d, min:%d, val:%d\n",
m_BufferTime.max, m_BufferTime.min, m_BufferTime.val);
//(m_BufferTime.max > 120000) ? 120000 : m_BufferTime.max;//120000
snd_pcm_hw_params_set_buffer_time_near(m_PcmHandle, params, &m_BufferTime.val, &m_Dir);
snd_pcm_hw_params_get_period_time_max(params, &m_PeriodTime.max, &m_Dir);
snd_pcm_hw_params_get_period_time_min(params, &m_PeriodTime.min, &m_Dir);
m_PeriodTime.val = m_BufferTime.val / 4;
//m_PeriodTime.val = m_PeriodTime.min + (m_PeriodTime.max - m_PeriodTime.min) / 2;
printf("period time max:%d, min:%d, val:%d\n",
m_PeriodTime.max, m_PeriodTime.min, m_PeriodTime.val);
snd_pcm_hw_params_set_period_time_near(m_PcmHandle, params, &m_PeriodTime.val, &m_Dir);
int ret = snd_pcm_hw_params(m_PcmHandle, params);
if (ret != 0) {
snd_pcm_hw_params_free(params);
return false;
}
// get period size again
snd_pcm_hw_params_get_period_size(params, &m_PeriodSize.val, &m_Dir);
snd_pcm_hw_params_get_buffer_size(params, &m_BufferSize.val);
m_BitsPerSample = snd_pcm_format_physical_width(SND_PCM_FORMAT_S16_LE);
m_FrameLength = (m_BitsPerSample/8 * m_Channels.val);
//mPeriodBufferLength = m_PeriodSize.val * m_FrameLength ;
snd_pcm_hw_params_free(params);
return true;
}
static snd_pcm_t * bg_alsa_open(const char * card,
gavl_audio_format_t * format,
snd_pcm_stream_t stream,
gavl_time_t buffer_time,
int * convert_4_3)
{
unsigned int i_tmp;
int dir, err;
snd_pcm_hw_params_t *hw_params = NULL;
// snd_pcm_sw_params_t *sw_params = NULL;
snd_pcm_t *ret = NULL;
snd_pcm_uframes_t buffer_size;
snd_pcm_uframes_t period_size;
snd_pcm_uframes_t period_size_min = 0;
snd_pcm_uframes_t period_size_max = 0;
snd_pcm_uframes_t buffer_size_min = 0;
snd_pcm_uframes_t buffer_size_max = 0;
/* We open in non blocking mode so our process won't hang if the card is
busy */
if((err = snd_pcm_open(&ret,
card,
stream, // SND_PCM_STREAM_PLAYBACK SND_PCM_STREAM_CAPTURE
SND_PCM_NONBLOCK // SND_PCM_ASYNC
) < 0))
{
ret = NULL;
bg_log(BG_LOG_ERROR, LOG_DOMAIN, "snd_pcm_open failed for device %s (%s)",
card, snd_strerror(err));
goto fail;
}
/* Now, set blocking mode */
snd_pcm_nonblock(ret, 0);
if(snd_pcm_hw_params_malloc(&hw_params) < 0)
{
bg_log(BG_LOG_ERROR, LOG_DOMAIN, "snd_pcm_hw_params_malloc failed");
goto fail;
}
if(snd_pcm_hw_params_any(ret, hw_params) < 0)
{
bg_log(BG_LOG_ERROR, LOG_DOMAIN, "snd_pcm_hw_params_any failed");
goto fail;
}
/* Interleave mode */
if(snd_pcm_hw_params_set_access(ret, hw_params,
SND_PCM_ACCESS_RW_INTERLEAVED) < 0)
{
bg_log(BG_LOG_ERROR, LOG_DOMAIN, "snd_pcm_hw_params_set_access failed");
goto fail;
}
else
format->interleave_mode = GAVL_INTERLEAVE_ALL;
/* Sample format */
switch(format->sample_format)
{
case GAVL_SAMPLE_S8:
case GAVL_SAMPLE_U8:
if(snd_pcm_hw_params_set_format(ret, hw_params, SND_PCM_FORMAT_S8) < 0)
// if(1)
{
/* Soundcard support no 8-bit, try 16 */
if(snd_pcm_hw_params_set_format(ret, hw_params, SND_PCM_FORMAT_S16) < 0)
{
/* Hopeless */
bg_log(BG_LOG_ERROR, LOG_DOMAIN, "snd_pcm_hw_params_set_format failed");
goto fail;
}
else
format->sample_format = GAVL_SAMPLE_S16;
}
else
format->sample_format = GAVL_SAMPLE_S8;
break;
case GAVL_SAMPLE_S16:
case GAVL_SAMPLE_U16:
if(snd_pcm_hw_params_set_format(ret, hw_params, SND_PCM_FORMAT_S16) < 0)
{
/* Hopeless */
bg_log(BG_LOG_ERROR, LOG_DOMAIN, "snd_pcm_hw_params_set_format failed");
goto fail;
}
else
format->sample_format = GAVL_SAMPLE_S16;
break;
case GAVL_SAMPLE_S32:
#ifndef WORDS_BIGENDIAN
if(snd_pcm_hw_params_set_format(ret, hw_params, SND_PCM_FORMAT_S32_LE) < 0)
#else
if(snd_pcm_hw_params_set_format(ret, hw_params, SND_PCM_FORMAT_S32_BE) < 0)
#endif
{
/* Soundcard supports no 32-bit, try 24
(more probably supported but needs conversion) */
#ifndef WORDS_BIGENDIAN
if(snd_pcm_hw_params_set_format(ret, hw_params, SND_PCM_FORMAT_S24_3LE) < 0)
#else
if(snd_pcm_hw_params_set_format(ret, hw_params, SND_PCM_FORMAT_S24_3BE) < 0)
#endif
{
/* No 24 bit, try 16 */
if(snd_pcm_hw_params_set_format(ret, hw_params, SND_PCM_FORMAT_S16) < 0)
{
/* Hopeless */
bg_log(BG_LOG_ERROR, LOG_DOMAIN, "snd_pcm_hw_params_set_format failed");
goto fail;
}
else
format->sample_format = GAVL_SAMPLE_S16;
}
else
{
format->sample_format = GAVL_SAMPLE_S32;
if(convert_4_3)
*convert_4_3 = 1;
}
}
else
format->sample_format = GAVL_SAMPLE_S32;
break;
case GAVL_SAMPLE_FLOAT:
case GAVL_SAMPLE_DOUBLE:
if(snd_pcm_hw_params_set_format(ret, hw_params, SND_PCM_FORMAT_FLOAT) < 0)
{
#ifndef WORDS_BIGENDIAN
if(snd_pcm_hw_params_set_format(ret, hw_params, SND_PCM_FORMAT_S32_LE) < 0)
#else
if(snd_pcm_hw_params_set_format(ret, hw_params, SND_PCM_FORMAT_S32_BE) < 0)
#endif
{
/* Soundcard supports no 32-bit, try 24
(more probably supported but needs conversion) */
#ifndef WORDS_BIGENDIAN
if(snd_pcm_hw_params_set_format(ret, hw_params, SND_PCM_FORMAT_S24_3LE) < 0)
#else
if(snd_pcm_hw_params_set_format(ret, hw_params, SND_PCM_FORMAT_S24_3BE) < 0)
#endif
{
/* No 24 bit, try 16 */
if(snd_pcm_hw_params_set_format(ret, hw_params, SND_PCM_FORMAT_S16) < 0)
{
/* Hopeless */
bg_log(BG_LOG_ERROR, LOG_DOMAIN, "snd_pcm_hw_params_set_format failed");
goto fail;
}
else
format->sample_format = GAVL_SAMPLE_S16;
}
else
{
format->sample_format = GAVL_SAMPLE_S32;
if(convert_4_3)
*convert_4_3 = 1;
}
}
else
format->sample_format = GAVL_SAMPLE_S32;
}
else
format->sample_format = GAVL_SAMPLE_FLOAT;
break;
case GAVL_SAMPLE_NONE:
goto fail;
break;
}
/* Channels */
if(snd_pcm_hw_params_set_channels(ret, hw_params,
format->num_channels) < 0)
{
if(format->num_channels == 1) /* Mono doesn't work, try stereo */
{
if(snd_pcm_hw_params_set_channels(ret, hw_params,
2) < 0)
{
bg_log(BG_LOG_ERROR, LOG_DOMAIN,
"snd_pcm_hw_params_set_channels failed (Format has %d channels)",
format->num_channels);
goto fail;
}
else
{
format->num_channels = 2;
format->channel_locations[0] = GAVL_CHID_FRONT_LEFT;
format->channel_locations[1] = GAVL_CHID_FRONT_RIGHT;
}
}
else
{
bg_log(BG_LOG_ERROR, LOG_DOMAIN,
"snd_pcm_hw_params_set_channels failed (Format has %d channels)",
format->num_channels);
goto fail;
}
}
/* Switch off driver side resampling */
#if SND_LIB_VERSION >= 0x010009
snd_pcm_hw_params_set_rate_resample(ret, hw_params, 0);
#endif
/* Samplerate */
i_tmp = format->samplerate;
if(snd_pcm_hw_params_set_rate_near(ret, hw_params,
&i_tmp,
0) < 0)
{
bg_log(BG_LOG_ERROR, LOG_DOMAIN, "snd_pcm_hw_params_set_rate_near failed");
goto fail;
}
if(format->samplerate != i_tmp)
{
bg_log(BG_LOG_INFO, LOG_DOMAIN,
"Samplerate %d not supported by device %s, using %d",
format->samplerate, card, i_tmp);
}
format->samplerate = i_tmp;
dir = 0;
/* Buffer size */
snd_pcm_hw_params_get_buffer_size_min(hw_params, &buffer_size_min);
snd_pcm_hw_params_get_buffer_size_max(hw_params, &buffer_size_max);
dir=0;
snd_pcm_hw_params_get_period_size_min(hw_params, &period_size_min,&dir);
dir=0;
snd_pcm_hw_params_get_period_size_max(hw_params, &period_size_max,&dir);
buffer_size = gavl_time_to_samples(format->samplerate, buffer_time);
if(buffer_size > buffer_size_max)
buffer_size = buffer_size_max;
if(buffer_size < buffer_size_min)
buffer_size = buffer_size_min;
period_size = buffer_size / 8;
buffer_size = period_size * 8;
dir = 0;
if(snd_pcm_hw_params_set_period_size_near(ret, hw_params, &period_size, &dir) < 0)
{
bg_log(BG_LOG_ERROR, LOG_DOMAIN, "snd_pcm_hw_params_set_period_size failed");
goto fail;
}
dir = 0;
snd_pcm_hw_params_get_period_size(hw_params, &period_size, &dir);
dir = 0;
if(snd_pcm_hw_params_set_buffer_size_near(ret, hw_params, &buffer_size) < 0)
{
bg_log(BG_LOG_ERROR, LOG_DOMAIN, "snd_pcm_hw_params_set_buffer_size failed");
goto fail;
}
snd_pcm_hw_params_get_buffer_size(hw_params, &buffer_size);
format->samples_per_frame = period_size;
/* Write params to card */
if(snd_pcm_hw_params (ret, hw_params) < 0)
{
bg_log(BG_LOG_ERROR, LOG_DOMAIN, "snd_pcm_hw_params failed");
goto fail;
}
snd_pcm_hw_params_free(hw_params);
gavl_set_channel_setup(format);
// gavl_audio_format_dump(format);
return ret;
fail:
bg_log(BG_LOG_ERROR, LOG_DOMAIN, "Alsa initialization failed");
if(ret)
snd_pcm_close(ret);
if(hw_params)
snd_pcm_hw_params_free(hw_params);
return NULL;
}
static void *alsa_init(const char *device, unsigned rate, unsigned latency)
{
snd_pcm_format_t format;
snd_pcm_uframes_t buffer_size;
snd_pcm_hw_params_t *params = NULL;
snd_pcm_sw_params_t *sw_params = NULL;
unsigned latency_usec = latency * 1000;
unsigned channels = 2;
unsigned periods = 4;
const char *alsa_dev = "default";
alsa_t *alsa = (alsa_t*)calloc(1, sizeof(alsa_t));
if (!alsa)
return NULL;
if (device)
alsa_dev = device;
TRY_ALSA(snd_pcm_open(
&alsa->pcm, alsa_dev, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK));
TRY_ALSA(snd_pcm_hw_params_malloc(¶ms));
alsa->has_float = find_float_format(alsa->pcm, params);
format = alsa->has_float ? SND_PCM_FORMAT_FLOAT : SND_PCM_FORMAT_S16;
TRY_ALSA(snd_pcm_hw_params_any(alsa->pcm, params));
TRY_ALSA(snd_pcm_hw_params_set_access(
alsa->pcm, params, SND_PCM_ACCESS_RW_INTERLEAVED));
TRY_ALSA(snd_pcm_hw_params_set_format(alsa->pcm, params, format));
TRY_ALSA(snd_pcm_hw_params_set_channels(alsa->pcm, params, channels));
TRY_ALSA(snd_pcm_hw_params_set_rate(alsa->pcm, params, rate, 0));
TRY_ALSA(snd_pcm_hw_params_set_buffer_time_near(
alsa->pcm, params, &latency_usec, NULL));
TRY_ALSA(snd_pcm_hw_params_set_periods_near(
alsa->pcm, params, &periods, NULL));
TRY_ALSA(snd_pcm_hw_params(alsa->pcm, params));
/* Shouldn't have to bother with this,
* but some drivers are apparently broken. */
if (snd_pcm_hw_params_get_period_size(params, &buffer_size, NULL))
snd_pcm_hw_params_get_period_size_min(params, &buffer_size, NULL);
RARCH_LOG("ALSA: Period size: %d frames\n", (int)buffer_size);
if (snd_pcm_hw_params_get_buffer_size(params, &buffer_size))
snd_pcm_hw_params_get_buffer_size_max(params, &buffer_size);
RARCH_LOG("ALSA: Buffer size: %d frames\n", (int)buffer_size);
alsa->buffer_size = snd_pcm_frames_to_bytes(alsa->pcm, buffer_size);
alsa->can_pause = snd_pcm_hw_params_can_pause(params);
RARCH_LOG("ALSA: Can pause: %s.\n", alsa->can_pause ? "yes" : "no");
TRY_ALSA(snd_pcm_sw_params_malloc(&sw_params));
TRY_ALSA(snd_pcm_sw_params_current(alsa->pcm, sw_params));
TRY_ALSA(snd_pcm_sw_params_set_start_threshold(
alsa->pcm, sw_params, buffer_size / 2));
TRY_ALSA(snd_pcm_sw_params(alsa->pcm, sw_params));
snd_pcm_hw_params_free(params);
snd_pcm_sw_params_free(sw_params);
return alsa;
error:
RARCH_ERR("ALSA: Failed to initialize...\n");
if (params)
snd_pcm_hw_params_free(params);
if (sw_params)
snd_pcm_sw_params_free(sw_params);
if (alsa)
{
if (alsa->pcm)
snd_pcm_close(alsa->pcm);
free(alsa);
}
return NULL;
}
