// This callback gets called when our context changes state. We really only
// care about when it's ready or if it has failed
void state_cb(pa_context *c, void *userdata) {
pa_context_state_t state;
int *pa_ready = userdata;
printf("State changed\n");
state = pa_context_get_state(c);
switch (state) {
// There are just here for reference
case PA_CONTEXT_UNCONNECTED:
case PA_CONTEXT_CONNECTING:
case PA_CONTEXT_AUTHORIZING:
case PA_CONTEXT_SETTING_NAME:
default:
break;
case PA_CONTEXT_FAILED:
case PA_CONTEXT_TERMINATED:
*pa_ready = 2;
break;
case PA_CONTEXT_READY: {
pa_buffer_attr buffer_attr;
if (verbose)
printf("Connection established.%s\n", CLEAR_LINE);
if (!(stream = pa_stream_new(c, "JanPlayback", &sample_spec, NULL))) {
printf("pa_stream_new() failed: %s", pa_strerror(pa_context_errno(c)));
exit(1); // goto fail;
}
pa_stream_set_state_callback(stream, stream_state_callback, NULL);
pa_stream_set_write_callback(stream, stream_write_callback, NULL);
//pa_stream_set_read_callback(stream, stream_read_callback, NULL);
pa_stream_set_suspended_callback(stream, stream_suspended_callback, NULL);
pa_stream_set_moved_callback(stream, stream_moved_callback, NULL);
pa_stream_set_underflow_callback(stream, stream_underflow_callback, NULL);
pa_stream_set_overflow_callback(stream, stream_overflow_callback, NULL);
pa_stream_set_started_callback(stream, stream_started_callback, NULL);
pa_stream_set_event_callback(stream, stream_event_callback, NULL);
pa_stream_set_buffer_attr_callback(stream, stream_buffer_attr_callback, NULL);
pa_zero(buffer_attr);
buffer_attr.maxlength = (uint32_t) -1;
buffer_attr.prebuf = (uint32_t) -1;
pa_cvolume cv;
if (pa_stream_connect_playback(stream, NULL, &buffer_attr, flags,
NULL,
NULL) < 0) {
printf("pa_stream_connect_playback() failed: %s", pa_strerror(pa_context_errno(c)));
exit(1); //goto fail;
} else {
printf("Set playback callback\n");
}
pa_stream_trigger(stream, stream_success, NULL);
}
break;
}
}
static int Open(vlc_object_t *obj)
{
demux_t *demux = (demux_t *)obj;
demux_sys_t *sys = malloc(sizeof (*sys));
if (unlikely(sys == NULL))
return VLC_ENOMEM;
sys->context = vlc_pa_connect(obj, &sys->mainloop);
if (sys->context == NULL) {
free(sys);
return VLC_EGENERIC;
}
sys->stream = NULL;
sys->es = NULL;
sys->discontinuity = false;
sys->caching = INT64_C(1000) * var_InheritInteger(obj, "live-caching");
demux->p_sys = sys;
/* Stream parameters */
struct pa_sample_spec ss;
ss.format = PA_SAMPLE_S16NE;
ss.rate = 48000;
ss.channels = 2;
assert(pa_sample_spec_valid(&ss));
struct pa_channel_map map;
map.channels = 2;
map.map[0] = PA_CHANNEL_POSITION_FRONT_LEFT;
map.map[1] = PA_CHANNEL_POSITION_FRONT_RIGHT;
assert(pa_channel_map_valid(&map));
const pa_stream_flags_t flags = PA_STREAM_INTERPOLATE_TIMING
| PA_STREAM_AUTO_TIMING_UPDATE
| PA_STREAM_ADJUST_LATENCY
| PA_STREAM_FIX_FORMAT
| PA_STREAM_FIX_RATE
/*| PA_STREAM_FIX_CHANNELS*/;
const char *dev = NULL;
if (demux->psz_location != NULL && demux->psz_location[0] != '\0')
dev = demux->psz_location;
struct pa_buffer_attr attr = {
.maxlength = -1,
.fragsize = pa_usec_to_bytes(sys->caching, &ss) / 2,
};
es_format_t fmt;
/* Create record stream */
pa_stream *s;
pa_operation *op;
pa_threaded_mainloop_lock(sys->mainloop);
s = pa_stream_new(sys->context, "audio stream", &ss, &map);
if (s == NULL)
goto error;
sys->stream = s;
pa_stream_set_state_callback(s, stream_state_cb, sys->mainloop);
pa_stream_set_read_callback(s, stream_read_cb, demux);
pa_stream_set_buffer_attr_callback(s, stream_buffer_attr_cb, demux);
pa_stream_set_moved_callback(s, stream_moved_cb, demux);
pa_stream_set_overflow_callback(s, stream_overflow_cb, demux);
pa_stream_set_started_callback(s, stream_started_cb, demux);
pa_stream_set_suspended_callback(s, stream_suspended_cb, demux);
pa_stream_set_underflow_callback(s, stream_underflow_cb, demux);
if (pa_stream_connect_record(s, dev, &attr, flags) < 0
|| stream_wait(s, sys->mainloop)) {
vlc_pa_error(obj, "cannot connect record stream", sys->context);
goto error;
}
/* The ES should be initialized before stream_read_cb(), but how? */
const struct pa_sample_spec *pss = pa_stream_get_sample_spec(s);
if ((unsigned)pss->format >= sizeof (fourccs) / sizeof (fourccs[0])) {
msg_Err(obj, "unknown PulseAudio sample format %u",
(unsigned)pss->format);
goto error;
}
vlc_fourcc_t format = fourccs[pss->format];
if (format == 0) { /* FIXME: should renegotiate something else */
msg_Err(obj, "unsupported PulseAudio sample format %u",
(unsigned)pss->format);
goto error;
}
es_format_Init(&fmt, AUDIO_ES, format);
fmt.audio.i_physical_channels = fmt.audio.i_original_channels =
AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT;
fmt.audio.i_channels = ss.channels;
fmt.audio.i_rate = pss->rate;
fmt.audio.i_bitspersample = aout_BitsPerSample(format);
fmt.audio.i_blockalign = fmt.audio.i_bitspersample * ss.channels / 8;
fmt.i_bitrate = fmt.audio.i_bitspersample * ss.channels * pss->rate;
sys->framesize = fmt.audio.i_blockalign;
sys->es = es_out_Add (demux->out, &fmt);
/* Update the buffer attributes according to actual format */
attr.fragsize = pa_usec_to_bytes(sys->caching, pss) / 2;
op = pa_stream_set_buffer_attr(s, &attr, stream_success_cb, sys->mainloop);
if (likely(op != NULL)) {
while (pa_operation_get_state(op) == PA_OPERATION_RUNNING)
pa_threaded_mainloop_wait(sys->mainloop);
pa_operation_unref(op);
}
stream_buffer_attr_cb(s, demux);
pa_threaded_mainloop_unlock(sys->mainloop);
demux->pf_demux = NULL;
demux->pf_control = Control;
return VLC_SUCCESS;
error:
pa_threaded_mainloop_unlock(sys->mainloop);
Close(obj);
return VLC_EGENERIC;
}
static void Close (vlc_object_t *obj)
{
demux_t *demux = (demux_t *)obj;
demux_sys_t *sys = demux->p_sys;
pa_stream *s = sys->stream;
if (likely(s != NULL)) {
pa_threaded_mainloop_lock(sys->mainloop);
pa_stream_disconnect(s);
pa_stream_set_state_callback(s, NULL, NULL);
pa_stream_set_read_callback(s, NULL, NULL);
pa_stream_set_buffer_attr_callback(s, NULL, NULL);
pa_stream_set_moved_callback(s, NULL, NULL);
pa_stream_set_overflow_callback(s, NULL, NULL);
pa_stream_set_started_callback(s, NULL, NULL);
pa_stream_set_suspended_callback(s, NULL, NULL);
pa_stream_set_underflow_callback(s, NULL, NULL);
pa_stream_unref(s);
pa_threaded_mainloop_unlock(sys->mainloop);
}
vlc_pa_disconnect(obj, sys->context, sys->mainloop);
free(sys);
}
/* This is called whenever the context status changes */
static void context_state_callback(pa_context *c, void *userdata) {
pa_assert(c);
switch (pa_context_get_state(c)) {
case PA_CONTEXT_CONNECTING:
case PA_CONTEXT_AUTHORIZING:
case PA_CONTEXT_SETTING_NAME:
break;
case PA_CONTEXT_READY: {
pa_buffer_attr buffer_attr;
pa_assert(c);
pa_assert(!stream);
if (verbose)
pa_log(_("Connection established.%s"), CLEAR_LINE);
if (!(stream = pa_stream_new_with_proplist(c, NULL, &sample_spec, &channel_map, proplist))) {
pa_log(_("pa_stream_new() failed: %s"), pa_strerror(pa_context_errno(c)));
goto fail;
}
pa_stream_set_state_callback(stream, stream_state_callback, NULL);
pa_stream_set_write_callback(stream, stream_write_callback, NULL);
pa_stream_set_read_callback(stream, stream_read_callback, NULL);
pa_stream_set_suspended_callback(stream, stream_suspended_callback, NULL);
pa_stream_set_moved_callback(stream, stream_moved_callback, NULL);
pa_stream_set_underflow_callback(stream, stream_underflow_callback, NULL);
pa_stream_set_overflow_callback(stream, stream_overflow_callback, NULL);
pa_stream_set_started_callback(stream, stream_started_callback, NULL);
pa_stream_set_event_callback(stream, stream_event_callback, NULL);
pa_stream_set_buffer_attr_callback(stream, stream_buffer_attr_callback, NULL);
pa_zero(buffer_attr);
buffer_attr.maxlength = (uint32_t) -1;
buffer_attr.prebuf = (uint32_t) -1;
if (latency_msec > 0) {
buffer_attr.fragsize = buffer_attr.tlength = pa_usec_to_bytes(latency_msec * PA_USEC_PER_MSEC, &sample_spec);
flags |= PA_STREAM_ADJUST_LATENCY;
} else if (latency > 0) {
buffer_attr.fragsize = buffer_attr.tlength = (uint32_t) latency;
flags |= PA_STREAM_ADJUST_LATENCY;
} else
buffer_attr.fragsize = buffer_attr.tlength = (uint32_t) -1;
if (process_time_msec > 0) {
buffer_attr.minreq = pa_usec_to_bytes(process_time_msec * PA_USEC_PER_MSEC, &sample_spec);
} else if (process_time > 0)
buffer_attr.minreq = (uint32_t) process_time;
else
buffer_attr.minreq = (uint32_t) -1;
if (mode == PLAYBACK) {
pa_cvolume cv;
if (pa_stream_connect_playback(stream, device, &buffer_attr, flags, volume_is_set ? pa_cvolume_set(&cv, sample_spec.channels, volume) : NULL, NULL) < 0) {
pa_log(_("pa_stream_connect_playback() failed: %s"), pa_strerror(pa_context_errno(c)));
goto fail;
}
} else {
if (pa_stream_connect_record(stream, device, latency > 0 ? &buffer_attr : NULL, flags) < 0) {
pa_log(_("pa_stream_connect_record() failed: %s"), pa_strerror(pa_context_errno(c)));
goto fail;
}
}
break;
}
case PA_CONTEXT_TERMINATED:
quit(0);
break;
case PA_CONTEXT_FAILED:
default:
pa_log(_("Connection failure: %s"), pa_strerror(pa_context_errno(c)));
goto fail;
}
return;
fail:
quit(1);
}
static void server_info_cb(pa_context *c, const pa_server_info *info, void *userdata) {
struct sound_dev **pDevices = userdata;
pa_buffer_attr rec_ba;
pa_buffer_attr play_ba;
pa_sample_spec ss;
pa_sample_spec default_ss;
pa_stream_flags_t pb_flags = PA_STREAM_NOFLAGS;
pa_stream_flags_t rec_flags = PA_STREAM_ADJUST_LATENCY;
default_ss = info->sample_spec;
printf("Connected to %s \n", info->host_name);
while(*pDevices) {
struct sound_dev *dev = *pDevices++;
const char *dev_name;
pa_stream *s;
pa_zero(rec_ba);
pa_zero(play_ba);
if (dev->name[5] == ':')
dev_name = dev->name + 6; // the device name is given; "pulse:alsa_input.pci-0000_00_1b.0.analog-stereo"
else
dev_name = NULL; // the device name is "pulse" for the default device
if (quisk_sound_state.verbose_pulse)
printf("Opening Device %s ", dev_name);
//Construct sample specification. Use S16LE if availiable. Default to Float32 for others.
//If the source/sink is not Float32, Pulseaudio will convert it (uses CPU)
//dev->sample_bytes = (int)pa_frame_size(&ss) / ss.channels;
if (default_ss.format == PA_SAMPLE_S16LE) {
dev->sample_bytes = 2;
ss.format = default_ss.format;
}
else {
dev->sample_bytes = 4;
ss.format = PA_SAMPLE_FLOAT32LE;
}
ss.rate = dev->sample_rate;
ss.channels = dev->num_channels;
rec_ba.maxlength = (uint32_t) -1;
rec_ba.fragsize = (uint32_t) SAMP_BUFFER_SIZE / 16; //higher numbers eat cpu on reading monitor streams.
play_ba.maxlength = (uint32_t) -1;
play_ba.prebuf = (uint32_t) (dev->sample_bytes * ss.channels * dev->latency_frames);
//play_ba.tlength = (uint32_t) -1;
play_ba.tlength = play_ba.prebuf;
if (dev->latency_frames == 0)
play_ba.minreq = (uint32_t) 0; //verify this is sane
else
play_ba.minreq = (uint32_t) -1;
if (dev->stream_dir_record) {
if (!(s = pa_stream_new(c, dev->stream_description, &ss, NULL))) {
printf("pa_stream_new() failed: %s", pa_strerror(pa_context_errno(c)));
exit(1);
}
if (pa_stream_connect_record(s, dev_name, &rec_ba, rec_flags) < 0) {
printf("pa_stream_connect_record() failed: %s", pa_strerror(pa_context_errno(c)));
exit(1);
}
pa_stream_set_overflow_callback(s, stream_overflow_callback, dev);
}
else {
pa_cvolume cv;
pa_volume_t volume = PA_VOLUME_NORM;
if (!(s = pa_stream_new(c, dev->stream_description, &ss, NULL))) {
printf("pa_stream_new() failed: %s", pa_strerror(pa_context_errno(c)));
exit(1);
}
if (pa_stream_connect_playback(s, dev_name, &play_ba, pb_flags, pa_cvolume_set(&cv, ss.channels, volume), NULL) < 0) {
printf("pa_stream_connect_playback() failed: %s", pa_strerror(pa_context_errno(c)));
exit(1);
}
pa_stream_set_underflow_callback(s, stream_underflow_callback, dev);
}
pa_stream_set_state_callback(s, stream_state_callback, dev);
pa_stream_set_started_callback(s, stream_started_callback, dev);
dev->handle = (void*)s; //save memory address for stream in handle
int i;
for(i=0;i < PA_LIST_SIZE;i++) { //save address for stream for easy exit
if (!(OpenPulseDevices[i])) {
OpenPulseDevices[i] = dev->handle;
break;
}
}
}
}
