enum {
SUBCOMMAND_TEST,
+ SUBCOMMAND_PLAY_SAMPLE,
+ SUBCOMMAND_PLAY_SAMPLE_CONTINUOUSLY,
SUBCOMMAND_MONO,
SUBCOMMAND_BALANCE,
+ SUBCOMMAND_MUTEALL,
+ SUBCOMMAND_SET_USE_CASE,
+ SUBCOMMAND_SET_SESSION,
+ SUBCOMMAND_SET_SUBSESSION,
+ SUBCOMMAND_SET_ACTIVE_DEVICE,
+ SUBCOMMAND_RESET,
+ SUBCOMMAND_GET_VOLUME_LEVEL_MAX,
+ SUBCOMMAND_GET_VOLUME_LEVEL,
+ SUBCOMMAND_SET_VOLUME_LEVEL,
+ SUBCOMMAND_UPDATE_VOLUME,
+ SUBCOMMAND_GET_MUTE,
+ SUBCOMMAND_SET_MUTE,
+ SUBCOMMAND_IS_AVAILABLE_HIGH_LATENCY,
+ SUBCOMMAND_UNLOAD_HDMI,
+
};
static void ext_policy_test_cb(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
return o;
}
+static void ext_policy_play_sample_cb(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata)
+{
+ pa_operation *o = userdata;
+ uint32_t stream_index = 0;
+
+ pa_assert(pd);
+ pa_assert(o);
+ pa_assert(PA_REFCNT_VALUE(o) >= 1);
+
+ if (!o->context)
+ goto finish;
+
+ if (command != PA_COMMAND_REPLY) {
+ if (pa_context_handle_error(o->context, command, t, FALSE) < 0)
+ goto finish;
+
+ } else {
+ while (!pa_tagstruct_eof(t)) {
+ if (pa_tagstruct_getu32(t, &stream_index) < 0) {
+ pa_context_fail(o->context, PA_ERR_PROTOCOL);
+ pa_log_error("play_sample : context fail");
+ goto finish;
+ }
+ }
+ }
+
+ if (o->callback) {
+ pa_ext_policy_play_sample_cb_t cb = (pa_ext_policy_play_sample_cb_t) o->callback;
+ cb(o->context, stream_index, o->userdata);
+ }
+
+finish:
+ pa_operation_done(o);
+ pa_operation_unref(o);
+}
+
+pa_operation *pa_ext_policy_play_sample (
+ pa_context *c,
+ const char *name,
+ uint32_t volume_type,
+ uint32_t gain_type,
+ uint32_t volume_level,
+ pa_ext_policy_play_sample_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_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-policy");
+ pa_tagstruct_putu32(t, SUBCOMMAND_PLAY_SAMPLE);
+
+ pa_tagstruct_puts(t, name);
+ pa_tagstruct_putu32(t, volume_type);
+ pa_tagstruct_putu32(t, (gain_type >> 8));
+ pa_tagstruct_putu32(t, volume_level);
+
+ pa_pstream_send_tagstruct(c->pstream, t);
+ pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, ext_policy_play_sample_cb, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
+
+ return o;
+}
+
+#ifdef BURST_SHOT
+pa_operation *pa_ext_policy_play_sample_continuously (
+ pa_context *c,
+ const char *name,
+ int start,
+ uint32_t volume_type,
+ uint32_t gain_type,
+ uint32_t volume_level,
+ pa_usec_t interval,
+ pa_ext_policy_play_sample_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_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-policy");
+ pa_tagstruct_putu32(t, SUBCOMMAND_PLAY_SAMPLE_CONTINUOUSLY);
+
+ pa_tagstruct_puts(t, name);
+ pa_tagstruct_put_boolean(t, !!start);
+ pa_tagstruct_putu32(t, volume_type);
+ pa_tagstruct_putu32(t, (gain_type >> 8));
+ pa_tagstruct_putu32(t, volume_level);
+ pa_tagstruct_put_usec(t, interval);
+
+ pa_pstream_send_tagstruct(c->pstream, t);
+ pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, ext_policy_play_sample_cb, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
+
+ return o;
+}
+
+#endif
+
pa_operation *pa_ext_policy_set_mono (
pa_context *c,
int enable,
return o;
}
+pa_operation *pa_ext_policy_set_muteall (
+ pa_context *c,
+ int enable,
+ 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_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-policy");
+ pa_tagstruct_putu32(t, SUBCOMMAND_MUTEALL);
+ pa_tagstruct_put_boolean(t, !!enable);
+
+ 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;
+}
+
+
+pa_operation *pa_ext_policy_set_use_case (
+ pa_context *c,
+ const char *verb,
+ const char *devices[],
+ const int num_devices,
+ const char *modifiers[],
+ const int num_modifiers,
+ pa_context_success_cb_t cb,
+ void *userdata) {
+
+ uint32_t tag;
+ pa_operation *o = NULL;
+ pa_tagstruct *t = NULL;
+ int i = 0;
+
+ pa_assert(c);
+ pa_assert(PA_REFCNT_VALUE(c) >= 1);
+
+ 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-policy");
+ pa_tagstruct_putu32(t, SUBCOMMAND_SET_USE_CASE);
+
+ pa_tagstruct_puts(t, verb);
+
+ pa_log_info("verb: %s", verb);
+ pa_tagstruct_putu32(t, num_devices);
+
+ for(i = 0; i < num_devices; i++) {
+ pa_tagstruct_puts(t, devices[i]);
+ pa_log_error("device: %s", devices[i]);
+ }
+
+ pa_tagstruct_putu32(t, num_modifiers);
+ for(i = 0; i < num_modifiers; i++) {
+ pa_tagstruct_puts(t, modifiers[i]);
+ pa_log_error("modifier: %s", modifiers[i]);
+ }
+ 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;
+}
+
+pa_operation *pa_ext_policy_set_session (
+ pa_context *c,
+ uint32_t session,
+ uint32_t start,
+ 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_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-policy");
+ pa_tagstruct_putu32(t, SUBCOMMAND_SET_SESSION);
+
+ pa_tagstruct_putu32(t, session);
+ pa_tagstruct_putu32(t, start);
+
+ 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;
+}
+
+pa_operation *pa_ext_policy_set_subsession (
+ pa_context *c,
+ uint32_t subsession,
+ uint32_t subsession_opt,
+ 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_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-policy");
+ pa_tagstruct_putu32(t, SUBCOMMAND_SET_SUBSESSION);
+
+ pa_tagstruct_putu32(t, subsession);
+ pa_tagstruct_putu32(t, subsession_opt);
+
+ 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;
+}
+
+static void ext_policy_set_active_device_cb(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata)
+{
+ pa_operation *o = userdata;
+ int success = 1;
+ uint32_t need_update = 0;
+ uint32_t index = 0;
+
+ pa_assert(pd);
+ pa_assert(o);
+ pa_assert(PA_REFCNT_VALUE(o) >= 1);
+
+ if (!o->context)
+ goto finish;
+
+ if (command != PA_COMMAND_REPLY) {
+ if (pa_context_handle_error(o->context, command, t, FALSE) < 0)
+ goto finish;
+
+ success = 0;
+ } else {
+ while (!pa_tagstruct_eof(t)) {
+ if (pa_tagstruct_getu32(t, &need_update) < 0) {
+ pa_context_fail(o->context, PA_ERR_PROTOCOL);
+ pa_log_error("get_mute : context fail");
+ goto finish;
+ }
+ index++;
+ }
+ }
+
+ if (o->callback) {
+ pa_ext_policy_set_active_device_cb_t cb = (pa_ext_policy_get_mute_cb_t) o->callback;
+ cb(o->context, success, need_update, o->userdata);
+ }
+
+finish:
+ pa_operation_done(o);
+ pa_operation_unref(o);
+}
+
+pa_operation *pa_ext_policy_set_active_device (
+ pa_context *c,
+ uint32_t device_in,
+ uint32_t device_out,
+ pa_ext_policy_set_active_device_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_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-policy");
+ pa_tagstruct_putu32(t, SUBCOMMAND_SET_ACTIVE_DEVICE);
+
+ pa_tagstruct_putu32(t, device_in);
+ pa_tagstruct_putu32(t, device_out);
+
+ pa_pstream_send_tagstruct(c->pstream, t);
+ pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, ext_policy_set_active_device_cb, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
+
+ return o;
+}
+
+pa_operation *pa_ext_policy_reset (
+ pa_context *c,
+ 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_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-policy");
+ pa_tagstruct_putu32(t, SUBCOMMAND_RESET);
+
+ 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;
+}
+
+static void ext_policy_get_volume_level_max_cb(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata)
+{
+ pa_operation *o = userdata;
+ uint32_t volume_level = 0;
+
+ pa_assert(pd);
+ pa_assert(o);
+ pa_assert(PA_REFCNT_VALUE(o) >= 1);
+
+ if (!o->context)
+ goto finish;
+
+ if (command != PA_COMMAND_REPLY) {
+ if (pa_context_handle_error(o->context, command, t, FALSE) < 0)
+ goto finish;
+
+ } else {
+ while (!pa_tagstruct_eof(t)) {
+ if (pa_tagstruct_getu32(t, &volume_level) < 0) {
+ pa_context_fail(o->context, PA_ERR_PROTOCOL);
+ pa_log_error("get_volume_level_max : context fail");
+ goto finish;
+ }
+ }
+ }
+
+ if (o->callback) {
+ pa_ext_policy_get_volume_level_max_cb_t cb = (pa_ext_policy_get_volume_level_max_cb_t) o->callback;
+ cb(o->context, volume_level, o->userdata);
+ }
+
+finish:
+ pa_operation_done(o);
+ pa_operation_unref(o);
+}
+
+pa_operation *pa_ext_policy_get_volume_level_max (
+ pa_context *c,
+ uint32_t volume_type,
+ pa_ext_policy_get_volume_level_max_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_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-policy");
+ pa_tagstruct_putu32(t, SUBCOMMAND_GET_VOLUME_LEVEL_MAX);
+
+ pa_tagstruct_putu32(t, volume_type);
+
+ pa_pstream_send_tagstruct(c->pstream, t);
+ pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, ext_policy_get_volume_level_max_cb, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
+
+ return o;
+}
+
+static void ext_policy_get_volume_level_cb(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata)
+{
+ pa_operation *o = userdata;
+ uint32_t volume_level = 0;
+
+ pa_assert(pd);
+ pa_assert(o);
+ pa_assert(PA_REFCNT_VALUE(o) >= 1);
+
+ if (!o->context)
+ goto finish;
+
+ if (command != PA_COMMAND_REPLY) {
+ if (pa_context_handle_error(o->context, command, t, FALSE) < 0)
+ goto finish;
+
+ } else {
+ while (!pa_tagstruct_eof(t)) {
+ if (pa_tagstruct_getu32(t, &volume_level) < 0) {
+ pa_context_fail(o->context, PA_ERR_PROTOCOL);
+ pa_log_error("get_volume_level : context fail");
+ goto finish;
+ }
+ }
+ }
+
+ if (o->callback) {
+ pa_ext_policy_get_volume_level_cb_t cb = (pa_ext_policy_get_volume_level_cb_t) o->callback;
+ cb(o->context, volume_level, o->userdata);
+ }
+
+finish:
+ pa_operation_done(o);
+ pa_operation_unref(o);
+}
+
+pa_operation *pa_ext_policy_get_volume_level (
+ pa_context *c,
+ uint32_t stream_idx,
+ uint32_t volume_type,
+ pa_ext_policy_get_volume_level_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_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-policy");
+ pa_tagstruct_putu32(t, SUBCOMMAND_GET_VOLUME_LEVEL);
+
+ pa_tagstruct_putu32(t, stream_idx);
+ pa_tagstruct_putu32(t, volume_type);
+
+ pa_pstream_send_tagstruct(c->pstream, t);
+ pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, ext_policy_get_volume_level_cb, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
+
+ return o;
+}
+
+pa_operation *pa_ext_policy_set_volume_level (
+ pa_context *c,
+ uint32_t stream_idx,
+ uint32_t volume_type,
+ uint32_t volume_level,
+ 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_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-policy");
+ pa_tagstruct_putu32(t, SUBCOMMAND_SET_VOLUME_LEVEL);
+
+ pa_tagstruct_putu32(t, stream_idx);
+ pa_tagstruct_putu32(t, volume_type);
+ pa_tagstruct_putu32(t, volume_level);
+
+ 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;
+}
+
+pa_operation *pa_ext_policy_update_volume (
+ pa_context *c,
+ 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_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-policy");
+ pa_tagstruct_putu32(t, SUBCOMMAND_UPDATE_VOLUME);
+
+ 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;
+}
+
+static void ext_policy_get_mute_cb(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata)
+{
+ pa_operation *o = userdata;
+ uint32_t mute = 0;
+
+ pa_assert(pd);
+ pa_assert(o);
+ pa_assert(PA_REFCNT_VALUE(o) >= 1);
+
+ if (!o->context)
+ goto finish;
+
+ if (command != PA_COMMAND_REPLY) {
+ if (pa_context_handle_error(o->context, command, t, FALSE) < 0)
+ goto finish;
+
+ } else {
+ while (!pa_tagstruct_eof(t)) {
+ if (pa_tagstruct_getu32(t, &mute) < 0) {
+ pa_context_fail(o->context, PA_ERR_PROTOCOL);
+ pa_log_error("get_mute : context fail");
+ goto finish;
+ }
+ }
+ }
+
+ if (o->callback) {
+ pa_ext_policy_get_mute_cb_t cb = (pa_ext_policy_get_mute_cb_t) o->callback;
+ cb(o->context, mute, o->userdata);
+ }
+
+finish:
+ pa_operation_done(o);
+ pa_operation_unref(o);
+}
+
+pa_operation *pa_ext_policy_get_mute (
+ pa_context *c,
+ uint32_t stream_idx,
+ uint32_t volume_type,
+ uint32_t direction,
+ pa_ext_policy_get_mute_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_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-policy");
+ pa_tagstruct_putu32(t, SUBCOMMAND_GET_MUTE);
+
+ pa_tagstruct_putu32(t, stream_idx);
+ pa_tagstruct_putu32(t, volume_type);
+ pa_tagstruct_putu32(t, direction);
+
+ pa_pstream_send_tagstruct(c->pstream, t);
+ pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, ext_policy_get_mute_cb, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
+
+ return o;
+}
+
+pa_operation *pa_ext_policy_set_mute (
+ pa_context *c,
+ uint32_t stream_idx,
+ uint32_t volume_type,
+ uint32_t direction,
+ uint32_t mute,
+ 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_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-policy");
+ pa_tagstruct_putu32(t, SUBCOMMAND_SET_MUTE);
+
+ pa_tagstruct_putu32(t, stream_idx);
+ pa_tagstruct_putu32(t, volume_type);
+ pa_tagstruct_putu32(t, direction);
+ pa_tagstruct_putu32(t, 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;
+}
+
+static void ext_policy_is_available_high_latency_cb(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata)
+{
+ pa_operation *o = userdata;
+ uint32_t available = 0;
+
+ pa_assert(pd);
+ pa_assert(o);
+ pa_assert(PA_REFCNT_VALUE(o) >= 1);
+
+ if (!o->context)
+ goto finish;
+
+ if (command != PA_COMMAND_REPLY) {
+ if (pa_context_handle_error(o->context, command, t, FALSE) < 0)
+ goto finish;
+
+ } else {
+ while (!pa_tagstruct_eof(t)) {
+ if (pa_tagstruct_getu32(t, &available) < 0) {
+ pa_context_fail(o->context, PA_ERR_PROTOCOL);
+ pa_log_error("is_available_high_latency : context fail");
+ goto finish;
+ }
+ }
+ }
+
+ if (o->callback) {
+ pa_ext_policy_is_available_high_latency_cb_t cb = (pa_ext_policy_is_available_high_latency_cb_t) o->callback;
+ cb(o->context, available, o->userdata);
+ }
+
+finish:
+ pa_operation_done(o);
+ pa_operation_unref(o);
+}
+
+pa_operation *pa_ext_policy_is_available_high_latency (
+ pa_context *c,
+ pa_ext_policy_is_available_high_latency_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_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-policy");
+ pa_tagstruct_putu32(t, SUBCOMMAND_IS_AVAILABLE_HIGH_LATENCY);
+
+ pa_pstream_send_tagstruct(c->pstream, t);
+ pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, ext_policy_is_available_high_latency_cb, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
+
+ return o;
+}
+
+pa_operation *pa_ext_policy_unload_hdmi (
+ pa_context *c,
+ 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_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-policy");
+ pa_tagstruct_putu32(t, SUBCOMMAND_UNLOAD_HDMI);
+
+ 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;
+}
PA_C_DECL_BEGIN
+typedef enum {
+ PA_TIZEN_SESSION_MEDIA,
+ PA_TIZEN_SESSION_VOICECALL,
+ PA_TIZEN_SESSION_VIDEOCALL,
+ PA_TIZEN_SESSION_VOIP,
+ PA_TIZEN_SESSION_FMRADIO,
+ PA_TIZEN_SESSION_CAMCORDER,
+ PA_TIZEN_SESSION_NOTIFICATION,
+ PA_TIZEN_SESSION_ALARM,
+ PA_TIZEN_SESSION_EMERGENCY,
+ PA_TIZEN_SESSION_VOICE_RECOGNITION,
+ PA_TIZEN_SESSION_MAX
+} pa_tizen_session_t;
+
+typedef enum {
+ PA_TIZEN_SUBSESSION_NONE,
+ PA_TIZEN_SUBSESSION_VOICE,
+ PA_TIZEN_SUBSESSION_RINGTONE,
+ PA_TIZEN_SUBSESSION_MEDIA,
+ PA_TIZEN_SUBSESSION_VR_INIT,
+ PA_TIZEN_SUBSESSION_VR_NORMAL,
+ PA_TIZEN_SUBSESSION_VR_DRIVE,
+ PA_TIZEN_SUBSESSION_STEREO_REC,
+ PA_TIZEN_SUBSESSION_MONO_REC,
+ PA_TIZEN_SUBSESSION_MAX
+} pa_tizen_subsession_t;
+
+typedef enum {
+ PA_TIZEN_DEVICE_IN_NONE,
+ PA_TIZEN_DEVICE_IN_MIC, /**< Device builtin mic. */
+ PA_TIZEN_DEVICE_IN_WIRED_ACCESSORY, /**< Wired input devices */
+ PA_TIZEN_DEVICE_IN_BT_SCO, /**< Bluetooth SCO device */
+} pa_tizen_device_in_t;
+
+typedef enum pa_tizen_device_out {
+ PA_TIZEN_DEVICE_OUT_NONE,
+ PA_TIZEN_DEVICE_OUT_SPEAKER, /**< Device builtin speaker */
+ PA_TIZEN_DEVICE_OUT_RECEIVER, /**< Device builtin receiver */
+ PA_TIZEN_DEVICE_OUT_WIRED_ACCESSORY, /**< Wired output devices such as headphone, headset, and so on. */
+ PA_TIZEN_DEVICE_OUT_BT_SCO, /**< Bluetooth SCO device */
+ PA_TIZEN_DEVICE_OUT_BT_A2DP, /**< Bluetooth A2DP device */
+ PA_TIZEN_DEVICE_OUT_DOCK, /**< DOCK device */
+ PA_TIZEN_DEVICE_OUT_HDMI, /**< HDMI device */
+ PA_TIZEN_DEVICE_OUT_MIRRORING, /**< MIRRORING device */
+ PA_TIZEN_DEVICE_OUT_USB_AUDIO, /**< USB Audio device */
+ PA_TIZEN_DEVICE_OUT_MULTIMEDIA_DOCK, /**< Multimedia DOCK device */
+} pa_tizen_device_out_t;
+
+typedef enum pa_tizen_volume_type {
+ PA_TIZEN_VOLUME_TYPE_SYSTEM, /**< System volume type */
+ PA_TIZEN_VOLUME_TYPE_NOTIFICATION, /**< Notification volume type */
+ PA_TIZEN_VOLUME_TYPE_ALARM, /**< Alarm volume type */
+ PA_TIZEN_VOLUME_TYPE_RINGTONE, /**< Ringtone volume type */
+ PA_TIZEN_VOLUME_TYPE_MEDIA, /**< Media volume type */
+ PA_TIZEN_VOLUME_TYPE_CALL, /**< Call volume type */
+ PA_TIZEN_VOLUME_TYPE_VOIP, /**< VOIP volume type */
+ PA_TIZEN_VOLUME_TYPE_VOICE, /**< VOICE volume type */
+ PA_TIZEN_VOLUME_TYPE_FIXED, /**< Volume type for fixed acoustic level */
+ PA_TIZEN_VOLUME_TYPE_MAX, /**< Volume type count */
+ PA_TIZEN_VOLUME_TYPE_DEFAULT = PA_TIZEN_VOLUME_TYPE_SYSTEM,
+} pa_tizen_volume_type_t;
+
+typedef enum pa_tizen_gain_type {
+ PA_TIZEN_GAIN_TYPE_DEFAULT,
+ PA_TIZEN_GAIN_TYPE_DIALER,
+ PA_TIZEN_GAIN_TYPE_TOUCH,
+ PA_TIZEN_GAIN_TYPE_AF,
+ PA_TIZEN_GAIN_TYPE_SHUTTER1,
+ PA_TIZEN_GAIN_TYPE_SHUTTER2,
+ PA_TIZEN_GAIN_TYPE_CAMCODING,
+ PA_TIZEN_GAIN_TYPE_MIDI,
+ PA_TIZEN_GAIN_TYPE_BOOTING,
+ PA_TIZEN_GAIN_TYPE_VIDEO,
+ PA_TIZEN_GAIN_TYPE_MAX,
+} pa_tizen_gain_type_t;
+
+#define PA_TIZEN_VOLUME_TYPE_LEVEL_MAX 15
+
/** Callback prototype for pa_ext_policy_test(). \since 0.9.21 */
typedef void (*pa_ext_policy_test_cb_t)(
pa_context *c,
pa_ext_policy_test_cb_t cb,
void *userdata);
+/** Callback prototype for pa_ext_policy_play_sample(). \since 0.9.21 */
+typedef void (*pa_ext_policy_play_sample_cb_t)(
+ pa_context *c,
+ uint32_t stream_index,
+ void *userdata);
+
+/* Similar with pa_context_play_sample, but can apply volume type */
+pa_operation *pa_ext_policy_play_sample (
+ pa_context *c,
+ const char *name,
+ uint32_t volume_type,
+ uint32_t gain_type,
+ uint32_t volume_level,
+ pa_ext_policy_play_sample_cb_t cb,
+ void *userdata);
+
+#ifdef BURST_SHOT
+/* make one sink-input and then push burst cam-shutter sound. */
+pa_operation *pa_ext_policy_play_sample_continuously (
+ pa_context *c,
+ const char *name,
+ int start, /* start/stop */
+ uint32_t volume_type,
+ uint32_t gain_type,
+ uint32_t volume_level,
+ pa_usec_t interval, /* timeout_cb interval */
+ pa_ext_policy_play_sample_cb_t cb,
+ void *userdata);
+#endif
+
/** Enable the mono mode. \since 0.9.21 */
pa_operation *pa_ext_policy_set_mono (
pa_context *c,
pa_context_success_cb_t cb,
void *userdata);
+/** Enable the muteall mode. \since 0.9.21 */
+pa_operation *pa_ext_policy_set_muteall (
+ pa_context *c,
+ int enable,
+ pa_context_success_cb_t cb,
+ void *userdata);
+
+pa_operation *pa_ext_policy_set_use_case (
+ pa_context *c,
+ const char *verb,
+ const char *devices[],
+ const int num_devices,
+ const char *modifiers[],
+ const int num_modifiers,
+ pa_context_success_cb_t cb,
+ void *userdata);
+
+pa_operation *pa_ext_policy_set_session (
+ pa_context *c,
+ uint32_t session,
+ uint32_t start,
+ pa_context_success_cb_t cb,
+ void *userdata);
+
+pa_operation *pa_ext_policy_set_subsession (
+ pa_context *c,
+ uint32_t subsession,
+ uint32_t subsession_opt,
+ pa_context_success_cb_t cb,
+ void *userdata);
+
+typedef void (*pa_ext_policy_set_active_device_cb_t)(
+ pa_context *c,
+ int success,
+ uint32_t need_update,
+ void *userdata);
+
+pa_operation *pa_ext_policy_set_active_device (
+ pa_context *c,
+ uint32_t device_in,
+ uint32_t device_out,
+ pa_ext_policy_set_active_device_cb_t cb,
+ void *userdata);
+
+pa_operation *pa_ext_policy_reset (
+ pa_context *c,
+ pa_context_success_cb_t cb,
+ void *userdata);
+
+/** Callback prototype for pa_ext_policy_get_volume_level_max(). \since 0.9.21 */
+typedef void (*pa_ext_policy_get_volume_level_max_cb_t)(
+ pa_context *c,
+ uint32_t volume_level,
+ void *userdata);
+
+pa_operation *pa_ext_policy_get_volume_level_max (
+ pa_context *c,
+ uint32_t volume_type,
+ pa_ext_policy_get_volume_level_max_cb_t cb,
+ void *userdata);
+
+/** Callback prototype for pa_ext_policy_get_volume_level(). \since 0.9.21 */
+typedef void (*pa_ext_policy_get_volume_level_cb_t)(
+ pa_context *c,
+ uint32_t volume_level,
+ void *userdata);
+
+pa_operation *pa_ext_policy_get_volume_level (
+ pa_context *c,
+ uint32_t stream_idx,
+ uint32_t volume_type,
+ pa_ext_policy_get_volume_level_max_cb_t cb,
+ void *userdata);
+
+pa_operation *pa_ext_policy_set_volume_level (
+ pa_context *c,
+ uint32_t stream_idx,
+ uint32_t volume_type,
+ uint32_t volume_level,
+ pa_context_success_cb_t cb,
+ void *userdata);
+
+pa_operation *pa_ext_policy_update_volume (
+ pa_context *c,
+ pa_context_success_cb_t cb,
+ void *userdata);
+
+/** Callback prototype for pa_ext_policy_get_mute(). \since 0.9.21 */
+typedef void (*pa_ext_policy_get_mute_cb_t)(
+ pa_context *c,
+ uint32_t mute,
+ void *userdata);
+
+pa_operation *pa_ext_policy_get_mute (
+ pa_context *c,
+ uint32_t stream_idx,
+ uint32_t volume_type,
+ uint32_t direction,
+ pa_ext_policy_get_mute_cb_t cb,
+ void *userdata);
+
+pa_operation *pa_ext_policy_set_mute (
+ pa_context *c,
+ uint32_t stream_idx,
+ uint32_t volume_type,
+ uint32_t direction,
+ uint32_t mute,
+ pa_context_success_cb_t cb,
+ void *userdata);
+
+/** Callback prototype for pa_ext_policy_get_mute(). \since 0.9.21 */
+typedef void (*pa_ext_policy_is_available_high_latency_cb_t)(
+ pa_context *c,
+ uint32_t available,
+ void *userdata);
+
+pa_operation *pa_ext_policy_is_available_high_latency (
+ pa_context *c,
+ pa_ext_policy_is_available_high_latency_cb_t cb,
+ void *userdata);
+
+pa_operation *pa_ext_policy_unload_hdmi (
+ pa_context *c,
+ pa_context_success_cb_t cb,
+ void *userdata);
+
PA_C_DECL_END
#endif
#define DEFAULT_PROCESS_MSEC 20 /* 20ms */
#define DEFAULT_FRAGSIZE_MSEC DEFAULT_TLENGTH_MSEC
+#ifdef __TIZEN__
+#define DEVICE_BUS_BUILTIN "builtin"
+#define MEDIA_POLICY_VOIP "voip"
+#endif
+
struct pa_native_protocol;
typedef struct record_stream {
static void command_set_volume(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
static void command_set_mute(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
static void command_cork_playback_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
+#ifdef __TIZEN__
+static void command_cork_playback_stream_all(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
+#endif
static void command_trigger_or_flush_or_prebuf_playback_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
static void command_set_default_sink_or_source(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
+#ifdef __TIZEN__
+static void command_set_default_sink_by_api_bus(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
+static void command_set_default_sink_for_usb(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
+#endif
static void command_set_stream_name(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
static void command_kill(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
static void command_load_module(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
[PA_COMMAND_SUSPEND_SOURCE] = command_suspend,
[PA_COMMAND_CORK_PLAYBACK_STREAM] = command_cork_playback_stream,
+#ifdef __TIZEN__
+ [PA_COMMAND_CORK_PLAYBACK_STREAM_ALL] = command_cork_playback_stream_all,
+#endif
[PA_COMMAND_FLUSH_PLAYBACK_STREAM] = command_trigger_or_flush_or_prebuf_playback_stream,
[PA_COMMAND_TRIGGER_PLAYBACK_STREAM] = command_trigger_or_flush_or_prebuf_playback_stream,
[PA_COMMAND_PREBUF_PLAYBACK_STREAM] = command_trigger_or_flush_or_prebuf_playback_stream,
[PA_COMMAND_FLUSH_RECORD_STREAM] = command_flush_record_stream,
[PA_COMMAND_SET_DEFAULT_SINK] = command_set_default_sink_or_source,
+#ifdef __TIZEN__
+ [PA_COMMAND_SET_DEFAULT_SINK_BY_API_BUS] = command_set_default_sink_by_api_bus,
+ [PA_COMMAND_SET_DEFAULT_SINK_FOR_USB] = command_set_default_sink_for_usb,
+#endif
[PA_COMMAND_SET_DEFAULT_SOURCE] = command_set_default_sink_or_source,
[PA_COMMAND_SET_PLAYBACK_STREAM_NAME] = command_set_stream_name,
[PA_COMMAND_SET_RECORD_STREAM_NAME] = command_set_stream_name,
if (pa_atomic_dec(&s->seek_or_post_in_queue) > 1)
s->seek_windex = windex;
else {
+#ifdef __TIZEN__
+ const char *name = NULL;
+#endif
s->seek_windex = -1;
- handle_seek(s, windex);
+
+#ifdef __TIZEN__
+ name = pa_proplist_gets(i->proplist, PA_PROP_MEDIA_POLICY);
+ if (!name || (name && !pa_streq(name, MEDIA_POLICY_VOIP)))
+ handle_seek(s, windex);
+#else
+ handle_seek(s, windex);
+#endif
}
return 0;
}
handle_seek(ssync, windex);
}
+#ifdef __TIZEN__
+ if (code == SINK_INPUT_MESSAGE_FLUSH) {
+ pa_log_debug("Requesting rewind due to rewrite. Flush old data in sink");
+ pa_sink_input_request_rewind(s->sink_input, 0, FALSE, TRUE, FALSE);
+ }
+#endif
+
if (code == SINK_INPUT_MESSAGE_DRAIN) {
if (!pa_memblockq_is_readable(s->memblockq))
pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(s), PLAYBACK_STREAM_MESSAGE_DRAIN_ACK, userdata, 0, NULL, NULL);
pa_pstream_send_simple_ack(c->pstream, tag);
}
+#ifdef __TIZEN__
+#define SINK_ALSA_NORMAL "alsa_output.0.analog-stereo"
+#define SINK_ALSA_HDMI "alsa_output.1.analog-stereo"
+#define SINK_ALSA_VOIP "alsa_output.3.analog-stereo"
+#define SINK_ALSA_LPA "alsa_output.4.analog-stereo"
+
+#define PROP_MANUAL_CORK "manual_cork_by_device_switch"
+
+static void command_cork_playback_stream_all(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
+ pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
+ uint32_t idx;
+ uint32_t sink_idx;
+ pa_bool_t b;
+ playback_stream *s;
+ pa_sink_input* si;
+ pa_sink* sink;
+ char* role = NULL;
+ int ret;
+ char* is_manual_corked_str = NULL;
+ int is_manual_corked;
+ pa_sink_input_state_t si_state;
+
+ void *state = NULL;
+
+ pa_native_connection_assert_ref(c);
+ pa_assert(t);
+
+ if (pa_tagstruct_get_boolean(t, &b) < 0 ||
+ !pa_tagstruct_eof(t)) {
+ protocol_error(c);
+ return;
+ }
+
+ CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
+
+ pa_log_debug("========================= %s start =========================", b > 0 ? "cork" : "uncork");
+
+ PA_IDXSET_FOREACH(si, c->protocol->core->sink_inputs, idx) {
+ /* Skip this if it is already in the process of being moved
+ * anyway */
+ if (!si->sink)
+ continue;
+
+ /* It might happen that a stream and a sink are set up at the
+ same time, in which case we want to make sure we don't
+ interfere with that */
+ if (!PA_SINK_INPUT_IS_LINKED(pa_sink_input_get_state(si)))
+ continue;
+
+ if ((role = pa_proplist_gets(si->proplist, PA_PROP_MEDIA_ROLE))) {
+ if (pa_streq(role, "filter")) {
+ pa_log_debug("This sink-input [%d] linked to [%s] is FILTER...skip", si->index, (si->sink)? si->sink->name : NULL);
+ continue;
+ }
+ }
+
+ if (pa_streq (si->sink->name, SINK_ALSA_VOIP)) {
+ pa_log_info("Skip sink-input for VOIP sink");
+ continue;
+ }
+
+ if (b) {
+ si_state = pa_sink_input_get_state(si);
+ /* Cork only if sink-input was Running / Drained */
+ if (si_state == PA_SINK_INPUT_RUNNING || si_state == PA_SINK_INPUT_DRAINED) {
+ pa_proplist_sets(si->proplist, PROP_MANUAL_CORK, "1");
+ pa_sink_input_cork(si, TRUE);
+ pa_log_info(" <Cork %d> for sink-input[%d]:sink[%s]", b, si->index, si->sink->name);
+ }
+ } else {
+ /* UnCork if corked by manually */
+ if ((is_manual_corked_str = pa_proplist_gets(si->proplist, PROP_MANUAL_CORK))) {
+ pa_atou(is_manual_corked_str, &is_manual_corked);
+ if (is_manual_corked) {
+ pa_proplist_sets(si->proplist, PROP_MANUAL_CORK, "0");
+ pa_sink_input_cork(si, FALSE);
+ pa_log_info(" <UnCork %d> for sink-input[%d]:sink[%s]", b, si->index, si->sink->name);
+ }
+ }
+ }
+ }
+
+ /* If CORK case, Do manual suspend for ALSA devices */
+ if (b) {
+ PA_IDXSET_FOREACH(sink, c->protocol->core->sinks, sink_idx) {
+ if (pa_streq (sink->name, SINK_ALSA_NORMAL) ||
+ pa_streq (sink->name, SINK_ALSA_LPA) ||
+ pa_streq (sink->name, SINK_ALSA_HDMI)) {
+ pa_log_info("sink[%d][%s] state=[%d], used_by[%d], check_suspend[%d], suspend-cause[0x%x]",
+ sink->index, sink->name, pa_sink_get_state(sink), pa_sink_used_by(sink), pa_sink_check_suspend(sink), sink->suspend_cause);
+
+ /* If sink is Not Suspended and can be suspended, do suspend */
+ if (pa_sink_get_state(sink) != PA_SINK_SUSPENDED && pa_sink_check_suspend(sink) == 0) {
+ ret = pa_sink_suspend (sink, TRUE, PA_SUSPEND_INTERNAL);
+ pa_log_info("suspend result [%d], after suspend-cause[0x%x]", ret, sink->suspend_cause);
+ }
+ }
+ }
+ }
+ pa_log_debug("========================= %s end =========================", b > 0 ? "cork" : "uncork");
+ pa_pstream_send_simple_ack(c->pstream, tag);
+}
+#endif /* __TIZEN__ */
+
static void command_trigger_or_flush_or_prebuf_playback_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
uint32_t idx;
pa_pstream_send_simple_ack(c->pstream, tag);
}
+#ifdef __TIZEN__
+static void command_set_default_sink_by_api_bus(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
+ pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
+ pa_sink *sink;
+ pa_bool_t found = FALSE;
+ const char *api, *bus;
+ const char *api_string, *bus_string, *form_factor;
+ uint32_t idx;
+
+ pa_native_connection_assert_ref(c);
+ pa_assert(t);
+
+ if (pa_tagstruct_gets(t, &api) < 0 ||
+ pa_tagstruct_gets(t, &bus) < 0 ||
+ !pa_tagstruct_eof(t)) {
+ protocol_error(c);
+ return;
+ }
+
+ CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
+ CHECK_VALIDITY(c->pstream, !api || pa_utf8_valid(api), tag, PA_ERR_INVALID);
+ CHECK_VALIDITY(c->pstream, !bus || pa_utf8_valid(bus), tag, PA_ERR_INVALID);
+
+ pa_assert(command == PA_COMMAND_SET_DEFAULT_SINK_BY_API_BUS);
+
+ PA_IDXSET_FOREACH(sink, c->protocol->core->sinks, idx) {
+ if (sink && sink->proplist) {
+ api_string = pa_proplist_gets(sink->proplist, "device.api");
+ if (api_string) {
+ pa_log_debug("Found api = [%s]\n", api_string);
+ if (!strcmp(api, api_string)) {
+ bus_string = pa_proplist_gets(sink->proplist, "device.bus");
+ if (bus_string) {
+ pa_log_debug("Found bus = [%s]\n", bus_string);
+ if(!strcmp(bus, bus_string)) {
+ pa_log_debug(" ** FOUND!!! set default sink to [%s]\n", sink->name);
+ found = TRUE;
+ break;
+ } else {
+ pa_log_debug("No string [%s] match, match with form_factor = internal\n", bus);
+ form_factor = pa_proplist_gets(sink->proplist, PA_PROP_DEVICE_FORM_FACTOR );
+ if (form_factor) {
+ if(!strcmp(form_factor, "internal")) {
+ pa_log_debug("Found internal device(sink) , set (%s) as default sink", sink->name);
+ found = TRUE;
+ break;
+ }
+ }
+ else {
+ pa_log_debug("This device doesn't have form factor property");
+ }
+ }
+ } else {
+ pa_log_debug(" Found no bus ");
+ if (!strcmp(DEVICE_BUS_BUILTIN, bus)) {
+ pa_log_debug(" searching bus was builtin, then select this");
+ found = TRUE;
+ break;
+ }
+ }
+ } else {
+ pa_log_debug("No string [%s] match!!!!\n", api);
+ }
+ }
+
+ }
+ }
+
+ if (!found)
+ sink = NULL;
+
+ CHECK_VALIDITY(c->pstream, sink, tag, PA_ERR_NOENTITY);
+
+ pa_namereg_set_default_sink(c->protocol->core, sink);
+
+ pa_pstream_send_simple_ack(c->pstream, tag);
+}
+
+static void command_set_default_sink_for_usb(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
+ pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
+ pa_sink *sink;
+ pa_bool_t found = FALSE;
+ const char *serial;
+ const char *s;
+ uint32_t idx;
+
+ pa_native_connection_assert_ref(c);
+ pa_assert(t);
+
+ if (pa_tagstruct_gets(t, &s) < 0 ||
+ !pa_tagstruct_eof(t)) {
+ protocol_error(c);
+ return;
+ }
+
+ CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
+ CHECK_VALIDITY(c->pstream, !s || pa_namereg_is_valid_name(s), tag, PA_ERR_INVALID);
+
+ pa_assert(command == PA_COMMAND_SET_DEFAULT_SINK_FOR_USB);
+
+ PA_IDXSET_FOREACH(sink, c->protocol->core->sinks, idx) {
+ if (sink && sink->card && sink->card->proplist) {
+ if ((serial = pa_proplist_gets(sink->card->proplist, PA_PROP_DEVICE_SERIAL)) == NULL) {
+ pa_log_warn(" ** No serial for this sink [%s]", sink->name);
+ continue;
+ }
+
+ if ((found = pa_streq(serial, s))) {
+ pa_log_info(" ** serial [%s] for sink [%s] is matched, set as default sink\n", serial, sink->name);
+ break;
+ } else {
+ pa_log_debug(" ** serial [%s] for sink [%s] is not matched...", serial, sink->name);
+ }
+ }
+ }
+
+ if (!found)
+ sink = NULL;
+
+ CHECK_VALIDITY(c->pstream, sink, tag, PA_ERR_NOENTITY);
+
+ pa_namereg_set_default_sink(c->protocol->core, sink);
+
+ pa_pstream_send_simple_ack(c->pstream, tag);
+}
+
+#endif /* __TIZEN__ */
+
static void command_set_stream_name(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
uint32_t idx;
projects / platform / upstream / pulseaudio.git / commitdiff