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;
}
}
/* This routine is called whenever the stream state changes */
void QPulseAudioThread::stream_state_callback ( pa_stream *s, void *userdata )
{
assert ( s );
QPulseAudioThread * thread = (QPulseAudioThread *)userdata;
switch ( pa_stream_get_state ( s ) ) {
case PA_STREAM_UNCONNECTED:
qDebug() << "UNCONNECTED";
break;
case PA_STREAM_CREATING:
qDebug() << "CREATED";
break;
case PA_STREAM_TERMINATED:
qDebug() << "TERMINATED";
break;
case PA_STREAM_READY:
qDebug() << "READY";
if ( verbose ) {
const pa_buffer_attr *a;
fprintf ( stderr, "Stream successfully created.\n" );
if ( ! ( a = pa_stream_get_buffer_attr ( s ) ) )
fprintf ( stderr, "pa_stream_get_buffer_attr() failed: %s\n", pa_strerror ( pa_context_errno ( pa_stream_get_context ( s ) ) ) );
else {
fprintf(stderr, "Buffer metrics: maxlength=%u, fragsize=%u\n", a->maxlength, a->fragsize);
}
}
break;
case PA_STREAM_FAILED:
qDebug() << "FAILED";
default:
fprintf ( stderr, "Stream error: %s\n", pa_strerror ( pa_context_errno ( pa_stream_get_context ( s ) ) ) );
pulseQuit ( 1 );
}
}
int AudioOutputPulseAudio::GetBufferedOnSoundcard(void) const
{
pa_usec_t latency = 0;
size_t buffered = 0;
if (!pcontext || pa_context_get_state(pcontext) != PA_CONTEXT_READY)
return 0;
if (!pstream || pa_stream_get_state(pstream) != PA_STREAM_READY)
return 0;
const pa_buffer_attr *buf_attr = pa_stream_get_buffer_attr(pstream);
size_t bfree = pa_stream_writable_size(pstream);
buffered = buf_attr->tlength - bfree;
pa_threaded_mainloop_lock(mainloop);
while (pa_stream_get_latency(pstream, &latency, NULL) < 0)
{
if (pa_context_errno(pcontext) != PA_ERR_NODATA)
{
latency = 0;
break;
}
pa_threaded_mainloop_wait(mainloop);
}
pa_threaded_mainloop_unlock(mainloop);
return ((uint64_t)latency * samplerate *
output_bytes_per_frame / 1000000) + buffered;
}
static void inputStreamStateCallback(pa_stream *stream, void *userdata)
{
Q_UNUSED(userdata);
pa_stream_state_t state = pa_stream_get_state(stream);
#ifdef DEBUG_PULSE
qDebug() << "Stream state: " << QPulseAudioInternal::stateToQString(state);
#endif
switch (state) {
case PA_STREAM_CREATING:
break;
case PA_STREAM_READY: {
#ifdef DEBUG_PULSE
QPulseAudioInput *audioInput = static_cast<QPulseAudioInput*>(userdata);
const pa_buffer_attr *buffer_attr = pa_stream_get_buffer_attr(stream);
qDebug() << "*** maxlength: " << buffer_attr->maxlength;
qDebug() << "*** prebuf: " << buffer_attr->prebuf;
qDebug() << "*** fragsize: " << buffer_attr->fragsize;
qDebug() << "*** minreq: " << buffer_attr->minreq;
qDebug() << "*** tlength: " << buffer_attr->tlength;
pa_sample_spec spec = QPulseAudioInternal::audioFormatToSampleSpec(audioInput->format());
qDebug() << "*** bytes_to_usec: " << pa_bytes_to_usec(buffer_attr->fragsize, &spec);
#endif
}
break;
case PA_STREAM_TERMINATED:
break;
case PA_STREAM_FAILED:
default:
qWarning() << QString("Stream error: %1").arg(pa_strerror(pa_context_errno(pa_stream_get_context(stream))));
QPulseAudioEngine *pulseEngine = QPulseAudioEngine::instance();
pa_threaded_mainloop_signal(pulseEngine->mainloop(), 0);
break;
}
}
static void stream_buffer_attr_callback(pa_stream *stream, void *pdata) //{{{
{
const pa_buffer_attr *attr;
(void)pdata;
attr = pa_stream_get_buffer_attr(stream);
WARN("PulseAudio modified buffer length: minreq=%d, tlength=%d\n", attr->minreq, attr->tlength);
}//}}}
static void stream_buffer_attr_cb(pa_stream *s, void *userdata)
{
demux_t *demux = userdata;
const struct pa_buffer_attr *pba = pa_stream_get_buffer_attr(s);
msg_Dbg(demux, "using buffer metrics: maxlength=%"PRIu32", "
"fragsize=%"PRIu32, pba->maxlength, pba->fragsize);
}
static void stream_buffer_attr_callback(pa_stream *stream, void *pdata)
{
ALCdevice *device = pdata;
pulse_data *data = device->ExtraData;
data->attr = *pa_stream_get_buffer_attr(stream);
TRACE("minreq=%d, tlength=%d, prebuf=%d\n", data->attr.minreq, data->attr.tlength, data->attr.prebuf);
}
/* called when remote server changes the stream buffer_attr */
static void stream_changed_buffer_attr_cb(pa_stream *stream, void *userdata) {
struct userdata *u = userdata;
const pa_buffer_attr *bufferattr;
pa_assert(u);
bufferattr = pa_stream_get_buffer_attr(u->stream);
pa_sink_set_max_request_within_thread(u->sink, bufferattr->tlength);
}
static void buffer_attr_cb(pa_stream *s, void *data)
{
pa_t *pa = (pa_t*)data;
const pa_buffer_attr *server_attr = pa_stream_get_buffer_attr(s);
if (server_attr)
pa->buffer_size = server_attr->tlength;
RARCH_LOG("[PulseAudio]: Got new buffer size %u.\n", (unsigned)pa->buffer_size);
}
static void stream_buffer_attr_cb(pa_stream *s, void *userdata)
{
audio_output_t *aout = userdata;
const pa_buffer_attr *pba = pa_stream_get_buffer_attr(s);
msg_Dbg(aout, "changed buffer metrics: maxlength=%u, tlength=%u, "
"prebuf=%u, minreq=%u",
pba->maxlength, pba->tlength, pba->prebuf, pba->minreq);
}
/**
* 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);
}
}
/* 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);
}
}
static void stream_buffer_attr_callback(pa_stream *stream, void *pdata) //{{{
{
ALCdevice *Device = pdata;
pulse_data *data = Device->ExtraData;
LockDevice(Device);
data->attr = *(pa_stream_get_buffer_attr(stream));
Device->UpdateSize = data->attr.minreq / data->frame_size;
Device->NumUpdates = (data->attr.tlength/data->frame_size) / Device->UpdateSize;
if(Device->NumUpdates <= 1)
{
Device->NumUpdates = 1;
ERR("PulseAudio returned minreq > tlength/2; expect lag or break up\n");
}
UnlockDevice(Device);
}//}}}
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);
}
}
static void sink_update_requested_latency_cb(pa_sink *s) {
struct userdata *u;
pa_operation *operation;
size_t nbytes;
pa_usec_t block_usec;
pa_buffer_attr bufferattr;
pa_sink_assert_ref(s);
pa_assert_se(u = s->userdata);
block_usec = pa_sink_get_requested_latency_within_thread(s);
if (block_usec == (pa_usec_t) -1)
block_usec = s->thread_info.max_latency;
nbytes = pa_usec_to_bytes(block_usec, &s->sample_spec);
pa_sink_set_max_request_within_thread(s, nbytes);
if (u->stream) {
switch (pa_stream_get_state(u->stream)) {
case PA_STREAM_READY:
if (pa_stream_get_buffer_attr(u->stream)->tlength == nbytes)
break;
reset_bufferattr(&bufferattr);
bufferattr.tlength = nbytes;
if ((operation = pa_stream_set_buffer_attr(u->stream, &bufferattr, stream_set_buffer_attr_cb, u)))
pa_operation_unref(operation);
break;
case PA_STREAM_CREATING:
/* we have to delay our request until stream is ready */
u->update_stream_bufferattr_after_connect = true;
break;
default:
break;
}
}
}
static gboolean
gst_pulsesrc_prepare (GstAudioSrc * asrc, GstRingBufferSpec * spec)
{
pa_buffer_attr wanted;
const pa_buffer_attr *actual;
GstPulseSrc *pulsesrc = GST_PULSESRC_CAST (asrc);
pa_threaded_mainloop_lock (pulsesrc->mainloop);
wanted.maxlength = -1;
wanted.tlength = -1;
wanted.prebuf = 0;
wanted.minreq = -1;
wanted.fragsize = spec->segsize;
GST_INFO_OBJECT (pulsesrc, "maxlength: %d", wanted.maxlength);
GST_INFO_OBJECT (pulsesrc, "tlength: %d", wanted.tlength);
GST_INFO_OBJECT (pulsesrc, "prebuf: %d", wanted.prebuf);
GST_INFO_OBJECT (pulsesrc, "minreq: %d", wanted.minreq);
GST_INFO_OBJECT (pulsesrc, "fragsize: %d", wanted.fragsize);
if (pa_stream_connect_record (pulsesrc->stream, pulsesrc->device, &wanted,
PA_STREAM_INTERPOLATE_TIMING |
PA_STREAM_AUTO_TIMING_UPDATE | PA_STREAM_NOT_MONOTONOUS |
#ifdef HAVE_PULSE_0_9_11
PA_STREAM_ADJUST_LATENCY |
#endif
PA_STREAM_START_CORKED) < 0) {
GST_ELEMENT_ERROR (pulsesrc, RESOURCE, FAILED,
("Failed to connect stream: %s",
pa_strerror (pa_context_errno (pulsesrc->context))), (NULL));
goto unlock_and_fail;
}
pulsesrc->corked = TRUE;
for (;;) {
pa_stream_state_t state;
state = pa_stream_get_state (pulsesrc->stream);
if (!PA_STREAM_IS_GOOD (state)) {
GST_ELEMENT_ERROR (pulsesrc, RESOURCE, FAILED,
("Failed to connect stream: %s",
pa_strerror (pa_context_errno (pulsesrc->context))), (NULL));
goto unlock_and_fail;
}
if (state == PA_STREAM_READY)
break;
/* Wait until the stream is ready */
pa_threaded_mainloop_wait (pulsesrc->mainloop);
}
/* get the actual buffering properties now */
actual = pa_stream_get_buffer_attr (pulsesrc->stream);
GST_INFO_OBJECT (pulsesrc, "maxlength: %d", actual->maxlength);
GST_INFO_OBJECT (pulsesrc, "tlength: %d (wanted: %d)",
actual->tlength, wanted.tlength);
GST_INFO_OBJECT (pulsesrc, "prebuf: %d", actual->prebuf);
GST_INFO_OBJECT (pulsesrc, "minreq: %d (wanted %d)", actual->minreq,
wanted.minreq);
GST_INFO_OBJECT (pulsesrc, "fragsize: %d (wanted %d)",
actual->fragsize, wanted.fragsize);
if (actual->fragsize >= wanted.fragsize) {
spec->segsize = actual->fragsize;
} else {
spec->segsize = actual->fragsize * (wanted.fragsize / actual->fragsize);
}
spec->segtotal = actual->maxlength / spec->segsize;
pa_threaded_mainloop_unlock (pulsesrc->mainloop);
return TRUE;
unlock_and_fail:
{
gst_pulsesrc_destroy_stream (pulsesrc);
pa_threaded_mainloop_unlock (pulsesrc->mainloop);
return FALSE;
}
}
static gboolean
gst_pulsesrc_prepare (GstAudioSrc * asrc, GstAudioRingBufferSpec * spec)
{
pa_buffer_attr wanted;
const pa_buffer_attr *actual;
GstPulseSrc *pulsesrc = GST_PULSESRC_CAST (asrc);
pa_stream_flags_t flags;
pa_operation *o;
GstAudioClock *clock;
pa_threaded_mainloop_lock (pulsesrc->mainloop);
{
GstAudioRingBufferSpec s = *spec;
const pa_channel_map *m;
m = pa_stream_get_channel_map (pulsesrc->stream);
gst_pulse_channel_map_to_gst (m, &s);
gst_audio_ring_buffer_set_channel_positions (GST_AUDIO_BASE_SRC
(pulsesrc)->ringbuffer, s.info.position);
}
/* enable event notifications */
GST_LOG_OBJECT (pulsesrc, "subscribing to context events");
if (!(o = pa_context_subscribe (pulsesrc->context,
PA_SUBSCRIPTION_MASK_SOURCE_OUTPUT, NULL, NULL))) {
GST_ELEMENT_ERROR (pulsesrc, RESOURCE, FAILED,
("pa_context_subscribe() failed: %s",
pa_strerror (pa_context_errno (pulsesrc->context))), (NULL));
goto unlock_and_fail;
}
pa_operation_unref (o);
wanted.maxlength = -1;
wanted.tlength = -1;
wanted.prebuf = 0;
wanted.minreq = -1;
wanted.fragsize = spec->segsize;
GST_INFO_OBJECT (pulsesrc, "maxlength: %d", wanted.maxlength);
GST_INFO_OBJECT (pulsesrc, "tlength: %d", wanted.tlength);
GST_INFO_OBJECT (pulsesrc, "prebuf: %d", wanted.prebuf);
GST_INFO_OBJECT (pulsesrc, "minreq: %d", wanted.minreq);
GST_INFO_OBJECT (pulsesrc, "fragsize: %d", wanted.fragsize);
flags = PA_STREAM_INTERPOLATE_TIMING | PA_STREAM_AUTO_TIMING_UPDATE |
PA_STREAM_NOT_MONOTONIC | PA_STREAM_ADJUST_LATENCY |
PA_STREAM_START_CORKED;
if (pulsesrc->mute_set && pulsesrc->mute)
flags |= PA_STREAM_START_MUTED;
if (pa_stream_connect_record (pulsesrc->stream, pulsesrc->device, &wanted,
flags) < 0) {
goto connect_failed;
}
/* our clock will now start from 0 again */
clock = GST_AUDIO_CLOCK (GST_AUDIO_BASE_SRC (pulsesrc)->clock);
gst_audio_clock_reset (clock, 0);
pulsesrc->corked = TRUE;
for (;;) {
pa_stream_state_t state;
state = pa_stream_get_state (pulsesrc->stream);
if (!PA_STREAM_IS_GOOD (state))
goto stream_is_bad;
if (state == PA_STREAM_READY)
break;
/* Wait until the stream is ready */
pa_threaded_mainloop_wait (pulsesrc->mainloop);
}
pulsesrc->stream_connected = TRUE;
/* store the source output index so it can be accessed via a property */
pulsesrc->source_output_idx = pa_stream_get_index (pulsesrc->stream);
g_object_notify (G_OBJECT (pulsesrc), "source-output-index");
if (pulsesrc->volume_set) {
gst_pulsesrc_set_stream_volume (pulsesrc, pulsesrc->volume);
pulsesrc->volume_set = FALSE;
}
/* get the actual buffering properties now */
actual = pa_stream_get_buffer_attr (pulsesrc->stream);
GST_INFO_OBJECT (pulsesrc, "maxlength: %d", actual->maxlength);
GST_INFO_OBJECT (pulsesrc, "tlength: %d (wanted: %d)",
actual->tlength, wanted.tlength);
GST_INFO_OBJECT (pulsesrc, "prebuf: %d", actual->prebuf);
GST_INFO_OBJECT (pulsesrc, "minreq: %d (wanted %d)", actual->minreq,
wanted.minreq);
GST_INFO_OBJECT (pulsesrc, "fragsize: %d (wanted %d)",
actual->fragsize, wanted.fragsize);
if (actual->fragsize >= wanted.fragsize) {
spec->segsize = actual->fragsize;
} else {
spec->segsize = actual->fragsize * (wanted.fragsize / actual->fragsize);
}
spec->segtotal = actual->maxlength / spec->segsize;
if (!pulsesrc->paused) {
GST_DEBUG_OBJECT (pulsesrc, "uncorking because we are playing");
gst_pulsesrc_set_corked (pulsesrc, FALSE, FALSE);
}
pa_threaded_mainloop_unlock (pulsesrc->mainloop);
return TRUE;
/* ERRORS */
connect_failed:
{
GST_ELEMENT_ERROR (pulsesrc, RESOURCE, FAILED,
("Failed to connect stream: %s",
pa_strerror (pa_context_errno (pulsesrc->context))), (NULL));
goto unlock_and_fail;
}
stream_is_bad:
{
GST_ELEMENT_ERROR (pulsesrc, RESOURCE, FAILED,
("Failed to connect 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);
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;
}
bool CAESinkPULSE::Initialize(AEAudioFormat &format, std::string &device)
{
{
CSingleLock lock(m_sec);
m_IsAllocated = false;
}
m_passthrough = false;
m_BytesPerSecond = 0;
m_BufferSize = 0;
m_filled_bytes = 0;
m_lastPackageStamp = 0;
m_Channels = 0;
m_Stream = NULL;
m_Context = NULL;
m_periodSize = 0;
if (!SetupContext(NULL, &m_Context, &m_MainLoop))
{
CLog::Log(LOGNOTICE, "PulseAudio might not be running. Context was not created.");
Deinitialize();
return false;
}
pa_threaded_mainloop_lock(m_MainLoop);
struct pa_channel_map map;
pa_channel_map_init(&map);
// PULSE cannot cope with e.g. planar formats so we fallback to FLOAT
// when we receive an invalid pulse format
if (AEFormatToPulseFormat(format.m_dataFormat) == PA_SAMPLE_INVALID)
{
CLog::Log(LOGDEBUG, "PULSE does not support format: %s - will fallback to AE_FMT_FLOAT", CAEUtil::DataFormatToStr(format.m_dataFormat));
format.m_dataFormat = AE_FMT_FLOAT;
}
m_passthrough = AE_IS_RAW(format.m_dataFormat);
if(m_passthrough)
{
map.channels = 2;
format.m_channelLayout = AE_CH_LAYOUT_2_0;
}
else
{
map = AEChannelMapToPAChannel(format.m_channelLayout);
// if count has changed we need to fit the AE Map
if(map.channels != format.m_channelLayout.Count())
format.m_channelLayout = PAChannelToAEChannelMap(map);
}
m_Channels = format.m_channelLayout.Count();
// store information about current sink
SinkInfoStruct sinkStruct;
sinkStruct.mainloop = m_MainLoop;
sinkStruct.device_found = false;
// get real sample rate of the device we want to open - to avoid resampling
bool isDefaultDevice = (device == "Default");
WaitForOperation(pa_context_get_sink_info_by_name(m_Context, isDefaultDevice ? NULL : device.c_str(), SinkInfoCallback, &sinkStruct), m_MainLoop, "Get Sink Info");
// only check if the device is existing - don't alter the sample rate
if (!sinkStruct.device_found)
{
CLog::Log(LOGERROR, "PulseAudio: Sink %s not found", device.c_str());
pa_threaded_mainloop_unlock(m_MainLoop);
Deinitialize();
return false;
}
// Pulse can resample everything between 1 hz and 192000 hz
// Make sure we are in the range that we originally added
format.m_sampleRate = std::max(5512U, std::min(format.m_sampleRate, 192000U));
pa_format_info *info[1];
info[0] = pa_format_info_new();
info[0]->encoding = AEFormatToPulseEncoding(format.m_dataFormat);
if(!m_passthrough)
{
pa_format_info_set_sample_format(info[0], AEFormatToPulseFormat(format.m_dataFormat));
pa_format_info_set_channel_map(info[0], &map);
}
pa_format_info_set_channels(info[0], m_Channels);
// PA requires m_encodedRate in order to do EAC3
unsigned int samplerate = format.m_sampleRate;
if (m_passthrough && (AEFormatToPulseEncoding(format.m_dataFormat) == PA_ENCODING_EAC3_IEC61937))
{
// this is only used internally for PA to use EAC3
samplerate = format.m_encodedRate;
}
pa_format_info_set_rate(info[0], samplerate);
if (!pa_format_info_valid(info[0]))
{
CLog::Log(LOGERROR, "PulseAudio: Invalid format info");
pa_format_info_free(info[0]);
pa_threaded_mainloop_unlock(m_MainLoop);
Deinitialize();
return false;
}
pa_sample_spec spec;
#if PA_CHECK_VERSION(2,0,0)
pa_format_info_to_sample_spec(info[0], &spec, NULL);
#else
spec.rate = (AEFormatToPulseEncoding(format.m_dataFormat) == PA_ENCODING_EAC3_IEC61937) ? 4 * samplerate : samplerate;
spec.format = AEFormatToPulseFormat(format.m_dataFormat);
spec.channels = m_Channels;
#endif
if (!pa_sample_spec_valid(&spec))
{
CLog::Log(LOGERROR, "PulseAudio: Invalid sample spec");
pa_format_info_free(info[0]);
pa_threaded_mainloop_unlock(m_MainLoop);
Deinitialize();
return false;
}
m_BytesPerSecond = pa_bytes_per_second(&spec);
unsigned int frameSize = pa_frame_size(&spec);
m_Stream = pa_stream_new_extended(m_Context, "kodi audio stream", info, 1, NULL);
pa_format_info_free(info[0]);
if (m_Stream == NULL)
{
CLog::Log(LOGERROR, "PulseAudio: Could not create a stream");
pa_threaded_mainloop_unlock(m_MainLoop);
Deinitialize();
return false;
}
pa_stream_set_state_callback(m_Stream, StreamStateCallback, m_MainLoop);
pa_stream_set_write_callback(m_Stream, StreamRequestCallback, m_MainLoop);
pa_stream_set_latency_update_callback(m_Stream, StreamLatencyUpdateCallback, m_MainLoop);
// default buffer construction
// align with AE's max buffer
unsigned int latency = m_BytesPerSecond / 2.5; // 400 ms
unsigned int process_time = latency / 4; // 100 ms
if(sinkStruct.isHWDevice)
{
// on hw devices buffers can be further reduced
// 200ms max latency
// 50ms min packet size
latency = m_BytesPerSecond / 5;
process_time = latency / 4;
}
pa_buffer_attr buffer_attr;
buffer_attr.fragsize = latency;
buffer_attr.maxlength = (uint32_t) -1;
buffer_attr.minreq = process_time;
buffer_attr.prebuf = (uint32_t) -1;
buffer_attr.tlength = latency;
if (pa_stream_connect_playback(m_Stream, isDefaultDevice ? NULL : device.c_str(), &buffer_attr, ((pa_stream_flags)(PA_STREAM_INTERPOLATE_TIMING | PA_STREAM_AUTO_TIMING_UPDATE | PA_STREAM_ADJUST_LATENCY)), NULL, NULL) < 0)
{
CLog::Log(LOGERROR, "PulseAudio: Failed to connect stream to output");
pa_threaded_mainloop_unlock(m_MainLoop);
Deinitialize();
return false;
}
/* Wait until the stream is ready */
do
{
pa_threaded_mainloop_wait(m_MainLoop);
CLog::Log(LOGDEBUG, "PulseAudio: Stream %s", StreamStateToString(pa_stream_get_state(m_Stream)));
}
while (pa_stream_get_state(m_Stream) != PA_STREAM_READY && pa_stream_get_state(m_Stream) != PA_STREAM_FAILED);
if (pa_stream_get_state(m_Stream) == PA_STREAM_FAILED)
{
CLog::Log(LOGERROR, "PulseAudio: Waited for the stream but it failed");
pa_threaded_mainloop_unlock(m_MainLoop);
Deinitialize();
return false;
}
const pa_buffer_attr *a;
if (!(a = pa_stream_get_buffer_attr(m_Stream)))
{
CLog::Log(LOGERROR, "PulseAudio: %s", pa_strerror(pa_context_errno(m_Context)));
pa_threaded_mainloop_unlock(m_MainLoop);
Deinitialize();
return false;
}
else
{
unsigned int packetSize = a->minreq;
m_BufferSize = a->tlength;
m_periodSize = a->minreq;
format.m_frames = packetSize / frameSize;
}
{
CSingleLock lock(m_sec);
// Register Callback for Sink changes
pa_context_set_subscribe_callback(m_Context, SinkChangedCallback, this);
const pa_subscription_mask_t mask = PA_SUBSCRIPTION_MASK_SINK;
pa_operation *op = pa_context_subscribe(m_Context, mask, NULL, this);
if (op != NULL)
pa_operation_unref(op);
// Register Callback for Sink Info changes - this handles volume
pa_context_set_subscribe_callback(m_Context, SinkInputInfoChangedCallback, this);
const pa_subscription_mask_t mask_input = PA_SUBSCRIPTION_MASK_SINK_INPUT;
pa_operation* op_sinfo = pa_context_subscribe(m_Context, mask_input, NULL, this);
if (op_sinfo != NULL)
pa_operation_unref(op_sinfo);
}
pa_threaded_mainloop_unlock(m_MainLoop);
format.m_frameSize = frameSize;
format.m_frameSamples = format.m_frames * format.m_channelLayout.Count();
m_format = format;
format.m_dataFormat = m_passthrough ? AE_FMT_S16NE : format.m_dataFormat;
CLog::Log(LOGNOTICE, "PulseAudio: Opened device %s in %s mode with Buffersize %u ms",
device.c_str(), m_passthrough ? "passthrough" : "pcm",
(unsigned int) ((m_BufferSize / (float) m_BytesPerSecond) * 1000));
// Cork stream will resume when adding first package
Pause(true);
{
CSingleLock lock(m_sec);
m_IsAllocated = true;
}
return true;
}
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;
} //}}}
static int drvHostPulseAudioOpen(bool fIn, const char *pszName,
pa_sample_spec *pSampleSpec, pa_buffer_attr *pBufAttr,
pa_stream **ppStream)
{
AssertPtrReturn(pszName, VERR_INVALID_POINTER);
AssertPtrReturn(pSampleSpec, VERR_INVALID_POINTER);
AssertPtrReturn(pBufAttr, VERR_INVALID_POINTER);
AssertPtrReturn(ppStream, VERR_INVALID_POINTER);
if (!pa_sample_spec_valid(pSampleSpec))
{
LogRel(("PulseAudio: Unsupported sample specification for stream \"%s\"\n",
pszName));
return VERR_NOT_SUPPORTED;
}
int rc = VINF_SUCCESS;
pa_stream *pStream = NULL;
uint32_t flags = PA_STREAM_NOFLAGS;
LogFunc(("Opening \"%s\", rate=%dHz, channels=%d, format=%s\n",
pszName, pSampleSpec->rate, pSampleSpec->channels,
pa_sample_format_to_string(pSampleSpec->format)));
pa_threaded_mainloop_lock(g_pMainLoop);
do
{
if (!(pStream = pa_stream_new(g_pContext, pszName, pSampleSpec,
NULL /* pa_channel_map */)))
{
LogRel(("PulseAudio: Could not create stream \"%s\"\n", pszName));
rc = VERR_NO_MEMORY;
break;
}
pa_stream_set_state_callback(pStream, drvHostPulseAudioCbStreamState, NULL);
#if PA_API_VERSION >= 12
/* XXX */
flags |= PA_STREAM_ADJUST_LATENCY;
#endif
#if 0
/* Not applicable as we don't use pa_stream_get_latency() and pa_stream_get_time(). */
flags |= PA_STREAM_INTERPOLATE_TIMING | PA_STREAM_AUTO_TIMING_UPDATE;
#endif
/* No input/output right away after the stream was started. */
flags |= PA_STREAM_START_CORKED;
if (fIn)
{
LogFunc(("Input stream attributes: maxlength=%d fragsize=%d\n",
pBufAttr->maxlength, pBufAttr->fragsize));
if (pa_stream_connect_record(pStream, /*dev=*/NULL, pBufAttr, (pa_stream_flags_t)flags) < 0)
{
LogRel(("PulseAudio: Could not connect input stream \"%s\": %s\n",
pszName, pa_strerror(pa_context_errno(g_pContext))));
rc = VERR_AUDIO_BACKEND_INIT_FAILED;
break;
}
}
else
{
LogFunc(("Output buffer attributes: maxlength=%d tlength=%d prebuf=%d minreq=%d\n",
pBufAttr->maxlength, pBufAttr->tlength, pBufAttr->prebuf, pBufAttr->minreq));
if (pa_stream_connect_playback(pStream, /*dev=*/NULL, pBufAttr, (pa_stream_flags_t)flags,
/*cvolume=*/NULL, /*sync_stream=*/NULL) < 0)
{
LogRel(("PulseAudio: Could not connect playback stream \"%s\": %s\n",
pszName, pa_strerror(pa_context_errno(g_pContext))));
rc = VERR_AUDIO_BACKEND_INIT_FAILED;
break;
}
}
/* Wait until the stream is ready. */
for (;;)
{
if (!g_fAbortMainLoop)
pa_threaded_mainloop_wait(g_pMainLoop);
g_fAbortMainLoop = false;
pa_stream_state_t sstate = pa_stream_get_state(pStream);
if (sstate == PA_STREAM_READY)
break;
else if ( sstate == PA_STREAM_FAILED
|| sstate == PA_STREAM_TERMINATED)
{
LogRel(("PulseAudio: Failed to initialize stream \"%s\" (state %ld)\n",
pszName, sstate));
rc = VERR_AUDIO_BACKEND_INIT_FAILED;
break;
}
}
if (RT_FAILURE(rc))
break;
const pa_buffer_attr *pBufAttrObtained = pa_stream_get_buffer_attr(pStream);
AssertPtr(pBufAttrObtained);
memcpy(pBufAttr, pBufAttrObtained, sizeof(pa_buffer_attr));
if (fIn)
LogFunc(("Obtained record buffer attributes: maxlength=%RU32, fragsize=%RU32\n",
pBufAttr->maxlength, pBufAttr->fragsize));
else
LogFunc(("Obtained playback buffer attributes: maxlength=%d, tlength=%d, prebuf=%d, minreq=%d\n",
pBufAttr->maxlength, pBufAttr->tlength, pBufAttr->prebuf, pBufAttr->minreq));
}
while (0);
if ( RT_FAILURE(rc)
&& pStream)
pa_stream_disconnect(pStream);
pa_threaded_mainloop_unlock(g_pMainLoop);
if (RT_FAILURE(rc))
{
if (pStream)
pa_stream_unref(pStream);
}
else
*ppStream = pStream;
LogFlowFuncLeaveRC(rc);
return rc;
}
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 void *pulse_init(const char *device, unsigned rate, unsigned latency)
{
pa_sample_spec spec;
pa_t *pa;
pa_buffer_attr buffer_attr = {0};
const pa_buffer_attr *server_attr = NULL;
memset(&spec, 0, sizeof(spec));
pa = (pa_t*)calloc(1, sizeof(*pa));
if (!pa)
goto error;
pa->mainloop = pa_threaded_mainloop_new();
if (!pa->mainloop)
goto error;
pa->context = pa_context_new(pa_threaded_mainloop_get_api(pa->mainloop), "RetroArch");
if (!pa->context)
goto error;
pa_context_set_state_callback(pa->context, context_state_cb, pa);
if (pa_context_connect(pa->context, device, PA_CONTEXT_NOFLAGS, NULL) < 0)
goto error;
pa_threaded_mainloop_lock(pa->mainloop);
if (pa_threaded_mainloop_start(pa->mainloop) < 0)
goto error;
pa_threaded_mainloop_wait(pa->mainloop);
if (pa_context_get_state(pa->context) != PA_CONTEXT_READY)
goto unlock_error;
spec.format = is_little_endian() ? PA_SAMPLE_FLOAT32LE : PA_SAMPLE_FLOAT32BE;
spec.channels = 2;
spec.rate = rate;
pa->stream = pa_stream_new(pa->context, "audio", &spec, NULL);
if (!pa->stream)
goto unlock_error;
pa_stream_set_state_callback(pa->stream, stream_state_cb, pa);
pa_stream_set_write_callback(pa->stream, stream_request_cb, pa);
pa_stream_set_latency_update_callback(pa->stream, stream_latency_update_cb, pa);
pa_stream_set_underflow_callback(pa->stream, underrun_update_cb, pa);
pa_stream_set_buffer_attr_callback(pa->stream, buffer_attr_cb, pa);
buffer_attr.maxlength = -1;
buffer_attr.tlength = pa_usec_to_bytes(latency * PA_USEC_PER_MSEC, &spec);
buffer_attr.prebuf = -1;
buffer_attr.minreq = -1;
buffer_attr.fragsize = -1;
if (pa_stream_connect_playback(pa->stream, NULL, &buffer_attr, PA_STREAM_ADJUST_LATENCY, NULL, NULL) < 0)
goto error;
pa_threaded_mainloop_wait(pa->mainloop);
if (pa_stream_get_state(pa->stream) != PA_STREAM_READY)
goto unlock_error;
server_attr = pa_stream_get_buffer_attr(pa->stream);
if (server_attr)
{
pa->buffer_size = server_attr->tlength;
RARCH_LOG("[PulseAudio]: Requested %u bytes buffer, got %u.\n",
(unsigned)buffer_attr.tlength,
(unsigned)pa->buffer_size);
}
else
pa->buffer_size = buffer_attr.tlength;
pa_threaded_mainloop_unlock(pa->mainloop);
return pa;
unlock_error:
pa_threaded_mainloop_unlock(pa->mainloop);
error:
pulse_free(pa);
return NULL;
}
/*****************************************************************************
* 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;
}
