ALCboolean alc_alsa_init(BackendFuncs *func_list)
{
if(!alsa_load())
return ALC_FALSE;
*func_list = alsa_funcs;
return ALC_TRUE;
}
void alc_alsa_probe(int type)
{
ALuint i;
if(!alsa_load())
return;
if(type == DEVICE_PROBE)
AppendDeviceList(alsaDevice);
else if(type == ALL_DEVICE_PROBE)
{
for(i = 0;i < numDevNames;++i)
free(allDevNameMap[i].name);
free(allDevNameMap);
allDevNameMap = probe_devices(SND_PCM_STREAM_PLAYBACK, &numDevNames);
for(i = 0;i < numDevNames;++i)
AppendAllDeviceList(allDevNameMap[i].name);
}
else if(type == CAPTURE_DEVICE_PROBE)
{
for(i = 0;i < numCaptureDevNames;++i)
free(allCaptureDevNameMap[i].name);
free(allCaptureDevNameMap);
allCaptureDevNameMap = probe_devices(SND_PCM_STREAM_CAPTURE, &numCaptureDevNames);
for(i = 0;i < numCaptureDevNames;++i)
AppendCaptureDeviceList(allCaptureDevNameMap[i].name);
}
}
static ALCboolean alsa_open_playback(ALCdevice *device, const ALCchar *deviceName)
{
alsa_data *data;
char driver[64];
int i;
if(!alsa_load())
return ALC_FALSE;
strncpy(driver, GetConfigValue("alsa", "device", "default"), sizeof(driver)-1);
driver[sizeof(driver)-1] = 0;
if(!deviceName)
deviceName = alsaDevice;
else if(strcmp(deviceName, alsaDevice) != 0)
{
size_t idx;
if(!allDevNameMap)
allDevNameMap = probe_devices(SND_PCM_STREAM_PLAYBACK, &numDevNames);
for(idx = 0;idx < numDevNames;idx++)
{
if(allDevNameMap[idx].name &&
strcmp(deviceName, allDevNameMap[idx].name) == 0)
{
if(idx > 0)
sprintf(driver, "hw:%d,%d", allDevNameMap[idx].card, allDevNameMap[idx].dev);
break;
}
}
if(idx == numDevNames)
return ALC_FALSE;
}
data = (alsa_data*)calloc(1, sizeof(alsa_data));
i = psnd_pcm_open(&data->pcmHandle, driver, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK);
if(i < 0)
{
Sleep(200);
i = psnd_pcm_open(&data->pcmHandle, driver, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK);
}
if(i >= 0)
{
i = psnd_pcm_nonblock(data->pcmHandle, 0);
if(i < 0)
psnd_pcm_close(data->pcmHandle);
}
if(i < 0)
{
free(data);
AL_PRINT("Could not open playback device '%s': %s\n", driver, psnd_strerror(i));
return ALC_FALSE;
}
device->szDeviceName = strdup(deviceName);
device->ExtraData = data;
return ALC_TRUE;
}
ALCboolean alc_alsa_init(BackendFuncs *func_list)
{
if(!alsa_load())
return ALC_FALSE;
device_prefix = GetConfigValue("alsa", "device-prefix", "plughw:");
capture_prefix = GetConfigValue("alsa", "capture-prefix", "plughw:");
*func_list = alsa_funcs;
return ALC_TRUE;
}
static ALCboolean alsa_open_capture(ALCdevice *pDevice, const ALCchar *deviceName)
{
snd_pcm_hw_params_t *p;
snd_pcm_uframes_t bufferSizeInFrames;
snd_pcm_format_t format;
ALuint frameSize;
alsa_data *data;
char driver[64];
char *err;
int i;
if(!alsa_load())
return ALC_FALSE;
strncpy(driver, GetConfigValue("alsa", "capture", "default"), sizeof(driver)-1);
driver[sizeof(driver)-1] = 0;
if(!allCaptureDevNameMap)
allCaptureDevNameMap = probe_devices(SND_PCM_STREAM_CAPTURE, &numCaptureDevNames);
if(!deviceName)
deviceName = allCaptureDevNameMap[0].name;
else
{
size_t idx;
for(idx = 0;idx < numCaptureDevNames;idx++)
{
if(allCaptureDevNameMap[idx].name &&
strcmp(deviceName, allCaptureDevNameMap[idx].name) == 0)
{
if(idx > 0)
sprintf(driver, "plughw:%d,%d", allCaptureDevNameMap[idx].card, allCaptureDevNameMap[idx].dev);
break;
}
}
if(idx == numCaptureDevNames)
return ALC_FALSE;
}
data = (alsa_data*)calloc(1, sizeof(alsa_data));
i = psnd_pcm_open(&data->pcmHandle, driver, SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK);
if(i < 0)
{
Sleep(200);
i = psnd_pcm_open(&data->pcmHandle, driver, SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK);
}
if(i < 0)
{
AL_PRINT("Could not open capture device '%s': %s\n", driver, psnd_strerror(i));
free(data);
return ALC_FALSE;
}
switch(aluBytesFromFormat(pDevice->Format))
{
case 1:
format = SND_PCM_FORMAT_U8;
break;
case 2:
format = SND_PCM_FORMAT_S16;
break;
case 4:
format = SND_PCM_FORMAT_FLOAT;
break;
default:
AL_PRINT("Unknown format: 0x%x\n", pDevice->Format);
goto error;
}
err = NULL;
bufferSizeInFrames = pDevice->UpdateSize * pDevice->NumUpdates;
psnd_pcm_hw_params_malloc(&p);
if((i=psnd_pcm_hw_params_any(data->pcmHandle, p)) < 0)
err = "any";
/* set interleaved access */
if(i >= 0 && (i=psnd_pcm_hw_params_set_access(data->pcmHandle, p, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0)
err = "set access";
/* set format (implicitly sets sample bits) */
if(i >= 0 && (i=psnd_pcm_hw_params_set_format(data->pcmHandle, p, format)) < 0)
err = "set format";
/* set channels (implicitly sets frame bits) */
if(i >= 0 && (i=psnd_pcm_hw_params_set_channels(data->pcmHandle, p, aluChannelsFromFormat(pDevice->Format))) < 0)
err = "set channels";
/* set rate (implicitly constrains period/buffer parameters) */
if(i >= 0 && (i=psnd_pcm_hw_params_set_rate(data->pcmHandle, p, pDevice->Frequency, 0)) < 0)
err = "set rate near";
/* set buffer size in frame units (implicitly sets period size/bytes/time and buffer time/bytes) */
if(i >= 0 && (i=psnd_pcm_hw_params_set_buffer_size_near(data->pcmHandle, p, &bufferSizeInFrames)) < 0)
err = "set buffer size near";
/* install and prepare hardware configuration */
if(i >= 0 && (i=psnd_pcm_hw_params(data->pcmHandle, p)) < 0)
err = "set params";
if(i < 0)
{
AL_PRINT("%s failed: %s\n", err, psnd_strerror(i));
psnd_pcm_hw_params_free(p);
goto error;
}
if((i=psnd_pcm_hw_params_get_period_size(p, &bufferSizeInFrames, NULL)) < 0)
{
AL_PRINT("get size failed: %s\n", psnd_strerror(i));
psnd_pcm_hw_params_free(p);
goto error;
}
psnd_pcm_hw_params_free(p);
frameSize = aluFrameSizeFromFormat(pDevice->Format);
data->ring = CreateRingBuffer(frameSize, pDevice->UpdateSize*pDevice->NumUpdates);
if(!data->ring)
{
AL_PRINT("ring buffer create failed\n");
goto error;
}
data->size = psnd_pcm_frames_to_bytes(data->pcmHandle, bufferSizeInFrames);
data->buffer = malloc(data->size);
if(!data->buffer)
{
AL_PRINT("buffer malloc failed\n");
goto error;
}
pDevice->szDeviceName = strdup(deviceName);
pDevice->ExtraData = data;
return ALC_TRUE;
error:
free(data->buffer);
DestroyRingBuffer(data->ring);
psnd_pcm_close(data->pcmHandle);
free(data);
pDevice->ExtraData = NULL;
return ALC_FALSE;
}