internal
void hhxcb_init_alsa(hhxcb_context *context, hhxcb_sound_output *sound_output)
{
// NOTE: "hw:0,0" doesn't seem to work with alsa running on top of pulseaudio
char *device = (char *)"default";
// char *device = (char *)"hw:0,0";
int err;
snd_pcm_sframes_t frames;
err = snd_output_stdio_attach(&context->alsa_log, stderr, 0);
if ((err = snd_pcm_open(&context->handle, device, SND_PCM_STREAM_PLAYBACK, 0)) < 0)
{
printf("Playback open error: %s\n", snd_strerror(err));
exit(EXIT_FAILURE);
}
snd_pcm_hw_params_t *hwparams;
snd_pcm_hw_params_alloca(&hwparams);
snd_pcm_hw_params_any(context->handle, hwparams);
snd_pcm_hw_params_set_rate_resample(context->handle, hwparams, 0);
snd_pcm_hw_params_set_access(context->handle, hwparams, SND_PCM_ACCESS_RW_INTERLEAVED);
snd_pcm_hw_params_set_format(context->handle, hwparams, SND_PCM_FORMAT_S16_LE);
snd_pcm_hw_params_set_channels(context->handle, hwparams, 2);
snd_pcm_hw_params_set_rate(context->handle, hwparams, sound_output->samples_per_second, 0);
snd_pcm_hw_params_set_period_size(context->handle, hwparams, sound_output->samples_per_second / 60, 0);
// NOTE: restricting this buffer size too much seems to crash the game
sound_output->secondary_buffer_size = 48000 / 2;
snd_pcm_hw_params_set_buffer_size(context->handle, hwparams, sound_output->secondary_buffer_size);
snd_pcm_hw_params(context->handle, hwparams);
snd_pcm_dump(context->handle, context->alsa_log);
}
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));
}
int setparams(snd_pcm_t *chandle, int sample_rate, snd_pcm_format_t *format, const char *cdevice)
{
int err;
snd_pcm_hw_params_t *ct_params; /* templates with rate, format and channels */
snd_pcm_hw_params_alloca(&ct_params);
err = snd_pcm_hw_params_any(chandle, ct_params);
if (err < 0)
error_exit("Broken configuration for %s PCM: no configurations available: %s", cdevice, snd_strerror(err));
/* Disable rate resampling */
err = snd_pcm_hw_params_set_rate_resample(chandle, ct_params, 0);
if (err < 0)
error_exit("Could not disable rate resampling: %s", snd_strerror(err));
/* Set access to SND_PCM_ACCESS_RW_INTERLEAVED */
err = snd_pcm_hw_params_set_access(chandle, ct_params, SND_PCM_ACCESS_RW_INTERLEAVED);
if (err < 0)
error_exit("Could not set access to SND_PCM_ACCESS_RW_INTERLEAVED: %s", snd_strerror(err));
/* Restrict a configuration space to have rate nearest to our target rate */
err = snd_pcm_hw_params_set_rate_near(chandle, ct_params, (unsigned int *)&sample_rate, 0);
if (err < 0)
error_exit("Rate %iHz not available for %s: %s", sample_rate, cdevice, snd_strerror(err));
/* Set sample format */
*format = SND_PCM_FORMAT_S16_BE;
err = snd_pcm_hw_params_set_format(chandle, ct_params, *format);
if (err < 0)
{
*format = SND_PCM_FORMAT_S16_LE;
err = snd_pcm_hw_params_set_format(chandle, ct_params, *format);
}
if (err < 0)
error_exit("Sample format (SND_PCM_FORMAT_S16_BE and _LE) not available for %s: %s", cdevice, snd_strerror(err));
/* Set stereo */
err = snd_pcm_hw_params_set_channels(chandle, ct_params, 2);
if (err < 0)
error_exit("Channels count (%i) not available for %s: %s", 2, cdevice, snd_strerror(err));
/* Apply settings to sound device */
err = snd_pcm_hw_params(chandle, ct_params);
if (err < 0)
error_exit("Could not apply settings to sound device! %s", snd_strerror(err));
return 0;
}
int init_mic_input(void **device) {
snd_pcm_hw_params_t *hwparams;
snd_pcm_format_t format;
unsigned int rate = DEFAULT_SAMPLE_RATE;
int err;
snd_pcm_hw_params_alloca(&hwparams);
if (is_bigendian())
format = SND_PCM_FORMAT_S16_BE;
else
format = SND_PCM_FORMAT_S16_LE;
if ((err = snd_pcm_open((snd_pcm_t **)device, ALSA_AUDIO_DEVICE, SND_PCM_STREAM_CAPTURE, 0)) < 0) {
cosby_print_err("Uhhh... I don't think this computer has speakers (%d)\n",err);
return -1;
}
if ((err = snd_pcm_hw_params_any((snd_pcm_t *)(*device), hwparams)) < 0) {
cosby_print_err("Your sounds is really fd up dude. (%d)\n",err);
return -1;
}
if ((err = snd_pcm_hw_params_set_rate_resample((snd_pcm_t *)(*device), hwparams, 0)) < 0) {
cosby_print_err("Dude! I just said it's fine to resample and your soundscared freaked out on me (%d)\n",err);
return -1;
}
if ((err = snd_pcm_hw_params_set_format((snd_pcm_t *)(*device), hwparams, format)) < 0) {
cosby_print_err("Hey there. You don't support 16bit sound? Is this 1991? (%d)\n",err);
return -1;
}
if ((err = snd_pcm_hw_params_set_channels((snd_pcm_t *)(*device), hwparams, 2)) < 0) {
cosby_print_err("Dude! WTF! No stereo sound! (%d)\n",err);
return -1;
}
if ((err = snd_pcm_hw_params_set_access((snd_pcm_t *)(*device), hwparams, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0) {
cosby_print_err("ALSA is seriously braindead. Consider writing a letter to the mailing list complaining. (%d)\n",err);
return -1;
}
if ((err = snd_pcm_hw_params_set_rate_near((snd_pcm_t *)(*device), hwparams, &rate, 0)) < 0) {
cosby_print_err("I think you have a sound card from 1990 (%d)\n",err);
return -1;
}
if ((err = snd_pcm_hw_params((snd_pcm_t *)(*device), hwparams) < 0)) {
cosby_print_err("Yur soundscard is br0kn!! (%d)\n",err);
return -1;
}
return 0;
}
int setparams_stream(snd_pcm_t *handle,
snd_pcm_hw_params_t *params,
const char *id)
{
int err;
unsigned int rrate;
err = snd_pcm_hw_params_any(handle, params);
if (err < 0) {
printf("Broken configuration for %s PCM: no configurations available: %s\n", snd_strerror(err), id);
return err;
}
err = snd_pcm_hw_params_set_rate_resample(handle, params, resample);
if (err < 0) {
printf("Resample setup failed for %s (val %i): %s\n", id, resample, snd_strerror(err));
return err;
}
err = snd_pcm_hw_params_set_access(handle, params, SND_PCM_ACCESS_RW_INTERLEAVED);
if (err < 0) {
printf("Access type not available for %s: %s\n", id, snd_strerror(err));
return err;
}
err = snd_pcm_hw_params_set_format(handle, params, format);
if (err < 0) {
printf("Sample format not available for %s: %s\n", id, snd_strerror(err));
return err;
}
err = snd_pcm_hw_params_set_channels(handle, params, channels);
if (err < 0) {
printf("Channels count (%i) not available for %s: %s\n", channels, id, snd_strerror(err));
return err;
}
rrate = rate;
err = snd_pcm_hw_params_set_rate_near(handle, params, &rrate, 0);
if (err < 0) {
printf("Rate %iHz not available for %s: %s\n", rate, id, snd_strerror(err));
return err;
}
if ((int)rrate != rate) {
printf("Rate doesn't match (requested %iHz, get %iHz)\n", rate, err);
return -EINVAL;
}
return 0;
}
static void
init_audio(const char* devname)
{
snd_pcm_hw_params_t* hwparams = 0;
snd_pcm_sw_params_t* swparams = 0;
snd_pcm_uframes_t bufsize = 0;
unsigned int buftime = 1000000;
unsigned int pertime = 50000;
int dir = 0;
int rc;
if ((rc = snd_output_stdio_attach(&output, stderr, 0)) < 0)
exit_snd_error(rc, "log output");
if ((rc = snd_pcm_open(&audio, devname, SND_PCM_STREAM_PLAYBACK, 0)) < 0)
exit_snd_error(rc, "opening device");
if ((rc = snd_pcm_hw_params_malloc(&hwparams)) < 0)
exit_snd_error(rc, "hardware parameters");
if ((rc = snd_pcm_hw_params_any(audio, hwparams)) < 0)
exit_snd_error(rc, "hardware parameters");
if ((rc = snd_pcm_hw_params_set_rate_resample(audio, hwparams, 0)) < 0)
exit_snd_error(rc, "hardware parameters");
if ((rc = snd_pcm_hw_params_set_access(audio, hwparams, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0)
exit_snd_error(rc, "access type");
if ((rc = snd_pcm_hw_params_set_format(audio, hwparams, SND_PCM_FORMAT_S16)) < 0)
exit_snd_error(rc, "sample format");
if ((rc = snd_pcm_hw_params_set_channels_near(audio, hwparams, &n_channels)) < 0)
exit_snd_error(rc, "number of channels");
if ((rc = snd_pcm_hw_params_set_rate_near(audio, hwparams, &samplerate, &dir)) < 0)
exit_snd_error(rc, "sample rate");
if ((rc = snd_pcm_hw_params_set_buffer_time_near(audio, hwparams, &buftime, &dir)) < 0)
exit_snd_error(rc, "buffer time");
if ((rc = snd_pcm_hw_params_set_period_time_near(audio, hwparams, &pertime, &dir)) < 0)
exit_snd_error(rc, "period time");
if ((rc = snd_pcm_hw_params(audio, hwparams)) < 0)
exit_snd_error(rc, "applying hardware parameters");
if ((rc = snd_pcm_hw_params_get_buffer_size(hwparams, &bufsize)) < 0)
exit_snd_error(rc, "buffer size");
if ((rc = snd_pcm_hw_params_get_period_size(hwparams, &periodsize, &dir)) < 0)
exit_snd_error(rc, "period size");
snd_pcm_hw_params_free(hwparams);
if ((rc = snd_pcm_sw_params_malloc(&swparams)) < 0)
exit_snd_error(rc, "software parameters");
if ((rc = snd_pcm_sw_params_current(audio, swparams)) < 0)
exit_snd_error(rc, "software parameters");
if ((rc = snd_pcm_sw_params_set_start_threshold(audio, swparams,
bufsize / periodsize * periodsize)) < 0)
exit_snd_error(rc, "start threshold");
if ((rc = snd_pcm_sw_params(audio, swparams)) < 0)
exit_snd_error(rc, "applying software parameters");
snd_pcm_sw_params_free(swparams);
if ((rc = snd_pcm_prepare(audio)) < 0)
exit_snd_error(rc, "preparing device");
}
int
set_hwparams(snd_pcm_t *handle, int sampleRate, int channels, int bufferSize)
{
snd_pcm_access_t access = SND_PCM_ACCESS_RW_INTERLEAVED;
int ret, dir;
snd_pcm_hw_params_t *hwparams;
snd_pcm_hw_params_alloca(&hwparams);
/* choose all parameters */
ret = snd_pcm_hw_params_any(handle, hwparams);
if (ret < 0) {
fprintf(stderr, "Broken configuration for playback: "
"no configurations available: %s\n", snd_strerror(ret));
return ret;
}
/* set hardware resampling */
ret = snd_pcm_hw_params_set_rate_resample(handle, hwparams, resample);
if (ret < 0) {
fprintf(stderr, "Resampling setup failed for playback: %s\n",
snd_strerror(ret));
return ret;
}
/* set the interleaved read/write format */
ret = snd_pcm_hw_params_set_access(handle, hwparams, access);
if (ret < 0) {
fprintf(stderr, "Access type not available for playback: %s\n",
snd_strerror(ret));
return ret;
}
/* set the sample format */
ret = snd_pcm_hw_params_set_format(handle, hwparams, format);
if (ret < 0) {
fprintf(stderr, "Sample format not available for playback: %s\n",
snd_strerror(ret));
return ret;
}
/* set the count of channels */
ret = snd_pcm_hw_params_set_channels(handle, hwparams, channels);
if (ret < 0) {
fprintf(stderr,
"Channels count (%d) not available for playbacks: %s\n",
channels, snd_strerror(ret));
return ret;
}
/* set the stream rate */
int rate = sampleRate;
ret = snd_pcm_hw_params_set_rate(handle, hwparams, rate, 0);
if (ret < 0) {
fprintf(stderr, "Rate %dHz not available for playback: %s\n",
sampleRate, snd_strerror(ret));
return ret;
}
if (rate != sampleRate) {
fprintf(stderr, "Rate doesn't match (requested %dHz, get %dHz)\n",
rate, ret);
return -EINVAL;
}
/* set the buffer frames */
unsigned int buffer_frames = bufferSize / 2 / channels; // bytes to frames
ret = snd_pcm_hw_params_set_buffer_size(handle, hwparams, buffer_frames);
if (ret < 0) {
fprintf(stderr, "Unable to set buffer size %d for playback: %s\n",
buffer_frames, snd_strerror(ret));
return ret;
}
/* set the period time */
dir = 0;
ret = snd_pcm_hw_params_set_period_time_near(handle, hwparams,
&period_time, &dir);
if (ret < 0) {
fprintf(stderr, "Unable to set period time %d for playback: %s\n",
period_time, snd_strerror(ret));
return ret;
}
/* write the parameters to device */
ret = snd_pcm_hw_params(handle, hwparams);
if (ret < 0) {
fprintf(stderr, "Unable to set hw params for playback: %s\n",
snd_strerror(ret));
return ret;
}
dump_hwparams(handle);
}
int initAlsa(char **argv,int optind)
{
snd_pcm_hw_params_t *hw_params;
int err,n;
unsigned int Fs;
if ((err = snd_pcm_open(&capture_handle, argv[optind],
SND_PCM_STREAM_CAPTURE, 0)) < 0) {
fprintf(stderr, "Alsa cannot open audio device %s (%s)\n",argv[optind], snd_strerror(err));
return 1;
}
if ((err = snd_pcm_hw_params_malloc(&hw_params)) < 0) {
fprintf(stderr,
"Alsa cannot allocate hardware parameter structure (%s)\n",snd_strerror(err));
return 1;
}
if ((err = snd_pcm_hw_params_any(capture_handle, hw_params)) < 0) {
fprintf(stderr,
"Alsa cannot initialize hardware parameter structure (%s)\n",snd_strerror(err));
return 1;
}
if ((err = snd_pcm_hw_params_set_access(capture_handle, hw_params,SND_PCM_ACCESS_RW_INTERLEAVED)) < 0) {
fprintf(stderr, "Alsa cannot set access type (%s)\n",snd_strerror(err));
return 1;
}
if ((err = snd_pcm_hw_params_set_format(capture_handle, hw_params,SND_PCM_FORMAT_S16)) < 0) {
fprintf(stderr, "Alsa cannot set sample format (%s)\n",snd_strerror(err));
return 1;
}
snd_pcm_hw_params_set_rate_resample(capture_handle, hw_params,0);
Fs=19200;
n=1;
if ((err = snd_pcm_hw_params_set_rate_near(capture_handle, hw_params, &Fs,&n)) < 0) {
fprintf(stderr, "Alsa cannot set sample rate (%s)\n",snd_strerror(err));
return 1;
}
fprintf(stderr, "Alsa sample rate %d\n",Fs);
if(snd_pcm_hw_params_get_channels (hw_params, &nbch)!=0) {
fprintf(stderr, "Alsa cannot get number of channels\n");
return 1;
}
if(nbch>4) {
fprintf(stderr, "Alsa too much channels\n");
return 1;
}
if ((err = snd_pcm_hw_params(capture_handle, hw_params)) < 0) {
fprintf(stderr, "Alsa cannot set parameters (%s)\n",snd_strerror(err));
return 1;
}
snd_pcm_hw_params_free(hw_params);
if ((err = snd_pcm_prepare(capture_handle)) < 0) {
fprintf(stderr,
"Alsa cannot prepare audio interface for use (%s)\n",snd_strerror(err));
return 1;
}
for(n=0; n<nbch; n++) {
channel[n].chn=n;
channel[n].Infs=Fs;
channel[n].InBuff=malloc(MAXNBFRAMES*sizeof(sample_t));
}
for(; n<MAXNBCHANNELS; n++) channel[n].Infs=0;
return (0);
}
static RD_BOOL
alsa_set_format(snd_pcm_t * pcm, RD_WAVEFORMATEX * pwfx)
{
snd_pcm_hw_params_t *hwparams = NULL;
int err;
unsigned int buffertime;
short samplewidth;
int audiochannels;
unsigned int rate;
samplewidth = pwfx->wBitsPerSample / 8;
if ((err = snd_pcm_hw_params_malloc(&hwparams)) < 0)
{
error("snd_pcm_hw_params_malloc: %s\n", snd_strerror(err));
return False;
}
if ((err = snd_pcm_hw_params_any(pcm, hwparams)) < 0)
{
error("snd_pcm_hw_params_any: %s\n", snd_strerror(err));
return False;
}
if ((err = snd_pcm_hw_params_set_access(pcm, hwparams, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0)
{
error("snd_pcm_hw_params_set_access: %s\n", snd_strerror(err));
return False;
}
if (pwfx->wBitsPerSample == 16)
{
if ((err = snd_pcm_hw_params_set_format(pcm, hwparams, SND_PCM_FORMAT_S16_LE)) < 0)
{
error("snd_pcm_hw_params_set_format: %s\n", snd_strerror(err));
return False;
}
}
else
{
if ((err = snd_pcm_hw_params_set_format(pcm, hwparams, SND_PCM_FORMAT_S8)) < 0)
{
error("snd_pcm_hw_params_set_format: %s\n", snd_strerror(err));
return False;
}
}
#if 0
if ((err = snd_pcm_hw_params_set_rate_resample(pcm, hwparams, 1)) < 0)
{
error("snd_pcm_hw_params_set_rate_resample: %s\n", snd_strerror(err));
return False;
}
#endif
rate = pwfx->nSamplesPerSec;
if ((err = snd_pcm_hw_params_set_rate_near(pcm, hwparams, &rate, 0)) < 0)
{
error("snd_pcm_hw_params_set_rate_near: %s\n", snd_strerror(err));
return False;
}
audiochannels = pwfx->nChannels;
if ((err = snd_pcm_hw_params_set_channels(pcm, hwparams, pwfx->nChannels)) < 0)
{
error("snd_pcm_hw_params_set_channels: %s\n", snd_strerror(err));
return False;
}
buffertime = 500000; /* microseconds */
if ((err = snd_pcm_hw_params_set_buffer_time_near(pcm, hwparams, &buffertime, 0)) < 0)
{
error("snd_pcm_hw_params_set_buffer_time_near: %s\n", snd_strerror(err));
return False;
}
if ((err = snd_pcm_hw_params(pcm, hwparams)) < 0)
{
error("snd_pcm_hw_params: %s\n", snd_strerror(err));
return False;
}
snd_pcm_hw_params_free(hwparams);
if ((err = snd_pcm_prepare(pcm)) < 0)
{
error("snd_pcm_prepare: %s\n", snd_strerror(err));
return False;
}
reopened = True;
return True;
}
static int set_hwparams(snd_pcm_t *handle,
snd_pcm_hw_params_t *params,
snd_pcm_access_t access)
{
unsigned int rrate;
int err;
/* choose all parameters */
err = snd_pcm_hw_params_any(handle, params);
if (err < 0) {
printf("Broken configuration for playback: no configurations available: %s\n", snd_strerror(err));
return err;
}
/* set hardware resampling */
err = snd_pcm_hw_params_set_rate_resample(handle, params, 0);
if (err < 0) {
printf("Resampling setup failed for playback: %s\n", snd_strerror(err));
return err;
}
/* set the interleaved read/write format */
err = snd_pcm_hw_params_set_access(handle, params, access);
if (err < 0) {
printf("Access type not available for playback: %s\n", snd_strerror(err));
return err;
}
/* set the sample format */
err = snd_pcm_hw_params_set_format(handle, params, format);
if (err < 0) {
printf("Sample format not available for playback: %s\n", snd_strerror(err));
return err;
}
/* set the count of channels */
err = snd_pcm_hw_params_set_channels(handle, params, channels);
if (err < 0) {
printf("Channels count (%i) not available for playbacks: %s\n", channels, snd_strerror(err));
return err;
}
/* set the stream rate */
// rrate = rate;
err = snd_pcm_hw_params_set_rate(handle, params, rate, 0);
if (err < 0) {
printf("Rate %iHz not available for playback: %s\n", rate, snd_strerror(err));
return err;
}
err = snd_pcm_hw_params_set_buffer_size(handle, params, BUFFER_SIZE);
if (err < 0) {
printf("Unable to set buffer size %lu for playback: %s\n", PERIOD_SIZE, snd_strerror(err));
return err;
}
int dir;
err = snd_pcm_hw_params_set_period_size(handle, params, PERIOD_SIZE, 0);
if (err < 0) {
printf("Unable to set period size %lu for playback: %s\n", PERIOD_SIZE, snd_strerror(err));
return err;
}
/* write the parameters to device */
err = snd_pcm_hw_params(handle, params);
if (err < 0) {
printf("Unable to set hw params for playback: %s\n", snd_strerror(err));
return err;
}
return 0;
}
static int setparams(snd_pcm_t *phandle, snd_pcm_t *chandle,
snd_pcm_format_t format,
int latency, int allow_resample,
struct final_params *negotiated)
{
int i;
unsigned ratep, ratec = 0;
unsigned ratemin = 32000, ratemax = 96000, val;
int err, channels = 2;
snd_pcm_hw_params_t *p_hwparams, *c_hwparams;
snd_pcm_sw_params_t *p_swparams, *c_swparams;
snd_pcm_uframes_t c_size, p_psize, c_psize;
/* Our latency is 2 periods (in usecs) */
unsigned int c_periods = 2, p_periods;
unsigned int c_periodtime, p_periodtime;
const unsigned int prefered_rates[] = { 44100, 48000, 32000 };
snd_pcm_hw_params_alloca(&p_hwparams);
snd_pcm_hw_params_alloca(&c_hwparams);
snd_pcm_sw_params_alloca(&p_swparams);
snd_pcm_sw_params_alloca(&c_swparams);
if (setparams_stream(chandle, c_hwparams, format, &channels, "capture"))
return 1;
if (setparams_stream(phandle, p_hwparams, format, &channels, "playback"))
return 1;
if (allow_resample) {
err = snd_pcm_hw_params_set_rate_resample(chandle, c_hwparams, 1);
if (err < 0) {
fprintf(error_fp, "alsa: Resample setup failed: %s\n", snd_strerror(err));
return 1;
} else if (verbose)
fprintf(error_fp, "alsa: Resample enabled.\n");
}
err = snd_pcm_hw_params_get_rate_min(c_hwparams, &ratemin, 0);
if (err >= 0 && verbose)
fprintf(error_fp, "alsa: Capture min rate is %d\n", ratemin);
err = snd_pcm_hw_params_get_rate_max(c_hwparams, &ratemax, 0);
if (err >= 0 && verbose)
fprintf(error_fp, "alsa: Capture max rate is %u\n", ratemax);
err = snd_pcm_hw_params_get_rate_min(p_hwparams, &val, 0);
if (err >= 0) {
if (verbose)
fprintf(error_fp, "alsa: Playback min rate is %u\n", val);
if (val > ratemin)
ratemin = val;
}
err = snd_pcm_hw_params_get_rate_max(p_hwparams, &val, 0);
if (err >= 0) {
if (verbose)
fprintf(error_fp, "alsa: Playback max rate is %u\n", val);
if (val < ratemax)
ratemax = val;
}
if (verbose)
fprintf(error_fp,
"alsa: Will search a common rate between %u and %u\n",
ratemin, ratemax);
/* First try a set of common rates */
err = -1;
for (i = 0; i < ARRAY_SIZE(prefered_rates); i++) {
if (prefered_rates[i] < ratemin || prefered_rates[i] > ratemax)
continue;
ratep = ratec = prefered_rates[i];
err = alsa_try_rate(phandle, chandle, p_hwparams, c_hwparams,
allow_resample, &ratep, &ratec);
if (err == 0)
break;
}
if (err != 0) {
if (ratemin >= 44100) {
for (i = ratemin; i <= ratemax; i += 100) {
ratep = ratec = i;
err = alsa_try_rate(phandle, chandle, p_hwparams, c_hwparams,
allow_resample, &ratep, &ratec);
if (err == 0)
break;
}
} else {
for (i = ratemax; i >= ratemin; i -= 100) {
ratep = ratec = i;
err = alsa_try_rate(phandle, chandle, p_hwparams, c_hwparams,
allow_resample, &ratep, &ratec);
if (err == 0)
break;
}
}
}
if (err < 0) {
fprintf(error_fp, "alsa: Failed to set a supported rate: %s\n",
snd_strerror(err));
return 1;
}
if (ratep != ratec) {
if (verbose || allow_resample)
fprintf(error_fp,
"alsa: Couldn't find a rate that it is supported by both playback and capture\n");
return 2;
}
if (verbose)
fprintf(error_fp, "alsa: Using Rate %d\n", ratec);
/* Negotiate period parameters */
c_periodtime = latency * 1000 / c_periods;
getparams_periods(chandle, c_hwparams, &c_periodtime, &c_periods, "capture");
p_periods = c_periods * 2;
p_periodtime = c_periodtime;
getparams_periods(phandle, p_hwparams, &p_periodtime, &p_periods, "playback");
c_periods = p_periods / 2;
/*
* Some playback devices support a very limited periodtime range. If the user needs to
* use a higher latency to avoid overrun/underrun, use an alternate algorithm of incresing
* the number of periods, to archive the needed latency
*/
if (p_periodtime < c_periodtime) {
c_periodtime = p_periodtime;
c_periods = round (latency * 1000.0 / c_periodtime + 0.5);
getparams_periods(chandle, c_hwparams, &c_periodtime, &c_periods, "capture");
p_periods = c_periods * 2;
p_periodtime = c_periodtime;
getparams_periods(phandle, p_hwparams, &p_periodtime, &p_periods, "playback");
c_periods = p_periods / 2;
}
if (setparams_periods(chandle, c_hwparams, &c_periodtime, &c_periods, "capture"))
return 1;
/* Note we use twice as much periods for the playback buffer, since we
will get a period size near the requested time and we don't want it to
end up smaller then the capture buffer as then we could end up blocking
on writing to it. Note we will configure the playback dev to start
playing as soon as it has 2 capture periods worth of data, so this
won't influence latency */
if (setparams_periods(phandle, p_hwparams, &p_periodtime, &p_periods, "playback"))
return 1;
snd_pcm_hw_params_get_period_size(p_hwparams, &p_psize, NULL);
snd_pcm_hw_params_get_period_size(c_hwparams, &c_psize, NULL);
snd_pcm_hw_params_get_buffer_size(c_hwparams, &c_size);
latency = c_periods * c_psize;
if (setparams_set(phandle, p_hwparams, p_swparams, latency, "playback"))
return 1;
if (setparams_set(chandle, c_hwparams, c_swparams, c_psize, "capture"))
return 1;
if ((err = snd_pcm_prepare(phandle)) < 0) {
fprintf(error_fp, "alsa: Prepare error: %s\n", snd_strerror(err));
return 1;
}
if (verbose) {
fprintf(error_fp, "alsa: Negociated configuration:\n");
snd_pcm_dump_setup(phandle, output);
snd_pcm_dump_setup(chandle, output);
fprintf(error_fp, "alsa: Parameters are %iHz, %s, %i channels\n",
ratep, snd_pcm_format_name(format), channels);
fprintf(error_fp, "alsa: Set bitrate to %u%s, buffer size is %u\n", ratec,
allow_resample ? " with resample enabled at playback": "",
(unsigned int)c_size);
}
negotiated->bufsize = c_size;
negotiated->rate = ratep;
negotiated->channels = channels;
negotiated->latency = latency;
return 0;
}
static int
palsa_set_hw_params (ddb_waveformat_t *fmt) {
snd_pcm_hw_params_t *hw_params = NULL;
int err = 0;
memcpy (&plugin.fmt, fmt, sizeof (ddb_waveformat_t));
if (!plugin.fmt.channels) {
// generic format
plugin.fmt.bps = 16;
plugin.fmt.is_float = 0;
plugin.fmt.channels = 2;
plugin.fmt.samplerate = 44100;
plugin.fmt.channelmask = 3;
}
snd_pcm_nonblock(audio, 0);
snd_pcm_drain (audio);
snd_pcm_nonblock(audio, 1);
if ((err = snd_pcm_hw_params_malloc (&hw_params)) < 0) {
fprintf (stderr, "cannot allocate hardware parameter structure (%s)\n",
snd_strerror (err));
goto error;
}
if ((err = snd_pcm_hw_params_any (audio, hw_params)) < 0) {
fprintf (stderr, "cannot initialize hardware parameter structure (%s)\n",
snd_strerror (err));
goto error;
}
if ((err = snd_pcm_hw_params_set_access (audio, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0) {
fprintf (stderr, "cannot set access type (%s)\n",
snd_strerror (err));
goto error;
}
snd_pcm_format_t sample_fmt;
switch (plugin.fmt.bps) {
case 8:
sample_fmt = SND_PCM_FORMAT_S8;
break;
case 16:
#if WORDS_BIGENDIAN
sample_fmt = SND_PCM_FORMAT_S16_BE;
#else
sample_fmt = SND_PCM_FORMAT_S16_LE;
#endif
break;
case 24:
#if WORDS_BIGENDIAN
sample_fmt = SND_PCM_FORMAT_S24_3BE;
#else
sample_fmt = SND_PCM_FORMAT_S24_3LE;
#endif
break;
case 32:
if (plugin.fmt.is_float) {
#if WORDS_BIGENDIAN
sample_fmt = SND_PCM_FORMAT_FLOAT_BE;
#else
sample_fmt = SND_PCM_FORMAT_FLOAT_LE;
#endif
}
else {
#if WORDS_BIGENDIAN
sample_fmt = SND_PCM_FORMAT_S32_BE;
#else
sample_fmt = SND_PCM_FORMAT_S32_LE;
#endif
}
break;
}
if ((err = snd_pcm_hw_params_set_format (audio, hw_params, sample_fmt)) < 0) {
fprintf (stderr, "cannot set sample format to %d bps (error: %s), trying all supported formats\n", plugin.fmt.bps, snd_strerror (err));
int fmt_cnt[] = { 16, 24, 32, 32, 8 };
#if WORDS_BIGENDIAN
int fmt[] = { SND_PCM_FORMAT_S16_BE, SND_PCM_FORMAT_S24_3BE, SND_PCM_FORMAT_S32_BE, SND_PCM_FORMAT_FLOAT_BE, SND_PCM_FORMAT_S8, -1 };
#else
int fmt[] = { SND_PCM_FORMAT_S16_LE, SND_PCM_FORMAT_S24_3LE, SND_PCM_FORMAT_S32_LE, SND_PCM_FORMAT_FLOAT_LE, SND_PCM_FORMAT_S8, -1 };
#endif
// 1st try formats with higher bps
int i = 0;
for (i = 0; fmt[i] != -1; i++) {
if (fmt[i] != sample_fmt && fmt_cnt[i] > plugin.fmt.bps) {
if (snd_pcm_hw_params_set_format (audio, hw_params, fmt[i]) >= 0) {
fprintf (stderr, "Found compatible format %d bps\n", fmt_cnt[i]);
sample_fmt = fmt[i];
break;
}
}
}
if (fmt[i] == -1) {
// next try formats with lower bps
i = 0;
for (i = 0; fmt[i] != -1; i++) {
if (fmt[i] != sample_fmt && fmt_cnt[i] < plugin.fmt.bps) {
if (snd_pcm_hw_params_set_format (audio, hw_params, fmt[i]) >= 0) {
fprintf (stderr, "Found compatible format %d bps\n", fmt_cnt[i]);
sample_fmt = fmt[i];
break;
}
}
}
}
if (fmt[i] == -1) {
fprintf (stderr, "Fallback format could not be found\n");
goto error;
}
}
snd_pcm_hw_params_get_format (hw_params, &sample_fmt);
trace ("chosen sample format: %04Xh\n", (int)sample_fmt);
int val = plugin.fmt.samplerate;
int ret = 0;
if ((err = snd_pcm_hw_params_set_rate_resample (audio, hw_params, conf_alsa_resample)) < 0) {
fprintf (stderr, "cannot setup resampling (%s)\n",
snd_strerror (err));
goto error;
}
if ((err = snd_pcm_hw_params_set_rate_near (audio, hw_params, &val, &ret)) < 0) {
fprintf (stderr, "cannot set sample rate (%s)\n",
snd_strerror (err));
goto error;
}
plugin.fmt.samplerate = val;
trace ("chosen samplerate: %d Hz\n", val);
int chanmin, chanmax;
snd_pcm_hw_params_get_channels_min (hw_params, &chanmin);
snd_pcm_hw_params_get_channels_max (hw_params, &chanmax);
trace ("minchan: %d, maxchan: %d\n", chanmin, chanmax);
int nchan = plugin.fmt.channels;
if (nchan > chanmax) {
nchan = chanmax;
}
else if (nchan < chanmin) {
nchan = chanmin;
}
trace ("setting chan=%d\n", nchan);
if ((err = snd_pcm_hw_params_set_channels (audio, hw_params, nchan)) < 0) {
fprintf (stderr, "cannot set channel count (%s)\n",
snd_strerror (err));
}
snd_pcm_hw_params_get_channels (hw_params, &nchan);
trace ("alsa channels: %d\n", nchan);
req_buffer_size = deadbeef->conf_get_int ("alsa.buffer", DEFAULT_BUFFER_SIZE);
req_period_size = deadbeef->conf_get_int ("alsa.period", DEFAULT_PERIOD_SIZE);
buffer_size = req_buffer_size;
period_size = req_period_size;
trace ("trying buffer size: %d frames\n", (int)buffer_size);
trace ("trying period size: %d frames\n", (int)period_size);
snd_pcm_hw_params_set_buffer_size_near (audio, hw_params, &buffer_size);
snd_pcm_hw_params_set_period_size_near (audio, hw_params, &period_size, NULL);
trace ("alsa buffer size: %d frames\n", (int)buffer_size);
trace ("alsa period size: %d frames\n", (int)period_size);
if ((err = snd_pcm_hw_params (audio, hw_params)) < 0) {
fprintf (stderr, "cannot set parameters (%s)\n",
snd_strerror (err));
goto error;
}
plugin.fmt.is_float = 0;
switch (sample_fmt) {
case SND_PCM_FORMAT_S8:
plugin.fmt.bps = 8;
break;
case SND_PCM_FORMAT_S16_BE:
case SND_PCM_FORMAT_S16_LE:
plugin.fmt.bps = 16;
break;
case SND_PCM_FORMAT_S24_3BE:
case SND_PCM_FORMAT_S24_3LE:
plugin.fmt.bps = 24;
break;
case SND_PCM_FORMAT_S32_BE:
case SND_PCM_FORMAT_S32_LE:
plugin.fmt.bps = 32;
break;
case SND_PCM_FORMAT_FLOAT_LE:
case SND_PCM_FORMAT_FLOAT_BE:
plugin.fmt.bps = 32;
plugin.fmt.is_float = 1;
break;
}
trace ("chosen bps: %d (%s)\n", plugin.fmt.bps, plugin.fmt.is_float ? "float" : "int");
plugin.fmt.channels = nchan;
plugin.fmt.channelmask = 0;
if (nchan == 1) {
plugin.fmt.channelmask = DDB_SPEAKER_FRONT_LEFT;
}
if (nchan == 2) {
plugin.fmt.channelmask = DDB_SPEAKER_FRONT_LEFT | DDB_SPEAKER_FRONT_RIGHT;
}
if (nchan == 3) {
plugin.fmt.channelmask = DDB_SPEAKER_FRONT_LEFT | DDB_SPEAKER_FRONT_RIGHT | DDB_SPEAKER_LOW_FREQUENCY;
}
if (nchan == 4) {
plugin.fmt.channelmask = DDB_SPEAKER_FRONT_LEFT | DDB_SPEAKER_FRONT_RIGHT | DDB_SPEAKER_BACK_LEFT | DDB_SPEAKER_BACK_RIGHT;
}
if (nchan == 5) {
plugin.fmt.channelmask = DDB_SPEAKER_FRONT_LEFT | DDB_SPEAKER_FRONT_RIGHT | DDB_SPEAKER_BACK_LEFT | DDB_SPEAKER_BACK_RIGHT | DDB_SPEAKER_FRONT_CENTER;
}
if (nchan == 6) {
plugin.fmt.channelmask = DDB_SPEAKER_FRONT_LEFT | DDB_SPEAKER_FRONT_RIGHT | DDB_SPEAKER_BACK_LEFT | DDB_SPEAKER_BACK_RIGHT | DDB_SPEAKER_FRONT_CENTER | DDB_SPEAKER_LOW_FREQUENCY;
}
if (nchan == 7) {
plugin.fmt.channelmask = DDB_SPEAKER_FRONT_LEFT | DDB_SPEAKER_FRONT_RIGHT | DDB_SPEAKER_BACK_LEFT | DDB_SPEAKER_BACK_RIGHT | DDB_SPEAKER_FRONT_CENTER | DDB_SPEAKER_SIDE_LEFT | DDB_SPEAKER_SIDE_RIGHT;
}
if (nchan == 8) {
plugin.fmt.channelmask = DDB_SPEAKER_FRONT_LEFT | DDB_SPEAKER_FRONT_RIGHT | DDB_SPEAKER_BACK_LEFT | DDB_SPEAKER_BACK_RIGHT | DDB_SPEAKER_FRONT_CENTER | DDB_SPEAKER_SIDE_LEFT | DDB_SPEAKER_SIDE_RIGHT | DDB_SPEAKER_LOW_FREQUENCY;
}
error:
if (err < 0) {
memset (&plugin.fmt, 0, sizeof (ddb_waveformat_t));
}
if (hw_params) {
snd_pcm_hw_params_free (hw_params);
}
return err;
}
static void *_msynth_thread_main(void *arg)
{
int i;
int err;
int sample;
int processed;
struct sampleclock sc = {0, 0, 0.0f, 0.0f};
msynth_frame fb = NULL;
puts("synthread: started");
/* Begin initialization of ALSA */
/* snd_pcm_open(pcm_handle, device_name, stream_type, open_mode) */
err = snd_pcm_open(&pcm, config.device_name, SND_PCM_STREAM_PLAYBACK, 0);
ALSERT("opening audio device");
/* First ALSA hardware settings */
/* Allocate HW params */
err = snd_pcm_hw_params_malloc(&hw_p);
ALSERT("allocating hw params");
/* Get default HW parameters */
err = snd_pcm_hw_params_any(pcm, hw_p);
ALSERT("requesting hw default params");
/* Disable software resampling */
err = snd_pcm_hw_params_set_rate_resample(pcm, hw_p, config.resample);
ALSERT("disabling software resampling");
/* Configure sample rate */
if (config.srate != -1)
srate = config.srate;
else {
/* Get maximum hardware samplerate */
err = snd_pcm_hw_params_get_rate_max(hw_p, &srate, &dir);
ALSERT("requesting maximum hardware samplerate");
}
/* Set sample rate
* snd_pcm_hw_params_set_rate_near(pcn, hw_p, *rate,
* 0 (== set exact rate))
*/
err = snd_pcm_hw_params_set_rate_near(pcm, hw_p, &srate, 0);
ALSERT("setting samplerate");
printf("synthread: Detected samplerate of %u\n", srate);
/* RW interleaved access (means we will use the snd_pcm_writei function) */
err = snd_pcm_hw_params_set_access(pcm, hw_p,
SND_PCM_ACCESS_RW_INTERLEAVED);
ALSERT("setting access mode");
/* native-endian 16-bit signed sample format */
err = snd_pcm_hw_params_set_format(pcm, hw_p, SND_PCM_FORMAT_S16);
ALSERT("setting sample format");
/* Switch to 2.0ch audio */
err = snd_pcm_hw_params_set_channels(pcm, hw_p, 2);
ALSERT("switching to 2.0ch audio");
if (config.buffer_time != -1) {
/* Set configured buffer time */
err = snd_pcm_hw_params_set_buffer_time_near(pcm, hw_p,
&config.buffer_time, &dir);
ALSERT("setting buffer time");
/* Fetch resulting size */
err = snd_pcm_hw_params_get_buffer_size(hw_p, &buffer_size);
ALSERT("getting buffer size");
} else {
/* Since we want the interactive synthesizer to be very responsive
* select a minimum buffer size.
*/
err = snd_pcm_hw_params_set_buffer_size_first(pcm, hw_p, &buffer_size);
ALSERT("setting buffer size");
}
printf("synthread: Selected buffersize of %lu\n", buffer_size);
printf("synthread: Response delay is approximately %.2f ms\n",
(double)buffer_size / (double)srate * 1000.0);
if (config.period_time != -1) {
err = snd_pcm_hw_params_set_period_time_near(pcm, hw_p,
&config.period_time, &dir);
ALSERT("setting period time");
err = snd_pcm_hw_params_get_period_size(hw_p, &period_size, &dir);
ALSERT("getting period size");
} else {
/* Select a period time of half the buffer time
* since this improves processing performance
*/
err = snd_pcm_hw_params_set_period_size_last(pcm, hw_p, &period_size, &dir);
ALSERT("setting period size");
}
if (dir)
printf("synthread: Selected period size near %lu\n", period_size);
else
printf("synthread: Selected period size of %lu\n", period_size);
/* write hw parameters to device */
err = snd_pcm_hw_params(pcm, hw_p);
ALSERT("writing hw params");
/* Begin ALSA software side setup */
/* Allocate SW params */
err = snd_pcm_sw_params_malloc(&sw_p);
ALSERT("allocating sw params");
/* Request software current settings */
err = snd_pcm_sw_params_current(pcm, sw_p);
ALSERT("requesting current sw params");
/* Automatically start playing after the first period is written */
err = snd_pcm_sw_params_set_start_threshold(pcm, sw_p, period_size);
ALSERT("settings start threshold");
/* XRUN when buffer is empty */
err = snd_pcm_sw_params_set_stop_threshold(pcm, sw_p, buffer_size * 2);
ALSERT("setting stop threshold");
/* Block synthesizer when there is not at least period frames available */
err = snd_pcm_sw_params_set_avail_min(pcm, sw_p, period_size);
ALSERT("setting minimum free frames");
/* Write software parameters */
err = snd_pcm_sw_params(pcm, sw_p);
ALSERT("writing sw params");
printf("synthread: Audio system configured.\n");
/* Prepare device for playback */
err = snd_pcm_prepare(pcm);
ALSERT("preparing device");
/* Allocate a period sized framebuffer
* (yup an audio buffer is in ALSA speak indeed called a framebuffer)
*/
fb = malloc(sizeof(struct _msynth_frame) * period_size);
if (!fb) {
perror("malloc framebuffer failed");
exit(1);
}
/* Set sampleclock to 0 */
sc.samples = 0;
sc.samplerate = srate;
sc.cycle = 0.0f;
sc.seconds = 0.0f;
/* Initially the <root> variable describing the flow of sound within
* the synthesizer is configured to be a NULL signal. (silence)
*/
/* Signal successful completion of initialization */
pthread_mutex_lock(&mutex);
pthread_cond_signal(&cond);
pthread_mutex_unlock(&mutex);
/* -------------- Main loop --------------- */
while (!shutdown) {
/* Only during generation we need the synth tree to be static */
synth_lock_graphs();
for (i = 0; i < period_size; i++) {
/* Evaluate variables */
ssv_eval(sc);
sample = (int)(32767.5 * ssv_get_var_eval("left") * volume);
/* Clip samples */
if (sample > 32767) sample = 32767;
if (sample < -32768) sample = -32768;
fb[i].left = (short)sample;
sample = (int)(32767.5 * ssv_get_var_eval("right") * volume);
/* Clip samples */
if (sample > 32767) sample = 32767;
if (sample < -32768) sample = -32768;
fb[i].right = (short)sample;
sc = sc_from_samples(sc.samplerate, sc.samples + 1);
}
synth_unlock_graphs();
/* Send audio to sound card */
processed = 0;
while (processed != period_size) {
err = snd_pcm_writei(pcm, fb + processed, period_size - processed);
/* Retry on interruption by signal */
if (err == -EAGAIN)
continue;
/* Recover from XRUN/suspend */
if (err < 0) {
err = synth_recover(err);
ALSERT("sending audio");
continue;
}
/* Update processed samples */
processed += err;
}
}
puts("synthread: shutting down");
/* Dump any statistics recorded */
if (recover_resumes)
printf("synthread: Device was resumed %i times\n", recover_resumes);
if (recover_xruns)
printf("synthread: %i xrun recoveries were needed\n", recover_xruns);
printf("synthread: processed %i samples\n", sc.samples);
/* Wait for playback to complete */
err = snd_pcm_drain(pcm);
ALSERT("draining device");
/* Shutdown PCM device */
err = snd_pcm_close(pcm);
ALSERT("closing audio device");
/* Clean up parameters */
snd_pcm_hw_params_free(hw_p);
snd_pcm_sw_params_free(sw_p);
return NULL;
}
/*
open & setup audio device
return: 1=success 0=fail
*/
static int init(int rate_hz, int channels, int format, int flags)
{
unsigned int alsa_buffer_time = 500000; /* 0.5 s */
unsigned int alsa_fragcount = 16;
int err;
int block;
strarg_t device;
snd_pcm_uframes_t chunk_size;
snd_pcm_uframes_t bufsize;
snd_pcm_uframes_t boundary;
const opt_t subopts[] = {
{"block", OPT_ARG_BOOL, &block, NULL},
{"device", OPT_ARG_STR, &device, str_maxlen},
{NULL}
};
char alsa_device[ALSA_DEVICE_SIZE + 1];
// make sure alsa_device is null-terminated even when using strncpy etc.
memset(alsa_device, 0, ALSA_DEVICE_SIZE + 1);
mp_msg(MSGT_AO,MSGL_V,"alsa-init: requested format: %d Hz, %d channels, %x\n", rate_hz,
channels, format);
alsa_handler = NULL;
#if SND_LIB_VERSION >= 0x010005
mp_msg(MSGT_AO,MSGL_V,"alsa-init: using ALSA %s\n", snd_asoundlib_version());
#else
mp_msg(MSGT_AO,MSGL_V,"alsa-init: compiled for ALSA-%s\n", SND_LIB_VERSION_STR);
#endif
snd_lib_error_set_handler(alsa_error_handler);
ao_data.samplerate = rate_hz;
ao_data.format = format;
ao_data.channels = channels;
switch (format)
{
case AF_FORMAT_S8:
alsa_format = SND_PCM_FORMAT_S8;
break;
case AF_FORMAT_U8:
alsa_format = SND_PCM_FORMAT_U8;
break;
case AF_FORMAT_U16_LE:
alsa_format = SND_PCM_FORMAT_U16_LE;
break;
case AF_FORMAT_U16_BE:
alsa_format = SND_PCM_FORMAT_U16_BE;
break;
case AF_FORMAT_AC3_LE:
case AF_FORMAT_S16_LE:
case AF_FORMAT_IEC61937_LE:
alsa_format = SND_PCM_FORMAT_S16_LE;
break;
case AF_FORMAT_AC3_BE:
case AF_FORMAT_S16_BE:
case AF_FORMAT_IEC61937_BE:
alsa_format = SND_PCM_FORMAT_S16_BE;
break;
case AF_FORMAT_U32_LE:
alsa_format = SND_PCM_FORMAT_U32_LE;
break;
case AF_FORMAT_U32_BE:
alsa_format = SND_PCM_FORMAT_U32_BE;
break;
case AF_FORMAT_S32_LE:
alsa_format = SND_PCM_FORMAT_S32_LE;
break;
case AF_FORMAT_S32_BE:
alsa_format = SND_PCM_FORMAT_S32_BE;
break;
case AF_FORMAT_U24_LE:
alsa_format = SND_PCM_FORMAT_U24_3LE;
break;
case AF_FORMAT_U24_BE:
alsa_format = SND_PCM_FORMAT_U24_3BE;
break;
case AF_FORMAT_S24_LE:
alsa_format = SND_PCM_FORMAT_S24_3LE;
break;
case AF_FORMAT_S24_BE:
alsa_format = SND_PCM_FORMAT_S24_3BE;
break;
case AF_FORMAT_FLOAT_LE:
alsa_format = SND_PCM_FORMAT_FLOAT_LE;
break;
case AF_FORMAT_FLOAT_BE:
alsa_format = SND_PCM_FORMAT_FLOAT_BE;
break;
case AF_FORMAT_MU_LAW:
alsa_format = SND_PCM_FORMAT_MU_LAW;
break;
case AF_FORMAT_A_LAW:
alsa_format = SND_PCM_FORMAT_A_LAW;
break;
default:
alsa_format = SND_PCM_FORMAT_MPEG; //? default should be -1
break;
}
//subdevice parsing
// set defaults
block = 1;
/* switch for spdif
* sets opening sequence for SPDIF
* sets also the playback and other switches 'on the fly'
* while opening the abstract alias for the spdif subdevice
* 'iec958'
*/
if (AF_FORMAT_IS_IEC61937(format)) {
device.str = "iec958";
mp_msg(MSGT_AO,MSGL_V,"alsa-spdif-init: playing AC3/iec61937/iec958, %i channels\n", channels);
}
else
/* in any case for multichannel playback we should select
* appropriate device
*/
switch (channels) {
case 1:
case 2:
device.str = "default";
mp_msg(MSGT_AO,MSGL_V,"alsa-init: setup for 1/2 channel(s)\n");
break;
case 4:
if (alsa_format == SND_PCM_FORMAT_FLOAT_LE)
// hack - use the converter plugin
device.str = "plug:surround40";
else
device.str = "surround40";
mp_msg(MSGT_AO,MSGL_V,"alsa-init: device set to surround40\n");
break;
case 6:
if (alsa_format == SND_PCM_FORMAT_FLOAT_LE)
device.str = "plug:surround51";
else
device.str = "surround51";
mp_msg(MSGT_AO,MSGL_V,"alsa-init: device set to surround51\n");
break;
case 8:
if (alsa_format == SND_PCM_FORMAT_FLOAT_LE)
device.str = "plug:surround71";
else
device.str = "surround71";
mp_msg(MSGT_AO,MSGL_V,"alsa-init: device set to surround71\n");
break;
default:
device.str = "default";
mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_ChannelsNotSupported,channels);
}
device.len = strlen(device.str);
if (subopt_parse(ao_subdevice, subopts) != 0) {
print_help();
return 0;
}
parse_device(alsa_device, device.str, device.len);
mp_msg(MSGT_AO,MSGL_V,"alsa-init: using device %s\n", alsa_device);
if (!alsa_handler) {
int open_mode = block ? 0 : SND_PCM_NONBLOCK;
int isac3 = AF_FORMAT_IS_IEC61937(format);
//modes = 0, SND_PCM_NONBLOCK, SND_PCM_ASYNC
mp_msg(MSGT_AO,MSGL_V,"alsa-init: opening device in %sblocking mode\n", block ? "" : "non-");
if ((err = try_open_device(alsa_device, open_mode, isac3)) < 0)
{
if (err != -EBUSY && !block) {
mp_msg(MSGT_AO,MSGL_INFO,MSGTR_AO_ALSA_OpenInNonblockModeFailed);
if ((err = try_open_device(alsa_device, 0, isac3)) < 0) {
mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_PlaybackOpenError, snd_strerror(err));
return 0;
}
} else {
mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_PlaybackOpenError, snd_strerror(err));
return 0;
}
}
if ((err = snd_pcm_nonblock(alsa_handler, 0)) < 0) {
mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_ErrorSetBlockMode, snd_strerror(err));
} else {
mp_msg(MSGT_AO,MSGL_V,"alsa-init: device reopened in blocking mode\n");
}
snd_pcm_hw_params_alloca(&alsa_hwparams);
snd_pcm_sw_params_alloca(&alsa_swparams);
// setting hw-parameters
if ((err = snd_pcm_hw_params_any(alsa_handler, alsa_hwparams)) < 0)
{
mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToGetInitialParameters,
snd_strerror(err));
return 0;
}
err = snd_pcm_hw_params_set_access(alsa_handler, alsa_hwparams,
SND_PCM_ACCESS_RW_INTERLEAVED);
if (err < 0) {
mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToSetAccessType,
snd_strerror(err));
return 0;
}
/* workaround for nonsupported formats
sets default format to S16_LE if the given formats aren't supported */
if ((err = snd_pcm_hw_params_test_format(alsa_handler, alsa_hwparams,
alsa_format)) < 0)
{
mp_msg(MSGT_AO,MSGL_INFO,
MSGTR_AO_ALSA_FormatNotSupportedByHardware, af_fmt2str_short(format));
alsa_format = SND_PCM_FORMAT_S16_LE;
if (AF_FORMAT_IS_AC3(ao_data.format))
ao_data.format = AF_FORMAT_AC3_LE;
else if (AF_FORMAT_IS_IEC61937(ao_data.format))
ao_data.format = AF_FORMAT_IEC61937_LE;
else
ao_data.format = AF_FORMAT_S16_LE;
}
if ((err = snd_pcm_hw_params_set_format(alsa_handler, alsa_hwparams,
alsa_format)) < 0)
{
mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToSetFormat,
snd_strerror(err));
return 0;
}
if ((err = snd_pcm_hw_params_set_channels_near(alsa_handler, alsa_hwparams,
&ao_data.channels)) < 0)
{
mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToSetChannels,
snd_strerror(err));
return 0;
}
/* workaround for buggy rate plugin (should be fixed in ALSA 1.0.11)
prefer our own resampler, since that allows users to choose the resampler,
even per file if desired */
#if SND_LIB_VERSION >= 0x010009
if ((err = snd_pcm_hw_params_set_rate_resample(alsa_handler, alsa_hwparams,
0)) < 0)
{
mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToDisableResampling,
snd_strerror(err));
return 0;
}
#endif
if ((err = snd_pcm_hw_params_set_rate_near(alsa_handler, alsa_hwparams,
&ao_data.samplerate, NULL)) < 0)
{
mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToSetSamplerate2,
snd_strerror(err));
return 0;
}
bytes_per_sample = af_fmt2bits(ao_data.format) / 8;
bytes_per_sample *= ao_data.channels;
ao_data.bps = ao_data.samplerate * bytes_per_sample;
if ((err = snd_pcm_hw_params_set_buffer_time_near(alsa_handler, alsa_hwparams,
&alsa_buffer_time, NULL)) < 0)
{
mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToSetBufferTimeNear,
snd_strerror(err));
return 0;
}
if ((err = snd_pcm_hw_params_set_periods_near(alsa_handler, alsa_hwparams,
&alsa_fragcount, NULL)) < 0) {
mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToSetPeriods,
snd_strerror(err));
return 0;
}
/* finally install hardware parameters */
if ((err = snd_pcm_hw_params(alsa_handler, alsa_hwparams)) < 0)
{
mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToSetHwParameters,
snd_strerror(err));
return 0;
}
// end setting hw-params
// gets buffersize for control
if ((err = snd_pcm_hw_params_get_buffer_size(alsa_hwparams, &bufsize)) < 0)
{
mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToGetBufferSize, snd_strerror(err));
return 0;
}
else {
ao_data.buffersize = bufsize * bytes_per_sample;
mp_msg(MSGT_AO,MSGL_V,"alsa-init: got buffersize=%i\n", ao_data.buffersize);
}
if ((err = snd_pcm_hw_params_get_period_size(alsa_hwparams, &chunk_size, NULL)) < 0) {
mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToGetPeriodSize, snd_strerror(err));
return 0;
} else {
mp_msg(MSGT_AO,MSGL_V,"alsa-init: got period size %li\n", chunk_size);
}
ao_data.outburst = chunk_size * bytes_per_sample;
/* setting software parameters */
if ((err = snd_pcm_sw_params_current(alsa_handler, alsa_swparams)) < 0) {
mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToGetSwParameters,
snd_strerror(err));
return 0;
}
#if SND_LIB_VERSION >= 0x000901
if ((err = snd_pcm_sw_params_get_boundary(alsa_swparams, &boundary)) < 0) {
mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToGetBoundary,
snd_strerror(err));
return 0;
}
#else
boundary = 0x7fffffff;
#endif
/* start playing when one period has been written */
if ((err = snd_pcm_sw_params_set_start_threshold(alsa_handler, alsa_swparams, chunk_size)) < 0) {
mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToSetStartThreshold,
snd_strerror(err));
return 0;
}
/* disable underrun reporting */
if ((err = snd_pcm_sw_params_set_stop_threshold(alsa_handler, alsa_swparams, boundary)) < 0) {
mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToSetStopThreshold,
snd_strerror(err));
return 0;
}
#if SND_LIB_VERSION >= 0x000901
/* play silence when there is an underrun */
if ((err = snd_pcm_sw_params_set_silence_size(alsa_handler, alsa_swparams, boundary)) < 0) {
mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToSetSilenceSize,
snd_strerror(err));
return 0;
}
#endif
if ((err = snd_pcm_sw_params(alsa_handler, alsa_swparams)) < 0) {
mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToGetSwParameters,
snd_strerror(err));
return 0;
}
/* end setting sw-params */
mp_msg(MSGT_AO,MSGL_V,"alsa: %d Hz/%d channels/%d bpf/%d bytes buffer/%s\n",
ao_data.samplerate, ao_data.channels, (int)bytes_per_sample, ao_data.buffersize,
snd_pcm_format_description(alsa_format));
} // end switch alsa_handler (spdif)
alsa_can_pause = snd_pcm_hw_params_can_pause(alsa_hwparams);
return 1;
} // end init
bool WaveRecorder::init(uint32_t samples_per_sec,
uint32_t bits_per_sample,
uint32_t channels,
uint32_t frame_size)
{
const char* pcm_device = "default";
snd_pcm_format_t format;
int err;
_frame_size = frame_size;
switch (bits_per_sample) {
case 8:
format = SND_PCM_FORMAT_S8;
break;
case 16:
format = SND_PCM_FORMAT_S16_LE;
break;
default:
return false;
}
if ((err = snd_pcm_open(&_pcm, pcm_device, SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK)) < 0) {
LOG_ERROR("cannot open audio record device %s %s", pcm_device, snd_strerror(err));
return false;
}
if ((err = snd_pcm_hw_params_malloc(&_hw_params)) < 0) {
LOG_ERROR("cannot allocate hardware parameter structure %s", snd_strerror(err));
return false;
}
if ((err = snd_pcm_sw_params_malloc(&_sw_params)) < 0) {
LOG_ERROR("cannot allocate software parameter structure %s", snd_strerror(err));
return false;
}
if ((err = snd_pcm_hw_params_any(_pcm, _hw_params)) < 0) {
LOG_ERROR("cannot initialize hardware parameter structure %s", snd_strerror(err));
return false;
}
if ((err = snd_pcm_hw_params_set_rate_resample(_pcm, _hw_params, 1)) < 0) {
LOG_ERROR("cannot set rate resample %s", snd_strerror(err));
return false;
}
if ((err = snd_pcm_hw_params_set_access(_pcm, _hw_params, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0) {
LOG_ERROR("cannot set access type %s", snd_strerror(err));
return false;
}
if ((err = snd_pcm_hw_params_set_rate(_pcm, _hw_params, samples_per_sec, 0)) < 0) {
LOG_ERROR("cannot set sample rate %s", snd_strerror(err));
return false;
}
if ((err = snd_pcm_hw_params_set_channels(_pcm, _hw_params, channels)) < 0) {
LOG_ERROR("cannot set channel count %s", snd_strerror(err));
return false;
}
if ((err = snd_pcm_hw_params_set_format(_pcm, _hw_params, format)) < 0) {
LOG_ERROR("cannot set sample format %s", snd_strerror(err));
return false;
}
int direction = 0;
snd_pcm_uframes_t buffer_size = (samples_per_sec * 160 / 1000) / frame_size * frame_size;
if ((err = snd_pcm_hw_params_set_buffer_size_near(_pcm, _hw_params, &buffer_size)) < 0) {
LOG_ERROR("cannot set buffer size %s", snd_strerror(err));
return false;
}
snd_pcm_uframes_t period_size = frame_size;
if ((err = snd_pcm_hw_params_set_period_size_near(_pcm, _hw_params, &period_size,
&direction)) < 0) {
LOG_ERROR("cannot set period size near %s", snd_strerror(err));
return false;
}
if ((err = snd_pcm_hw_params(_pcm, _hw_params)) < 0) {
LOG_ERROR("cannot set parameters %s", snd_strerror(err));
return false;
}
if ((err = snd_pcm_sw_params_current(_pcm, _sw_params)) < 0) {
LOG_ERROR("cannot get current sw parameters %s", snd_strerror(err));
return false;
}
if ((err = snd_pcm_sw_params_set_start_threshold(_pcm, _sw_params, frame_size)) < 0) {
LOG_ERROR("cannot set start threshold %s", snd_strerror(err));
return false;
}
if ((err = snd_pcm_sw_params(_pcm, _sw_params)) < 0) {
LOG_ERROR("cannot set sw parameters %s", snd_strerror(err));
return false;
}
struct pollfd pfd;
if ((err = snd_pcm_poll_descriptors(_pcm, &pfd, 1)) < 0) {
LOG_ERROR("cannot get poll ID %s", snd_strerror(err));
return false;
}
_event_trigger = new WaveRecorder::EventTrigger(*this, pfd.fd);
_client.add_event_source(*_event_trigger);
return true;
}
bool AlsaRenderer::SetupHwParams()
{
snd_pcm_hw_params_t* params;
/* allocate a hardware parameters object */
snd_pcm_hw_params_malloc(¶ms);
/* choose all parameters */
snd_pcm_hw_params_any(m_PcmHandle, params);
/* enable hardware resampling */
snd_pcm_hw_params_set_rate_resample(m_PcmHandle, params, m_Resample);
/* set the interleaved read/write format */
snd_pcm_hw_params_set_access(m_PcmHandle, params, SND_PCM_ACCESS_RW_INTERLEAVED);
/* signed 16-bit little-endian format */
snd_pcm_hw_params_set_format(m_PcmHandle, params, SND_PCM_FORMAT_S16_LE);
/* set the count of channels */
snd_pcm_hw_params_get_channels_max(params, &m_Channels.max);
snd_pcm_hw_params_get_channels_min(params, &m_Channels.min);
if (m_Channels.val < m_Channels.min || m_Channels.val > m_Channels.max)
m_Channels.val = m_Channels.min;
snd_pcm_hw_params_set_channels(m_PcmHandle, params, m_Channels.val);
/* set the stream rate */
snd_pcm_hw_params_get_rate_max(params, &m_SampleRate.max, &m_Dir);
snd_pcm_hw_params_get_rate_min(params, &m_SampleRate.min, &m_Dir);
if (m_SampleRate.val < m_SampleRate.min || m_SampleRate.val > m_SampleRate.max)
m_SampleRate.val = m_SampleRate.min;
printf("sample rate max:%d, min:%d, val:%d\n",
m_SampleRate.max, m_SampleRate.min, m_SampleRate.val);
snd_pcm_hw_params_set_rate(m_PcmHandle, params, m_SampleRate.val, m_Dir);
/* we can set period and buffer by size or time */
/* by default we use "size" (count of frames) */
/* set how many frames in a buffer (a buffer cantains several periods) */
snd_pcm_hw_params_get_buffer_size_max(params, &m_BufferSize.max);
snd_pcm_hw_params_get_buffer_size_min(params, &m_BufferSize.min);
/* detect period time and buffer time range */
snd_pcm_hw_params_get_buffer_time_max(params, &m_BufferTime.max, &m_Dir);
snd_pcm_hw_params_get_buffer_time_min(params, &m_BufferTime.min, &m_Dir);
m_BufferTime.val = std::max(m_BufferTime.max / 2, m_BufferTime.min);
//m_BufferTime.val = m_BufferTime.min + (m_BufferTime.max - m_BufferTime.min) /2;
printf("buffer time max:%d, min:%d, val:%d\n",
m_BufferTime.max, m_BufferTime.min, m_BufferTime.val);
//(m_BufferTime.max > 120000) ? 120000 : m_BufferTime.max;//120000
snd_pcm_hw_params_set_buffer_time_near(m_PcmHandle, params, &m_BufferTime.val, &m_Dir);
snd_pcm_hw_params_get_period_time_max(params, &m_PeriodTime.max, &m_Dir);
snd_pcm_hw_params_get_period_time_min(params, &m_PeriodTime.min, &m_Dir);
m_PeriodTime.val = m_BufferTime.val / 4;
//m_PeriodTime.val = m_PeriodTime.min + (m_PeriodTime.max - m_PeriodTime.min) / 2;
printf("period time max:%d, min:%d, val:%d\n",
m_PeriodTime.max, m_PeriodTime.min, m_PeriodTime.val);
snd_pcm_hw_params_set_period_time_near(m_PcmHandle, params, &m_PeriodTime.val, &m_Dir);
int ret = snd_pcm_hw_params(m_PcmHandle, params);
if (ret != 0) {
snd_pcm_hw_params_free(params);
return false;
}
// get period size again
snd_pcm_hw_params_get_period_size(params, &m_PeriodSize.val, &m_Dir);
snd_pcm_hw_params_get_buffer_size(params, &m_BufferSize.val);
m_BitsPerSample = snd_pcm_format_physical_width(SND_PCM_FORMAT_S16_LE);
m_FrameLength = (m_BitsPerSample/8 * m_Channels.val);
//mPeriodBufferLength = m_PeriodSize.val * m_FrameLength ;
snd_pcm_hw_params_free(params);
return true;
}
bool
AlsaSource::SetupHW ()
{
bool result = false;
bool rw_available = false;
bool mmap_available = false;
#if DEBUG
bool debug = debug_flags & RUNTIME_DEBUG_AUDIO;
#else
bool debug = false;
#endif
snd_pcm_hw_params_t *params = NULL;
snd_output_t *output = NULL;
guint32 buffer_time = 100000; // request 0.1 seconds of buffer time.
int err = 0;
int dir = 0;
unsigned int rate = GetSampleRate ();
unsigned int actual_rate = rate;
guint32 channels = GetChannels ();
if (debug) {
err = snd_output_stdio_attach (&output, stdout, 0);
if (err < 0)
LOG_AUDIO ("AlsaSource::SetupHW (): Could not create alsa output: %s\n", snd_strerror (err));
}
err = snd_pcm_hw_params_malloc (¶ms);
if (err < 0) {
LOG_AUDIO ("AlsaSource::SetupHW (): Audio HW setup failed (malloc): %s\n", snd_strerror (err));
return false;
}
// choose all parameters
err = snd_pcm_hw_params_any (pcm, params);
if (err < 0) {
LOG_AUDIO ("AlsaSource::SetupHW (): Audio HW setup failed (no configurations available): %s\n", snd_strerror (err));
goto cleanup;
}
if (debug && output != NULL) {
LOG_AUDIO ("AlsaSource::SetupHW (): hw configurations:\n");
snd_pcm_hw_params_dump (params, output);
}
// enable software resampling
err = snd_pcm_hw_params_set_rate_resample (pcm, params, 1);
if (err < 0) {
LOG_AUDIO ("AlsaSource::SetupHW (): Audio HW setup failed (could not enable resampling): %s\n", snd_strerror (err));
goto cleanup;
}
// test for available transfer modes
if (!(moonlight_flags & RUNTIME_INIT_AUDIO_ALSA_MMAP)) {
err = snd_pcm_hw_params_test_access (pcm, params, SND_PCM_ACCESS_RW_INTERLEAVED);
if (err < 0) {
LOG_AUDIO ("AlsaSource::SetupHW (): Audio HW setup: RW access mode not supported (%s).\n", snd_strerror (err));
} else {
rw_available = true;
}
}
if (!(moonlight_flags & RUNTIME_INIT_AUDIO_ALSA_RW)) {
err = snd_pcm_hw_params_test_access (pcm, params, SND_PCM_ACCESS_MMAP_INTERLEAVED);
if (err < 0) {
LOG_AUDIO ("AlsaSource::SetupHW (): Audio HW setup: MMAP access mode not supported (%s).\n", snd_strerror (err));
} else {
mmap_available = true;
}
}
if (mmap_available) {
mmap = true;
} else if (rw_available) {
mmap = false;
} else {
LOG_AUDIO ("AlsaSource::SetupHW (): Audio HW setup failed, no available access mode\n");
goto cleanup;
}
LOG_AUDIO ("AlsaSource::SetupHW (): Audio HW setup: using %s access mode.\n", mmap ? "MMAP" : "RW");
// set transfer mode (mmap or rw in our case)
err = snd_pcm_hw_params_set_access (pcm, params, mmap ? SND_PCM_ACCESS_MMAP_INTERLEAVED : SND_PCM_ACCESS_RW_INTERLEAVED);
if (err < 0) {
LOG_AUDIO ("AlsaSource::SetupHW (): Audio HW setup failed (access type not available for playback): %s\n", snd_strerror (err));
goto cleanup;
}
// set audio format
switch (GetInputBytesPerSample ()) {
case 1: // 8 bit audio
err = snd_pcm_hw_params_set_format (pcm, params, SND_PCM_FORMAT_S16);
SetOutputBytesPerSample (2);
break;
case 2: // 16 bit audio
err = snd_pcm_hw_params_set_format (pcm, params, SND_PCM_FORMAT_S16);
SetOutputBytesPerSample (2);
break;
case 3: // 24 bit audio
// write as 32 bit audio, this is a lot easier to write to than 24 bit.
err = snd_pcm_hw_params_set_format (pcm, params, SND_PCM_FORMAT_S32);
SetOutputBytesPerSample (4);
break;
default:
LOG_AUDIO ("AlsaSource::SetupHW (): Invalid input bytes per sample, expected 1, 2 or 3, got %i\n", GetInputBytesPerSample ());
goto cleanup;
}
if (err < 0) {
LOG_AUDIO ("AlsaSource::SetupHW (): Audio HW setup failed (sample format not available for playback): %s\n", snd_strerror (err));
goto cleanup;
}
// set channel count
err = snd_pcm_hw_params_set_channels (pcm, params, channels);
if (err < 0) {
LOG_AUDIO ("AlsaSource::SetupHW (): Audio HW setup failed (channels count %i not available for playback): %s\n", channels, snd_strerror (err));
goto cleanup;
}
// set sample rate
err = snd_pcm_hw_params_set_rate_near (pcm, params, &actual_rate, 0);
if (err < 0) {
LOG_AUDIO ("AlsaSource::SetupHW (): Audio HW setup failed (sample rate %i Hz not available for playback): %s\n", rate, snd_strerror (err));
goto cleanup;
} else if (actual_rate != rate) {
LOG_AUDIO ("AlsaSource::SetupHW (): Audio HW setup failed (sample rate %i Hz not available for playback, only got %i Hz).\n", rate, actual_rate);
goto cleanup;
}
// set the buffer time
err = snd_pcm_hw_params_set_buffer_time_near (pcm, params, &buffer_time, &dir);
if (err < 0) {
LOG_AUDIO ("AudioNode::SetupHW (): Audio HW setup failed (unable to set buffer time %i for playback: %s\n", buffer_time, snd_strerror (err));
goto cleanup;
}
// write the parameters to device
err = snd_pcm_hw_params (pcm, params);
if (err < 0) {
LOG_AUDIO ("AlsaSource::SetupHW (): Audio HW setup failed (unable to set hw params for playback: %s)\n", snd_strerror (err));
if (debug && output != NULL) {
LOG_AUDIO ("AlsaSource::SetupHW (): current hw configurations:\n");
snd_pcm_hw_params_dump (params, output);
}
goto cleanup;
}
if (debug) {
LOG_AUDIO ("AlsaSource::SetupHW (): hardware pause support: %s\n", snd_pcm_hw_params_can_pause (params) == 0 ? "no" : "yes");
LOG_AUDIO ("AlsaSource::SetupHW (): succeeded\n");
if (output != NULL)
snd_pcm_hw_params_dump (params, output);
}
result = true;
cleanup:
snd_pcm_hw_params_free (params);
return result;
}
void create_recorder(int samp_rate,char* dev_name,int nchan,void **capture_handle_f)
{
int err;
snd_pcm_t *capture_handle;
snd_pcm_hw_params_t *hw_params;
printf("From C: *capture_handle_f=%p\n",*capture_handle_f);
if ((err = snd_pcm_open ((snd_pcm_t**)capture_handle_f, dev_name,
SND_PCM_STREAM_CAPTURE, 0)) < 0) {
fprintf (stderr, "cannot open audio device %s (%s)\n",
dev_name,
snd_strerror (err));
fprintf(stderr, "Hint: Use \"arecord -l\" to list recording devices.\n");
exit (1);
}
capture_handle = (snd_pcm_t*)(*capture_handle_f);
printf("made handle %p (&=%p) to %s at %d\n",capture_handle,&capture_handle,dev_name,samp_rate);
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 (capture_handle, hw_params)) < 0) {
fprintf (stderr, "cannot initialize hardware parameter structure (%s)\n",
snd_strerror (err));
exit (1);
}
if ((err = snd_pcm_hw_params_set_access (capture_handle,
hw_params, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0) {
fprintf (stderr, "cannot set access type (%s)\n",
snd_strerror(err));
exit (1);
}
if ((err = snd_pcm_hw_params_set_format (capture_handle,
hw_params, SND_PCM_FORMAT_S16_LE)) < 0) {
fprintf (stderr, "cannot set sample format (%s)\n",
snd_strerror (err));
exit (1);
}
if ((err = snd_pcm_hw_params_set_rate_resample(capture_handle,hw_params, 0)) < 0) {
fprintf(stderr, "failed attempting to prevent ALSA resampling. (%s)",
snd_strerror(err));
exit (1);
}
int dir = 0;
unsigned int val = samp_rate;
if ((err = snd_pcm_hw_params_set_rate_near (capture_handle,
hw_params, &val, &dir)) < 0) {
fprintf (stderr, "cannot set sample rate (%s)\n",
snd_strerror (err));
exit (1);
}
if ((err = snd_pcm_hw_params_set_channels (capture_handle, hw_params, nchan)) < 0) {
fprintf (stderr, "cannot set channel count (%s)\n",
snd_strerror (err));
exit (1);
}
if ((err = snd_pcm_hw_params (capture_handle, hw_params)) < 0) {
fprintf (stderr, "cannot set parameters (%s)\n",
snd_strerror (err));
exit (1);
}
snd_pcm_hw_params_free (hw_params);
if ((err = snd_pcm_prepare (capture_handle)) < 0) {
fprintf (stderr, "cannot prepare audio interface for use (%s)\n",
snd_strerror (err));
exit (1);
}
/*
int nbuf = 8000;
short *buf = (short*)malloc(sizeof(short)*nbuf);
int i;
for (i=0; i<2; ++i) {
if ((err = snd_pcm_readi(capture_handle, buf, nbuf)) != nbuf) {
fprintf (stderr, "read from audio interface failed (%s)\n",
snd_strerror(err));
exit (1);
}
else {
printf("read from C using %p into %p.\n",capture_handle,buf);
}
}
*/
}
/*hard ware parameter set*/
static int set_hwparams(snd_pcm_t *handle,snd_pcm_hw_params_t *params,snd_pcm_access_t access)
{
unsigned int rrate;
snd_pcm_uframes_t size;
int err, dir;
/* choose all parameters */
err = snd_pcm_hw_params_any(handle, params);
if (err < 0)
{
printf("Broken configuration for playback: no configurations available: %s\n", snd_strerror(err));
return err;
}
/* set hardware resampling */
err = snd_pcm_hw_params_set_rate_resample(handle, params, resample);
if (err < 0)
{
printf("Resampling setup failed for playback: %s\n", snd_strerror(err));
return err;
}
/* set the interleaved read/write format */
err = snd_pcm_hw_params_set_access(handle, params, access);
if (err < 0)
{
printf("Access type not available for playback: %s\n", snd_strerror(err));
return err;
}
/* set the sample format */
err = snd_pcm_hw_params_set_format(handle, params, format);
if (err < 0)
{
printf("Sample format not available for playback: %s\n", snd_strerror(err));
return err;
}
/* set the count of channels */
err = snd_pcm_hw_params_set_channels(handle, params, channels);
if (err < 0)
{
printf("Channels count (%i) not available for playbacks: %s\n", channels, snd_strerror(err));
return err;
}
/* set the stream rate */
rrate = rate;
err = snd_pcm_hw_params_set_rate_near(handle, params, &rrate, 0);
if (err < 0)
{
printf("Rate %iHz not available for playback: %s\n", rate, snd_strerror(err));
return err;
}
if (rrate != rate)
{
printf("Rate doesn't match (requested %iHz, get %iHz)\n", rate, err);
return -EINVAL;
}
/* set the buffer time */
err = snd_pcm_hw_params_set_buffer_time_near(handle, params, &buffer_time, &dir);
if (err < 0)
{
printf("Unable to set buffer time %i for playback: %s\n", buffer_time, snd_strerror(err));
return err;
}
err = snd_pcm_hw_params_get_buffer_size(params, &size);
if (err < 0)
{
printf("Unable to get buffer size for playback: %s\n", snd_strerror(err));
return err;
}
buffer_size = size;
/* set the period time */
err = snd_pcm_hw_params_set_period_time_near(handle, params, &period_time, &dir);
if (err < 0)
{
printf("Unable to set period time %i for playback: %s\n", period_time, snd_strerror(err));
return err;
}
/*
snd_pcm_uframes_t periodsize=800;
err = snd_pcm_hw_params_set_period_size(handle, params,910,0);
printf("period near %d %d\r\n",dir,periodsize);
if (err < 0) {
printf("Unable to set period size %s\n ", snd_strerror(err));
return err;
}*/
err = snd_pcm_hw_params_get_period_size(params, &size, &dir);
printf("size or the period_size: %ld\r\n",size);
if (err < 0)
{
printf("Unable to get period size for playback: %s\n", snd_strerror(err));
return err;
}
period_size = size;
/* write the parameters to device */
err = snd_pcm_hw_params(handle, params);
if (err < 0)
{
printf("Unable to set hw params for playback: %s\n", snd_strerror(err));
return err;
}
return 0;
}
int sound_init_alsa() {
int err;
snd_pcm_hw_params_t *hw_params;
unsigned int resample,samplerate;
snd_pcm_uframes_t bufferSize;
err = snd_pcm_open( &_soundDevice, "plughw:0,0", SND_PCM_STREAM_PLAYBACK, 0 );
if (err<0) {
return -1;
}
if ((err = snd_pcm_hw_params_malloc (&hw_params)) < 0) {
snd_pcm_close (_soundDevice);
return -2;
}
if ((err = snd_pcm_hw_params_any (_soundDevice, hw_params)) < 0) {
snd_pcm_close (_soundDevice);
return -2;
}
if ((err = snd_pcm_hw_params_set_access (_soundDevice, hw_params,SND_PCM_ACCESS_RW_INTERLEAVED)) < 0) {
snd_pcm_close (_soundDevice);
return -3;
}
if (snd_pcm_hw_params_set_format (_soundDevice, hw_params,SND_PCM_FORMAT_U8) >= 0) {
ordenador.sign=0;
ordenador.format=0;
} else if (snd_pcm_hw_params_set_format (_soundDevice, hw_params,SND_PCM_FORMAT_S8) >= 0) {
ordenador.sign=-128;
ordenador.format=0;
} else if (snd_pcm_hw_params_set_format (_soundDevice, hw_params,SND_PCM_FORMAT_U16_LE) >= 0) {
ordenador.sign=0;
ordenador.format=1;
} else if (snd_pcm_hw_params_set_format (_soundDevice, hw_params,SND_PCM_FORMAT_S16_LE) >= 0) {
ordenador.sign=-128;
ordenador.format=1;
} else if (snd_pcm_hw_params_set_format (_soundDevice, hw_params,SND_PCM_FORMAT_U16_BE) >= 0) {
ordenador.sign=0;
ordenador.format=2;
} else if (snd_pcm_hw_params_set_format (_soundDevice, hw_params,SND_PCM_FORMAT_S16_BE) >= 0) {
ordenador.sign=-128;
ordenador.format=2;
} else {
snd_pcm_close (_soundDevice);
return -3;
}
// Disable resampling.
resample = 0;
err = snd_pcm_hw_params_set_rate_resample(_soundDevice, hw_params, resample);
if (err < 0) {
snd_pcm_close (_soundDevice);
return -3;
}
if ((err = snd_pcm_hw_params_set_channels (_soundDevice, hw_params, 1)) >= 0) {
ordenador.channels=1;
} else if ((err = snd_pcm_hw_params_set_channels (_soundDevice, hw_params, 2)) >= 0) {
ordenador.channels=2;
} else {
snd_pcm_close (_soundDevice);
return -3;
}
samplerate=48000;
if ((err = snd_pcm_hw_params_set_rate_near (_soundDevice, hw_params, &samplerate, 0)) < 0) {
snd_pcm_close (_soundDevice);
return -3;
}
bufferSize=4096;
if (snd_pcm_hw_params_set_buffer_size_near(_soundDevice, hw_params, &bufferSize) < 0) {
fprintf(stderr, "Error setting buffersize.\n");
return -3;
}
ordenador.freq=samplerate;
err = snd_pcm_hw_params (_soundDevice, hw_params);
if (err<0) {
return -3;
}
//snd_pcm_hw_params_get_buffer_size( hw_params, &bufferSize );
ordenador.buffer_len=bufferSize;
started_sound=0;
return 0;
err = snd_pcm_prepare (_soundDevice);
if (err<0) {
return -5;
}
return 0;
}
bool QAlsaAudioInput::open()
{
#ifdef DEBUG_AUDIO
QTime now(QTime::currentTime());
qDebug()<<now.second()<<"s "<<now.msec()<<"ms :open()";
#endif
clockStamp.restart();
timeStamp.restart();
elapsedTimeOffset = 0;
int dir;
int err = 0;
int count=0;
unsigned int sampleRate=settings.sampleRate();
if (!settings.isValid()) {
qWarning("QAudioInput: open error, invalid format.");
} else if (settings.sampleRate() <= 0) {
qWarning("QAudioInput: open error, invalid sample rate (%d).",
settings.sampleRate());
} else {
err = -1;
}
if (err == 0) {
errorState = QAudio::OpenError;
deviceState = QAudio::StoppedState;
emit errorChanged(errorState);
return false;
}
QString dev = QString(QLatin1String(m_device.constData()));
QList<QByteArray> devices = QAlsaAudioDeviceInfo::availableDevices(QAudio::AudioInput);
if(dev.compare(QLatin1String("default")) == 0) {
#if(SND_LIB_MAJOR == 1 && SND_LIB_MINOR == 0 && SND_LIB_SUBMINOR >= 14)
if (devices.size() > 0)
dev = QLatin1String(devices.first());
else
return false;
#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_CAPTURE,0);
if(err < 0)
count++;
}
if (( err < 0)||(handle == 0)) {
errorState = QAudio::OpenError;
deviceState = QAudio::StoppedState;
emit stateChanged(deviceState);
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("QAudioInput: 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("QAudioInput: 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("QAudioInput: snd_pcm_hw_params_set_access: err = %1").arg(err);
}
}
if ( !fatal ) {
err = setFormat();
if ( err < 0 ) {
fatal = true;
errMessage = QString::fromLatin1("QAudioInput: snd_pcm_hw_params_set_format: err = %1").arg(err);
}
}
if ( !fatal ) {
err = snd_pcm_hw_params_set_channels( handle, hwparams, (unsigned int)settings.channelCount() );
if ( err < 0 ) {
fatal = true;
errMessage = QString::fromLatin1("QAudioInput: snd_pcm_hw_params_set_channels: err = %1").arg(err);
}
}
if ( !fatal ) {
err = snd_pcm_hw_params_set_rate_near( handle, hwparams, &sampleRate, 0 );
if ( err < 0 ) {
fatal = true;
errMessage = QString::fromLatin1("QAudioInput: 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("QAudioInput: 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("QAudioInput: 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("QAudioInput: 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("QAudioInput: snd_pcm_hw_params: err = %1").arg(err);
}
}
if( err < 0) {
qWarning()<<errMessage;
errorState = QAudio::OpenError;
deviceState = QAudio::StoppedState;
emit stateChanged(deviceState);
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
ringBuffer.resize(buffer_size);
snd_pcm_prepare( handle );
snd_pcm_start(handle);
// Step 5: Setup timer
bytesAvailable = checkBytesReady();
if(pullMode)
connect(audioSource,SIGNAL(readyRead()),this,SLOT(userFeed()));
// Step 6: Start audio processing
chunks = buffer_size/period_size;
timer->start(period_time*chunks/2000);
errorState = QAudio::NoError;
totalTimeValue = 0;
return true;
}
static int Open (vlc_object_t *obj)
{
demux_t *demux = (demux_t *)obj;
demux_sys_t *sys = vlc_obj_malloc(obj, sizeof (*sys));
if (unlikely(sys == NULL))
return VLC_ENOMEM;
/* Open the device */
const char *device = demux->psz_location;
if (device == NULL || !device[0])
device = "default";
const int mode = SND_PCM_NONBLOCK
/*| SND_PCM_NO_AUTO_RESAMPLE*/
| SND_PCM_NO_AUTO_CHANNELS
/*| SND_PCM_NO_AUTO_FORMAT*/;
snd_pcm_t *pcm;
int val = snd_pcm_open (&pcm, device, SND_PCM_STREAM_CAPTURE, mode);
if (val != 0)
{
msg_Err (demux, "cannot open ALSA device \"%s\": %s", device,
snd_strerror (val));
return VLC_EGENERIC;
}
sys->pcm = pcm;
msg_Dbg (demux, "using ALSA device: %s", device);
DumpDevice (VLC_OBJECT(demux), pcm);
/* Negotiate capture parameters */
snd_pcm_hw_params_t *hw;
es_format_t fmt;
unsigned param;
int dir;
snd_pcm_hw_params_alloca (&hw);
snd_pcm_hw_params_any (pcm, hw);
Dump (demux, "initial hardware setup:\n", snd_pcm_hw_params_dump, hw);
val = snd_pcm_hw_params_set_rate_resample (pcm, hw, 0);
if (val)
{
msg_Err (demux, "cannot disable resampling: %s", snd_strerror (val));
goto error;
}
val = snd_pcm_hw_params_set_access (pcm, hw,
SND_PCM_ACCESS_RW_INTERLEAVED);
if (val)
{
msg_Err (demux, "cannot set access mode: %s", snd_strerror (val));
goto error;
}
snd_pcm_format_t format = SND_PCM_FORMAT_UNKNOWN;
for (size_t i = 0; i < sizeof (choices) / sizeof (choices[0]); i++)
if (snd_pcm_hw_params_test_format (pcm, hw, choices[i]) == 0)
{
val = snd_pcm_hw_params_set_format (pcm, hw, choices[i]);
if (val)
{
msg_Err (demux, "cannot set sample format: %s",
snd_strerror (val));
goto error;
}
format = choices[i];
break;
}
if (format == SND_PCM_FORMAT_UNKNOWN)
{
msg_Err (demux, "no supported sample format");
goto error;
}
assert ((size_t)format < (sizeof (formats) / sizeof (formats[0])));
es_format_Init (&fmt, AUDIO_ES, formats[format]);
fmt.audio.i_format = fmt.i_codec;
param = 1 + var_InheritBool (demux, "alsa-stereo");
val = snd_pcm_hw_params_set_channels_max (pcm, hw, ¶m);
if (val)
{
msg_Err (demux, "cannot restrict channels count: %s",
snd_strerror (val));
goto error;
}
val = snd_pcm_hw_params_set_channels_last (pcm, hw, ¶m);
if (val)
{
msg_Err (demux, "cannot set channels count: %s", snd_strerror (val));
goto error;
}
assert (param > 0);
assert (param < (sizeof (channel_maps) / sizeof (channel_maps[0])));
fmt.audio.i_channels = param;
fmt.audio.i_physical_channels = channel_maps[param - 1];
param = var_InheritInteger (demux, "alsa-samplerate");
val = snd_pcm_hw_params_set_rate_max (pcm, hw, ¶m, NULL);
if (val)
{
msg_Err (demux, "cannot restrict rate to %u Hz or less: %s", 192000,
snd_strerror (val));
goto error;
}
val = snd_pcm_hw_params_set_rate_last (pcm, hw, ¶m, &dir);
if (val)
{
msg_Err (demux, "cannot set sample rate: %s", snd_strerror (val));
goto error;
}
if (dir)
msg_Warn (demux, "sample rate is not integral");
fmt.audio.i_rate = param;
sys->rate = param;
sys->start = mdate ();
sys->caching = INT64_C(1000) * var_InheritInteger (demux, "live-caching");
param = sys->caching;
val = snd_pcm_hw_params_set_buffer_time_near (pcm, hw, ¶m, NULL);
if (val)
{
msg_Err (demux, "cannot set buffer duration: %s", snd_strerror (val));
goto error;
}
param /= 4;
val = snd_pcm_hw_params_set_period_time_near (pcm, hw, ¶m, NULL);
if (val)
{
msg_Err (demux, "cannot set period: %s", snd_strerror (val));
goto error;
}
val = snd_pcm_hw_params_get_period_size (hw, &sys->period_size, &dir);
if (val)
{
msg_Err (demux, "cannot get period size: %s", snd_strerror (val));
goto error;
}
if (dir > 0)
sys->period_size++;
/* Commit hardware parameters */
val = snd_pcm_hw_params (pcm, hw);
if (val)
{
msg_Err (demux, "cannot commit hardware parameters: %s",
snd_strerror (val));
goto error;
}
Dump (demux, "final HW setup:\n", snd_pcm_hw_params_dump, hw);
/* Kick recording */
aout_FormatPrepare (&fmt.audio);
sys->es = es_out_Add (demux->out, &fmt);
demux->p_sys = sys;
if (vlc_clone (&sys->thread, Thread, demux, VLC_THREAD_PRIORITY_INPUT))
{
es_out_Del (demux->out, sys->es);
goto error;
}
demux->pf_demux = NULL;
demux->pf_control = Control;
return VLC_SUCCESS;
error:
snd_pcm_close (pcm);
return VLC_EGENERIC;
}
int main(int argc, char *argv[]) {
const char *dev;
int r, cap, count = 0;
snd_pcm_hw_params_t *hwparams;
snd_pcm_sw_params_t *swparams;
snd_pcm_status_t *status;
snd_pcm_t *pcm;
unsigned rate = 44100;
unsigned periods = 2;
snd_pcm_uframes_t boundary, buffer_size = 44100/10; /* 100s */
int dir = 1;
struct timespec start, last_timestamp = { 0, 0 };
uint64_t start_us, last_us = 0;
snd_pcm_sframes_t last_avail = 0, last_delay = 0;
struct pollfd *pollfds;
int n_pollfd;
int64_t sample_count = 0;
struct sched_param sp;
r = -1;
#ifdef _POSIX_PRIORITY_SCHEDULING
sp.sched_priority = 5;
r = pthread_setschedparam(pthread_self(), SCHED_RR, &sp);
#endif
if (r)
printf("Could not get RT prio. :(\n");
snd_pcm_hw_params_alloca(&hwparams);
snd_pcm_sw_params_alloca(&swparams);
snd_pcm_status_alloca(&status);
r = clock_gettime(CLOCK_MONOTONIC, &start);
assert(r == 0);
start_us = timespec_us(&start);
dev = argc > 1 ? argv[1] : "front:AudioPCI";
cap = argc > 2 ? atoi(argv[2]) : 0;
if (cap == 0)
r = snd_pcm_open(&pcm, dev, SND_PCM_STREAM_PLAYBACK, 0);
else
r = snd_pcm_open(&pcm, dev, SND_PCM_STREAM_CAPTURE, 0);
assert(r == 0);
r = snd_pcm_hw_params_any(pcm, hwparams);
assert(r == 0);
r = snd_pcm_hw_params_set_rate_resample(pcm, hwparams, 0);
assert(r == 0);
r = snd_pcm_hw_params_set_access(pcm, hwparams, SND_PCM_ACCESS_RW_INTERLEAVED);
assert(r == 0);
r = snd_pcm_hw_params_set_format(pcm, hwparams, SND_PCM_FORMAT_S16_LE);
assert(r == 0);
r = snd_pcm_hw_params_set_rate_near(pcm, hwparams, &rate, NULL);
assert(r == 0);
r = snd_pcm_hw_params_set_channels(pcm, hwparams, 2);
assert(r == 0);
r = snd_pcm_hw_params_set_periods_integer(pcm, hwparams);
assert(r == 0);
r = snd_pcm_hw_params_set_periods_near(pcm, hwparams, &periods, &dir);
assert(r == 0);
r = snd_pcm_hw_params_set_buffer_size_near(pcm, hwparams, &buffer_size);
assert(r == 0);
r = snd_pcm_hw_params(pcm, hwparams);
assert(r == 0);
r = snd_pcm_hw_params_current(pcm, hwparams);
assert(r == 0);
r = snd_pcm_sw_params_current(pcm, swparams);
assert(r == 0);
if (cap == 0)
r = snd_pcm_sw_params_set_avail_min(pcm, swparams, 1);
else
r = snd_pcm_sw_params_set_avail_min(pcm, swparams, 0);
assert(r == 0);
r = snd_pcm_sw_params_set_period_event(pcm, swparams, 0);
assert(r == 0);
r = snd_pcm_hw_params_get_buffer_size(hwparams, &buffer_size);
assert(r == 0);
r = snd_pcm_sw_params_set_start_threshold(pcm, swparams, buffer_size);
assert(r == 0);
r = snd_pcm_sw_params_get_boundary(swparams, &boundary);
assert(r == 0);
r = snd_pcm_sw_params_set_stop_threshold(pcm, swparams, boundary);
assert(r == 0);
r = snd_pcm_sw_params_set_tstamp_mode(pcm, swparams, SND_PCM_TSTAMP_ENABLE);
assert(r == 0);
r = snd_pcm_sw_params(pcm, swparams);
assert(r == 0);
r = snd_pcm_prepare(pcm);
assert(r == 0);
r = snd_pcm_sw_params_current(pcm, swparams);
assert(r == 0);
/* assert(snd_pcm_hw_params_is_monotonic(hwparams) > 0); */
n_pollfd = snd_pcm_poll_descriptors_count(pcm);
assert(n_pollfd > 0);
pollfds = malloc(sizeof(struct pollfd) * n_pollfd);
assert(pollfds);
r = snd_pcm_poll_descriptors(pcm, pollfds, n_pollfd);
assert(r == n_pollfd);
printf("Starting. Buffer size is %u frames\n", (unsigned int) buffer_size);
if (cap) {
r = snd_pcm_start(pcm);
assert(r == 0);
}
for (;;) {
snd_pcm_sframes_t avail, delay;
struct timespec now, timestamp;
unsigned short revents;
int handled = 0;
uint64_t now_us, timestamp_us;
snd_pcm_state_t state;
unsigned long long pos;
r = poll(pollfds, n_pollfd, 0);
assert(r >= 0);
r = snd_pcm_poll_descriptors_revents(pcm, pollfds, n_pollfd, &revents);
assert(r == 0);
if (cap == 0)
assert((revents & ~POLLOUT) == 0);
else
assert((revents & ~POLLIN) == 0);
avail = snd_pcm_avail(pcm);
assert(avail >= 0);
r = snd_pcm_status(pcm, status);
assert(r == 0);
/* This assertion fails from time to time. ALSA seems to be broken */
/* assert(avail == (snd_pcm_sframes_t) snd_pcm_status_get_avail(status)); */
/* printf("%lu %lu\n", (unsigned long) avail, (unsigned long) snd_pcm_status_get_avail(status)); */
snd_pcm_status_get_htstamp(status, ×tamp);
delay = snd_pcm_status_get_delay(status);
state = snd_pcm_status_get_state(status);
r = clock_gettime(CLOCK_MONOTONIC, &now);
assert(r == 0);
assert(!revents || avail > 0);
if ((!cap && avail) || (cap && (unsigned)avail >= buffer_size)) {
snd_pcm_sframes_t sframes;
static const uint16_t psamples[2] = { 0, 0 };
uint16_t csamples[2];
if (cap == 0)
sframes = snd_pcm_writei(pcm, psamples, 1);
else
sframes = snd_pcm_readi(pcm, csamples, 1);
assert(sframes == 1);
handled = 1;
sample_count++;
}
if (!handled &&
memcmp(×tamp, &last_timestamp, sizeof(timestamp)) == 0 &&
avail == last_avail &&
delay == last_delay) {
/* This is boring */
continue;
}
now_us = timespec_us(&now);
timestamp_us = timespec_us(×tamp);
if (cap == 0)
pos = (unsigned long long) ((sample_count - handled - delay) * 1000000LU / 44100);
else
pos = (unsigned long long) ((sample_count - handled + delay) * 1000000LU / 44100);
if (count++ % 50 == 0)
printf("Elapsed\tCPU\tALSA\tPos\tSamples\tavail\tdelay\trevents\thandled\tstate\n");
printf("%llu\t%llu\t%llu\t%llu\t%llu\t%li\t%li\t%i\t%i\t%i\n",
(unsigned long long) (now_us - last_us),
(unsigned long long) (now_us - start_us),
(unsigned long long) (timestamp_us ? timestamp_us - start_us : 0),
pos,
(unsigned long long) sample_count,
(signed long) avail,
(signed long) delay,
revents,
handled,
state);
if (cap == 0)
/** When this assert is hit, most likely something bad
* happened, i.e. the avail jumped suddenly. */
assert((unsigned) avail <= buffer_size);
last_avail = avail;
last_delay = delay;
last_timestamp = timestamp;
last_us = now_us;
}
return 0;
}
bool CALSAAudioSource::InitDevice(void)
{
int err;
// Capture stream
snd_pcm_stream_t stream = SND_PCM_STREAM_CAPTURE;
// This structure contains information about
// the hardware and can be used to specify the
// configuration to be used for the PCM stream.
snd_pcm_hw_params_t *hwparams;
// Name of the PCM device, like plughw:0,0
const char *pcm_name = m_pConfig->GetStringValue(CONFIG_AUDIO_SOURCE_NAME);
// Allocate the snd_pcm_hw_params_t structure on the stack.
snd_pcm_hw_params_alloca(&hwparams);
// Open PCM
if ((err = snd_pcm_open(&m_pcmHandle, pcm_name, stream, 0)) < 0) {
error_message("Failed to open %s: %s", pcm_name, snd_strerror(err));
return false;
}
// Init hwparams with full configuration space
if ((err = snd_pcm_hw_params_any(m_pcmHandle, hwparams)) < 0) {
error_message("Can not configure the PCM device %s: %s", pcm_name, snd_strerror(err));
return false;
}
// Enable resample
#ifdef HAVE_SND_PCM_HW_PARAMS_SET_RATE_RESAMPLE
if ((err = snd_pcm_hw_params_set_rate_resample(m_pcmHandle, hwparams, 1)) < 0) {
error_message("Error enabling resample for PCM device %s: %s", pcm_name, snd_strerror(err));
return false;
}
#endif
// Set access type to SND_PCM_ACCESS_RW_INTERLEAVED
if ((err = snd_pcm_hw_params_set_access(m_pcmHandle, hwparams, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0) {
error_message("Error setting access type for PCM device %s: %s", pcm_name, snd_strerror(err));
return false;
}
// Set sample format
#ifdef WORDS_BIGENDIAN
#define OUR_FORMAT SND_PCM_FORMAT_S16_BE
#else
#define OUR_FORMAT SND_PCM_FORMAT_S16_LE
#endif
if ((err = snd_pcm_hw_params_set_format(m_pcmHandle, hwparams, OUR_FORMAT)) < 0) {
error_message("Couldn't set format for PCM device %s: %s", pcm_name, snd_strerror(err));
snd_pcm_close(m_pcmHandle);
return false;
}
// Set number of channels
m_channelsConfigured = m_pConfig->GetIntegerValue(CONFIG_AUDIO_CHANNELS);
if ((err = snd_pcm_hw_params_set_channels(m_pcmHandle, hwparams, m_channelsConfigured)) < 0) {
error_message("Couldn't set audio channels for PCM device %s: %s", pcm_name, snd_strerror(err));
snd_pcm_close(m_pcmHandle);
return false;
}
// Set sample rate
u_int32_t samplingRate = m_pConfig->GetIntegerValue(CONFIG_AUDIO_SAMPLE_RATE);
u_int32_t targetSamplingRate = samplingRate;
// TODO maybe use snd_pcm_hw_params_set_rate instead
if ((err = snd_pcm_hw_params_set_rate_near(m_pcmHandle, hwparams, &targetSamplingRate, 0)) < 0) {
error_message("Couldn't set sample rate for PCM device %s: %s", pcm_name, snd_strerror(err));
snd_pcm_close(m_pcmHandle);
return false;
}
if (samplingRate != targetSamplingRate) {
error_message("Couldn't set sample rate for PCM device %s", pcm_name);
snd_pcm_close(m_pcmHandle);
return false;
}
// Apply HW parameter settings to PCM device. This will also put it into PREPARED state
if ((err = snd_pcm_hw_params(m_pcmHandle, hwparams)) < 0) {
error_message("Couldn't set hw parameters PCM device %s: %s", pcm_name, snd_strerror(err));
snd_pcm_close(m_pcmHandle);
return false;
}
debug_message("alsa init done");
return true;
}
void
ags_devout_alsa_init(AgsSoundcard *soundcard,
GError **error)
{
AgsDevout *devout;
int rc;
snd_pcm_t *handle;
snd_pcm_hw_params_t *hwparams;
unsigned int val;
snd_pcm_uframes_t frames;
unsigned int rate;
unsigned int rrate;
unsigned int channels;
snd_pcm_uframes_t size;
snd_pcm_sframes_t buffer_size;
snd_pcm_sframes_t period_size;
snd_pcm_sw_params_t *swparams;
int period_event = 0;
int err, dir;
static unsigned int period_time = 100000;
static snd_pcm_format_t format = SND_PCM_FORMAT_S16;
devout = AGS_DEVOUT(soundcard);
/* */
devout->flags |= (AGS_DEVOUT_BUFFER3 |
AGS_DEVOUT_START_PLAY |
AGS_DEVOUT_PLAY |
AGS_DEVOUT_NONBLOCKING);
devout->note_offset = 0;
memset(devout->buffer[0], 0, devout->dsp_channels * devout->buffer_size * sizeof(signed short));
memset(devout->buffer[1], 0, devout->dsp_channels * devout->buffer_size * sizeof(signed short));
memset(devout->buffer[2], 0, devout->dsp_channels * devout->buffer_size * sizeof(signed short));
memset(devout->buffer[3], 0, devout->dsp_channels * devout->buffer_size * sizeof(signed short));
/* Open PCM device for playback. */
if ((err = snd_pcm_open(&handle, devout->out.alsa.device, SND_PCM_STREAM_PLAYBACK, 0)) < 0) {
printf("Playback open error: %s\n", snd_strerror(err));
g_set_error(error,
AGS_DEVOUT_ERROR,
AGS_DEVOUT_ERROR_LOCKED_SOUNDCARD,
"unable to open pcm device: %s\n\0",
snd_strerror(err));
return;
}
snd_pcm_hw_params_alloca(&hwparams);
snd_pcm_sw_params_alloca(&swparams);
/* choose all parameters */
err = snd_pcm_hw_params_any(handle, hwparams);
if (err < 0) {
printf("Broken configuration for playback: no configurations available: %s\n", snd_strerror(err));
return;
}
/* set hardware resampling */
err = snd_pcm_hw_params_set_rate_resample(handle, hwparams, 1);
if (err < 0) {
printf("Resampling setup failed for playback: %s\n", snd_strerror(err));
return;
}
/* set the interleaved read/write format */
err = snd_pcm_hw_params_set_access(handle, hwparams, SND_PCM_ACCESS_RW_INTERLEAVED);
if (err < 0) {
printf("Access type not available for playback: %s\n", snd_strerror(err));
return;
}
/* set the sample format */
err = snd_pcm_hw_params_set_format(handle, hwparams, format);
if (err < 0) {
printf("Sample format not available for playback: %s\n", snd_strerror(err));
return;
}
/* set the count of channels */
channels = devout->dsp_channels;
err = snd_pcm_hw_params_set_channels(handle, hwparams, channels);
if (err < 0) {
printf("Channels count (%i) not available for playbacks: %s\n", channels, snd_strerror(err));
return;
}
/* set the stream rate */
rate = devout->samplerate;
rrate = rate;
err = snd_pcm_hw_params_set_rate_near(handle, hwparams, &rrate, 0);
if (err < 0) {
printf("Rate %iHz not available for playback: %s\n", rate, snd_strerror(err));
return;
}
if (rrate != rate) {
printf("Rate doesn't match (requested %iHz, get %iHz)\n", rate, err);
// exit(-EINVAL);
return;
}
/* set the buffer size */
size = devout->buffer_size;
err = snd_pcm_hw_params_set_buffer_size(handle, hwparams, size);
if (err < 0) {
printf("Unable to set buffer size %i for playback: %s\n", size, snd_strerror(err));
return;
}
buffer_size = size;
/* set the period time */
period_time = MSEC_PER_SEC / devout->samplerate;
dir = -1;
err = snd_pcm_hw_params_set_period_time_near(handle, hwparams, &period_time, &dir);
if (err < 0) {
printf("Unable to set period time %i for playback: %s\n", period_time, snd_strerror(err));
return;
}
err = snd_pcm_hw_params_get_period_size(hwparams, &size, &dir);
if (err < 0) {
printf("Unable to get period size for playback: %s\n", snd_strerror(err));
return;
}
period_size = size;
/* write the parameters to device */
err = snd_pcm_hw_params(handle, hwparams);
if (err < 0) {
printf("Unable to set hw params for playback: %s\n", snd_strerror(err));
return;
}
/* 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;
}
/* 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);
if (err < 0) {
printf("Unable to set start threshold mode for playback: %s\n", snd_strerror(err));
return;
}
/* 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);
if (err < 0) {
printf("Unable to set avail min for playback: %s\n", snd_strerror(err));
return;
}
/* 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;
}
/* */
devout->out.alsa.handle = handle;
devout->delay_counter = 0.0;
devout->tic_counter = 0;
}
static HRESULT SetFormat(IDsDriverBufferImpl *This, LPWAVEFORMATEX pwfx)
{
snd_pcm_t *pcm = NULL;
snd_pcm_hw_params_t *hw_params = This->hw_params;
unsigned int buffer_time = 500000;
snd_pcm_format_t format = -1;
snd_pcm_uframes_t psize;
DWORD rate = pwfx->nSamplesPerSec;
int err=0;
switch (pwfx->wBitsPerSample)
{
case 8: format = SND_PCM_FORMAT_U8; break;
case 16: format = SND_PCM_FORMAT_S16_LE; break;
case 24: format = SND_PCM_FORMAT_S24_3LE; break;
case 32: format = SND_PCM_FORMAT_S32_LE; break;
default: FIXME("Unsupported bpp: %d\n", pwfx->wBitsPerSample); return DSERR_GENERIC;
}
err = snd_pcm_open(&pcm, WOutDev[This->drv->wDevID].pcmname, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK);
if (err < 0)
{
if (errno != EBUSY || !This->pcm)
{
WARN("Cannot open sound device: %s\n", snd_strerror(err));
return DSERR_GENERIC;
}
snd_pcm_drop(This->pcm);
snd_pcm_close(This->pcm);
This->pcm = NULL;
err = snd_pcm_open(&pcm, WOutDev[This->drv->wDevID].pcmname, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK);
if (err < 0)
{
WARN("Cannot open sound device: %s\n", snd_strerror(err));
return DSERR_BUFFERLOST;
}
}
/* Set some defaults */
snd_pcm_hw_params_any(pcm, hw_params);
err = snd_pcm_hw_params_set_channels(pcm, hw_params, pwfx->nChannels);
if (err < 0) { WARN("Could not set channels to %d\n", pwfx->nChannels); goto err; }
err = snd_pcm_hw_params_set_format(pcm, hw_params, format);
if (err < 0) { WARN("Could not set format to %d bpp\n", pwfx->wBitsPerSample); goto err; }
/* Alsa's rate resampling is only used if the application specifically requests
* a buffer at a certain frequency, else it is better to disable it due to unwanted
* side effects, which may include: Less granular pointer, changing buffer sizes, etc
*/
#if SND_LIB_VERSION >= 0x010009
snd_pcm_hw_params_set_rate_resample(pcm, hw_params, 0);
#endif
err = snd_pcm_hw_params_set_rate_near(pcm, hw_params, &rate, NULL);
if (err < 0) { rate = pwfx->nSamplesPerSec; WARN("Could not set rate\n"); goto err; }
if (!ALSA_NearMatch(rate, pwfx->nSamplesPerSec))
{
WARN("Could not set sound rate to %d, but instead to %d\n", pwfx->nSamplesPerSec, rate);
pwfx->nSamplesPerSec = rate;
pwfx->nAvgBytesPerSec = rate * pwfx->nBlockAlign;
/* Let DirectSound detect this */
}
snd_pcm_hw_params_set_periods_integer(pcm, hw_params);
snd_pcm_hw_params_set_buffer_time_near(pcm, hw_params, &buffer_time, NULL);
buffer_time = 10000;
snd_pcm_hw_params_set_period_time_near(pcm, hw_params, &buffer_time, NULL);
err = snd_pcm_hw_params_get_period_size(hw_params, &psize, NULL);
buffer_time = 16;
snd_pcm_hw_params_set_periods_near(pcm, hw_params, &buffer_time, NULL);
if (!This->mmap)
{
HeapFree(GetProcessHeap(), 0, This->mmap_buffer);
This->mmap_buffer = NULL;
}
err = snd_pcm_hw_params_set_access (pcm, hw_params, SND_PCM_ACCESS_MMAP_INTERLEAVED);
if (err >= 0)
This->mmap = 1;
else
{
This->mmap = 0;
err = snd_pcm_hw_params_set_access (pcm, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED);
}
err = snd_pcm_hw_params(pcm, hw_params);
/* ALSA needs at least 3 buffers to work successfully */
This->mmap_commitahead = 3 * psize;
while (This->mmap_commitahead <= 512)
This->mmap_commitahead += psize;
if (This->pcm)
{
snd_pcm_drop(This->pcm);
snd_pcm_close(This->pcm);
}
This->pcm = pcm;
snd_pcm_prepare(This->pcm);
DSDB_CreateMMAP(This);
return S_OK;
err:
if (err < 0)
WARN("Failed to apply changes: %s\n", snd_strerror(err));
if (!This->pcm)
This->pcm = pcm;
else
snd_pcm_close(pcm);
if (This->pcm)
snd_pcm_hw_params_current(This->pcm, This->hw_params);
return DSERR_BADFORMAT;
}
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 ALCboolean alsa_reset_playback(ALCdevice *device)
{
alsa_data *data = (alsa_data*)device->ExtraData;
snd_pcm_uframes_t periodSizeInFrames;
unsigned int periodLen, bufferLen;
snd_pcm_sw_params_t *sp = NULL;
snd_pcm_hw_params_t *hp = NULL;
snd_pcm_access_t access;
snd_pcm_format_t format;
unsigned int periods;
unsigned int rate;
const char *funcerr;
int allowmmap;
int err;
format = -1;
switch(device->FmtType)
{
case DevFmtByte:
format = SND_PCM_FORMAT_S8;
break;
case DevFmtUByte:
format = SND_PCM_FORMAT_U8;
break;
case DevFmtShort:
format = SND_PCM_FORMAT_S16;
break;
case DevFmtUShort:
format = SND_PCM_FORMAT_U16;
break;
case DevFmtInt:
format = SND_PCM_FORMAT_S32;
break;
case DevFmtUInt:
format = SND_PCM_FORMAT_U32;
break;
case DevFmtFloat:
format = SND_PCM_FORMAT_FLOAT;
break;
}
allowmmap = GetConfigValueBool("alsa", "mmap", 1);
periods = device->NumUpdates;
periodLen = (ALuint64)device->UpdateSize * 1000000 / device->Frequency;
bufferLen = periodLen * periods;
rate = device->Frequency;
snd_pcm_hw_params_malloc(&hp);
#define CHECK(x) if((funcerr=#x),(err=(x)) < 0) goto error
CHECK(snd_pcm_hw_params_any(data->pcmHandle, hp));
/* set interleaved access */
if(!allowmmap || snd_pcm_hw_params_set_access(data->pcmHandle, hp, SND_PCM_ACCESS_MMAP_INTERLEAVED) < 0)
{
if(periods > 2)
{
periods--;
bufferLen = periodLen * periods;
}
CHECK(snd_pcm_hw_params_set_access(data->pcmHandle, hp, SND_PCM_ACCESS_RW_INTERLEAVED));
}
/* test and set format (implicitly sets sample bits) */
if(snd_pcm_hw_params_test_format(data->pcmHandle, hp, format) < 0)
{
static const struct {
snd_pcm_format_t format;
enum DevFmtType fmttype;
} formatlist[] = {
{ SND_PCM_FORMAT_FLOAT, DevFmtFloat },
{ SND_PCM_FORMAT_S32, DevFmtInt },
{ SND_PCM_FORMAT_U32, DevFmtUInt },
{ SND_PCM_FORMAT_S16, DevFmtShort },
{ SND_PCM_FORMAT_U16, DevFmtUShort },
{ SND_PCM_FORMAT_S8, DevFmtByte },
{ SND_PCM_FORMAT_U8, DevFmtUByte },
};
size_t k;
for(k = 0;k < COUNTOF(formatlist);k++)
{
format = formatlist[k].format;
if(snd_pcm_hw_params_test_format(data->pcmHandle, hp, format) >= 0)
{
device->FmtType = formatlist[k].fmttype;
break;
}
}
}
CHECK(snd_pcm_hw_params_set_format(data->pcmHandle, hp, format));
/* test and set channels (implicitly sets frame bits) */
if(snd_pcm_hw_params_test_channels(data->pcmHandle, hp, ChannelsFromDevFmt(device->FmtChans)) < 0)
{
static const enum DevFmtChannels channellist[] = {
DevFmtStereo,
DevFmtQuad,
DevFmtX51,
DevFmtX71,
DevFmtMono,
};
size_t k;
for(k = 0;k < COUNTOF(channellist);k++)
{
if(snd_pcm_hw_params_test_channels(data->pcmHandle, hp, ChannelsFromDevFmt(channellist[k])) >= 0)
{
device->FmtChans = channellist[k];
break;
}
}
}
CHECK(snd_pcm_hw_params_set_channels(data->pcmHandle, hp, ChannelsFromDevFmt(device->FmtChans)));
/* set rate (implicitly constrains period/buffer parameters) */
if(snd_pcm_hw_params_set_rate_resample(data->pcmHandle, hp, 0) < 0)
ERR("Failed to disable ALSA resampler\n");
CHECK(snd_pcm_hw_params_set_rate_near(data->pcmHandle, hp, &rate, NULL));
/* set buffer time (implicitly constrains period/buffer parameters) */
CHECK(snd_pcm_hw_params_set_buffer_time_near(data->pcmHandle, hp, &bufferLen, NULL));
/* set period time (implicitly sets buffer size/bytes/time and period size/bytes) */
CHECK(snd_pcm_hw_params_set_period_time_near(data->pcmHandle, hp, &periodLen, NULL));
/* install and prepare hardware configuration */
CHECK(snd_pcm_hw_params(data->pcmHandle, hp));
/* retrieve configuration info */
CHECK(snd_pcm_hw_params_get_access(hp, &access));
CHECK(snd_pcm_hw_params_get_period_size(hp, &periodSizeInFrames, NULL));
CHECK(snd_pcm_hw_params_get_periods(hp, &periods, NULL));
snd_pcm_hw_params_free(hp);
hp = NULL;
snd_pcm_sw_params_malloc(&sp);
CHECK(snd_pcm_sw_params_current(data->pcmHandle, sp));
CHECK(snd_pcm_sw_params_set_avail_min(data->pcmHandle, sp, periodSizeInFrames));
CHECK(snd_pcm_sw_params_set_stop_threshold(data->pcmHandle, sp, periodSizeInFrames*periods));
CHECK(snd_pcm_sw_params(data->pcmHandle, sp));
#undef CHECK
snd_pcm_sw_params_free(sp);
sp = NULL;
/* Increase periods by one, since the temp buffer counts as an extra
* period */
if(access == SND_PCM_ACCESS_RW_INTERLEAVED)
device->NumUpdates = periods+1;
else
device->NumUpdates = periods;
device->UpdateSize = periodSizeInFrames;
device->Frequency = rate;
SetDefaultChannelOrder(device);
return ALC_TRUE;
error:
ERR("%s failed: %s\n", funcerr, snd_strerror(err));
if(hp) snd_pcm_hw_params_free(hp);
if(sp) snd_pcm_sw_params_free(sp);
return ALC_FALSE;
}
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;
}
bool ALSAWriter::processParams(bool *paramsCorrected)
{
const unsigned chn = getParam("chn").toUInt();
const unsigned rate = getParam("rate").toUInt();
const bool resetAudio = channels != chn || sample_rate != rate;
channels = chn;
sample_rate = rate;
if (resetAudio || err)
{
snd_pcm_hw_params_t *params;
snd_pcm_hw_params_alloca(¶ms);
close();
QString chosenDevName = devName;
if (autoFindMultichannelDevice && channels > 2)
{
bool mustAutoFind = true, forceStereo = false;
if (!snd_pcm_open(&snd, chosenDevName.toLocal8Bit(), SND_PCM_STREAM_PLAYBACK, 0))
{
if (snd_pcm_type(snd) == SND_PCM_TYPE_HW)
{
unsigned max_chn = 0;
snd_pcm_hw_params_any(snd, params);
mustAutoFind = snd_pcm_hw_params_get_channels_max(params, &max_chn) || max_chn < channels;
}
#ifdef HAVE_CHMAP
else if (paramsCorrected)
{
snd_pcm_chmap_query_t **chmaps = snd_pcm_query_chmaps(snd);
if (chmaps)
snd_pcm_free_chmaps(chmaps);
else
forceStereo = true;
}
#endif
snd_pcm_close(snd);
snd = NULL;
}
if (mustAutoFind)
{
QString newDevName;
if (channels <= 4)
newDevName = "surround40";
else if (channels <= 6)
newDevName = "surround51";
else
newDevName = "surround71";
if (!newDevName.isEmpty() && newDevName != chosenDevName)
{
if (ALSACommon::getDevices().first.contains(newDevName))
chosenDevName = newDevName;
else if (forceStereo)
{
channels = 2;
*paramsCorrected = true;
}
}
}
}
if (!chosenDevName.isEmpty())
{
bool sndOpen = !snd_pcm_open(&snd, chosenDevName.toLocal8Bit(), SND_PCM_STREAM_PLAYBACK, 0);
if (devName != chosenDevName)
{
if (sndOpen)
QMPlay2Core.logInfo("ALSA :: " + devName + "\" -> \"" + chosenDevName + "\"");
else
{
sndOpen = !snd_pcm_open(&snd, devName.toLocal8Bit(), SND_PCM_STREAM_PLAYBACK, 0);
QMPlay2Core.logInfo("ALSA :: " + tr("Cannot open") + " \"" + chosenDevName + "\", " + tr("back to") + " \"" + devName + "\"");
}
}
if (sndOpen)
{
snd_pcm_hw_params_any(snd, params);
snd_pcm_format_t fmt = SND_PCM_FORMAT_UNKNOWN;
if (!snd_pcm_hw_params_test_format(snd, params, SND_PCM_FORMAT_S32))
{
fmt = SND_PCM_FORMAT_S32;
sample_size = 4;
}
else if (!snd_pcm_hw_params_test_format(snd, params, SND_PCM_FORMAT_S16))
{
fmt = SND_PCM_FORMAT_S16;
sample_size = 2;
}
else if (!snd_pcm_hw_params_test_format(snd, params, SND_PCM_FORMAT_S8))
{
fmt = SND_PCM_FORMAT_S8;
sample_size = 1;
}
unsigned delay_us = round(delay * 1000000.0);
if (fmt != SND_PCM_FORMAT_UNKNOWN && set_snd_pcm_hw_params(snd, params, fmt, channels, sample_rate, delay_us))
{
bool err2 = false;
if (channels != chn || sample_rate != rate)
{
if (paramsCorrected)
*paramsCorrected = true;
else
err2 = true;
}
if (!err2)
{
err2 = snd_pcm_hw_params(snd, params);
if (err2 && paramsCorrected) //jakiś błąd, próba zmiany sample_rate
{
snd_pcm_hw_params_any(snd, params);
err2 = snd_pcm_hw_params_set_rate_resample(snd, params, false) || !set_snd_pcm_hw_params(snd, params, fmt, channels, sample_rate, delay_us) || snd_pcm_hw_params(snd, params);
if (!err2)
*paramsCorrected = true;
}
if (!err2)
{
modParam("delay", delay_us / 1000000.0);
if (paramsCorrected && *paramsCorrected)
{
modParam("chn", channels);
modParam("rate", sample_rate);
}
canPause = snd_pcm_hw_params_can_pause(params) && snd_pcm_hw_params_can_resume(params);
mustSwapChn = channels == 6 || channels == 8;
#ifdef HAVE_CHMAP
if (mustSwapChn)
{
snd_pcm_chmap_query_t **chmaps = snd_pcm_query_chmaps(snd);
if (chmaps)
{
for (int i = 0; chmaps[i]; ++i)
{
if (chmaps[i]->map.channels >= channels)
{
for (uint j = 0; j < channels; ++j)
{
mustSwapChn &= chmaps[i]->map.pos[j] == j + SND_CHMAP_FL;
if (!mustSwapChn)
break;
}
break;
}
}
snd_pcm_free_chmaps(chmaps);
}
}
#endif
return true;
}
}
}
}
}
err = true;
QMPlay2Core.logError("ALSA :: " + tr("Cannot open audio output stream"));
}
return readyWrite();
}
