static int outstream_start_pa(struct SoundIoPrivate *si, struct SoundIoOutStreamPrivate *os) {
struct SoundIoOutStream *outstream = &os->pub;
struct SoundIoPulseAudio *sipa = &si->backend_data.pulseaudio;
struct SoundIoOutStreamPulseAudio *ospa = &os->backend_data.pulseaudio;
pa_threaded_mainloop_lock(sipa->main_loop);
ospa->write_byte_count = pa_stream_writable_size(ospa->stream);
int frame_count = ospa->write_byte_count / outstream->bytes_per_frame;
outstream->write_callback(outstream, 0, frame_count);
pa_operation *op = pa_stream_cork(ospa->stream, false, NULL, NULL);
if (!op) {
pa_threaded_mainloop_unlock(sipa->main_loop);
return SoundIoErrorStreaming;
}
pa_operation_unref(op);
pa_stream_set_write_callback(ospa->stream, playback_stream_write_callback, os);
pa_stream_set_underflow_callback(ospa->stream, playback_stream_underflow_callback, outstream);
pa_stream_set_overflow_callback(ospa->stream, playback_stream_underflow_callback, outstream);
pa_threaded_mainloop_unlock(sipa->main_loop);
return 0;
}
void QPulseAudioInput::close()
{
if (!m_opened)
return;
m_timer->stop();
QPulseAudioEngine *pulseEngine = QPulseAudioEngine::instance();
if (m_stream) {
pulseEngine->lock();
pa_stream_set_state_callback(m_stream, 0, 0);
pa_stream_set_read_callback(m_stream, 0, 0);
pa_stream_set_underflow_callback(m_stream, 0, 0);
pa_stream_set_overflow_callback(m_stream, 0, 0);
pa_stream_disconnect(m_stream);
pa_stream_unref(m_stream);
m_stream = 0;
pulseEngine->unlock();
}
disconnect(pulseEngine, &QPulseAudioEngine::contextFailed, this, &QPulseAudioInput::onPulseContextFailed);
if (!m_pullMode && m_audioSource) {
delete m_audioSource;
m_audioSource = 0;
}
m_opened = false;
}
AudioStream::~AudioStream()
{
PulseMainLoopLock lock(mainloop_);
pa_stream_disconnect(audiostream_);
// make sure we don't get any further callback
pa_stream_set_state_callback(audiostream_, NULL, NULL);
pa_stream_set_write_callback(audiostream_, NULL, NULL);
pa_stream_set_read_callback(audiostream_, NULL, NULL);
pa_stream_set_moved_callback(audiostream_, NULL, NULL);
pa_stream_set_underflow_callback(audiostream_, NULL, NULL);
pa_stream_set_overflow_callback(audiostream_, NULL, NULL);
pa_stream_unref(audiostream_);
}
AudioStream::~AudioStream()
{
pa_threaded_mainloop_lock(mainloop_);
pa_stream_disconnect(audiostream_);
// make sure we don't get any further callback
pa_stream_set_state_callback(audiostream_, NULL, NULL);
pa_stream_set_write_callback(audiostream_, NULL, NULL);
pa_stream_set_underflow_callback(audiostream_, NULL, NULL);
pa_stream_set_overflow_callback(audiostream_, NULL, NULL);
pa_stream_unref(audiostream_);
pa_threaded_mainloop_unlock(mainloop_);
}
static void outstream_destroy_pa(struct SoundIoPrivate *si, struct SoundIoOutStreamPrivate *os) {
struct SoundIoOutStreamPulseAudio *ospa = &os->backend_data.pulseaudio;
struct SoundIoPulseAudio *sipa = &si->backend_data.pulseaudio;
pa_stream *stream = ospa->stream;
if (stream) {
pa_threaded_mainloop_lock(sipa->main_loop);
pa_stream_set_write_callback(stream, NULL, NULL);
pa_stream_set_state_callback(stream, NULL, NULL);
pa_stream_set_underflow_callback(stream, NULL, NULL);
pa_stream_set_overflow_callback(stream, NULL, NULL);
pa_stream_disconnect(stream);
pa_stream_unref(stream);
pa_threaded_mainloop_unlock(sipa->main_loop);
ospa->stream = NULL;
}
}
// 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;
}
}
/* 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 conn_state(pa_context *context, void *arg)
{
int err;
struct pulse_conn_t *conn = arg;
pa_context_state_t state = pa_context_get_state(context);
switch(state) {
case PA_CONTEXT_UNCONNECTED:
case PA_CONTEXT_CONNECTING: break;
case PA_CONTEXT_AUTHORIZING: break;
case PA_CONTEXT_SETTING_NAME: break;
case PA_CONTEXT_FAILED:
case PA_CONTEXT_TERMINATED:
break;
case PA_CONTEXT_READY:
{
pa_sample_spec spec;
pa_buffer_attr attr;
spec.rate = conn->conf.rate;
spec.format = PA_SAMPLE_FLOAT32NE;
if(conn->conf.in > 0) {
spec.channels = conn->conf.in;
conn->record = pa_stream_new(conn->context, "Record", &spec, NULL);
pa_stream_set_read_callback(conn->record, conn_record, conn);
pa_stream_set_overflow_callback(conn->record, conn_overflow, conn);
}
else
conn->record = NULL;
if(conn->conf.out > 0) {
spec.channels = conn->conf.out;
conn->playback = pa_stream_new(conn->context, "Playback", &spec, NULL);
pa_stream_set_write_callback(conn->playback, conn_playback, conn);
pa_stream_set_underflow_callback(conn->playback, conn_underflow, conn);
}
else
conn->playback = NULL;
attr.fragsize = sizeof(float) * conn->lat;
attr.maxlength = (uint32_t)-1;
attr.maxlength = sizeof(float) * conn->lat;
attr.minreq = 0;
attr.prebuf = 0;
attr.tlength = sizeof(float) * conn->lat;
if(conn->record != NULL) {
err = pa_stream_connect_record(conn->record, NULL, &attr, PA_STREAM_INTERPOLATE_TIMING | PA_STREAM_ADJUST_LATENCY | PA_STREAM_AUTO_TIMING_UPDATE);
if(err < 0)
fprintf(stderr, "Failed to connect to recorder."), exit(1);
}
if(conn->playback != NULL) {
err = pa_stream_connect_playback(conn->playback, NULL, &attr, PA_STREAM_INTERPOLATE_TIMING | PA_STREAM_ADJUST_LATENCY | PA_STREAM_AUTO_TIMING_UPDATE, NULL, NULL);
if(err < 0)
fprintf(stderr, "Failed to connect to playback."), exit(1);
}
}
break;
}
}
bool AudioOutputPulseAudio::ConnectPlaybackStream(void)
{
QString fn_log_tag = "ConnectPlaybackStream, ";
pstream = pa_stream_new(pcontext, "MythTV playback", &sample_spec,
&channel_map);
if (!pstream)
{
VBERROR(fn_log_tag + QString("failed to create new playback stream"));
return false;
}
pa_stream_set_state_callback(pstream, StreamStateCallback, this);
pa_stream_set_write_callback(pstream, WriteCallback, this);
pa_stream_set_overflow_callback(pstream, BufferFlowCallback, (char*)"over");
pa_stream_set_underflow_callback(pstream, BufferFlowCallback,
(char*)"under");
if (set_initial_vol)
{
int volume = gCoreContext->GetNumSetting("MasterMixerVolume", 80);
pa_cvolume_set(&volume_control, channels,
(float)volume * (float)PA_VOLUME_NORM / 100.0f);
}
else
pa_cvolume_reset(&volume_control, channels);
fragment_size = (samplerate * 25 * output_bytes_per_frame) / 1000;
buffer_settings.maxlength = (uint32_t)-1;
buffer_settings.tlength = fragment_size * 4;
buffer_settings.prebuf = (uint32_t)-1;
buffer_settings.minreq = (uint32_t)-1;
int flags = PA_STREAM_INTERPOLATE_TIMING
| PA_STREAM_ADJUST_LATENCY
| PA_STREAM_AUTO_TIMING_UPDATE
| PA_STREAM_NO_REMIX_CHANNELS;
pa_stream_connect_playback(pstream, NULL, &buffer_settings,
(pa_stream_flags_t)flags, &volume_control, NULL);
pa_context_state_t cstate;
pa_stream_state_t sstate;
bool connected = false, failed = false;
while (!(connected || failed))
{
switch (cstate = pa_context_get_state(pcontext))
{
case PA_CONTEXT_FAILED:
case PA_CONTEXT_TERMINATED:
VERBOSE(VB_IMPORTANT, LOC_ERR + fn_log_tag +
QString("context is stuffed, %1")
.arg(pa_strerror(pa_context_errno(
pcontext))));
failed = true;
break;
default:
switch (sstate = pa_stream_get_state(pstream))
{
case PA_STREAM_READY:
connected = true;
break;
case PA_STREAM_FAILED:
case PA_STREAM_TERMINATED:
VBERROR(fn_log_tag +
QString("stream failed or was terminated, "
"context state %1, stream state %2")
.arg(cstate).arg(sstate));
failed = true;
break;
default:
pa_threaded_mainloop_wait(mainloop);
break;
}
}
}
const pa_buffer_attr *buf_attr = pa_stream_get_buffer_attr(pstream);
fragment_size = buf_attr->tlength >> 2;
soundcard_buffer_size = buf_attr->maxlength;
VBAUDIO(fn_log_tag + QString("fragment size %1, soundcard buffer size %2")
.arg(fragment_size).arg(soundcard_buffer_size));
return (connected && !failed);
}
static gboolean
gst_pulsesrc_create_stream (GstPulseSrc * pulsesrc, GstCaps * caps)
{
pa_channel_map channel_map;
GstStructure *s;
gboolean need_channel_layout = FALSE;
GstRingBufferSpec spec;
const gchar *name;
memset (&spec, 0, sizeof (GstRingBufferSpec));
spec.latency_time = GST_SECOND;
if (!gst_ring_buffer_parse_caps (&spec, caps)) {
GST_ELEMENT_ERROR (pulsesrc, RESOURCE, SETTINGS,
("Can't parse caps."), (NULL));
goto fail;
}
/* Keep the refcount of the caps at 1 to make them writable */
gst_caps_unref (spec.caps);
if (!gst_pulse_fill_sample_spec (&spec, &pulsesrc->sample_spec)) {
GST_ELEMENT_ERROR (pulsesrc, RESOURCE, SETTINGS,
("Invalid sample specification."), (NULL));
goto fail;
}
pa_threaded_mainloop_lock (pulsesrc->mainloop);
if (!pulsesrc->context) {
GST_ELEMENT_ERROR (pulsesrc, RESOURCE, FAILED, ("Bad context"), (NULL));
goto unlock_and_fail;
}
s = gst_caps_get_structure (caps, 0);
if (!gst_structure_has_field (s, "channel-layout") ||
!gst_pulse_gst_to_channel_map (&channel_map, &spec)) {
if (spec.channels == 1)
pa_channel_map_init_mono (&channel_map);
else if (spec.channels == 2)
pa_channel_map_init_stereo (&channel_map);
else
need_channel_layout = TRUE;
}
name = "Record Stream";
if (pulsesrc->proplist) {
if (!(pulsesrc->stream = pa_stream_new_with_proplist (pulsesrc->context,
name, &pulsesrc->sample_spec,
(need_channel_layout) ? NULL : &channel_map,
pulsesrc->proplist))) {
GST_ELEMENT_ERROR (pulsesrc, RESOURCE, FAILED,
("Failed to create stream: %s",
pa_strerror (pa_context_errno (pulsesrc->context))), (NULL));
goto unlock_and_fail;
}
} else if (!(pulsesrc->stream = pa_stream_new (pulsesrc->context,
name, &pulsesrc->sample_spec,
(need_channel_layout) ? NULL : &channel_map))) {
GST_ELEMENT_ERROR (pulsesrc, RESOURCE, FAILED,
("Failed to create stream: %s",
pa_strerror (pa_context_errno (pulsesrc->context))), (NULL));
goto unlock_and_fail;
}
if (need_channel_layout) {
const pa_channel_map *m = pa_stream_get_channel_map (pulsesrc->stream);
gst_pulse_channel_map_to_gst (m, &spec);
caps = spec.caps;
}
GST_DEBUG_OBJECT (pulsesrc, "Caps are %" GST_PTR_FORMAT, caps);
pa_stream_set_state_callback (pulsesrc->stream, gst_pulsesrc_stream_state_cb,
pulsesrc);
pa_stream_set_read_callback (pulsesrc->stream, gst_pulsesrc_stream_request_cb,
pulsesrc);
pa_stream_set_underflow_callback (pulsesrc->stream,
gst_pulsesrc_stream_underflow_cb, pulsesrc);
pa_stream_set_overflow_callback (pulsesrc->stream,
gst_pulsesrc_stream_overflow_cb, pulsesrc);
pa_stream_set_latency_update_callback (pulsesrc->stream,
gst_pulsesrc_stream_latency_update_cb, pulsesrc);
pa_threaded_mainloop_unlock (pulsesrc->mainloop);
return TRUE;
unlock_and_fail:
gst_pulsesrc_destroy_stream (pulsesrc);
pa_threaded_mainloop_unlock (pulsesrc->mainloop);
fail:
return FALSE;
}
bool QPulseAudioInput::open()
{
if (m_opened)
return true;
QPulseAudioEngine *pulseEngine = QPulseAudioEngine::instance();
if (!pulseEngine->context() || pa_context_get_state(pulseEngine->context()) != PA_CONTEXT_READY) {
setError(QAudio::FatalError);
setState(QAudio::StoppedState);
return false;
}
pa_sample_spec spec = QPulseAudioInternal::audioFormatToSampleSpec(m_format);
if (!pa_sample_spec_valid(&spec)) {
setError(QAudio::OpenError);
setState(QAudio::StoppedState);
return false;
}
m_spec = spec;
#ifdef DEBUG_PULSE
// QTime now(QTime::currentTime());
// qDebug()<<now.second()<<"s "<<now.msec()<<"ms :open()";
#endif
if (m_streamName.isNull())
m_streamName = QString(QLatin1String("QtmPulseStream-%1-%2")).arg(::getpid()).arg(quintptr(this)).toUtf8();
#ifdef DEBUG_PULSE
qDebug() << "Format: " << QPulseAudioInternal::sampleFormatToQString(spec.format);
qDebug() << "Rate: " << spec.rate;
qDebug() << "Channels: " << spec.channels;
qDebug() << "Frame size: " << pa_frame_size(&spec);
#endif
pulseEngine->lock();
pa_channel_map channel_map;
pa_channel_map_init_extend(&channel_map, spec.channels, PA_CHANNEL_MAP_DEFAULT);
if (!pa_channel_map_compatible(&channel_map, &spec))
qWarning() << "Channel map doesn't match sample specification!";
m_stream = pa_stream_new(pulseEngine->context(), m_streamName.constData(), &spec, &channel_map);
pa_stream_set_state_callback(m_stream, inputStreamStateCallback, this);
pa_stream_set_read_callback(m_stream, inputStreamReadCallback, this);
pa_stream_set_underflow_callback(m_stream, inputStreamUnderflowCallback, this);
pa_stream_set_overflow_callback(m_stream, inputStreamOverflowCallback, this);
m_periodSize = pa_usec_to_bytes(PeriodTimeMs*1000, &spec);
int flags = 0;
pa_buffer_attr buffer_attr;
buffer_attr.maxlength = (uint32_t) -1;
buffer_attr.prebuf = (uint32_t) -1;
buffer_attr.tlength = (uint32_t) -1;
buffer_attr.minreq = (uint32_t) -1;
flags |= PA_STREAM_ADJUST_LATENCY;
if (m_bufferSize > 0)
buffer_attr.fragsize = (uint32_t) m_bufferSize;
else
buffer_attr.fragsize = (uint32_t) m_periodSize;
if (pa_stream_connect_record(m_stream, m_device.data(), &buffer_attr, (pa_stream_flags_t)flags) < 0) {
qWarning() << "pa_stream_connect_record() failed!";
pa_stream_unref(m_stream);
m_stream = 0;
pulseEngine->unlock();
setError(QAudio::OpenError);
setState(QAudio::StoppedState);
return false;
}
while (pa_stream_get_state(m_stream) != PA_STREAM_READY)
pa_threaded_mainloop_wait(pulseEngine->mainloop());
const pa_buffer_attr *actualBufferAttr = pa_stream_get_buffer_attr(m_stream);
m_periodSize = actualBufferAttr->fragsize;
m_periodTime = pa_bytes_to_usec(m_periodSize, &spec) / 1000;
if (actualBufferAttr->tlength != (uint32_t)-1)
m_bufferSize = actualBufferAttr->tlength;
pulseEngine->unlock();
connect(pulseEngine, &QPulseAudioEngine::contextFailed, this, &QPulseAudioInput::onPulseContextFailed);
m_opened = true;
m_timer->start(m_periodTime);
m_clockStamp.restart();
m_timeStamp.restart();
m_elapsedTimeOffset = 0;
m_totalTimeValue = 0;
return true;
}
static gboolean
gst_pulsesrc_create_stream (GstPulseSrc * pulsesrc, GstCaps ** caps)
{
pa_channel_map channel_map;
const pa_channel_map *m;
GstStructure *s;
gboolean need_channel_layout = FALSE;
GstAudioRingBufferSpec spec;
const gchar *name;
s = gst_caps_get_structure (*caps, 0);
gst_structure_get_int (s, "channels", &spec.info.channels);
if (!gst_structure_has_field (s, "channel-mask")) {
if (spec.info.channels == 1) {
pa_channel_map_init_mono (&channel_map);
} else if (spec.info.channels == 2) {
gst_structure_set (s, "channel-mask", GST_TYPE_BITMASK,
GST_AUDIO_CHANNEL_POSITION_MASK (FRONT_LEFT) |
GST_AUDIO_CHANNEL_POSITION_MASK (FRONT_RIGHT), NULL);
pa_channel_map_init_stereo (&channel_map);
} else {
need_channel_layout = TRUE;
gst_structure_set (s, "channel-mask", GST_TYPE_BITMASK,
G_GUINT64_CONSTANT (0), NULL);
}
}
memset (&spec, 0, sizeof (GstAudioRingBufferSpec));
spec.latency_time = GST_SECOND;
if (!gst_audio_ring_buffer_parse_caps (&spec, *caps))
goto invalid_caps;
/* Keep the refcount of the caps at 1 to make them writable */
gst_caps_unref (spec.caps);
if (!need_channel_layout
&& !gst_pulse_gst_to_channel_map (&channel_map, &spec)) {
need_channel_layout = TRUE;
gst_structure_set (s, "channel-mask", GST_TYPE_BITMASK,
G_GUINT64_CONSTANT (0), NULL);
memset (spec.info.position, 0xff, sizeof (spec.info.position));
}
if (!gst_pulse_fill_sample_spec (&spec, &pulsesrc->sample_spec))
goto invalid_spec;
pa_threaded_mainloop_lock (pulsesrc->mainloop);
if (!pulsesrc->context)
goto bad_context;
name = "Record Stream";
if (pulsesrc->proplist) {
if (!(pulsesrc->stream = pa_stream_new_with_proplist (pulsesrc->context,
name, &pulsesrc->sample_spec,
(need_channel_layout) ? NULL : &channel_map,
pulsesrc->proplist)))
goto create_failed;
} else if (!(pulsesrc->stream = pa_stream_new (pulsesrc->context,
name, &pulsesrc->sample_spec,
(need_channel_layout) ? NULL : &channel_map)))
goto create_failed;
m = pa_stream_get_channel_map (pulsesrc->stream);
gst_pulse_channel_map_to_gst (m, &spec);
gst_audio_channel_positions_to_valid_order (spec.info.position,
spec.info.channels);
gst_caps_unref (*caps);
*caps = gst_audio_info_to_caps (&spec.info);
GST_DEBUG_OBJECT (pulsesrc, "Caps are %" GST_PTR_FORMAT, *caps);
pa_stream_set_state_callback (pulsesrc->stream, gst_pulsesrc_stream_state_cb,
pulsesrc);
pa_stream_set_read_callback (pulsesrc->stream, gst_pulsesrc_stream_request_cb,
pulsesrc);
pa_stream_set_underflow_callback (pulsesrc->stream,
gst_pulsesrc_stream_underflow_cb, pulsesrc);
pa_stream_set_overflow_callback (pulsesrc->stream,
gst_pulsesrc_stream_overflow_cb, pulsesrc);
pa_stream_set_latency_update_callback (pulsesrc->stream,
gst_pulsesrc_stream_latency_update_cb, pulsesrc);
pa_threaded_mainloop_unlock (pulsesrc->mainloop);
return TRUE;
/* ERRORS */
invalid_caps:
{
GST_ELEMENT_ERROR (pulsesrc, RESOURCE, SETTINGS,
("Can't parse caps."), (NULL));
goto fail;
}
invalid_spec:
{
GST_ELEMENT_ERROR (pulsesrc, RESOURCE, SETTINGS,
("Invalid sample specification."), (NULL));
goto fail;
}
bad_context:
{
GST_ELEMENT_ERROR (pulsesrc, RESOURCE, FAILED, ("Bad context"), (NULL));
goto unlock_and_fail;
}
create_failed:
{
GST_ELEMENT_ERROR (pulsesrc, RESOURCE, FAILED,
("Failed to create stream: %s",
pa_strerror (pa_context_errno (pulsesrc->context))), (NULL));
goto unlock_and_fail;
}
unlock_and_fail:
{
gst_pulsesrc_destroy_stream (pulsesrc);
pa_threaded_mainloop_unlock (pulsesrc->mainloop);
fail:
return FALSE;
}
}
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);
}
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;
}
}
}
}
