void on_monitor_read_callback(pa_stream *p, size_t length, void *userdata)
{
const void *data;
double v;
printf("read callback length: %d\n", length);
printf("\tget_device_index: %d\n", pa_stream_get_device_index(p));
printf("\tget_device_name: %s\n", pa_stream_get_device_name(p));
printf("\tget_monitor_stream: %d\n", pa_stream_get_monitor_stream(p));
if (pa_stream_peek(p, &data, &length) < 0) {
printf("Failed to read data from stream\n");
return;
}
assert(length > 0);
assert(length % sizeof(float) == 0);
v = ((const float*) data)[length / sizeof(float) -1];
pa_stream_drop(p);
if (v < 0) v = 0;
//if (v > 1) v = 1;
printf("\tread callback peek: %f\n", v);
ret = v;
g_main_loop_quit(mainloop);
}
void QPulseAudioThread::stream_moved_callback(pa_stream *s, void *userdata)
{
Q_ASSERT(s);
if (verbose)
fprintf(stderr, "Stream moved to device %s (%u, %ssuspended).\n", pa_stream_get_device_name(s), pa_stream_get_device_index(s), pa_stream_is_suspended(s) ? "" : "not ");
}
void
AudioStream::stream_state_callback(pa_stream* s, void* /*user_data*/)
{
char str[PA_SAMPLE_SPEC_SNPRINT_MAX];
switch (pa_stream_get_state(s)) {
case PA_STREAM_CREATING:
DEBUG("Stream is creating...");
break;
case PA_STREAM_TERMINATED:
DEBUG("Stream is terminating...");
break;
case PA_STREAM_READY:
DEBUG("Stream successfully created, connected to %s", pa_stream_get_device_name(s));
DEBUG("maxlength %u", pa_stream_get_buffer_attr(s)->maxlength);
DEBUG("tlength %u", pa_stream_get_buffer_attr(s)->tlength);
DEBUG("prebuf %u", pa_stream_get_buffer_attr(s)->prebuf);
DEBUG("minreq %u", pa_stream_get_buffer_attr(s)->minreq);
DEBUG("fragsize %u", pa_stream_get_buffer_attr(s)->fragsize);
DEBUG("samplespec %s", pa_sample_spec_snprint(str, sizeof(str), pa_stream_get_sample_spec(s)));
break;
case PA_STREAM_UNCONNECTED:
DEBUG("Stream unconnected");
break;
case PA_STREAM_FAILED:
default:
ERROR("Sink/Source doesn't exists: %s" , pa_strerror(pa_context_errno(pa_stream_get_context(s))));
break;
}
}
void
AudioStream::stateChanged(pa_stream* s)
{
UNUSED char str[PA_SAMPLE_SPEC_SNPRINT_MAX];
switch (pa_stream_get_state(s)) {
case PA_STREAM_CREATING:
RING_DBG("Stream is creating...");
break;
case PA_STREAM_TERMINATED:
RING_DBG("Stream is terminating...");
break;
case PA_STREAM_READY:
RING_DBG("Stream successfully created, connected to %s", pa_stream_get_device_name(s));
//RING_DBG("maxlength %u", pa_stream_get_buffer_attr(s)->maxlength);
//RING_DBG("tlength %u", pa_stream_get_buffer_attr(s)->tlength);
//RING_DBG("prebuf %u", pa_stream_get_buffer_attr(s)->prebuf);
//RING_DBG("minreq %u", pa_stream_get_buffer_attr(s)->minreq);
//RING_DBG("fragsize %u", pa_stream_get_buffer_attr(s)->fragsize);
//RING_DBG("samplespec %s", pa_sample_spec_snprint(str, sizeof(str), pa_stream_get_sample_spec(s)));
break;
case PA_STREAM_UNCONNECTED:
RING_DBG("Stream unconnected");
break;
case PA_STREAM_FAILED:
default:
RING_ERR("Stream failure: %s" , pa_strerror(pa_context_errno(pa_stream_get_context(s))));
break;
}
}
JNIEXPORT jstring JNICALL
Java_org_jitsi_impl_neomedia_pulseaudio_PA_stream_1get_1device_1name
(JNIEnv *env, jclass clazz, jlong s)
{
const char *chars = pa_stream_get_device_name((pa_stream *) (intptr_t) s);
return chars ? (*env)->NewStringUTF(env, chars) : NULL;
}
static void stream_device_callback(pa_stream *stream, void *pdata) //{{{
{
ALCdevice *Device = pdata;
pulse_data *data = Device->ExtraData;
free(data->device_name);
data->device_name = strdup(pa_stream_get_device_name(stream));
}//}}}
static void stream_moved_cb(pa_stream *s, void *userdata)
{
audio_output_t *aout = userdata;
const char *name = pa_stream_get_device_name(s);
msg_Dbg(aout, "connected to sink %s", name);
aout_DeviceReport(aout, name);
}
/* 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 void stream_moved_cb(pa_stream *s, void *userdata)
{
demux_t *demux = userdata;
uint32_t idx = pa_stream_get_device_index(s);
msg_Dbg(demux, "connected to source %"PRIu32": %s", idx,
pa_stream_get_device_name(s));
stream_buffer_attr_cb(s, userdata);
}
/**
* Pulseaudio stream state callback
*/
static void
stream_state_callback (pa_stream * s, void *userdata)
{
GNUNET_assert (NULL != s);
switch (pa_stream_get_state (s))
{
case PA_STREAM_CREATING:
case PA_STREAM_TERMINATED:
break;
case PA_STREAM_READY:
{
const pa_buffer_attr *a;
char cmt[PA_CHANNEL_MAP_SNPRINT_MAX];
char sst[PA_SAMPLE_SPEC_SNPRINT_MAX];
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
_("Stream successfully created.\n"));
if (!(a = pa_stream_get_buffer_attr (s)))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("pa_stream_get_buffer_attr() failed: %s\n"),
pa_strerror (pa_context_errno
(pa_stream_get_context (s))));
}
else
{
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
_("Buffer metrics: maxlength=%u, fragsize=%u\n"),
a->maxlength, a->fragsize);
}
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
_("Using sample spec '%s', channel map '%s'.\n"),
pa_sample_spec_snprint (sst, sizeof (sst),
pa_stream_get_sample_spec (s)),
pa_channel_map_snprint (cmt, sizeof (cmt),
pa_stream_get_channel_map (s)));
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
_("Connected to device %s (%u, %ssuspended).\n"),
pa_stream_get_device_name (s),
pa_stream_get_device_index (s),
pa_stream_is_suspended (s) ? "" : "not ");
}
break;
case PA_STREAM_FAILED:
default:
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Stream error: %s\n"),
pa_strerror (pa_context_errno (pa_stream_get_context (s))));
quit (1);
}
}
static void stream_moved_callback(pa_stream *stream, void *pdata)
{
ALCdevice *device = pdata;
pulse_data *data = device->ExtraData;
(void)stream;
free(data->device_name);
data->device_name = strdup(pa_stream_get_device_name(data->stream));
TRACE("Stream moved to %s\n", data->device_name);
}
static void stream_moved_cb(pa_stream *s, void *userdata)
{
audio_output_t *aout = userdata;
aout_sys_t *sys = aout->sys;
const char *name = pa_stream_get_device_name(s);
pa_operation *op;
msg_Dbg(aout, "connected to sink %s", name);
aout_DeviceReport(aout, name);
op = pa_context_get_sink_info_by_name(sys->context, name, sink_info_cb,
aout);
if (likely(op != NULL))
pa_operation_unref(op);
}
static void stream_moved_cb(pa_stream *s, void *userdata)
{
audio_output_t *aout = userdata;
aout_sys_t *sys = aout->sys;
const char *name = pa_stream_get_device_name(s);
struct sink *sink = sink_find(sys, pa_stream_get_device_index(s));
msg_Dbg(aout, "connected to sink %s", name);
aout_DeviceReport(aout, name);
sys->base_volume = likely(sink != NULL) ? sink->base_volume
: PA_VOLUME_INVALID;
msg_Dbg(aout, "base volume: %"PRIu32, sys->base_volume);
if (pa_cvolume_valid(&sys->cvolume))
VolumeReport(aout);
}
/* This routine is called whenever the stream state changes */
static void stream_state_callback(pa_stream *s, void *userdata) {
pa_assert(s);
switch (pa_stream_get_state(s)) {
case PA_STREAM_CREATING:
case PA_STREAM_TERMINATED:
break;
case PA_STREAM_READY:
if (verbose) {
const pa_buffer_attr *a;
char cmt[PA_CHANNEL_MAP_SNPRINT_MAX], sst[PA_SAMPLE_SPEC_SNPRINT_MAX];
pa_log(_("Stream successfully created."));
if (!(a = pa_stream_get_buffer_attr(s)))
pa_log(_("pa_stream_get_buffer_attr() failed: %s"), pa_strerror(pa_context_errno(pa_stream_get_context(s))));
else {
if (mode == PLAYBACK)
pa_log(_("Buffer metrics: maxlength=%u, tlength=%u, prebuf=%u, minreq=%u"), a->maxlength, a->tlength, a->prebuf, a->minreq);
else {
pa_assert(mode == RECORD);
pa_log(_("Buffer metrics: maxlength=%u, fragsize=%u"), a->maxlength, a->fragsize);
}
}
pa_log(_("Using sample spec '%s', channel map '%s'."),
pa_sample_spec_snprint(sst, sizeof(sst), pa_stream_get_sample_spec(s)),
pa_channel_map_snprint(cmt, sizeof(cmt), pa_stream_get_channel_map(s)));
pa_log(_("Connected to device %s (%u, %ssuspended)."),
pa_stream_get_device_name(s),
pa_stream_get_device_index(s),
pa_stream_is_suspended(s) ? "" : "not ");
}
break;
case PA_STREAM_FAILED:
default:
pa_log(_("Stream error: %s"), pa_strerror(pa_context_errno(pa_stream_get_context(s))));
quit(1);
}
}
void stream_state_callback(pa_stream *s, void *userdata) {
assert(s);
switch (pa_stream_get_state(s)) {
case PA_STREAM_CREATING:
break;
case PA_STREAM_TERMINATED:
break;
case PA_STREAM_READY:
if (verbose) {
const pa_buffer_attr *a;
char cmt[PA_CHANNEL_MAP_SNPRINT_MAX], sst[PA_SAMPLE_SPEC_SNPRINT_MAX];
printf("Stream successfully created.\n");
if (!(a = pa_stream_get_buffer_attr(s)))
printf("pa_stream_get_buffer_attr() failed: %s\n", pa_strerror(pa_context_errno(pa_stream_get_context(s))));
else {
printf("Buffer metrics: maxlength=%u, fragsize=%u\n", a->maxlength, a->fragsize);
}
/*
printf("Using sample spec '%s', channel map '%s'.",
pa_sample_spec_snprint(sst, sizeof(sst), pa_stream_get_sample_spec(s)),
pa_channel_map_snprint(cmt, sizeof(cmt), pa_stream_get_channel_map(s)));
*/
printf("Connected to device %s (%u, %ssuspended).\n",
pa_stream_get_device_name(s),
pa_stream_get_device_index(s),
pa_stream_is_suspended(s) ? "" : "not ");
}
break;
case PA_STREAM_FAILED:
default:
printf("Stream error: %s", pa_strerror(pa_context_errno(pa_stream_get_context(s))));
exit(1); //quit(1);
}
}
void stream_state_callback(pa_stream *s, void *userdata) {
struct sound_dev *dev = userdata;
assert(s);
assert(dev);
switch (pa_stream_get_state(s)) {
case PA_STREAM_CREATING:
break;
case PA_STREAM_TERMINATED:
if (quisk_sound_state.verbose_pulse)
printf("stream %s terminated\n", dev->name);
streams_ready--;
break;
case PA_STREAM_READY:
streams_ready++; //increment counter to tell other thread that this stream is ready
if (quisk_sound_state.verbose_pulse) {
const pa_buffer_attr *a;
printf("Connected to device %s (%u, %ssuspended). ",
pa_stream_get_device_name(s), pa_stream_get_device_index(s),
pa_stream_is_suspended(s) ? "" : "not ");
if (!(a = pa_stream_get_buffer_attr(s)))
printf("pa_stream_get_buffer_attr() failed: %s", pa_strerror(pa_context_errno(pa_stream_get_context(s))));
else if (!(a->prebuf)) {
printf("Buffer metrics %s: maxlength=%u, fragsize=%u\n", dev->name, a->maxlength, a->fragsize);
}
else {
printf("Buffer metrics %s: maxlength=%u, prebuf=%u, tlength=%u minreq=%u\n",
dev->name, a->maxlength, a->prebuf, a->tlength, a->minreq);
}
}
break;
case PA_STREAM_FAILED:
default:
printf("Stream error: %s - %s\n", dev->name, pa_strerror(pa_context_errno(pa_stream_get_context(s))));
exit(1);
}
}
void AudioStream::moved(pa_stream* s)
{
audiostream_ = s;
RING_DBG("Stream %d to %s", pa_stream_get_index(s), pa_stream_get_device_name(s));
}
static void stream_moved_callback(pa_stream *s, void *userdata) {
assert(s);
if (verbose)
fprintf(stderr, "Stream moved to device %s (%u, %ssuspended).%s \n", pa_stream_get_device_name(s), pa_stream_get_device_index(s), pa_stream_is_suspended(s) ? "" : "not ", CLEAR_LINE);
}
static void stream_moved_callback(pa_stream *s, void *userdata) {
pa_assert(s);
if (verbose)
pa_log(_("Stream moved to device %s (%u, %ssuspended).%s"), pa_stream_get_device_name(s), pa_stream_get_device_index(s), pa_stream_is_suspended(s) ? "" : _("not "), CLEAR_LINE);
}
// 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;
} //}}}
/*****************************************************************************
* Open: open the audio device
*****************************************************************************/
static int Open ( vlc_object_t *p_this )
{
aout_instance_t *p_aout = (aout_instance_t *)p_this;
struct aout_sys_t * p_sys;
struct pa_sample_spec ss;
const struct pa_buffer_attr *buffer_attr;
struct pa_buffer_attr a;
struct pa_channel_map map;
/* Allocate structures */
p_aout->output.p_sys = p_sys = calloc( 1, sizeof( aout_sys_t ) );
if( p_sys == NULL )
return VLC_ENOMEM;
PULSE_DEBUG( "Pulse start initialization");
ss.channels = aout_FormatNbChannels( &p_aout->output.output ); /* Get the input stream channel count */
/* Setup the pulse audio stream based on the input stream count */
switch(ss.channels)
{
case 8:
p_aout->output.output.i_physical_channels
= AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
| AOUT_CHAN_MIDDLELEFT | AOUT_CHAN_MIDDLERIGHT
| AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT
| AOUT_CHAN_LFE;
break;
case 6:
p_aout->output.output.i_physical_channels
= AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
| AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT
| AOUT_CHAN_LFE;
break;
case 4:
p_aout->output.output.i_physical_channels
= AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT
| AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT;
break;
case 2:
p_aout->output.output.i_physical_channels
= AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT;
break;
case 1:
p_aout->output.output.i_physical_channels = AOUT_CHAN_CENTER;
break;
default:
msg_Err(p_aout,"Invalid number of channels");
goto fail;
}
/* Add a quick command line info message */
msg_Info(p_aout, "No. of Audio Channels: %d", ss.channels);
ss.rate = p_aout->output.output.i_rate;
ss.format = PA_SAMPLE_FLOAT32NE;
p_aout->output.output.i_format = VLC_CODEC_FL32;
if (!pa_sample_spec_valid(&ss)) {
msg_Err(p_aout,"Invalid sample spec");
goto fail;
}
/* Reduce overall latency to 200mS to reduce audible clicks
* Also pulse minreq and internal buffers are now 20mS which reduces resampling
*/
a.tlength = pa_bytes_per_second(&ss)/5;
a.maxlength = a.tlength * 2;
a.prebuf = a.tlength / 2;
a.minreq = a.tlength / 10;
/* Buffer size is 20mS */
p_sys->buffer_size = a.minreq;
/* Initialise the speaker map setup above */
pa_channel_map_init_auto(&map, ss.channels, PA_CHANNEL_MAP_ALSA);
if (!(p_sys->mainloop = pa_threaded_mainloop_new())) {
msg_Err(p_aout, "Failed to allocate main loop");
goto fail;
}
if (!(p_sys->context = pa_context_new(pa_threaded_mainloop_get_api(p_sys->mainloop), _( PULSE_CLIENT_NAME )))) {
msg_Err(p_aout, "Failed to allocate context");
goto fail;
}
pa_context_set_state_callback(p_sys->context, context_state_cb, p_aout);
PULSE_DEBUG( "Pulse before context connect");
if (pa_context_connect(p_sys->context, NULL, 0, NULL) < 0) {
msg_Err(p_aout, "Failed to connect to server: %s", pa_strerror(pa_context_errno(p_sys->context)));
goto fail;
}
PULSE_DEBUG( "Pulse after context connect");
pa_threaded_mainloop_lock(p_sys->mainloop);
if (pa_threaded_mainloop_start(p_sys->mainloop) < 0) {
msg_Err(p_aout, "Failed to start main loop");
goto unlock_and_fail;
}
msg_Dbg(p_aout, "Pulse mainloop started");
/* Wait until the context is ready */
pa_threaded_mainloop_wait(p_sys->mainloop);
if (pa_context_get_state(p_sys->context) != PA_CONTEXT_READY) {
msg_Err(p_aout, "Failed to connect to server: %s", pa_strerror(pa_context_errno(p_sys->context)));
goto unlock_and_fail;
}
if (!(p_sys->stream = pa_stream_new(p_sys->context, "audio stream", &ss, &map))) {
msg_Err(p_aout, "Failed to create stream: %s", pa_strerror(pa_context_errno(p_sys->context)));
goto unlock_and_fail;
}
PULSE_DEBUG( "Pulse after new stream");
pa_stream_set_state_callback(p_sys->stream, stream_state_cb, p_aout);
pa_stream_set_write_callback(p_sys->stream, stream_request_cb, p_aout);
pa_stream_set_latency_update_callback(p_sys->stream, stream_latency_update_cb, p_aout);
if (pa_stream_connect_playback(p_sys->stream, NULL, &a, PA_STREAM_INTERPOLATE_TIMING|PA_STREAM_AUTO_TIMING_UPDATE|PA_STREAM_ADJUST_LATENCY, NULL, NULL) < 0) {
msg_Err(p_aout, "Failed to connect stream: %s", pa_strerror(pa_context_errno(p_sys->context)));
goto unlock_and_fail;
}
PULSE_DEBUG("Pulse stream connect");
/* Wait until the stream is ready */
pa_threaded_mainloop_wait(p_sys->mainloop);
msg_Dbg(p_aout,"Pulse stream connected");
if (pa_stream_get_state(p_sys->stream) != PA_STREAM_READY) {
msg_Err(p_aout, "Failed to connect to server: %s", pa_strerror(pa_context_errno(p_sys->context)));
goto unlock_and_fail;
}
PULSE_DEBUG("Pulse after stream get status");
pa_threaded_mainloop_unlock(p_sys->mainloop);
buffer_attr = pa_stream_get_buffer_attr(p_sys->stream);
p_aout->output.i_nb_samples = buffer_attr->minreq / pa_frame_size(&ss);
p_aout->output.pf_play = Play;
aout_VolumeSoftInit(p_aout);
msg_Dbg(p_aout, "Pulse initialized successfully");
{
char cmt[PA_CHANNEL_MAP_SNPRINT_MAX], sst[PA_SAMPLE_SPEC_SNPRINT_MAX];
msg_Dbg(p_aout, "Buffer metrics: maxlength=%u, tlength=%u, prebuf=%u, minreq=%u", buffer_attr->maxlength, buffer_attr->tlength, buffer_attr->prebuf, buffer_attr->minreq);
msg_Dbg(p_aout, "Using sample spec '%s', channel map '%s'.",
pa_sample_spec_snprint(sst, sizeof(sst), pa_stream_get_sample_spec(p_sys->stream)),
pa_channel_map_snprint(cmt, sizeof(cmt), pa_stream_get_channel_map(p_sys->stream)));
msg_Dbg(p_aout, "Connected to device %s (%u, %ssuspended).",
pa_stream_get_device_name(p_sys->stream),
pa_stream_get_device_index(p_sys->stream),
pa_stream_is_suspended(p_sys->stream) ? "" : "not ");
}
return VLC_SUCCESS;
unlock_and_fail:
msg_Dbg(p_aout, "Pulse initialization unlock and fail");
if (p_sys->mainloop)
pa_threaded_mainloop_unlock(p_sys->mainloop);
fail:
msg_Err(p_aout, "Pulse initialization failed");
uninit(p_aout);
return VLC_EGENERIC;
}
static ALCenum pulse_open_capture(ALCdevice *device, const ALCchar *device_name)
{
const char *pulse_name = NULL;
pa_stream_flags_t flags = 0;
pa_channel_map chanmap;
pulse_data *data;
pa_operation *o;
ALuint samples;
if(device_name)
{
ALuint i;
if(!allCaptureDevNameMap)
probe_devices(AL_TRUE);
for(i = 0;i < numCaptureDevNames;i++)
{
if(strcmp(device_name, allCaptureDevNameMap[i].name) == 0)
{
pulse_name = allCaptureDevNameMap[i].device_name;
break;
}
}
if(i == numCaptureDevNames)
return ALC_INVALID_VALUE;
}
if(pulse_open(device) == ALC_FALSE)
return ALC_INVALID_VALUE;
data = device->ExtraData;
pa_threaded_mainloop_lock(data->loop);
data->spec.rate = device->Frequency;
data->spec.channels = ChannelsFromDevFmt(device->FmtChans);
switch(device->FmtType)
{
case DevFmtUByte:
data->spec.format = PA_SAMPLE_U8;
break;
case DevFmtShort:
data->spec.format = PA_SAMPLE_S16NE;
break;
case DevFmtInt:
data->spec.format = PA_SAMPLE_S32NE;
break;
case DevFmtFloat:
data->spec.format = PA_SAMPLE_FLOAT32NE;
break;
case DevFmtByte:
case DevFmtUShort:
case DevFmtUInt:
ERR("%s capture samples not supported\n", DevFmtTypeString(device->FmtType));
pa_threaded_mainloop_unlock(data->loop);
goto fail;
}
if(pa_sample_spec_valid(&data->spec) == 0)
{
ERR("Invalid sample format\n");
pa_threaded_mainloop_unlock(data->loop);
goto fail;
}
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);
goto fail;
}
samples = device->UpdateSize * device->NumUpdates;
samples = maxu(samples, 100 * device->Frequency / 1000);
data->attr.minreq = -1;
data->attr.prebuf = -1;
data->attr.maxlength = samples * pa_frame_size(&data->spec);
data->attr.tlength = -1;
data->attr.fragsize = minu(samples, 50*device->Frequency/1000) *
pa_frame_size(&data->spec);
flags |= PA_STREAM_DONT_MOVE;
flags |= PA_STREAM_START_CORKED|PA_STREAM_ADJUST_LATENCY;
data->stream = connect_record_stream(pulse_name, data->loop, data->context,
flags, &data->attr, &data->spec,
&chanmap);
if(!data->stream)
{
pa_threaded_mainloop_unlock(data->loop);
goto fail;
}
pa_stream_set_state_callback(data->stream, stream_state_callback2, device);
data->device_name = strdup(pa_stream_get_device_name(data->stream));
o = pa_context_get_source_info_by_name(data->context, data->device_name,
source_name_callback, device);
WAIT_FOR_OPERATION(o, data->loop);
pa_threaded_mainloop_unlock(data->loop);
return ALC_NO_ERROR;
fail:
pulse_close(device);
return ALC_INVALID_VALUE;
}
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);
}
