struct codec * alsa_codec_init(const char *path, const char *type, const char *enc, int fs, int channels, int endian, int mode)
{
int err;
snd_pcm_t *dev = NULL;
snd_pcm_hw_params_t *p = NULL;
struct codec *c = NULL;
struct alsa_state *state = NULL;
snd_pcm_uframes_t buf_frames;
struct alsa_enc_info *enc_info;
if ((err = snd_pcm_open(&dev, path, (mode == CODEC_MODE_WRITE) ? SND_PCM_STREAM_PLAYBACK : SND_PCM_STREAM_CAPTURE, 0)) < 0) {
LOG(LL_OPEN_ERROR, "dsp: alsa: error: failed to open device: %s\n", snd_strerror(err));
goto fail;
}
if ((enc_info = alsa_get_enc_info(enc)) == NULL) {
LOG(LL_ERROR, "dsp: alsa: error: bad encoding: %s\n", enc);
goto fail;
}
if ((err = snd_pcm_hw_params_malloc(&p)) < 0) {
LOG(LL_ERROR, "dsp: alsa: error: failed to allocate hw params: %s\n", snd_strerror(err));
goto fail;
}
if ((err = snd_pcm_hw_params_any(dev, p)) < 0) {
LOG(LL_ERROR, "dsp: alsa: error: failed to initialize hw params: %s\n", snd_strerror(err));
goto fail;
}
if ((err = snd_pcm_hw_params_set_access(dev, p, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0) {
LOG(LL_ERROR, "dsp: alsa: error: failed to set access: %s\n", snd_strerror(err));
goto fail;
}
if ((err = snd_pcm_hw_params_set_format(dev, p, enc_info->fmt)) < 0) {
LOG(LL_ERROR, "dsp: alsa: error: failed to set format: %s\n", snd_strerror(err));
goto fail;
}
if ((err = snd_pcm_hw_params_set_rate(dev, p, (unsigned int) fs, 0)) < 0) {
LOG(LL_ERROR, "dsp: alsa: error: failed to set rate: %s\n", snd_strerror(err));
goto fail;
}
if ((err = snd_pcm_hw_params_set_channels(dev, p, channels)) < 0) {
LOG(LL_ERROR, "dsp: alsa: error: failed to set channels: %s\n", snd_strerror(err));
goto fail;
}
buf_frames = dsp_globals.buf_frames;
if ((err = snd_pcm_hw_params_set_buffer_size_min(dev, p, &buf_frames)) < 0) {
LOG(LL_ERROR, "dsp: alsa: error: failed to set buffer size minimum: %s\n", snd_strerror(err));
goto fail;
}
buf_frames = dsp_globals.buf_frames * dsp_globals.max_buf_ratio;
if ((err = snd_pcm_hw_params_set_buffer_size_max(dev, p, &buf_frames)) < 0) {
LOG(LL_ERROR, "dsp: alsa: error: failed to set buffer size maximum: %s\n", snd_strerror(err));
goto fail;
}
if ((err = snd_pcm_hw_params(dev, p)) < 0) {
LOG(LL_ERROR, "dsp: alsa: error: failed to set params: %s\n", snd_strerror(err));
goto fail;
}
if ((err = snd_pcm_prepare(dev)) < 0) {
LOG(LL_ERROR, "dsp: alsa: error: failed to prepare device: %s\n", snd_strerror(err));
goto fail;
}
state = calloc(1, sizeof(struct alsa_state));
state->dev = dev;
state->enc_info = enc_info;
state->delay = 0;
if (mode == CODEC_MODE_WRITE) {
state->buf = calloc(dsp_globals.buf_frames * channels, enc_info->bytes);
state->buf_frames = dsp_globals.buf_frames;
}
c = calloc(1, sizeof(struct codec));
c->path = path;
c->type = type;
c->enc = enc_info->name;
c->fs = fs;
c->channels = channels;
c->prec = enc_info->prec;
c->interactive = (mode == CODEC_MODE_WRITE) ? 1 : 0;
c->frames = -1;
c->read = alsa_read;
c->write = alsa_write;
c->seek = alsa_seek;
c->delay = alsa_delay;
c->drop = alsa_drop;
c->pause = alsa_pause;
c->destroy = alsa_destroy;
c->data = state;
snd_pcm_hw_params_free(p);
return c;
fail:
if (p != NULL)
snd_pcm_hw_params_free(p);
if (dev != NULL)
snd_pcm_close(dev);
return NULL;
}
static ALCenum alsa_open_capture(ALCdevice *Device, const ALCchar *deviceName)
{
const char *driver = NULL;
snd_pcm_hw_params_t *hp;
snd_pcm_uframes_t bufferSizeInFrames;
snd_pcm_uframes_t periodSizeInFrames;
ALboolean needring = AL_FALSE;
snd_pcm_format_t format;
const char *funcerr;
alsa_data *data;
int err;
if(deviceName)
{
size_t idx;
if(!allCaptureDevNameMap)
allCaptureDevNameMap = probe_devices(SND_PCM_STREAM_CAPTURE, &numCaptureDevNames);
for(idx = 0;idx < numCaptureDevNames;idx++)
{
if(strcmp(deviceName, allCaptureDevNameMap[idx].name) == 0)
{
driver = allCaptureDevNameMap[idx].device;
break;
}
}
if(idx == numCaptureDevNames)
return ALC_INVALID_VALUE;
}
else
{
deviceName = alsaDevice;
driver = GetConfigValue("alsa", "capture", "default");
}
data = (alsa_data*)calloc(1, sizeof(alsa_data));
err = snd_pcm_open(&data->pcmHandle, driver, SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK);
if(err < 0)
{
ERR("Could not open capture device '%s': %s\n", driver, snd_strerror(err));
free(data);
return ALC_INVALID_VALUE;
}
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;
}
funcerr = NULL;
bufferSizeInFrames = maxu(Device->UpdateSize*Device->NumUpdates,
100*Device->Frequency/1000);
periodSizeInFrames = minu(bufferSizeInFrames, 25*Device->Frequency/1000);
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 */
CHECK(snd_pcm_hw_params_set_access(data->pcmHandle, hp, SND_PCM_ACCESS_RW_INTERLEAVED));
/* set format (implicitly sets sample bits) */
CHECK(snd_pcm_hw_params_set_format(data->pcmHandle, hp, format));
/* set channels (implicitly sets frame bits) */
CHECK(snd_pcm_hw_params_set_channels(data->pcmHandle, hp, ChannelsFromDevFmt(Device->FmtChans)));
/* set rate (implicitly constrains period/buffer parameters) */
CHECK(snd_pcm_hw_params_set_rate(data->pcmHandle, hp, Device->Frequency, 0));
/* set buffer size in frame units (implicitly sets period size/bytes/time and buffer time/bytes) */
if(snd_pcm_hw_params_set_buffer_size_min(data->pcmHandle, hp, &bufferSizeInFrames) < 0)
{
TRACE("Buffer too large, using intermediate ring buffer\n");
needring = AL_TRUE;
CHECK(snd_pcm_hw_params_set_buffer_size_near(data->pcmHandle, hp, &bufferSizeInFrames));
}
/* set buffer size in frame units (implicitly sets period size/bytes/time and buffer time/bytes) */
CHECK(snd_pcm_hw_params_set_period_size_near(data->pcmHandle, hp, &periodSizeInFrames, NULL));
/* install and prepare hardware configuration */
CHECK(snd_pcm_hw_params(data->pcmHandle, hp));
/* retrieve configuration info */
CHECK(snd_pcm_hw_params_get_period_size(hp, &periodSizeInFrames, NULL));
#undef CHECK
snd_pcm_hw_params_free(hp);
hp = NULL;
if(needring)
{
data->ring = CreateRingBuffer(FrameSizeFromDevFmt(Device->FmtChans, Device->FmtType),
Device->UpdateSize*Device->NumUpdates);
if(!data->ring)
{
ERR("ring buffer create failed\n");
goto error2;
}
data->size = snd_pcm_frames_to_bytes(data->pcmHandle, periodSizeInFrames);
data->buffer = malloc(data->size);
if(!data->buffer)
{
ERR("buffer malloc failed\n");
goto error2;
}
}
Device->DeviceName = strdup(deviceName);
Device->ExtraData = data;
return ALC_NO_ERROR;
error:
ERR("%s failed: %s\n", funcerr, snd_strerror(err));
if(hp) snd_pcm_hw_params_free(hp);
error2:
free(data->buffer);
DestroyRingBuffer(data->ring);
snd_pcm_close(data->pcmHandle);
free(data);
Device->ExtraData = NULL;
return ALC_INVALID_VALUE;
}
adv_error soundb_alsa_init(int sound_id, unsigned* rate, adv_bool stereo_flag, double buffer_time)
{
int r;
snd_pcm_hw_params_t* hw_params;
snd_pcm_sw_params_t* sw_params;
snd_pcm_uframes_t buffer_size;
log_std(("sound:alsa: soundb_alsa_init(id:%d, rate:%d, stereo:%d, buffer_time:%g)\n", sound_id, *rate, stereo_flag, buffer_time));
if (!alsa_option.initialized) {
soundb_alsa_default();
}
alsa_state.volume = ALSA_VOLUME_BASE;
if (stereo_flag) {
alsa_state.sample_length = 4;
alsa_state.channel = 2;
} else {
alsa_state.sample_length = 2;
alsa_state.channel = 1;
}
log_std(("sound:alsa: using device %s\n", alsa_option.device_buffer));
r = snd_pcm_open(&alsa_state.handle, alsa_option.device_buffer, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK);
if (r < 0) {
log_std(("ERROR:sound:alsa: Couldn't open audio device %s: %s\n", alsa_option.device_buffer, snd_strerror(r)));
goto err;
}
snd_pcm_hw_params_alloca(&hw_params);
snd_pcm_sw_params_alloca(&sw_params);
r = snd_pcm_hw_params_any(alsa_state.handle, hw_params);
if (r < 0) {
log_std(("ERROR:sound:alsa: Couldn't get hardware config: %s\n", snd_strerror(r)));
goto err_close;
}
r = snd_pcm_hw_params_set_access(alsa_state.handle, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED);
if (r < 0) {
log_std(("ERROR:sound:alsa: Couldn't set interleaved access: %s\n", snd_strerror(r)));
goto err_close;
}
r = snd_pcm_hw_params_set_format(alsa_state.handle, hw_params, SND_PCM_FORMAT_S16_LE);
if (r < 0) {
log_std(("ERROR:sound:alsa: Couldn't set audio format: %s\n", snd_strerror(r)));
goto err_close;
}
r = snd_pcm_hw_params_set_channels(alsa_state.handle, hw_params, alsa_state.channel);
if (r < 0) {
log_std(("ERROR:sound:alsa: Couldn't set audio channels: %s\n", snd_strerror(r)));
goto err_close;
}
alsa_state.rate = *rate;
r = snd_pcm_hw_params_set_rate_near(alsa_state.handle, hw_params, &alsa_state.rate, 0);
if (r < 0) {
log_std(("ERROR:sound:alsa: Couldn't set audio frequency: %s\n", snd_strerror(r)));
goto err_close;
}
log_std(("sound:alsa: selected rate %d\n", alsa_state.rate));
buffer_size = alsa_state.rate * buffer_time;
log_std(("sound:alsa: request buffer_size of %d samples\n", (unsigned)buffer_size));
r = snd_pcm_hw_params_set_buffer_size_min(alsa_state.handle, hw_params, &buffer_size);
if (r < 0) {
log_std(("ERROR:sound:alsa: Couldn't set buffer size min %d: %s\n", (unsigned)buffer_size, snd_strerror(r)));
r = snd_pcm_hw_params_set_buffer_size_near(alsa_state.handle, hw_params, &buffer_size);
if (r < 0) {
log_std(("ERROR:sound:alsa: Couldn't set buffer size near %d: %s\n", (unsigned)buffer_size, snd_strerror(r)));
goto err_close;
} else {
log_std(("sound:alsa: set_buffer_size_near() -> %d\n", (unsigned)buffer_size));
}
} else {
log_std(("sound:alsa: set_buffer_size_min() -> %d\n", (unsigned)buffer_size));
}
if (buffer_size < alsa_state.rate * buffer_time) {
log_std(("ERROR:sound:alsa: audio buffer TOO SMALL\n"));
}
r = snd_pcm_hw_params(alsa_state.handle, hw_params);
if (r < 0) {
log_std(("ERROR:sound:alsa: Couldn't set hw audio parameters: %s\n", snd_strerror(r)));
goto err_close;
}
r = snd_pcm_sw_params_current(alsa_state.handle, sw_params);
if (r < 0) {
log_std(("ERROR:sound:alsa: Couldn't get software audio parameters: %s\n", snd_strerror(r)));
goto err_close;
}
r = snd_pcm_sw_params_set_xfer_align(alsa_state.handle, sw_params, 1);
if (r < 0) {
log_std(("ERROR:sound:alsa: Couldn't set xfer_align: %s\n", snd_strerror(r)));
goto err_close;
}
r = snd_pcm_sw_params(alsa_state.handle, sw_params);
if (r < 0) {
log_std(("ERROR:sound:alsa: Couldn't set sw audio parameters: %s\n", snd_strerror(r)));
goto err_close;
}
alsa_log(hw_params, sw_params);
*rate = alsa_state.rate;
return 0;
err_close:
snd_pcm_close(alsa_state.handle);
err:
error_set("Error initializing the ALSA library.\n");
return -1;
}
