void ResetBuffers()
{
std::lock_guard<std::mutex> lk(mMutex);
pa_sample_spec ss(mSSpec);
ss.rate = mOutputSamplesPerSec;
size_t bytes = pa_bytes_per_second(&mSSpec) * 5;
mQBuffer.resize(0);
mQBuffer.reserve(bytes);
bytes = pa_bytes_per_second(&ss) * 5;
mResampledBuffer.resize(0);
mResampledBuffer.reserve(bytes);
src_reset(mResampler);
}
char *pa_scache_list_to_string(pa_core *c) {
pa_strbuf *s;
pa_assert(c);
s = pa_strbuf_new();
pa_strbuf_printf(s, "%u cache entrie(s) available.\n", c->scache ? pa_idxset_size(c->scache) : 0);
if (c->scache) {
pa_scache_entry *e;
uint32_t idx = PA_IDXSET_INVALID;
for (e = pa_idxset_first(c->scache, &idx); e; e = pa_idxset_next(c->scache, &idx)) {
double l = 0;
char ss[PA_SAMPLE_SPEC_SNPRINT_MAX] = "n/a", cv[PA_CVOLUME_SNPRINT_MAX], cvdb[PA_SW_CVOLUME_SNPRINT_DB_MAX], cm[PA_CHANNEL_MAP_SNPRINT_MAX] = "n/a", *t;
const char *cmn;
cmn = pa_channel_map_to_pretty_name(&e->channel_map);
if (e->memchunk.memblock) {
pa_sample_spec_snprint(ss, sizeof(ss), &e->sample_spec);
pa_channel_map_snprint(cm, sizeof(cm), &e->channel_map);
l = (double) e->memchunk.length / (double) pa_bytes_per_second(&e->sample_spec);
}
pa_strbuf_printf(
s,
" name: <%s>\n"
"\tindex: %u\n"
"\tsample spec: %s\n"
"\tchannel map: %s%s%s\n"
"\tlength: %lu\n"
"\tduration: %0.1f s\n"
"\tvolume: %s\n"
"\t %s\n"
"\t balance %0.2f\n"
"\tlazy: %s\n"
"\tfilename: <%s>\n",
e->name,
e->index,
ss,
cm,
cmn ? "\n\t " : "",
cmn ? cmn : "",
(long unsigned)(e->memchunk.memblock ? e->memchunk.length : 0),
l,
e->volume_is_set ? pa_cvolume_snprint(cv, sizeof(cv), &e->volume) : "n/a",
e->volume_is_set ? pa_sw_cvolume_snprint_dB(cvdb, sizeof(cvdb), &e->volume) : "n/a",
(e->memchunk.memblock && e->volume_is_set) ? pa_cvolume_get_balance(&e->volume, &e->channel_map) : 0.0f,
pa_yes_no(e->lazy),
e->filename ? e->filename : "n/a");
t = pa_proplist_to_string_sep(e->proplist, "\n\t\t");
pa_strbuf_printf(s, "\tproperties:\n\t\t%s\n", t);
pa_xfree(t);
}
}
return pa_strbuf_tostring_free(s);
}
char *pa_scache_list_to_string(pa_core *c) {
pa_strbuf *s;
pa_assert(c);
s = pa_strbuf_new();
pa_strbuf_printf(s, "%u cache entries available.\n", c->scache ? pa_idxset_size(c->scache) : 0);
if (c->scache) {
pa_scache_entry *e;
uint32_t idx = PA_IDXSET_INVALID;
for (e = pa_idxset_first(c->scache, &idx); e; e = pa_idxset_next(c->scache, &idx)) {
double l = 0;
char ss[PA_SAMPLE_SPEC_SNPRINT_MAX] = "n/a", cv[PA_CVOLUME_SNPRINT_MAX], cm[PA_CHANNEL_MAP_SNPRINT_MAX] = "n/a";
if (e->memchunk.memblock) {
pa_sample_spec_snprint(ss, sizeof(ss), &e->sample_spec);
pa_channel_map_snprint(cm, sizeof(cm), &e->channel_map);
l = (double) e->memchunk.length / pa_bytes_per_second(&e->sample_spec);
}
pa_strbuf_printf(
s,
" name: <%s>\n"
"\tindex: <%u>\n"
"\tsample spec: <%s>\n"
"\tchannel map: <%s>\n"
"\tlength: <%lu>\n"
"\tduration: <%0.1fs>\n"
"\tvolume: <%s>\n"
"\tlazy: %s\n"
"\tfilename: %s\n",
e->name,
e->index,
ss,
cm,
(long unsigned)(e->memchunk.memblock ? e->memchunk.length : 0),
l,
pa_cvolume_snprint(cv, sizeof(cv), &e->volume),
e->lazy ? "yes" : "no",
e->filename ? e->filename : "n/a");
}
}
return pa_strbuf_tostring_free(s);
}
APULSE_EXPORT
pa_usec_t
pa_bytes_to_usec(uint64_t length, const pa_sample_spec *spec)
{
return 1000 * 1000 * length / pa_bytes_per_second(spec);
}
APULSE_EXPORT
size_t
pa_usec_to_bytes(pa_usec_t t, const pa_sample_spec *spec)
{
return t * pa_bytes_per_second(spec) / (1000 * 1000);
}
static int init(struct ao *ao, char *params)
{
struct pa_sample_spec ss;
struct pa_channel_map map;
char *devarg = NULL;
char *host = NULL;
char *sink = NULL;
const char *version = pa_get_library_version();
struct priv *priv = talloc_zero(ao, struct priv);
ao->priv = priv;
if (params) {
devarg = strdup(params);
sink = strchr(devarg, ':');
if (sink)
*sink++ = 0;
if (devarg[0])
host = devarg;
}
priv->broken_pause = false;
/* not sure which versions are affected, assume 0.9.11* to 0.9.14*
* known bad: 0.9.14, 0.9.13
* known good: 0.9.9, 0.9.10, 0.9.15
* To test: pause, wait ca. 5 seconds, framestep and see if MPlayer
* hangs somewhen. */
if (strncmp(version, "0.9.1", 5) == 0 && version[5] >= '1'
&& version[5] <= '4') {
mp_msg(MSGT_AO, MSGL_WARN,
"[pulse] working around probably broken pause functionality,\n"
" see http://www.pulseaudio.org/ticket/440\n");
priv->broken_pause = true;
}
ss.channels = ao->channels;
ss.rate = ao->samplerate;
const struct format_map *fmt_map = format_maps;
while (fmt_map->mp_format != ao->format) {
if (fmt_map->mp_format == AF_FORMAT_UNKNOWN) {
mp_msg(MSGT_AO, MSGL_V,
"AO: [pulse] Unsupported format, using default\n");
fmt_map = format_maps;
break;
}
fmt_map++;
}
ao->format = fmt_map->mp_format;
ss.format = fmt_map->pa_format;
if (!pa_sample_spec_valid(&ss)) {
mp_msg(MSGT_AO, MSGL_ERR, "AO: [pulse] Invalid sample spec\n");
goto fail;
}
pa_channel_map_init_auto(&map, ss.channels, PA_CHANNEL_MAP_ALSA);
ao->bps = pa_bytes_per_second(&ss);
if (!(priv->mainloop = pa_threaded_mainloop_new())) {
mp_msg(MSGT_AO, MSGL_ERR, "AO: [pulse] Failed to allocate main loop\n");
goto fail;
}
if (!(priv->context = pa_context_new(pa_threaded_mainloop_get_api(
priv->mainloop), PULSE_CLIENT_NAME))) {
mp_msg(MSGT_AO, MSGL_ERR, "AO: [pulse] Failed to allocate context\n");
goto fail;
}
pa_context_set_state_callback(priv->context, context_state_cb, ao);
if (pa_context_connect(priv->context, host, 0, NULL) < 0)
goto fail;
pa_threaded_mainloop_lock(priv->mainloop);
if (pa_threaded_mainloop_start(priv->mainloop) < 0)
goto unlock_and_fail;
/* Wait until the context is ready */
pa_threaded_mainloop_wait(priv->mainloop);
if (pa_context_get_state(priv->context) != PA_CONTEXT_READY)
goto unlock_and_fail;
if (!(priv->stream = pa_stream_new(priv->context, "audio stream", &ss,
&map)))
goto unlock_and_fail;
pa_stream_set_state_callback(priv->stream, stream_state_cb, ao);
pa_stream_set_write_callback(priv->stream, stream_request_cb, ao);
pa_stream_set_latency_update_callback(priv->stream,
stream_latency_update_cb, ao);
pa_buffer_attr bufattr = {
.maxlength = -1,
.tlength = pa_usec_to_bytes(1000000, &ss),
.prebuf = -1,
.minreq = -1,
.fragsize = -1,
};
if (pa_stream_connect_playback(priv->stream, sink, &bufattr,
PA_STREAM_INTERPOLATE_TIMING
| PA_STREAM_AUTO_TIMING_UPDATE, NULL,
NULL) < 0)
goto unlock_and_fail;
/* Wait until the stream is ready */
pa_threaded_mainloop_wait(priv->mainloop);
if (pa_stream_get_state(priv->stream) != PA_STREAM_READY)
goto unlock_and_fail;
pa_threaded_mainloop_unlock(priv->mainloop);
free(devarg);
return 0;
unlock_and_fail:
if (priv->mainloop)
pa_threaded_mainloop_unlock(priv->mainloop);
fail:
if (priv->context)
GENERIC_ERR_MSG(priv->context, "Init failed");
free(devarg);
uninit(ao, true);
return -1;
}
static void cork(struct ao *ao, bool pause)
{
struct priv *priv = ao->priv;
pa_threaded_mainloop_lock(priv->mainloop);
priv->retval = 0;
if (!waitop(priv, pa_stream_cork(priv->stream, pause, success_cb, ao)) ||
!priv->retval)
GENERIC_ERR_MSG(priv->context, "pa_stream_cork() failed");
}
// Play the specified data to the pulseaudio server
static int play(struct ao *ao, void *data, int len, int flags)
{
struct priv *priv = ao->priv;
/* For some reason Pulseaudio behaves worse if this is done after
* the write - rapidly repeated seeks result in bogus increasing
* reported latency. */
if (priv->did_reset)
cork(ao, false);
pa_threaded_mainloop_lock(priv->mainloop);
if (pa_stream_write(priv->stream, data, len, NULL, 0,
PA_SEEK_RELATIVE) < 0) {
GENERIC_ERR_MSG(priv->context, "pa_stream_write() failed");
len = -1;
}
if (priv->did_reset) {
priv->did_reset = false;
if (!waitop(priv, pa_stream_update_timing_info(priv->stream,
success_cb, ao))
|| !priv->retval)
GENERIC_ERR_MSG(priv->context, "pa_stream_UPP() failed");
} else
pa_threaded_mainloop_unlock(priv->mainloop);
return len;
}
// Reset the audio stream, i.e. flush the playback buffer on the server side
static void reset(struct ao *ao)
{
// pa_stream_flush() works badly if not corked
cork(ao, true);
struct priv *priv = ao->priv;
pa_threaded_mainloop_lock(priv->mainloop);
priv->retval = 0;
if (!waitop(priv, pa_stream_flush(priv->stream, success_cb, ao)) ||
!priv->retval)
GENERIC_ERR_MSG(priv->context, "pa_stream_flush() failed");
priv->did_reset = true;
}
/*! Starts up audio streaming to the host. */
void HostAudio::open()
{
m_mainloop = pa_threaded_mainloop_new();
if (!m_mainloop) {
qDebug("Could not acquire PulseAudio main loop");
return;
}
m_api = pa_threaded_mainloop_get_api(m_mainloop);
m_context = pa_context_new(m_api, "emumaster");
pa_context_set_state_callback(m_context, contextStreamCallback, this);
if (!m_context) {
qDebug("Could not acquire PulseAudio device context");
return;
}
#if defined(MEEGO_EDITION_HARMATTAN)
if (pa_context_connect(m_context, 0, PA_CONTEXT_NOFLAGS, 0) < 0) {
#elif defined(Q_WS_MAEMO_5)
if (pa_context_connect(m_context, 0, (pa_context_flags_t)0, 0) < 0) {
#endif
int error = pa_context_errno(m_context);
qDebug("Could not connect to PulseAudio server: %s", pa_strerror(error));
return;
}
pa_threaded_mainloop_lock(m_mainloop);
if (pa_threaded_mainloop_start(m_mainloop) < 0) {
qDebug("Could not start mainloop");
return;
}
waitForStreamReady();
pa_sample_spec fmt;
fmt.channels = 2;
fmt.format = PA_SAMPLE_S16LE;
fmt.rate = 44100;
pa_buffer_attr buffer_attributes;
buffer_attributes.tlength = pa_bytes_per_second(&fmt) / 5;
buffer_attributes.maxlength = buffer_attributes.tlength * 3;
buffer_attributes.minreq = buffer_attributes.tlength / 3;
buffer_attributes.prebuf = buffer_attributes.tlength;
m_stream = pa_stream_new(m_context, "emumaster", &fmt, 0);
if (!m_stream) {
int error = pa_context_errno(m_context);
qDebug("Could not acquire new PulseAudio stream: %s", pa_strerror(error));
return;
}
pa_stream_flags_t flags = (pa_stream_flags_t)(PA_STREAM_ADJUST_LATENCY | PA_STREAM_INTERPOLATE_TIMING | PA_STREAM_AUTO_TIMING_UPDATE);
// pa_stream_flags_t flags = (pa_stream_flags_t) (PA_STREAM_INTERPOLATE_TIMING | PA_STREAM_AUTO_TIMING_UPDATE | PA_STREAM_EARLY_REQUESTS);
if (pa_stream_connect_playback(m_stream, 0, &buffer_attributes, flags, 0, 0) < 0) {
m_stream = 0;
int error = pa_context_errno(m_context);
qDebug("Could not connect for playback: %s", pa_strerror(error));
return;
}
waitForStreamReady();
pa_threaded_mainloop_unlock(m_mainloop);
}
/*! Stops audio streaming. */
void HostAudio::close()
{
if (m_mainloop)
pa_threaded_mainloop_stop(m_mainloop);
if (m_stream) {
pa_stream_unref(m_stream);
m_stream = 0;
}
if (m_context) {
pa_context_disconnect(m_context);
pa_context_unref(m_context);
m_context = 0;
}
if (m_mainloop) {
pa_threaded_mainloop_free(m_mainloop);
m_mainloop = 0;
}
}
/*! Streams a frame of audio from emulated system to the host. */
void HostAudio::sendFrame()
{
if (!m_stream)
return;
pa_threaded_mainloop_lock(m_mainloop);
void *data;
#if defined(MEEGO_EDITION_HARMATTAN)
size_t size = -1;
pa_stream_begin_write(m_stream, &data, &size);
#elif defined(Q_WS_MAEMO_5)
size_t size = 4096;
static char buf[4096];
data = buf;
#endif
size = qMin(size, pa_stream_writable_size(m_stream));
if (size)
size = m_emu->fillAudioBuffer(reinterpret_cast<char *>(data), size);
if (size)
pa_stream_write(m_stream, data, size, 0, 0, PA_SEEK_RELATIVE);
#if defined(MEEGO_EDITION_HARMATTAN)
else
pa_stream_cancel_write(m_stream);
#endif
pa_threaded_mainloop_unlock(m_mainloop);
}
/*! \internal */
void HostAudio::waitForStreamReady()
{
pa_context_state_t context_state = pa_context_get_state(m_context);
while (context_state != PA_CONTEXT_READY) {
context_state = pa_context_get_state(m_context);
if (!PA_CONTEXT_IS_GOOD(context_state)) {
int error = pa_context_errno(m_context);
qDebug("Context state is not good: %s", pa_strerror(error));
return;
} else if (context_state == PA_CONTEXT_READY) {
break;
} else {
//qDebug("PulseAudio context state is %d", context_state);
}
pa_threaded_mainloop_wait(m_mainloop);
}
}
int pa__init(pa_module*m) {
struct userdata *u = NULL;
pa_sample_spec ss;
pa_channel_map map;
pa_modargs *ma = NULL;
pa_assert(m);
if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
pa_log("Failed to parse module arguments.");
goto fail;
}
ss = m->core->default_sample_spec;
if (pa_modargs_get_sample_spec_and_channel_map(ma, &ss, &map, PA_CHANNEL_MAP_DEFAULT) < 0) {
pa_log("Invalid sample format specification or channel map");
goto fail;
}
u = pa_xnew0(struct userdata, 1);
u->core = m->core;
u->module = m;
m->userdata = u;
pa_thread_mq_init(&u->thread_mq, m->core->mainloop);
u->rtpoll = pa_rtpoll_new();
pa_rtpoll_item_new_asyncmsgq(u->rtpoll, PA_RTPOLL_EARLY, u->thread_mq.inq);
if (!(u->sink = pa_sink_new(m->core, __FILE__, pa_modargs_get_value(ma, "sink_name", DEFAULT_SINK_NAME), 0, &ss, &map))) {
pa_log("Failed to create sink.");
goto fail;
}
u->sink->parent.process_msg = sink_process_msg;
u->sink->userdata = u;
u->sink->flags = PA_SINK_LATENCY;
pa_sink_set_module(u->sink, m);
pa_sink_set_asyncmsgq(u->sink, u->thread_mq.inq);
pa_sink_set_rtpoll(u->sink, u->rtpoll);
pa_sink_set_description(u->sink, pa_modargs_get_value(ma, "description", "NULL sink"));
u->block_size = pa_bytes_per_second(&ss) / 20; /* 50 ms */
if (u->block_size <= 0)
u->block_size = pa_frame_size(&ss);
if (!(u->thread = pa_thread_new(thread_func, u))) {
pa_log("Failed to create thread.");
goto fail;
}
pa_sink_put(u->sink);
pa_modargs_free(ma);
return 0;
fail:
if (ma)
pa_modargs_free(ma);
pa__done(m);
return -1;
}
void SetupSound (void)
{
int error_number;
// Acquire mainloop ///////////////////////////////////////////////////////
device.mainloop = pa_threaded_mainloop_new ();
if (device.mainloop == NULL)
{
fprintf (stderr, "Could not acquire PulseAudio main loop\n");
return;
}
// Acquire context ////////////////////////////////////////////////////////
device.api = pa_threaded_mainloop_get_api (device.mainloop);
device.context = pa_context_new (device.api, "PCSXR");
pa_context_set_state_callback (device.context, context_state_cb, &device);
if (device.context == NULL)
{
fprintf (stderr, "Could not acquire PulseAudio device context\n");
return;
}
// Connect to PulseAudio server ///////////////////////////////////////////
if (pa_context_connect (device.context, NULL, 0, NULL) < 0)
{
error_number = pa_context_errno (device.context);
fprintf (stderr, "Could not connect to PulseAudio server: %s\n", pa_strerror(error_number));
return;
}
// Run mainloop until sever context is ready //////////////////////////////
pa_threaded_mainloop_lock (device.mainloop);
if (pa_threaded_mainloop_start (device.mainloop) < 0)
{
fprintf (stderr, "Could not start mainloop\n");
return;
}
pa_context_state_t context_state;
context_state = pa_context_get_state (device.context);
while (context_state != PA_CONTEXT_READY)
{
context_state = pa_context_get_state (device.context);
if (! PA_CONTEXT_IS_GOOD (context_state))
{
error_number = pa_context_errno (device.context);
fprintf (stderr, "Context state is not good: %s\n", pa_strerror (error_number));
return;
}
else if (context_state == PA_CONTEXT_READY)
break;
else
fprintf (stderr, "PulseAudio context state is %d\n", context_state);
pa_threaded_mainloop_wait (device.mainloop);
}
// Set sample spec ////////////////////////////////////////////////////////
device.spec.format = PA_SAMPLE_S16NE;
if (iDisStereo)
device.spec.channels = 1;
else
device.spec.channels = 2;
device.spec.rate = settings.frequency;
pa_buffer_attr buffer_attributes;
buffer_attributes.tlength = pa_bytes_per_second (& device.spec) / 5;
buffer_attributes.maxlength = buffer_attributes.tlength * 3;
buffer_attributes.minreq = buffer_attributes.tlength / 3;
buffer_attributes.prebuf = buffer_attributes.tlength;
//maxlength = buffer_attributes.maxlength;
//fprintf (stderr, "Total space: %u\n", buffer_attributes.maxlength);
//fprintf (stderr, "Minimum request size: %u\n", buffer_attributes.minreq);
//fprintf (stderr, "Bytes needed before playback: %u\n", buffer_attributes.prebuf);
//fprintf (stderr, "Target buffer size: %lu\n", buffer_attributes.tlength);
// Acquire new stream using spec //////////////////////////////////////////
device.stream = pa_stream_new (device.context, "PCSXR", &device.spec, NULL);
if (device.stream == NULL)
{
error_number = pa_context_errno (device.context);
fprintf (stderr, "Could not acquire new PulseAudio stream: %s\n", pa_strerror (error_number));
return;
}
// Set callbacks for server events ////////////////////////////////////////
pa_stream_set_state_callback (device.stream, stream_state_cb, &device);
pa_stream_set_write_callback (device.stream, stream_request_cb, &device);
pa_stream_set_latency_update_callback (device.stream, stream_latency_update_cb, &device);
// Ready stream for playback //////////////////////////////////////////////
pa_stream_flags_t flags = (pa_stream_flags_t) (PA_STREAM_ADJUST_LATENCY | PA_STREAM_INTERPOLATE_TIMING | PA_STREAM_AUTO_TIMING_UPDATE);
//pa_stream_flags_t flags = (pa_stream_flags_t) (PA_STREAM_INTERPOLATE_TIMING | PA_STREAM_AUTO_TIMING_UPDATE | PA_STREAM_EARLY_REQUESTS);
if (pa_stream_connect_playback (device.stream, NULL, &buffer_attributes, flags, NULL, NULL) < 0)
{
pa_context_errno (device.context);
fprintf (stderr, "Could not connect for playback: %s\n", pa_strerror (error_number));
return;
}
// Run mainloop until stream is ready /////////////////////////////////////
pa_stream_state_t stream_state;
stream_state = pa_stream_get_state (device.stream);
while (stream_state != PA_STREAM_READY)
{
stream_state = pa_stream_get_state (device.stream);
if (stream_state == PA_STREAM_READY)
break;
else if (! PA_STREAM_IS_GOOD (stream_state))
{
error_number = pa_context_errno (device.context);
fprintf (stderr, "Stream state is not good: %s\n", pa_strerror (error_number));
return;
}
else
fprintf (stderr, "PulseAudio stream state is %d\n", stream_state);
pa_threaded_mainloop_wait (device.mainloop);
}
pa_threaded_mainloop_unlock (device.mainloop);
fprintf (stderr, "PulseAudio should be connected\n");
return;
}
static DECLCALLBACK(int) drvHostPulseAudioInitOut(PPDMIHOSTAUDIO pInterface,
PPDMAUDIOHSTSTRMOUT pHstStrmOut, PPDMAUDIOSTREAMCFG pCfg,
uint32_t *pcSamples)
{
AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
AssertPtrReturn(pHstStrmOut, VERR_INVALID_POINTER);
AssertPtrReturn(pCfg, VERR_INVALID_POINTER);
/* pcSamples is optional. */
PDRVHOSTPULSEAUDIO pDrv = PDMIHOSTAUDIO_2_DRVHOSTPULSEAUDIO(pInterface);
PPULSEAUDIOSTREAM pThisStrmOut = (PPULSEAUDIOSTREAM)pHstStrmOut;
LogFlowFuncEnter();
pThisStrmOut->pDrainOp = NULL;
pThisStrmOut->SampleSpec.format = drvHostPulseAudioFmtToPulse(pCfg->enmFormat);
pThisStrmOut->SampleSpec.rate = pCfg->uHz;
pThisStrmOut->SampleSpec.channels = pCfg->cChannels;
/* Note that setting maxlength to -1 does not work on PulseAudio servers
* older than 0.9.10. So use the suggested value of 3/2 of tlength */
pThisStrmOut->BufAttr.tlength = (pa_bytes_per_second(&pThisStrmOut->SampleSpec)
* s_pulseCfg.buffer_msecs_out) / 1000;
pThisStrmOut->BufAttr.maxlength = (pThisStrmOut->BufAttr.tlength * 3) / 2;
pThisStrmOut->BufAttr.prebuf = -1; /* Same as tlength */
pThisStrmOut->BufAttr.minreq = -1; /* Pulse should set something sensible for minreq on it's own */
/* Note that the struct BufAttr is updated to the obtained values after this call! */
char achName[64];
RTStrPrintf(achName, sizeof(achName), "%.32s (out)", pDrv->pszStreamName);
int rc = drvHostPulseAudioOpen(false /* fIn */, achName, &pThisStrmOut->SampleSpec, &pThisStrmOut->BufAttr,
&pThisStrmOut->pStream);
if (RT_FAILURE(rc))
return rc;
PDMAUDIOSTREAMCFG streamCfg;
rc = drvHostPulseAudioPulseToFmt(pThisStrmOut->SampleSpec.format,
&streamCfg.enmFormat, &streamCfg.enmEndianness);
if (RT_FAILURE(rc))
{
LogRel(("PulseAudio: Cannot find audio output format %ld\n", pThisStrmOut->SampleSpec.format));
return rc;
}
streamCfg.uHz = pThisStrmOut->SampleSpec.rate;
streamCfg.cChannels = pThisStrmOut->SampleSpec.channels;
rc = DrvAudioStreamCfgToProps(&streamCfg, &pHstStrmOut->Props);
if (RT_SUCCESS(rc))
{
uint32_t cbBuf = RT_MIN(pThisStrmOut->BufAttr.tlength * 2,
pThisStrmOut->BufAttr.maxlength); /** @todo Make this configurable! */
if (cbBuf)
{
pThisStrmOut->pvPCMBuf = RTMemAllocZ(cbBuf);
if (pThisStrmOut->pvPCMBuf)
{
pThisStrmOut->cbPCMBuf = cbBuf;
uint32_t cSamples = cbBuf >> pHstStrmOut->Props.cShift;
if (pcSamples)
*pcSamples = cSamples;
/* Save pointer to driver instance. */
pThisStrmOut->pDrv = pDrv;
LogFunc(("cbBuf=%RU32, cSamples=%RU32\n", cbBuf, cSamples));
}
else
rc = VERR_NO_MEMORY;
}
/*****************************************************************************
* 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;
}
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;
}
void pa_simple_protocol_connect(pa_simple_protocol *p, pa_iochannel *io, pa_simple_options *o) {
connection *c = NULL;
char pname[128];
pa_client_new_data client_data;
pa_assert(p);
pa_assert(io);
pa_assert(o);
if (pa_idxset_size(p->connections)+1 > MAX_CONNECTIONS) {
pa_log("Warning! Too many connections (%u), dropping incoming connection.", MAX_CONNECTIONS);
pa_iochannel_free(io);
return;
}
c = pa_msgobject_new(connection);
c->parent.parent.free = connection_free;
c->parent.process_msg = connection_process_msg;
c->io = io;
pa_iochannel_set_callback(c->io, io_callback, c);
c->sink_input = NULL;
c->source_output = NULL;
c->input_memblockq = c->output_memblockq = NULL;
c->protocol = p;
c->options = pa_simple_options_ref(o);
c->playback.current_memblock = NULL;
c->playback.memblock_index = 0;
c->dead = false;
c->playback.underrun = true;
pa_atomic_store(&c->playback.missing, 0);
pa_client_new_data_init(&client_data);
client_data.module = o->module;
client_data.driver = __FILE__;
pa_iochannel_socket_peer_to_string(io, pname, sizeof(pname));
pa_proplist_setf(client_data.proplist, PA_PROP_APPLICATION_NAME, "Simple client (%s)", pname);
pa_proplist_sets(client_data.proplist, "simple-protocol.peer", pname);
c->client = pa_client_new(p->core, &client_data);
pa_client_new_data_done(&client_data);
if (!c->client)
goto fail;
c->client->kill = client_kill_cb;
c->client->userdata = c;
if (o->playback) {
pa_sink_input_new_data data;
pa_memchunk silence;
size_t l;
pa_sink *sink;
if (!(sink = pa_namereg_get(c->protocol->core, o->default_sink, PA_NAMEREG_SINK))) {
pa_log("Failed to get sink.");
goto fail;
}
pa_sink_input_new_data_init(&data);
data.driver = __FILE__;
data.module = o->module;
data.client = c->client;
pa_sink_input_new_data_set_sink(&data, sink, false);
pa_proplist_update(data.proplist, PA_UPDATE_MERGE, c->client->proplist);
pa_sink_input_new_data_set_sample_spec(&data, &o->sample_spec);
pa_sink_input_new(&c->sink_input, p->core, &data);
pa_sink_input_new_data_done(&data);
if (!c->sink_input) {
pa_log("Failed to create sink input.");
goto fail;
}
c->sink_input->parent.process_msg = sink_input_process_msg;
c->sink_input->pop = sink_input_pop_cb;
c->sink_input->process_rewind = sink_input_process_rewind_cb;
c->sink_input->update_max_rewind = sink_input_update_max_rewind_cb;
c->sink_input->kill = sink_input_kill_cb;
c->sink_input->userdata = c;
pa_sink_input_set_requested_latency(c->sink_input, DEFAULT_SINK_LATENCY);
l = (size_t) ((double) pa_bytes_per_second(&o->sample_spec)*PLAYBACK_BUFFER_SECONDS);
pa_sink_input_get_silence(c->sink_input, &silence);
c->input_memblockq = pa_memblockq_new(
"simple protocol connection input_memblockq",
0,
l,
l,
&o->sample_spec,
(size_t) -1,
l/PLAYBACK_BUFFER_FRAGMENTS,
0,
&silence);
pa_memblock_unref(silence.memblock);
pa_iochannel_socket_set_rcvbuf(io, l);
pa_atomic_store(&c->playback.missing, (int) pa_memblockq_pop_missing(c->input_memblockq));
pa_sink_input_put(c->sink_input);
}
if (o->record) {
pa_source_output_new_data data;
size_t l;
pa_source *source;
if (!(source = pa_namereg_get(c->protocol->core, o->default_source, PA_NAMEREG_SOURCE))) {
pa_log("Failed to get source.");
goto fail;
}
pa_source_output_new_data_init(&data);
data.driver = __FILE__;
data.module = o->module;
data.client = c->client;
pa_source_output_new_data_set_source(&data, source, false);
pa_proplist_update(data.proplist, PA_UPDATE_MERGE, c->client->proplist);
pa_source_output_new_data_set_sample_spec(&data, &o->sample_spec);
pa_source_output_new(&c->source_output, p->core, &data);
pa_source_output_new_data_done(&data);
if (!c->source_output) {
pa_log("Failed to create source output.");
goto fail;
}
c->source_output->push = source_output_push_cb;
c->source_output->kill = source_output_kill_cb;
c->source_output->get_latency = source_output_get_latency_cb;
c->source_output->userdata = c;
pa_source_output_set_requested_latency(c->source_output, DEFAULT_SOURCE_LATENCY);
l = (size_t) (pa_bytes_per_second(&o->sample_spec)*RECORD_BUFFER_SECONDS);
c->output_memblockq = pa_memblockq_new(
"simple protocol connection output_memblockq",
0,
l,
0,
&o->sample_spec,
1,
0,
0,
NULL);
pa_iochannel_socket_set_sndbuf(io, l);
pa_source_output_put(c->source_output);
}
pa_idxset_put(p->connections, c, NULL);
return;
fail:
connection_unlink(c);
}
static int paCreateStreamOut(PPDMIHOSTAUDIO pInterface,
PPDMAUDIOSTREAM pStream, PPDMAUDIOSTREAMCFG pCfg, uint32_t *pcSamples)
{
AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
AssertPtrReturn(pStream, VERR_INVALID_POINTER);
AssertPtrReturn(pCfg, VERR_INVALID_POINTER);
/* pcSamples is optional. */
PDRVHOSTPULSEAUDIO pThis = PDMIHOSTAUDIO_2_DRVHOSTPULSEAUDIO(pInterface);
PPULSEAUDIOSTREAM pStrm = (PPULSEAUDIOSTREAM)pStream;
LogFlowFuncEnter();
pStrm->pDrainOp = NULL;
pStrm->SampleSpec.format = paFmtToPulse(pCfg->enmFormat);
pStrm->SampleSpec.rate = pCfg->uHz;
pStrm->SampleSpec.channels = pCfg->cChannels;
/* Note that setting maxlength to -1 does not work on PulseAudio servers
* older than 0.9.10. So use the suggested value of 3/2 of tlength */
pStrm->BufAttr.tlength = (pa_bytes_per_second(&pStrm->SampleSpec)
* s_pulseCfg.buffer_msecs_out) / 1000;
pStrm->BufAttr.maxlength = (pStrm->BufAttr.tlength * 3) / 2;
pStrm->BufAttr.prebuf = -1; /* Same as tlength */
pStrm->BufAttr.minreq = -1;
/* Note that the struct BufAttr is updated to the obtained values after this call! */
int rc = paStreamOpen(pThis, false /* fIn */, "PulseAudio (Out)", &pStrm->SampleSpec, &pStrm->BufAttr, &pStrm->pPAStream);
if (RT_FAILURE(rc))
return rc;
PDMAUDIOSTREAMCFG streamCfg;
rc = paPulseToFmt(pStrm->SampleSpec.format,
&streamCfg.enmFormat, &streamCfg.enmEndianness);
if (RT_FAILURE(rc))
{
LogRel(("PulseAudio: Cannot find audio output format %ld\n", pStrm->SampleSpec.format));
return rc;
}
streamCfg.uHz = pStrm->SampleSpec.rate;
streamCfg.cChannels = pStrm->SampleSpec.channels;
rc = DrvAudioHlpStreamCfgToProps(&streamCfg, &pStream->Props);
if (RT_SUCCESS(rc))
{
uint32_t cbBuf = RT_MIN(pStrm->BufAttr.tlength * 2,
pStrm->BufAttr.maxlength); /** @todo Make this configurable! */
if (cbBuf)
{
pStrm->pvPCMBuf = RTMemAllocZ(cbBuf);
if (pStrm->pvPCMBuf)
{
pStrm->cbPCMBuf = cbBuf;
uint32_t cSamples = cbBuf >> pStream->Props.cShift;
if (pcSamples)
*pcSamples = cSamples;
/* Save pointer to driver instance. */
pStrm->pDrv = pThis;
LogFunc(("cbBuf=%RU32, cSamples=%RU32\n", cbBuf, cSamples));
}
else
rc = VERR_NO_MEMORY;
}
/** libao initialization function, arguments are sampling frequency,
* number of channels, sample type and some flags */
static int init(int rate_hz, int channels, int format, int flags) {
struct pa_sample_spec ss;
struct pa_buffer_attr a;
char hn[128];
char *host = NULL;
assert(!context && !stream && !mainloop);
if (ao_subdevice) {
int i = strcspn(ao_subdevice, ":");
if (i >= sizeof(hn))
i = sizeof(hn)-1;
if (i > 0) {
strncpy(host = hn, ao_subdevice, i);
hn[i] = 0;
}
if (ao_subdevice[i] == ':')
sink = ao_subdevice+i+1;
}
mp_msg(MSGT_AO, MSGL_ERR, "AO: [polyp] -%s-%s-\n", host, sink);
ss.channels = channels;
ss.rate = rate_hz;
switch (format) {
case AF_FORMAT_U8:
ss.format = PA_SAMPLE_U8;
break;
case AF_FORMAT_S16_LE:
ss.format = PA_SAMPLE_S16LE;
break;
case AF_FORMAT_S16_BE:
ss.format = PA_SAMPLE_S16BE;
break;
case AF_FORMAT_FLOAT_NE:
ss.format = PA_SAMPLE_FLOAT32;
break;
default:
mp_msg(MSGT_AO, MSGL_ERR, "AO: [polyp] Unsupported sample spec\n");
goto fail;
}
if (!pa_sample_spec_valid(&ss)) {
mp_msg(MSGT_AO, MSGL_ERR, "AO: [polyp] Invalid sample spec\n");
goto fail;
}
mainloop = pa_mainloop_new();
assert(mainloop);
context = pa_context_new(pa_mainloop_get_api(mainloop), POLYP_CLIENT_NAME);
assert(context);
pa_context_connect(context, host, 1, NULL);
wait_for_completion();
if (pa_context_get_state(context) != PA_CONTEXT_READY) {
mp_msg(MSGT_AO, MSGL_ERR, "AO: [polyp] Failed to connect to server: %s\n", pa_strerror(pa_context_errno(context)));
goto fail;
}
stream = pa_stream_new(context, "audio stream", &ss);
assert(stream);
a.maxlength = pa_bytes_per_second(&ss)*1;
a.tlength = a.maxlength*9/10;
a.prebuf = a.tlength/2;
a.minreq = a.tlength/10;
pa_stream_connect_playback(stream, sink, &a, PA_STREAM_INTERPOLATE_LATENCY, PA_VOLUME_NORM);
wait_for_completion();
if (pa_stream_get_state(stream) != PA_STREAM_READY) {
mp_msg(MSGT_AO, MSGL_ERR, "AO: [polyp] Failed to connect to server: %s\n", pa_strerror(pa_context_errno(context)));
goto fail;
}
return 1;
fail:
uninit(1);
return 0;
}
static int init(int rate_hz, int channels, int format, int flags) {
struct pa_sample_spec ss;
struct pa_channel_map map;
const struct format_map_s *fmt_map;
char *devarg = NULL;
char *host = NULL;
char *sink = NULL;
char *version = pa_get_library_version();
if (ao_subdevice) {
devarg = strdup(ao_subdevice);
sink = strchr(devarg, ':');
if (sink) *sink++ = 0;
if (devarg[0]) host = devarg;
}
broken_pause = 0;
// not sure which versions are affected, assume 0.9.11* to 0.9.14*
// known bad: 0.9.14, 0.9.13
// known good: 0.9.9, 0.9.10, 0.9.15
// to test: pause, wait ca. 5 seconds framestep and see if MPlayer hangs somewhen
if (strncmp(version, "0.9.1", 5) == 0 && version[5] >= '1' && version[5] <= '4') {
mp_msg(MSGT_AO, MSGL_WARN, "[pulse] working around probably broken pause functionality,\n"
" see http://www.pulseaudio.org/ticket/440\n");
broken_pause = 1;
}
ss.channels = channels;
ss.rate = rate_hz;
ao_data.samplerate = rate_hz;
ao_data.channels = channels;
fmt_map = format_maps;
while (fmt_map->mp_format != format) {
if (fmt_map->mp_format == AF_FORMAT_UNKNOWN) {
mp_msg(MSGT_AO, MSGL_V, "AO: [pulse] Unsupported format, using default\n");
fmt_map = format_maps;
break;
}
fmt_map++;
}
ao_data.format = fmt_map->mp_format;
ss.format = fmt_map->pa_format;
if (!pa_sample_spec_valid(&ss)) {
mp_msg(MSGT_AO, MSGL_ERR, "AO: [pulse] Invalid sample spec\n");
goto fail;
}
pa_channel_map_init_auto(&map, ss.channels, PA_CHANNEL_MAP_ALSA);
ao_data.bps = pa_bytes_per_second(&ss);
pa_cvolume_reset(&volume, ss.channels);
if (!(mainloop = pa_threaded_mainloop_new())) {
mp_msg(MSGT_AO, MSGL_ERR, "AO: [pulse] Failed to allocate main loop\n");
goto fail;
}
if (!(context = pa_context_new(pa_threaded_mainloop_get_api(mainloop), PULSE_CLIENT_NAME))) {
mp_msg(MSGT_AO, MSGL_ERR, "AO: [pulse] Failed to allocate context\n");
goto fail;
}
pa_context_set_state_callback(context, context_state_cb, NULL);
if (pa_context_connect(context, host, 0, NULL) < 0)
goto fail;
pa_threaded_mainloop_lock(mainloop);
if (pa_threaded_mainloop_start(mainloop) < 0)
goto unlock_and_fail;
/* Wait until the context is ready */
pa_threaded_mainloop_wait(mainloop);
if (pa_context_get_state(context) != PA_CONTEXT_READY)
goto unlock_and_fail;
if (!(stream = pa_stream_new(context, "audio stream", &ss, &map)))
goto unlock_and_fail;
pa_stream_set_state_callback(stream, stream_state_cb, NULL);
pa_stream_set_write_callback(stream, stream_request_cb, NULL);
pa_stream_set_latency_update_callback(stream, stream_latency_update_cb, NULL);
if (pa_stream_connect_playback(stream, sink, NULL, PA_STREAM_INTERPOLATE_TIMING|PA_STREAM_AUTO_TIMING_UPDATE, &volume, NULL) < 0)
goto unlock_and_fail;
/* Wait until the stream is ready */
pa_threaded_mainloop_wait(mainloop);
if (pa_stream_get_state(stream) != PA_STREAM_READY)
goto unlock_and_fail;
pa_threaded_mainloop_unlock(mainloop);
free(devarg);
return 1;
unlock_and_fail:
if (mainloop)
pa_threaded_mainloop_unlock(mainloop);
fail:
if (context)
GENERIC_ERR_MSG(context, "Init failed");
free(devarg);
uninit(1);
return 0;
}
