From: Sangchul Lee Date: Thu, 12 Aug 2021 09:19:00 +0000 (+0900) Subject: webrtc/webrtc_websocket: Apply g_mutex_locker_new() X-Git-Tag: submit/tizen/20210813.072227~2 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=f193ba04513cb40f6f1fdcced0936ba2a7f13fdc;p=platform%2Fcore%2Fapi%2Fwebrtc.git webrtc/webrtc_websocket: Apply g_mutex_locker_new() Unused macros are removed [Version] 0.2.75 [Issue Type] Refactoring Change-Id: Icba100fdca5d5f8a92bd25bd7cfab4a8eb31fc88 Signed-off-by: Sangchul Lee --- diff --git a/include/webrtc_private.h b/include/webrtc_private.h index ba3be081..b5a36abf 100644 --- a/include/webrtc_private.h +++ b/include/webrtc_private.h @@ -110,24 +110,6 @@ do { \ } \ } while (0) -#define RET_WITH_UNLOCK_IF(expr, mutex, fmt, arg...) \ -do { \ - if ((expr)) { \ - LOG_ERROR(""fmt"", ##arg); \ - g_mutex_unlock(mutex); \ - return; \ - } \ -} while (0) - -#define RET_VAL_WITH_UNLOCK_IF(expr, val, mutex, fmt, arg...) \ -do { \ - if ((expr)) { \ - LOG_ERROR(""fmt"", ##arg); \ - g_mutex_unlock(mutex); \ - return (val);\ - } \ -} while (0) - #define RET_ERR_IF_PRIVILEGE_IS_NOT_ALLOWED(x_privilege) \ do { \ int ret = _check_privilege(x_privilege); \ diff --git a/packaging/capi-media-webrtc.spec b/packaging/capi-media-webrtc.spec index b319a8b3..f8edf768 100644 --- a/packaging/capi-media-webrtc.spec +++ b/packaging/capi-media-webrtc.spec @@ -1,6 +1,6 @@ Name: capi-media-webrtc Summary: A WebRTC library in Tizen Native API -Version: 0.2.74 +Version: 0.2.75 Release: 0 Group: Multimedia/API License: Apache-2.0 diff --git a/src/webrtc.c b/src/webrtc.c index d85bbc4b..98a03f2c 100644 --- a/src/webrtc.c +++ b/src/webrtc.c @@ -50,13 +50,14 @@ int webrtc_set_error_cb(webrtc_h webrtc, webrtc_error_cb callback, void *user_da int webrtc_unset_error_cb(webrtc_h webrtc) { + g_autoptr(GMutexLocker) locker = NULL; webrtc_s *_webrtc = (webrtc_s*)webrtc; RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL"); - g_mutex_lock(&_webrtc->mutex); + locker = g_mutex_locker_new(&_webrtc->mutex); - RET_VAL_WITH_UNLOCK_IF(_webrtc->error_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, &_webrtc->mutex, "callback was not set"); + RET_VAL_IF(_webrtc->error_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, "callback was not set"); LOG_INFO("callback[%p] user_data[%p] is reset to NULL", _webrtc->error_cb.callback, _webrtc->error_cb.user_data); @@ -64,8 +65,6 @@ int webrtc_unset_error_cb(webrtc_h webrtc) _webrtc->error_cb.callback = NULL; _webrtc->error_cb.user_data = NULL; - g_mutex_unlock(&_webrtc->mutex); - return WEBRTC_ERROR_NONE; } @@ -116,18 +115,19 @@ int webrtc_create(webrtc_h *webrtc) int webrtc_destroy(webrtc_h webrtc) { int ret = WEBRTC_ERROR_NONE; + g_autoptr(GMutexLocker) locker = NULL; webrtc_s *_webrtc = (webrtc_s*)webrtc; RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL"); - g_mutex_lock(&_webrtc->mutex); + locker = g_mutex_locker_new(&_webrtc->mutex); ret = _gst_pipeline_set_state(_webrtc, GST_STATE_NULL); - RET_VAL_WITH_UNLOCK_IF(ret != WEBRTC_ERROR_NONE, ret, &_webrtc->mutex, "failed to _gst_pipeline_set_state()"); + RET_VAL_IF(ret != WEBRTC_ERROR_NONE, ret, "failed to _gst_pipeline_set_state()"); #ifndef TIZEN_TV ret = _destroy_resource_manager(_webrtc); - RET_VAL_WITH_UNLOCK_IF(ret != WEBRTC_ERROR_NONE, ret, &_webrtc->mutex, "failed to _destroy_resource_manager()"); + RET_VAL_IF(ret != WEBRTC_ERROR_NONE, ret, "failed to _destroy_resource_manager()"); #endif _webrtc->pend_state = WEBRTC_STATE_IDLE; _webrtc->state = _webrtc->pend_state; @@ -141,7 +141,7 @@ int webrtc_destroy(webrtc_h webrtc) LOG_INFO("webrtc[%p] is destroyed", webrtc); - g_mutex_unlock(&_webrtc->mutex); + g_clear_pointer(&locker, g_mutex_locker_free); g_mutex_clear(&_webrtc->mutex); g_free(_webrtc); @@ -152,34 +152,33 @@ int webrtc_destroy(webrtc_h webrtc) int webrtc_start(webrtc_h webrtc) { int ret = WEBRTC_ERROR_NONE; + g_autoptr(GMutexLocker) locker = NULL; webrtc_s *_webrtc = (webrtc_s*)webrtc; RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL"); - g_mutex_lock(&_webrtc->mutex); + locker = g_mutex_locker_new(&_webrtc->mutex); - RET_VAL_WITH_UNLOCK_IF(_webrtc->ice_candidate_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, &_webrtc->mutex, "the ice candidate callback should be set"); - RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be IDLE"); - RET_VAL_WITH_UNLOCK_IF(_webrtc->gst.webrtcbin == NULL, WEBRTC_ERROR_INVALID_OPERATION, &_webrtc->mutex, "webrtcbin is NULL"); - RET_VAL_WITH_UNLOCK_IF(!_check_if_format_is_set_to_packet_sources(_webrtc), WEBRTC_ERROR_INVALID_OPERATION, &_webrtc->mutex, "the media format should be set"); - RET_VAL_WITH_UNLOCK_IF(!_check_if_path_is_set_to_file_sources(_webrtc), WEBRTC_ERROR_INVALID_OPERATION, &_webrtc->mutex, "the media path should be set"); + RET_VAL_IF(_webrtc->ice_candidate_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, "the ice candidate callback should be set"); + RET_VAL_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, "the state should be IDLE"); + RET_VAL_IF(_webrtc->gst.webrtcbin == NULL, WEBRTC_ERROR_INVALID_OPERATION, "webrtcbin is NULL"); + RET_VAL_IF(!_check_if_format_is_set_to_packet_sources(_webrtc), WEBRTC_ERROR_INVALID_OPERATION, "the media format should be set"); + RET_VAL_IF(!_check_if_path_is_set_to_file_sources(_webrtc), WEBRTC_ERROR_INVALID_OPERATION, "the media path should be set"); #ifndef TIZEN_TV ret = _acquire_resource_if_needed(_webrtc); if (ret != WEBRTC_ERROR_NONE) { LOG_ERROR("failed to acquire resource, webrtc[%p]", _webrtc); - g_mutex_unlock(&_webrtc->mutex); return ret; } #endif ret = _gst_pipeline_set_state(_webrtc, GST_STATE_PLAYING); - RET_VAL_WITH_UNLOCK_IF(ret != WEBRTC_ERROR_NONE, ret, &_webrtc->mutex, "failed to change GST state to PLAYING"); + RET_VAL_IF(ret != WEBRTC_ERROR_NONE, ret, "failed to change GST state to PLAYING"); _webrtc->pend_state = WEBRTC_STATE_NEGOTIATING; LOG_INFO("webrtc[%p] is started", webrtc); - g_mutex_unlock(&_webrtc->mutex); return WEBRTC_ERROR_NONE; } @@ -216,13 +215,14 @@ int webrtc_set_state_changed_cb(webrtc_h webrtc, webrtc_state_changed_cb callbac int webrtc_unset_state_changed_cb(webrtc_h webrtc) { + g_autoptr(GMutexLocker) locker = NULL; webrtc_s *_webrtc = (webrtc_s*)webrtc; RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL"); - g_mutex_lock(&_webrtc->mutex); + locker = g_mutex_locker_new(&_webrtc->mutex); - RET_VAL_WITH_UNLOCK_IF(_webrtc->state_changed_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, &_webrtc->mutex, "callback was not set"); + RET_VAL_IF(_webrtc->state_changed_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, "callback was not set"); LOG_INFO("callback[%p] user_data[%p] is reset to NULL", _webrtc->state_changed_cb.callback, _webrtc->state_changed_cb.user_data); @@ -230,8 +230,6 @@ int webrtc_unset_state_changed_cb(webrtc_h webrtc) _webrtc->state_changed_cb.callback = NULL; _webrtc->state_changed_cb.user_data = NULL; - g_mutex_unlock(&_webrtc->mutex); - return WEBRTC_ERROR_NONE; } @@ -256,6 +254,7 @@ int webrtc_get_state(webrtc_h webrtc, webrtc_state_e *state) int webrtc_add_media_source(webrtc_h webrtc, webrtc_media_source_type_e type, unsigned int *source_id) { int ret = WEBRTC_ERROR_NONE; + g_autoptr(GMutexLocker) locker = NULL; webrtc_s *_webrtc = (webrtc_s*)webrtc; if (type == WEBRTC_MEDIA_SOURCE_TYPE_CAMERA) { @@ -269,56 +268,52 @@ int webrtc_add_media_source(webrtc_h webrtc, webrtc_media_source_type_e type, un RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL"); RET_VAL_IF(source_id == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "source_id is NULL"); - g_mutex_lock(&_webrtc->mutex); + locker = g_mutex_locker_new(&_webrtc->mutex); - RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be IDLE"); + RET_VAL_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, "the state should be IDLE"); ret = _add_media_source(webrtc, type, source_id); if (ret == WEBRTC_ERROR_NONE) LOG_INFO("source_id[%u]", *source_id); - g_mutex_unlock(&_webrtc->mutex); - return ret; } int webrtc_remove_media_source(webrtc_h webrtc, unsigned int source_id) { int ret = WEBRTC_ERROR_NONE; + g_autoptr(GMutexLocker) locker = NULL; webrtc_s *_webrtc = (webrtc_s*)webrtc; RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL"); - g_mutex_lock(&_webrtc->mutex); + locker = g_mutex_locker_new(&_webrtc->mutex); - RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be IDLE"); + RET_VAL_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, "the state should be IDLE"); ret = _remove_media_source(webrtc, source_id); if (ret == WEBRTC_ERROR_NONE) LOG_INFO("source_id[%u]", source_id); - g_mutex_unlock(&_webrtc->mutex); - return ret; } int webrtc_media_source_set_transceiver_direction(webrtc_h webrtc, unsigned int source_id, webrtc_media_type_e media_type, webrtc_transceiver_direction_e direction) { int ret = WEBRTC_ERROR_NONE; + g_autoptr(GMutexLocker) locker = NULL; webrtc_s *_webrtc = (webrtc_s*)webrtc; RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL"); - g_mutex_lock(&_webrtc->mutex); + locker = g_mutex_locker_new(&_webrtc->mutex); - RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be IDLE"); + RET_VAL_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, "the state should be IDLE"); ret = _set_transceiver_direction(webrtc, source_id, media_type, direction); if (ret == WEBRTC_ERROR_NONE) LOG_INFO("source_id[%u] media_type[%d] direction[%d]", source_id, media_type, direction); - g_mutex_unlock(&_webrtc->mutex); - return ret; } @@ -477,24 +472,24 @@ int webrtc_media_source_get_video_resolution(webrtc_h webrtc, unsigned int sourc int webrtc_mic_source_set_sound_stream_info(webrtc_h webrtc, unsigned int source_id, sound_stream_info_h stream_info) { int ret = WEBRTC_ERROR_NONE; + g_autoptr(GMutexLocker) locker = NULL; webrtc_s *_webrtc = (webrtc_s*)webrtc; RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL"); RET_VAL_IF(stream_info == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "stream_info is NULL"); - g_mutex_lock(&_webrtc->mutex); + locker = g_mutex_locker_new(&_webrtc->mutex); - RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be IDLE"); + RET_VAL_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, "the state should be IDLE"); ret = _set_sound_stream_info(webrtc, source_id, stream_info); - g_mutex_unlock(&_webrtc->mutex); - return ret; } int webrtc_media_packet_source_set_buffer_state_changed_cb(webrtc_h webrtc, unsigned int source_id, webrtc_media_packet_source_buffer_state_changed_cb callback, void *user_data) { + g_autoptr(GMutexLocker) locker = NULL; webrtc_s *_webrtc = (webrtc_s*)webrtc; webrtc_gst_slot_s *source; @@ -502,11 +497,11 @@ int webrtc_media_packet_source_set_buffer_state_changed_cb(webrtc_h webrtc, unsi RET_VAL_IF(source_id == 0, WEBRTC_ERROR_INVALID_PARAMETER, "source_id is 0"); RET_VAL_IF(callback == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "callback is NULL"); - g_mutex_lock(&_webrtc->mutex); + locker = g_mutex_locker_new(&_webrtc->mutex); - RET_VAL_WITH_UNLOCK_IF((source = _get_slot_by_id(_webrtc->gst.source_slots, source_id)) == NULL, WEBRTC_ERROR_INVALID_PARAMETER, - &_webrtc->mutex, "source is NULL"); - RET_VAL_WITH_UNLOCK_IF(source->type != WEBRTC_MEDIA_SOURCE_TYPE_MEDIA_PACKET, WEBRTC_ERROR_INVALID_PARAMETER, &_webrtc->mutex, + RET_VAL_IF((source = _get_slot_by_id(_webrtc->gst.source_slots, source_id)) == NULL, + WEBRTC_ERROR_INVALID_PARAMETER, "source is NULL"); + RET_VAL_IF(source->type != WEBRTC_MEDIA_SOURCE_TYPE_MEDIA_PACKET, WEBRTC_ERROR_INVALID_PARAMETER, "source is not media packet type"); LOG_WARNING_IF_CALLBACK_EXISTS(source->buffer_state_changed_cb); @@ -516,26 +511,25 @@ int webrtc_media_packet_source_set_buffer_state_changed_cb(webrtc_h webrtc, unsi LOG_INFO("callback[%p] user_data[%p]", callback, user_data); - g_mutex_unlock(&_webrtc->mutex); - return WEBRTC_ERROR_NONE; } int webrtc_media_packet_source_unset_buffer_state_changed_cb(webrtc_h webrtc, unsigned int source_id) { + g_autoptr(GMutexLocker) locker = NULL; webrtc_s *_webrtc = (webrtc_s*)webrtc; webrtc_gst_slot_s *source; RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL"); RET_VAL_IF(source_id == 0, WEBRTC_ERROR_INVALID_PARAMETER, "source_id is 0"); - g_mutex_lock(&_webrtc->mutex); + locker = g_mutex_locker_new(&_webrtc->mutex); - RET_VAL_WITH_UNLOCK_IF((source = _get_slot_by_id(_webrtc->gst.source_slots, source_id)) == NULL, WEBRTC_ERROR_INVALID_PARAMETER, - &_webrtc->mutex, "source is NULL"); - RET_VAL_WITH_UNLOCK_IF(source->type != WEBRTC_MEDIA_SOURCE_TYPE_MEDIA_PACKET, WEBRTC_ERROR_INVALID_PARAMETER, &_webrtc->mutex, + RET_VAL_IF((source = _get_slot_by_id(_webrtc->gst.source_slots, source_id)) == NULL, + WEBRTC_ERROR_INVALID_PARAMETER, "source is NULL"); + RET_VAL_IF(source->type != WEBRTC_MEDIA_SOURCE_TYPE_MEDIA_PACKET, WEBRTC_ERROR_INVALID_PARAMETER, "source is not media packet type"); - RET_VAL_WITH_UNLOCK_IF(source->buffer_state_changed_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, &_webrtc->mutex,\ + RET_VAL_IF(source->buffer_state_changed_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, "callback was not set"); LOG_INFO("callback[%p] user_data[%p] is reset to NULL", @@ -544,105 +538,100 @@ int webrtc_media_packet_source_unset_buffer_state_changed_cb(webrtc_h webrtc, un source->buffer_state_changed_cb.callback = NULL; source->buffer_state_changed_cb.user_data = NULL; - g_mutex_unlock(&_webrtc->mutex); - return WEBRTC_ERROR_NONE; } int webrtc_media_packet_source_set_format(webrtc_h webrtc, unsigned int source_id, media_format_h format) { int ret = WEBRTC_ERROR_NONE; + g_autoptr(GMutexLocker) locker = NULL; webrtc_s *_webrtc = (webrtc_s*)webrtc; RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL"); RET_VAL_IF(format == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "format is NULL"); - g_mutex_lock(&_webrtc->mutex); + locker = g_mutex_locker_new(&_webrtc->mutex); - RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be IDLE"); + RET_VAL_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, "the state should be IDLE"); ret = _set_media_format(_webrtc, source_id, format); if (ret == WEBRTC_ERROR_NONE) LOG_INFO("source_id[%u] format[%p]", source_id, format); - g_mutex_unlock(&_webrtc->mutex); - return ret; } int webrtc_media_packet_source_push_packet(webrtc_h webrtc, unsigned int source_id, media_packet_h packet) { int ret = WEBRTC_ERROR_NONE; + g_autoptr(GMutexLocker) locker = NULL; webrtc_s *_webrtc = (webrtc_s*)webrtc; webrtc_gst_slot_s *source; RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL"); RET_VAL_IF(packet == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "packet is NULL"); - g_mutex_lock(&_webrtc->mutex); + locker = g_mutex_locker_new(&_webrtc->mutex); - RET_VAL_WITH_UNLOCK_IF((source = _get_slot_by_id(_webrtc->gst.source_slots, source_id)) == NULL, WEBRTC_ERROR_INVALID_PARAMETER, - &_webrtc->mutex, "source is NULL"); - RET_VAL_WITH_UNLOCK_IF(source->type != WEBRTC_MEDIA_SOURCE_TYPE_MEDIA_PACKET, WEBRTC_ERROR_INVALID_PARAMETER, &_webrtc->mutex, + RET_VAL_IF((source = _get_slot_by_id(_webrtc->gst.source_slots, source_id)) == NULL, + WEBRTC_ERROR_INVALID_PARAMETER, "source is NULL"); + RET_VAL_IF(source->type != WEBRTC_MEDIA_SOURCE_TYPE_MEDIA_PACKET, WEBRTC_ERROR_INVALID_PARAMETER, "source is not media packet type"); - RET_VAL_WITH_UNLOCK_IF(source->media_format == NULL, WEBRTC_ERROR_INVALID_OPERATION, &_webrtc->mutex, + RET_VAL_IF(source->media_format == NULL, WEBRTC_ERROR_INVALID_OPERATION, "the media format should be set"); - RET_VAL_WITH_UNLOCK_IF(source->buffer_state_changed_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, &_webrtc->mutex, + RET_VAL_IF(source->buffer_state_changed_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, "the buffer state changed callback should be set"); ret = _push_media_packet(webrtc, source_id, packet); - g_mutex_unlock(&_webrtc->mutex); - return ret; } int webrtc_file_source_set_path(webrtc_h webrtc, unsigned int source_id, const char *path) { int ret = WEBRTC_ERROR_NONE; + g_autoptr(GMutexLocker) locker = NULL; webrtc_s *_webrtc = (webrtc_s*)webrtc; RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL"); RET_VAL_IF(source_id == 0, WEBRTC_ERROR_INVALID_PARAMETER, "source_id is 0"); RET_VAL_IF(path == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "path is NULL"); - g_mutex_lock(&_webrtc->mutex); + locker = g_mutex_locker_new(&_webrtc->mutex); - RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be IDLE"); + RET_VAL_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, "the state should be IDLE"); ret = _set_media_path(_webrtc, source_id, path); - g_mutex_unlock(&_webrtc->mutex); - return ret; } int webrtc_set_sound_stream_info(webrtc_h webrtc, unsigned int track_id, sound_stream_info_h stream_info) { int ret = WEBRTC_ERROR_NONE; + g_autoptr(GMutexLocker) locker = NULL; webrtc_s *_webrtc = (webrtc_s*)webrtc; RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL"); RET_VAL_IF(track_id == 0, WEBRTC_ERROR_INVALID_PARAMETER, "track id is 0"); RET_VAL_IF(stream_info == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "stream_info is NULL"); - g_mutex_lock(&_webrtc->mutex); + locker = g_mutex_locker_new(&_webrtc->mutex); - RET_VAL_WITH_UNLOCK_IF(_webrtc->track_added_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, &_webrtc->mutex, "track added callback was not set"); - RET_VAL_WITH_UNLOCK_IF(_webrtc->encoded_audio_frame_cb.callback, WEBRTC_ERROR_INVALID_OPERATION, &_webrtc->mutex, "encoded audio frame callback was set"); - RET_VAL_WITH_UNLOCK_IF(!_is_owner_of_track_build_context(_webrtc, track_id), WEBRTC_ERROR_INVALID_OPERATION, &_webrtc->mutex, - "this function should be called within the track added callback"); + RET_VAL_IF(_webrtc->track_added_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, "track added callback was not set"); + RET_VAL_IF(_webrtc->encoded_audio_frame_cb.callback, WEBRTC_ERROR_INVALID_OPERATION, "encoded audio frame callback was set"); + RET_VAL_IF(!_is_owner_of_track_build_context(_webrtc, track_id), WEBRTC_ERROR_INVALID_OPERATION, + "this function should be called within the track added callback"); ret = _set_stream_info_to_sink(webrtc, track_id, stream_info); - g_mutex_unlock(&_webrtc->mutex); - return ret; } int webrtc_set_display(webrtc_h webrtc, unsigned int track_id, webrtc_display_type_e type, webrtc_display_h display) { int ret = WEBRTC_ERROR_NONE; + g_autoptr(GMutexLocker) locker = NULL; webrtc_s *_webrtc = (webrtc_s*)webrtc; RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL"); @@ -650,17 +639,15 @@ int webrtc_set_display(webrtc_h webrtc, unsigned int track_id, webrtc_display_ty RET_VAL_IF(type > WEBRTC_DISPLAY_TYPE_EVAS, WEBRTC_ERROR_INVALID_PARAMETER, "invalid display type(%d)", type); RET_VAL_IF(display == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "display is NULL"); - g_mutex_lock(&_webrtc->mutex); + locker = g_mutex_locker_new(&_webrtc->mutex); - RET_VAL_WITH_UNLOCK_IF(_webrtc->track_added_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, &_webrtc->mutex, "track added callback was not set"); - RET_VAL_WITH_UNLOCK_IF(_webrtc->encoded_video_frame_cb.callback, WEBRTC_ERROR_INVALID_OPERATION, &_webrtc->mutex, "encoded video frame callback was set"); - RET_VAL_WITH_UNLOCK_IF(!_is_owner_of_track_build_context(_webrtc, track_id), WEBRTC_ERROR_INVALID_OPERATION, &_webrtc->mutex, - "this function should be called within the track added callback"); + RET_VAL_IF(_webrtc->track_added_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, "track added callback was not set"); + RET_VAL_IF(_webrtc->encoded_video_frame_cb.callback, WEBRTC_ERROR_INVALID_OPERATION, "encoded video frame callback was set"); + RET_VAL_IF(!_is_owner_of_track_build_context(_webrtc, track_id), WEBRTC_ERROR_INVALID_OPERATION, + "this function should be called within the track added callback"); ret = _set_display_to_sink(webrtc, track_id, (unsigned int)type, (void *)display); - g_mutex_unlock(&_webrtc->mutex); - return ret; } @@ -749,14 +736,15 @@ int webrtc_get_display_visible(webrtc_h webrtc, unsigned int track_id, bool *vis int webrtc_set_encoded_audio_frame_cb(webrtc_h webrtc, webrtc_encoded_frame_cb callback, void *user_data) { + g_autoptr(GMutexLocker) locker = NULL; webrtc_s *_webrtc = (webrtc_s*)webrtc; RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL"); RET_VAL_IF(callback == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "callback is NULL"); - g_mutex_lock(&_webrtc->mutex); + locker = g_mutex_locker_new(&_webrtc->mutex); - RET_VAL_WITH_UNLOCK_IF(_webrtc->state == WEBRTC_STATE_PLAYING, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should NOT be PLAYING"); + RET_VAL_IF(_webrtc->state == WEBRTC_STATE_PLAYING, WEBRTC_ERROR_INVALID_STATE, "the state should NOT be PLAYING"); LOG_WARNING_IF_CALLBACK_EXISTS(_webrtc->encoded_audio_frame_cb); @@ -765,21 +753,20 @@ int webrtc_set_encoded_audio_frame_cb(webrtc_h webrtc, webrtc_encoded_frame_cb c LOG_INFO("callback[%p] user_data[%p]", callback, user_data); - g_mutex_unlock(&_webrtc->mutex); - return WEBRTC_ERROR_NONE; } int webrtc_unset_encoded_audio_frame_cb(webrtc_h webrtc) { + g_autoptr(GMutexLocker) locker = NULL; webrtc_s *_webrtc = (webrtc_s*)webrtc; RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL"); - g_mutex_lock(&_webrtc->mutex); + locker = g_mutex_locker_new(&_webrtc->mutex); - RET_VAL_WITH_UNLOCK_IF(_webrtc->encoded_audio_frame_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, &_webrtc->mutex, "callback was not set"); - RET_VAL_WITH_UNLOCK_IF(_webrtc->state == WEBRTC_STATE_PLAYING, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should NOT be PLAYING"); + RET_VAL_IF(_webrtc->encoded_audio_frame_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, "callback was not set"); + RET_VAL_IF(_webrtc->state == WEBRTC_STATE_PLAYING, WEBRTC_ERROR_INVALID_STATE, "the state should NOT be PLAYING"); LOG_INFO("callback[%p] user_data[%p] is reset to NULL", _webrtc->encoded_audio_frame_cb.callback, _webrtc->encoded_audio_frame_cb.user_data); @@ -787,21 +774,20 @@ int webrtc_unset_encoded_audio_frame_cb(webrtc_h webrtc) _webrtc->encoded_audio_frame_cb.callback = NULL; _webrtc->encoded_audio_frame_cb.user_data = NULL; - g_mutex_unlock(&_webrtc->mutex); - return WEBRTC_ERROR_NONE; } int webrtc_set_encoded_video_frame_cb(webrtc_h webrtc, webrtc_encoded_frame_cb callback, void *user_data) { + g_autoptr(GMutexLocker) locker = NULL; webrtc_s *_webrtc = (webrtc_s*)webrtc; RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL"); RET_VAL_IF(callback == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "callback is NULL"); - g_mutex_lock(&_webrtc->mutex); + locker = g_mutex_locker_new(&_webrtc->mutex); - RET_VAL_WITH_UNLOCK_IF(_webrtc->state == WEBRTC_STATE_PLAYING, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should NOT be PLAYING"); + RET_VAL_IF(_webrtc->state == WEBRTC_STATE_PLAYING, WEBRTC_ERROR_INVALID_STATE, "the state should NOT be PLAYING"); LOG_WARNING_IF_CALLBACK_EXISTS(_webrtc->encoded_video_frame_cb); @@ -810,21 +796,20 @@ int webrtc_set_encoded_video_frame_cb(webrtc_h webrtc, webrtc_encoded_frame_cb c LOG_INFO("callback[%p] user_data[%p]", callback, user_data); - g_mutex_unlock(&_webrtc->mutex); - return WEBRTC_ERROR_NONE; } int webrtc_unset_encoded_video_frame_cb(webrtc_h webrtc) { + g_autoptr(GMutexLocker) locker = NULL; webrtc_s *_webrtc = (webrtc_s*)webrtc; RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL"); - g_mutex_lock(&_webrtc->mutex); + locker = g_mutex_locker_new(&_webrtc->mutex); - RET_VAL_WITH_UNLOCK_IF(_webrtc->encoded_video_frame_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, &_webrtc->mutex, "callback was not set"); - RET_VAL_WITH_UNLOCK_IF(_webrtc->state == WEBRTC_STATE_PLAYING, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should NOT be PLAYING"); + RET_VAL_IF(_webrtc->encoded_video_frame_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, "callback was not set"); + RET_VAL_IF(_webrtc->state == WEBRTC_STATE_PLAYING, WEBRTC_ERROR_INVALID_STATE, "the state should NOT be PLAYING"); LOG_INFO("callback[%p] user_data[%p] is reset to NULL", _webrtc->encoded_video_frame_cb.callback, _webrtc->encoded_video_frame_cb.user_data); @@ -832,8 +817,6 @@ int webrtc_unset_encoded_video_frame_cb(webrtc_h webrtc) _webrtc->encoded_video_frame_cb.callback = NULL; _webrtc->encoded_video_frame_cb.user_data = NULL; - g_mutex_unlock(&_webrtc->mutex); - return WEBRTC_ERROR_NONE; } @@ -876,14 +859,15 @@ int webrtc_media_source_set_video_loopback(webrtc_h webrtc, unsigned int source_ int webrtc_set_stun_server(webrtc_h webrtc, const char *stun_server) { + g_autoptr(GMutexLocker) locker = NULL; webrtc_s *_webrtc = (webrtc_s*)webrtc; RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL"); RET_VAL_IF(stun_server == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "stun_server is NULL"); - g_mutex_lock(&_webrtc->mutex); + locker = g_mutex_locker_new(&_webrtc->mutex); - RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be IDLE"); + RET_VAL_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, "the state should be IDLE"); g_free(_webrtc->stun_server_url); @@ -893,8 +877,6 @@ int webrtc_set_stun_server(webrtc_h webrtc, const char *stun_server) LOG_INFO("stun_server[%s]", stun_server); - g_mutex_unlock(&_webrtc->mutex); - return WEBRTC_ERROR_NONE; } @@ -922,24 +904,23 @@ int webrtc_get_stun_server(webrtc_h webrtc, char **stun_server) int webrtc_add_turn_server(webrtc_h webrtc, const char *turn_server) { gboolean ret = FALSE; + g_autoptr(GMutexLocker) locker = NULL; webrtc_s *_webrtc = (webrtc_s*)webrtc; RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL"); RET_VAL_IF(turn_server == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "turn_server is NULL"); - g_mutex_lock(&_webrtc->mutex); + locker = g_mutex_locker_new(&_webrtc->mutex); - RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be IDLE"); + RET_VAL_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, "the state should be IDLE"); g_signal_emit_by_name(G_OBJECT(_webrtc->gst.webrtcbin), "add-turn-server", turn_server, &ret); - RET_VAL_WITH_UNLOCK_IF(!ret, WEBRTC_ERROR_INVALID_PARAMETER, &_webrtc->mutex, "invalid turn server url (%s)", turn_server); + RET_VAL_IF(!ret, WEBRTC_ERROR_INVALID_PARAMETER, "invalid turn server url (%s)", turn_server); _webrtc->turn_server_urls = g_list_append(_webrtc->turn_server_urls, g_strdup(turn_server)); LOG_INFO("turn_server[%s]", turn_server); - g_mutex_unlock(&_webrtc->mutex); - return WEBRTC_ERROR_NONE; } @@ -972,21 +953,20 @@ int webrtc_foreach_turn_server(webrtc_h webrtc, webrtc_turn_server_cb callback, int webrtc_set_ice_transport_policy(webrtc_h webrtc, webrtc_ice_transport_policy_e policy) { + g_autoptr(GMutexLocker) locker = NULL; webrtc_s *_webrtc = (webrtc_s*)webrtc; RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL"); RET_VAL_IF(policy > WEBRTC_ICE_TRANSPORT_POLICY_RELAY, WEBRTC_ERROR_INVALID_PARAMETER, "invalid policy(%d)", policy); - g_mutex_lock(&_webrtc->mutex); + locker = g_mutex_locker_new(&_webrtc->mutex); - RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be IDLE"); + RET_VAL_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, "the state should be IDLE"); g_object_set(G_OBJECT(_webrtc->gst.webrtcbin), "ice-transport-policy", (GstWebRTCICETransportPolicy)policy, NULL); LOG_INFO("policy[%s]", (policy == WEBRTC_ICE_TRANSPORT_POLICY_ALL) ? "all" : "relay"); - g_mutex_unlock(&_webrtc->mutex); - return WEBRTC_ERROR_NONE; } @@ -1013,14 +993,15 @@ int webrtc_get_ice_transport_policy(webrtc_h webrtc, webrtc_ice_transport_policy int webrtc_set_peer_connection_state_change_cb(webrtc_h webrtc, webrtc_peer_connection_state_change_cb callback, void *user_data) { + g_autoptr(GMutexLocker) locker = NULL; webrtc_s *_webrtc = (webrtc_s*)webrtc; RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL"); RET_VAL_IF(callback == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "callback is NULL"); - g_mutex_lock(&_webrtc->mutex); + locker = g_mutex_locker_new(&_webrtc->mutex); - RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be IDLE"); + RET_VAL_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, "the state should be IDLE"); LOG_WARNING_IF_CALLBACK_EXISTS(_webrtc->peer_connection_state_change_cb); @@ -1029,21 +1010,20 @@ int webrtc_set_peer_connection_state_change_cb(webrtc_h webrtc, webrtc_peer_conn LOG_INFO("callback[%p] user_data[%p]", callback, user_data); - g_mutex_unlock(&_webrtc->mutex); - return WEBRTC_ERROR_NONE; } int webrtc_unset_peer_connection_state_change_cb(webrtc_h webrtc) { + g_autoptr(GMutexLocker) locker = NULL; webrtc_s *_webrtc = (webrtc_s*)webrtc; RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL"); - g_mutex_lock(&_webrtc->mutex); + locker = g_mutex_locker_new(&_webrtc->mutex); - RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be IDLE"); - RET_VAL_WITH_UNLOCK_IF(_webrtc->peer_connection_state_change_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, &_webrtc->mutex, "callback was not set"); + RET_VAL_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, "the state should be IDLE"); + RET_VAL_IF(_webrtc->peer_connection_state_change_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, "callback was not set"); LOG_INFO("callback[%p] user_data[%p] is reset to NULL", _webrtc->peer_connection_state_change_cb.callback, _webrtc->peer_connection_state_change_cb.user_data); @@ -1051,8 +1031,6 @@ int webrtc_unset_peer_connection_state_change_cb(webrtc_h webrtc) _webrtc->peer_connection_state_change_cb.callback = NULL; _webrtc->peer_connection_state_change_cb.user_data = NULL; - g_mutex_unlock(&_webrtc->mutex); - return WEBRTC_ERROR_NONE; } @@ -1076,14 +1054,15 @@ int webrtc_get_peer_connection_state(webrtc_h webrtc, webrtc_peer_connection_sta int webrtc_set_signaling_state_change_cb(webrtc_h webrtc, webrtc_signaling_state_change_cb callback, void *user_data) { + g_autoptr(GMutexLocker) locker = NULL; webrtc_s *_webrtc = (webrtc_s*)webrtc; RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL"); RET_VAL_IF(callback == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "callback is NULL"); - g_mutex_lock(&_webrtc->mutex); + locker = g_mutex_locker_new(&_webrtc->mutex); - RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be IDLE"); + RET_VAL_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, "the state should be IDLE"); LOG_WARNING_IF_CALLBACK_EXISTS(_webrtc->signaling_state_change_cb); @@ -1092,21 +1071,20 @@ int webrtc_set_signaling_state_change_cb(webrtc_h webrtc, webrtc_signaling_state LOG_INFO("callback[%p] user_data[%p]", callback, user_data); - g_mutex_unlock(&_webrtc->mutex); - return WEBRTC_ERROR_NONE; } int webrtc_unset_signaling_state_change_cb(webrtc_h webrtc) { + g_autoptr(GMutexLocker) locker = NULL; webrtc_s *_webrtc = (webrtc_s*)webrtc; RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL"); - g_mutex_lock(&_webrtc->mutex); + locker = g_mutex_locker_new(&_webrtc->mutex); - RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be IDLE"); - RET_VAL_WITH_UNLOCK_IF(_webrtc->signaling_state_change_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, &_webrtc->mutex, "callback was not set"); + RET_VAL_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, "the state should be IDLE"); + RET_VAL_IF(_webrtc->signaling_state_change_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, "callback was not set"); LOG_INFO("callback[%p] user_data[%p] is reset to NULL", _webrtc->signaling_state_change_cb.callback, _webrtc->signaling_state_change_cb.user_data); @@ -1114,8 +1092,6 @@ int webrtc_unset_signaling_state_change_cb(webrtc_h webrtc) _webrtc->signaling_state_change_cb.callback = NULL; _webrtc->signaling_state_change_cb.user_data = NULL; - g_mutex_unlock(&_webrtc->mutex); - return WEBRTC_ERROR_NONE; } @@ -1139,14 +1115,15 @@ int webrtc_get_signaling_state(webrtc_h webrtc, webrtc_signaling_state_e *state) int webrtc_set_ice_gathering_state_change_cb(webrtc_h webrtc, webrtc_ice_gathering_state_change_cb callback, void *user_data) { + g_autoptr(GMutexLocker) locker = NULL; webrtc_s *_webrtc = (webrtc_s*)webrtc; RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL"); RET_VAL_IF(callback == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "callback is NULL"); - g_mutex_lock(&_webrtc->mutex); + locker = g_mutex_locker_new(&_webrtc->mutex); - RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be IDLE"); + RET_VAL_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, "the state should be IDLE"); LOG_WARNING_IF_CALLBACK_EXISTS(_webrtc->ice_gathering_state_change_cb); @@ -1155,21 +1132,20 @@ int webrtc_set_ice_gathering_state_change_cb(webrtc_h webrtc, webrtc_ice_gatheri LOG_INFO("callback[%p] user_data[%p]", callback, user_data); - g_mutex_unlock(&_webrtc->mutex); - return WEBRTC_ERROR_NONE; } int webrtc_unset_ice_gathering_state_change_cb(webrtc_h webrtc) { + g_autoptr(GMutexLocker) locker = NULL; webrtc_s *_webrtc = (webrtc_s*)webrtc; RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL"); - g_mutex_lock(&_webrtc->mutex); + locker = g_mutex_locker_new(&_webrtc->mutex); - RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be IDLE"); - RET_VAL_WITH_UNLOCK_IF(_webrtc->ice_gathering_state_change_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, &_webrtc->mutex, "callback was not set"); + RET_VAL_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, "the state should be IDLE"); + RET_VAL_IF(_webrtc->ice_gathering_state_change_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, "callback was not set"); LOG_INFO("callback[%p] user_data[%p] is reset to NULL", _webrtc->ice_gathering_state_change_cb.callback, _webrtc->ice_gathering_state_change_cb.user_data); @@ -1177,8 +1153,6 @@ int webrtc_unset_ice_gathering_state_change_cb(webrtc_h webrtc) _webrtc->ice_gathering_state_change_cb.callback = NULL; _webrtc->ice_gathering_state_change_cb.user_data = NULL; - g_mutex_unlock(&_webrtc->mutex); - return WEBRTC_ERROR_NONE; } @@ -1202,14 +1176,15 @@ int webrtc_get_ice_gathering_state(webrtc_h webrtc, webrtc_ice_gathering_state_e int webrtc_set_ice_connection_state_change_cb(webrtc_h webrtc, webrtc_ice_connection_state_change_cb callback, void *user_data) { + g_autoptr(GMutexLocker) locker = NULL; webrtc_s *_webrtc = (webrtc_s*)webrtc; RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL"); RET_VAL_IF(callback == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "callback is NULL"); - g_mutex_lock(&_webrtc->mutex); + locker = g_mutex_locker_new(&_webrtc->mutex); - RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be IDLE"); + RET_VAL_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, "the state should be IDLE"); LOG_WARNING_IF_CALLBACK_EXISTS(_webrtc->ice_connection_state_change_cb); @@ -1218,21 +1193,20 @@ int webrtc_set_ice_connection_state_change_cb(webrtc_h webrtc, webrtc_ice_connec LOG_INFO("callback[%p] user_data[%p]", callback, user_data); - g_mutex_unlock(&_webrtc->mutex); - return WEBRTC_ERROR_NONE; } int webrtc_unset_ice_connection_state_change_cb(webrtc_h webrtc) { + g_autoptr(GMutexLocker) locker = NULL; webrtc_s *_webrtc = (webrtc_s*)webrtc; RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL"); - g_mutex_lock(&_webrtc->mutex); + locker = g_mutex_locker_new(&_webrtc->mutex); - RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be IDLE"); - RET_VAL_WITH_UNLOCK_IF(_webrtc->ice_connection_state_change_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, &_webrtc->mutex, "callback was not set"); + RET_VAL_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, "the state should be IDLE"); + RET_VAL_IF(_webrtc->ice_connection_state_change_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, "callback was not set"); LOG_INFO("callback[%p] user_data[%p] is reset to NULL", _webrtc->ice_connection_state_change_cb.callback, _webrtc->ice_connection_state_change_cb.user_data); @@ -1240,8 +1214,6 @@ int webrtc_unset_ice_connection_state_change_cb(webrtc_h webrtc) _webrtc->ice_connection_state_change_cb.callback = NULL; _webrtc->ice_connection_state_change_cb.user_data = NULL; - g_mutex_unlock(&_webrtc->mutex); - return WEBRTC_ERROR_NONE; } @@ -1265,14 +1237,15 @@ int webrtc_get_ice_connection_state(webrtc_h webrtc, webrtc_ice_connection_state int webrtc_set_negotiation_needed_cb(webrtc_h webrtc, webrtc_negotiation_needed_cb callback, void *user_data) { + g_autoptr(GMutexLocker) locker = NULL; webrtc_s *_webrtc = (webrtc_s*)webrtc; RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL"); RET_VAL_IF(callback == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "callback is NULL"); - g_mutex_lock(&_webrtc->mutex); + locker = g_mutex_locker_new(&_webrtc->mutex); - RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be IDLE"); + RET_VAL_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, "the state should be IDLE"); LOG_WARNING_IF_CALLBACK_EXISTS(_webrtc->negotiation_needed_cb); @@ -1281,21 +1254,20 @@ int webrtc_set_negotiation_needed_cb(webrtc_h webrtc, webrtc_negotiation_needed_ LOG_INFO("callback[%p] user_data[%p]", callback, user_data); - g_mutex_unlock(&_webrtc->mutex); - return WEBRTC_ERROR_NONE; } int webrtc_unset_negotiation_needed_cb(webrtc_h webrtc) { + g_autoptr(GMutexLocker) locker = NULL; webrtc_s *_webrtc = (webrtc_s*)webrtc; RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL"); - g_mutex_lock(&_webrtc->mutex); + locker = g_mutex_locker_new(&_webrtc->mutex); - RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be IDLE"); - RET_VAL_WITH_UNLOCK_IF(_webrtc->negotiation_needed_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, &_webrtc->mutex, "callback was not set"); + RET_VAL_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, "the state should be IDLE"); + RET_VAL_IF(_webrtc->negotiation_needed_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, "callback was not set"); LOG_INFO("callback[%p] user_data[%p] is reset to NULL", _webrtc->negotiation_needed_cb.callback, _webrtc->negotiation_needed_cb.user_data); @@ -1303,21 +1275,20 @@ int webrtc_unset_negotiation_needed_cb(webrtc_h webrtc) _webrtc->negotiation_needed_cb.callback = NULL; _webrtc->negotiation_needed_cb.user_data = NULL; - g_mutex_unlock(&_webrtc->mutex); - return WEBRTC_ERROR_NONE; } int webrtc_set_ice_candidate_cb(webrtc_h webrtc, webrtc_ice_candidate_cb callback, void *user_data) { + g_autoptr(GMutexLocker) locker = NULL; webrtc_s *_webrtc = (webrtc_s*)webrtc; RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL"); RET_VAL_IF(callback == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "callback is NULL"); - g_mutex_lock(&_webrtc->mutex); + locker = g_mutex_locker_new(&_webrtc->mutex); - RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be IDLE"); + RET_VAL_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, "the state should be IDLE"); LOG_WARNING_IF_CALLBACK_EXISTS(_webrtc->ice_candidate_cb); @@ -1326,21 +1297,20 @@ int webrtc_set_ice_candidate_cb(webrtc_h webrtc, webrtc_ice_candidate_cb callbac LOG_INFO("callback[%p] user_data[%p]", callback, user_data); - g_mutex_unlock(&_webrtc->mutex); - return WEBRTC_ERROR_NONE; } int webrtc_unset_ice_candidate_cb(webrtc_h webrtc) { + g_autoptr(GMutexLocker) locker = NULL; webrtc_s *_webrtc = (webrtc_s*)webrtc; RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL"); - g_mutex_lock(&_webrtc->mutex); + locker = g_mutex_locker_new(&_webrtc->mutex); - RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be IDLE"); - RET_VAL_WITH_UNLOCK_IF(_webrtc->ice_candidate_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, &_webrtc->mutex, "callback was not set"); + RET_VAL_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, "the state should be IDLE"); + RET_VAL_IF(_webrtc->ice_candidate_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, "callback was not set"); LOG_INFO("callback[%p] user_data[%p] is reset to NULL", _webrtc->ice_candidate_cb.callback, _webrtc->ice_candidate_cb.user_data); @@ -1348,21 +1318,20 @@ int webrtc_unset_ice_candidate_cb(webrtc_h webrtc) _webrtc->ice_candidate_cb.callback = NULL; _webrtc->ice_candidate_cb.user_data = NULL; - g_mutex_unlock(&_webrtc->mutex); - return WEBRTC_ERROR_NONE; } int webrtc_set_track_added_cb(webrtc_h webrtc, webrtc_track_added_cb callback, void *user_data) { + g_autoptr(GMutexLocker) locker = NULL; webrtc_s *_webrtc = (webrtc_s*)webrtc; RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL"); RET_VAL_IF(callback == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "callback is NULL"); - g_mutex_lock(&_webrtc->mutex); + locker = g_mutex_locker_new(&_webrtc->mutex); - RET_VAL_WITH_UNLOCK_IF(_webrtc->state == WEBRTC_STATE_PLAYING, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should NOT be PLAYING"); + RET_VAL_IF(_webrtc->state == WEBRTC_STATE_PLAYING, WEBRTC_ERROR_INVALID_STATE, "the state should NOT be PLAYING"); LOG_WARNING_IF_CALLBACK_EXISTS(_webrtc->track_added_cb); @@ -1371,20 +1340,19 @@ int webrtc_set_track_added_cb(webrtc_h webrtc, webrtc_track_added_cb callback, v LOG_INFO("callback[%p] user_data[%p]", callback, user_data); - g_mutex_unlock(&_webrtc->mutex); - return WEBRTC_ERROR_NONE; } int webrtc_unset_track_added_cb(webrtc_h webrtc) { + g_autoptr(GMutexLocker) locker = NULL; webrtc_s *_webrtc = (webrtc_s*)webrtc; RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL"); - g_mutex_lock(&_webrtc->mutex); + locker = g_mutex_locker_new(&_webrtc->mutex); - RET_VAL_WITH_UNLOCK_IF(_webrtc->track_added_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, &_webrtc->mutex, "callback was not set"); + RET_VAL_IF(_webrtc->track_added_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, "callback was not set"); LOG_INFO("callback[%p] user_data[%p] is reset to NULL", _webrtc->track_added_cb.callback, _webrtc->track_added_cb.user_data); @@ -1392,135 +1360,109 @@ int webrtc_unset_track_added_cb(webrtc_h webrtc) _webrtc->track_added_cb.callback = NULL; _webrtc->track_added_cb.user_data = NULL; - g_mutex_unlock(&_webrtc->mutex); - return WEBRTC_ERROR_NONE; } int webrtc_create_offer(webrtc_h webrtc, bundle *options, char **offer) { - int ret = WEBRTC_ERROR_NONE; + g_autoptr(GMutexLocker) locker = NULL; webrtc_s *_webrtc = (webrtc_s*)webrtc; RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL"); RET_VAL_IF(offer == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "offer is NULL"); - g_mutex_lock(&_webrtc->mutex); + locker = g_mutex_locker_new(&_webrtc->mutex); - RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_NEGOTIATING, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be NEGOTIATING"); + RET_VAL_IF(_webrtc->state != WEBRTC_STATE_NEGOTIATING, WEBRTC_ERROR_INVALID_STATE, "the state should be NEGOTIATING"); LOG_INFO("offer[%p]", offer); - ret = _webrtcbin_create_session_description(webrtc, true, offer); - - g_mutex_unlock(&_webrtc->mutex); - - return ret; + return _webrtcbin_create_session_description(webrtc, true, offer); } int webrtc_create_answer(webrtc_h webrtc, bundle *options, char **answer) { - int ret = WEBRTC_ERROR_NONE; + g_autoptr(GMutexLocker) locker = NULL; webrtc_s *_webrtc = (webrtc_s*)webrtc; RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL"); RET_VAL_IF(answer == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "answer is NULL"); - g_mutex_lock(&_webrtc->mutex); + locker = g_mutex_locker_new(&_webrtc->mutex); - RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_NEGOTIATING, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be NEGOTIATING"); - RET_VAL_WITH_UNLOCK_IF(!_webrtcbin_have_remote_offer(_webrtc), WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "remote offer should be set"); + RET_VAL_IF(_webrtc->state != WEBRTC_STATE_NEGOTIATING, WEBRTC_ERROR_INVALID_STATE, "the state should be NEGOTIATING"); + RET_VAL_IF(!_webrtcbin_have_remote_offer(_webrtc), WEBRTC_ERROR_INVALID_STATE, "remote offer should be set"); LOG_INFO("answer[%p]", answer); - ret = _webrtcbin_create_session_description(webrtc, false, answer); - - g_mutex_unlock(&_webrtc->mutex); - - return ret; + return _webrtcbin_create_session_description(webrtc, false, answer); } int webrtc_set_local_description(webrtc_h webrtc, const char *description) { - int ret = WEBRTC_ERROR_NONE; + g_autoptr(GMutexLocker) locker = NULL; webrtc_s *_webrtc = (webrtc_s*)webrtc; RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL"); RET_VAL_IF(description == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "description is NULL"); - g_mutex_lock(&_webrtc->mutex); + locker = g_mutex_locker_new(&_webrtc->mutex); - RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_NEGOTIATING, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be NEGOTIATING"); + RET_VAL_IF(_webrtc->state != WEBRTC_STATE_NEGOTIATING, WEBRTC_ERROR_INVALID_STATE, "the state should be NEGOTIATING"); LOG_INFO("description: %s", description); - ret = _webrtcbin_set_session_description(webrtc, description, false); - - g_mutex_unlock(&_webrtc->mutex); - - return ret; + return _webrtcbin_set_session_description(webrtc, description, false); } int webrtc_set_remote_description(webrtc_h webrtc, const char *description) { - int ret = WEBRTC_ERROR_NONE; + g_autoptr(GMutexLocker) locker = NULL; webrtc_s *_webrtc = (webrtc_s*)webrtc; RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL"); RET_VAL_IF(description == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "description is NULL"); - g_mutex_lock(&_webrtc->mutex); + locker = g_mutex_locker_new(&_webrtc->mutex); - RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_NEGOTIATING, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be NEGOTIATING"); + RET_VAL_IF(_webrtc->state != WEBRTC_STATE_NEGOTIATING, WEBRTC_ERROR_INVALID_STATE, "the state should be NEGOTIATING"); LOG_INFO("description: %s", description); - ret = _webrtcbin_set_session_description(webrtc, description, true); - - g_mutex_unlock(&_webrtc->mutex); - - return ret; + return _webrtcbin_set_session_description(webrtc, description, true); } int webrtc_add_ice_candidate(webrtc_h webrtc, const char *candidate) { - int ret = WEBRTC_ERROR_NONE; + g_autoptr(GMutexLocker) locker = NULL; webrtc_s *_webrtc = (webrtc_s*)webrtc; RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL"); RET_VAL_IF(candidate == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "candidate is NULL"); - g_mutex_lock(&_webrtc->mutex); + locker = g_mutex_locker_new(&_webrtc->mutex); - RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_NEGOTIATING, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be NEGOTIATING"); + RET_VAL_IF(_webrtc->state != WEBRTC_STATE_NEGOTIATING, WEBRTC_ERROR_INVALID_STATE, "the state should be NEGOTIATING"); LOG_INFO("candidate: %s", candidate); - ret = _webrtcbin_add_ice_candidate(webrtc, candidate); - - g_mutex_unlock(&_webrtc->mutex); - - return ret; + return _webrtcbin_add_ice_candidate(webrtc, candidate); } int webrtc_create_data_channel(webrtc_h webrtc, const char *label, bundle *options, webrtc_data_channel_h *channel) { - int ret = WEBRTC_ERROR_NONE; + g_autoptr(GMutexLocker) locker = NULL; webrtc_s *_webrtc = (webrtc_s*)webrtc; RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL"); RET_VAL_IF(label == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "label is NULL"); RET_VAL_IF(channel == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "channel is NULL"); - g_mutex_lock(&_webrtc->mutex); - - RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be IDLE"); - - ret = _create_data_channel(webrtc, label, options, (webrtc_data_channel_s **)channel); + locker = g_mutex_locker_new(&_webrtc->mutex); - g_mutex_unlock(&_webrtc->mutex); + RET_VAL_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, "the state should be IDLE"); - return ret; + return _create_data_channel(webrtc, label, options, (webrtc_data_channel_s **)channel); } int webrtc_destroy_data_channel(webrtc_data_channel_h channel) @@ -1532,14 +1474,15 @@ int webrtc_destroy_data_channel(webrtc_data_channel_h channel) int webrtc_set_data_channel_cb(webrtc_h webrtc, webrtc_data_channel_cb callback, void *user_data) { + g_autoptr(GMutexLocker) locker = NULL; webrtc_s *_webrtc = (webrtc_s*)webrtc; RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL"); RET_VAL_IF(callback == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "callback is NULL"); - g_mutex_lock(&_webrtc->mutex); + locker = g_mutex_locker_new(&_webrtc->mutex); - RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be IDLE"); + RET_VAL_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, "the state should be IDLE"); LOG_WARNING_IF_CALLBACK_EXISTS(_webrtc->data_channel_cb); @@ -1548,21 +1491,20 @@ int webrtc_set_data_channel_cb(webrtc_h webrtc, webrtc_data_channel_cb callback, LOG_INFO("callback[%p] user_data[%p]", callback, user_data); - g_mutex_unlock(&_webrtc->mutex); - return WEBRTC_ERROR_NONE; } int webrtc_unset_data_channel_cb(webrtc_h webrtc) { + g_autoptr(GMutexLocker) locker = NULL; webrtc_s *_webrtc = (webrtc_s*)webrtc; RET_VAL_IF(_webrtc == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "webrtc is NULL"); - g_mutex_lock(&_webrtc->mutex); + locker = g_mutex_locker_new(&_webrtc->mutex); - RET_VAL_WITH_UNLOCK_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, &_webrtc->mutex, "the state should be IDLE"); - RET_VAL_WITH_UNLOCK_IF(_webrtc->data_channel_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, &_webrtc->mutex, "callback was not set"); + RET_VAL_IF(_webrtc->state != WEBRTC_STATE_IDLE, WEBRTC_ERROR_INVALID_STATE, "the state should be IDLE"); + RET_VAL_IF(_webrtc->data_channel_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, "callback was not set"); LOG_INFO("callback[%p] user_data[%p] is reset to NULL", _webrtc->data_channel_cb.callback, _webrtc->data_channel_cb.user_data); @@ -1570,8 +1512,6 @@ int webrtc_unset_data_channel_cb(webrtc_h webrtc) _webrtc->data_channel_cb.callback = NULL; _webrtc->data_channel_cb.user_data = NULL; - g_mutex_unlock(&_webrtc->mutex); - return WEBRTC_ERROR_NONE; } @@ -1598,13 +1538,14 @@ int webrtc_data_channel_set_open_cb(webrtc_data_channel_h channel, webrtc_data_c int webrtc_data_channel_unset_open_cb(webrtc_data_channel_h channel) { + g_autoptr(GMutexLocker) locker = NULL; webrtc_data_channel_s *_channel = (webrtc_data_channel_s*)channel; RET_VAL_IF(_channel == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "channel is NULL"); - g_mutex_lock(&_channel->mutex); + locker = g_mutex_locker_new(&_channel->mutex); - RET_VAL_WITH_UNLOCK_IF(_channel->open_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, &_channel->mutex, "callback was not set"); + RET_VAL_IF(_channel->open_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, "callback was not set"); LOG_INFO("channel[%p] callback[%p] user_data[%p] is reset to NULL", _channel, _channel->open_cb.callback, _channel->open_cb.user_data); @@ -1612,8 +1553,6 @@ int webrtc_data_channel_unset_open_cb(webrtc_data_channel_h channel) _channel->open_cb.callback = NULL; _channel->open_cb.user_data = NULL; - g_mutex_unlock(&_channel->mutex); - return WEBRTC_ERROR_NONE; } @@ -1640,13 +1579,14 @@ int webrtc_data_channel_set_message_cb(webrtc_data_channel_h channel, webrtc_dat int webrtc_data_channel_unset_message_cb(webrtc_data_channel_h channel) { + g_autoptr(GMutexLocker) locker = NULL; webrtc_data_channel_s *_channel = (webrtc_data_channel_s*)channel; RET_VAL_IF(_channel == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "channel is NULL"); - g_mutex_lock(&_channel->mutex); + locker = g_mutex_locker_new(&_channel->mutex); - RET_VAL_WITH_UNLOCK_IF(_channel->message_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, &_channel->mutex, "callback was not set"); + RET_VAL_IF(_channel->message_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, "callback was not set"); LOG_INFO("channel[%p] callback[%p] user_data[%p] is reset to NULL", _channel, _channel->message_cb.callback, _channel->message_cb.user_data); @@ -1654,8 +1594,6 @@ int webrtc_data_channel_unset_message_cb(webrtc_data_channel_h channel) _channel->message_cb.callback = NULL; _channel->message_cb.user_data = NULL; - g_mutex_unlock(&_channel->mutex); - return WEBRTC_ERROR_NONE; } @@ -1682,13 +1620,14 @@ int webrtc_data_channel_set_error_cb(webrtc_data_channel_h channel, webrtc_data_ int webrtc_data_channel_unset_error_cb(webrtc_data_channel_h channel) { + g_autoptr(GMutexLocker) locker = NULL; webrtc_data_channel_s *_channel = (webrtc_data_channel_s*)channel; RET_VAL_IF(_channel == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "channel is NULL"); - g_mutex_lock(&_channel->mutex); + locker = g_mutex_locker_new(&_channel->mutex); - RET_VAL_WITH_UNLOCK_IF(_channel->error_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, &_channel->mutex, "callback was not set"); + RET_VAL_IF(_channel->error_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, "callback was not set"); LOG_INFO("channel[%p] callback[%p] user_data[%p] is reset to NULL", _channel, _channel->error_cb.callback, _channel->error_cb.user_data); @@ -1696,8 +1635,6 @@ int webrtc_data_channel_unset_error_cb(webrtc_data_channel_h channel) _channel->error_cb.callback = NULL; _channel->error_cb.user_data = NULL; - g_mutex_unlock(&_channel->mutex); - return WEBRTC_ERROR_NONE; } @@ -1724,13 +1661,14 @@ int webrtc_data_channel_set_close_cb(webrtc_data_channel_h channel, webrtc_data_ int webrtc_data_channel_unset_close_cb(webrtc_data_channel_h channel) { + g_autoptr(GMutexLocker) locker = NULL; webrtc_data_channel_s *_channel = (webrtc_data_channel_s*)channel; RET_VAL_IF(_channel == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "channel is NULL"); - g_mutex_lock(&_channel->mutex); + locker = g_mutex_locker_new(&_channel->mutex); - RET_VAL_WITH_UNLOCK_IF(_channel->close_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, &_channel->mutex, "callback was not set"); + RET_VAL_IF(_channel->close_cb.callback == NULL, WEBRTC_ERROR_INVALID_OPERATION, "callback was not set"); LOG_INFO("channel[%p] callback[%p] user_data[%p] is reset to NULL", _channel, _channel->close_cb.callback, _channel->close_cb.user_data); @@ -1738,8 +1676,6 @@ int webrtc_data_channel_unset_close_cb(webrtc_data_channel_h channel) _channel->close_cb.callback = NULL; _channel->close_cb.user_data = NULL; - g_mutex_unlock(&_channel->mutex); - return WEBRTC_ERROR_NONE; } diff --git a/src/webrtc_display.c b/src/webrtc_display.c index 3cd8ff3d..9778de0f 100644 --- a/src/webrtc_display.c +++ b/src/webrtc_display.c @@ -786,8 +786,8 @@ int _set_display_mode(webrtc_display_s *display, webrtc_display_mode_e mode) locker = g_mutex_locker_new(&display->mutex); - RET_VAL_WITH_UNLOCK_IF(display->mm_display == NULL, WEBRTC_ERROR_INVALID_OPERATION, &display->mutex, "mm_display is NULL"); - RET_VAL_WITH_UNLOCK_IF(display->surface == NULL, WEBRTC_ERROR_INVALID_OPERATION, &display->mutex, "surface is NULL"); + RET_VAL_IF(display->mm_display == NULL, WEBRTC_ERROR_INVALID_OPERATION, "mm_display is NULL"); + RET_VAL_IF(display->surface == NULL, WEBRTC_ERROR_INVALID_OPERATION, "surface is NULL"); switch (display->type) { case WEBRTC_DISPLAY_TYPE_OVERLAY: diff --git a/src/webrtc_signaling_server.c b/src/webrtc_signaling_server.c index 3f28165f..a47d2ff8 100644 --- a/src/webrtc_signaling_server.c +++ b/src/webrtc_signaling_server.c @@ -434,7 +434,7 @@ int webrtc_signaling_server_start(webrtc_signaling_server_h server) _server->exit_thread = false; _server->thread = g_thread_try_new("signaling-thread", __thread_func, _server, &error); - RET_VAL_WITH_UNLOCK_IF(_server->thread == NULL, WEBRTC_ERROR_INVALID_OPERATION, &_server->mutex, + RET_VAL_IF(_server->thread == NULL, WEBRTC_ERROR_INVALID_OPERATION, "failed to g_thread_try_new(), error[%s]", error->message); LOG_INFO("server[%p, thread:%p]", _server, _server->thread); diff --git a/src/webrtc_websocket.c b/src/webrtc_websocket.c index 4b238b86..2f6f3f71 100644 --- a/src/webrtc_websocket.c +++ b/src/webrtc_websocket.c @@ -82,23 +82,21 @@ void _release_websocket(webrtc_websocket_s *ws) int _start_websocket(webrtc_websocket_s *ws, int timeout_ms) { int ret; + g_autoptr(GMutexLocker) locker = NULL; RET_VAL_IF(ws == NULL, WEBRTC_ERROR_INVALID_PARAMETER, "ws is NULL"); RET_VAL_IF(timeout_ms < 0, WEBRTC_ERROR_INVALID_PARAMETER, "invalid timeout_ms(%d)", timeout_ms); - g_mutex_lock(&ws->mutex); + locker = g_mutex_locker_new(&ws->mutex); ret = lws_service(ws->context, timeout_ms); if (ret != 0) { LOG_ERROR("failed to lws_service(), ret[%d]", ret); - g_mutex_unlock(&ws->mutex); return WEBRTC_ERROR_INVALID_OPERATION; } LOG_DEBUG("ws[%p, context:%p], timeout_ms[%d]", ws, ws->context, timeout_ms); - g_mutex_unlock(&ws->mutex); - return WEBRTC_ERROR_NONE; }