コード例 #1
0
static void probe_devices( ALboolean capture )
{
	pa_threaded_mainloop* loop;

	if ( capture == AL_FALSE )
	{
		allDevNameMap = malloc( sizeof( DevMap ) * 1 );
		allDevNameMap[0].name = strdup( "PulseAudio Default" );
		allDevNameMap[0].device_name = NULL;
		numDevNames = 1;
	}
	else
	{
		allCaptureDevNameMap = malloc( sizeof( DevMap ) * 1 );
		allCaptureDevNameMap[0].name = strdup( "PulseAudio Default" );
		allCaptureDevNameMap[0].device_name = NULL;
		numCaptureDevNames = 1;
	}

	if ( ( loop = ppa_threaded_mainloop_new() ) &&
	     ppa_threaded_mainloop_start( loop ) >= 0 )
	{
		pa_context* context;

		ppa_threaded_mainloop_lock( loop );
		context = connect_context( loop );

		if ( context )
		{
			pa_operation* o;

			if ( capture == AL_FALSE )
			{
				o = ppa_context_get_sink_info_list( context, sink_device_callback, loop );
			}
			else
			{
				o = ppa_context_get_source_info_list( context, source_device_callback, loop );
			}

			while ( ppa_operation_get_state( o ) == PA_OPERATION_RUNNING )
			{
				ppa_threaded_mainloop_wait( loop );
			}

			ppa_operation_unref( o );

			ppa_context_disconnect( context );
			ppa_context_unref( context );
		}

		ppa_threaded_mainloop_unlock( loop );
		ppa_threaded_mainloop_stop( loop );
	}

	if ( loop )
	{
		ppa_threaded_mainloop_free( loop );
	}
}
コード例 #2
0
ファイル: pulseaudio.c プロジェクト: RuiVarela/rengine
static void pulse_stop_capture(ALCdevice *device) //{{{
{
    pulse_data *data = device->ExtraData;
    pa_operation *o;

    ppa_threaded_mainloop_lock(data->loop);
    o = ppa_stream_cork(data->stream, 1, stream_success_callback, device);
    while(ppa_operation_get_state(o) == PA_OPERATION_RUNNING)
        ppa_threaded_mainloop_wait(data->loop);
    ppa_operation_unref(o);
    ppa_threaded_mainloop_unlock(data->loop);
} //}}}
コード例 #3
0
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;
} //}}}