int pa_simple_flush(pa_simple *p, int *rerror) {
pa_operation *o = NULL;
pa_assert(p);
CHECK_VALIDITY_RETURN_ANY(rerror, p->direction == PA_STREAM_PLAYBACK, PA_ERR_BADSTATE, -1);
pa_threaded_mainloop_lock(p->mainloop);
CHECK_DEAD_GOTO(p, rerror, unlock_and_fail);
o = pa_stream_flush(p->stream, success_cb, p);
CHECK_SUCCESS_GOTO(p, rerror, o, unlock_and_fail);
p->operation_success = 0;
while (pa_operation_get_state(o) == PA_OPERATION_RUNNING) {
pa_threaded_mainloop_wait(p->mainloop);
CHECK_DEAD_GOTO(p, rerror, unlock_and_fail);
}
CHECK_SUCCESS_GOTO(p, rerror, p->operation_success, unlock_and_fail);
pa_operation_unref(o);
pa_threaded_mainloop_unlock(p->mainloop);
return 0;
unlock_and_fail:
if (o) {
pa_operation_cancel(o);
pa_operation_unref(o);
}
pa_threaded_mainloop_unlock(p->mainloop);
return -1;
}
static void context_unlink(pa_context *c) {
pa_stream *s;
pa_assert(c);
s = c->streams ? pa_stream_ref(c->streams) : NULL;
while (s) {
pa_stream *n = s->next ? pa_stream_ref(s->next) : NULL;
pa_stream_set_state(s, c->state == PA_CONTEXT_FAILED ? PA_STREAM_FAILED : PA_STREAM_TERMINATED);
pa_stream_unref(s);
s = n;
}
while (c->operations)
pa_operation_cancel(c->operations);
if (c->pdispatch) {
pa_pdispatch_unref(c->pdispatch);
c->pdispatch = NULL;
}
if (c->pstream) {
pa_pstream_unlink(c->pstream);
pa_pstream_unref(c->pstream);
c->pstream = NULL;
}
if (c->client) {
pa_socket_client_unref(c->client);
c->client = NULL;
}
reset_callbacks(c);
}
static gboolean
play_timeout (MokoNotify *notify)
{
MokoNotifyPrivate *priv;
g_return_val_if_fail (MOKO_IS_NOTIFY (notify), FALSE);
priv = notify->priv;
if (!priv->pac)
return FALSE;
if (!priv->operation)
{
g_debug ("No operation");
return FALSE;
}
if (!priv->started)
{
pa_operation_cancel (priv->operation);
g_debug ("Cancelling early");
return FALSE;
}
if (pa_operation_get_state (priv->operation) == PA_OPERATION_DONE)
{
g_timeout_add (1500, (GSourceFunc)play, (gpointer)notify);
g_debug ("Playing done");
return FALSE;
}
g_debug ("Not finshed yet");
return TRUE;
}
/*
this method may be called inside the pulse main loop,
so be VERY careful with locking
*/
void CPulseAEStream::Destroy()
{
if (!m_Initialized)
return;
if (m_Destroyed)
return;
m_fader.StopThread(true);
pa_threaded_mainloop_lock(m_MainLoop);
if (m_DrainOperation)
{
pa_operation_cancel(m_DrainOperation);
pa_operation_unref(m_DrainOperation);
m_DrainOperation = NULL;
}
if (m_Stream)
{
pa_stream_disconnect(m_Stream);
pa_stream_unref(m_Stream);
m_Stream = NULL;
}
/* signal CPulseAE to free us */
m_Destroyed = true;
m_Initialized = false;
pa_threaded_mainloop_unlock(m_MainLoop);
}
int pa_simple_cork(pa_simple *p, int cork, int *rerror) {
pa_operation *o = NULL;
pa_assert(p);
pa_threaded_mainloop_lock(p->mainloop);
CHECK_DEAD_GOTO(p, rerror, unlock_and_fail);
o = pa_stream_cork(p->stream, cork, success_context_cb, p);
CHECK_SUCCESS_GOTO(p, rerror, o, unlock_and_fail);
p->operation_success = 0;
while (pa_operation_get_state(o) == PA_OPERATION_RUNNING) {
pa_threaded_mainloop_wait(p->mainloop);
CHECK_DEAD_GOTO(p, rerror, unlock_and_fail);
}
CHECK_SUCCESS_GOTO(p, rerror, p->operation_success, unlock_and_fail);
pa_operation_unref(o);
pa_threaded_mainloop_unlock(p->mainloop);
return 0;
unlock_and_fail:
if (o) {
pa_operation_cancel(o);
pa_operation_unref(o);
}
pa_threaded_mainloop_unlock(p->mainloop);
return -1;
}
void CPulseAESound::Stop()
{
if (m_op)
{
pa_operation_cancel(m_op);
pa_operation_unref(m_op);
m_op = NULL;
}
}
static void
gst_pulsesrc_reset (GstAudioSrc * asrc)
{
GstPulseSrc *pulsesrc = GST_PULSESRC_CAST (asrc);
pa_operation *o = NULL;
pa_threaded_mainloop_lock (pulsesrc->mainloop);
GST_DEBUG_OBJECT (pulsesrc, "reset");
if (gst_pulsesrc_is_dead (pulsesrc, TRUE))
goto unlock_and_fail;
if (!(o =
pa_stream_flush (pulsesrc->stream, gst_pulsesrc_success_cb,
pulsesrc))) {
GST_ELEMENT_ERROR (pulsesrc, RESOURCE, FAILED,
("pa_stream_flush() failed: %s",
pa_strerror (pa_context_errno (pulsesrc->context))), (NULL));
goto unlock_and_fail;
}
pulsesrc->paused = TRUE;
/* Inform anyone waiting in _write() call that it shall wakeup */
if (pulsesrc->in_read) {
pa_threaded_mainloop_signal (pulsesrc->mainloop, 0);
}
pulsesrc->operation_success = FALSE;
while (pa_operation_get_state (o) == PA_OPERATION_RUNNING) {
if (gst_pulsesrc_is_dead (pulsesrc, TRUE))
goto unlock_and_fail;
pa_threaded_mainloop_wait (pulsesrc->mainloop);
}
if (!pulsesrc->operation_success) {
GST_ELEMENT_ERROR (pulsesrc, RESOURCE, FAILED, ("Flush failed: %s",
pa_strerror (pa_context_errno (pulsesrc->context))), (NULL));
goto unlock_and_fail;
}
unlock_and_fail:
if (o) {
pa_operation_cancel (o);
pa_operation_unref (o);
}
pa_threaded_mainloop_unlock (pulsesrc->mainloop);
}
void m1sdr_PlayStop(void)
{
#if 0
pa_operation *op;
#endif
#ifdef USE_SDL
if (lnxdrv_apimode == 0)
{
SDL_PauseAudio(1);
}
#endif
if (lnxdrv_apimode == 1)
{
// snd_pcm_pause(pHandle, 1);
snd_pcm_drop(pHandle);
}
#if PULSE_USE_SIMPLE
if ((lnxdrv_apimode == 3) && (my_simple))
{
pa_simple_flush(my_simple, NULL);
pa_simple_free(my_simple);
my_simple = NULL;
}
#else
#if 0
if (lnxdrv_apimode == 3)
{
op = pa_stream_drain(my_pa_stream, &pa_stream_drain_complete, NULL);
if (op)
{
while (pa_operation_get_state(op) != PA_OPERATION_DONE)
{
if (pa_context_get_state(my_pa_context) != PA_CONTEXT_READY ||
pa_stream_get_state(my_pa_stream) != PA_STREAM_READY ||
pa_mainloop_iterate(my_pa_mainloop, 0, NULL) < 0)
{
pa_operation_cancel(op);
break;
}
}
}
}
#endif
#endif
waveLogStop();
oss_playing = 0;
}
pa_operation *pa_ext_device_manager_delete(
pa_context *c,
const char *const s[],
pa_context_success_cb_t cb,
void *userdata) {
uint32_t tag;
pa_operation *o = NULL;
pa_tagstruct *t = NULL;
const char *const *k;
pa_assert(c);
pa_assert(PA_REFCNT_VALUE(c) >= 1);
pa_assert(s);
PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 14, PA_ERR_NOTSUPPORTED);
o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
t = pa_tagstruct_command(c, PA_COMMAND_EXTENSION, &tag);
pa_tagstruct_putu32(t, PA_INVALID_INDEX);
pa_tagstruct_puts(t, "module-device-manager");
pa_tagstruct_putu32(t, SUBCOMMAND_DELETE);
for (k = s; *k; k++) {
if (!*k || !**k)
goto fail;
pa_tagstruct_puts(t, *k);
}
pa_pstream_send_tagstruct(c->pstream, t);
pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, pa_context_simple_ack_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
return o;
fail:
if (o) {
pa_operation_cancel(o);
pa_operation_unref(o);
}
if (t)
pa_tagstruct_free(t);
pa_context_set_error(c, PA_ERR_INVALID);
return NULL;
}
int pa_simple_set_volume(pa_simple *p, int volume, int *rerror) {
pa_operation *o = NULL;
pa_stream *s = NULL;
uint32_t idx;
pa_cvolume cv;
pa_volume_t v;
pa_assert(p);
CHECK_VALIDITY_RETURN_ANY(rerror, p->direction == PA_STREAM_PLAYBACK, PA_ERR_BADSTATE, -1);
CHECK_VALIDITY_RETURN_ANY(rerror, volume >= 0, PA_ERR_INVALID, -1);
CHECK_VALIDITY_RETURN_ANY(rerror, volume <= 65535, PA_ERR_INVALID, -1);
pa_threaded_mainloop_lock(p->mainloop);
CHECK_DEAD_GOTO(p, rerror, unlock_and_fail);
CHECK_SUCCESS_GOTO(p, rerror, ((idx = pa_stream_get_index (p->stream)) != PA_INVALID_INDEX), unlock_and_fail);
s = p->stream;
pa_assert(s);
pa_cvolume_set(&cv, s->sample_spec.channels, volume);
o = pa_context_set_sink_input_volume (p->context, idx, &cv, success_context_cb, p);
CHECK_SUCCESS_GOTO(p, rerror, o, unlock_and_fail);
p->operation_success = 0;
while (pa_operation_get_state(o) == PA_OPERATION_RUNNING) {
pa_threaded_mainloop_wait(p->mainloop);
CHECK_DEAD_GOTO(p, rerror, unlock_and_fail);
}
CHECK_SUCCESS_GOTO(p, rerror, p->operation_success, unlock_and_fail);
pa_operation_unref(o);
pa_threaded_mainloop_unlock(p->mainloop);
return 0;
unlock_and_fail:
if (o) {
pa_operation_cancel(o);
pa_operation_unref(o);
}
pa_threaded_mainloop_unlock(p->mainloop);
return -1;
}
static void
moko_notify_stop_ringtone (MokoNotify *notify)
{
MokoNotifyPrivate *priv;
g_return_if_fail (MOKO_IS_NOTIFY (notify));
priv = notify->priv;
if (priv->operation)
{
pa_operation_cancel (priv->operation);
g_debug ("Cancelling");
}
priv->operation = NULL;
}
void
cubeb_stream_destroy(cubeb_stream * stm)
{
if (stm->stream) {
stream_cork(stm, CORK);
pa_threaded_mainloop_lock(stm->context->mainloop);
if (stm->draining) {
pa_operation_cancel(stm->draining);
pa_operation_unref(stm->draining);
}
pa_stream_disconnect(stm->stream);
pa_stream_unref(stm->stream);
pa_threaded_mainloop_unlock(stm->context->mainloop);
}
free(stm);
}
gboolean xmms_pulse_backend_flush (xmms_pulse *p, int *rerror)
{
pa_operation *o = NULL;
pa_threaded_mainloop_lock (p->mainloop);
if (!check_pulse_health (p, rerror))
goto unlock_and_fail;
o = pa_stream_flush (p->stream, drain_result_cb, p);
if (!o) {
if (rerror)
*rerror = pa_context_errno ((p)->context);
goto unlock_and_fail;
}
p->operation_success = 0;
while (pa_operation_get_state (o) != PA_OPERATION_DONE) {
pa_threaded_mainloop_wait (p->mainloop);
if (!check_pulse_health (p, rerror))
goto unlock_and_fail;
}
pa_operation_unref (o);
o = NULL;
if (!p->operation_success) {
if (rerror)
*rerror = pa_context_errno ((p)->context);
goto unlock_and_fail;
}
pa_threaded_mainloop_unlock (p->mainloop);
return 0;
unlock_and_fail:
if (o) {
pa_operation_cancel (o);
pa_operation_unref (o);
}
pa_threaded_mainloop_unlock (p->mainloop);
return -1;
}
pa_operation *pa_ext_stream_restore_write(
pa_context *c,
pa_update_mode_t mode,
const pa_ext_stream_restore_info data[],
unsigned n,
int apply_immediately,
pa_context_success_cb_t cb,
void *userdata) {
uint32_t tag;
pa_operation *o = NULL;
pa_tagstruct *t = NULL;
pa_assert(c);
pa_assert(PA_REFCNT_VALUE(c) >= 1);
pa_assert(mode == PA_UPDATE_MERGE || mode == PA_UPDATE_REPLACE || mode == PA_UPDATE_SET);
pa_assert(data);
PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 14, PA_ERR_NOTSUPPORTED);
o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
t = pa_tagstruct_command(c, PA_COMMAND_EXTENSION, &tag);
pa_tagstruct_putu32(t, PA_INVALID_INDEX);
pa_tagstruct_puts(t, "module-stream-restore");
pa_tagstruct_putu32(t, SUBCOMMAND_WRITE);
pa_tagstruct_putu32(t, mode);
pa_tagstruct_put_boolean(t, apply_immediately);
for (; n > 0; n--, data++) {
if (!data->name || !*data->name)
goto fail;
pa_tagstruct_puts(t, data->name);
if (data->volume.channels > 0 &&
!pa_cvolume_compatible_with_channel_map(&data->volume, &data->channel_map))
goto fail;
pa_tagstruct_put_channel_map(t, &data->channel_map);
pa_tagstruct_put_cvolume(t, &data->volume);
pa_tagstruct_puts(t, data->device);
pa_tagstruct_put_boolean(t, data->mute);
}
pa_pstream_send_tagstruct(c->pstream, t);
pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, pa_context_simple_ack_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
return o;
fail:
pa_operation_cancel(o);
pa_operation_unref(o);
pa_tagstruct_free(t);
pa_context_set_error(c, PA_ERR_INVALID);
return NULL;
}
