--- /dev/null
+/*
+ * This file is a part of MAFW
+ *
+ * Copyright (C) 2007, 2008, 2009 Nokia Corporation, all rights reserved.
+ *
+ * Contact: Visa Smolander <visa.smolander@nokia.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifndef MAFW_GST_RENDERER_DISABLE_PULSE_VOLUME
+
+#include <pulse/pulseaudio.h>
+#include <pulse/glib-mainloop.h>
+#include <pulse/ext-stream-restore.h>
+#include <string.h>
+
+#include "mafw-gst-renderer-worker-volume.h"
+#include "config.h"
+
+#undef G_LOG_DOMAIN
+#define G_LOG_DOMAIN "mafw-gst-renderer-worker-volume"
+
+#define MAFW_GST_RENDERER_WORKER_VOLUME_SERVER NULL
+
+#define MAFW_GST_RENDERER_WORKER_VOLUME_ROLE_PROPERTY "PULSE_PROP_media.role"
+#define MAFW_GST_RENDERER_WORKER_VOLUME_ROLE_PREFIX "sink-input-by-media-role:"
+#define MAFW_GST_RENDERER_WORKER_VOLUME_ROLE "x-maemo"
+
+#define MAFW_GST_RENDERER_WORKER_SET_TIMEOUT 200
+
+
+struct _MafwGstRendererWorkerVolume {
+ pa_glib_mainloop *mainloop;
+ pa_context *context;
+ gdouble pulse_volume;
+ gboolean pulse_mute;
+ MafwGstRendererWorkerVolumeChangedCb cb;
+ gpointer user_data;
+ MafwGstRendererWorkerVolumeMuteCb mute_cb;
+ gpointer mute_user_data;
+ gdouble current_volume;
+ gboolean current_mute;
+ gboolean pending_operation;
+ gdouble pending_operation_volume;
+ gboolean pending_operation_mute;
+ guint change_request_id;
+ pa_operation *pa_operation;
+};
+
+typedef struct {
+ MafwGstRendererWorkerVolume *wvolume;
+ MafwGstRendererWorkerVolumeInitCb cb;
+ gpointer user_data;
+} InitCbClosure;
+
+#define _pa_volume_to_per_one(volume) \
+ ((guint) ((((gdouble)(volume) / (gdouble) PA_VOLUME_NORM) + \
+ (gdouble) 0.005) * (gdouble) 100.0) / (gdouble) 100.0)
+#define _pa_volume_from_per_one(volume) \
+ ((pa_volume_t)((gdouble)(volume) * (gdouble) PA_VOLUME_NORM))
+
+#define _pa_operation_running(wvolume) \
+ (wvolume->pa_operation != NULL && \
+ pa_operation_get_state(wvolume->pa_operation) == PA_OPERATION_RUNNING)
+
+static void _state_cb_init(pa_context *c, void *data);
+
+
+static gchar *_get_client_name(void) {
+ gchar buf[PATH_MAX];
+ gchar *name = NULL;
+
+ if (pa_get_binary_name(buf, sizeof(buf)))
+ name = g_strdup_printf("mafw-gst-renderer[%s]", buf);
+ else
+ name = g_strdup("mafw-gst-renderer");
+
+ return name;
+}
+
+static void _ext_stream_restore_read_cb(pa_context *c,
+ const pa_ext_stream_restore2_info *i,
+ int eol,
+ void *userdata)
+{
+ MafwGstRendererWorkerVolume *wvolume = userdata;
+ gdouble volume;
+ gboolean mute;
+
+ if (eol < 0) {
+ g_critical("eol parameter should not be < 1. "
+ "Discarding volume event");
+ return;
+ }
+
+ if (i == NULL ||
+ strcmp(i->name, MAFW_GST_RENDERER_WORKER_VOLUME_ROLE_PREFIX
+ MAFW_GST_RENDERER_WORKER_VOLUME_ROLE) != 0) {
+ return;
+ }
+
+ volume = _pa_volume_to_per_one(pa_cvolume_max(&i->volume));
+ mute = i->mute != 0 ? TRUE : FALSE;
+
+ if (_pa_operation_running(wvolume) ||
+ (wvolume->pending_operation &&
+ (wvolume->pending_operation_volume != volume
+#ifdef MAFW_GST_RENDERER_ENABLE_MUTE
+ || wvolume->pending_operation_mute != mute
+#endif
+ ))) {
+ g_debug("volume notification, but operation running, ignoring");
+ return;
+ }
+
+ wvolume->pulse_volume = volume;
+ wvolume->pulse_mute = mute;
+
+ /* EMIT VOLUME */
+ g_debug("ext stream volume is %lf (mute: %d) for role %s in device %s",
+ wvolume->pulse_volume, wvolume->pulse_mute, i->name, i->device);
+ if (!wvolume->pending_operation &&
+ wvolume->pulse_volume != wvolume->current_volume) {
+ wvolume->current_volume = wvolume->pulse_volume;
+ if (wvolume->cb != NULL) {
+ g_debug("signalling volume");
+ wvolume->cb(wvolume, wvolume->current_volume,
+ wvolume->user_data);
+ }
+ }
+#ifdef MAFW_GST_RENDERER_ENABLE_MUTE
+ if (!wvolume->pending_operation &&
+ wvolume->pulse_mute != wvolume->current_mute) {
+ wvolume->current_mute = wvolume->pulse_mute;
+ if (wvolume->mute_cb != NULL) {
+ g_debug("signalling mute");
+ wvolume->mute_cb(wvolume, wvolume->current_mute,
+ wvolume->mute_user_data);
+ }
+ }
+#endif
+
+ wvolume->pending_operation = FALSE;
+}
+
+static void _destroy_context(MafwGstRendererWorkerVolume *wvolume)
+{
+ if (wvolume->pa_operation != NULL) {
+ if (pa_operation_get_state(wvolume->pa_operation) ==
+ PA_OPERATION_RUNNING) {
+ pa_operation_cancel(wvolume->pa_operation);
+ }
+ pa_operation_unref(wvolume->pa_operation);
+ wvolume->pa_operation = NULL;
+ }
+ pa_context_unref(wvolume->context);
+}
+
+static InitCbClosure *_init_cb_closure_new(MafwGstRendererWorkerVolume *wvolume,
+ MafwGstRendererWorkerVolumeInitCb cb,
+ gpointer user_data)
+{
+ InitCbClosure *closure;
+
+ closure = g_new(InitCbClosure, 1);
+ closure->wvolume = wvolume;
+ closure->cb = cb;
+ closure->user_data = user_data;
+
+ return closure;
+}
+
+static void _connect(gpointer user_data)
+{
+ gchar *name = NULL;
+ pa_mainloop_api *api = NULL;
+ InitCbClosure *closure = user_data;
+ MafwGstRendererWorkerVolume *wvolume = closure->wvolume;
+
+ name = _get_client_name();
+
+ /* get the mainloop api and create a context */
+ api = pa_glib_mainloop_get_api(wvolume->mainloop);
+ wvolume->context = pa_context_new(api, name);
+ g_assert(wvolume->context != NULL);
+
+ /* register some essential callbacks */
+ pa_context_set_state_callback(wvolume->context, _state_cb_init,
+ closure);
+
+ g_debug("connecting to pulse");
+
+ g_assert(pa_context_connect(wvolume->context,
+ MAFW_GST_RENDERER_WORKER_VOLUME_SERVER,
+ PA_CONTEXT_NOAUTOSPAWN | PA_CONTEXT_NOFAIL,
+ NULL) >= 0);
+ g_free(name);
+}
+
+static gboolean _reconnect(gpointer user_data)
+{
+ InitCbClosure *closure = user_data;
+ MafwGstRendererWorkerVolume *wvolume = closure->wvolume;
+
+ g_warning("got disconnected from pulse, reconnecting");
+ _destroy_context(wvolume);
+ _connect(user_data);
+
+ return FALSE;
+}
+
+static void
+_state_cb(pa_context *c, void *data)
+{
+ MafwGstRendererWorkerVolume *wvolume = data;
+ pa_context_state_t state;
+
+ state = pa_context_get_state(c);
+
+ switch (state) {
+ case PA_CONTEXT_TERMINATED:
+ case PA_CONTEXT_FAILED:
+ {
+ InitCbClosure *closure;
+
+ closure = _init_cb_closure_new(wvolume, NULL, NULL);
+ g_idle_add(_reconnect, closure);
+ break;
+ }
+ case PA_CONTEXT_READY: {
+ pa_operation *o;
+
+ o = pa_ext_stream_restore2_read(c, _ext_stream_restore_read_cb,
+ wvolume);
+ g_assert(o != NULL);
+ pa_operation_unref(o);
+
+ break;
+ }
+ default:
+ break;
+ }
+}
+
+static void _ext_stream_restore_read_cb_init(pa_context *c,
+ const pa_ext_stream_restore2_info *i,
+ int eol,
+ void *userdata)
+{
+ InitCbClosure *closure = userdata;
+
+ if (eol < 0) {
+ g_critical("eol parameter should not be < 1");
+ }
+
+ if (i == NULL ||
+ strcmp(i->name, MAFW_GST_RENDERER_WORKER_VOLUME_ROLE_PREFIX
+ MAFW_GST_RENDERER_WORKER_VOLUME_ROLE) != 0)
+ return;
+
+ closure->wvolume->pulse_volume =
+ _pa_volume_to_per_one(pa_cvolume_max(&i->volume));
+ closure->wvolume->pulse_mute = i->mute != 0 ? TRUE : FALSE;
+ closure->wvolume->current_volume = closure->wvolume->pulse_volume;
+ closure->wvolume->current_mute = closure->wvolume->pulse_mute;
+
+ /* NOT EMIT VOLUME, BUT DEBUG */
+ g_debug("ext stream volume is %lf (mute: %d) for role %s in device %s",
+ closure->wvolume->pulse_volume, i->mute, i->name, i->device);
+
+ if (closure->cb != NULL) {
+ g_debug("initialized: returning volume manager");
+ closure->cb(closure->wvolume, closure->user_data);
+ } else {
+ if (closure->wvolume->cb != NULL) {
+ g_debug("signalling volume after reconnection");
+ closure->wvolume->cb(closure->wvolume,
+ closure->wvolume->current_volume,
+ closure->wvolume->user_data);
+ }
+ if (closure->wvolume->mute_cb != NULL) {
+ g_debug("signalling mute after reconnection");
+ closure->wvolume->mute_cb(closure->wvolume,
+ closure->wvolume->
+ current_mute,
+ closure->wvolume->
+ mute_user_data);
+ }
+ }
+
+ pa_context_set_state_callback(closure->wvolume->context, _state_cb,
+ closure->wvolume);
+
+ g_free(closure);
+}
+
+static void _ext_stream_restore_subscribe_cb(pa_context *c, void *userdata)
+{
+ pa_operation *o;
+
+ o = pa_ext_stream_restore2_read(c, _ext_stream_restore_read_cb, userdata);
+ g_assert(o != NULL);
+ pa_operation_unref(o);
+}
+
+static void
+_state_cb_init(pa_context *c, void *data)
+{
+ InitCbClosure *closure = data;
+ MafwGstRendererWorkerVolume *wvolume = closure->wvolume;
+ pa_context_state_t state;
+
+ state = pa_context_get_state(c);
+
+ g_debug("state: %d", state);
+
+ switch (state) {
+ case PA_CONTEXT_TERMINATED:
+ case PA_CONTEXT_FAILED:
+ g_critical("Connection to pulse failed, reconnection in 1 "
+ "second");
+ g_timeout_add_seconds(1, _reconnect, closure);
+ break;
+ case PA_CONTEXT_READY: {
+ pa_operation *o;
+
+ g_debug("PA_CONTEXT_READY");
+
+ o = pa_ext_stream_restore2_read(c,
+ _ext_stream_restore_read_cb_init,
+ closure);
+ g_assert(o != NULL);
+ pa_operation_unref(o);
+
+ pa_ext_stream_restore_set_subscribe_cb(
+ c, _ext_stream_restore_subscribe_cb, wvolume);
+
+ o = pa_ext_stream_restore_subscribe(c, 1, NULL, NULL);
+ g_assert(o != NULL);
+ pa_operation_unref(o);
+
+ break;
+ }
+ default:
+ break;
+ }
+}
+
+static gboolean _destroy_idle(gpointer data)
+{
+ MafwGstRendererWorkerVolume *wvolume = data;
+
+ g_debug("destroying");
+
+ _destroy_context(wvolume);
+ pa_glib_mainloop_free(wvolume->mainloop);
+ g_free(wvolume);
+
+ return FALSE;
+}
+
+static void
+_state_cb_destroy(pa_context *c, void *data)
+{
+ pa_context_state_t state;
+
+ state = pa_context_get_state(c);
+
+ switch (state) {
+ case PA_CONTEXT_TERMINATED:
+ g_idle_add(_destroy_idle, data);
+ break;
+ case PA_CONTEXT_FAILED:
+ g_error("Unexpected problem in volume management");
+ break;
+ default:
+ break;
+ }
+}
+
+static void _success_cb(pa_context *c, int success, void *userdata)
+{
+ if (success == 0) {
+ g_critical("Setting volume to pulse operation failed");
+ }
+}
+
+static void _remove_set_timeout(MafwGstRendererWorkerVolume *wvolume)
+{
+ if (wvolume->change_request_id != 0) {
+ g_source_remove(wvolume->change_request_id);
+ }
+ wvolume->change_request_id = 0;
+}
+
+static gboolean _set_timeout(gpointer data)
+{
+ pa_ext_stream_restore2_info info;
+ pa_ext_stream_restore2_info *infos[1];
+ MafwGstRendererWorkerVolume *wvolume = data;
+
+ if (wvolume->pending_operation) {
+ g_debug("setting volume ignored as there is still a pending "
+ "operation. Waiting till next iteration");
+ } else if (wvolume->pulse_volume != wvolume->current_volume
+#ifdef MAFW_GST_RENDERER_ENABLE_MUTE
+ || wvolume->pulse_mute != wvolume->current_mute
+#endif
+ ) {
+
+ info.name = MAFW_GST_RENDERER_WORKER_VOLUME_ROLE_PREFIX
+ MAFW_GST_RENDERER_WORKER_VOLUME_ROLE;
+ info.channel_map.channels = 1;
+ info.channel_map.map[0] = PA_CHANNEL_POSITION_MONO;
+ info.device = NULL;
+ info.volume_is_absolute = TRUE;
+ infos[0] = &info;
+
+ info.mute = wvolume->current_mute;
+ pa_cvolume_init(&info.volume);
+ pa_cvolume_set(&info.volume, info.channel_map.channels,
+ _pa_volume_from_per_one(wvolume->
+ current_volume));
+
+ g_debug("setting volume to %lf and mute to %d",
+ wvolume->current_volume, wvolume->current_mute);
+
+ if (wvolume->pa_operation != NULL) {
+ pa_operation_unref(wvolume->pa_operation);
+ }
+
+ wvolume->pending_operation = TRUE;
+ wvolume->pending_operation_volume = wvolume->current_volume;
+ wvolume->pending_operation_mute = wvolume->current_mute;
+
+ wvolume->pa_operation = pa_ext_stream_restore2_write(
+ wvolume->context,
+ PA_UPDATE_REPLACE,
+ (const pa_ext_stream_restore2_info*
+ const *)infos,
+ 1, TRUE, _success_cb, wvolume);
+
+ if (wvolume->pa_operation == NULL) {
+ g_critical("NULL operation when writing volume to "
+ "pulse");
+ _remove_set_timeout(wvolume);
+ }
+ } else {
+ g_debug("removing volume timeout");
+ _remove_set_timeout(wvolume);
+ }
+
+ return wvolume->change_request_id != 0;
+}
+
+void mafw_gst_renderer_worker_volume_init(GMainContext *main_context,
+ MafwGstRendererWorkerVolumeInitCb cb,
+ gpointer user_data,
+ MafwGstRendererWorkerVolumeChangedCb
+ changed_cb,
+ gpointer changed_user_data,
+ MafwGstRendererWorkerVolumeMuteCb
+ mute_cb, gpointer mute_user_data)
+{
+ MafwGstRendererWorkerVolume *wvolume = NULL;
+ InitCbClosure *closure;
+
+ g_return_if_fail(cb != NULL);
+
+ g_assert(g_setenv(MAFW_GST_RENDERER_WORKER_VOLUME_ROLE_PROPERTY,
+ MAFW_GST_RENDERER_WORKER_VOLUME_ROLE, FALSE));
+
+ g_debug("initializing volume manager");
+
+ wvolume = g_new0(MafwGstRendererWorkerVolume, 1);
+
+ wvolume->pulse_volume = 1.0;
+ wvolume->pulse_mute = FALSE;
+ wvolume->cb = changed_cb;
+ wvolume->user_data = changed_user_data;
+ wvolume->mute_cb = mute_cb;
+ wvolume->mute_user_data = mute_user_data;
+
+ wvolume->mainloop = pa_glib_mainloop_new(main_context);
+ g_assert(wvolume->mainloop != NULL);
+
+ closure = _init_cb_closure_new(wvolume, cb, user_data);
+ _connect(closure);
+}
+
+void mafw_gst_renderer_worker_volume_set(MafwGstRendererWorkerVolume *wvolume,
+ gdouble volume, gboolean mute)
+{
+ gboolean signal_volume, signal_mute;
+
+ g_return_if_fail(wvolume != NULL);
+ g_return_if_fail(pa_context_get_state(wvolume->context) ==
+ PA_CONTEXT_READY);
+
+#ifndef MAFW_GST_RENDERER_ENABLE_MUTE
+ mute = FALSE;
+#endif
+
+ signal_volume = wvolume->current_volume != volume &&
+ wvolume->cb != NULL;
+ signal_mute = wvolume->current_mute != mute && wvolume->mute_cb != NULL;
+
+ wvolume->current_volume = volume;
+ wvolume->current_mute = mute;
+
+ g_debug("volume set: %lf (mute %d)", volume, mute);
+
+ if (signal_volume) {
+ g_debug("signalling volume");
+ wvolume->cb(wvolume, volume, wvolume->user_data);
+ }
+
+ if (signal_mute) {
+ g_debug("signalling mute");
+ wvolume->mute_cb(wvolume, mute, wvolume->mute_user_data);
+ }
+
+ if ((signal_mute || signal_volume) && wvolume->change_request_id == 0) {
+ wvolume->change_request_id =
+ g_timeout_add(MAFW_GST_RENDERER_WORKER_SET_TIMEOUT,
+ _set_timeout, wvolume);
+
+ _set_timeout(wvolume);
+ }
+}
+
+gdouble mafw_gst_renderer_worker_volume_get(
+ MafwGstRendererWorkerVolume *wvolume)
+{
+ g_return_val_if_fail(wvolume != NULL, 0.0);
+
+ g_debug("getting volume; %lf", wvolume->current_volume);
+
+ return wvolume->current_volume;
+}
+
+gboolean mafw_gst_renderer_worker_volume_is_muted(
+ MafwGstRendererWorkerVolume *wvolume)
+{
+ g_return_val_if_fail(wvolume != NULL, FALSE);
+
+ g_debug("getting mute; %d", wvolume->current_mute);
+
+ return wvolume->current_mute;
+}
+
+void mafw_gst_renderer_worker_volume_destroy(
+ MafwGstRendererWorkerVolume *wvolume)
+{
+ g_return_if_fail(wvolume != NULL);
+
+ g_debug("disconnecting");
+
+ pa_ext_stream_restore_set_subscribe_cb(wvolume->context, NULL, NULL);
+ pa_context_set_state_callback(wvolume->context, _state_cb_destroy,
+ wvolume);
+ pa_context_disconnect(wvolume->context);
+}
+
+
+
+#else
+
+
+#include "mafw-gst-renderer-worker-volume.h"
+
+#undef G_LOG_DOMAIN
+#define G_LOG_DOMAIN "mafw-gst-renderer-worker-volume-fake"
+
+struct _MafwGstRendererWorkerVolume {
+ MafwGstRendererWorkerVolumeChangedCb cb;
+ gpointer user_data;
+ MafwGstRendererWorkerVolumeMuteCb mute_cb;
+ gpointer mute_user_data;
+ gdouble current_volume;
+ gboolean current_mute;
+};
+
+typedef struct {
+ MafwGstRendererWorkerVolume *wvolume;
+ MafwGstRendererWorkerVolumeInitCb cb;
+ gpointer user_data;
+} InitCbClosure;
+
+static gboolean _init_cb_closure(gpointer user_data)
+{
+ InitCbClosure *closure = user_data;
+
+ if (closure->cb != NULL) {
+ closure->cb(closure->wvolume, closure->user_data);
+ }
+ g_free(closure);
+
+ return FALSE;
+}
+
+void mafw_gst_renderer_worker_volume_init(GMainContext *main_context,
+ MafwGstRendererWorkerVolumeInitCb cb,
+ gpointer user_data,
+ MafwGstRendererWorkerVolumeChangedCb
+ changed_cb,
+ gpointer changed_user_data,
+ MafwGstRendererWorkerVolumeMuteCb
+ mute_cb, gpointer mute_user_data)
+{
+ MafwGstRendererWorkerVolume *wvolume = NULL;
+ InitCbClosure *closure;
+
+ g_return_if_fail(cb != NULL);
+
+ g_debug("initializing volume manager");
+
+ wvolume = g_new0(MafwGstRendererWorkerVolume, 1);
+
+ wvolume->cb = changed_cb;
+ wvolume->user_data = changed_user_data;
+ wvolume->mute_cb = mute_cb;
+ wvolume->mute_user_data = mute_user_data;
+ wvolume->current_volume = 0.485;
+
+ closure = g_new0(InitCbClosure, 1);
+ closure->wvolume = wvolume;
+ closure->cb = cb;
+ closure->user_data = user_data;
+ g_idle_add(_init_cb_closure, closure);
+}
+
+void mafw_gst_renderer_worker_volume_set(MafwGstRendererWorkerVolume *wvolume,
+ gdouble volume, gboolean mute)
+{
+ gboolean signal_volume, signal_mute;
+
+ g_return_if_fail(wvolume != NULL);
+
+#ifndef MAFW_GST_RENDERER_ENABLE_MUTE
+ mute = FALSE;
+#endif
+
+ signal_volume = wvolume->current_volume != volume &&
+ wvolume->cb != NULL;
+ signal_mute = wvolume->current_mute != mute && wvolume->mute_cb != NULL;
+
+ wvolume->current_volume = volume;
+ wvolume->current_mute = mute;
+
+ g_debug("volume set: %lf (mute %d)", volume, mute);
+
+ if (signal_volume) {
+ g_debug("signalling volume");
+ wvolume->cb(wvolume, volume, wvolume->user_data);
+ }
+
+ if (signal_mute) {
+ g_debug("signalling mute");
+ wvolume->mute_cb(wvolume, mute, wvolume->mute_user_data);
+ }
+}
+
+gdouble mafw_gst_renderer_worker_volume_get(
+ MafwGstRendererWorkerVolume *wvolume)
+{
+ g_return_val_if_fail(wvolume != NULL, 0.0);
+
+ g_debug("getting volume; %lf", wvolume->current_volume);
+
+ return wvolume->current_volume;
+}
+
+gboolean mafw_gst_renderer_worker_volume_is_muted(
+ MafwGstRendererWorkerVolume *wvolume)
+{
+ g_return_val_if_fail(wvolume != NULL, FALSE);
+
+ g_debug("getting mute; %d", wvolume->current_mute);
+
+ return wvolume->current_mute;
+}
+
+void mafw_gst_renderer_worker_volume_destroy(
+ MafwGstRendererWorkerVolume *wvolume)
+{
+ g_return_if_fail(wvolume != NULL);
+
+ g_free(wvolume);
+}
+
+#endif
projects / mafwsubrenderer / blobdiff