/* OpenAL */
static ALCenum pulse_open_playback(ALCdevice *device, const ALCchar *device_name)
{
const char *pulse_name = NULL;
pa_stream_flags_t flags;
pa_sample_spec spec;
pulse_data *data;
pa_operation *o;
if(device_name)
{
ALuint i;
if(!allDevNameMap)
probe_devices(AL_FALSE);
for(i = 0;i < numDevNames;i++)
{
if(strcmp(device_name, allDevNameMap[i].name) == 0)
{
pulse_name = allDevNameMap[i].device_name;
break;
}
}
if(i == numDevNames)
return ALC_INVALID_VALUE;
}
if(pulse_open(device) == ALC_FALSE)
return ALC_INVALID_VALUE;
data = device->ExtraData;
pa_threaded_mainloop_lock(data->loop);
flags = PA_STREAM_FIX_FORMAT | PA_STREAM_FIX_RATE |
PA_STREAM_FIX_CHANNELS | PA_STREAM_DONT_MOVE;
spec.format = PA_SAMPLE_S16NE;
spec.rate = 44100;
spec.channels = 2;
data->stream = connect_playback_stream(pulse_name, data->loop, data->context,
flags, NULL, &spec, NULL);
if(!data->stream)
{
pa_threaded_mainloop_unlock(data->loop);
pulse_close(device);
return ALC_INVALID_VALUE;
}
data->device_name = strdup(pa_stream_get_device_name(data->stream));
o = pa_context_get_sink_info_by_name(data->context, data->device_name,
sink_name_callback, device);
WAIT_FOR_OPERATION(o, data->loop);
pa_threaded_mainloop_unlock(data->loop);
return ALC_NO_ERROR;
}
static ALCboolean pulse_reset_playback(ALCdevice *device) //{{{
{
pulse_data *data = device->ExtraData;
pa_stream_flags_t flags = 0;
pa_channel_map chanmap;
pa_threaded_mainloop_lock(data->loop);
if(!(device->Flags&DEVICE_CHANNELS_REQUEST))
{
pa_operation *o;
o = pa_context_get_sink_info_by_name(data->context, data->device_name, sink_info_callback, device);
while(pa_operation_get_state(o) == PA_OPERATION_RUNNING)
pa_threaded_mainloop_wait(data->loop);
pa_operation_unref(o);
}
if(!(device->Flags&DEVICE_FREQUENCY_REQUEST))
flags |= PA_STREAM_FIX_RATE;
data->frame_size = FrameSizeFromDevFmt(device->FmtChans, device->FmtType);
data->attr.prebuf = -1;
data->attr.fragsize = -1;
data->attr.minreq = device->UpdateSize * data->frame_size;
data->attr.tlength = data->attr.minreq * maxu(device->NumUpdates, 2);
data->attr.maxlength = -1;
flags |= PA_STREAM_EARLY_REQUESTS;
flags |= PA_STREAM_INTERPOLATE_TIMING | PA_STREAM_AUTO_TIMING_UPDATE;
switch(device->FmtType)
{
case DevFmtByte:
device->FmtType = DevFmtUByte;
/* fall-through */
case DevFmtUByte:
data->spec.format = PA_SAMPLE_U8;
break;
case DevFmtUShort:
device->FmtType = DevFmtShort;
/* fall-through */
case DevFmtShort:
data->spec.format = PA_SAMPLE_S16NE;
break;
case DevFmtFloat:
data->spec.format = PA_SAMPLE_FLOAT32NE;
break;
}
data->spec.rate = device->Frequency;
data->spec.channels = ChannelsFromDevFmt(device->FmtChans);
if(pa_sample_spec_valid(&data->spec) == 0)
{
ERR("Invalid sample format\n");
pa_threaded_mainloop_unlock(data->loop);
return ALC_FALSE;
}
if(!pa_channel_map_init_auto(&chanmap, data->spec.channels, PA_CHANNEL_MAP_WAVEEX))
{
ERR("Couldn't build map for channel count (%d)!\n", data->spec.channels);
pa_threaded_mainloop_unlock(data->loop);
return ALC_FALSE;
}
SetDefaultWFXChannelOrder(device);
data->stream = connect_playback_stream(device, flags, &data->attr, &data->spec, &chanmap);
if(!data->stream)
{
pa_threaded_mainloop_unlock(data->loop);
return ALC_FALSE;
}
pa_stream_set_state_callback(data->stream, stream_state_callback2, device);
data->spec = *(pa_stream_get_sample_spec(data->stream));
if(device->Frequency != data->spec.rate)
{
pa_operation *o;
if((device->Flags&DEVICE_FREQUENCY_REQUEST))
ERR("Failed to set frequency %dhz, got %dhz instead\n", device->Frequency, data->spec.rate);
device->Flags &= ~DEVICE_FREQUENCY_REQUEST;
/* Server updated our playback rate, so modify the buffer attribs
* accordingly. */
data->attr.minreq = (ALuint64)(data->attr.minreq/data->frame_size) *
data->spec.rate / device->Frequency * data->frame_size;
data->attr.tlength = data->attr.minreq * maxu(device->NumUpdates, 2);
o = pa_stream_set_buffer_attr(data->stream, &data->attr,
stream_success_callback, device);
while(pa_operation_get_state(o) == PA_OPERATION_RUNNING)
pa_threaded_mainloop_wait(data->loop);
pa_operation_unref(o);
device->Frequency = data->spec.rate;
}
#if PA_CHECK_VERSION(0,9,15)
if(pa_stream_set_buffer_attr_callback)
pa_stream_set_buffer_attr_callback(data->stream, stream_buffer_attr_callback, device);
#endif
pa_stream_set_moved_callback(data->stream, stream_device_callback, device);
pa_stream_set_write_callback(data->stream, stream_write_callback, device);
pa_stream_set_underflow_callback(data->stream, stream_signal_callback, device);
data->attr = *(pa_stream_get_buffer_attr(data->stream));
ERR("PulseAudio returned minreq=%d, tlength=%d\n", data->attr.minreq, data->attr.tlength);
device->UpdateSize = data->attr.minreq / data->frame_size;
device->NumUpdates = (data->attr.tlength/data->frame_size) / device->UpdateSize;
while(device->NumUpdates <= 2)
{
pa_operation *o;
ERR("minreq too high - expect lag or break up\n");
/* Server gave a comparatively large minreq, so modify the tlength. */
device->NumUpdates = 2;
data->attr.tlength = data->attr.minreq * device->NumUpdates;
o = pa_stream_set_buffer_attr(data->stream, &data->attr,
stream_success_callback, device);
while(pa_operation_get_state(o) == PA_OPERATION_RUNNING)
pa_threaded_mainloop_wait(data->loop);
pa_operation_unref(o);
data->attr = *(pa_stream_get_buffer_attr(data->stream));
ERR("PulseAudio returned minreq=%d, tlength=%d", data->attr.minreq, data->attr.tlength);
device->UpdateSize = data->attr.minreq / data->frame_size;
device->NumUpdates = (data->attr.tlength/data->frame_size) / device->UpdateSize;
}
data->thread = StartThread(PulseProc, device);
if(!data->thread)
{
#if PA_CHECK_VERSION(0,9,15)
if(pa_stream_set_buffer_attr_callback)
pa_stream_set_buffer_attr_callback(data->stream, NULL, NULL);
#endif
pa_stream_set_moved_callback(data->stream, NULL, NULL);
pa_stream_set_write_callback(data->stream, NULL, NULL);
pa_stream_set_underflow_callback(data->stream, NULL, NULL);
pa_stream_disconnect(data->stream);
pa_stream_unref(data->stream);
data->stream = NULL;
pa_threaded_mainloop_unlock(data->loop);
return ALC_FALSE;
}
pa_threaded_mainloop_unlock(data->loop);
return ALC_TRUE;
} //}}}
// OpenAL {{{
static ALCenum pulse_open_playback(ALCdevice *device, const ALCchar *device_name) //{{{
{
char *pulse_name = NULL;
pa_sample_spec spec;
pulse_data *data;
if(!allDevNameMap)
probe_devices(AL_FALSE);
if(!device_name)
device_name = pulse_device;
else if(strcmp(device_name, pulse_device) != 0)
{
ALuint i;
for(i = 0;i < numDevNames;i++)
{
if(strcmp(device_name, allDevNameMap[i].name) == 0)
{
pulse_name = allDevNameMap[i].device_name;
break;
}
}
if(i == numDevNames)
return ALC_INVALID_VALUE;
}
if(pulse_open(device, device_name) == ALC_FALSE)
return ALC_INVALID_VALUE;
data = device->ExtraData;
pa_threaded_mainloop_lock(data->loop);
spec.format = PA_SAMPLE_S16NE;
spec.rate = 44100;
spec.channels = 2;
data->device_name = pulse_name;
pa_stream *stream = connect_playback_stream(device, 0, NULL, &spec, NULL);
if(!stream)
{
pa_threaded_mainloop_unlock(data->loop);
goto fail;
}
if(pa_stream_is_suspended(stream))
{
ERR("Device is suspended\n");
pa_stream_disconnect(stream);
pa_stream_unref(stream);
pa_threaded_mainloop_unlock(data->loop);
goto fail;
}
data->device_name = strdup(pa_stream_get_device_name(stream));
pa_stream_disconnect(stream);
pa_stream_unref(stream);
pa_threaded_mainloop_unlock(data->loop);
return ALC_NO_ERROR;
fail:
pulse_close(device);
return ALC_INVALID_VALUE;
} //}}}
static ALCboolean pulse_reset_playback( ALCdevice* device ) //{{{
{
pulse_data* data = device->ExtraData;
pa_stream_flags_t flags = 0;
pa_channel_map chanmap;
ppa_threaded_mainloop_lock( data->loop );
if ( !ConfigValueExists( NULL, "format" ) )
{
pa_operation* o;
o = ppa_context_get_sink_info_by_name( data->context, data->device_name, sink_info_callback, device );
while ( ppa_operation_get_state( o ) == PA_OPERATION_RUNNING )
{
ppa_threaded_mainloop_wait( data->loop );
}
ppa_operation_unref( o );
}
if ( !ConfigValueExists( NULL, "frequency" ) )
{
flags |= PA_STREAM_FIX_RATE;
}
data->frame_size = aluFrameSizeFromFormat( device->Format );
data->attr.minreq = -1;
data->attr.prebuf = -1;
data->attr.fragsize = -1;
data->attr.tlength = device->UpdateSize * device->NumUpdates *
data->frame_size;
data->attr.maxlength = data->attr.tlength;
switch ( aluBytesFromFormat( device->Format ) )
{
case 1:
data->spec.format = PA_SAMPLE_U8;
break;
case 2:
data->spec.format = PA_SAMPLE_S16NE;
break;
case 4:
data->spec.format = PA_SAMPLE_FLOAT32NE;
break;
default:
AL_PRINT( "Unknown format: 0x%x\n", device->Format );
ppa_threaded_mainloop_unlock( data->loop );
return ALC_FALSE;
}
data->spec.rate = device->Frequency;
data->spec.channels = aluChannelsFromFormat( device->Format );
if ( ppa_sample_spec_valid( &data->spec ) == 0 )
{
AL_PRINT( "Invalid sample format\n" );
ppa_threaded_mainloop_unlock( data->loop );
return ALC_FALSE;
}
if ( !ppa_channel_map_init_auto( &chanmap, data->spec.channels, PA_CHANNEL_MAP_WAVEEX ) )
{
AL_PRINT( "Couldn't build map for channel count (%d)!\n", data->spec.channels );
ppa_threaded_mainloop_unlock( data->loop );
return ALC_FALSE;
}
SetDefaultWFXChannelOrder( device );
data->stream = connect_playback_stream( device, flags, &data->attr, &data->spec, &chanmap );
if ( !data->stream )
{
ppa_threaded_mainloop_unlock( data->loop );
return ALC_FALSE;
}
ppa_stream_set_state_callback( data->stream, stream_state_callback2, device );
data->spec = *( ppa_stream_get_sample_spec( data->stream ) );
if ( device->Frequency != data->spec.rate )
{
pa_operation* o;
/* Server updated our playback rate, so modify the buffer attribs
* accordingly. */
data->attr.tlength = ( ALuint64 )( data->attr.tlength / data->frame_size ) *
data->spec.rate / device->Frequency * data->frame_size;
data->attr.maxlength = data->attr.tlength;
o = ppa_stream_set_buffer_attr( data->stream, &data->attr,
stream_success_callback, device );
while ( ppa_operation_get_state( o ) == PA_OPERATION_RUNNING )
{
ppa_threaded_mainloop_wait( data->loop );
}
ppa_operation_unref( o );
device->Frequency = data->spec.rate;
}
stream_buffer_attr_callback( data->stream, device );
#if PA_CHECK_VERSION(0,9,15)
if ( ppa_stream_set_buffer_attr_callback )
{
ppa_stream_set_buffer_attr_callback( data->stream, stream_buffer_attr_callback, device );
}
#endif
ppa_stream_set_moved_callback( data->stream, stream_device_callback, device );
stream_write_callback( data->stream, data->attr.tlength, device );
ppa_stream_set_write_callback( data->stream, stream_write_callback, device );
ppa_threaded_mainloop_unlock( data->loop );
return ALC_TRUE;
} //}}}
// OpenAL {{{
static ALCboolean pulse_open_playback( ALCdevice* device, const ALCchar* device_name ) //{{{
{
char* pulse_name = NULL;
pa_sample_spec spec;
pulse_data* data;
ALuint len;
if ( !pulse_load() )
{
return ALC_FALSE;
}
if ( !device_name )
{
device_name = pulse_device;
}
else if ( strcmp( device_name, pulse_device ) != 0 )
{
ALuint i;
if ( !allDevNameMap )
{
probe_devices( AL_FALSE );
}
for ( i = 0; i < numDevNames; i++ )
{
if ( strcmp( device_name, allDevNameMap[i].name ) == 0 )
{
pulse_name = allDevNameMap[i].device_name;
break;
}
}
if ( i == numDevNames )
{
return ALC_FALSE;
}
}
if ( pulse_open( device, device_name ) == ALC_FALSE )
{
return ALC_FALSE;
}
data = device->ExtraData;
ppa_threaded_mainloop_lock( data->loop );
spec.format = PA_SAMPLE_S16NE;
spec.rate = 44100;
spec.channels = 2;
data->device_name = pulse_name;
pa_stream* stream = connect_playback_stream( device, 0, NULL, &spec, NULL );
if ( !stream )
{
ppa_threaded_mainloop_unlock( data->loop );
goto fail;
}
if ( ppa_stream_is_suspended( stream ) )
{
ppa_stream_disconnect( stream );
ppa_stream_unref( stream );
ppa_threaded_mainloop_unlock( data->loop );
goto fail;
}
data->device_name = strdup( ppa_stream_get_device_name( stream ) );
ppa_stream_disconnect( stream );
ppa_stream_unref( stream );
ppa_threaded_mainloop_unlock( data->loop );
len = GetConfigValueInt( "pulse", "buffer-length", 2048 );
if ( len != 0 )
{
device->UpdateSize = len;
device->NumUpdates = 1;
}
return ALC_TRUE;
fail:
pulse_close( device );
return ALC_FALSE;
} //}}}
static ALCboolean pulse_reset_playback(ALCdevice *device)
{
pulse_data *data = device->ExtraData;
pa_stream_flags_t flags = 0;
pa_channel_map chanmap;
pa_threaded_mainloop_lock(data->loop);
if(data->stream)
{
#if PA_CHECK_VERSION(0,9,15)
if(pa_stream_set_buffer_attr_callback)
pa_stream_set_buffer_attr_callback(data->stream, NULL, NULL);
#endif
pa_stream_disconnect(data->stream);
pa_stream_unref(data->stream);
data->stream = NULL;
}
if(!(device->Flags&DEVICE_CHANNELS_REQUEST))
{
pa_operation *o;
o = pa_context_get_sink_info_by_name(data->context, data->device_name, sink_info_callback, device);
WAIT_FOR_OPERATION(o, data->loop);
}
if(!(device->Flags&DEVICE_FREQUENCY_REQUEST))
flags |= PA_STREAM_FIX_RATE;
flags |= PA_STREAM_INTERPOLATE_TIMING | PA_STREAM_AUTO_TIMING_UPDATE;
flags |= PA_STREAM_ADJUST_LATENCY;
flags |= PA_STREAM_START_CORKED;
flags |= PA_STREAM_DONT_MOVE;
switch(device->FmtType)
{
case DevFmtByte:
device->FmtType = DevFmtUByte;
/* fall-through */
case DevFmtUByte:
data->spec.format = PA_SAMPLE_U8;
break;
case DevFmtUShort:
device->FmtType = DevFmtShort;
/* fall-through */
case DevFmtShort:
data->spec.format = PA_SAMPLE_S16NE;
break;
case DevFmtUInt:
device->FmtType = DevFmtInt;
/* fall-through */
case DevFmtInt:
data->spec.format = PA_SAMPLE_S32NE;
break;
case DevFmtFloat:
data->spec.format = PA_SAMPLE_FLOAT32NE;
break;
}
data->spec.rate = device->Frequency;
data->spec.channels = ChannelsFromDevFmt(device->FmtChans);
if(pa_sample_spec_valid(&data->spec) == 0)
{
ERR("Invalid sample format\n");
pa_threaded_mainloop_unlock(data->loop);
return ALC_FALSE;
}
if(!pa_channel_map_init_auto(&chanmap, data->spec.channels, PA_CHANNEL_MAP_WAVEEX))
{
ERR("Couldn't build map for channel count (%d)!\n", data->spec.channels);
pa_threaded_mainloop_unlock(data->loop);
return ALC_FALSE;
}
SetDefaultWFXChannelOrder(device);
data->attr.fragsize = -1;
data->attr.prebuf = 0;
data->attr.minreq = device->UpdateSize * pa_frame_size(&data->spec);
data->attr.tlength = data->attr.minreq * maxu(device->NumUpdates, 2);
data->attr.maxlength = -1;
data->stream = connect_playback_stream(data->device_name, data->loop,
data->context, flags, &data->attr,
&data->spec, &chanmap);
if(!data->stream)
{
pa_threaded_mainloop_unlock(data->loop);
return ALC_FALSE;
}
pa_stream_set_state_callback(data->stream, stream_state_callback2, device);
data->spec = *(pa_stream_get_sample_spec(data->stream));
if(device->Frequency != data->spec.rate)
{
pa_operation *o;
/* Server updated our playback rate, so modify the buffer attribs
* accordingly. */
data->attr.minreq = (ALuint64)device->UpdateSize * data->spec.rate /
device->Frequency * pa_frame_size(&data->spec);
data->attr.tlength = data->attr.minreq * maxu(device->NumUpdates, 2);
data->attr.prebuf = 0;
o = pa_stream_set_buffer_attr(data->stream, &data->attr,
stream_success_callback, device);
WAIT_FOR_OPERATION(o, data->loop);
device->Frequency = data->spec.rate;
}
#if PA_CHECK_VERSION(0,9,15)
if(pa_stream_set_buffer_attr_callback)
pa_stream_set_buffer_attr_callback(data->stream, stream_buffer_attr_callback, device);
#endif
stream_buffer_attr_callback(data->stream, device);
device->NumUpdates = device->UpdateSize*device->NumUpdates /
(data->attr.minreq/pa_frame_size(&data->spec));
device->NumUpdates = maxu(device->NumUpdates, 2);
device->UpdateSize = data->attr.minreq / pa_frame_size(&data->spec);
pa_threaded_mainloop_unlock(data->loop);
return ALC_TRUE;
}
static void probe_devices(ALboolean capture)
{
pa_threaded_mainloop *loop;
if(capture == AL_FALSE)
allDevNameMap = malloc(sizeof(DevMap) * 1);
else
allCaptureDevNameMap = malloc(sizeof(DevMap) * 1);
if((loop=pa_threaded_mainloop_new()) &&
pa_threaded_mainloop_start(loop) >= 0)
{
pa_context *context;
pa_threaded_mainloop_lock(loop);
context = connect_context(loop, AL_FALSE);
if(context)
{
pa_operation *o;
if(capture == AL_FALSE)
{
pa_stream_flags_t flags;
pa_sample_spec spec;
pa_stream *stream;
flags = PA_STREAM_FIX_FORMAT | PA_STREAM_FIX_RATE |
PA_STREAM_FIX_CHANNELS | PA_STREAM_DONT_MOVE;
spec.format = PA_SAMPLE_S16NE;
spec.rate = 44100;
spec.channels = 2;
stream = connect_playback_stream(NULL, loop, context, flags,
NULL, &spec, NULL);
if(stream)
{
o = pa_context_get_sink_info_by_name(context, pa_stream_get_device_name(stream), sink_device_callback, loop);
WAIT_FOR_OPERATION(o, loop);
pa_stream_disconnect(stream);
pa_stream_unref(stream);
stream = NULL;
}
o = pa_context_get_sink_info_list(context, sink_device_callback, loop);
}
else
{
pa_stream_flags_t flags;
pa_sample_spec spec;
pa_stream *stream;
flags = PA_STREAM_FIX_FORMAT | PA_STREAM_FIX_RATE |
PA_STREAM_FIX_CHANNELS | PA_STREAM_DONT_MOVE;
spec.format = PA_SAMPLE_S16NE;
spec.rate = 44100;
spec.channels = 1;
stream = connect_record_stream(NULL, loop, context, flags,
NULL, &spec, NULL);
if(stream)
{
o = pa_context_get_source_info_by_name(context, pa_stream_get_device_name(stream), source_device_callback, loop);
WAIT_FOR_OPERATION(o, loop);
pa_stream_disconnect(stream);
pa_stream_unref(stream);
stream = NULL;
}
o = pa_context_get_source_info_list(context, source_device_callback, loop);
}
WAIT_FOR_OPERATION(o, loop);
pa_context_disconnect(context);
pa_context_unref(context);
}
pa_threaded_mainloop_unlock(loop);
pa_threaded_mainloop_stop(loop);
}
if(loop)
pa_threaded_mainloop_free(loop);
}