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; }