optional<int> AudioOutputDeviceAlsa::ParameterFragmentSize::RangeMinAsInt(std::map<String,String> Parameters) {
if (!Parameters.count("CARD")) return optional<int>::nothing;
// obtain information from given sound card
String pcm_name = "hw:" + Parameters["CARD"];
snd_pcm_t* pcm_handle = NULL;
if (snd_pcm_open(&pcm_handle, pcm_name.c_str(), SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK) < 0) return optional<int>::nothing;
snd_pcm_hw_params_t* hwparams;
snd_pcm_hw_params_alloca(&hwparams);
if (snd_pcm_hw_params_any(pcm_handle, hwparams) < 0) {
snd_pcm_close(pcm_handle);
return optional<int>::nothing;
}
int dir = 0;
unsigned long period_size_min;
if (snd_pcm_hw_params_get_period_size_min(hwparams, &period_size_min, &dir) < 0) {
snd_pcm_close(pcm_handle);
return optional<int>::nothing;
}
snd_pcm_close(pcm_handle);
return (int) period_size_min;
}
static int drvHostALSAAudioOpen(bool fIn,
PALSAAUDIOSTREAMCFG pCfgReq,
PALSAAUDIOSTREAMCFG pCfgObt,
snd_pcm_t **pphPCM)
{
snd_pcm_t *phPCM = NULL;
int rc;
unsigned int cChannels = pCfgReq->nchannels;
unsigned int uFreq = pCfgReq->freq;
snd_pcm_uframes_t obt_buffer_size;
do
{
const char *pszDev = fIn ? s_ALSAConf.pcm_name_in : s_ALSAConf.pcm_name_out;
if (!pszDev)
{
LogRel(("ALSA: Invalid or no %s device name set\n",
fIn ? "input" : "output"));
rc = VERR_INVALID_PARAMETER;
break;
}
int err = snd_pcm_open(&phPCM, pszDev,
fIn ? SND_PCM_STREAM_CAPTURE : SND_PCM_STREAM_PLAYBACK,
SND_PCM_NONBLOCK);
if (err < 0)
{
LogRel(("ALSA: Failed to open \"%s\" as %s: %s\n", pszDev,
fIn ? "ADC" : "DAC", snd_strerror(err)));
rc = VERR_GENERAL_FAILURE; /** @todo Find a better rc. */
break;
}
snd_pcm_hw_params_t *pHWParms;
snd_pcm_hw_params_alloca(&pHWParms); /** @todo Check for successful allocation? */
err = snd_pcm_hw_params_any(phPCM, pHWParms);
if (err < 0)
{
LogRel(("ALSA: Failed to initialize hardware parameters: %s\n",
snd_strerror(err)));
rc = VERR_GENERAL_FAILURE; /** @todo Find a better rc. */
break;
}
err = snd_pcm_hw_params_set_access(phPCM, pHWParms,
SND_PCM_ACCESS_RW_INTERLEAVED);
if (err < 0)
{
LogRel(("ALSA: Failed to set access type: %s\n", snd_strerror(err)));
rc = VERR_GENERAL_FAILURE; /** @todo Find a better rc. */
break;
}
err = snd_pcm_hw_params_set_format(phPCM, pHWParms, pCfgReq->fmt);
if (err < 0)
{
LogRel(("ALSA: Failed to set audio format to %d: %s\n",
pCfgReq->fmt, snd_strerror(err)));
rc = VERR_GENERAL_FAILURE; /** @todo Find a better rc. */
break;
}
err = snd_pcm_hw_params_set_rate_near(phPCM, pHWParms, &uFreq, 0);
if (err < 0)
{
LogRel(("ALSA: Failed to set frequency to %dHz: %s\n",
pCfgReq->freq, snd_strerror(err)));
rc = VERR_GENERAL_FAILURE; /** @todo Find a better rc. */
break;
}
err = snd_pcm_hw_params_set_channels_near(phPCM, pHWParms, &cChannels);
if (err < 0)
{
LogRel(("ALSA: Failed to set number of channels to %d\n", pCfgReq->nchannels));
rc = VERR_GENERAL_FAILURE; /** @todo Find a better rc. */
break;
}
if ( cChannels != 1
&& cChannels != 2)
{
LogRel(("ALSA: Number of audio channels (%u) not supported\n", cChannels));
rc = VERR_GENERAL_FAILURE; /** @todo Find a better rc. */
break;
}
unsigned int period_size = pCfgReq->period_size;
unsigned int buffer_size = pCfgReq->buffer_size;
if ( !((fIn && s_ALSAConf.size_in_usec_in)
|| (!fIn && s_ALSAConf.size_in_usec_out)))
{
if (!buffer_size)
{
buffer_size = DEFAULT_BUFFER_SIZE;
period_size = DEFAULT_PERIOD_SIZE;
}
}
if (buffer_size)
{
if ( ( fIn && s_ALSAConf.size_in_usec_in)
|| (!fIn && s_ALSAConf.size_in_usec_out))
{
if (period_size)
{
err = snd_pcm_hw_params_set_period_time_near(phPCM, pHWParms,
&period_size, 0);
if (err < 0)
{
LogRel(("ALSA: Failed to set period time %d\n", pCfgReq->period_size));
rc = VERR_GENERAL_FAILURE; /** @todo Find a better rc. */
break;
}
}
err = snd_pcm_hw_params_set_buffer_time_near(phPCM, pHWParms,
&buffer_size, 0);
if (err < 0)
{
LogRel(("ALSA: Failed to set buffer time %d\n", pCfgReq->buffer_size));
rc = VERR_GENERAL_FAILURE; /** @todo Find a better rc. */
break;
}
}
else
{
snd_pcm_uframes_t period_size_f = (snd_pcm_uframes_t)period_size;
snd_pcm_uframes_t buffer_size_f = (snd_pcm_uframes_t)buffer_size;
snd_pcm_uframes_t minval;
if (period_size_f)
{
minval = period_size_f;
int dir = 0;
err = snd_pcm_hw_params_get_period_size_min(pHWParms,
&minval, &dir);
if (err < 0)
{
LogRel(("ALSA: Could not determine minimal period size\n"));
rc = VERR_GENERAL_FAILURE; /** @todo Find a better rc. */
break;
}
else
{
LogFunc(("Minimal period size is: %ld\n", minval));
if (period_size_f < minval)
{
if ( ( fIn && s_ALSAConf.period_size_in_overriden)
|| (!fIn && s_ALSAConf.period_size_out_overriden))
{
LogFunc(("Period size %RU32 is less than minimal period size %RU32\n",
period_size_f, minval));
}
period_size_f = minval;
}
}
err = snd_pcm_hw_params_set_period_size_near(phPCM, pHWParms,
&period_size_f, 0);
LogFunc(("Period size is: %RU32\n", period_size_f));
if (err < 0)
{
LogRel(("ALSA: Failed to set period size %d (%s)\n",
period_size_f, snd_strerror(err)));
rc = VERR_GENERAL_FAILURE; /** @todo Find a better rc. */
break;
}
}
/* Calculate default buffer size here since it might have been changed
* in the _near functions */
buffer_size_f = 4 * period_size_f;
minval = buffer_size_f;
err = snd_pcm_hw_params_get_buffer_size_min(pHWParms, &minval);
if (err < 0)
{
LogRel(("ALSA: Could not retrieve minimal buffer size\n"));
rc = VERR_GENERAL_FAILURE; /** @todo Find a better rc. */
break;
}
else
{
LogFunc(("Minimal buffer size is: %RU32\n", minval));
if (buffer_size_f < minval)
{
if ( ( fIn && s_ALSAConf.buffer_size_in_overriden)
|| (!fIn && s_ALSAConf.buffer_size_out_overriden))
{
LogFunc(("Buffer size %RU32 is less than minimal buffer size %RU32\n",
buffer_size_f, minval));
}
buffer_size_f = minval;
}
}
err = snd_pcm_hw_params_set_buffer_size_near(phPCM,
pHWParms, &buffer_size_f);
LogFunc(("Buffer size is: %RU32\n", buffer_size_f));
if (err < 0)
{
LogRel(("ALSA: Failed to set buffer size %d: %s\n",
buffer_size_f, snd_strerror(err)));
rc = VERR_GENERAL_FAILURE; /** @todo Find a better rc. */
break;
}
}
}
else
LogFunc(("Warning: Buffer size is not set\n"));
err = snd_pcm_hw_params(phPCM, pHWParms);
if (err < 0)
{
LogRel(("ALSA: Failed to apply audio parameters\n"));
rc = VERR_GENERAL_FAILURE; /** @todo Find a better rc. */
break;
}
err = snd_pcm_hw_params_get_buffer_size(pHWParms, &obt_buffer_size);
if (err < 0)
{
LogRel(("ALSA: Failed to get buffer size\n"));
rc = VERR_GENERAL_FAILURE; /** @todo Find a better rc. */
break;
}
snd_pcm_uframes_t obt_period_size;
int dir = 0;
err = snd_pcm_hw_params_get_period_size(pHWParms, &obt_period_size, &dir);
if (err < 0)
{
LogRel(("ALSA: Failed to get period size\n"));
rc = VERR_GENERAL_FAILURE; /** @todo Find a better rc. */
break;
}
LogFunc(("Freq=%dHz, period size=%RU32, buffer size=%RU32\n",
pCfgReq->freq, obt_period_size, obt_buffer_size));
err = snd_pcm_prepare(phPCM);
if (err < 0)
{
LogRel(("ALSA: Could not prepare hPCM %p\n", (void *)phPCM));
rc = VERR_GENERAL_FAILURE; /** @todo Find a better rc. */
break;
}
if ( !fIn
&& s_ALSAConf.threshold)
{
unsigned uShift;
rc = drvHostALSAAudioALSAGetShift(pCfgReq->fmt, &uShift);
if (RT_SUCCESS(rc))
{
int bytes_per_sec = uFreq
<< (cChannels == 2)
<< uShift;
snd_pcm_uframes_t threshold
= (s_ALSAConf.threshold * bytes_per_sec) / 1000;
rc = drvHostALSAAudioSetThreshold(phPCM, threshold);
}
}
else
rc = VINF_SUCCESS;
}
while (0);
if (RT_SUCCESS(rc))
{
pCfgObt->fmt = pCfgReq->fmt;
pCfgObt->nchannels = cChannels;
pCfgObt->freq = uFreq;
pCfgObt->samples = obt_buffer_size;
*pphPCM = phPCM;
}
else
drvHostALSAAudioClose(&phPCM);
LogFlowFuncLeaveRC(rc);
return rc;
}
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;
}
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;
}
static void
check_period_sizes (alsa_driver *d)
{
/* Almost everything (luckily except sampling frequency) can affect period size: buffer size,
format, channel numbers... So we need to recheck it after at least one of the parameters is
changed -- mutab0r */
gint err;
guint address = PARAMS_TO_ADDRESS(d);
/* The procedure is time-consuming and may cause audio system lock. So be sure if we really
need it before starting... -- mutab0r */
if(d->bits == 0)
return;
if((address == d->address_old) && (d->buffer_size == d->bufsize_old))
return;
if(pcm_open_and_load_hwparams(d) < 0)
return;
if((err = snd_pcm_hw_params_set_format(d->soundfd, d->hwparams,
(d->bits - 8) ? d->signedness16 ? SND_PCM_FORMAT_S16 : SND_PCM_FORMAT_U16 :
d->signedness8 ? SND_PCM_FORMAT_S8 : SND_PCM_FORMAT_U8)) < 0) {
alsa_error(N_("Unable to set audio format"), err);
snd_pcm_close(d->soundfd);
return;
}
if((err = snd_pcm_hw_params_set_channels(d->soundfd, d->hwparams, d->stereo + 1)) < 0) {
alsa_error(N_("Unable to set channels number"), err);
snd_pcm_close(d->soundfd);
return;
}
if(snd_pcm_hw_params_set_buffer_size(d->soundfd, d->hwparams, 1 << d->buffer_size) < 0) {
/* Some soundcards report wrong maximal buffer size (maybe alsa bug). So we should try
to downscale its value before the reporting an error. The spinbutton still may display
the wrong number, but actually the correct value will be implemented.*/
while((--d->buffer_size) >= 8)
if(!snd_pcm_hw_params_set_buffer_size(d->soundfd, d->hwparams, 1 << d->buffer_size))
break;
if(d->buffer_size < 8) {
error_error(N_("Unable to set appropriate buffer size"));
snd_pcm_close(d->soundfd);
return;
}
}
snd_pcm_close(d->soundfd);
if ((err = snd_pcm_hw_params_get_period_size_min(d->hwparams, &(d->persizemin), 0)) < 0) {
alsa_error(N_("Unable to get minimal period size"), err);
return;
}
if ((err = snd_pcm_hw_params_get_period_size_max(d->hwparams, &(d->persizemax), 0)) < 0) {
alsa_error(N_("Unable to get maximal period size"), err);
return;
}
update_periods_range(d);
update_estimate(d);
d->address_old = address;
d->bufsize_old = d->buffer_size;
}
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;
}
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);
}
int setup_pcmdev(char *pcm_name)
{
snd_pcm_hw_params_t *params;
snd_pcm_stream_t stream = SND_PCM_STREAM_PLAYBACK;
int rate = 44100, dir;
snd_pcm_uframes_t persize, persize2;
int maxrate, minrate;
unsigned int pertime, perTmin, perTmax;
snd_pcm_uframes_t bufsize, perSmin, perSmax, bufSmin, bufSmax;
/* Allocate the snd_pcm_hw_params_t structure on the stack. */
snd_pcm_hw_params_alloca(¶ms);
/* Open PCM device for playback. */
if (snd_pcm_open(&handle, pcm_name, stream, 0) < 0) {
fprintf(stderr, "Error opening PCM device %s\n", pcm_name);
return(-1);
}
/* Init params with full configuration space */
if (snd_pcm_hw_params_any(handle, params) < 0) {
fprintf(stderr, "Can not configure this PCM device.\n");
return(-1);
}
/* set interleaved mode */
if (snd_pcm_hw_params_set_access(handle, params, SND_PCM_ACCESS_RW_INTERLEAVED) < 0) {
fprintf(stderr, "Error setting access.\n");
return(-1);
}
/* Set sample format */
if (snd_pcm_hw_params_set_format(handle, params, SND_PCM_FORMAT_S16_LE) < 0) {
fprintf(stderr, "Error setting format.\n");
return(-1);
}
/* Set sample rate.*/
if (snd_pcm_hw_params_set_rate_near(handle, params, &rate, 0) < 0) {
fprintf(stderr, "Error setting rate.\n");
return(-1);
}
/* Set number of channels */
if (snd_pcm_hw_params_set_channels(handle, params, nchan) < 0) {
fprintf(stderr, "Error setting channels.\n");
return(-1);
}
/* Set period size to n frames (samples). */
persize = 1024; dir=0;
if (snd_pcm_hw_params_set_period_size_near(handle,params, &persize, &dir)< 0) {
fprintf(stderr, "Error setting period size to %d.\n", (int) persize);
return(-1);
}
/* Apply HW parameter settings to PCM device */
if (snd_pcm_hw_params(handle, params) < 0) {
fprintf(stderr, "Error setting HW params.\n");
return(-1);
}
/*get some inof about the hardware*/
// printf("\n ---------- hardware parameters ------------ \n");
snd_pcm_hw_params_get_rate_min (params, &minrate, &dir);
//printf("min rate: %d samples per sec\n",minrate);
snd_pcm_hw_params_get_rate_max (params, &maxrate, &dir);
//printf("max rate: %d samples per sec\n",maxrate);
snd_pcm_hw_params_get_period_time (params, &pertime, &dir);
//printf("period: %d microseconds\n",pertime);
snd_pcm_hw_params_get_period_time_min (params, &perTmin, &dir);
snd_pcm_hw_params_get_period_time_min (params, &perTmax, &dir);
//printf("min period time: %d microseconds\n",perTmin);
//printf("max period time: %d microseconds\n",perTmax);
snd_pcm_hw_params_get_period_size (params, &persize2, &dir);
//printf("period: %d frames\n",(int) persize2);
snd_pcm_hw_params_get_period_size_min (params, &perSmin, &dir);
snd_pcm_hw_params_get_period_size_min (params, &perSmax, &dir);
//printf("min period size: %d frames\n",(int) perSmin);
//printf("max period size: %d frames\n",(int) perSmax);
snd_pcm_hw_params_get_buffer_size (params, &bufsize);
//printf("buffer size: %d frames\n",(int) bufsize);
snd_pcm_hw_params_get_buffer_size_min (params, &bufSmin);
snd_pcm_hw_params_get_buffer_size_min (params, &bufSmax);
//printf("min buffer size: %d frames\n",(int) bufSmin);
//printf("max buffer size: %d frames\n",(int) bufSmax);
return (double) persize2;
}
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;
}
/**************************************************************************
* 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;
}
/**
* 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)
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;
}
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
}
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 CAESinkALSA::InitializeHW(const ALSAConfig &inconfig, ALSAConfig &outconfig)
{
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 = inconfig.sampleRate;
unsigned int channelCount = inconfig.channels;
#if defined(HAS_AMLPLAYER) || defined(HAS_LIBAMCODEC)
// alsa/kernel lies, so map everything to 44100 or 48000
switch(sampleRate)
{
case 11025:
case 22050:
case 88200:
case 176400:
sampleRate = 44100;
break;
case 8000:
case 16000:
case 24000:
case 32000:
case 96000:
case 192000:
case 384000:
sampleRate = 48000;
break;
}
#endif
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 (inconfig.channels > channelCount)
{
CLog::Log(LOGINFO, "CAESinkALSA::InitializeHW - Unable to open the required number of channels");
}
/* update outconfig */
outconfig.channels = channelCount;
snd_pcm_format_t fmt = AEFormatToALSAFormat(inconfig.format);
outconfig.format = inconfig.format;
if (fmt == SND_PCM_FORMAT_UNKNOWN)
{
/* if we dont support the requested format, fallback to float */
fmt = SND_PCM_FORMAT_FLOAT;
outconfig.format = AE_FMT_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(outconfig.format));
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 */
outconfig.format = i;
CLog::Log(LOGINFO, "CAESinkALSA::InitializeHW - Using data format %s", CAEUtil::DataFormatToStr(outconfig.format));
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_periods_min(hw_params, &periods, NULL);
snd_pcm_hw_params_get_period_size_min(hw_params, &periodSize, NULL);
snd_pcm_hw_params_get_buffer_size_min(hw_params, &bufferSize);
CLog::Log(LOGDEBUG, "CAESinkALSA::InitializeHW - Min: periodSize %lu, periods %u, bufferSize %lu", periodSize, periods, bufferSize);
snd_pcm_hw_params_get_periods_max(hw_params, &periods, NULL);
snd_pcm_hw_params_get_period_size_max(hw_params, &periodSize, NULL);
snd_pcm_hw_params_get_buffer_size_max(hw_params, &bufferSize);
CLog::Log(LOGDEBUG, "CAESinkALSA::InitializeHW - Max: periodSize %lu, periods %u, bufferSize %lu", periodSize, periods, 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);
#if defined(HAS_AMLPLAYER) || defined(HAS_LIBAMCODEC)
// must be pot for pivos.
bufferSize = CheckNP2(bufferSize);
#endif
/*
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);
#if defined(HAS_AMLPLAYER) || defined(HAS_LIBAMCODEC)
// must be pot for pivos.
periodSize = CheckNP2(periodSize);
#endif
bufferSize = std::min(bufferSize, (snd_pcm_uframes_t)8192);
periodSize = bufferSize / ALSA_PERIODS;
periods = ALSA_PERIODS;
CLog::Log(LOGDEBUG, "CAESinkALSA::InitializeHW - Req: periodSize %lu, periods %u, bufferSize %lu", periodSize, periods, 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 */
outconfig.sampleRate = sampleRate;
outconfig.periodSize = periodSize;
outconfig.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 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;
}
TErrors SalsaStream::updateSettings(llaAudioPipe& buffer) {
refreshState();
llaAudioPipe::TSampleOrg org;
int err;
// the real buffer size is twice the size of the required latency in frames
snd_pcm_uframes_t sndframes = buffer.getBufferLength();
sndframes = sndframes < REAL_BUFFER_SIZE_MIN ? REAL_BUFFER_SIZE_MIN: sndframes ;
snd_pcm_access_t acc_required;
TSampleFormat format;
if(direction_ == INPUT_STREAM) { format = buffer.getInputBuffer().formatRequested; }
else { format = buffer.getOutputBuffer().formatRequested; }
snd_pcm_format_t sndformat = lla2alsaFormat(format);
switch(pcm_state_) {
case CLOSED:
return E_OK;
case OPENED: // set and write parameters if they changed since last setup
// initial params
snd_pcm_hw_params_alloca(&hw_config_);
snd_pcm_hw_params_any(pcm_, hw_config_);
// /////////////////////////////////////////////////////////////////////
// set buffer organization: interleaved/non_interleaved
// The llaAudioBuffer object's setting has priority
if(direction_ == INPUT_STREAM)
org = buffer.getInputBuffer().organizationRequested;
else
org = buffer.getOutputBuffer().organizationRequested;
acc_required = (org == llaAudioPipe::INTERLEAVED)?
SND_PCM_ACCESS_RW_INTERLEAVED:SND_PCM_ACCESS_RW_NONINTERLEAVED;
err = snd_pcm_hw_params_set_access(pcm_, hw_config_,
acc_required);
if(err ) {
// cannot set required access mode, hmm hmm, try to convert
// the buffer data organization or update buffer organization if
// this is an input stream
acc_required = (acc_required==SND_PCM_ACCESS_RW_NONINTERLEAVED)?
SND_PCM_ACCESS_RW_INTERLEAVED:SND_PCM_ACCESS_RW_NONINTERLEAVED;
err = snd_pcm_hw_params_set_access(pcm_, hw_config_,
acc_required);
CHECK_SNDERROR(err, E_STREAM_CONFIG);
llaAudioPipe::TSampleOrg org_required =
(acc_required==SND_PCM_ACCESS_RW_NONINTERLEAVED)?
llaAudioPipe::NON_INTERLEAVED:llaAudioPipe::INTERLEAVED;
if(direction_ == INPUT_STREAM) {
buffer.getInputBuffer().organizationRequested = org_required;
} else {
//buffer.getOutputBuffer().convertOrganization(org_required);
buffer.getOutputBuffer().organizationRequested = org_required;
}
}
organization_ = acc_required;
// /////////////////////////////////////////////////////////////////////
// Sample format base is the buffer object's format with conversion to
// a suitable alternative form the engine
err = snd_pcm_hw_params_set_format(pcm_, hw_config_, sndformat);
if(err) {
// TODO find a format supported by the engine and convert the
// buffer data if this is an output stream, but for now
// set the closest format to required and set the buffer to this
if(format.isFloating()) {
if( format.getBits() <= 32 ) {
// set something signed 16
sndformat = SND_PCM_FORMAT_S16;
err = snd_pcm_hw_params_set_format(pcm_, hw_config_,
sndformat);
if(direction_ == INPUT_STREAM) {
buffer.getInputBuffer().formatRequested = llaAudioPipe::FORMAT_S16;
}
else {
buffer.getOutputBuffer().formatRequested = llaAudioPipe::FORMAT_S16;
}
}
else {
sndformat = SND_PCM_FORMAT_S32;
err = snd_pcm_hw_params_set_format(pcm_, hw_config_,
sndformat);
if(direction_ == INPUT_STREAM) {
buffer.getInputBuffer().formatRequested = llaAudioPipe::FORMAT_S32;
}
else {
buffer.getOutputBuffer().formatRequested = llaAudioPipe::FORMAT_S32;
}
}
CHECK_SNDERROR(err, E_STREAM_CONFIG);
}
if(err) {
LOGGER().warning(E_BUFFER_DISMATCH, "Pcm format not supported");
CHECK_SNDERROR(err, E_STREAM_CONFIG);
}
}
else {
format_ = sndformat;
}
// /////////////////////////////////////////////////////////////////////
// set buffer's channel number: the stream's configuration has priority,
// the buffer is up-mixed or down-mixed by it's methods
if(direction_ == OUTPUT_STREAM) {
if(buffer.getOutputBuffer().channelsRequested != channels_) {
buffer.getOutputBuffer().changeChannelCount(channels_);
}
} else {
if(buffer.getInputBuffer().channelsRequested != channels_) {
buffer.getInputBuffer().channelsRequested = channels_;
}
}
// set buffer size /////////////////////////////////////////////////////
if(buffer_size_ != sndframes) {
err = snd_pcm_hw_params_set_buffer_size_near(pcm_, hw_config_,
&sndframes);
CHECK_SNDERROR(err, E_STREAM_CONFIG);
buffer_size_ = sndframes;
}
err = snd_pcm_hw_params_get_period_size_min(hw_config_, &sndframes, 0);
CHECK_SNDERROR(err, E_STREAM_CONFIG);
// char num[10];
// sprintf(num, "%ld", sndframes);
// LOGGER().log(num);
err = snd_pcm_hw_params_set_period_size_near(pcm_, hw_config_,
&sndframes, NULL);
CHECK_SNDERROR(err, E_STREAM_CONFIG);
period_size_ = sndframes;
// write settings //////////////////////////////////////////////////////
if(direction_ == INPUT_STREAM) buffer.getInputBuffer().alloc();
else buffer.getOutputBuffer().alloc();
snd_pcm_hw_params(pcm_, hw_config_);
pcm_state_ = SETUP;
snd_pcm_prepare(pcm_);
break;
case RUNNING:
break;
case SETUP:
// TODO check and renew settings
break;
case XRUN:
snd_pcm_prepare(pcm_);
break;
};
return E_OK;
}
