snd_pcm_t *open_pcm(char *pcm_name) {
snd_pcm_t *playback_handle;
snd_pcm_hw_params_t *hw_params;
snd_pcm_sw_params_t *sw_params;
if (snd_pcm_open (&playback_handle, pcm_name, SND_PCM_STREAM_PLAYBACK, 0) < 0) {
fprintf (stderr, "cannot open audio device %s\n", pcm_name);
exit (1);
}
snd_pcm_hw_params_alloca(&hw_params);
snd_pcm_hw_params_any(playback_handle, hw_params);
snd_pcm_hw_params_set_access(playback_handle, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED);
snd_pcm_hw_params_set_format(playback_handle, hw_params, SND_PCM_FORMAT_S16_LE);
snd_pcm_hw_params_set_rate_near(playback_handle, hw_params, 44100, 0);
snd_pcm_hw_params_set_channels(playback_handle, hw_params, 2);
snd_pcm_hw_params_set_periods(playback_handle, hw_params, 2, 0);
snd_pcm_hw_params_set_period_size(playback_handle, hw_params, BUFSIZE, 0);
snd_pcm_hw_params(playback_handle, hw_params);
snd_pcm_sw_params_alloca(&sw_params);
snd_pcm_sw_params_current(playback_handle, sw_params);
snd_pcm_sw_params_set_avail_min(playback_handle, sw_params, BUFSIZE);
snd_pcm_sw_params(playback_handle, sw_params);
return(playback_handle);
}
static int snd_pcm_ioctl_sw_params_compat(struct snd_pcm_substream *substream,
struct snd_pcm_sw_params32 __user *src)
{
struct snd_pcm_sw_params params;
snd_pcm_uframes_t boundary;
int err;
memset(¶ms, 0, sizeof(params));
if (get_user(params.tstamp_mode, &src->tstamp_mode) ||
get_user(params.period_step, &src->period_step) ||
get_user(params.sleep_min, &src->sleep_min) ||
get_user(params.avail_min, &src->avail_min) ||
get_user(params.xfer_align, &src->xfer_align) ||
get_user(params.start_threshold, &src->start_threshold) ||
get_user(params.stop_threshold, &src->stop_threshold) ||
get_user(params.silence_threshold, &src->silence_threshold) ||
get_user(params.silence_size, &src->silence_size))
return -EFAULT;
/*
* Check silent_size parameter. Since we have 64bit boundary,
* silence_size must be compared with the 32bit boundary.
*/
boundary = recalculate_boundary(substream->runtime);
if (boundary && params.silence_size >= boundary)
params.silence_size = substream->runtime->boundary;
err = snd_pcm_sw_params(substream, ¶ms);
if (err < 0)
return err;
if (boundary && put_user(boundary, &src->boundary))
return -EFAULT;
return err;
}
// returns 1 if successful
int setSWParams(AlsaPcmInfo* info) {
int ret;
/* get the current swparams */
ret = snd_pcm_sw_params_current(info->handle, info->swParams);
if (ret < 0) {
ERROR1("Unable to determine current swparams: %s\n", snd_strerror(ret));
return FALSE;
}
/* never start the transfer automatically */
if (!setStartThresholdNoCommit(info, FALSE /* don't use threshold */)) {
return FALSE;
}
/* allow the transfer when at least period_size samples can be processed */
ret = snd_pcm_sw_params_set_avail_min(info->handle, info->swParams, info->periodSize);
if (ret < 0) {
ERROR1("Unable to set avail min for playback: %s\n", snd_strerror(ret));
return FALSE;
}
/* align all transfers to 1 sample */
ret = snd_pcm_sw_params_set_xfer_align(info->handle, info->swParams, 1);
if (ret < 0) {
ERROR1("Unable to set transfer align: %s\n", snd_strerror(ret));
return FALSE;
}
/* write the parameters to the playback device */
ret = snd_pcm_sw_params(info->handle, info->swParams);
if (ret < 0) {
ERROR1("Unable to set sw params: %s\n", snd_strerror(ret));
return FALSE;
}
return TRUE;
}
static void alsa_set_sw_params(struct alsa_dev *dev, snd_pcm_t *handle,
int period, int thres)
{
int ret;
snd_pcm_sw_params_t *sw_params;
ret = snd_pcm_sw_params_malloc(&sw_params);
if (ret < 0)
syslog_panic("Cannot allocate software parameters: %s\n",
snd_strerror(ret));
ret = snd_pcm_sw_params_current(handle, sw_params);
if (ret < 0)
syslog_panic("Cannot initialize software parameters: %s\n",
snd_strerror(ret));
ret = snd_pcm_sw_params_set_avail_min(handle, sw_params, period);
if (ret < 0)
syslog_panic("Cannot set minimum available count: %s\n",
snd_strerror(ret));
if (thres) {
ret = snd_pcm_sw_params_set_start_threshold(handle, sw_params,
period);
if (ret < 0)
syslog_panic("Cannot set start mode: %s\n",
snd_strerror(ret));
}
ret = snd_pcm_sw_params(handle, sw_params);
if (ret < 0)
syslog_panic("Cannot set software parameters: %s\n",
snd_strerror(ret));
snd_pcm_sw_params_free(sw_params);
}
static void audio_renderer_init() {
int rc;
decoder = opus_decoder_create(SAMPLE_RATE, CHANNEL_COUNT, &rc);
snd_pcm_hw_params_t *hw_params;
snd_pcm_sw_params_t *sw_params;
snd_pcm_uframes_t period_size = FRAME_SIZE * CHANNEL_COUNT * 2;
snd_pcm_uframes_t buffer_size = 12 * period_size;
unsigned int sampleRate = SAMPLE_RATE;
/* Open PCM device for playback. */
CHECK_RETURN(snd_pcm_open(&handle, audio_device, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK))
/* Set hardware parameters */
CHECK_RETURN(snd_pcm_hw_params_malloc(&hw_params));
CHECK_RETURN(snd_pcm_hw_params_any(handle, hw_params));
CHECK_RETURN(snd_pcm_hw_params_set_access(handle, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED));
CHECK_RETURN(snd_pcm_hw_params_set_format(handle, hw_params, SND_PCM_FORMAT_S16_LE));
CHECK_RETURN(snd_pcm_hw_params_set_rate_near(handle, hw_params, &sampleRate, NULL));
CHECK_RETURN(snd_pcm_hw_params_set_channels(handle, hw_params, CHANNEL_COUNT));
CHECK_RETURN(snd_pcm_hw_params_set_buffer_size_near(handle, hw_params, &buffer_size));
CHECK_RETURN(snd_pcm_hw_params_set_period_size_near(handle, hw_params, &period_size, NULL));
CHECK_RETURN(snd_pcm_hw_params(handle, hw_params));
snd_pcm_hw_params_free(hw_params);
/* Set software parameters */
CHECK_RETURN(snd_pcm_sw_params_malloc(&sw_params));
CHECK_RETURN(snd_pcm_sw_params_current(handle, sw_params));
CHECK_RETURN(snd_pcm_sw_params_set_start_threshold(handle, sw_params, buffer_size - period_size));
CHECK_RETURN(snd_pcm_sw_params_set_avail_min(handle, sw_params, period_size));
CHECK_RETURN(snd_pcm_sw_params(handle, sw_params));
snd_pcm_sw_params_free(sw_params);
CHECK_RETURN(snd_pcm_prepare(handle));
}
int set_swparams(snd_pcm_t *handle, snd_pcm_sw_params_t *swparams)
{
int err;
/* get the current swparams */
err = snd_pcm_sw_params_current(handle, swparams);
if (err < 0) {
printf("Unable to determine current swparams for playback: %s\n", snd_strerror(err));
return err;
}
/* start the transfer when the buffer is almost full: */
/* (buffer_size / avail_min) * avail_min */
//err = snd_pcm_sw_params_set_start_threshold(handle, swparams, (buffer_size / period_size) * period_size);
err = snd_pcm_sw_params_set_start_threshold(handle, swparams, period_size * periods - arnold_frame_size);
if (err < 0) {
printf("Unable to set start threshold mode for playback: %s\n", snd_strerror(err));
return err;
}
/* allow the transfer when at least period_size samples can be processed */
err = snd_pcm_sw_params_set_avail_min(handle, swparams, arnold_frame_size);
if (err < 0) {
printf("Unable to set avail min for playback: %s\n", snd_strerror(err));
return err;
}
/* write the parameters to the playback device */
err = snd_pcm_sw_params(handle, swparams);
if (err < 0) {
printf("Unable to set sw params for playback: %s\n", snd_strerror(err));
return err;
}
return 0;
}
static int set_sw_params(snd_pcm_t *pcm,
snd_pcm_sw_params_t *sw_params,
snd_spcm_xrun_type_t xrun_type)
{
int err;
err = snd_pcm_sw_params_current(pcm, sw_params);
if (err < 0)
return err;
err = snd_pcm_sw_params_set_start_threshold(pcm, sw_params, (pcm->buffer_size / pcm->period_size) * pcm->period_size);
if (err < 0)
return err;
err = snd_pcm_sw_params_set_avail_min(pcm, sw_params, pcm->period_size);
if (err < 0)
return err;
switch (xrun_type) {
case SND_SPCM_XRUN_STOP:
err = snd_pcm_sw_params_set_stop_threshold(pcm, sw_params, pcm->buffer_size);
break;
case SND_SPCM_XRUN_IGNORE:
err = snd_pcm_sw_params_set_stop_threshold(pcm, sw_params, pcm->boundary);
break;
default:
return -EINVAL;
}
if (err < 0)
return err;
err = snd_pcm_sw_params_set_xfer_align(pcm, sw_params, 1);
if (err < 0)
return err;
err = snd_pcm_sw_params(pcm, sw_params);
if (err < 0)
return err;
return 0;
}
static BOOL tsmf_alsa_set_format(ITSMFAudioDevice *audio,
UINT32 sample_rate, UINT32 channels, UINT32 bits_per_sample)
{
int error;
snd_pcm_uframes_t frames;
snd_pcm_hw_params_t *hw_params;
snd_pcm_sw_params_t *sw_params;
TSMFAlsaAudioDevice *alsa = (TSMFAlsaAudioDevice *) audio;
if(!alsa->out_handle)
return FALSE;
snd_pcm_drop(alsa->out_handle);
alsa->actual_rate = alsa->source_rate = sample_rate;
alsa->actual_channels = alsa->source_channels = channels;
alsa->bytes_per_sample = bits_per_sample / 8;
error = snd_pcm_hw_params_malloc(&hw_params);
if(error < 0)
{
WLog_ERR(TAG, "snd_pcm_hw_params_malloc failed");
return FALSE;
}
snd_pcm_hw_params_any(alsa->out_handle, hw_params);
snd_pcm_hw_params_set_access(alsa->out_handle, hw_params,
SND_PCM_ACCESS_RW_INTERLEAVED);
snd_pcm_hw_params_set_format(alsa->out_handle, hw_params,
SND_PCM_FORMAT_S16_LE);
snd_pcm_hw_params_set_rate_near(alsa->out_handle, hw_params,
&alsa->actual_rate, NULL);
snd_pcm_hw_params_set_channels_near(alsa->out_handle, hw_params,
&alsa->actual_channels);
frames = sample_rate;
snd_pcm_hw_params_set_buffer_size_near(alsa->out_handle, hw_params,
&frames);
snd_pcm_hw_params(alsa->out_handle, hw_params);
snd_pcm_hw_params_free(hw_params);
error = snd_pcm_sw_params_malloc(&sw_params);
if(error < 0)
{
WLog_ERR(TAG, "snd_pcm_sw_params_malloc");
return FALSE;
}
snd_pcm_sw_params_current(alsa->out_handle, sw_params);
snd_pcm_sw_params_set_start_threshold(alsa->out_handle, sw_params,
frames / 2);
snd_pcm_sw_params(alsa->out_handle, sw_params);
snd_pcm_sw_params_free(sw_params);
snd_pcm_prepare(alsa->out_handle);
DEBUG_TSMF("sample_rate %d channels %d bits_per_sample %d",
sample_rate, channels, bits_per_sample);
DEBUG_TSMF("hardware buffer %d frames", (int)frames);
if((alsa->actual_rate != alsa->source_rate) ||
(alsa->actual_channels != alsa->source_channels))
{
DEBUG_TSMF("actual rate %d / channel %d is different "
"from source rate %d / channel %d, resampling required.",
alsa->actual_rate, alsa->actual_channels,
alsa->source_rate, alsa->source_channels);
}
return TRUE;
}
static av_cold int audio_read_header(AVFormatContext *s1,
AVFormatParameters *ap)
{
AlsaData *s = s1->priv_data;
AVStream *st;
int ret;
enum CodecID codec_id;
snd_pcm_sw_params_t *sw_params;
st = av_new_stream(s1, 0);
if (!st) {
av_log(s1, AV_LOG_ERROR, "Cannot add stream\n");
return AVERROR(ENOMEM);
}
codec_id = s1->audio_codec_id;
ret = ff_alsa_open(s1, SND_PCM_STREAM_CAPTURE, &s->sample_rate, s->channels,
&codec_id);
if (ret < 0) {
return AVERROR(EIO);
}
if (snd_pcm_type(s->h) != SND_PCM_TYPE_HW)
av_log(s1, AV_LOG_WARNING,
"capture with some ALSA plugins, especially dsnoop, "
"may hang.\n");
ret = snd_pcm_sw_params_malloc(&sw_params);
if (ret < 0) {
av_log(s1, AV_LOG_ERROR, "cannot allocate software parameters structure (%s)\n",
snd_strerror(ret));
goto fail;
}
snd_pcm_sw_params_current(s->h, sw_params);
snd_pcm_sw_params_set_tstamp_mode(s->h, sw_params, SND_PCM_TSTAMP_ENABLE);
ret = snd_pcm_sw_params(s->h, sw_params);
snd_pcm_sw_params_free(sw_params);
if (ret < 0) {
av_log(s1, AV_LOG_ERROR, "cannot install ALSA software parameters (%s)\n",
snd_strerror(ret));
goto fail;
}
/* take real parameters */
st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_id = codec_id;
st->codec->sample_rate = s->sample_rate;
st->codec->channels = s->channels;
av_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in us */
return 0;
fail:
snd_pcm_close(s->h);
return AVERROR(EIO);
}
static int
set_params(struct alsa_device_data * alsa_data)
{
snd_pcm_hw_params_t * hw_params;
snd_pcm_sw_params_t * sw_params;
int error;
snd_pcm_uframes_t frames;
snd_pcm_drop(alsa_data->out_handle);
error = snd_pcm_hw_params_malloc(&hw_params);
if (error < 0)
{
LLOGLN(0, ("set_params: snd_pcm_hw_params_malloc failed"));
return 1;
}
snd_pcm_hw_params_any(alsa_data->out_handle, hw_params);
snd_pcm_hw_params_set_access(alsa_data->out_handle, hw_params,
SND_PCM_ACCESS_RW_INTERLEAVED);
snd_pcm_hw_params_set_format(alsa_data->out_handle, hw_params,
alsa_data->format);
snd_pcm_hw_params_set_rate_near(alsa_data->out_handle, hw_params,
&alsa_data->actual_rate, NULL);
snd_pcm_hw_params_set_channels_near(alsa_data->out_handle, hw_params,
&alsa_data->actual_channels);
frames = alsa_data->actual_rate * 4;
snd_pcm_hw_params_set_buffer_size_near(alsa_data->out_handle, hw_params,
&frames);
snd_pcm_hw_params(alsa_data->out_handle, hw_params);
snd_pcm_hw_params_free(hw_params);
error = snd_pcm_sw_params_malloc(&sw_params);
if (error < 0)
{
LLOGLN(0, ("set_params: snd_pcm_sw_params_malloc"));
return 1;
}
snd_pcm_sw_params_current(alsa_data->out_handle, sw_params);
snd_pcm_sw_params_set_start_threshold(alsa_data->out_handle, sw_params,
frames / 2);
snd_pcm_sw_params(alsa_data->out_handle, sw_params);
snd_pcm_sw_params_free(sw_params);
snd_pcm_prepare(alsa_data->out_handle);
LLOGLN(10, ("set_params: hardware buffer %d frames, playback buffer %.2g seconds",
(int)frames, (double)frames / 2.0 / (double)alsa_data->actual_rate));
if ((alsa_data->actual_rate != alsa_data->source_rate) ||
(alsa_data->actual_channels != alsa_data->source_channels))
{
LLOGLN(0, ("set_params: actual rate %d / channel %d is different from source rate %d / channel %d, resampling required.",
alsa_data->actual_rate, alsa_data->actual_channels, alsa_data->source_rate, alsa_data->source_channels));
}
return 0;
}
int AudioAlsa::setSWParams()
{
int err;
// get the current swparams
if( ( err = snd_pcm_sw_params_current( m_handle, m_swParams ) ) < 0 )
{
printf( "Unable to determine current swparams for playback: %s"
"\n", snd_strerror( err ) );
return err;
}
// start the transfer when a period is full
if( ( err = snd_pcm_sw_params_set_start_threshold( m_handle,
m_swParams, m_periodSize ) ) < 0 )
{
printf( "Unable to set start threshold mode for playback: %s\n",
snd_strerror( err ) );
return err;
}
// allow the transfer when at least m_periodSize samples can be
// processed
if( ( err = snd_pcm_sw_params_set_avail_min( m_handle, m_swParams,
m_periodSize ) ) < 0 )
{
printf( "Unable to set avail min for playback: %s\n",
snd_strerror( err ) );
return err;
}
// align all transfers to 1 sample
#if SND_LIB_VERSION < ((1<<16)|(0)|16)
if( ( err = snd_pcm_sw_params_set_xfer_align( m_handle,
m_swParams, 1 ) ) < 0 )
{
printf( "Unable to set transfer align for playback: %s\n",
snd_strerror( err ) );
return err;
}
#endif
// write the parameters to the playback device
if( ( err = snd_pcm_sw_params( m_handle, m_swParams ) ) < 0 )
{
printf( "Unable to set sw params for playback: %s\n",
snd_strerror( err ) );
return err;
}
return 0; // all ok
}
void mixer_open()
{
memset(&channels, 0, sizeof(channels));
int err = snd_pcm_open(&pcm, "default", SND_PCM_STREAM_PLAYBACK, 0);
if (err < 0)
{
printf("Failed to open pcm device: %s\n", snd_strerror(err));
exit(1);
}
unsigned int rate = 44100;
snd_pcm_hw_params_t *hw_params = 0;
snd_pcm_hw_params_alloca(&hw_params);
snd_pcm_hw_params_any(pcm, hw_params);
snd_pcm_hw_params_set_rate_resample(pcm, hw_params, 0);
snd_pcm_hw_params_set_access(pcm, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED);
snd_pcm_hw_params_set_format(pcm, hw_params, SND_PCM_FORMAT_S16_LE);
snd_pcm_hw_params_set_rate_near(pcm, hw_params, &rate, 0);
snd_pcm_hw_params_set_channels(pcm, hw_params, 2);
snd_pcm_hw_params_set_period_size(pcm, hw_params, BUFFER_SIZE, 0);
snd_pcm_hw_params_set_buffer_size(pcm, hw_params, BUFFER_SIZE * 4);
err = snd_pcm_hw_params(pcm, hw_params);
if (err < 0)
{
printf("Failed to apply pcm hardware settings: %s\n", snd_strerror(err));
exit(1);
}
snd_pcm_sw_params_t *sw_params = 0;
snd_pcm_sw_params_alloca(&sw_params);
snd_pcm_sw_params_current(pcm, sw_params);
snd_pcm_sw_params_set_avail_min(pcm, sw_params, BUFFER_SIZE * 4);
err = snd_pcm_sw_params(pcm, sw_params);
if (err < 0)
{
printf("Failed to apply pcm software settings: %s\n", snd_strerror(err));
exit(1);
}
err = snd_pcm_prepare(pcm);
if (err < 0)
{
printf("Failed to prepare pcm interface: %s\n", snd_strerror(err));
exit(1);
}
memset(delay_left, 0, sizeof(delay_left));
memset(delay_right, 0, sizeof(delay_right));
}
static int setparams_set(snd_pcm_t *handle,
snd_pcm_hw_params_t *params,
snd_pcm_sw_params_t *swparams,
snd_pcm_uframes_t start_treshold,
const char *id)
{
int err;
err = snd_pcm_hw_params(handle, params);
if (err < 0) {
fprintf(error_fp, "alsa: Unable to set hw params for %s: %s\n",
id, snd_strerror(err));
return err;
}
err = snd_pcm_sw_params_current(handle, swparams);
if (err < 0) {
fprintf(error_fp, "alsa: Unable to determine current swparams for %s: %s\n",
id, snd_strerror(err));
return err;
}
err = snd_pcm_sw_params_set_start_threshold(handle, swparams,
start_treshold);
if (err < 0) {
fprintf(error_fp, "alsa: Unable to set start threshold mode for %s: %s\n",
id, snd_strerror(err));
return err;
}
err = snd_pcm_sw_params_set_avail_min(handle, swparams, 4);
if (err < 0) {
fprintf(error_fp, "alsa: Unable to set avail min for %s: %s\n",
id, snd_strerror(err));
return err;
}
err = snd_pcm_sw_params_set_tstamp_mode(handle, swparams, SND_PCM_TSTAMP_ENABLE);
if (err < 0) {
fprintf(error_fp, "alsa: Unable to enable timestamps for %s: %s\n",
id, snd_strerror(err));
}
err = snd_pcm_sw_params(handle, swparams);
if (err < 0) {
fprintf(error_fp, "alsa: Unable to set sw params for %s: %s\n",
id, snd_strerror(err));
return err;
}
return 0;
}
int setStartThreshold(AlsaPcmInfo* info, int useThreshold) {
int ret = 0;
if (!setStartThresholdNoCommit(info, useThreshold)) {
ret = -1;
}
if (ret == 0) {
// commit it
ret = snd_pcm_sw_params(info->handle, info->swParams);
if (ret < 0) {
ERROR1("Unable to set sw params: %s\n", snd_strerror(ret));
}
}
return (ret == 0)?TRUE:FALSE;
}
/**************************************************************************************
* set_swparams
* history: (1) 2014 03 30 mhb
*
**************************************************************************************/
static int set_swparams(snd_pcm_t *handle,
snd_pcm_sw_params_t *swparams)
{
int err;
/* get the current swparams */
err = snd_pcm_sw_params_current(handle, swparams);
if (err < 0)
{
printf("Unable to determine current swparams : %s\n", snd_strerror(err));
return err;
}
/* start the transfer when the buffer is almost full: */
/* (buffer_size / avail_min) * avail_min */
err = snd_pcm_sw_params_set_start_threshold(handle, swparams, (buffer_size / period_size) * period_size);
//err = snd_pcm_sw_params_set_start_threshold(handle, swparams, 3*period_size);// mhb| 修改此值，太小程序会卡死
if (err < 0)
{
printf("Unable to set start threshold mode : %s\n", snd_strerror(err));
return err;
}
/* allow the transfer when at least period_size samples can be processed */
/* or disable this mechanism when period event is enabled (aka interrupt like style processing) */
err = snd_pcm_sw_params_set_avail_min(handle, swparams, period_event ? buffer_size : period_size);
//err = snd_pcm_sw_params_set_avail_min(handle, swparams, 0);//mhb
if (err < 0)
{
printf("Unable to set avail min : %s\n", snd_strerror(err));
return err;
}
/* enable period events when requested */
if (period_event)
{
err = snd_pcm_sw_params_set_period_event(handle, swparams, 1);
if (err < 0)
{
printf("Unable to set period event: %s\n", snd_strerror(err));
return err;
}
}
/* write the parameters to the playback device */
err = snd_pcm_sw_params(handle, swparams);
if (err < 0)
{
printf("Unable to set sw params : %s\n", snd_strerror(err));
return err;
}
return 0;
}
int
set_mic_swparams(snd_pcm_t *handle)
{
// set software params
snd_pcm_sw_params_t *swparams;
snd_pcm_sw_params_alloca(&swparams);
/* get the current swparams */
int ret = snd_pcm_sw_params_current(handle, swparams);
if (ret < 0) {
fprintf(stderr,
"Unable to determine current swparams for mic: %s\n",
snd_strerror(ret));
return ret;
}
/* allow transfer when at least period_frames can be processed */
ret = snd_pcm_sw_params_set_avail_min(handle, swparams,
get_period_frames(handle));
if (ret < 0) {
fprintf(stderr, "Unable to set avail min for mic: %s\n",
snd_strerror(ret));
return ret;
}
/* align all transfers to 1 sample */
ret = snd_pcm_sw_params_set_xfer_align(handle, swparams, 1);
if (ret < 0) {
fprintf(stderr, "Unable to set transfer align for mic: %s\n",
snd_strerror(ret));
return ret;
}
/* write the parameters to the microphone device */
ret = snd_pcm_sw_params(handle, swparams);
if (ret < 0) {
fprintf(stderr, "Unable to set sw params for mic: %s\n",
snd_strerror(ret));
return ret;
}
dump_swparams(handle);
return 0;
}
static int alsa_set_hwparams()
{
snd_pcm_hw_params_t *hwp;
snd_pcm_sw_params_t *swp;
int dir = 1;
unsigned period_time;
snd_pcm_uframes_t buffer_size, period_size;
snd_pcm_hw_params_alloca(&hwp);
snd_pcm_sw_params_alloca(&swp);
// ALSA bug? If we request 44100 Hz, it rounds the value up to 48000...
alsa_hw.rate--;
if (alsa_error("hw_params_any", snd_pcm_hw_params_any(alsa_hw.handle, hwp))
|| alsa_error("hw_params_set_format", snd_pcm_hw_params_set_format(alsa_hw.handle, hwp, alsa_hw.format))
|| alsa_error("hw_params_set_channels",
snd_pcm_hw_params_set_channels(alsa_hw.handle, hwp, alsa_hw.num_channels))
|| alsa_error("hw_params_set_rate_near",
snd_pcm_hw_params_set_rate_near(alsa_hw.handle, hwp, &alsa_hw.rate, &dir))
|| alsa_error("hw_params_set_access",
snd_pcm_hw_params_set_access(alsa_hw.handle, hwp, SND_PCM_ACCESS_RW_INTERLEAVED))
|| alsa_error("hw_params_set_buffer_time_near",
snd_pcm_hw_params_set_buffer_time_near(alsa_hw.handle, hwp, &alsa_hw.buffer_time, 0)))
return -1;
/* How often to call our SIGIO handler (~40Hz) */
period_time = alsa_hw.buffer_time / 4;
if (alsa_error
("hw_params_set_period_time_near",
snd_pcm_hw_params_set_period_time_near(alsa_hw.handle, hwp, &period_time, &dir))
|| alsa_error("hw_params_get_buffer_size", snd_pcm_hw_params_get_buffer_size(hwp, &buffer_size))
|| alsa_error("hw_params_get_period_size", snd_pcm_hw_params_get_period_size(hwp, &period_size, 0))
|| alsa_error("hw_params", snd_pcm_hw_params(alsa_hw.handle, hwp)))
return -1;
snd_pcm_sw_params_current(alsa_hw.handle, swp);
if (alsa_error
("sw_params_set_start_threshold", snd_pcm_sw_params_set_start_threshold(alsa_hw.handle, swp, period_size))
|| alsa_error("sw_params_set_avail_min", snd_pcm_sw_params_set_avail_min(alsa_hw.handle, swp, period_size))
|| alsa_error("sw_params", snd_pcm_sw_params(alsa_hw.handle, swp)))
return -1;
return 0;
}
static int
laudio_alsa_set_start_threshold(snd_pcm_uframes_t threshold)
{
snd_pcm_sw_params_t *sw_params;
int ret;
ret = snd_pcm_sw_params_malloc(&sw_params);
if (ret < 0)
{
DPRINTF(E_LOG, L_LAUDIO, "Could not allocate sw params: %s\n", snd_strerror(ret));
goto out_fail;
}
ret = snd_pcm_sw_params_current(hdl, sw_params);
if (ret < 0)
{
DPRINTF(E_LOG, L_LAUDIO, "Could not retrieve current sw params: %s\n", snd_strerror(ret));
goto out_fail;
}
ret = snd_pcm_sw_params_set_start_threshold(hdl, sw_params, threshold);
if (ret < 0)
{
DPRINTF(E_LOG, L_LAUDIO, "Could not set start threshold: %s\n", snd_strerror(ret));
goto out_fail;
}
ret = snd_pcm_sw_params(hdl, sw_params);
if (ret < 0)
{
DPRINTF(E_LOG, L_LAUDIO, "Could not set sw params: %s\n", snd_strerror(ret));
goto out_fail;
}
return 0;
out_fail:
snd_pcm_sw_params_free(sw_params);
return -1;
}
static int drvHostALSAAudioSetThreshold(snd_pcm_t *phPCM,
snd_pcm_uframes_t threshold)
{
snd_pcm_sw_params_t *pSWParms = NULL;
snd_pcm_sw_params_alloca(&pSWParms);
if (!pSWParms)
return VERR_NO_MEMORY;
int rc;
do
{
int err = snd_pcm_sw_params_current(phPCM, pSWParms);
if (err < 0)
{
LogRel(("ALSA: Failed to get current software parameters for threshold: %s\n",
snd_strerror(err)));
rc = VERR_ACCESS_DENIED;
break;
}
err = snd_pcm_sw_params_set_start_threshold(phPCM, pSWParms, threshold);
if (err < 0)
{
LogRel(("ALSA: Failed to set software threshold to %ld: %s\n",
threshold, snd_strerror(err)));
rc = VERR_ACCESS_DENIED;
break;
}
err = snd_pcm_sw_params(phPCM, pSWParms);
if (err < 0)
{
LogRel(("ALSA: Failed to set new software parameters for threshold: %s\n",
snd_strerror(err)));
rc = VERR_ACCESS_DENIED;
break;
}
LogFlowFunc(("Setting threshold to %RU32\n", threshold));
rc = VINF_SUCCESS;
}
while (0);
return rc;
}
/* setup alsa data transfer behavior */
static inline int alsa_set_swparams(ao_alsa_internal *internal)
{
snd_pcm_sw_params_t *params;
int err;
/* allocate the software parameter structure */
snd_pcm_sw_params_alloca(¶ms);
/* fetch the current software parameters */
internal->cmd = "snd_pcm_sw_params_current";
err = snd_pcm_sw_params_current(internal->pcm_handle, params);
if (err < 0)
return err;
/* allow transfers to start when there is one period */
internal->cmd = "snd_pcm_sw_params_set_start_threshold";
err = snd_pcm_sw_params_set_start_threshold(internal->pcm_handle,
params, internal->period_size);
if (err < 0)
return err;
/* require a minimum of one full transfer in the buffer */
internal->cmd = "snd_pcm_sw_params_set_avail_min";
err = snd_pcm_sw_params_set_avail_min(internal->pcm_handle, params,
internal->period_size);
if (err < 0)
return err;
/* do not align transfers */
internal->cmd = "snd_pcm_sw_params_set_xfer_align";
err = snd_pcm_sw_params_set_xfer_align(internal->pcm_handle, params, 1);
if (err < 0)
return err;
/* commit the params structure to ALSA */
internal->cmd = "snd_pcm_sw_params";
err = snd_pcm_sw_params(internal->pcm_handle, params);
if (err < 0)
return err;
return 1;
}
void AlsaRenderer::SetupSwParams()
{
snd_pcm_sw_params_t* params;
/* allocate a software parameters object */
snd_pcm_sw_params_malloc(¶ms);
/* get the current swparams */
snd_pcm_sw_params_current(m_PcmHandle, params);
/* round up to closest transfer boundary */
snd_pcm_sw_params_set_start_threshold(m_PcmHandle, params, 1);
/* require a minimum of one full transfer in the buffer */
snd_pcm_sw_params_set_avail_min(m_PcmHandle, params, 1);
snd_pcm_sw_params(m_PcmHandle, params);
/* free */
snd_pcm_sw_params_free(params);
}
static int set_swparams(snd_pcm_t *handle, snd_pcm_sw_params_t *swparams, int period, int nperiods) {
int err;
/* get the current swparams */
err = snd_pcm_sw_params_current(handle, swparams);
if (err < 0) {
printf("Unable to determine current swparams for capture: %s\n", snd_strerror(err));
return err;
}
/* start the transfer when the buffer is full */
err = snd_pcm_sw_params_set_start_threshold(handle, swparams, period );
if (err < 0) {
printf("Unable to set start threshold mode for capture: %s\n", snd_strerror(err));
return err;
}
err = snd_pcm_sw_params_set_stop_threshold(handle, swparams, -1 );
if (err < 0) {
printf("Unable to set start threshold mode for capture: %s\n", snd_strerror(err));
return err;
}
/* allow the transfer when at least period_size samples can be processed */
err = snd_pcm_sw_params_set_avail_min(handle, swparams, 1 );
if (err < 0) {
printf("Unable to set avail min for capture: %s\n", snd_strerror(err));
return err;
}
/* align all transfers to 1 sample */
err = snd_pcm_sw_params_set_xfer_align(handle, swparams, 1);
if (err < 0) {
printf("Unable to set transfer align for capture: %s\n", snd_strerror(err));
return err;
}
/* write the parameters to the playback device */
err = snd_pcm_sw_params(handle, swparams);
if (err < 0) {
printf("Unable to set sw params for capture: %s\n", snd_strerror(err));
return err;
}
return 0;
}
int setparams_set(snd_pcm_t *handle,
snd_pcm_hw_params_t *params,
snd_pcm_sw_params_t *swparams,
const char *id)
{
int err;
snd_pcm_uframes_t val;
err = snd_pcm_hw_params(handle, params);
if (err < 0) {
printf("Unable to set hw params for %s: %s\n", id, snd_strerror(err));
return err;
}
err = snd_pcm_sw_params_current(handle, swparams);
if (err < 0) {
printf("Unable to determine current swparams for %s: %s\n", id, snd_strerror(err));
return err;
}
err = snd_pcm_sw_params_set_start_threshold(handle, swparams, 0x7fffffff);
if (err < 0) {
printf("Unable to set start threshold mode for %s: %s\n", id, snd_strerror(err));
return err;
}
if (!block)
val = 4;
else
snd_pcm_hw_params_get_period_size(params, &val, NULL);
err = snd_pcm_sw_params_set_avail_min(handle, swparams, val);
if (err < 0) {
printf("Unable to set avail min for %s: %s\n", id, snd_strerror(err));
return err;
}
err = snd_pcm_sw_params(handle, swparams);
if (err < 0) {
printf("Unable to set sw params for %s: %s\n", id, snd_strerror(err));
return err;
}
return 0;
}
snd_pcm_t *open_pcm(char *pcm_name) {
snd_pcm_t *playback_handle;
snd_pcm_hw_params_t *hw_params;
snd_pcm_sw_params_t *sw_params;
if (snd_pcm_open (&playback_handle, pcm_name, SND_PCM_STREAM_PLAYBACK, 0) < 0) {
fprintf (stderr, "cannot open audio device %s\n", pcm_name);
return NULL;//it seems greedy and wants exclusive control?!
}
snd_pcm_hw_params_alloca(&hw_params);
snd_pcm_hw_params_any(playback_handle, hw_params);
snd_pcm_hw_params_set_access(playback_handle, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED);
snd_pcm_hw_params_set_format(playback_handle, hw_params, SND_PCM_FORMAT_S16_LE);
snd_pcm_hw_params_set_rate_near(playback_handle, hw_params, &rate, 0);
snd_pcm_hw_params_set_channels(playback_handle, hw_params, 2);
snd_pcm_hw_params_set_periods(playback_handle, hw_params, 2, 0);
snd_pcm_hw_params_set_period_size(playback_handle, hw_params, BUFSAMPS, 0);
snd_pcm_hw_params(playback_handle, hw_params);
snd_pcm_sw_params_alloca(&sw_params);
snd_pcm_sw_params_current(playback_handle, sw_params);
snd_pcm_sw_params_set_avail_min(playback_handle, sw_params, BUFSAMPS);
snd_pcm_sw_params(playback_handle, sw_params);
return(playback_handle);
}
bool CAESinkALSA::InitializeSW(AEAudioFormat &format)
{
snd_pcm_sw_params_t *sw_params;
snd_pcm_uframes_t boundary;
snd_pcm_sw_params_alloca(&sw_params);
memset(sw_params, 0, snd_pcm_sw_params_sizeof());
snd_pcm_sw_params_current (m_pcm, sw_params);
snd_pcm_sw_params_set_start_threshold (m_pcm, sw_params, INT_MAX);
snd_pcm_sw_params_set_silence_threshold(m_pcm, sw_params, 0);
snd_pcm_sw_params_get_boundary (sw_params, &boundary);
snd_pcm_sw_params_set_silence_size (m_pcm, sw_params, boundary);
snd_pcm_sw_params_set_avail_min (m_pcm, sw_params, format.m_frames);
if (snd_pcm_sw_params(m_pcm, sw_params) < 0)
{
CLog::Log(LOGERROR, "CAESinkALSA::InitializeSW - Failed to set the parameters");
return false;
}
return true;
}
bool AudioInputALSA::PrepSwParams(void)
{
snd_pcm_sw_params_t* swparams;
snd_pcm_sw_params_alloca(&swparams);
snd_pcm_uframes_t boundary;
if (AlsaBad(snd_pcm_sw_params_current(pcm_handle, swparams),
"failed to get swparams"))
return false;
if (AlsaBad(snd_pcm_sw_params_get_boundary(swparams, &boundary),
"failed to get boundary"))
return false;
// explicit start, not auto start
if (AlsaBad(snd_pcm_sw_params_set_start_threshold(pcm_handle, swparams,
boundary), "failed to set start threshold"))
return false;
if (AlsaBad(snd_pcm_sw_params_set_stop_threshold(pcm_handle, swparams,
boundary), "failed to set stop threshold"))
return false;
if (AlsaBad(snd_pcm_sw_params(pcm_handle, swparams),
"failed to set software parameters"))
return false;
return true;
}
int ai_alsa_setup(audio_in_t *ai)
{
snd_pcm_hw_params_t *params;
snd_pcm_sw_params_t *swparams;
snd_pcm_uframes_t buffer_size, period_size;
int err;
int dir;
unsigned int rate;
snd_pcm_hw_params_alloca(¶ms);
snd_pcm_sw_params_alloca(&swparams);
err = snd_pcm_hw_params_any(ai->alsa.handle, params);
if (err < 0) {
mp_tmsg(MSGT_TV, MSGL_ERR, "Broken configuration for this PCM: no configurations available.\n");
return -1;
}
err = snd_pcm_hw_params_set_access(ai->alsa.handle, params,
SND_PCM_ACCESS_RW_INTERLEAVED);
if (err < 0) {
mp_tmsg(MSGT_TV, MSGL_ERR, "Access type not available.\n");
return -1;
}
err = snd_pcm_hw_params_set_format(ai->alsa.handle, params, SND_PCM_FORMAT_S16_LE);
if (err < 0) {
mp_tmsg(MSGT_TV, MSGL_ERR, "Sample format not available.\n");
return -1;
}
err = snd_pcm_hw_params_set_channels(ai->alsa.handle, params, ai->req_channels);
if (err < 0) {
snd_pcm_hw_params_get_channels(params, &ai->channels);
mp_tmsg(MSGT_TV, MSGL_ERR, "Channel count not available - reverting to default: %d\n",
ai->channels);
} else {
ai->channels = ai->req_channels;
}
dir = 0;
rate = ai->req_samplerate;
err = snd_pcm_hw_params_set_rate_near(ai->alsa.handle, params, &rate, &dir);
if (err < 0) {
mp_tmsg(MSGT_TV, MSGL_ERR, "Cannot set samplerate.\n");
}
ai->samplerate = rate;
dir = 0;
ai->alsa.buffer_time = 1000000;
err = snd_pcm_hw_params_set_buffer_time_near(ai->alsa.handle, params,
&ai->alsa.buffer_time, &dir);
if (err < 0) {
mp_tmsg(MSGT_TV, MSGL_ERR, "Cannot set buffer time.\n");
}
dir = 0;
ai->alsa.period_time = ai->alsa.buffer_time / 4;
err = snd_pcm_hw_params_set_period_time_near(ai->alsa.handle, params,
&ai->alsa.period_time, &dir);
if (err < 0) {
mp_tmsg(MSGT_TV, MSGL_ERR, "Cannot set period time.\n");
}
err = snd_pcm_hw_params(ai->alsa.handle, params);
if (err < 0) {
mp_tmsg(MSGT_TV, MSGL_ERR, "Unable to install hardware parameters: %s", snd_strerror(err));
snd_pcm_hw_params_dump(params, ai->alsa.log);
return -1;
}
dir = -1;
snd_pcm_hw_params_get_period_size(params, &period_size, &dir);
snd_pcm_hw_params_get_buffer_size(params, &buffer_size);
ai->alsa.chunk_size = period_size;
if (period_size == buffer_size) {
mp_tmsg(MSGT_TV, MSGL_ERR, "Can't use period equal to buffer size (%u == %lu)\n", ai->alsa.chunk_size, (long)buffer_size);
return -1;
}
snd_pcm_sw_params_current(ai->alsa.handle, swparams);
err = snd_pcm_sw_params_set_avail_min(ai->alsa.handle, swparams, ai->alsa.chunk_size);
err = snd_pcm_sw_params_set_start_threshold(ai->alsa.handle, swparams, 0);
err = snd_pcm_sw_params_set_stop_threshold(ai->alsa.handle, swparams, buffer_size);
if (snd_pcm_sw_params(ai->alsa.handle, swparams) < 0) {
mp_tmsg(MSGT_TV, MSGL_ERR, "Unable to install software parameters:\n");
snd_pcm_sw_params_dump(swparams, ai->alsa.log);
return -1;
}
if (mp_msg_test(MSGT_TV, MSGL_V)) {
snd_pcm_dump(ai->alsa.handle, ai->alsa.log);
}
ai->alsa.bits_per_sample = snd_pcm_format_physical_width(SND_PCM_FORMAT_S16_LE);
ai->alsa.bits_per_frame = ai->alsa.bits_per_sample * ai->channels;
ai->blocksize = ai->alsa.chunk_size * ai->alsa.bits_per_frame / 8;
ai->samplesize = ai->alsa.bits_per_sample;
ai->bytes_per_sample = ai->alsa.bits_per_sample/8;
return 0;
}
static int capture(lua_State *lstate) {
char *card;
snd_pcm_sw_params_t *sparams;
int ret, dir, i;
snd_pcm_format_t f, format;
unsigned int rate, buffer_time;
if (rbuf == NULL) {
rbuf = new_ringbuf(jack_sr, CHANNELS, BUFSECS,
0.333, 0.667);
}
getstring(lstate, "card", &card);
lua_pop(lstate, 1);
for (i = 0; i < 20; i++) {
ret = snd_pcm_open(&handle, card, SND_PCM_STREAM_CAPTURE, 0);
if (ret < 0) {
logmsg("can't open %s (%s)\n", card, snd_strerror(ret));
}
else {
break;
}
}
free(card);
if (ret < 0) return 0;
if (hparams != NULL) snd_pcm_hw_params_free(hparams);
snd_pcm_hw_params_malloc(&hparams);
snd_pcm_hw_params_any(handle, hparams);
for (f = format = 0; f < SND_PCM_FORMAT_LAST; f++) {
ret = snd_pcm_hw_params_test_format(handle, hparams, f);
if (ret == 0) {
logmsg("- %s\n", snd_pcm_format_name(f));
format = f;
}
}
ret = snd_pcm_hw_params_set_access(handle, hparams,
SND_PCM_ACCESS_RW_INTERLEAVED);
if (ret < 0) {
logmsg("access %s\n", snd_strerror(ret));
}
ret = snd_pcm_hw_params_set_format(handle, hparams, format);
logmsg("format: %s\n", snd_pcm_format_description(format));
if (ret < 0) {
logmsg("format error %s\n", snd_strerror(ret));
}
snd_pcm_hw_params_get_buffer_time_max(hparams, &buffer_time, 0);
rate = jack_sr;
ret = snd_pcm_hw_params_set_rate(handle, hparams, rate, 0);
logmsg("rate %d\n", rate);
if (ret < 0) logmsg("rate error %s\n", snd_strerror(ret));
snd_pcm_hw_params_set_channels(handle, hparams, CHANNELS);
blocksize = BLOCKSIZE;
snd_pcm_hw_params_set_period_size(handle, hparams, blocksize, 0);
logmsg("period %ld\n", blocksize);
snd_pcm_hw_params_set_buffer_time_near(handle, hparams, &buffer_time, &dir);
logmsg("buffer time %u\n", buffer_time);
if ((ret = snd_pcm_hw_params(handle, hparams)) < 0) {
logmsg("can't set hardware: %s\n",
snd_strerror(ret));
return 0;
}
else logmsg("hardware configd\n");
snd_pcm_sw_params_malloc(&sparams);
snd_pcm_sw_params_current(handle, sparams);
snd_pcm_sw_params_set_avail_min(handle, sparams, blocksize);
snd_pcm_sw_params_set_start_threshold(handle, sparams, 0U);
if ((ret = snd_pcm_sw_params(handle, sparams)) < 0) {
logmsg("can't set software: %s\n",
snd_strerror(ret));
}
else logmsg("software configd\n");
snd_pcm_sw_params_free(sparams);
pthread_create(&thread_id, NULL, dev_thread, NULL);
return 0;
}
bool QAudioOutputPrivate::open()
{
if(opened)
return true;
#ifdef DEBUG_AUDIO
QTime now(QTime::currentTime());
qDebug()<<now.second()<<"s "<<now.msec()<<"ms :open()";
#endif
timeStamp.restart();
elapsedTimeOffset = 0;
int dir;
int err=-1;
int count=0;
unsigned int freakuency=settings.frequency();
QString dev = QLatin1String(m_device.constData());
QList<QByteArray> devices = QAudioDeviceInfoInternal::availableDevices(QAudio::AudioOutput);
if(dev.compare(QLatin1String("default")) == 0) {
#if(SND_LIB_MAJOR == 1 && SND_LIB_MINOR == 0 && SND_LIB_SUBMINOR >= 14)
dev = QLatin1String(devices.first().constData());
#else
dev = QLatin1String("hw:0,0");
#endif
} else {
#if(SND_LIB_MAJOR == 1 && SND_LIB_MINOR == 0 && SND_LIB_SUBMINOR >= 14)
dev = QLatin1String(m_device);
#else
int idx = 0;
char *name;
QString shortName = QLatin1String(m_device.mid(m_device.indexOf('=',0)+1).constData());
while(snd_card_get_name(idx,&name) == 0) {
if(qstrncmp(shortName.toLocal8Bit().constData(),name,shortName.length()) == 0)
break;
idx++;
}
dev = QString(QLatin1String("hw:%1,0")).arg(idx);
#endif
}
// Step 1: try and open the device
while((count < 5) && (err < 0)) {
err=snd_pcm_open(&handle,dev.toLocal8Bit().constData(),SND_PCM_STREAM_PLAYBACK,0);
if(err < 0)
count++;
}
if (( err < 0)||(handle == 0)) {
errorState = QAudio::OpenError;
deviceState = QAudio::StoppedState;
return false;
}
snd_pcm_nonblock( handle, 0 );
// Step 2: Set the desired HW parameters.
snd_pcm_hw_params_alloca( &hwparams );
bool fatal = false;
QString errMessage;
unsigned int chunks = 8;
err = snd_pcm_hw_params_any( handle, hwparams );
if ( err < 0 ) {
fatal = true;
errMessage = QString::fromLatin1("QAudioOutput: snd_pcm_hw_params_any: err = %1").arg(err);
}
if ( !fatal ) {
err = snd_pcm_hw_params_set_rate_resample( handle, hwparams, 1 );
if ( err < 0 ) {
fatal = true;
errMessage = QString::fromLatin1("QAudioOutput: snd_pcm_hw_params_set_rate_resample: err = %1").arg(err);
}
}
if ( !fatal ) {
err = snd_pcm_hw_params_set_access( handle, hwparams, access );
if ( err < 0 ) {
fatal = true;
errMessage = QString::fromLatin1("QAudioOutput: snd_pcm_hw_params_set_access: err = %1").arg(err);
}
}
if ( !fatal ) {
err = setFormat();
if ( err < 0 ) {
fatal = true;
errMessage = QString::fromLatin1("QAudioOutput: snd_pcm_hw_params_set_format: err = %1").arg(err);
}
}
if ( !fatal ) {
err = snd_pcm_hw_params_set_channels( handle, hwparams, (unsigned int)settings.channels() );
if ( err < 0 ) {
fatal = true;
errMessage = QString::fromLatin1("QAudioOutput: snd_pcm_hw_params_set_channels: err = %1").arg(err);
}
}
if ( !fatal ) {
err = snd_pcm_hw_params_set_rate_near( handle, hwparams, &freakuency, 0 );
if ( err < 0 ) {
fatal = true;
errMessage = QString::fromLatin1("QAudioOutput: snd_pcm_hw_params_set_rate_near: err = %1").arg(err);
}
}
if ( !fatal ) {
err = snd_pcm_hw_params_set_buffer_time_near(handle, hwparams, &buffer_time, &dir);
if ( err < 0 ) {
fatal = true;
errMessage = QString::fromLatin1("QAudioOutput: snd_pcm_hw_params_set_buffer_time_near: err = %1").arg(err);
}
}
if ( !fatal ) {
err = snd_pcm_hw_params_set_period_time_near(handle, hwparams, &period_time, &dir);
if ( err < 0 ) {
fatal = true;
errMessage = QString::fromLatin1("QAudioOutput: snd_pcm_hw_params_set_period_time_near: err = %1").arg(err);
}
}
if ( !fatal ) {
err = snd_pcm_hw_params_set_periods_near(handle, hwparams, &chunks, &dir);
if ( err < 0 ) {
fatal = true;
errMessage = QString::fromLatin1("QAudioOutput: snd_pcm_hw_params_set_periods_near: err = %1").arg(err);
}
}
if ( !fatal ) {
err = snd_pcm_hw_params(handle, hwparams);
if ( err < 0 ) {
fatal = true;
errMessage = QString::fromLatin1("QAudioOutput: snd_pcm_hw_params: err = %1").arg(err);
}
}
if( err < 0) {
qWarning()<<errMessage;
errorState = QAudio::OpenError;
deviceState = QAudio::StoppedState;
return false;
}
snd_pcm_hw_params_get_buffer_size(hwparams,&buffer_frames);
buffer_size = snd_pcm_frames_to_bytes(handle,buffer_frames);
snd_pcm_hw_params_get_period_size(hwparams,&period_frames, &dir);
period_size = snd_pcm_frames_to_bytes(handle,period_frames);
snd_pcm_hw_params_get_buffer_time(hwparams,&buffer_time, &dir);
snd_pcm_hw_params_get_period_time(hwparams,&period_time, &dir);
// Step 3: Set the desired SW parameters.
snd_pcm_sw_params_t *swparams;
snd_pcm_sw_params_alloca(&swparams);
snd_pcm_sw_params_current(handle, swparams);
snd_pcm_sw_params_set_start_threshold(handle,swparams,period_frames);
snd_pcm_sw_params_set_stop_threshold(handle,swparams,buffer_frames);
snd_pcm_sw_params_set_avail_min(handle, swparams,period_frames);
snd_pcm_sw_params(handle, swparams);
// Step 4: Prepare audio
if(audioBuffer == 0)
audioBuffer = new char[snd_pcm_frames_to_bytes(handle,buffer_frames)];
snd_pcm_prepare( handle );
snd_pcm_start(handle);
// Step 5: Setup callback and timer fallback
snd_async_add_pcm_handler(&ahandler, handle, async_callback, this);
bytesAvailable = bytesFree();
// Step 6: Start audio processing
timer->start(period_time/1000);
clockStamp.restart();
timeStamp.restart();
elapsedTimeOffset = 0;
errorState = QAudio::NoError;
totalTimeValue = 0;
opened = true;
return true;
}
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;
}
