From ff392108d7d644aaa7166259c52f6798ede1cc51 Mon Sep 17 00:00:00 2001 From: Seungbae Shin Date: Tue, 27 Oct 2020 20:08:46 +0900 Subject: [PATCH 01/16] device-manager-dbus: fix crash of getting empty supported samplerates/formats [Version] 13.0.34 [Issue Type] Bug Change-Id: I8faab3479f9bf2daa87d0f818b50f1a95e96caeb --- packaging/pulseaudio-modules-tizen.spec | 2 +- src/device-manager-dbus.c | 12 ++++++++++++ 2 files changed, 13 insertions(+), 1 deletion(-) diff --git a/packaging/pulseaudio-modules-tizen.spec b/packaging/pulseaudio-modules-tizen.spec index 0a6f996..638827d 100644 --- a/packaging/pulseaudio-modules-tizen.spec +++ b/packaging/pulseaudio-modules-tizen.spec @@ -1,6 +1,6 @@ Name: pulseaudio-modules-tizen Summary: Pulseaudio modules for Tizen -Version: 13.0.33 +Version: 13.0.34 Release: 0 Group: Multimedia/Audio License: LGPL-2.1+ diff --git a/src/device-manager-dbus.c b/src/device-manager-dbus.c index b9ab071..7190965 100644 --- a/src/device-manager-dbus.c +++ b/src/device-manager-dbus.c @@ -1095,6 +1095,12 @@ static void handle_get_supported_sample_formats(DBusConnection *conn, DBusMessag return; } + if (!sink->supported_sample_formats) { + pa_log_error("supported sample formats is not set on this sink"); + pa_dbus_send_error(conn, msg, DBUS_ERROR_NOT_SUPPORTED, "%s", "org.tizen.multimedia.audio.InvalidOperation"); + return; + } + dbus_message_iter_init_append(reply, &msg_iter); pa_assert_se(dbus_message_iter_open_container(&msg_iter, DBUS_TYPE_ARRAY, "s", &array_iter)); for (i = 0; sink->supported_sample_formats[i] != PA_SAMPLE_MAX; i++) { @@ -1268,6 +1274,12 @@ static void handle_get_supported_sample_rates(DBusConnection *conn, DBusMessage return; } + if (!sink->supported_sample_rates) { + pa_log_error("supported sample rates is not set on this sink"); + pa_dbus_send_error(conn, msg, DBUS_ERROR_NOT_SUPPORTED, "%s", "org.tizen.multimedia.audio.InvalidOperation"); + return; + } + dbus_message_iter_init_append(reply, &msg_iter); pa_assert_se(dbus_message_iter_open_container(&msg_iter, DBUS_TYPE_ARRAY, "u", &array_iter)); for (i = 0; sink->supported_sample_rates[i]; i++) { -- 2.7.4 From d07b2271b0453d63ac22c9970313412140b90953 Mon Sep 17 00:00:00 2001 From: Seungbae Shin Date: Wed, 28 Oct 2020 20:17:32 +0900 Subject: [PATCH 02/16] device-manager-dbus: use pa dbus wrapper function if possible [Version] 13.0.35 [Issue Type] Revise Change-Id: I926a1860bc43b789ae5cf5490973f92b9ddd6cbd --- packaging/pulseaudio-modules-tizen.spec | 2 +- src/device-manager-dbus.c | 306 +++++++++++--------------------- 2 files changed, 108 insertions(+), 200 deletions(-) diff --git a/packaging/pulseaudio-modules-tizen.spec b/packaging/pulseaudio-modules-tizen.spec index 638827d..e6f794d 100644 --- a/packaging/pulseaudio-modules-tizen.spec +++ b/packaging/pulseaudio-modules-tizen.spec @@ -1,6 +1,6 @@ Name: pulseaudio-modules-tizen Summary: Pulseaudio modules for Tizen -Version: 13.0.34 +Version: 13.0.35 Release: 0 Group: Multimedia/Audio License: LGPL-2.1+ diff --git a/src/device-manager-dbus.c b/src/device-manager-dbus.c index 7190965..52e87e1 100644 --- a/src/device-manager-dbus.c +++ b/src/device-manager-dbus.c @@ -507,10 +507,10 @@ static int handle_bluez_headset_property_changed(DBusConnection *c, DBusMessage static DBusHandlerResult dbus_filter_device_detect_handler(DBusConnection *c, DBusMessage *s, void *userdata) { DBusError error; int status = 0; - pa_device_manager *dm = (pa_device_manager *) userdata; + pa_device_manager *dm = (pa_device_manager *)userdata; device_detected_type_t detected; - pa_assert(userdata); + pa_assert(dm); if (dbus_message_get_type(s) != DBUS_MESSAGE_TYPE_SIGNAL) return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; @@ -678,7 +678,7 @@ static int method_call_bt_get_name(DBusConnection *conn, const char *device_path } static void handle_get_connected_device_list(DBusConnection *conn, DBusMessage *msg, void *userdata) { - pa_device_manager *dm; + pa_device_manager *dm = (pa_device_manager *)userdata; DBusMessage *reply = NULL; DBusMessageIter msg_iter, array_iter, device_iter; pa_tz_device *device; @@ -692,10 +692,7 @@ static void handle_get_connected_device_list(DBusConnection *conn, DBusMessage * pa_assert(conn); pa_assert(msg); - pa_assert(userdata); - - - dm = (pa_device_manager*) userdata; + pa_assert(dm); pa_assert_se((reply = dbus_message_new_method_return(msg))); @@ -742,7 +739,7 @@ static void handle_get_connected_device_list(DBusConnection *conn, DBusMessage * } static void handle_get_device_by_id(DBusConnection *conn, DBusMessage *msg, void *userdata) { - pa_device_manager *manager; + pa_device_manager *dm = (pa_device_manager *)userdata; DBusMessage *reply; DBusMessageIter msg_iter; pa_tz_device *device; @@ -753,9 +750,7 @@ static void handle_get_device_by_id(DBusConnection *conn, DBusMessage *msg, void pa_assert(conn); pa_assert(msg); - pa_assert(userdata); - - manager = (pa_device_manager*) userdata; + pa_assert(dm); pa_assert_se(dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &device_id, @@ -763,7 +758,7 @@ static void handle_get_device_by_id(DBusConnection *conn, DBusMessage *msg, void pa_log_info("Get device by id(%d)", device_id); - if ((device = device_list_get_device_by_id(manager, device_id))) { + if ((device = device_list_get_device_by_id(dm, device_id))) { pa_assert_se((reply = dbus_message_new_method_return(msg))); dbus_message_iter_init_append(reply, &msg_iter); @@ -792,19 +787,15 @@ static void handle_get_device_by_id(DBusConnection *conn, DBusMessage *msg, void } } -static void handle_is_device_running_by_id(DBusConnection *conn, DBusMessage *msg, void *userdata) -{ - pa_device_manager *manager; - DBusMessage *reply; +static void handle_is_device_running_by_id(DBusConnection *conn, DBusMessage *msg, void *userdata) { + pa_device_manager *dm = (pa_device_manager *)userdata; pa_tz_device *device; dbus_int32_t device_id; dbus_bool_t is_running; pa_assert(conn); pa_assert(msg); - pa_assert(userdata); - - manager = (pa_device_manager *)userdata; + pa_assert(dm); pa_assert_se(dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &device_id, @@ -812,28 +803,21 @@ static void handle_is_device_running_by_id(DBusConnection *conn, DBusMessage *ms pa_log_info("Is device running by id(%d)", device_id); - if ((device = device_list_get_device_by_id(manager, device_id))) { - pa_assert_se((reply = dbus_message_new_method_return(msg))); - + if ((device = device_list_get_device_by_id(dm, device_id))) { is_running = pa_tz_device_is_running(device); pa_log_info("device(id:%d) is %s", device_id, is_running ? "Running" : "Not Running"); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &is_running, - DBUS_TYPE_INVALID)); - - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); + pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_BOOLEAN, &is_running); } else { pa_dbus_send_error(conn, msg, DBUS_ERROR_FAILED, "%s", "org.tizen.multimedia.audio.Internal"); } } static void handle_is_stream_on_device(DBusConnection *conn, DBusMessage *msg, void *userdata) { - pa_device_manager *manager; - DBusMessage *reply; + pa_device_manager *dm = (pa_device_manager *)userdata; pa_tz_device *device; - dbus_bool_t is_on = false; + dbus_bool_t is_on = FALSE; dbus_int32_t stream_id, device_id; pa_intset *stream_id_set; int32_t stream_id_val; @@ -842,27 +826,22 @@ static void handle_is_stream_on_device(DBusConnection *conn, DBusMessage *msg, v pa_assert(conn); pa_assert(msg); - pa_assert(userdata); + pa_assert(dm); pa_log_info("Is stream on device"); - manager = (pa_device_manager*) userdata; - - pa_assert_se(dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &stream_id, DBUS_TYPE_INT32, &device_id, DBUS_TYPE_INVALID)); - if ((device = device_list_get_device_by_id(manager, device_id))) { - pa_assert_se((reply = dbus_message_new_method_return(msg))); - + if ((device = device_list_get_device_by_id(dm, device_id))) { state = pa_tz_device_get_state(device); if (state == DM_DEVICE_STATE_ACTIVATED) { stream_id_set = pa_tz_device_get_stream_list(device); PA_INTSET_FOREACH(stream_id_val, stream_id_set, ret) { if (stream_id_val == stream_id) { - is_on = true; + is_on = TRUE; pa_log_info("stream(%d) is on device(%d)", stream_id, device_id); break; } @@ -870,113 +849,106 @@ static void handle_is_stream_on_device(DBusConnection *conn, DBusMessage *msg, v pa_intset_free(stream_id_set); } else { pa_log_info("device(%d) is not activated, regard as no stream on it", device_id); - is_on = false; + is_on = FALSE; } - - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &is_on, - DBUS_TYPE_INVALID)); - - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); + pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_BOOLEAN, &is_on); } else { pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "%s", "org.tizen.multimedia.audio.Internal"); } } static void handle_get_bt_a2dp_status(DBusConnection *conn, DBusMessage *msg, void *userdata) { - pa_device_manager *dm; + pa_device_manager *dm = (pa_device_manager *)userdata; DBusMessage *reply = NULL; pa_tz_device *device; - dbus_bool_t is_bt_on = false; + dbus_bool_t is_bt_on = FALSE; const char *bt_name = "none"; pa_assert(conn); pa_assert(msg); - pa_assert(userdata); + pa_assert(dm); pa_log_info("Get BT A2DP list"); - dm = (pa_device_manager*) userdata; - - pa_assert_se((reply = dbus_message_new_method_return(msg))); - /* FIXME : Give system_id for multi device */ if ((device = device_list_get_device(dm, DEVICE_TYPE_BT_A2DP, NULL, NULL)) != NULL) { - is_bt_on = true; + is_bt_on = TRUE; bt_name = pa_tz_device_get_name(device); } + pa_assert_se((reply = dbus_message_new_method_return(msg))); pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &is_bt_on, DBUS_TYPE_STRING, &bt_name, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_connection_send(conn, reply, NULL)); dbus_message_unref(reply); } static void handle_load_sink(DBusConnection *conn, DBusMessage *msg, void *userdata) { - pa_device_manager *dm; + pa_device_manager *dm = (pa_device_manager *)userdata; char *type, *role; pa_sink *sink; - DBusMessage *reply = NULL; - dm = (pa_device_manager *) userdata; + pa_assert(conn); + pa_assert(msg); + pa_assert(dm); + pa_assert_se(dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &type, DBUS_TYPE_STRING, &role, DBUS_TYPE_INVALID)); - if (!(sink = pa_device_manager_load_sink(dm, type, role))) { + if (!(sink = pa_device_manager_load_sink(dm, type, role))) pa_dbus_send_error(conn, msg, DBUS_ERROR_FAILED, "%s", "org.tizen.multimedia.audio.Internal"); - return; - } - - pa_assert_se((reply = dbus_message_new_method_return(msg))); - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); + else + pa_dbus_send_empty_reply(conn, msg); } static void handle_unload_sink(DBusConnection *conn, DBusMessage *msg, void *userdata) { - pa_device_manager *dm; + pa_device_manager *dm = (pa_device_manager *)userdata; char *type, *role; - DBusMessage *reply = NULL; - pa_assert_se((reply = dbus_message_new_method_return(msg))); - dm = (pa_device_manager *) userdata; + pa_assert(conn); + pa_assert(msg); + pa_assert(dm); + pa_assert_se(dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &type, DBUS_TYPE_STRING, &role, DBUS_TYPE_INVALID)); pa_device_manager_unload_sink(dm, type, role); - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); + + pa_dbus_send_empty_reply(conn, msg); } static void handle_unload_sink_with_device_string(DBusConnection *conn, DBusMessage *msg, void *userdata) { - pa_device_manager *dm; + pa_device_manager *dm = (pa_device_manager *)userdata; char *device_string; - DBusMessage *reply = NULL; - pa_assert_se((reply = dbus_message_new_method_return(msg))); - dm = (pa_device_manager *) userdata; + pa_assert(conn); + pa_assert(msg); + pa_assert(dm); + pa_assert_se(dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &device_string, DBUS_TYPE_INVALID)); pa_device_manager_unload_sink_with_device_string(dm, device_string); - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); + + pa_dbus_send_empty_reply(conn, msg); } static void handle_get_device_string(DBusConnection *conn, DBusMessage *msg, void *userdata) { - pa_device_manager *dm; + pa_device_manager *dm = (pa_device_manager *)userdata; char *type, *role; const char *device_string; dbus_bool_t is_playback; - DBusMessage *reply; - dm = (pa_device_manager *) userdata; + pa_assert(conn); + pa_assert(msg); + pa_assert(dm); + pa_assert_se(dbus_message_get_args(msg, NULL, DBUS_TYPE_BOOLEAN, &is_playback, DBUS_TYPE_STRING, &type, @@ -990,27 +962,24 @@ static void handle_get_device_string(DBusConnection *conn, DBusMessage *msg, voi } pa_log_info("device string : %s", device_string); - pa_assert_se((reply = dbus_message_new_method_return(msg))); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &device_string, - DBUS_TYPE_INVALID)); - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); + + pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_STRING, &device_string); } static void handle_dump_device_list(DBusConnection *conn, DBusMessage *msg, void *userdata) { - pa_device_manager *dm; + pa_device_manager *dm = (pa_device_manager *)userdata; pa_tz_device *device; uint32_t device_idx; - DBusMessage *reply = NULL; - pa_assert_se((reply = dbus_message_new_method_return(msg))); - dm = (pa_device_manager *) userdata; + pa_assert(conn); + pa_assert(msg); + pa_assert(dm); PA_IDXSET_FOREACH(device, dm->device_list, device_idx) { pa_tz_device_dump_info(device, PA_LOG_INFO); } - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); + + pa_dbus_send_empty_reply(conn, msg); } static bool is_usb_output_device(pa_tz_device *device) { @@ -1057,7 +1026,7 @@ static bool is_supported_sample_format(pa_sample_format_t *supported_sample_form } static void handle_get_supported_sample_formats(DBusConnection *conn, DBusMessage *msg, void *userdata) { - pa_device_manager *dm; + pa_device_manager *dm = (pa_device_manager *)userdata; DBusMessage *reply = NULL; DBusMessageIter msg_iter, array_iter; dbus_int32_t device_id; @@ -1068,9 +1037,7 @@ static void handle_get_supported_sample_formats(DBusConnection *conn, DBusMessag pa_assert(conn); pa_assert(msg); - pa_assert(userdata); - - dm = (pa_device_manager *)userdata; + pa_assert(dm); pa_assert_se((reply = dbus_message_new_method_return(msg))); @@ -1114,8 +1081,7 @@ static void handle_get_supported_sample_formats(DBusConnection *conn, DBusMessag } static void handle_set_sample_format(DBusConnection *conn, DBusMessage *msg, void *userdata) { - pa_device_manager *dm; - DBusMessage *reply = NULL; + pa_device_manager *dm = (pa_device_manager *)userdata; dbus_int32_t device_id; char *sample_format; pa_sample_format_t prev_selected_sample_format; @@ -1125,10 +1091,8 @@ static void handle_set_sample_format(DBusConnection *conn, DBusMessage *msg, voi pa_assert(conn); pa_assert(msg); - pa_assert(userdata); + pa_assert(dm); - pa_assert_se((reply = dbus_message_new_method_return(msg))); - dm = (pa_device_manager *)userdata; pa_assert_se(dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &device_id, DBUS_TYPE_STRING, &sample_format, @@ -1172,13 +1136,12 @@ static void handle_set_sample_format(DBusConnection *conn, DBusMessage *msg, voi } pa_log_info("Set sample format(%s) of the device(id:%d) successfully", sample_format, device_id); - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); + + pa_dbus_send_empty_reply(conn, msg); } static void handle_get_sample_format(DBusConnection *conn, DBusMessage *msg, void *userdata) { - pa_device_manager *dm; - DBusMessage *reply = NULL; + pa_device_manager *dm = (pa_device_manager *)userdata; dbus_int32_t device_id; pa_tz_device *device; pa_sink *sink; @@ -1186,11 +1149,7 @@ static void handle_get_sample_format(DBusConnection *conn, DBusMessage *msg, voi pa_assert(conn); pa_assert(msg); - pa_assert(userdata); - - dm = (pa_device_manager *)userdata; - - pa_assert_se((reply = dbus_message_new_method_return(msg))); + pa_assert(dm); pa_assert_se(dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &device_id, @@ -1215,10 +1174,8 @@ static void handle_get_sample_format(DBusConnection *conn, DBusMessage *msg, voi format = pa_sample_format_to_string(sink->selected_sample_format); pa_log_info("Get sample format(%s) of the device(id:%d) successfully", format, device_id); - pa_assert_se((reply = dbus_message_new_method_return(msg))); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &format, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); + + pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_STRING, &format); } static bool is_supported_sample_rate(uint32_t *supported_sample_rates, uint32_t sample_rate) { @@ -1237,7 +1194,7 @@ static bool is_supported_sample_rate(uint32_t *supported_sample_rates, uint32_t } static void handle_get_supported_sample_rates(DBusConnection *conn, DBusMessage *msg, void *userdata) { - pa_device_manager *dm; + pa_device_manager *dm = (pa_device_manager *)userdata; DBusMessage *reply = NULL; DBusMessageIter msg_iter, array_iter; dbus_int32_t device_id; @@ -1247,9 +1204,7 @@ static void handle_get_supported_sample_rates(DBusConnection *conn, DBusMessage pa_assert(conn); pa_assert(msg); - pa_assert(userdata); - - dm = (pa_device_manager *)userdata; + pa_assert(dm); pa_assert_se((reply = dbus_message_new_method_return(msg))); @@ -1292,8 +1247,7 @@ static void handle_get_supported_sample_rates(DBusConnection *conn, DBusMessage } static void handle_set_sample_rate(DBusConnection *conn, DBusMessage *msg, void *userdata) { - pa_device_manager *dm; - DBusMessage *reply = NULL; + pa_device_manager *dm = (pa_device_manager *)userdata; dbus_int32_t device_id; dbus_uint32_t sample_rate; uint32_t prev_selected_sample_rate; @@ -1303,10 +1257,8 @@ static void handle_set_sample_rate(DBusConnection *conn, DBusMessage *msg, void pa_assert(conn); pa_assert(msg); - pa_assert(userdata); + pa_assert(dm); - pa_assert_se((reply = dbus_message_new_method_return(msg))); - dm = (pa_device_manager *)userdata; pa_assert_se(dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &device_id, DBUS_TYPE_UINT32, &sample_rate, @@ -1350,24 +1302,19 @@ static void handle_set_sample_rate(DBusConnection *conn, DBusMessage *msg, void } pa_log_info("Set sample rate(%u) of the device(id:%d) successfully", sample_rate, device_id); - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); + + pa_dbus_send_empty_reply(conn, msg); } static void handle_get_sample_rate(DBusConnection *conn, DBusMessage *msg, void *userdata) { - pa_device_manager *dm; - DBusMessage *reply = NULL; + pa_device_manager *dm = (pa_device_manager *)userdata; dbus_int32_t device_id; pa_tz_device *device; pa_sink *sink; pa_assert(conn); pa_assert(msg); - pa_assert(userdata); - - dm = (pa_device_manager *)userdata; - - pa_assert_se((reply = dbus_message_new_method_return(msg))); + pa_assert(dm); pa_assert_se(dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &device_id, @@ -1391,25 +1338,20 @@ static void handle_get_sample_rate(DBusConnection *conn, DBusMessage *msg, void } pa_log_info("Get sample rate(%u) of the device(id:%d) successfully", sink->selected_sample_rate, device_id); - pa_assert_se((reply = dbus_message_new_method_return(msg))); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_UINT32, &sink->selected_sample_rate, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); + + pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_UINT32, &sink->selected_sample_rate); } static void handle_set_specific_stream_only(DBusConnection *conn, DBusMessage *msg, void *userdata) { - pa_device_manager *dm; - DBusMessage *reply = NULL; + pa_device_manager *dm = (pa_device_manager *)userdata; dbus_int32_t device_id; char *stream_role; pa_tz_device *device; pa_assert(conn); pa_assert(msg); - pa_assert(userdata); + pa_assert(dm); - pa_assert_se((reply = dbus_message_new_method_return(msg))); - dm = (pa_device_manager *)userdata; pa_assert_se(dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &device_id, DBUS_TYPE_STRING, &stream_role, @@ -1434,24 +1376,18 @@ static void handle_set_specific_stream_only(DBusConnection *conn, DBusMessage *m pa_xfree(device->specified_stream_role); device->specified_stream_role = pa_xstrdup(stream_role); - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); + pa_dbus_send_empty_reply(conn, msg); } static void handle_get_specified_stream(DBusConnection *conn, DBusMessage *msg, void *userdata) { - pa_device_manager *dm; - DBusMessage *reply = NULL; + pa_device_manager *dm = (pa_device_manager *)userdata; dbus_int32_t device_id; char *specified_stream_role; pa_tz_device *device; pa_assert(conn); pa_assert(msg); - pa_assert(userdata); - - dm = (pa_device_manager *)userdata; - - pa_assert_se((reply = dbus_message_new_method_return(msg))); + pa_assert(dm); pa_assert_se(dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &device_id, @@ -1472,15 +1408,12 @@ static void handle_get_specified_stream(DBusConnection *conn, DBusMessage *msg, specified_stream_role = device->specified_stream_role; pa_log_info("stream role(%s) is specified for the device(id:%d)", device->specified_stream_role, device_id); - pa_assert_se((reply = dbus_message_new_method_return(msg))); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &specified_stream_role, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); + + pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_STRING, &specified_stream_role); } static void handle_set_avoid_resampling(DBusConnection *conn, DBusMessage *msg, void *userdata) { - pa_device_manager *dm; - DBusMessage *reply = NULL; + pa_device_manager *dm = (pa_device_manager *)userdata; dbus_int32_t device_id; dbus_bool_t avoid_resampling; pa_tz_device *device; @@ -1488,10 +1421,8 @@ static void handle_set_avoid_resampling(DBusConnection *conn, DBusMessage *msg, pa_assert(conn); pa_assert(msg); - pa_assert(userdata); + pa_assert(dm); - pa_assert_se((reply = dbus_message_new_method_return(msg))); - dm = (pa_device_manager *)userdata; pa_assert_se(dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &device_id, DBUS_TYPE_BOOLEAN, &avoid_resampling, @@ -1515,24 +1446,17 @@ static void handle_set_avoid_resampling(DBusConnection *conn, DBusMessage *msg, } if (sink->avoid_resampling == avoid_resampling) { pa_log_info("already set to %d", avoid_resampling); - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); - return; + } else { + sink->avoid_resampling = avoid_resampling; + save_preference(dm, sink); + pa_log_info("Set avoid-resampling(%d) to the device(id:%d)", avoid_resampling, device_id); } - sink->avoid_resampling = avoid_resampling; - - save_preference(dm, sink); - - pa_log_info("Set avoid-resampling(%d) to the device(id:%d)", avoid_resampling, device_id); - - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); + pa_dbus_send_empty_reply(conn, msg); } static void handle_get_avoid_resampling(DBusConnection *conn, DBusMessage *msg, void *userdata) { - pa_device_manager *dm; - DBusMessage *reply = NULL; + pa_device_manager *dm = (pa_device_manager *)userdata; dbus_int32_t device_id; dbus_bool_t avoid_resampling; pa_tz_device *device; @@ -1540,11 +1464,7 @@ static void handle_get_avoid_resampling(DBusConnection *conn, DBusMessage *msg, pa_assert(conn); pa_assert(msg); - pa_assert(userdata); - - dm = (pa_device_manager *)userdata; - - pa_assert_se((reply = dbus_message_new_method_return(msg))); + pa_assert(dm); pa_assert_se(dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &device_id, @@ -1570,48 +1490,38 @@ static void handle_get_avoid_resampling(DBusConnection *conn, DBusMessage *msg, avoid_resampling = sink->avoid_resampling; pa_log_info("got avoid-resampling(%d) of the device(id:%d)", avoid_resampling, device_id); - pa_assert_se((reply = dbus_message_new_method_return(msg))); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &avoid_resampling, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); + pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_BOOLEAN, &avoid_resampling); } static void handle_test_device_status_change(DBusConnection *conn, DBusMessage *msg, void *userdata) { pa_device_manager *dm = (pa_device_manager *)userdata; char *type; dbus_int32_t status; - DBusMessage *reply = NULL; - DBusError error; - pa_assert_se((reply = dbus_message_new_method_return(msg))); + pa_assert(conn); + pa_assert(msg); + pa_assert(dm); - dbus_error_init(&error); - if (!dbus_message_get_args(msg, NULL, + pa_assert_se(dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &type, DBUS_TYPE_INT32, &status, - DBUS_TYPE_INVALID)) { - pa_log_error("failed to get dbus args : %s", error.message); - pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "%s", error.message); - dbus_error_free(&error); - } + DBUS_TYPE_INVALID)); pa_log_debug("handle_test_device_status_change, type:%s, status:%d", type, status); - handle_device_status_changed(dm, type, NULL, NULL, status); - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); + handle_device_status_changed(dm, type, NULL, NULL, status); + + pa_dbus_send_empty_reply(conn, msg); } static void handle_set_acm_mode(DBusConnection *conn, DBusMessage *msg, void *userdata) { - pa_device_manager *dm; - DBusMessage *reply = NULL; + pa_device_manager *dm = (pa_device_manager *)userdata; uint32_t mode = 0; pa_assert(conn); pa_assert(msg); - pa_assert(userdata); + pa_assert(dm); - dm = (pa_device_manager *)userdata; pa_assert_se(dbus_message_get_args(msg, NULL, DBUS_TYPE_UINT32, &mode, DBUS_TYPE_INVALID)); @@ -1629,9 +1539,7 @@ static void handle_set_acm_mode(DBusConnection *conn, DBusMessage *msg, void *us } } - pa_assert_se((reply = dbus_message_new_method_return(msg))); - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); + pa_dbus_send_empty_reply(conn, msg); } static DBusHandlerResult handle_introspect(DBusConnection *conn, DBusMessage *msg, void *userdata) { -- 2.7.4 From 7275b04d86b876e76c958170541c1d5922566828 Mon Sep 17 00:00:00 2001 From: Seungbae Shin Date: Thu, 29 Oct 2020 16:34:37 +0900 Subject: [PATCH 03/16] stream-manager-dbus: use pa dbus wrapper function if possible [Version] 13.0.36 [Issue Type] Revise Change-Id: Ib30dd5934fa4a2554652feb550937d15a2fa177f --- packaging/pulseaudio-modules-tizen.spec | 2 +- src/stream-manager-dbus.c | 708 +++++++++++++------------------- 2 files changed, 278 insertions(+), 432 deletions(-) diff --git a/packaging/pulseaudio-modules-tizen.spec b/packaging/pulseaudio-modules-tizen.spec index e6f794d..9f5b1f7 100644 --- a/packaging/pulseaudio-modules-tizen.spec +++ b/packaging/pulseaudio-modules-tizen.spec @@ -1,6 +1,6 @@ Name: pulseaudio-modules-tizen Summary: Pulseaudio modules for Tizen -Version: 13.0.35 +Version: 13.0.36 Release: 0 Group: Multimedia/Audio License: LGPL-2.1+ diff --git a/src/stream-manager-dbus.c b/src/stream-manager-dbus.c index c365345..d5c87b3 100644 --- a/src/stream-manager-dbus.c +++ b/src/stream-manager-dbus.c @@ -381,6 +381,28 @@ static pa_dbus_method_handler method_handlers[METHOD_HANDLER_MAX] = { .receive_cb = handle_publish_local_device }, }; +static int get_stream_type(const char *direction, stream_type_t *stream_type) { + if (pa_safe_streq(direction, "in")) + *stream_type = STREAM_SOURCE_OUTPUT; + else if (pa_safe_streq(direction, "out")) + *stream_type = STREAM_SINK_INPUT; + else + return -1; + + return 0; +} + +static int get_direction_type(const char *direction, stream_direction_t *direction_type) { + if (pa_safe_streq(direction, "in")) + *direction_type = STREAM_DIRECTION_IN; + else if (pa_safe_streq(direction, "out")) + *direction_type = STREAM_DIRECTION_OUT; + else + return -1; + + return 0; +} + static DBusHandlerResult handle_introspect(DBusConnection *conn, DBusMessage *msg, void *userdata) { const char *xml = STREAM_MGR_INTROSPECT_XML; DBusMessage *r = NULL; @@ -401,10 +423,10 @@ static DBusHandlerResult handle_introspect(DBusConnection *conn, DBusMessage *ms } static void handle_get_stream_list(DBusConnection *conn, DBusMessage *msg, void *userdata) { + pa_stream_manager *m = (pa_stream_manager *)userdata; stream_list list; DBusMessage *reply = NULL; DBusMessageIter msg_iter; - pa_stream_manager *m = (pa_stream_manager*)userdata; pa_assert(conn); pa_assert(msg); @@ -429,11 +451,11 @@ static void handle_get_stream_list(DBusConnection *conn, DBusMessage *msg, void } static void handle_get_stream_info(DBusConnection *conn, DBusMessage *msg, void *userdata) { - char *type; + pa_stream_manager *m = (pa_stream_manager *)userdata; + const char *type; stream_info_per_type info; DBusMessage *reply = NULL; DBusMessageIter msg_iter; - pa_stream_manager *m = (pa_stream_manager*)userdata; pa_assert(conn); pa_assert(msg); @@ -550,15 +572,14 @@ static ret_msg_t update_devices_and_trigger_routing(pa_stream_manager *m, stream } static void handle_set_stream_route_devices(DBusConnection *conn, DBusMessage *msg, void *userdata) { - uint32_t id = 0; + pa_stream_manager *m = (pa_stream_manager *)userdata; int i = 0; - uint32_t *in_device_list = NULL; - uint32_t *out_device_list = NULL; - int list_len_in = 0; - int list_len_out = 0; + dbus_uint32_t *in_device_list = NULL; + dbus_uint32_t *out_device_list = NULL; + dbus_uint32_t id = 0; + dbus_uint32_t list_len_in = 0; + dbus_uint32_t list_len_out = 0; stream_parent *sp = NULL; - DBusMessage *reply = NULL; - pa_stream_manager *m = (pa_stream_manager*)userdata; ret_msg_t ret = RET_MSG_OK; pa_assert(conn); @@ -570,11 +591,9 @@ static void handle_set_stream_route_devices(DBusConnection *conn, DBusMessage *m DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32, &in_device_list, &list_len_in, DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32, &out_device_list, &list_len_out, DBUS_TYPE_INVALID)); - pa_log_info("id[%u], in_device_list[%p]:length[%d], out_device_list[%p]:length[%d]", + pa_log_info("id[%u], in_device_list[%p]:length[%u], out_device_list[%p]:length[%u]", id, in_device_list, list_len_in, out_device_list, list_len_out); - pa_assert_se((reply = dbus_message_new_method_return(msg))); - sp = pa_hashmap_get(m->stream_parents, (const void*)id); if (!sp) { pa_log_error("could not find matching client for this parent_id[%u]", id); @@ -606,9 +625,9 @@ static void handle_set_stream_route_devices(DBusConnection *conn, DBusMessage *m } pa_idxset_remove_all(sp->idx_route_in_devices, pa_xfree); - if (in_device_list && list_len_in) { + if (in_device_list) { for (i = 0; i < list_len_in; i++) { - pa_idxset_put(sp->idx_route_in_devices, pa_xmemdup(&in_device_list[i], sizeof(uint32_t)), NULL); + pa_idxset_put(sp->idx_route_in_devices, pa_xmemdup(&in_device_list[i], sizeof(dbus_uint32_t)), NULL); pa_log_debug(" -- [in] device id:%u", in_device_list[i]); } } @@ -616,30 +635,28 @@ static void handle_set_stream_route_devices(DBusConnection *conn, DBusMessage *m goto finish; pa_idxset_remove_all(sp->idx_route_out_devices, pa_xfree); - if (out_device_list && list_len_out) { + if (out_device_list) { for (i = 0; i < list_len_out; i++) { - pa_idxset_put(sp->idx_route_out_devices, pa_xmemdup(&out_device_list[i], sizeof(uint32_t)), NULL); + pa_idxset_put(sp->idx_route_out_devices, pa_xmemdup(&out_device_list[i], sizeof(dbus_uint32_t)), NULL); pa_log_debug(" -- [out] device id:%u", out_device_list[i]); } } - if ((ret = update_devices_and_trigger_routing(m, sp, STREAM_SINK_INPUT))) - goto finish; + + ret = update_devices_and_trigger_routing(m, sp, STREAM_SINK_INPUT); finish: - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret], DBUS_TYPE_INVALID)); - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); + pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret]); } static void handle_set_stream_route_option(DBusConnection *conn, DBusMessage *msg, void *userdata) { - uint32_t id = 0; + pa_stream_manager *m = (pa_stream_manager *)userdata; + dbus_uint32_t id = 0; const char *name = NULL; - int32_t value = 0; + dbus_int32_t value = 0; bool updated = false; stream_parent *sp = NULL; stream_route_option route_option; - DBusMessage *reply = NULL; - pa_stream_manager *m = (pa_stream_manager*)userdata; + ret_msg_t ret = RET_MSG_OK; pa_assert(conn); pa_assert(msg); @@ -650,9 +667,7 @@ static void handle_set_stream_route_option(DBusConnection *conn, DBusMessage *ms DBUS_TYPE_STRING, &name, DBUS_TYPE_INT32, &value, DBUS_TYPE_INVALID)); - pa_log_info("name[%s], value[%d]", name, value); - - pa_assert_se((reply = dbus_message_new_method_return(msg))); + pa_log_info("id[%u], name[%s], value[%d]", id, name, value); sp = pa_hashmap_get(m->stream_parents, (const void*)id); if (sp) { @@ -679,21 +694,18 @@ static void handle_set_stream_route_option(DBusConnection *conn, DBusMessage *ms } if (!updated) { pa_log_error("invalid state"); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_NO_STREAM], DBUS_TYPE_INVALID)); - } else - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_OK], DBUS_TYPE_INVALID)); + ret = RET_MSG_ERROR_NO_STREAM; + } } else { pa_log_error("invalid arguments"); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_INVALID_ARGUMENT], DBUS_TYPE_INVALID)); + ret = RET_MSG_ERROR_INVALID_ARGUMENT; } - } else { pa_log_error("could not find matching client for this parent_id[%u]", id); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_INTERNAL], DBUS_TYPE_INVALID)); + ret = RET_MSG_ERROR_INTERNAL; } - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); + pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret]); } static int get_device_for_preference(pa_stream_manager *m, stream_parent *sp, stream_direction_t direction, uint32_t device_id, pa_tz_device **device) { @@ -721,9 +733,10 @@ static int get_device_for_preference(pa_stream_manager *m, stream_parent *sp, st } static void handle_set_stream_preferred_device(DBusConnection *conn, DBusMessage *msg, void *userdata) { + pa_stream_manager *m = (pa_stream_manager *)userdata; const char *device_direction = NULL; - uint32_t sp_id = 0; - uint32_t device_id = 0; + dbus_uint32_t sp_id = 0; + dbus_uint32_t device_id = 0; uint32_t idx; uint32_t count = 0; stream_direction_t direction; @@ -741,9 +754,6 @@ static void handle_set_stream_preferred_device(DBusConnection *conn, DBusMessage pa_hashmap *devices; void *new_device = NULL; ret_msg_t ret = RET_MSG_OK; - DBusMessage *reply = NULL; - - pa_stream_manager *m = (pa_stream_manager*)userdata; pa_assert(conn); pa_assert(msg); @@ -756,19 +766,13 @@ static void handle_set_stream_preferred_device(DBusConnection *conn, DBusMessage DBUS_TYPE_INVALID)); pa_log_info("stream parent id[%u], device direction[%s], device_id[%u]", sp_id, device_direction, device_id); - pa_assert_se((reply = dbus_message_new_method_return(msg))); - if (!(sp = pa_hashmap_get(m->stream_parents, (const void*)sp_id))) { pa_log_error("could not find matching client for this parent_id[%u]", sp_id); ret = RET_MSG_ERROR_INTERNAL; goto finish; } - if (pa_safe_streq(device_direction, "in")) - direction = STREAM_DIRECTION_IN; - else if (pa_safe_streq(device_direction, "out")) - direction = STREAM_DIRECTION_OUT; - else { + if (get_direction_type(device_direction, &direction) != 0) { ret = RET_MSG_ERROR_INVALID_ARGUMENT; goto finish; } @@ -863,14 +867,13 @@ static void handle_set_stream_preferred_device(DBusConnection *conn, DBusMessage } finish: - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret], DBUS_TYPE_INVALID)); - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); + pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret]); } static void handle_get_stream_preferred_device(DBusConnection *conn, DBusMessage *msg, void *userdata) { + pa_stream_manager *m = (pa_stream_manager *)userdata; stream_parent *sp = NULL; - uint32_t sp_id = 0; + dbus_uint32_t sp_id = 0; uint32_t in_device_id = 0; uint32_t out_device_id = 0; const char *pref_in_type, *pref_out_type; @@ -882,8 +885,6 @@ static void handle_get_stream_preferred_device(DBusConnection *conn, DBusMessage ret_msg_t ret = RET_MSG_OK; DBusMessage *reply = NULL; - pa_stream_manager *m = (pa_stream_manager*)userdata; - pa_assert(conn); pa_assert(msg); pa_assert(m); @@ -910,13 +911,13 @@ static void handle_get_stream_preferred_device(DBusConnection *conn, DBusMessage dm_device_list = pa_device_manager_get_device_list(m->dm); PA_IDXSET_FOREACH(dm_device, dm_device_list, idx) { dm_direction = pa_tz_device_get_direction(dm_device); - if (!in_device_id && dm_direction & DM_DEVICE_DIRECTION_IN) { + if (in_device_id == 0 && (dm_direction & DM_DEVICE_DIRECTION_IN)) { if (pa_safe_streq(pref_in_type, pa_tz_device_get_type(dm_device))) { if (pa_safe_streq(pref_in_role, pa_tz_device_get_role(dm_device, pref_in_role))) in_device_id = pa_tz_device_get_id(dm_device); } } - if (!out_device_id && dm_direction & DM_DEVICE_DIRECTION_OUT) { + if (out_device_id == 0 && (dm_direction & DM_DEVICE_DIRECTION_OUT)) { if (pa_safe_streq(pref_out_type, pa_tz_device_get_type(dm_device))) { if (pa_safe_streq(pref_out_role, pa_tz_device_get_role(dm_device, pref_out_role))) out_device_id = pa_tz_device_get_id(dm_device); @@ -928,9 +929,10 @@ static void handle_get_stream_preferred_device(DBusConnection *conn, DBusMessage pa_log_info("preferred OUT device: type[%s] role[%s] id[%u]", pref_out_type, pref_out_role, out_device_id); finish: - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_UINT32, &in_device_id, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_UINT32, &out_device_id, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret], DBUS_TYPE_INVALID)); + pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_UINT32, &in_device_id, + DBUS_TYPE_UINT32, &out_device_id, + DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret], + DBUS_TYPE_INVALID)); pa_assert_se(dbus_connection_send(conn, reply, NULL)); dbus_message_unref(reply); } @@ -1052,10 +1054,11 @@ static void rollback_process_from_preemptive_device(pa_stream_manager *m, stream } static void handle_set_stream_preemptive_device(DBusConnection *conn, DBusMessage *msg, void *userdata) { + pa_stream_manager *m = (pa_stream_manager *)userdata; const char *stream_type = NULL; const char *device_direction = NULL; stream_direction_t direction; - uint32_t device_id = 0; + dbus_uint32_t device_id = 0; stream_info *s = NULL; pa_tz_device *device = NULL; char *device_type = NULL; @@ -1064,9 +1067,6 @@ static void handle_set_stream_preemptive_device(DBusConnection *conn, DBusMessag uint32_t idx; bool found = false; ret_msg_t ret = RET_MSG_OK; - DBusMessage *reply = NULL; - - pa_stream_manager *m = (pa_stream_manager*)userdata; pa_assert(conn); pa_assert(msg); @@ -1079,19 +1079,13 @@ static void handle_set_stream_preemptive_device(DBusConnection *conn, DBusMessag DBUS_TYPE_INVALID)); pa_log_info("stream type[%s], device direction[%s], device_id[%u]", stream_type, device_direction, device_id); - pa_assert_se((reply = dbus_message_new_method_return(msg))); - if ((s = pa_hashmap_get(m->stream_infos, stream_type)) == NULL) { pa_log_error("could not find this stream type(%s)", stream_type); ret = RET_MSG_ERROR_INTERNAL; goto finish; } - if (pa_safe_streq(device_direction, "in")) - direction = STREAM_DIRECTION_IN; - else if (pa_safe_streq(device_direction, "out")) - direction = STREAM_DIRECTION_OUT; - else { + if (get_direction_type(device_direction, &direction) != 0) { ret = RET_MSG_ERROR_INVALID_ARGUMENT; goto finish; } @@ -1141,7 +1135,8 @@ static void handle_set_stream_preemptive_device(DBusConnection *conn, DBusMessag /* move streams and change routing */ if (device_id == 0) { - if (!(device = pa_device_manager_get_device_by_id(m->dm, prev_device_id)) || !pa_safe_streq(device->type, prev_device_type)) { + if (!(device = pa_device_manager_get_device_by_id(m->dm, prev_device_id)) || + !pa_safe_streq(device->type, prev_device_type)) { pa_log_debug("could not find the previous device of id[%u], type[%s], nothing to do.", prev_device_id, prev_device_type); goto finish; } @@ -1151,12 +1146,11 @@ static void handle_set_stream_preemptive_device(DBusConnection *conn, DBusMessag } finish: - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret], DBUS_TYPE_INVALID)); - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); + pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret]); } static void handle_get_stream_preemptive_device(DBusConnection *conn, DBusMessage *msg, void *userdata) { + pa_stream_manager *m = (pa_stream_manager *)userdata; const char *stream_type = NULL; stream_info *s = NULL; uint32_t in_device_id = 0; @@ -1166,8 +1160,6 @@ static void handle_get_stream_preemptive_device(DBusConnection *conn, DBusMessag ret_msg_t ret = RET_MSG_OK; DBusMessage *reply = NULL; - pa_stream_manager *m = (pa_stream_manager*)userdata; - pa_assert(conn); pa_assert(msg); pa_assert(m); @@ -1194,22 +1186,21 @@ static void handle_get_stream_preemptive_device(DBusConnection *conn, DBusMessag pa_log_info("preemptive OUT device: type[%s] id[%u]", out_device_type, out_device_id); finish: - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_UINT32, &in_device_id, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_UINT32, &out_device_id, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret], DBUS_TYPE_INVALID)); + pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_UINT32, &in_device_id, + DBUS_TYPE_UINT32, &out_device_id, + DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret], + DBUS_TYPE_INVALID)); pa_assert_se(dbus_connection_send(conn, reply, NULL)); dbus_message_unref(reply); } static void handle_set_volume_level(DBusConnection *conn, DBusMessage *msg, void *userdata) { + pa_stream_manager *m = (pa_stream_manager *)userdata; const char *direction = NULL; const char *type = NULL; - uint32_t level = 0; + dbus_uint32_t level = 0; stream_type_t stream_type = STREAM_SINK_INPUT; - DBusMessage *reply = NULL; - pa_stream_manager *m = (pa_stream_manager*)userdata; int ret = 0; - ret_msg_t ret_msg = RET_MSG_ERROR_INTERNAL; pa_assert(conn); pa_assert(msg); @@ -1222,47 +1213,35 @@ static void handle_set_volume_level(DBusConnection *conn, DBusMessage *msg, void DBUS_TYPE_INVALID)); pa_log_info("direction[%s], type[%s], level[%u]", direction, type, level); - pa_assert_se((reply = dbus_message_new_method_return(msg))); - - if (pa_safe_streq(direction, "in")) - stream_type = STREAM_SOURCE_OUTPUT; - else if (pa_safe_streq(direction, "out")) - stream_type = STREAM_SINK_INPUT; - else { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret_msg], DBUS_TYPE_INVALID)); - ret = -1; + if (get_stream_type(direction, &stream_type) != 0) { + ret = RET_MSG_ERROR_INTERNAL; goto finish; } /* check vconf update here, volume will not be set if update fails */ if ((ret = update_volume_vconf(type, level))) { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret_msg], DBUS_TYPE_INVALID)); + ret = RET_MSG_ERROR_INTERNAL; goto finish; } - if ((ret = set_volume_level_by_type(m, stream_type, type, level))) { - if (ret == -2) - ret_msg = RET_MSG_ERROR_INVALID_ARGUMENT; - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret_msg], DBUS_TYPE_INVALID)); - } else { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_OK], DBUS_TYPE_INVALID)); - } + if ((ret = set_volume_level_by_type(m, stream_type, type, level)) != 0) + ret = (ret == -2) ? RET_MSG_ERROR_INVALID_ARGUMENT : RET_MSG_ERROR_INTERNAL; finish: - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); + pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret]); - if (!ret) + if (ret == 0) send_volume_changed_signal(conn, direction, type, level); } static void handle_get_volume_level(DBusConnection *conn, DBusMessage *msg, void *userdata) { + pa_stream_manager *m = (pa_stream_manager *)userdata; const char *direction = NULL; const char *type = NULL; uint32_t level = 0; stream_type_t stream_type = STREAM_SINK_INPUT; DBusMessage *reply = NULL; - pa_stream_manager *m = (pa_stream_manager*)userdata; + ret_msg_t ret = RET_MSG_OK; pa_assert(conn); pa_assert(msg); @@ -1276,36 +1255,30 @@ static void handle_get_volume_level(DBusConnection *conn, DBusMessage *msg, void pa_assert_se((reply = dbus_message_new_method_return(msg))); - if (pa_safe_streq(direction, "in")) - stream_type = STREAM_SOURCE_OUTPUT; - else if (pa_safe_streq(direction, "out")) - stream_type = STREAM_SINK_INPUT; - else { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_UINT32, &level, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_INTERNAL], DBUS_TYPE_INVALID)); + if (get_stream_type(direction, &stream_type) != 0) { + ret = RET_MSG_ERROR_INTERNAL; goto finish; } - if (get_volume_level_by_type(m, GET_VOLUME_CURRENT_LEVEL, stream_type, type, &level)) { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_UINT32, &level, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_INTERNAL], DBUS_TYPE_INVALID)); - } else { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_UINT32, &level, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_OK], DBUS_TYPE_INVALID)); - } + if (get_volume_level_by_type(m, GET_VOLUME_CURRENT_LEVEL, stream_type, type, &level) != 0) + ret = RET_MSG_ERROR_INTERNAL; finish: + pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_UINT32, &level, + DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret], + DBUS_TYPE_INVALID)); pa_assert_se(dbus_connection_send(conn, reply, NULL)); dbus_message_unref(reply); } static void handle_get_volume_max_level(DBusConnection *conn, DBusMessage *msg, void *userdata) { + pa_stream_manager *m = (pa_stream_manager *)userdata; const char *direction = NULL; const char *type = NULL; uint32_t level = 0; stream_type_t stream_type = STREAM_SINK_INPUT; DBusMessage *reply = NULL; - pa_stream_manager *m = (pa_stream_manager*)userdata; + ret_msg_t ret = RET_MSG_OK; pa_assert(conn); pa_assert(msg); @@ -1319,36 +1292,29 @@ static void handle_get_volume_max_level(DBusConnection *conn, DBusMessage *msg, pa_assert_se((reply = dbus_message_new_method_return(msg))); - if (pa_safe_streq(direction, "in")) - stream_type = STREAM_SOURCE_OUTPUT; - else if (pa_safe_streq(direction, "out")) - stream_type = STREAM_SINK_INPUT; - else { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_UINT32, &level, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_INTERNAL], DBUS_TYPE_INVALID)); + if (get_stream_type(direction, &stream_type) != 0) { + ret = RET_MSG_ERROR_INTERNAL; goto finish; } - if (get_volume_level_by_type(m, GET_VOLUME_MAX_LEVEL, stream_type, type, &level)) { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_UINT32, &level, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_INTERNAL], DBUS_TYPE_INVALID)); - } else { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_UINT32, &level, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_OK], DBUS_TYPE_INVALID)); - } + if (get_volume_level_by_type(m, GET_VOLUME_MAX_LEVEL, stream_type, type, &level) != 0) + ret = RET_MSG_ERROR_INTERNAL; + finish: + pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_UINT32, &level, + DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret], + DBUS_TYPE_INVALID)); pa_assert_se(dbus_connection_send(conn, reply, NULL)); dbus_message_unref(reply); } static void handle_set_volume_mute(DBusConnection *conn, DBusMessage *msg, void *userdata) { + pa_stream_manager *m = (pa_stream_manager *)userdata; const char *direction = NULL; const char *type = NULL; - uint32_t do_mute = 0; + dbus_uint32_t do_mute = 0; stream_type_t stream_type = STREAM_SINK_INPUT; - DBusMessage *reply = NULL; - pa_stream_manager *m = (pa_stream_manager*)userdata; - int ret = 0; + ret_msg_t ret = RET_MSG_OK; pa_assert(conn); pa_assert(msg); @@ -1361,40 +1327,33 @@ static void handle_set_volume_mute(DBusConnection *conn, DBusMessage *msg, void DBUS_TYPE_INVALID)); pa_log_info("direction[%s], type[%s], do_mute[%u]", direction, type, do_mute); - pa_assert_se((reply = dbus_message_new_method_return(msg))); - - if (pa_safe_streq(direction, "in")) - stream_type = STREAM_SOURCE_OUTPUT; - else if (pa_safe_streq(direction, "out")) - stream_type = STREAM_SINK_INPUT; - else { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_INTERNAL], DBUS_TYPE_INVALID)); + if (get_stream_type(direction, &stream_type) != 0) { + ret = RET_MSG_ERROR_INTERNAL; goto finish; } /* check vconf update here, mute will not be set if update fails */ - if ((ret = update_mute_vconf(type, do_mute))) { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_INTERNAL], DBUS_TYPE_INVALID)); + if (update_mute_vconf(type, do_mute) != 0) { + ret = RET_MSG_ERROR_INTERNAL; goto finish; } - if (set_volume_mute_by_type(m, stream_type, type, (bool)do_mute)) - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_INTERNAL], DBUS_TYPE_INVALID)); - else - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_OK], DBUS_TYPE_INVALID)); + if (set_volume_mute_by_type(m, stream_type, type, (bool)do_mute) != 0) + ret = RET_MSG_ERROR_INTERNAL; finish: - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); + pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret]); } static void handle_get_volume_mute(DBusConnection *conn, DBusMessage *msg, void *userdata) { + pa_stream_manager *m = (pa_stream_manager *)userdata; const char *direction = NULL; const char *type = NULL; - uint32_t is_muted = 0; + dbus_uint32_t is_muted = 0; stream_type_t stream_type = STREAM_SINK_INPUT; DBusMessage *reply = NULL; - pa_stream_manager *m = (pa_stream_manager*)userdata; + bool _is_muted = false; + ret_msg_t ret = RET_MSG_OK; pa_assert(conn); pa_assert(msg); @@ -1408,38 +1367,33 @@ static void handle_get_volume_mute(DBusConnection *conn, DBusMessage *msg, void pa_assert_se((reply = dbus_message_new_method_return(msg))); - if (pa_safe_streq(direction, "in")) - stream_type = STREAM_SOURCE_OUTPUT; - else if (pa_safe_streq(direction, "out")) - stream_type = STREAM_SINK_INPUT; - else { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_UINT32, &is_muted, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_INTERNAL], DBUS_TYPE_INVALID)); - goto fail; + if (get_stream_type(direction, &stream_type) != 0) { + ret = RET_MSG_ERROR_INTERNAL; + goto finish; } - if (get_volume_mute_by_type(m, stream_type, type, (bool*)&is_muted)) { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_UINT32, &is_muted, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_INTERNAL], DBUS_TYPE_INVALID)); - } else { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_UINT32, &is_muted, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_OK], DBUS_TYPE_INVALID)); + if (get_volume_mute_by_type(m, stream_type, type, &_is_muted) != 0) { + ret = RET_MSG_ERROR_INTERNAL; + goto finish; } -fail: + is_muted = (dbus_uint32_t)_is_muted; + +finish: + pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_UINT32, &is_muted, + DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret], + DBUS_TYPE_INVALID)); pa_assert_se(dbus_connection_send(conn, reply, NULL)); dbus_message_unref(reply); } static void handle_set_volume_ratio(DBusConnection *conn, DBusMessage *msg, void *userdata) { + pa_stream_manager *m = (pa_stream_manager *)userdata; const char *direction = NULL; - uint32_t idx; + dbus_uint32_t idx; double ratio; stream_type_t stream_type = STREAM_SINK_INPUT; - DBusMessage *reply = NULL; - pa_stream_manager *m = (pa_stream_manager*)userdata; - int ret = 0; - ret_msg_t ret_msg = RET_MSG_ERROR_INTERNAL; + ret_msg_t ret = RET_MSG_OK; pa_assert(conn); pa_assert(msg); @@ -1452,49 +1406,34 @@ static void handle_set_volume_ratio(DBusConnection *conn, DBusMessage *msg, void DBUS_TYPE_INVALID)); pa_log_info("direction[%s], idx[%u], ratio[%f]", direction, idx, ratio); - pa_assert_se((reply = dbus_message_new_method_return(msg))); - - if (pa_safe_streq(direction, "in")) - stream_type = STREAM_SOURCE_OUTPUT; - else if (pa_safe_streq(direction, "out")) - stream_type = STREAM_SINK_INPUT; - else { + if (get_stream_type(direction, &stream_type) != 0) { pa_log_error("invalid direction[%s]", direction); - goto invalid_argument; + ret = RET_MSG_ERROR_INVALID_ARGUMENT; + goto finish; } /* Check the ratio range (0.0 ~ 1.0) */ if (ratio < 0 || ratio > 1) { pa_log_error("invalid range, ratio[%f]", ratio); - goto invalid_argument; - } - - if ((ret = set_volume_ratio_by_idx(m, stream_type, idx, ratio))) { - if (ret == -2) - ret_msg = RET_MSG_ERROR_NO_STREAM; - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret_msg], DBUS_TYPE_INVALID)); - } else { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_OK], DBUS_TYPE_INVALID)); + ret = RET_MSG_ERROR_INVALID_ARGUMENT; + goto finish; } - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); - return; + if ((ret = set_volume_ratio_by_idx(m, stream_type, idx, ratio)) != 0) + ret = (ret == -2) ? RET_MSG_ERROR_NO_STREAM : RET_MSG_ERROR_INTERNAL; -invalid_argument: - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_INVALID_ARGUMENT], - DBUS_TYPE_INVALID)); - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); +finish: + pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret]); } static void handle_get_volume_ratio(DBusConnection *conn, DBusMessage *msg, void *userdata) { + pa_stream_manager *m = (pa_stream_manager *)userdata; const char *direction = NULL; - uint32_t idx = 0; + dbus_uint32_t idx = 0; double ratio; stream_type_t stream_type = STREAM_SINK_INPUT; DBusMessage *reply = NULL; - pa_stream_manager *m = (pa_stream_manager*)userdata; + ret_msg_t ret = RET_MSG_OK; pa_assert(conn); pa_assert(msg); @@ -1508,38 +1447,33 @@ static void handle_get_volume_ratio(DBusConnection *conn, DBusMessage *msg, void pa_assert_se((reply = dbus_message_new_method_return(msg))); - if (pa_safe_streq(direction, "in")) - stream_type = STREAM_SOURCE_OUTPUT; - else if (pa_safe_streq(direction, "out")) - stream_type = STREAM_SINK_INPUT; - else { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_DOUBLE, &ratio, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_INVALID_ARGUMENT], DBUS_TYPE_INVALID)); + if (get_stream_type(direction, &stream_type) != 0) { + pa_log_error("invalid direction[%s]", direction); + ret = RET_MSG_ERROR_INVALID_ARGUMENT; goto finish; } - if (get_volume_ratio_by_idx(m, stream_type, idx, &ratio)) { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_DOUBLE, &ratio, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_NO_STREAM], DBUS_TYPE_INVALID)); - } else { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_DOUBLE, &ratio, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_OK], DBUS_TYPE_INVALID)); - } + if (get_volume_ratio_by_idx(m, stream_type, idx, &ratio) != 0) + ret = RET_MSG_ERROR_NO_STREAM; finish: + pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_DOUBLE, &ratio, + DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret], + DBUS_TYPE_INVALID)); pa_assert_se(dbus_connection_send(conn, reply, NULL)); dbus_message_unref(reply); } static void handle_get_current_volume_type(DBusConnection *conn, DBusMessage *msg, void *userdata) { + pa_stream_manager *m = (pa_stream_manager *)userdata; const char *direction = NULL; - const char *type = NULL; + const char *type = dbus_str_none; void *s = NULL; stream_type_t stream_type = STREAM_SINK_INPUT; DBusMessage *reply = NULL; - pa_stream_manager *m = (pa_stream_manager*)userdata; uint32_t idx = 0; pa_idxset *streams = NULL; + ret_msg_t ret = RET_MSG_OK; pa_assert(conn); pa_assert(msg); @@ -1552,18 +1486,13 @@ static void handle_get_current_volume_type(DBusConnection *conn, DBusMessage *ms pa_assert_se((reply = dbus_message_new_method_return(msg))); - if (pa_safe_streq(direction, "in")) { - stream_type = STREAM_SOURCE_OUTPUT; - streams = m->core->source_outputs; - } else if (pa_safe_streq(direction, "out")) { - stream_type = STREAM_SINK_INPUT; - streams = m->core->sink_inputs; - } else { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &dbus_str_none, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_INTERNAL], DBUS_TYPE_INVALID)); - goto fail; + if (get_stream_type(direction, &stream_type) != 0) { + ret = RET_MSG_ERROR_INTERNAL; + goto finish; } + streams = (stream_type == STREAM_SOURCE_OUTPUT) ? m->core->source_outputs : m->core->sink_inputs; + /* Get a volume type of a stream that has the max priority role among all the running streams regardless of devices. Note that it does not represent any focus status of a stream rather only checking the priority of it */ if (pa_idxset_size(streams)) { @@ -1590,27 +1519,26 @@ static void handle_get_current_volume_type(DBusConnection *conn, DBusMessage *ms type = cur_max_type; } - if (type) { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &type, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_OK], DBUS_TYPE_INVALID)); - } else { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &dbus_str_none, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_NO_STREAM], DBUS_TYPE_INVALID)); - } + if (!strncmp(type, dbus_str_none, strlen(dbus_str_none))) + ret = RET_MSG_ERROR_NO_STREAM; -fail: +finish: + pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &type, + DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret], + DBUS_TYPE_INVALID)); pa_assert_se(dbus_connection_send(conn, reply, NULL)); dbus_message_unref(reply); } static void handle_get_current_media_routing_path(DBusConnection *conn, DBusMessage *msg, void *userdata) { + pa_stream_manager *m = (pa_stream_manager *)userdata; const char *direction = NULL; - const char *device_type = NULL; + const char *device_type = dbus_str_none; dm_device_direction_t dm_device_direction = DM_DEVICE_DIRECTION_NONE; stream_info *s = NULL; DBusMessage *reply = NULL; pa_tz_device *device = NULL; - pa_stream_manager *m = (pa_stream_manager*)userdata; + ret_msg_t ret = RET_MSG_ERROR_INTERNAL; pa_assert(conn); pa_assert(msg); @@ -1629,12 +1557,12 @@ static void handle_get_current_media_routing_path(DBusConnection *conn, DBusMess dm_device_direction = DM_DEVICE_DIRECTION_OUT; } else { pa_log_error("invalid direction[%s]", direction); - goto fail; + goto finish; } if ((s = pa_hashmap_get(m->stream_infos, STREAM_ROLE_MEDIA)) == NULL) { pa_log_error("could not find media role"); - goto fail; + goto finish; } if (s->route_type == STREAM_ROUTE_TYPE_AUTO) { @@ -1643,39 +1571,34 @@ static void handle_get_current_media_routing_path(DBusConnection *conn, DBusMess device = get_media_last_device(m, dm_device_direction); } else { pa_log_error("unexpected routing type for media[%d]", s->route_type); - goto fail; + goto finish; } if (device) { device_type = pa_tz_device_get_type(device); - goto success; + ret = RET_MSG_OK; } else { pa_log_error("could not found matched device"); } -fail: - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &dbus_str_none, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_INTERNAL], DBUS_TYPE_INVALID)); - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); - return; -success: - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &device_type, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_OK], DBUS_TYPE_INVALID)); +finish: + pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &device_type, + DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret], + DBUS_TYPE_INVALID)); pa_assert_se(dbus_connection_send(conn, reply, NULL)); dbus_message_unref(reply); } static void handle_update_focus_status(DBusConnection *conn, DBusMessage *msg, void *userdata) { - uint32_t id = 0; + pa_stream_manager *m = (pa_stream_manager *)userdata; + dbus_uint32_t id = 0; + dbus_uint32_t acquired_focus_status = 0; uint32_t idx = 0; uint32_t count = 0; - uint32_t acquired_focus_status = 0; stream_parent *sp = NULL; void *stream = NULL; - DBusMessage *reply = NULL; - pa_stream_manager *m = (pa_stream_manager*)userdata; int prev_status = STREAM_FOCUS_ACQUIRED_NONE; + ret_msg_t ret = RET_MSG_OK; pa_assert(conn); pa_assert(msg); @@ -1687,8 +1610,6 @@ static void handle_update_focus_status(DBusConnection *conn, DBusMessage *msg, v DBUS_TYPE_INVALID)); pa_log_info("id[%u], acquired_focus_status[0x%x]", id, acquired_focus_status); - pa_assert_se((reply = dbus_message_new_method_return(msg))); - if ((sp = pa_hashmap_get(m->stream_parents, (const void*)id))) { if (sp->focus_status != acquired_focus_status) { /* need to update */ @@ -1717,24 +1638,21 @@ static void handle_update_focus_status(DBusConnection *conn, DBusMessage *msg, v } else { pa_log_error("could not find matching client for this parent_id[%u]", id); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_INTERNAL], DBUS_TYPE_INVALID)); - goto fail; + ret = RET_MSG_ERROR_INTERNAL; } - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_OK], DBUS_TYPE_INVALID)); -fail: - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); + + pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret]); } static void handle_update_focus_status_by_focus_id(DBusConnection *conn, DBusMessage *msg, void *userdata) { - int32_t id = 0; + pa_stream_manager *m = (pa_stream_manager *)userdata; + dbus_int32_t id = 0; + dbus_uint32_t acquired_focus_status = 0; uint32_t idx = 0; - uint32_t acquired_focus_status = 0; int32_t focus_id = 0; const char *focus_id_str; pa_sink_input *i = NULL; - DBusMessage *reply = NULL; - pa_stream_manager *m = (pa_stream_manager*)userdata; + ret_msg_t ret = RET_MSG_ERROR_INTERNAL; pa_assert(conn); pa_assert(msg); @@ -1746,36 +1664,37 @@ static void handle_update_focus_status_by_focus_id(DBusConnection *conn, DBusMes DBUS_TYPE_INVALID)); pa_log_info("id[%d], acquired_focus_status[0x%x]", id, acquired_focus_status); - pa_assert_se((reply = dbus_message_new_method_return(msg))); - /* Currently, we only support sink-inputs */ PA_IDXSET_FOREACH(i, m->core->sink_inputs, idx) { if ((focus_id_str = pa_proplist_gets(GET_STREAM_PROPLIST(i, STREAM_SINK_INPUT), PA_PROP_MEDIA_FOCUS_ID))) { if (pa_atoi(focus_id_str, &focus_id)) - continue; - if (id == focus_id) { + continue; + + if (id != focus_id) + continue; + pa_log_info("found matching sink-input(%p, %u) - focus_id(%d)", i, i->index, id); pa_proplist_sets(GET_STREAM_PROPLIST(i, STREAM_SINK_INPUT), PA_PROP_MEDIA_FOCUS_STATUS, acquired_focus_status ? STREAM_FOCUS_STATE_ACQUIRED : STREAM_FOCUS_STATE_RELEASED); + process_stream(m, i, STREAM_SINK_INPUT, PROCESS_COMMAND_CHANGE_ROUTE_BY_STREAM_FOCUS_CHANGED, false); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_OK], DBUS_TYPE_INVALID)); - goto success; + ret = RET_MSG_OK; + break; } - } } - pa_log_error("could not find matching stream for this focus_id[%i]", id); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_INTERNAL], DBUS_TYPE_INVALID)); -success: - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); + + if (ret != RET_MSG_OK) + pa_log_error("could not find matching stream for this focus_id[%d]", id); + + pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret]); } static void handle_update_restriction(DBusConnection *conn, DBusMessage *msg, void *userdata) { + pa_stream_manager *m = (pa_stream_manager *)userdata; const char *name; - uint32_t value = 0; - DBusMessage *reply = NULL; - pa_stream_manager *m = (pa_stream_manager*)userdata; + dbus_uint32_t value = 0; + ret_msg_t ret = RET_MSG_OK; pa_assert(conn); pa_assert(msg); @@ -1787,17 +1706,10 @@ static void handle_update_restriction(DBusConnection *conn, DBusMessage *msg, vo DBUS_TYPE_INVALID)); pa_log_info("name[%s], value[%u]", name, value); - pa_assert_se((reply = dbus_message_new_method_return(msg))); - - if (handle_restrictions(m, name, value) < 0) { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_INTERNAL], DBUS_TYPE_INVALID)); - goto fail; - } + if (handle_restrictions(m, name, value) != 0) + ret = RET_MSG_ERROR_INTERNAL; - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_OK], DBUS_TYPE_INVALID)); -fail: - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); + pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret]); } #define MAX_CALL_PARAM_SIZE 32 @@ -1851,9 +1763,8 @@ static int32_t parse_call_parameters(const char *parameters, char *call_type, ch } static void handle_update_call_parameters(DBusConnection *conn, DBusMessage *msg, void *userdata) { + pa_stream_manager *m = (pa_stream_manager *)userdata; const char *parameters; - DBusMessage *reply = NULL; - pa_stream_manager *m = (pa_stream_manager*)userdata; char call_type[MAX_CALL_PARAM_SIZE] = {0,}; char call_domain[MAX_CALL_PARAM_SIZE] = {0,}; char network_band[MAX_CALL_PARAM_SIZE] = {0,}; @@ -1869,33 +1780,27 @@ static void handle_update_call_parameters(DBusConnection *conn, DBusMessage *msg DBUS_TYPE_INVALID)); pa_log_info("parameters[%s]", parameters); - pa_assert_se((reply = dbus_message_new_method_return(msg))); - - if (parse_call_parameters(parameters, call_type, call_domain, network_band) < 0) { + if (parse_call_parameters(parameters, call_type, call_domain, network_band) != 0) { ret = RET_MSG_ERROR_INTERNAL; - goto fail; + goto finish; } pa_log_debug("call_type[%s], call_domain[%s], network_band[%s]", call_type, call_domain, network_band); /* Currently, we only use network band */ route_option.name = "call-wideband"; - if (pa_safe_streq(network_band, "wb")) - route_option.value = 1; - else - route_option.value = 0; + route_option.value = pa_safe_streq(network_band, "wb") ? 1 : 0; + ret = do_notify(m, NOTIFY_COMMAND_UPDATE_ROUTE_OPTION, STREAM_SINK_INPUT, false, &route_option); -fail: - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret], DBUS_TYPE_INVALID)); - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); +finish: + pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret]); } static void handle_set_filter(DBusConnection *conn, DBusMessage *msg, void *userdata) { + pa_stream_manager *m = (pa_stream_manager *)userdata; const char *filter_name, *filter_parameters, *filter_group, *stream_type; - DBusMessage *reply = NULL; - pa_stream_manager *m = (pa_stream_manager*)userdata; + ret_msg_t ret = RET_MSG_OK; pa_assert(conn); pa_assert(msg); @@ -1907,30 +1812,20 @@ static void handle_set_filter(DBusConnection *conn, DBusMessage *msg, void *user DBUS_TYPE_STRING, &filter_group, DBUS_TYPE_STRING, &stream_type, DBUS_TYPE_INVALID)); - pa_log_info("filter_name[%s], filter_parameters[%s], filter_group[%s], stream_type[%s]", filter_name, - filter_parameters, filter_group, stream_type); - - pa_assert_se((reply = dbus_message_new_method_return(msg))); + pa_log_info("filter_name[%s], filter_parameters[%s], filter_group[%s], stream_type[%s]", + filter_name, filter_parameters, filter_group, stream_type); /* Set filter sink according to stream type */ - if (update_filter(m, filter_name, filter_parameters, filter_group, stream_type) < 0) { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_INTERNAL], - DBUS_TYPE_INVALID)); - goto fail; - } - - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_OK], - DBUS_TYPE_INVALID)); + if (update_filter(m, filter_name, filter_parameters, filter_group, stream_type) != 0) + ret = RET_MSG_ERROR_INTERNAL; -fail: - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); + pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret]); } static void handle_unset_filter(DBusConnection *conn, DBusMessage *msg, void *userdata) { + pa_stream_manager *m = (pa_stream_manager *)userdata; const char *stream_type; - DBusMessage *reply = NULL; - pa_stream_manager *m = (pa_stream_manager*)userdata; + ret_msg_t ret = RET_MSG_OK; pa_assert(conn); pa_assert(msg); @@ -1941,27 +1836,17 @@ static void handle_unset_filter(DBusConnection *conn, DBusMessage *msg, void *us DBUS_TYPE_INVALID)); pa_log_info("stream_type[%s]", stream_type); - pa_assert_se((reply = dbus_message_new_method_return(msg))); - /* Unset filter sink according to stream type */ - if (update_filter(m, NULL, NULL, NULL, stream_type) < 0) { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_INTERNAL], - DBUS_TYPE_INVALID)); - goto fail; - } - - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_OK], - DBUS_TYPE_INVALID)); + if (update_filter(m, NULL, NULL, NULL, stream_type) != 0) + ret = RET_MSG_ERROR_INTERNAL; -fail: - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); + pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret]); } static void handle_control_filter(DBusConnection *conn, DBusMessage *msg, void *userdata) { + pa_stream_manager *m = (pa_stream_manager *)userdata; const char *filter_name, *filter_controls, *stream_type; - DBusMessage *reply = NULL; - pa_stream_manager *m = (pa_stream_manager*)userdata; + ret_msg_t ret = RET_MSG_OK; pa_assert(conn); pa_assert(msg); @@ -1974,20 +1859,11 @@ static void handle_control_filter(DBusConnection *conn, DBusMessage *msg, void * DBUS_TYPE_INVALID)); pa_log_info("filter_name[%s], filter_controls[%s], stream_type[%s]", filter_name, filter_controls, stream_type); - pa_assert_se((reply = dbus_message_new_method_return(msg))); - /* Control parameters to filter sink */ - if (control_filter(m, filter_name, filter_controls, stream_type, conn) < 0) { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_INTERNAL], - DBUS_TYPE_INVALID)); - goto fail; - } + if (control_filter(m, filter_name, filter_controls, stream_type, conn) != 0) + ret = RET_MSG_ERROR_INTERNAL; - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_OK], - DBUS_TYPE_INVALID)); -fail: - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); + pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret]); } static bool check_stream_exist_by_pid(pa_stream_manager *m, uint32_t pid, const char *stream_role, stream_type_t type) { @@ -2025,12 +1901,12 @@ static bool check_stream_exist_by_pid(pa_stream_manager *m, uint32_t pid, const } static void handle_check_stream_exist_by_pid(DBusConnection *conn, DBusMessage *msg, void *userdata) { - uint32_t pid = 0; + pa_stream_manager *m = (pa_stream_manager *)userdata; + dbus_uint32_t pid = 0; const char *type; const char *direction; stream_type_t stream_type = STREAM_SINK_INPUT; - DBusMessage *reply = NULL; - pa_stream_manager *m = (pa_stream_manager*)userdata; + ret_msg_t ret = RET_MSG_OK; pa_assert(conn); pa_assert(msg); @@ -2043,29 +1919,16 @@ static void handle_check_stream_exist_by_pid(DBusConnection *conn, DBusMessage * DBUS_TYPE_INVALID)); pa_log_info("pid[%u], type[%s], direction[%s]", pid, type, direction); - pa_assert_se((reply = dbus_message_new_method_return(msg))); - - if (pa_safe_streq(direction, "in")) - stream_type = STREAM_SOURCE_OUTPUT; - else if (pa_safe_streq(direction, "out")) - stream_type = STREAM_SINK_INPUT; - else { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_INVALID_ARGUMENT], - DBUS_TYPE_INVALID)); - goto fail; + if (get_stream_type(direction, &stream_type) != 0) { + ret = RET_MSG_ERROR_INVALID_ARGUMENT; + goto finish; } - if (!check_stream_exist_by_pid(m, pid, type, stream_type)) { - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_NO_STREAM], - DBUS_TYPE_INVALID)); - goto fail; - } + if (!check_stream_exist_by_pid(m, pid, type, stream_type)) + ret = RET_MSG_ERROR_NO_STREAM; - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_OK], - DBUS_TYPE_INVALID)); -fail: - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); +finish: + pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret]); } static bool find_the_lastest_stream(pa_stream_manager *m, stream_type_t type, const char ** stream_roles, int length, uint32_t *pid) { @@ -2126,15 +1989,15 @@ static bool find_the_lastest_stream(pa_stream_manager *m, stream_type_t type, co } static void handle_get_pid_of_latest_stream(DBusConnection *conn, DBusMessage *msg, void *userdata) { + pa_stream_manager *m = (pa_stream_manager *)userdata; const char *direction; const char **types; int length; stream_type_t stream_type = STREAM_SINK_INPUT; uint32_t pid = 0; - ret_msg_t ret_msg = RET_MSG_OK; + ret_msg_t ret = RET_MSG_OK; DBusMessage *reply = NULL; - pa_stream_manager *m = (pa_stream_manager*)userdata; pa_assert(conn); pa_assert(msg); @@ -2147,48 +2010,38 @@ static void handle_get_pid_of_latest_stream(DBusConnection *conn, DBusMessage *m pa_assert_se((reply = dbus_message_new_method_return(msg))); - if (pa_safe_streq(direction, "in")) - stream_type = STREAM_SOURCE_OUTPUT; - else if (pa_safe_streq(direction, "out")) - stream_type = STREAM_SINK_INPUT; - else { + if (get_stream_type(direction, &stream_type) != 0) { pa_log_error("invalid direction[%s]", direction); - goto invalid_argument; + ret = RET_MSG_ERROR_INVALID_ARGUMENT; + goto finish; } if (length <= 0) { pa_log_error("At least one stream type should be contained"); - goto invalid_argument; + ret = RET_MSG_ERROR_INVALID_ARGUMENT; + goto finish; } if (!find_the_lastest_stream(m, stream_type, types, length, &pid)) - ret_msg = RET_MSG_ERROR_NO_STREAM; - - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_UINT32, &pid, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret_msg], - DBUS_TYPE_INVALID)); - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); - return; + ret = RET_MSG_ERROR_NO_STREAM; -invalid_argument: - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_UINT32, &pid, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[RET_MSG_ERROR_INVALID_ARGUMENT], - DBUS_TYPE_INVALID)); +finish: + pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_UINT32, &pid, + DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret], + DBUS_TYPE_INVALID)); pa_assert_se(dbus_connection_send(conn, reply, NULL)); dbus_message_unref(reply); } static void handle_activate_ducking(DBusConnection *conn, DBusMessage *msg, void *userdata) { + pa_stream_manager *m = (pa_stream_manager *)userdata; dbus_uint32_t id = 0; dbus_bool_t enable = 0; const char *target_stream = NULL; - uint32_t idx = 0; - pa_sink_input *i = NULL; dbus_uint32_t duration = 0; double ratio = 0.0; - DBusMessage *reply = NULL; - pa_stream_manager *m = (pa_stream_manager*)userdata; + uint32_t idx = 0; + pa_sink_input *i = NULL; pa_cvolume vol; pa_cvolume_ramp vol_ramp; stream_ducking *sd = NULL; @@ -2210,8 +2063,6 @@ static void handle_activate_ducking(DBusConnection *conn, DBusMessage *msg, void pa_log_info("id[%u], enable[%u], target stream[%s], duration[%u], ratio[%lf]", id, enable, target_stream, duration, ratio); - pa_assert_se((reply = dbus_message_new_method_return(msg))); - /* get stream_ducking */ sd = pa_hashmap_get(m->stream_duckings, (const void*)id); if (!sd) { @@ -2281,9 +2132,7 @@ static void handle_activate_ducking(DBusConnection *conn, DBusMessage *msg, void pa_log_info("ducking stream count[%p,%d]", sd, sd->ducking_stream_count); _ACTIVATE_DUCKING_DONE: - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret_msg], DBUS_TYPE_INVALID)); - pa_assert_se(dbus_connection_send(conn, reply, NULL)); - dbus_message_unref(reply); + pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret_msg]); if (ret_msg != RET_MSG_OK) return; @@ -2315,9 +2164,9 @@ _ACTIVATE_DUCKING_DONE: } static void handle_get_ducking_state(DBusConnection *conn, DBusMessage *msg, void *userdata) { + pa_stream_manager *m = (pa_stream_manager *)userdata; dbus_uint32_t id = 0; DBusMessage *reply = NULL; - pa_stream_manager *m = (pa_stream_manager*)userdata; stream_ducking *sd = NULL; dbus_bool_t is_ducked = FALSE; ret_msg_t ret_msg = RET_MSG_OK; @@ -2334,16 +2183,19 @@ static void handle_get_ducking_state(DBusConnection *conn, DBusMessage *msg, voi /* get stream_ducking */ sd = pa_hashmap_get(m->stream_duckings, (const void *)id); - if (sd) { - is_ducked = (dbus_bool_t)is_stream_ducked(sd); - pa_log_info("id[%u], is_ducked[%p,%d]", id, sd, is_ducked); - } else { - ret_msg = RET_MSG_ERROR_INTERNAL; + if (!sd) { pa_log_error("no matched stream ducking for id[%u]", id); + ret_msg = RET_MSG_ERROR_INTERNAL; + goto finish; } - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &is_ducked, DBUS_TYPE_INVALID)); - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret_msg], DBUS_TYPE_INVALID)); + is_ducked = (dbus_bool_t)is_stream_ducked(sd); + pa_log_info("id[%u], is_ducked[%p,%d]", id, sd, is_ducked); + +finish: + pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &is_ducked, + DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret_msg], + DBUS_TYPE_INVALID)); pa_assert_se(dbus_connection_send(conn, reply, NULL)); dbus_message_unref(reply); @@ -2382,11 +2234,11 @@ static int dbus_launch_mdnsd(pa_stream_manager *m, DBusConnection *conn) { } static void handle_set_remote_permission(DBusConnection *conn, DBusMessage *msg, void *userdata) { - pa_stream_manager *m = (pa_stream_manager*)userdata; + pa_stream_manager *m = (pa_stream_manager *)userdata; + const char *type = NULL; dbus_uint32_t index; dbus_bool_t allowed; pa_proplist *p = NULL; - char *type = NULL; pa_assert(conn); pa_assert(msg); @@ -2403,7 +2255,7 @@ static void handle_set_remote_permission(DBusConnection *conn, DBusMessage *msg, goto out; } - pa_log_info("type(%s), index(%d), allowed(%d)", type, index, allowed); + pa_log_info("type(%s), index(%u), allowed(%u)", type, index, allowed); p = pa_proplist_new(); if (!p) { @@ -2417,9 +2269,7 @@ static void handle_set_remote_permission(DBusConnection *conn, DBusMessage *msg, } if (pa_streq(type, "sink-input")) { - pa_sink_input *i; - - i = pa_idxset_get_by_index(m->core->sink_inputs, index); + pa_sink_input *i = pa_idxset_get_by_index(m->core->sink_inputs, index); if (!i) { pa_log_error("not found sink-input"); goto out; @@ -2431,9 +2281,7 @@ static void handle_set_remote_permission(DBusConnection *conn, DBusMessage *msg, } } else if (pa_streq(type, "source-output")) { - pa_source_output *o; - - o = pa_idxset_get_by_index(m->core->source_outputs, index); + pa_source_output *o = pa_idxset_get_by_index(m->core->source_outputs, index); if (!o) { pa_log_error("not found source-output"); goto out; @@ -2456,7 +2304,7 @@ out: } static void handle_discover_remote_device(DBusConnection *conn, DBusMessage *msg, void *userdata) { - pa_stream_manager *m = (pa_stream_manager*)userdata; + pa_stream_manager *m = (pa_stream_manager *)userdata; pa_module *module; dbus_bool_t enable; @@ -2468,7 +2316,7 @@ static void handle_discover_remote_device(DBusConnection *conn, DBusMessage *msg DBUS_TYPE_BOOLEAN, &enable, DBUS_TYPE_INVALID)); - pa_log_info("discover module enable(%d)", enable); + pa_log_info("discover module enable(%u)", enable); if (enable) { if (m->m_discover) { @@ -2494,7 +2342,6 @@ static void handle_discover_remote_device(DBusConnection *conn, DBusMessage *msg } pa_dbus_send_empty_reply(conn, msg); - return; error: @@ -2503,7 +2350,7 @@ error: } static void handle_publish_local_device(DBusConnection *conn, DBusMessage *msg, void *userdata) { - pa_stream_manager *m = (pa_stream_manager*)userdata; + pa_stream_manager *m = (pa_stream_manager *)userdata; pa_module *module; dbus_bool_t enable; @@ -2515,7 +2362,7 @@ static void handle_publish_local_device(DBusConnection *conn, DBusMessage *msg, DBUS_TYPE_BOOLEAN, &enable, DBUS_TYPE_INVALID)); - pa_log_info("publish module enable(%d)", enable); + pa_log_info("publish module enable(%u)", enable); if (enable) { if (m->m_protocol_tcp || m->m_publish) { @@ -2552,7 +2399,6 @@ static void handle_publish_local_device(DBusConnection *conn, DBusMessage *msg, } pa_dbus_send_empty_reply(conn, msg); - return; error: @@ -2562,7 +2408,7 @@ error: static DBusHandlerResult handle_methods(DBusConnection *conn, DBusMessage *msg, void *userdata) { int idx = 0; - pa_stream_manager *m = (pa_stream_manager*)userdata; + pa_stream_manager *m = (pa_stream_manager *)userdata; pa_assert(conn); pa_assert(msg); @@ -2586,7 +2432,7 @@ static DBusHandlerResult handle_methods(DBusConnection *conn, DBusMessage *msg, } static DBusHandlerResult method_handler_for_vt(DBusConnection *c, DBusMessage *m, void *userdata) { - pa_stream_manager *u = (pa_stream_manager*)userdata; + pa_stream_manager *u = (pa_stream_manager *)userdata; const char *path, *interface, *member; pa_assert(c); -- 2.7.4 From f7bc5b411064012739f3944ee98e96b1c676a0f8 Mon Sep 17 00:00:00 2001 From: Seungbae Shin Date: Thu, 29 Oct 2020 17:51:05 +0900 Subject: [PATCH 04/16] Fix various improper memory handling bugs - memory leaks due to missing message unref - memory leaks due to missing dbus string array free. - potential memory corruption due to passing different size of data type. - use-after-free of string retrieved by dbus_message_iter_get_basic() - use duplicated string for strtok_r() [Version] 13.0.37 [Issue Type] Bug Change-Id: I6dea62168cef2fd1387f1e1a3ffc37eb2fe47fa5 --- packaging/pulseaudio-modules-tizen.spec | 2 +- src/device-manager-dbus.c | 17 +++++--- src/stream-manager-dbus.c | 72 +++++++++++++++++++-------------- src/subscribe-observer.c | 2 +- src/tizen-device.c | 18 ++++++--- 5 files changed, 67 insertions(+), 44 deletions(-) diff --git a/packaging/pulseaudio-modules-tizen.spec b/packaging/pulseaudio-modules-tizen.spec index 9f5b1f7..7c7715c 100644 --- a/packaging/pulseaudio-modules-tizen.spec +++ b/packaging/pulseaudio-modules-tizen.spec @@ -1,6 +1,6 @@ Name: pulseaudio-modules-tizen Summary: Pulseaudio modules for Tizen -Version: 13.0.36 +Version: 13.0.37 Release: 0 Group: Multimedia/Audio License: LGPL-2.1+ diff --git a/src/device-manager-dbus.c b/src/device-manager-dbus.c index 52e87e1..2bc5dbd 100644 --- a/src/device-manager-dbus.c +++ b/src/device-manager-dbus.c @@ -481,7 +481,7 @@ static int handle_bluez_headset_property_changed(DBusConnection *c, DBusMessage return -1; } handle_device_status_changed(dm, DEVICE_TYPE_BT_SCO, name, dbus_message_get_path(s), detected); - + pa_xfree(name); } else if (pa_safe_streq(property_name, "Playing")) { pa_tz_device *device; pa_log_info("SCO Playing : %d", value); @@ -639,6 +639,7 @@ static int method_call_bt_get_name(DBusConnection *conn, const char *device_path DBusMessage *msg, *reply; DBusMessageIter reply_iter, variant_iter; DBusError err; + const char *_name; pa_assert(conn); pa_assert(device_path); @@ -654,23 +655,27 @@ static int method_call_bt_get_name(DBusConnection *conn, const char *device_path DBUS_TYPE_INVALID)); dbus_error_init(&err); - if (!(reply = dbus_connection_send_with_reply_and_block(conn, msg, -1, &err))) { + + reply = dbus_connection_send_with_reply_and_block(conn, msg, DBUS_TIMEOUT_USE_DEFAULT, &err); + dbus_message_unref(msg); + if (!reply) { pa_log_error("Failed to method call %s.%s, %s", DBUS_INTERFACE_BLUEZ_DEVICE, "Get", err.message); dbus_error_free(&err); return -1; } - dbus_message_iter_init(reply, &reply_iter); + dbus_message_iter_init(reply, &reply_iter); if (dbus_message_iter_get_arg_type(&reply_iter) != DBUS_TYPE_VARIANT) { pa_log_error("Cannot get reply argument"); return -1; } - dbus_message_iter_recurse(&reply_iter, &variant_iter); + dbus_message_iter_recurse(&reply_iter, &variant_iter); if (dbus_message_iter_get_arg_type(&variant_iter) == DBUS_TYPE_STRING) { - dbus_message_iter_get_basic(&variant_iter, name); + dbus_message_iter_get_basic(&variant_iter, &_name); + *name = pa_xstrdup(_name); } dbus_message_unref(reply); @@ -1666,7 +1671,7 @@ static void fill_signal_msg_with_device(const char *description, DBusMessageIter void send_device_connection_changed_signal(uint32_t event_id, pa_tz_device *device, bool connected, pa_device_manager *dm) { DBusMessage *signal_msg; DBusMessageIter msg_iter; - dbus_bool_t _connected = connected; + dbus_bool_t _connected = (dbus_bool_t)connected; pa_assert(device); pa_assert(dm); diff --git a/src/stream-manager-dbus.c b/src/stream-manager-dbus.c index d5c87b3..d81d157 100644 --- a/src/stream-manager-dbus.c +++ b/src/stream-manager-dbus.c @@ -1717,6 +1717,7 @@ static int32_t parse_call_parameters(const char *parameters, char *call_type, ch const char delimiter[] = ";"; char *token, *ptr = NULL; char key[32] = ""; + char *_parameters = NULL; pa_assert(parameters); pa_assert(call_type); @@ -1725,39 +1726,44 @@ static int32_t parse_call_parameters(const char *parameters, char *call_type, ch pa_log_info("parameters[%s]", parameters); - /*Reset the call parameters*/ + _parameters = pa_xstrdup(parameters); + if (!_parameters) { + pa_log_error("string duplication error!"); + return -1; + } + + /* Reset the call parameters */ memset(call_type, 0, MAX_CALL_PARAM_SIZE); memset(call_domain, 0, MAX_CALL_PARAM_SIZE); memset(network_band, 0, MAX_CALL_PARAM_SIZE); - if (parameters) { - token = strtok_r((char *)parameters, delimiter, &ptr); - while (token) { - char *delimiter_ptr = NULL; - char *value = NULL; - - delimiter_ptr = strstr(token, "="); - if (!delimiter_ptr) { - token = strtok_r(NULL, delimiter, &ptr); - continue; - } - strncpy(key, token, delimiter_ptr - token); - value = delimiter_ptr + 1; - pa_log_debug("key(%s), value(%s)", key, value); - if (!strncmp(key, "call-type", strlen("call-type"))) - pa_strlcpy(call_type, value, MAX_CALL_PARAM_SIZE); - else if (!strncmp(key, "call-domain", strlen("call-domain"))) - pa_strlcpy(call_domain, value, MAX_CALL_PARAM_SIZE); - else if (!strncmp(key, "network-band", strlen("network-band"))) - pa_strlcpy(network_band, value, MAX_CALL_PARAM_SIZE); - else - pa_log_warn("not supported key(%s)", key); + token = strtok_r(_parameters, delimiter, &ptr); + while (token) { + char *delimiter_ptr = NULL; + char *value = NULL; + delimiter_ptr = strstr(token, "="); + if (!delimiter_ptr) { token = strtok_r(NULL, delimiter, &ptr); - memset(key, 0, sizeof(key)); + continue; } - pa_log_info("call-type[%s], call-domain[%s], network-band[%s]", call_type, call_domain, network_band); + strncpy(key, token, delimiter_ptr - token); + value = delimiter_ptr + 1; + pa_log_debug("key(%s), value(%s)", key, value); + if (!strncmp(key, "call-type", strlen("call-type"))) + pa_strlcpy(call_type, value, MAX_CALL_PARAM_SIZE); + else if (!strncmp(key, "call-domain", strlen("call-domain"))) + pa_strlcpy(call_domain, value, MAX_CALL_PARAM_SIZE); + else if (!strncmp(key, "network-band", strlen("network-band"))) + pa_strlcpy(network_band, value, MAX_CALL_PARAM_SIZE); + else + pa_log_warn("not supported key(%s)", key); + + token = strtok_r(NULL, delimiter, &ptr); + memset(key, 0, sizeof(key)); } + pa_log_info("call-type[%s], call-domain[%s], network-band[%s]", call_type, call_domain, network_band); + pa_xfree(_parameters); return 0; } @@ -1991,7 +1997,7 @@ static bool find_the_lastest_stream(pa_stream_manager *m, stream_type_t type, co static void handle_get_pid_of_latest_stream(DBusConnection *conn, DBusMessage *msg, void *userdata) { pa_stream_manager *m = (pa_stream_manager *)userdata; const char *direction; - const char **types; + char **types; int length; stream_type_t stream_type = STREAM_SINK_INPUT; uint32_t pid = 0; @@ -2022,7 +2028,7 @@ static void handle_get_pid_of_latest_stream(DBusConnection *conn, DBusMessage *m goto finish; } - if (!find_the_lastest_stream(m, stream_type, types, length, &pid)) + if (!find_the_lastest_stream(m, stream_type, (const char **)types, length, &pid)) ret = RET_MSG_ERROR_NO_STREAM; finish: @@ -2031,6 +2037,8 @@ finish: DBUS_TYPE_INVALID)); pa_assert_se(dbus_connection_send(conn, reply, NULL)); dbus_message_unref(reply); + + dbus_free_string_array(types); } static void handle_activate_ducking(DBusConnection *conn, DBusMessage *msg, void *userdata) { @@ -2220,14 +2228,16 @@ static int dbus_launch_mdnsd(pa_stream_manager *m, DBusConnection *conn) { pa_assert_se(dbus_message_append_args(msg, DBUS_TYPE_STRING, &name, DBUS_TYPE_INVALID)); dbus_error_init(&err); - if (!(reply = dbus_connection_send_with_reply_and_block(conn, msg, -1, &err))) { + + reply = dbus_connection_send_with_reply_and_block(conn, msg, DBUS_TIMEOUT_USE_DEFAULT, &err); + dbus_message_unref(msg); + if (!reply) { pa_log_error("Failed to method call : %s", err.message); dbus_error_free(&err); return -1; } dbus_message_unref(reply); - pa_log_info("success"); return 0; @@ -2523,7 +2533,7 @@ void send_remote_found_signal(DBusConnection *conn, int type, bool connected, un const char *name, const char *description) { DBusMessage *signal_msg; DBusMessageIter msg_iter; - dbus_bool_t c = (dbus_bool_t)connected; + dbus_bool_t _connected = (dbus_bool_t)connected; pa_assert(conn); @@ -2539,7 +2549,7 @@ void send_remote_found_signal(DBusConnection *conn, int type, bool connected, un dbus_message_iter_append_basic(&msg_iter, DBUS_TYPE_INT32, &type); dbus_message_iter_append_basic(&msg_iter, DBUS_TYPE_UINT32, &index); - dbus_message_iter_append_basic(&msg_iter, DBUS_TYPE_BOOLEAN, &c); + dbus_message_iter_append_basic(&msg_iter, DBUS_TYPE_BOOLEAN, &_connected); dbus_message_iter_append_basic(&msg_iter, DBUS_TYPE_STRING, &name); dbus_message_iter_append_basic(&msg_iter, DBUS_TYPE_STRING, &description); diff --git a/src/subscribe-observer.c b/src/subscribe-observer.c index a8ec66a..b6e7d70 100644 --- a/src/subscribe-observer.c +++ b/src/subscribe-observer.c @@ -193,7 +193,7 @@ static int get_sender_pid(DBusConnection *c, DBusMessage *got_msg, uint32_t *_se DBUS_TYPE_INVALID)); dbus_error_init(&err); - if (!(reply = dbus_connection_send_with_reply_and_block(c, msg, -1, &err))) { + if (!(reply = dbus_connection_send_with_reply_and_block(c, msg, DBUS_TIMEOUT_USE_DEFAULT, &err))) { pa_log_error("Failed to method call %s.%s, %s", intf, method, err.message); dbus_error_free(&err); goto fail; diff --git a/src/tizen-device.c b/src/tizen-device.c index 4f90d45..996098a 100644 --- a/src/tizen-device.c +++ b/src/tizen-device.c @@ -836,6 +836,7 @@ static int method_call_bt_sco_enable_pcm(pa_dbus_connection *conn, bool enable) DBusMessage *msg, *reply; DBusError err; const char *method = "SetVoiceDial"; + dbus_bool_t _enable = (dbus_bool_t)enable; pa_assert(conn); @@ -844,9 +845,12 @@ static int method_call_bt_sco_enable_pcm(pa_dbus_connection *conn, bool enable) return -1; } + pa_assert_se(dbus_message_append_args(msg, DBUS_TYPE_BOOLEAN, &_enable, DBUS_TYPE_INVALID)); + dbus_error_init(&err); - pa_assert_se(dbus_message_append_args(msg, DBUS_TYPE_BOOLEAN, &enable, DBUS_TYPE_INVALID)); - if (!(reply = dbus_connection_send_with_reply_and_block(pa_dbus_connection_get(conn), msg, -1, &err))) { + reply = dbus_connection_send_with_reply_and_block(pa_dbus_connection_get(conn), msg, DBUS_TIMEOUT_USE_DEFAULT, &err); + dbus_message_unref(msg); + if (!reply) { pa_log_error("Failed to method call %s.%s, %s", DBUS_INTERFACE_HFP_AGENT, method, err.message); dbus_error_free(&err); return -1; @@ -870,7 +874,9 @@ static int method_call_bt_sco(pa_dbus_connection *conn, bool onoff) { } dbus_error_init(&err); - if (!(reply = dbus_connection_send_with_reply_and_block(pa_dbus_connection_get(conn), msg, -1, &err))) { + reply = dbus_connection_send_with_reply_and_block(pa_dbus_connection_get(conn), msg, DBUS_TIMEOUT_USE_DEFAULT, &err); + dbus_message_unref(msg); + if (!reply) { pa_log_error("Failed to method call %s.%s, %s", DBUS_INTERFACE_HFP_AGENT, method, err.message); dbus_error_free(&err); return -1; @@ -900,7 +906,9 @@ static int method_call_bt_sco_get_property(pa_dbus_connection *conn, bool *is_wi } dbus_error_init(&err); - if (!(reply = dbus_connection_send_with_reply_and_block(pa_dbus_connection_get(conn), msg, -1, &err))) { + reply = dbus_connection_send_with_reply_and_block(pa_dbus_connection_get(conn), msg, DBUS_TIMEOUT_USE_DEFAULT, &err); + dbus_message_unref(msg); + if (!reply) { pa_log_error("Failed to method call %s.%s, %s", DBUS_INTERFACE_HFP_AGENT, "GetProperties", err.message); dbus_error_free(&err); return -1; @@ -936,7 +944,7 @@ static int method_call_bt_sco_get_property(pa_dbus_connection *conn, bool *is_wi if (dbus_message_iter_get_arg_type(&dict_entry_val) != DBUS_TYPE_BOOLEAN) continue; dbus_message_iter_get_basic(&dict_entry_val, &nrec); - pa_log_debug("nrec= [%d]", nrec); + pa_log_debug("nrec = [%d]", nrec); *is_nrec = nrec; } -- 2.7.4 From 80f842ad723832fd4acdb2fc73fedeb16c806227 Mon Sep 17 00:00:00 2001 From: Jaechul Lee Date: Wed, 4 Nov 2020 14:20:36 +0900 Subject: [PATCH 05/16] Add null-sink argument norewinds=1 null-sink takes almost 2 seconds when starting to play sound. [Version] 13.0.38 [Issue Type] Improvement Change-Id: If53a67c1f822f032f8f3590566b4eaa3b6265d7c Signed-off-by: Jaechul Lee --- packaging/pulseaudio-modules-tizen.spec | 2 +- src/module-tizenaudio-policy.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/packaging/pulseaudio-modules-tizen.spec b/packaging/pulseaudio-modules-tizen.spec index 7c7715c..6178a05 100644 --- a/packaging/pulseaudio-modules-tizen.spec +++ b/packaging/pulseaudio-modules-tizen.spec @@ -1,6 +1,6 @@ Name: pulseaudio-modules-tizen Summary: Pulseaudio modules for Tizen -Version: 13.0.37 +Version: 13.0.38 Release: 0 Group: Multimedia/Audio License: LGPL-2.1+ diff --git a/src/module-tizenaudio-policy.c b/src/module-tizenaudio-policy.c index 2ba8198..f1563aa 100644 --- a/src/module-tizenaudio-policy.c +++ b/src/module-tizenaudio-policy.c @@ -1814,7 +1814,7 @@ int pa__init(pa_module *m) u->stream_manager = pa_stream_manager_get(u->core); /* load null sink/source */ - args = pa_sprintf_malloc("sink_name=%s", SINK_NAME_NULL); + args = pa_sprintf_malloc("sink_name=%s norewinds=1", SINK_NAME_NULL); if (pa_module_load(&u->module_null_sink, u->core, MODULE_NULL_SINK, args)) pa_log_error("failed to load module-null-sink"); pa_xfree(args); -- 2.7.4 From e65d41959c8558998c0093d892bddc6b2dfd65f3 Mon Sep 17 00:00:00 2001 From: Sangchul Lee Date: Thu, 19 Nov 2020 15:37:20 +0900 Subject: [PATCH 06/16] stream-manager: Invoke ramp finish hook when ducking stream is corked If a user corks a stream that ducking is in progress, it can not get a ramp finish callback from the pulseaudio core. It leads to invalid state of the stream ducking handle, therefore it is fixed to trigger the callback forcedly when this situation happens. [Version] 13.0.39 [Issue Type] Bug fix Change-Id: Icbe7d4ce2d70fcbfbba9afb2555a38308df18349 Signed-off-by: Sangchul Lee --- packaging/pulseaudio-modules-tizen.spec | 2 +- src/stream-manager.c | 31 ++++++++++++++++++++++--------- 2 files changed, 23 insertions(+), 10 deletions(-) diff --git a/packaging/pulseaudio-modules-tizen.spec b/packaging/pulseaudio-modules-tizen.spec index 6178a05..ea1c478 100644 --- a/packaging/pulseaudio-modules-tizen.spec +++ b/packaging/pulseaudio-modules-tizen.spec @@ -1,6 +1,6 @@ Name: pulseaudio-modules-tizen Summary: Pulseaudio modules for Tizen -Version: 13.0.38 +Version: 13.0.39 Release: 0 Group: Multimedia/Audio License: LGPL-2.1+ diff --git a/src/stream-manager.c b/src/stream-manager.c index 4507a71..4c12613 100644 --- a/src/stream-manager.c +++ b/src/stream-manager.c @@ -2416,8 +2416,8 @@ static void remove_sink_input_from_muted_streams(pa_stream_manager *m, pa_sink_i pa_idxset_remove_by_data(streams, i, NULL); } -/* Remove the sink-input from ducking streams */ -static void remove_sink_input_from_ducking_streams(pa_stream_manager *m, pa_sink_input *i) { +/* It can be utilized when it requires to invoke the ramp finish hook forcedly */ +static stream_ducking* fire_ramp_finish_hook_when_ducking_or_unducking_state(pa_stream_manager *m, pa_sink_input *i) { uint32_t idx = 0; stream_ducking *sd = NULL; void *stream = NULL; @@ -2429,17 +2429,29 @@ static void remove_sink_input_from_ducking_streams(pa_stream_manager *m, pa_sink PA_IDXSET_FOREACH(stream, sd->idx_ducking_streams, idx) { if (stream != i) continue; - if (sd->state == STREAM_DUCKING_STATE_DUCKING || - sd->state == STREAM_DUCKING_STATE_UNDUCKING) + sd->state == STREAM_DUCKING_STATE_UNDUCKING) { + pa_log_debug("stream(%p, index:%u) ducking state[%s]", + i, i->index, sd->state == STREAM_DUCKING_STATE_DUCKING ? "DUCKING" : "UNDUCKING"); pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_RAMP_FINISH], i); + } + return sd; + } + } - pa_log_error("remove stream(idx:%u,%p) from idx_ducking_streams, trigger_index(%u)", - i->index, i, sd->trigger_index); - pa_idxset_remove_by_data(sd->idx_ducking_streams, i, NULL); + return NULL; +} - return; - } +/* Remove the sink-input from ducking streams */ +static void remove_sink_input_from_ducking_streams(pa_stream_manager *m, pa_sink_input *i) { + stream_ducking *sd; + + pa_assert(m); + + if ((sd = fire_ramp_finish_hook_when_ducking_or_unducking_state(m, i))) { + pa_log_error("remove stream(%p, index:%u) from idx_ducking_streams, trigger_index(%u)", + i, i->index, sd->trigger_index); + pa_idxset_remove_by_data(sd->idx_ducking_streams, i, NULL); } } @@ -2537,6 +2549,7 @@ static pa_hook_result_t sink_input_state_changed_cb(pa_core *core, pa_sink_input switch (i->state) { case PA_SINK_INPUT_CORKED: process_stream(m, i, STREAM_SINK_INPUT, PROCESS_COMMAND_CHANGE_ROUTE_BY_STATE_CHANGED_CORKED, false); + fire_ramp_finish_hook_when_ducking_or_unducking_state(m, i); break; case PA_SINK_INPUT_RUNNING: process_stream(m, i, STREAM_SINK_INPUT, PROCESS_COMMAND_CHANGE_ROUTE_BY_STATE_CHANGED_RUNNING, false); -- 2.7.4 From ed7d1881cf551513456def0897e6cbdf1c3f0c03 Mon Sep 17 00:00:00 2001 From: Jaechul Lee Date: Wed, 9 Dec 2020 12:39:58 +0900 Subject: [PATCH 07/16] tizenaudio-policy: Add max_latency_msec to 100ms This patch improves the latency of null-src [Version] 13.0.40 [Issue Type] Improvement Change-Id: Idf6b2c985dd400a04f71ae5892ed6bd6517612fb Signed-off-by: Jaechul Lee --- packaging/pulseaudio-modules-tizen.spec | 2 +- src/module-tizenaudio-policy.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/packaging/pulseaudio-modules-tizen.spec b/packaging/pulseaudio-modules-tizen.spec index ea1c478..2eb1819 100644 --- a/packaging/pulseaudio-modules-tizen.spec +++ b/packaging/pulseaudio-modules-tizen.spec @@ -1,6 +1,6 @@ Name: pulseaudio-modules-tizen Summary: Pulseaudio modules for Tizen -Version: 13.0.39 +Version: 13.0.40 Release: 0 Group: Multimedia/Audio License: LGPL-2.1+ diff --git a/src/module-tizenaudio-policy.c b/src/module-tizenaudio-policy.c index f1563aa..04d75b7 100644 --- a/src/module-tizenaudio-policy.c +++ b/src/module-tizenaudio-policy.c @@ -1818,7 +1818,7 @@ int pa__init(pa_module *m) if (pa_module_load(&u->module_null_sink, u->core, MODULE_NULL_SINK, args)) pa_log_error("failed to load module-null-sink"); pa_xfree(args); - args = pa_sprintf_malloc("source_name=%s", SOURCE_NAME_NULL); + args = pa_sprintf_malloc("source_name=%s max_latency_msec=100", SOURCE_NAME_NULL); if (pa_module_load(&u->module_null_source, u->core, MODULE_NULL_SOURCE, args)) pa_log_error("failed to load module-null-source"); pa_xfree(args); -- 2.7.4 From 08182979d2b52cccca3042f5e0c638bf4dc8a226 Mon Sep 17 00:00:00 2001 From: Seungbae Shin Date: Fri, 11 Dec 2020 17:50:16 +0900 Subject: [PATCH 08/16] tone-player: Fix asan defect (stack-buffer-underflow) ==pulseaudio==799==ERROR: AddressSanitizer: stack-buffer-underflow on address 0xbdc65da0 at pc 0xb5c397ad bp 0xbdc60db0 sp 0xbdc60e00 READ of size 22 at 0xbdc65da0 thread T0 #0 0xb5c397aa in printf_common(void*, char const*, std::__va_list) (/usr/lib/libasan.so+0x757aa) #1 0xb5c3b11c in vsnprintf (/usr/lib/libasan.so+0x7711c) #2 0xb58ca3ba in pa_vsnprintf (/usr/lib/pulseaudio/libpulsecommon-13.0.so+0x4a3ba) #3 0xb58ddcd8 in pa_log_levelv_meta (/usr/lib/pulseaudio/libpulsecommon-13.0.so+0x5dcd8) #4 0xb58dd5c6 in pa_log_level_meta (/usr/lib/pulseaudio/libpulsecommon-13.0.so+0x5d5c6) #5 0xb2e262d8 in module_tone_player_LTX_pa__init (/usr/lib/pulse-13.0/modules/module-tone-player.so+0x22d8) #6 0xb5ab7072 in pa_module_load (/usr/lib/pulseaudio/libpulsecore-13.0.so+0x56072) #7 0xb5a9818e in pa_cli_command_load (/usr/lib/pulseaudio/libpulsecore-13.0.so+0x3718e) #8 0xb5aa06b2 in pa_cli_command_execute_line_stateful (/usr/lib/pulseaudio/libpulsecore-13.0.so+0x3f6b2) #9 0xb5aa11c4 in pa_cli_command_execute_file_stream (/usr/lib/pulseaudio/libpulsecore-13.0.so+0x401c4) #10 0x1810a in main (/usr/bin/pulseaudio+0x1810a) #11 0xb5440c80 in __libc_start_main (/lib/libc.so.6+0x1ac80) [Version] 13.0.41 [Issue Type] Bug Change-Id: Ib0c1987d14ac42d47b7e6036b12c1313b275b151 --- packaging/pulseaudio-modules-tizen.spec | 2 +- src/module-tone-player.c | 9 +++++++-- 2 files changed, 8 insertions(+), 3 deletions(-) diff --git a/packaging/pulseaudio-modules-tizen.spec b/packaging/pulseaudio-modules-tizen.spec index 2eb1819..bddc754 100644 --- a/packaging/pulseaudio-modules-tizen.spec +++ b/packaging/pulseaudio-modules-tizen.spec @@ -1,6 +1,6 @@ Name: pulseaudio-modules-tizen Summary: Pulseaudio modules for Tizen -Version: 13.0.40 +Version: 13.0.41 Release: 0 Group: Multimedia/Audio License: LGPL-2.1+ diff --git a/src/module-tone-player.c b/src/module-tone-player.c index de3d2f6..0e506c3 100644 --- a/src/module-tone-player.c +++ b/src/module-tone-player.c @@ -494,13 +494,18 @@ int pa__init(pa_module *m) { m->userdata = u = pa_xnew0(struct userdata, 1); u->module = m; + dbus_error_init(&err); + if (!(conn = pa_dbus_bus_get(u->module->core, DBUS_BUS_SYSTEM, &err)) || dbus_error_is_set(&err)) { if (conn) pa_dbus_connection_unref(conn); pa_log_error("Unable to contact D-Bus system bus: %s: %s", err.name, err.message); - } else - pa_log_debug("Got dbus connection"); + + pa_xfree(u); + return -1; + } + pa_log_debug("Got dbus connection"); u->dbus_conn = conn; pa_assert_se(dbus_connection_register_object_path(pa_dbus_connection_get(conn), -- 2.7.4 From 942bb6a04dc728200b603d168ac6b85f0d35b296 Mon Sep 17 00:00:00 2001 From: Sangchul Lee Date: Wed, 23 Dec 2020 14:21:38 +0900 Subject: [PATCH 09/16] tizenaudio-policy: Set use_internal_codec value of combine sink When a stream is finished, routing path should be updated for one of remaining streams. If one of them is using internal audio codec with a combine sink, it should also be updated for the stream. This patch sets the use_internal_codec value of the combine sink to true when loading the module if needed. A function to load the combine module is added and applied. [Version] 13.0.42 [Issue Type] Bug fix / Refactoring Change-Id: I02950f4df59535039409b9c75c627dc770c66462 Signed-off-by: Sangchul Lee --- packaging/pulseaudio-modules-tizen.spec | 2 +- src/module-tizenaudio-policy.c | 124 ++++++++++++++++++-------------- 2 files changed, 71 insertions(+), 55 deletions(-) diff --git a/packaging/pulseaudio-modules-tizen.spec b/packaging/pulseaudio-modules-tizen.spec index bddc754..e301cd3 100644 --- a/packaging/pulseaudio-modules-tizen.spec +++ b/packaging/pulseaudio-modules-tizen.spec @@ -1,6 +1,6 @@ Name: pulseaudio-modules-tizen Summary: Pulseaudio modules for Tizen -Version: 13.0.41 +Version: 13.0.42 Release: 0 Group: Multimedia/Audio License: LGPL-2.1+ diff --git a/src/module-tizenaudio-policy.c b/src/module-tizenaudio-policy.c index 04d75b7..43f8bca 100644 --- a/src/module-tizenaudio-policy.c +++ b/src/module-tizenaudio-policy.c @@ -485,6 +485,54 @@ static void update_loopback_module(struct userdata *u, bool load) { } } +static pa_sink *load_combine_sink_module(struct userdata *u, const char *combine_sink_name, pa_sink *sink1, pa_sink *sink2, pa_sink_input *stream) +{ + pa_module **combine_sink_module = NULL; + pa_sink *sink; + pa_sink_input *i; + + pa_assert(u); + pa_assert(combine_sink_name); + pa_assert(sink1); + pa_assert(sink2); + + if (pa_safe_streq(combine_sink_name, SINK_NAME_COMBINED)) { + combine_sink_module = &u->module_combine_sink; + } else if (pa_safe_streq(combine_sink_name, SINK_NAME_COMBINED_EX)) { + combine_sink_module = &u->module_combine_sink_for_ex; + } else { + pa_log_error("unknown combine_sink_name(%s)", combine_sink_name); + return NULL; + } + + if (!*combine_sink_module) { + char *args = pa_sprintf_malloc("sink_name=%s slaves=\"%s,%s\"", combine_sink_name, sink1->name, sink2->name); + pa_log_info("load combine sink module[%s]", args); + /* FIXME: load combine module per each stream role. */ + if (pa_module_load(combine_sink_module, u->core, MODULE_COMBINE_SINK, args)) + pa_log_error("failed to load module-combine-sink with args(%s)", args); + pa_xfree(args); + } + + sink = (pa_sink *)pa_namereg_get(u->core, combine_sink_name, PA_NAMEREG_SINK); + if (!sink) { + pa_log_error("failed to pa_namereg_get() for [%s]", combine_sink_name); + return NULL; + } + + sink->use_internal_codec = pa_safe_streq(combine_sink_name, SINK_NAME_COMBINED); + + if (stream) { + if ((i = pa_idxset_get_by_data(sink1->inputs, stream, NULL)) || + (i = pa_idxset_get_by_data(sink2->inputs, stream, NULL))) { + pa_sink_input_move_to(i, sink, false); + pa_log_info("*** sink-input(%p,%u) moves to sink(%p,%s)", i, i->index, sink, sink->name); + } + } + + return sink; +} + static void unload_combine_sink_module(struct userdata *u, const char *combine_sink_name, pa_sink *dst_sink) { pa_module **combine_sink_module = NULL; @@ -505,23 +553,26 @@ static void unload_combine_sink_module(struct userdata *u, const char *combine_s return; } - if (*combine_sink_module) { - combine_sink = (pa_sink*)pa_namereg_get(u->core, combine_sink_name, PA_NAMEREG_SINK); - if (!combine_sink) - pa_log_error("could not get combine_sink(%s)", combine_sink_name); - else { - PA_IDXSET_FOREACH(s, combine_sink->inputs, idx) { - pa_sink_input_move_to(s, dst_sink, false); - pa_log_info("[UNLOAD COMBINE SINK MODULE] *** sink-input(%p,%u) of (%s) moves to another sink(%p,%s)", - s, ((pa_sink_input*)s)->index, combine_sink_name, dst_sink, dst_sink->name); - } - pa_sink_suspend(combine_sink, true, PA_SUSPEND_USER); - } - pa_log_info("unload combine sink module[%s]", combine_sink_name); - pa_module_unload(*combine_sink_module, true); - *combine_sink_module = NULL; - } else + if (!*combine_sink_module) { pa_log_warn("module combine sink(%s) has been already unloaded", combine_sink_name); + return; + } + + combine_sink = (pa_sink*)pa_namereg_get(u->core, combine_sink_name, PA_NAMEREG_SINK); + if (!combine_sink) { + pa_log_error("could not get combine_sink(%s)", combine_sink_name); + } else { + PA_IDXSET_FOREACH(s, combine_sink->inputs, idx) { + pa_sink_input_move_to(s, dst_sink, false); + pa_log_info("*** sink-input(%p,%u) of (%s) moves to another sink(%p,%s)", + s, ((pa_sink_input*)s)->index, combine_sink_name, dst_sink, dst_sink->name); + } + pa_sink_suspend(combine_sink, true, PA_SUSPEND_USER); + } + + pa_log_info("unload combine sink module[%s]", combine_sink_name); + pa_module_unload(*combine_sink_module, true); + *combine_sink_module = NULL; } static bool skip_device(const char *stream_role, const char *device_type) @@ -845,7 +896,6 @@ static void select_device_by_manual_external_routing(struct userdata *u, pa_stre pa_source *source = NULL; pa_sink *combine_sink_arg1 = NULL; pa_sink *combine_sink_arg2 = NULL; - void *stream = NULL; pa_assert(u); pa_assert(data); @@ -874,26 +924,9 @@ static void select_device_by_manual_external_routing(struct userdata *u, pa_stre } else if (!combine_sink_arg2) { sink = combine_sink_arg2 = pa_tz_device_get_sink(device, NULL); if (sink && !pa_safe_streq(sink->name, combine_sink_arg1->name)) { - uint32_t s_idx = 0; - pa_log_info(" -- combine_sink_arg2[%s]", sink->name); - /* load combine sink */ - if (!u->module_combine_sink_for_ex) { - char *args = pa_sprintf_malloc("sink_name=%s slaves=\"%s,%s\"", - SINK_NAME_COMBINED_EX, combine_sink_arg1->name, combine_sink_arg2->name); - pa_log_info(" -- combined sink is not prepared, now load module[%s]", args); - if (pa_module_load(&u->module_combine_sink_for_ex, u->core, MODULE_COMBINE_SINK, args)) - pa_log_error("failed to load module-combine-sink with args(%s)", args); - pa_xfree(args); - } - sink = (pa_sink*)pa_namereg_get(u->core, SINK_NAME_COMBINED_EX, PA_NAMEREG_SINK); - PA_IDXSET_FOREACH(stream, combine_sink_arg1->inputs, s_idx) { - if (sink && stream == data->stream) { - pa_sink_input_move_to(stream, sink, false); - pa_log_info(" -- *** sink-input(%p,%u) moves to sink(%p,%s)", stream, ((pa_sink_input*)stream)->index, sink, sink->name); - break; - } - } + sink = load_combine_sink_module(u, SINK_NAME_COMBINED_EX, combine_sink_arg1, combine_sink_arg2, data->stream); + } else if (!sink) { pa_log_warn(" -- could not get combine_sink_arg2"); } @@ -1217,24 +1250,7 @@ static pa_hook_result_t update_combine_sink_and_bt_sco(struct userdata *u, pa_st sink = *combine_sink_arg2 = pa_tz_device_get_sink(device, data->device_role); if (sink && !pa_safe_streq(sink->name, (*combine_sink_arg1)->name)) { pa_log_info("[ROUTE][AUTO_ALL] combine_sink_arg2[%s]", sink->name); - /* load combine sink */ - if (!u->module_combine_sink) { - char *args = pa_sprintf_malloc("sink_name=%s slaves=\"%s,%s\"", - SINK_NAME_COMBINED, (*combine_sink_arg1)->name, (*combine_sink_arg2)->name); - pa_log_info("[ROUTE][AUTO_ALL] combined sink is not prepared, now load module[%s]", args); - if (pa_module_load(&u->module_combine_sink, u->core, MODULE_COMBINE_SINK, args)) - pa_log_error("failed to load module-combine-sink with args(%s)", args); - pa_xfree(args); - } - if ((sink = (pa_sink*)pa_namereg_get(u->core, SINK_NAME_COMBINED, PA_NAMEREG_SINK))) { - PA_IDXSET_FOREACH(s, (*combine_sink_arg1)->inputs, s_idx) { - if (s == data->stream) { - pa_sink_input_move_to(s, sink, false); - pa_log_info("[ROUTE][AUTO_ALL] *** sink-nput(%p,%u) moves to sink(%p,%s)", - s, ((pa_sink_input*)s)->index, sink, sink->name); - } - } - } + sink = load_combine_sink_module(u, SINK_NAME_COMBINED, *combine_sink_arg1, *combine_sink_arg2, data->stream); } } else if (data->stream_type == STREAM_SOURCE_OUTPUT) { -- 2.7.4 From 54a2c387877a7e71bb2cada016369c8f25afa74b Mon Sep 17 00:00:00 2001 From: Sangchul Lee Date: Mon, 28 Dec 2020 17:56:16 +0900 Subject: [PATCH 10/16] stream-manager: Revise conditions to invoke ducking state changed signal In sink_input_ramp_finish_cb(), it is fixed to send the signal only if the previous state of stream ducking is DUCKING or UNDUCKING. Some logs are revised for easy debugging. [Version] 13.0.43 [Issue Type] Improvement Change-Id: Ib857d6146afe3279436fa155bf18b0d45e9d1909 Signed-off-by: Sangchul Lee --- packaging/pulseaudio-modules-tizen.spec | 2 +- src/stream-manager-dbus.c | 10 +++++----- src/stream-manager.c | 31 ++++++++++++++++--------------- 3 files changed, 22 insertions(+), 21 deletions(-) diff --git a/packaging/pulseaudio-modules-tizen.spec b/packaging/pulseaudio-modules-tizen.spec index e301cd3..c99a785 100644 --- a/packaging/pulseaudio-modules-tizen.spec +++ b/packaging/pulseaudio-modules-tizen.spec @@ -1,6 +1,6 @@ Name: pulseaudio-modules-tizen Summary: Pulseaudio modules for Tizen -Version: 13.0.42 +Version: 13.0.43 Release: 0 Group: Multimedia/Audio License: LGPL-2.1+ diff --git a/src/stream-manager-dbus.c b/src/stream-manager-dbus.c index d81d157..3545cd1 100644 --- a/src/stream-manager-dbus.c +++ b/src/stream-manager-dbus.c @@ -2110,8 +2110,8 @@ static void handle_activate_ducking(DBusConnection *conn, DBusMessage *msg, void if (enable) { pa_idxset_put(sd->idx_ducking_streams, (void *)i, NULL); - pa_log_error("ducking: add volume_ramp factor, key[%s], set_vol[%u] to stream[idx:%u]", - sd->vol_key, sd->set_vol, i->index); + pa_log_error("ducking: add volume_ramp factor, key[%s], set_vol[%u] to stream[idx:%u, state:%u]", + sd->vol_key, sd->set_vol, i->index, i->state); pa_cvolume_ramp_set(&vol_ramp, i->volume.channels, PA_VOLUME_RAMP_TYPE_LINEAR, (long)duration, sd->set_vol); @@ -2124,8 +2124,8 @@ static void handle_activate_ducking(DBusConnection *conn, DBusMessage *msg, void pa_sink_input_add_volume_ramp_factor(i, sd->vol_key, &vol_ramp, true); } } else { - pa_log_error("unducking: remove volume(ramp) factor, key[%s] from stream[idx:%u]", - sd->vol_key, i->index); + pa_log_error("unducking: remove volume(ramp) factor, key[%s] from stream[idx:%u, state:%u]", + sd->vol_key, i->index, i->state); pa_sink_input_remove_volume_factor(i, sd->vol_key); pa_sink_input_remove_volume_ramp_factor(i, sd->vol_key, true); @@ -2137,7 +2137,7 @@ static void handle_activate_ducking(DBusConnection *conn, DBusMessage *msg, void memset(&sd->vol_key, 0, sizeof(sd->vol_key)); } - pa_log_info("ducking stream count[%p,%d]", sd, sd->ducking_stream_count); + pa_log_info("stream ducking[%p, ducking_stream_count:%d]", sd, sd->ducking_stream_count); _ACTIVATE_DUCKING_DONE: pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret_msg]); diff --git a/src/stream-manager.c b/src/stream-manager.c index 4c12613..0ce45e2 100644 --- a/src/stream-manager.c +++ b/src/stream-manager.c @@ -2593,9 +2593,7 @@ static pa_hook_result_t sink_input_move_finish_cb(pa_core *core, pa_sink_input * } static pa_hook_result_t sink_input_ramp_finish_cb(pa_core *core, pa_sink_input *i, pa_stream_manager *m) { - stream_ducking *sd = NULL; - pa_sink_input *stream = NULL; - uint32_t idx; + stream_ducking *sd; void *state; pa_core_assert_ref(core); @@ -2611,17 +2609,17 @@ static pa_hook_result_t sink_input_ramp_finish_cb(pa_core *core, pa_sink_input * * Check the number of managed streams of the context id, if it is the last one * then broadcast a signal with context id.*/ PA_HASHMAP_FOREACH(sd, m->stream_duckings, state) { - PA_IDXSET_FOREACH(stream, sd->idx_ducking_streams, idx) { - if (stream == i && sd->ducking_stream_count > 0) { - pa_log_info("found matched stream(%p, index:%u) in sd(%p)", i, i->index, sd); - break; - } - } - if (stream != i) { + if (!pa_idxset_get_by_data(sd->idx_ducking_streams, i, NULL)) { pa_log_debug("not found matched stream(%p, index:%u) in sd(%p)", i, i->index, sd); continue; } + pa_log_info("found matched stream(%p, index:%u) in sd(%p, ducking_stream_count:%d, state:%u)", + i, i->index, sd, sd->ducking_stream_count, sd->state); + + if (sd->ducking_stream_count <= 0) + continue; + /* Remove trigger when unducked */ if (sd->state == STREAM_DUCKING_STATE_UNDUCKING) pa_idxset_remove_by_data(sd->idx_ducking_streams, (void *)i, NULL); @@ -2629,14 +2627,17 @@ static pa_hook_result_t sink_input_ramp_finish_cb(pa_core *core, pa_sink_input * /* Send signal when all streams are ducked. * Note that the condition of increasing count value below is located in * handle_activate_ducking() of DBus handler. */ - if (sd->ducking_stream_count > 0 && --sd->ducking_stream_count == 0) { - if (sd->state == STREAM_DUCKING_STATE_DUCKING) + if (--sd->ducking_stream_count == 0) { + if (sd->state == STREAM_DUCKING_STATE_DUCKING) { sd->state = STREAM_DUCKING_STATE_DUCKED; - else + } else if (sd->state == STREAM_DUCKING_STATE_UNDUCKING) { sd->state = STREAM_DUCKING_STATE_UNDUCKED; + } else { + pa_log_warn("sd->state(%d), already ducked or unducked, skip sending signal", sd->state); + continue; + } - pa_log_info("send signal for ramp finished - sd(%p, state:%d)", sd, sd->state); - + pa_log_info("send signal for ramp finished - sd(%p, state:%u)", sd, sd->state); send_ducking_state_changed_signal(pa_dbus_connection_get(m->dbus_conn), sd->trigger_index, is_stream_ducked(sd)); } } -- 2.7.4 From a0f30f1186d0a7c3fa7d0dfae18995de6bb09515 Mon Sep 17 00:00:00 2001 From: Seungbae Shin Date: Tue, 5 Jan 2021 00:52:21 +0900 Subject: [PATCH 11/16] tizenaudio-policy: unload modules safely when daemon is on shutdown [Version] 13.0.44 [Issue Type] Bug Change-Id: Ib92c5cbff8bb48b40eef5685dc5549894a58cdd8 --- packaging/pulseaudio-modules-tizen.spec | 2 +- src/module-tizenaudio-policy.c | 29 ++++++++++++++++++----------- 2 files changed, 19 insertions(+), 12 deletions(-) diff --git a/packaging/pulseaudio-modules-tizen.spec b/packaging/pulseaudio-modules-tizen.spec index c99a785..d76a281 100644 --- a/packaging/pulseaudio-modules-tizen.spec +++ b/packaging/pulseaudio-modules-tizen.spec @@ -1,6 +1,6 @@ Name: pulseaudio-modules-tizen Summary: Pulseaudio modules for Tizen -Version: 13.0.43 +Version: 13.0.44 Release: 0 Group: Multimedia/Audio License: LGPL-2.1+ diff --git a/src/module-tizenaudio-policy.c b/src/module-tizenaudio-policy.c index 43f8bca..a6c1075 100644 --- a/src/module-tizenaudio-policy.c +++ b/src/module-tizenaudio-policy.c @@ -168,8 +168,8 @@ struct userdata { pa_module *module_combine_sink; pa_module *module_combine_sink_for_ex; - pa_module *module_null_sink; - pa_module *module_null_source; + uint32_t module_null_sink_index; + uint32_t module_null_source_index; pa_module *module_loopback; struct { int32_t latency_msec; @@ -1047,8 +1047,8 @@ static void reset_route(struct userdata *u, stream_type_t stream_type) { /* unload combine sink */ if (stream_type == STREAM_SINK_INPUT) { - null_sink = (pa_sink*)pa_namereg_get(u->core, SINK_NAME_NULL, PA_NAMEREG_SINK); - unload_combine_sink_module(u, SINK_NAME_COMBINED, null_sink); + if (null_sink = (pa_sink*)pa_namereg_get(u->core, SINK_NAME_NULL, PA_NAMEREG_SINK)) + unload_combine_sink_module(u, SINK_NAME_COMBINED, null_sink); } route_info.role = "reset"; @@ -1793,6 +1793,7 @@ int pa__init(pa_module *m) pa_modargs *ma = NULL; struct userdata *u; char *args = NULL; + pa_module *module_loaded; pa_assert(m); @@ -1804,6 +1805,8 @@ int pa__init(pa_module *m) m->userdata = u = pa_xnew0(struct userdata, 1); u->core = m->core; u->module = m; + u->module_null_sink_index = PA_INVALID_INDEX; + u->module_null_source_index = PA_INVALID_INDEX; if (!(u->hal_interface = pa_hal_interface_get(u->core))) { pa_log("Failed to get hal interface"); @@ -1826,17 +1829,21 @@ int pa__init(pa_module *m) PA_HOOK_EARLY, (pa_hook_cb_t)update_info_hook_cb, u); } u->device_manager = pa_device_manager_get(u->core); - u->stream_manager = pa_stream_manager_get(u->core); /* load null sink/source */ args = pa_sprintf_malloc("sink_name=%s norewinds=1", SINK_NAME_NULL); - if (pa_module_load(&u->module_null_sink, u->core, MODULE_NULL_SINK, args)) + if (pa_module_load(&module_loaded, u->core, MODULE_NULL_SINK, args)) pa_log_error("failed to load module-null-sink"); + else + u->module_null_sink_index = module_loaded->index; pa_xfree(args); + args = pa_sprintf_malloc("source_name=%s max_latency_msec=100", SOURCE_NAME_NULL); - if (pa_module_load(&u->module_null_source, u->core, MODULE_NULL_SOURCE, args)) + if (pa_module_load(&module_loaded, u->core, MODULE_NULL_SOURCE, args)) pa_log_error("failed to load module-null-source"); + else + u->module_null_source_index = module_loaded->index; pa_xfree(args); __load_dump_config(u); @@ -1865,11 +1872,11 @@ void pa__done(pa_module *m) bt_sco_close(u, false); - if (u->module_null_sink) - pa_module_unload(u->module_null_sink, true); + if (u->module_null_sink_index != PA_INVALID_INDEX) + pa_module_unload_by_index(m->core, u->module_null_sink_index, true); - if (u->module_null_source) - pa_module_unload(u->module_null_source, true); + if (u->module_null_source_index != PA_INVALID_INDEX) + pa_module_unload_by_index(m->core, u->module_null_source_index, true); if (u->device_manager) pa_device_manager_unref(u->device_manager); -- 2.7.4 From c310166cd5d92259499e46aea5f133549e21ca7b Mon Sep 17 00:00:00 2001 From: jungsup lee Date: Tue, 5 Jan 2021 15:01:46 +0900 Subject: [PATCH 12/16] device-manager: handle rtsp device handle rtsp device as network type device [Version] 13.0.45 [Issue Type] Update Change-Id: I90e4965c34db184f6177b19cf6e1874a13175723 Signed-off-by: jungsup lee --- packaging/pulseaudio-modules-tizen.spec | 2 +- src/device-manager.c | 51 +++++++++++++++++++++++++++++++++ src/tizen-device-def.c | 2 ++ src/tizen-device-def.h | 1 + 4 files changed, 55 insertions(+), 1 deletion(-) diff --git a/packaging/pulseaudio-modules-tizen.spec b/packaging/pulseaudio-modules-tizen.spec index d76a281..a88cd4f 100644 --- a/packaging/pulseaudio-modules-tizen.spec +++ b/packaging/pulseaudio-modules-tizen.spec @@ -1,6 +1,6 @@ Name: pulseaudio-modules-tizen Summary: Pulseaudio modules for Tizen -Version: 13.0.44 +Version: 13.0.45 Release: 0 Group: Multimedia/Audio License: LGPL-2.1+ diff --git a/src/device-manager.c b/src/device-manager.c index 7fc3435..14b2b89 100644 --- a/src/device-manager.c +++ b/src/device-manager.c @@ -82,6 +82,7 @@ #define DEVICE_API_ACM "acm" #define DEVICE_API_RAOP "raop" #define DEVICE_API_TUNNEL "tunnel" +#define DEVICE_API_RTSP "rtsp" #define DEVICE_BUS_USB "usb" #define DEVICE_CLASS_SOUND "sound" #define DEVICE_CLASS_MONITOR "monitor" @@ -456,6 +457,15 @@ static bool pulse_device_is_null(pa_object *pdevice) { } } +static bool pulse_device_is_rtsp(pa_object *pdevice) { + pa_proplist *prop = pulse_device_get_proplist(pdevice); + + if (!prop) + return false; + + return pa_safe_streq(pa_proplist_gets(prop, PA_PROP_DEVICE_API), DEVICE_API_RTSP); +} + static const char* pulse_device_get_device_string_removed_argument(pa_object *pdevice) { static char removed_param[DEVICE_PARAM_STRING_MAX] = {0,}; char *device_string_p = NULL; @@ -1152,6 +1162,8 @@ static const char* pulse_device_get_system_id(pa_object *pdevice) { return pa_proplist_gets(prop, PA_PROP_DEVICE_STRING); else if (pulse_device_is_tunnel(pdevice)) return pa_proplist_gets(prop, PA_PROP_DEVICE_DESCRIPTION); + else if (pulse_device_is_rtsp(pdevice)) + return pa_proplist_gets(prop, PA_PROP_DEVICE_DESCRIPTION); else return NULL; } @@ -1542,6 +1554,38 @@ static void handle_acm_pulse_device(pa_object *pdevice, bool is_loaded, pa_devic } } +static void handle_rtsp_pulse_device(pa_object *pdevice, bool is_loaded, pa_device_manager *dm) { + pa_tz_device *device; + const char *system_id; + + pa_assert(pdevice); + pa_assert(dm); + + pa_log_info("Handle RTSP pulse device"); + + system_id = pulse_device_get_system_id(pdevice); + + if (is_loaded) { + pa_tz_device_new_data data; + + pa_proplist *prop = pulse_device_get_proplist(pdevice); + const char *name = pa_proplist_gets(prop, PA_PROP_DEVICE_DESCRIPTION); + + pa_tz_device_new_data_init(&data, dm->device_list, dm->comm, dm->dbus_conn); + _fill_new_data_basic(&data, DEVICE_TYPE_NETWORK, DM_DEVICE_DIRECTION_IN, false, dm); + pa_tz_device_new_data_set_name(&data, name); + pa_tz_device_new_data_set_system_id(&data, system_id); + pa_tz_device_new_data_add_source(&data, DEVICE_ROLE_RTSP, PA_SOURCE(pdevice)); + pa_tz_device_new(&data); + pa_tz_device_new_data_done(&data); + } else { + if (!(device = device_list_get_device(dm, DEVICE_TYPE_NETWORK, NULL, system_id))) + pa_log_warn("Can't get RTSP device for %s", system_id); + else + pa_tz_device_free(device); + } +} + static void handle_internal_pulse_device(pa_object *pdevice, bool is_loaded, pa_device_manager *dm) { pa_tz_device *device; struct composite_type *ctype; @@ -1698,6 +1742,10 @@ static pa_hook_result_t source_put_hook_callback(pa_core *c, pa_source *source, pulse_device_set_use_internal_codec(PA_OBJECT(source), true); handle_internal_pulse_device(PA_OBJECT(source), true, dm); return PA_HOOK_OK; + } else if (pulse_device_is_rtsp(PA_OBJECT(source))) { + pulse_device_set_use_internal_codec(PA_OBJECT(source), false); + handle_rtsp_pulse_device(PA_OBJECT(source), true, dm); + return PA_HOOK_OK; } else { pa_log_debug("Don't care this source"); } @@ -1736,6 +1784,9 @@ static pa_hook_result_t source_unlink_hook_callback(pa_core *c, pa_source *sourc } else if (pulse_device_is_alsa(PA_OBJECT(source)) || pulse_device_is_tizenaudio(PA_OBJECT(source))) { handle_internal_pulse_device(PA_OBJECT(source), false, dm); return PA_HOOK_OK; + } else if (pulse_device_is_rtsp(PA_OBJECT(source))) { + handle_rtsp_pulse_device(PA_OBJECT(source), false, dm); + return PA_HOOK_OK; } else { pa_log_debug("Don't care this source"); } diff --git a/src/tizen-device-def.c b/src/tizen-device-def.c index 164146c..cca9ae2 100644 --- a/src/tizen-device-def.c +++ b/src/tizen-device-def.c @@ -181,6 +181,8 @@ bool device_role_is_valid(const char *device_role) { return true; else if (pa_safe_streq(device_role, DEVICE_ROLE_ACM)) return true; + else if (pa_safe_streq(device_role, DEVICE_ROLE_RTSP)) + return true; else return false; } diff --git a/src/tizen-device-def.h b/src/tizen-device-def.h index e4232da..d3c3a76 100644 --- a/src/tizen-device-def.h +++ b/src/tizen-device-def.h @@ -29,6 +29,7 @@ #define DEVICE_ROLE_RAOP "raop" #define DEVICE_ROLE_TUNNEL "tunnel" #define DEVICE_ROLE_ACM "acm" +#define DEVICE_ROLE_RTSP "rtsp" typedef enum dm_device_direction_type { DM_DEVICE_DIRECTION_NONE, -- 2.7.4 From ca712cd12259fd18a28b945d09917d2c4452ca08 Mon Sep 17 00:00:00 2001 From: Jaechul Lee Date: Mon, 25 Jan 2021 14:25:32 +0900 Subject: [PATCH 13/16] hal-interface: Use hal audio api + remove minor build warning [Version] 13.0.46 [Issue Type] Enhancement Change-Id: Iac9337a9c6f654723eb956f7f7a6b2a85deef8d6 Signed-off-by: Jaechul Lee --- Makefile.am | 4 +- configure.ac | 4 + packaging/pulseaudio-modules-tizen.spec | 6 +- src/hal-interface.c | 455 ++++++++++++++------------------ src/hal-interface.h | 8 +- src/module-tizenaudio-policy.c | 2 +- src/stream-manager.c | 8 +- 7 files changed, 222 insertions(+), 265 deletions(-) diff --git a/Makefile.am b/Makefile.am index e529cae..e66660b 100644 --- a/Makefile.am +++ b/Makefile.am @@ -53,8 +53,8 @@ endif libhal_interface_la_SOURCES = \ src/hal-interface.c src/hal-interface.h libhal_interface_la_LDFLAGS = $(AM_LDFLAGS) $(PA_LDFLAGS) -avoid-version -libhal_interface_la_LIBADD = $(AM_LIBADD) $(PACORE_LIBS) $(PA_LIBS) -libhal_interface_la_CFLAGS = $(AM_CFLAGS) $(PACORE_CFLAGS) $(PA_CFLAGS) +libhal_interface_la_LIBADD = $(AM_LIBADD) $(PACORE_LIBS) $(PA_LIBS) $(HALAPIAUDIO_LIBS) +libhal_interface_la_CFLAGS = $(AM_CFLAGS) $(PACORE_CFLAGS) $(PA_CFLAGS) $(HALAPIAUDIO_CFLAGS) libcommunicator_la_SOURCES = \ src/communicator.c src/communicator.h diff --git a/configure.ac b/configure.ac index 8557992..ac631fa 100644 --- a/configure.ac +++ b/configure.ac @@ -365,6 +365,10 @@ PKG_CHECK_MODULES(DNSSD, dns_sd) AC_SUBST(DNSSD_CFLAGS) AC_SUBST(DNSSD_LIBS) +PKG_CHECK_MODULES(HALAPIAUDIO, hal-api-audio) +AC_SUBST(HALAPIAUDIO_CFLAGS) +AC_SUBST(HALAPIAUDIO_LIBS) + dnl use hal tc ------------------------------------------------------------ AC_ARG_ENABLE(haltc, AC_HELP_STRING([--enable-haltc], [using haltc]), [ diff --git a/packaging/pulseaudio-modules-tizen.spec b/packaging/pulseaudio-modules-tizen.spec index a88cd4f..0b5626f 100644 --- a/packaging/pulseaudio-modules-tizen.spec +++ b/packaging/pulseaudio-modules-tizen.spec @@ -1,6 +1,6 @@ Name: pulseaudio-modules-tizen Summary: Pulseaudio modules for Tizen -Version: 13.0.45 +Version: 13.0.46 Release: 0 Group: Multimedia/Audio License: LGPL-2.1+ @@ -16,11 +16,11 @@ BuildRequires: pkgconfig(vconf) %if "%{tizen_profile_name}" == "tv" BuildRequires: pkgconfig(glib-2.0) %endif -BuildRequires: mm-hal-interface-devel BuildRequires: pkgconfig(libpulse) BuildRequires: pkgconfig(pulsecore) BuildRequires: pkgconfig(libsystemd) BuildRequires: pkgconfig(dns_sd) +BuildRequires: pkgconfig(hal-api-audio) BuildRequires: pulseaudio BuildRequires: m4 Requires(post): /sbin/ldconfig @@ -40,7 +40,7 @@ PulseAudio module-acm-sink for sending PCM data to ACM core. %setup -q %build -export CFLAGS="%{optflags} -fno-strict-aliasing -D__TIZEN__ -DSYSCONFDIR=\\\"%{_sysconfdir}\\\" -DAUDIOHALDIR=\\\"%{_libdir}\\\"" +export CFLAGS="%{optflags} -fno-strict-aliasing -D__TIZEN__ -DSYSCONFDIR=\\\"%{_sysconfdir}\\\" " export LD_AS_NEEDED=0 %reconfigure --prefix=%{_prefix} \ diff --git a/src/hal-interface.c b/src/hal-interface.c index 26ee345..e108f38 100644 --- a/src/hal-interface.c +++ b/src/hal-interface.c @@ -24,25 +24,24 @@ #endif #include "hal-interface.h" -#include + +#include +#include + #include #define SHARED_HAL_INTF "tizen-hal-interface" -/* Audio HAL library */ -#define LIB_TIZEN_AUDIO AUDIOHALDIR"/libtizen-audio.so" - struct _pa_hal_interface { PA_REFCNT_DECLARE; pa_core *core; - void *dl_handle; - void *ah_handle; - audio_interface_t intf; + void *audio_handle; }; pa_hal_interface* pa_hal_interface_get(pa_core *core) { pa_hal_interface *h; + audio_return_e hal_ret = AUDIO_RET_OK; pa_assert(core); @@ -53,49 +52,12 @@ pa_hal_interface* pa_hal_interface_get(pa_core *core) { PA_REFCNT_INIT(h); h->core = core; - /* Load library & init HAL interface */ - h->dl_handle = dlopen(LIB_TIZEN_AUDIO, RTLD_NOW); - if (h->dl_handle) { - h->intf.init = dlsym(h->dl_handle, "audio_init"); - h->intf.deinit = dlsym(h->dl_handle, "audio_deinit"); - h->intf.get_volume_level_max = dlsym(h->dl_handle, "audio_get_volume_level_max"); - h->intf.get_volume_level = dlsym(h->dl_handle, "audio_get_volume_level"); - h->intf.set_volume_level = dlsym(h->dl_handle, "audio_set_volume_level"); - h->intf.get_volume_value = dlsym(h->dl_handle, "audio_get_volume_value"); - h->intf.get_volume_mute = dlsym(h->dl_handle, "audio_get_volume_mute"); - h->intf.set_volume_mute = dlsym(h->dl_handle, "audio_set_volume_mute"); - h->intf.set_volume_ratio = dlsym(h->dl_handle, "audio_set_volume_ratio"); - h->intf.notify_ducking_activation_changed = dlsym(h->dl_handle, "audio_notify_ducking_activation_changed"); - h->intf.update_route = dlsym(h->dl_handle, "audio_update_route"); - h->intf.update_route_option = dlsym(h->dl_handle, "audio_update_route_option"); - h->intf.notify_stream_connection_changed = dlsym(h->dl_handle, "audio_notify_stream_connection_changed"); - h->intf.pcm_open = dlsym(h->dl_handle, "audio_pcm_open"); - h->intf.pcm_start = dlsym(h->dl_handle, "audio_pcm_start"); - h->intf.pcm_stop = dlsym(h->dl_handle, "audio_pcm_stop"); - h->intf.pcm_close = dlsym(h->dl_handle, "audio_pcm_close"); - h->intf.pcm_avail = dlsym(h->dl_handle, "audio_pcm_avail"); - h->intf.pcm_write = dlsym(h->dl_handle, "audio_pcm_write"); - h->intf.pcm_read = dlsym(h->dl_handle, "audio_pcm_read"); - h->intf.pcm_get_fd = dlsym(h->dl_handle, "audio_pcm_get_fd"); - h->intf.pcm_recover = dlsym(h->dl_handle, "audio_pcm_recover"); - h->intf.pcm_get_params = dlsym(h->dl_handle, "audio_pcm_get_params"); - h->intf.pcm_set_params = dlsym(h->dl_handle, "audio_pcm_set_params"); - h->intf.add_message_cb = dlsym(h->dl_handle, "audio_add_message_cb"); - h->intf.remove_message_cb = dlsym(h->dl_handle, "audio_remove_message_cb"); - if (h->intf.init) { - if (h->intf.init(&h->ah_handle) != AUDIO_RET_OK) { - pa_log_error("hal_interface init failed"); - dlclose(h->dl_handle); - pa_xfree(h); - return NULL; - } - } - - } else { - pa_log_error("open hal_interface failed :%s", dlerror()); - pa_xfree(h); - return NULL; - } + hal_ret = hal_audio_init(&h->audio_handle); + if (hal_ret != AUDIO_RET_OK) { + pa_log_error("hal_audio_init error:0x%x", hal_ret); + pa_xfree(h); + return NULL; + } pa_shared_set(core, SHARED_HAL_INTF, h); @@ -112,20 +74,17 @@ pa_hal_interface* pa_hal_interface_ref(pa_hal_interface *h) { } void pa_hal_interface_unref(pa_hal_interface *h) { + audio_return_e hal_ret = AUDIO_RET_OK; + pa_assert(h); pa_assert(PA_REFCNT_VALUE(h) > 0); if (PA_REFCNT_DEC(h) > 0) return; - /* Deinit HAL manager & unload library */ - if (h->intf.deinit) { - if (h->intf.deinit(h->ah_handle) != AUDIO_RET_OK) { - pa_log_error("hal_interface deinit failed"); - } - } - if (h->dl_handle) - dlclose(h->dl_handle); + hal_ret = hal_audio_deinit(h->audio_handle); + if (hal_ret != AUDIO_RET_OK) + pa_log_error("hal_audio_deinit error:0x%x", hal_ret); if (h->core) pa_shared_remove(h->core, SHARED_HAL_INTF); @@ -133,88 +92,82 @@ void pa_hal_interface_unref(pa_hal_interface *h) { pa_xfree(h); } -int32_t pa_hal_interface_get_volume_level_max(pa_hal_interface *h, const char *volume_type, io_direction_t direction, uint32_t *level) { - int32_t ret = 0; - audio_return_t hal_ret = AUDIO_RET_OK; - audio_volume_info_t info = {NULL, NULL, 0}; +int32_t pa_hal_interface_get_volume_level_max(pa_hal_interface *h, const char *volume_type, + io_direction_t direction, uint32_t *level) { + audio_return_e hal_ret = AUDIO_RET_OK; + audio_volume_info_s info = { volume_type, NULL, direction }; pa_assert(h); pa_assert(volume_type); pa_assert(level); - info.type = volume_type; - info.direction = direction; - - if (AUDIO_RET_OK != (hal_ret = h->intf.get_volume_level_max(h->ah_handle, &info, level))) { - pa_log_error("get_volume_level_max returns error:0x%x", hal_ret); - ret = -1; + hal_ret = hal_audio_get_volume_level_max(h->audio_handle, &info, level); + if (hal_ret != AUDIO_RET_OK) { + pa_log_error("hal_audio_get_volume_level_max error:0x%x", hal_ret); + return -1; } - return ret; + + return 0; } -int32_t pa_hal_interface_get_volume_level(pa_hal_interface *h, const char *volume_type, io_direction_t direction, uint32_t *level) { - int32_t ret = 0; - audio_return_t hal_ret = AUDIO_RET_OK; - audio_volume_info_t info = {NULL, NULL, 0}; +int32_t pa_hal_interface_get_volume_level(pa_hal_interface *h, const char *volume_type, + io_direction_t direction, uint32_t *level) { + audio_return_e hal_ret = AUDIO_RET_OK; + audio_volume_info_s info = { volume_type, NULL, direction }; pa_assert(h); pa_assert(volume_type); pa_assert(level); - info.type = volume_type; - info.direction = direction; - - if (AUDIO_RET_OK != (hal_ret = h->intf.get_volume_level(h->ah_handle, &info, level))) { - pa_log_error("get_volume_level returns error:0x%x", hal_ret); - ret = -1; + hal_ret = hal_audio_get_volume_level(h->audio_handle, &info, level); + if (hal_ret != AUDIO_RET_OK) { + pa_log_error("hal_audio_get_volume_level error:0x%x", hal_ret); + return -1; } - return ret; + + return 0; } -int32_t pa_hal_interface_set_volume_level(pa_hal_interface *h, const char *volume_type, io_direction_t direction, uint32_t level) { - int32_t ret = 0; - audio_return_t hal_ret = AUDIO_RET_OK; - audio_volume_info_t info = {NULL, NULL, 0}; +int32_t pa_hal_interface_set_volume_level(pa_hal_interface *h, const char *volume_type, + io_direction_t direction, uint32_t level) { + audio_return_e hal_ret = AUDIO_RET_OK; + audio_volume_info_s info = { volume_type, NULL, direction }; pa_assert(h); pa_assert(volume_type); - info.type = volume_type; - info.direction = direction; - - if (AUDIO_RET_OK != (hal_ret = h->intf.set_volume_level(h->ah_handle, &info, level))) { - pa_log_error("set_volume_level returns error:0x%x", hal_ret); - ret = -1; + hal_ret = hal_audio_set_volume_level(h->audio_handle, &info, level); + if (hal_ret != AUDIO_RET_OK) { + pa_log_error("hal_audio_set_volume_level error:0x%x", hal_ret); + return -1; } - return ret; + return 0; } -int32_t pa_hal_interface_get_volume_value(pa_hal_interface *h, const char *volume_type, const char *gain_type, io_direction_t direction, uint32_t level, double *value) { - int32_t ret = 0; - audio_return_t hal_ret = AUDIO_RET_OK; - audio_volume_info_t info = {NULL, NULL, 0}; +int32_t pa_hal_interface_get_volume_value(pa_hal_interface *h, const char *volume_type, + const char *gain_type, io_direction_t direction, + uint32_t level, double *value) { + audio_return_e hal_ret = AUDIO_RET_OK; + audio_volume_info_s info = { volume_type, gain_type, direction }; pa_assert(h); pa_assert(volume_type); pa_assert(value); - info.type = volume_type; - info.gain = gain_type; - info.direction = direction; - - if (AUDIO_RET_OK != (hal_ret = h->intf.get_volume_value(h->ah_handle, &info, level, value))) { - pa_log_error("get_volume_value returns error:0x%x", hal_ret); - ret = -1; + hal_ret = hal_audio_get_volume_value(h->audio_handle, &info, level, value); + if (hal_ret != AUDIO_RET_OK) { + pa_log_error("hal_audio_get_volume_value error:0x%x", hal_ret); + return -1; } - return ret; + return 0; } -int32_t pa_hal_interface_get_volume_mute(pa_hal_interface *h, const char *volume_type, io_direction_t direction, uint32_t *mute) { - int32_t ret = 0; - audio_return_t hal_ret = AUDIO_RET_OK; - audio_volume_info_t info = {NULL, NULL, 0}; +int32_t pa_hal_interface_get_volume_mute(pa_hal_interface *h, const char *volume_type, + io_direction_t direction, uint32_t *mute) { + audio_return_e hal_ret = AUDIO_RET_OK; + audio_volume_info_s info = { volume_type, NULL, direction }; pa_assert(h); pa_assert(volume_type); @@ -223,73 +176,63 @@ int32_t pa_hal_interface_get_volume_mute(pa_hal_interface *h, const char *volume info.type = volume_type; info.direction = direction; - if (AUDIO_RET_OK != (hal_ret = h->intf.get_volume_mute(h->ah_handle, &info, mute))) { - pa_log_error("get_mute returns error:0x%x", hal_ret); - ret = -1; + hal_ret = hal_audio_get_volume_mute(h->audio_handle, &info, mute); + if (hal_ret != AUDIO_RET_OK) { + pa_log_error("hal_audio_get_volume_mute error:0x%x", hal_ret); + return -1; } - return ret; + + return 0; } -int32_t pa_hal_interface_set_volume_mute(pa_hal_interface *h, const char *volume_type, io_direction_t direction, uint32_t mute) { - int32_t ret = 0; - audio_return_t hal_ret = AUDIO_RET_OK; - audio_volume_info_t info = {NULL, NULL, 0}; +int32_t pa_hal_interface_set_volume_mute(pa_hal_interface *h, const char *volume_type, + io_direction_t direction, uint32_t mute) { + audio_return_e hal_ret = AUDIO_RET_OK; + audio_volume_info_s info = { volume_type, NULL, direction }; pa_assert(h); pa_assert(volume_type); - info.type = volume_type; - info.direction = direction; - - if (AUDIO_RET_OK != (hal_ret = h->intf.set_volume_mute(h->ah_handle, &info, mute))) { - pa_log_error("set_mute returns error:0x%x", hal_ret); - ret = -1; + hal_ret = hal_audio_set_volume_mute(h->audio_handle, &info, mute); + if (hal_ret != AUDIO_RET_OK) { + pa_log_error("hal_audio_set_volume_mute error:0x%x", hal_ret); + return -1; } - return ret; + + return 0; } -int32_t pa_hal_interface_set_volume_ratio(pa_hal_interface *h, const char *stream_role, io_direction_t direction, uint32_t idx, double ratio) { - int32_t ret = 0; - audio_return_t hal_ret = AUDIO_RET_OK; - audio_stream_info_t info = {NULL, 0, 0}; +int32_t pa_hal_interface_set_volume_ratio(pa_hal_interface *h, const char *stream_role, + io_direction_t direction, uint32_t idx, double ratio) { + audio_return_e hal_ret = AUDIO_RET_OK; + audio_stream_info_s info = { stream_role, direction, idx }; pa_assert(h); pa_assert(stream_role); - if (h->intf.set_volume_ratio == NULL) { - pa_log_warn("there is no set_volume_ratio symbol in this audio hal, skip it"); + hal_ret = hal_audio_set_volume_ratio(h->audio_handle, &info, ratio); + if (hal_ret != AUDIO_RET_OK) { + pa_log_error("hal_audio_set_volume_ratio error:0x%x", hal_ret); return -1; } - info.role = stream_role; - info.direction = direction; - info.idx = idx; - - if (AUDIO_RET_OK != (hal_ret = h->intf.set_volume_ratio(h->ah_handle, &info, ratio))) { - pa_log_error("set_volume_ratio returns error:0x%x", hal_ret); - ret = -1; - } - return ret; + return 0; } int32_t pa_hal_interface_notify_ducking_activation_changed(pa_hal_interface *h, hal_ducking_activation_info *info) { - audio_return_t hal_ret = AUDIO_RET_OK; - audio_ducking_info_t hal_info; + audio_return_e hal_ret = AUDIO_RET_OK; + audio_ducking_info_s hal_info = { 0, }; pa_assert(h); pa_assert(info); - if (!h->intf.notify_ducking_activation_changed) { - pa_log_warn("not implemented"); - return -2; - } - hal_info.target_role = info->target_role; hal_info.duration = info->duration; hal_info.ratio = info->ratio; - if (AUDIO_RET_OK != (hal_ret = h->intf.notify_ducking_activation_changed(h->ah_handle, &hal_info, (uint32_t)info->is_activated))) { - pa_log_error("notify_ducking_activation_changed returns error:0x%x", hal_ret); + hal_ret = hal_audio_notify_ducking_activation_changed(h->audio_handle, &hal_info, (uint32_t)info->is_activated); + if (hal_ret != AUDIO_RET_OK) { + pa_log_error("hal_audio_notify_ducking_activation_changed error:0x%x", hal_ret); return -1; } @@ -297,37 +240,38 @@ int32_t pa_hal_interface_notify_ducking_activation_changed(pa_hal_interface *h, } int32_t pa_hal_interface_update_route(pa_hal_interface *h, hal_route_info *info) { - int32_t ret = 0; - audio_return_t hal_ret = AUDIO_RET_OK; + audio_return_e hal_ret = AUDIO_RET_OK; pa_assert(h); pa_assert(info); - if (AUDIO_RET_OK != (hal_ret = h->intf.update_route(h->ah_handle, (audio_route_info_t*)info))) { - pa_log_error("update_route returns error:0x%x", hal_ret); - ret = -1; + hal_ret = hal_audio_update_route(h->audio_handle, (audio_route_info_s*)info); + if (hal_ret != AUDIO_RET_OK) { + pa_log_error("hal_audio_update_route error:0x%x", hal_ret); + return -1; } - return ret; + + return 0; } int32_t pa_hal_interface_update_route_option(pa_hal_interface *h, hal_route_option *option) { - int32_t ret = 0; - audio_return_t hal_ret = AUDIO_RET_OK; + audio_return_e hal_ret = AUDIO_RET_OK; pa_assert(h); pa_assert(option); - if (AUDIO_RET_OK != (hal_ret = h->intf.update_route_option(h->ah_handle, (audio_route_option_t*)option))) { - pa_log_error("update_route_option returns error:0x%x", hal_ret); - ret = -1; + hal_ret = hal_audio_update_route_option(h->audio_handle, (audio_route_option_s*)option); + if (hal_ret != AUDIO_RET_OK) { + pa_log_error("hal_audio_update_route_option error:0x%x", hal_ret); + return -1; } - return ret; + + return 0; } int32_t pa_hal_interface_notify_stream_connection_changed(pa_hal_interface *h, hal_stream_connection_info *info) { - int32_t ret = 0; - audio_return_t hal_ret = AUDIO_RET_OK; - audio_stream_info_t hal_info; + audio_return_e hal_ret = AUDIO_RET_OK; + audio_stream_info_s hal_info = { 0, }; pa_assert(h); pa_assert(info); @@ -336,17 +280,18 @@ int32_t pa_hal_interface_notify_stream_connection_changed(pa_hal_interface *h, h hal_info.direction = info->direction; hal_info.idx = info->idx; - if (AUDIO_RET_OK != (hal_ret = h->intf.notify_stream_connection_changed(h->ah_handle, &hal_info, (uint32_t)info->is_connected))) { - pa_log_error("notify_tream_connection_changed returns error:0x%x", hal_ret); - ret = -1; + hal_ret = hal_audio_notify_stream_connection_changed(h->audio_handle, &hal_info, (uint32_t)info->is_connected); + if (hal_ret != AUDIO_RET_OK) { + pa_log_error("hal_audio_notify_stream_connection_changed error:0x%x", hal_ret); + return -1; } - return ret; + + return 0; } int32_t pa_hal_interface_pcm_open(pa_hal_interface *h, const char *card, const char *device, io_direction_t direction, pa_sample_spec *sample_spec, uint32_t period_size, uint32_t periods, pcm_handle *pcm_h) { - int32_t ret = 0; - audio_return_t hal_ret = AUDIO_RET_OK; + audio_return_e hal_ret = AUDIO_RET_OK; pa_assert(h); pa_assert(pcm_h); @@ -354,191 +299,199 @@ int32_t pa_hal_interface_pcm_open(pa_hal_interface *h, const char *card, const c pa_assert(device); pa_assert(sample_spec); - if (AUDIO_RET_OK != (hal_ret = h->intf.pcm_open(h->ah_handle, card, device, direction, sample_spec, period_size, periods, pcm_h))) { - pa_log_error("pcm_open returns error:0x%x", hal_ret); - ret = -1; + hal_ret = hal_audio_pcm_open(h->audio_handle, card, device, direction, sample_spec, period_size, periods, pcm_h); + if (hal_ret != AUDIO_RET_OK) { + pa_log_error("hal_audio_pcm_open error:0x%x", hal_ret); + return -1; } - return ret; + + return 0; } int32_t pa_hal_interface_pcm_start(pa_hal_interface *h, pcm_handle pcm_h) { - int32_t ret = 0; - audio_return_t hal_ret = AUDIO_RET_OK; + audio_return_e hal_ret = AUDIO_RET_OK; pa_assert(h); pa_assert(pcm_h); - if (AUDIO_RET_OK != (hal_ret = h->intf.pcm_start(h->ah_handle, pcm_h))) { - pa_log_error("pcm_start returns error:0x%x", hal_ret); - ret = -1; + hal_ret = hal_audio_pcm_start(h->audio_handle, pcm_h); + if (hal_ret != AUDIO_RET_OK) { + pa_log_error("hal_audio_pcm_start error:0x%x", hal_ret); + return -1; } - return ret; + + return 0; } int32_t pa_hal_interface_pcm_stop(pa_hal_interface *h, pcm_handle pcm_h) { - int32_t ret = 0; - audio_return_t hal_ret = AUDIO_RET_OK; + audio_return_e hal_ret = AUDIO_RET_OK; pa_assert(h); pa_assert(pcm_h); - if (AUDIO_RET_OK != (hal_ret = h->intf.pcm_stop(h->ah_handle, pcm_h))) { - pa_log_error("pcm_stop returns error:0x%x", hal_ret); - ret = -1; + hal_ret = hal_audio_pcm_stop(h->audio_handle, pcm_h); + if (hal_ret != AUDIO_RET_OK) { + pa_log_error("hal_audio_pcm_stop error:0x%x", hal_ret); + return -1; } - return ret; + + return 0; } int32_t pa_hal_interface_pcm_close(pa_hal_interface *h, pcm_handle pcm_h) { - int32_t ret = 0; - audio_return_t hal_ret = AUDIO_RET_OK; + audio_return_e hal_ret = AUDIO_RET_OK; pa_assert(h); pa_assert(pcm_h); - if (AUDIO_RET_OK != (hal_ret = h->intf.pcm_close(h->ah_handle, pcm_h))) { - pa_log_error("pcm_close returns error:0x%x", hal_ret); - ret = -1; + hal_ret = hal_audio_pcm_close(h->audio_handle, pcm_h); + if (hal_ret != AUDIO_RET_OK) { + pa_log_error("hal_audio_pcm_close error:0x%x", hal_ret); + return -1; } - return ret; + + return 0; } int32_t pa_hal_interface_pcm_available(pa_hal_interface *h, pcm_handle pcm_h, uint32_t *available) { - int32_t ret = 0; - audio_return_t hal_ret = AUDIO_RET_OK; + audio_return_e hal_ret = AUDIO_RET_OK; pa_assert(h); pa_assert(pcm_h); pa_assert(available); - if (AUDIO_RET_OK != (hal_ret = h->intf.pcm_avail(h->ah_handle, pcm_h, available))) { - pa_log_error("pcm_avail returns error:0x%x", hal_ret); - ret = -1; + hal_ret = hal_audio_pcm_avail(h->audio_handle, pcm_h, available); + if (hal_ret != AUDIO_RET_OK) { + pa_log_error("hal_audio_pcm_avail error:0x%x", hal_ret); + return -1; } - return ret; + + return 0; } int32_t pa_hal_interface_pcm_write(pa_hal_interface *h, pcm_handle pcm_h, const void *buffer, uint32_t frames) { - int32_t ret = 0; - audio_return_t hal_ret = AUDIO_RET_OK; + audio_return_e hal_ret = AUDIO_RET_OK; pa_assert(h); pa_assert(pcm_h); pa_assert(buffer); - if (AUDIO_RET_OK != (hal_ret = h->intf.pcm_write(h->ah_handle, pcm_h, buffer, frames))) { - pa_log_error("pcm_write returns error:0x%x", hal_ret); - ret = -1; + hal_ret = hal_audio_pcm_write(h->audio_handle, pcm_h, buffer, frames); + if (hal_ret != AUDIO_RET_OK) { + pa_log_error("hal_audio_pcm_write error:0x%x", hal_ret); + return -1; } - return ret; + + return 0; } int32_t pa_hal_interface_pcm_read(pa_hal_interface *h, pcm_handle pcm_h, void *buffer, uint32_t frames) { - int32_t ret = 0; - audio_return_t hal_ret = AUDIO_RET_OK; + audio_return_e hal_ret = AUDIO_RET_OK; pa_assert(h); pa_assert(pcm_h); pa_assert(buffer); - if (AUDIO_RET_OK != (hal_ret = h->intf.pcm_read(h->ah_handle, pcm_h, buffer, frames))) { - pa_log_error("pcm_read returns error:0x%x", hal_ret); - ret = -1; + hal_ret = hal_audio_pcm_read(h->audio_handle, pcm_h, buffer, frames); + if (hal_ret != AUDIO_RET_OK) { + pa_log_error("hal_audio_pcm_read error:0x%x", hal_ret); + return -1; } - return ret; + + return 0; } int32_t pa_hal_interface_pcm_get_fd(pa_hal_interface *h, pcm_handle pcm_h, int *fd) { - int32_t ret = 0; - audio_return_t hal_ret = AUDIO_RET_OK; + audio_return_e hal_ret = AUDIO_RET_OK; pa_assert(h); pa_assert(pcm_h); pa_assert(fd); - if (AUDIO_RET_OK != (hal_ret = h->intf.pcm_get_fd(h->ah_handle, pcm_h, fd))) { - pa_log_error("pcm_get_fd returns error:0x%x", hal_ret); - ret = -1; + hal_ret = hal_audio_pcm_get_fd(h->audio_handle, pcm_h, fd); + if (hal_ret != AUDIO_RET_OK) { + pa_log_error("hal_audio_pcm_get_fd error:0x%x", hal_ret); + return -1; } - return ret; + + return 0; } int32_t pa_hal_interface_pcm_recover(pa_hal_interface *h, pcm_handle pcm_h, int err) { - int32_t ret = 0; - audio_return_t hal_ret = AUDIO_RET_OK; + audio_return_e hal_ret = AUDIO_RET_OK; pa_assert(h); pa_assert(pcm_h); - if (AUDIO_RET_OK != (hal_ret = h->intf.pcm_recover(h->ah_handle, pcm_h, err))) { - pa_log_error("pcm_recover returns error:0x%x", hal_ret); - ret = -1; + hal_ret = hal_audio_pcm_recover(h->audio_handle, pcm_h, err); + if (hal_ret != AUDIO_RET_OK) { + pa_log_error("hal_audio_pcm_recover error:0x%x", hal_ret); + return -1; } - return ret; + + return 0; } -int32_t pa_hal_interface_pcm_get_params(pa_hal_interface *h, pcm_handle pcm_h, uint32_t direction, void **sample_spec, uint32_t *period_size, uint32_t *periods) { - int32_t ret = 0; - audio_return_t hal_ret = AUDIO_RET_OK; +int32_t pa_hal_interface_pcm_get_params(pa_hal_interface *h, pcm_handle pcm_h, uint32_t direction, + void **sample_spec, uint32_t *period_size, uint32_t *periods) { + audio_return_e hal_ret = AUDIO_RET_OK; pa_assert(h); pa_assert(*sample_spec); pa_assert(period_size); pa_assert(periods); - if (AUDIO_RET_OK != (hal_ret = h->intf.pcm_get_params(h->ah_handle, pcm_h, direction, sample_spec, period_size, periods))) { - pa_log_error("pcm_get_params returns error:0x%x", hal_ret); - ret = -1; + hal_ret = hal_audio_pcm_get_params(h->audio_handle, pcm_h, direction, sample_spec, period_size, periods); + if (hal_ret != AUDIO_RET_OK) { + pa_log_error("hal_audio_pcm_get_params error:0x%x", hal_ret); + return -1; } - return ret; + + return 0; } -int32_t pa_hal_interface_pcm_set_params(pa_hal_interface *h, pcm_handle pcm_h, uint32_t direction, void *sample_spec, uint32_t period_size, uint32_t periods) { - int32_t ret = 0; - audio_return_t hal_ret = AUDIO_RET_OK; +int32_t pa_hal_interface_pcm_set_params(pa_hal_interface *h, pcm_handle pcm_h, uint32_t direction, + void *sample_spec, uint32_t period_size, uint32_t periods) { + audio_return_e hal_ret = AUDIO_RET_OK; pa_assert(h); pa_assert(sample_spec); - if (AUDIO_RET_OK != (hal_ret = h->intf.pcm_set_params(h->ah_handle, pcm_h, direction, sample_spec, period_size, periods))) { - pa_log_error("pcm_set_params returns error:0x%x", hal_ret); - ret = -1; + hal_ret = hal_audio_pcm_set_params(h->audio_handle, pcm_h, direction, sample_spec, period_size, periods); + if (hal_ret != AUDIO_RET_OK) { + pa_log_error("hal_audio_pcm_set_params error:0x%x", hal_ret); + return -1; } - return ret; + + return 0; } int32_t pa_hal_interface_add_message_callback(pa_hal_interface *h, hal_message_callback callback, void *user_data) { - int32_t ret = 0; - audio_return_t hal_ret = AUDIO_RET_OK; + audio_return_e hal_ret = AUDIO_RET_OK; pa_assert(h); pa_assert(callback); - if (h->intf.add_message_cb == NULL) { - pa_log_error("there is no add_message_cb symbol in this audio hal"); - ret = -1; - } else if (AUDIO_RET_OK != (hal_ret = h->intf.add_message_cb(h->ah_handle, (message_cb)callback, user_data))) { - pa_log_error("add_message_cb returns error:0x%x", hal_ret); - ret = -1; + hal_ret = hal_audio_add_message_cb(h->audio_handle, (message_cb)callback, user_data); + if (hal_ret != AUDIO_RET_OK) { + pa_log_error("hal_audio_add_message_cb error:0x%x", hal_ret); + return -1; } - return ret; + return 0; } int32_t pa_hal_interface_remove_message_callback(pa_hal_interface *h, hal_message_callback callback) { - int32_t ret = 0; - audio_return_t hal_ret = AUDIO_RET_OK; + audio_return_e hal_ret = AUDIO_RET_OK; pa_assert(h); pa_assert(callback); - if (h->intf.remove_message_cb == NULL) { - pa_log_error("there is no remove_message_cb symbol in this audio hal"); - ret = -1; - } else if (AUDIO_RET_OK != (hal_ret = h->intf.remove_message_cb(h->ah_handle, (message_cb)callback))) { - pa_log_error("remove_message_cb returns error:0x%x", hal_ret); - ret = -1; + hal_ret = hal_audio_remove_message_cb(h->audio_handle, (message_cb)callback); + if (hal_ret != AUDIO_RET_OK) { + pa_log_error("hal_audio_remove_message_cb error:0x%x", hal_ret); + return -1; } - return ret; + return 0; } diff --git a/src/hal-interface.h b/src/hal-interface.h index 2351701..ebfca2f 100644 --- a/src/hal-interface.h +++ b/src/hal-interface.h @@ -65,10 +65,10 @@ typedef struct _hal_stream_info { } hal_stream_info; typedef struct _hal_ducking_activation_info { - const char *target_role; - uint32_t duration; - double ratio; - bool is_activated; + const char *target_role; + uint32_t duration; + double ratio; + bool is_activated; } hal_ducking_activation_info; typedef void* pcm_handle; diff --git a/src/module-tizenaudio-policy.c b/src/module-tizenaudio-policy.c index a6c1075..09759e3 100644 --- a/src/module-tizenaudio-policy.c +++ b/src/module-tizenaudio-policy.c @@ -1047,7 +1047,7 @@ static void reset_route(struct userdata *u, stream_type_t stream_type) { /* unload combine sink */ if (stream_type == STREAM_SINK_INPUT) { - if (null_sink = (pa_sink*)pa_namereg_get(u->core, SINK_NAME_NULL, PA_NAMEREG_SINK)) + if ((null_sink = (pa_sink*)pa_namereg_get(u->core, SINK_NAME_NULL, PA_NAMEREG_SINK))) unload_combine_sink_module(u, SINK_NAME_COMBINED, null_sink); } diff --git a/src/stream-manager.c b/src/stream-manager.c index 0ce45e2..d611844 100644 --- a/src/stream-manager.c +++ b/src/stream-manager.c @@ -3632,7 +3632,7 @@ static void subscribe_cb(pa_core *core, pa_subscription_event_type_t t, uint32_t } /* Message callback from HAL interface */ -static void message_cb(const char *name, int value, void *user_data) { +static void message_cb_func(const char *name, int value, void *user_data) { pa_stream_manager *m; pa_stream_manager_hook_data_for_update_info hook_call_data; @@ -3760,7 +3760,7 @@ pa_stream_manager* pa_stream_manager_get(pa_core *c) { if (!(m->hal = pa_hal_interface_get(c))) goto fail; - if (pa_hal_interface_add_message_callback(m->hal, message_cb, m)) + if (pa_hal_interface_add_message_callback(m->hal, message_cb_func, m)) pa_log_warn("skip adding message callback"); m->dm = pa_device_manager_get(c); m->subs_ob = pa_subscribe_observer_get(c); @@ -3823,7 +3823,7 @@ fail: deinit_filters(m); deinit_ipc(m); if (m->hal) { - pa_hal_interface_remove_message_callback(m->hal, message_cb); + pa_hal_interface_remove_message_callback(m->hal, message_cb_func); pa_hal_interface_unref(m->hal); } if (m->dm) @@ -3937,7 +3937,7 @@ void pa_stream_manager_unref(pa_stream_manager *m) { pa_device_manager_unref(m->dm); if (m->hal) { - pa_hal_interface_remove_message_callback(m->hal, message_cb); + pa_hal_interface_remove_message_callback(m->hal, message_cb_func); pa_hal_interface_unref(m->hal); } -- 2.7.4 From d2c9f1b0308e96ae3d37a8ed65f4ddce8e2e9740 Mon Sep 17 00:00:00 2001 From: Jeongmo Yang Date: Tue, 9 Feb 2021 20:52:10 +0900 Subject: [PATCH 14/16] stream-manager-dbus: Skip virtual stream for ducking streams - The ducking state is never changed because of virtual stream. [Version] 13.0.47 [Issue Type] Bug fix Change-Id: I545f381f8868c40eaa8562bcdf4f6ae3afecfb63 Signed-off-by: Jeongmo Yang --- packaging/pulseaudio-modules-tizen.spec | 2 +- src/stream-manager-dbus.c | 2 ++ src/stream-manager-priv.h | 2 ++ src/stream-manager.c | 2 +- 4 files changed, 6 insertions(+), 2 deletions(-) diff --git a/packaging/pulseaudio-modules-tizen.spec b/packaging/pulseaudio-modules-tizen.spec index 0b5626f..9270deb 100644 --- a/packaging/pulseaudio-modules-tizen.spec +++ b/packaging/pulseaudio-modules-tizen.spec @@ -1,6 +1,6 @@ Name: pulseaudio-modules-tizen Summary: Pulseaudio modules for Tizen -Version: 13.0.46 +Version: 13.0.47 Release: 0 Group: Multimedia/Audio License: LGPL-2.1+ diff --git a/src/stream-manager-dbus.c b/src/stream-manager-dbus.c index 3545cd1..d9320f5 100644 --- a/src/stream-manager-dbus.c +++ b/src/stream-manager-dbus.c @@ -2101,6 +2101,8 @@ static void handle_activate_ducking(DBusConnection *conn, DBusMessage *msg, void /* set volume ramp factor to target stream */ PA_IDXSET_FOREACH(i, m->core->sink_inputs, idx) { + if (pa_safe_streq(VIRTUAL_STREAM_NAME, pa_proplist_gets(i->proplist, PA_PROP_MEDIA_NAME))) + continue; if (!pa_safe_streq(target_stream, pa_proplist_gets(i->proplist, PA_PROP_MEDIA_ROLE))) continue; diff --git a/src/stream-manager-priv.h b/src/stream-manager-priv.h index aeb0ac9..390b156 100644 --- a/src/stream-manager-priv.h +++ b/src/stream-manager-priv.h @@ -123,6 +123,8 @@ typedef enum _stream_ducking_state { #define STREAM_FOCUS_STATE_RELEASED "0" #define STREAM_FOCUS_STATE_ACQUIRED "1" +#define VIRTUAL_STREAM_NAME "VIRTUAL_STREAM" /* The virtual stream created by sound-manager */ + #define VOLUME_KEY_LENGTH 24 #define STREAM_ROLE_STR_MAX 32 diff --git a/src/stream-manager.c b/src/stream-manager.c index d611844..034bf0a 100644 --- a/src/stream-manager.c +++ b/src/stream-manager.c @@ -67,7 +67,7 @@ #define STREAM_MANAGER_CLIENT_INFO "SOUND_MANAGER_STREAM_INFO" /* The stream info client via sound-manager */ #define STREAM_MANAGER_CLIENT_DUCKING "SOUND_MANAGER_STREAM_DUCKING" /* The ducking client via sound-manager */ -#define VIRTUAL_STREAM_NAME "VIRTUAL_STREAM" /* The virtual stream created by sound-manager */ + #define DEFAULT_ROLE "media" #define SKIP_ROLE "skip" #define ACTIVE_DEV_REMOVED "removed" -- 2.7.4 From 8acb8aa1bf86eacf69f0b81cf1e07a20380a97df Mon Sep 17 00:00:00 2001 From: Seungbae Shin Date: Thu, 4 Mar 2021 13:02:13 +0900 Subject: [PATCH 15/16] stream-manager-dbus: update volume vconf only after internal set is successful [Version] 13.0.48 [Issue Type] Bug fix Change-Id: I9238bbe1602b43f1ac1c56ef0029d248ddb56a22 --- packaging/pulseaudio-modules-tizen.spec | 2 +- src/stream-manager-dbus.c | 18 +++++++++++++----- 2 files changed, 14 insertions(+), 6 deletions(-) diff --git a/packaging/pulseaudio-modules-tizen.spec b/packaging/pulseaudio-modules-tizen.spec index 9270deb..005241f 100644 --- a/packaging/pulseaudio-modules-tizen.spec +++ b/packaging/pulseaudio-modules-tizen.spec @@ -1,6 +1,6 @@ Name: pulseaudio-modules-tizen Summary: Pulseaudio modules for Tizen -Version: 13.0.47 +Version: 13.0.48 Release: 0 Group: Multimedia/Audio License: LGPL-2.1+ diff --git a/src/stream-manager-dbus.c b/src/stream-manager-dbus.c index d9320f5..40b2160 100644 --- a/src/stream-manager-dbus.c +++ b/src/stream-manager-dbus.c @@ -1199,8 +1199,9 @@ static void handle_set_volume_level(DBusConnection *conn, DBusMessage *msg, void const char *direction = NULL; const char *type = NULL; dbus_uint32_t level = 0; + uint32_t old_level = 0; stream_type_t stream_type = STREAM_SINK_INPUT; - int ret = 0; + int ret = RET_MSG_OK; pa_assert(conn); pa_assert(msg); @@ -1218,19 +1219,26 @@ static void handle_set_volume_level(DBusConnection *conn, DBusMessage *msg, void goto finish; } - /* check vconf update here, volume will not be set if update fails */ - if ((ret = update_volume_vconf(type, level))) { + if (get_volume_level_by_type(m, GET_VOLUME_CURRENT_LEVEL, stream_type, type, &old_level) != 0) { ret = RET_MSG_ERROR_INTERNAL; goto finish; } - if ((ret = set_volume_level_by_type(m, stream_type, type, level)) != 0) + if ((ret = set_volume_level_by_type(m, stream_type, type, level)) != 0) { ret = (ret == -2) ? RET_MSG_ERROR_INVALID_ARGUMENT : RET_MSG_ERROR_INTERNAL; + goto finish; + } + + if (update_volume_vconf(type, level) != 0) { + ret = RET_MSG_ERROR_INTERNAL; + pa_log_error("Failed to update volume vconf, rollback to old level[%u]", old_level); + set_volume_level_by_type(m, stream_type, type, old_level); + } finish: pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret]); - if (ret == 0) + if (ret == RET_MSG_OK) send_volume_changed_signal(conn, direction, type, level); } -- 2.7.4 From e4cb6edb9e040c796ec6f3ca000c7526f4d88eb5 Mon Sep 17 00:00:00 2001 From: Seungbae Shin Date: Mon, 8 Mar 2021 17:47:34 +0900 Subject: [PATCH 16/16] stream-manager-dbus: fix improper null handling on handle_get_current_volume_type() [Version] 13.0.49 [Issue Type] Bug fix Change-Id: I067eeadf9deabcc17676df254984437920765be4 --- packaging/pulseaudio-modules-tizen.spec | 2 +- src/stream-manager-dbus.c | 11 +++++++---- 2 files changed, 8 insertions(+), 5 deletions(-) diff --git a/packaging/pulseaudio-modules-tizen.spec b/packaging/pulseaudio-modules-tizen.spec index 005241f..06a0216 100644 --- a/packaging/pulseaudio-modules-tizen.spec +++ b/packaging/pulseaudio-modules-tizen.spec @@ -1,6 +1,6 @@ Name: pulseaudio-modules-tizen Summary: Pulseaudio modules for Tizen -Version: 13.0.48 +Version: 13.0.49 Release: 0 Group: Multimedia/Audio License: LGPL-2.1+ diff --git a/src/stream-manager-dbus.c b/src/stream-manager-dbus.c index 40b2160..80ec2c1 100644 --- a/src/stream-manager-dbus.c +++ b/src/stream-manager-dbus.c @@ -1475,7 +1475,7 @@ finish: static void handle_get_current_volume_type(DBusConnection *conn, DBusMessage *msg, void *userdata) { pa_stream_manager *m = (pa_stream_manager *)userdata; const char *direction = NULL; - const char *type = dbus_str_none; + const char *result = dbus_str_none; void *s = NULL; stream_type_t stream_type = STREAM_SINK_INPUT; DBusMessage *reply = NULL; @@ -1507,6 +1507,7 @@ static void handle_get_current_volume_type(DBusConnection *conn, DBusMessage *ms int cur_max_priority = 0; const char *cur_max_type = NULL; const char *role = NULL; + const char *type = NULL; stream_info *s_info; PA_IDXSET_FOREACH(s, streams, idx) { @@ -1524,14 +1525,16 @@ static void handle_get_current_volume_type(DBusConnection *conn, DBusMessage *ms } } } - type = cur_max_type; + + if (cur_max_type) + result = cur_max_type; } - if (!strncmp(type, dbus_str_none, strlen(dbus_str_none))) + if (pa_safe_streq(result, dbus_str_none)) ret = RET_MSG_ERROR_NO_STREAM; finish: - pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &type, + pa_assert_se(dbus_message_append_args(reply, DBUS_TYPE_STRING, &result, DBUS_TYPE_STRING, &stream_manager_dbus_ret_str[ret], DBUS_TYPE_INVALID)); pa_assert_se(dbus_connection_send(conn, reply, NULL)); -- 2.7.4