Unify duplicated code regarding wfd sink property getting

Change-Id: Ib2b17f5084059c1a6039c601b7624340d9226071

diff --git a/include/scmirroring_private.h b/include/scmirroring_private.h
index 113ecb1882eec29d08076b5241f7f7808289aa74..85731fb43271771f45c968dff4aac46c46001569 100644 (file)
--- a/include/scmirroring_private.h
+++ b/include/scmirroring_private.h
@@ -284,6 +284,14 @@ int _scmirroring_sink_resume(MMHandleType handle);
 int _scmirroring_sink_disconnect(MMHandleType handle);
 int _scmirroring_sink_set_display(MMHandleType handle, scmirroring_display_type_e type, void *display_surface);
 int _scmirroring_sink_set_resolution(MMHandleType handle, int resolution);
+int _scmirroring_sink_get_negotiated_video_codec(MMHandleType handle, scmirroring_video_codec_e *codec);
+int _scmirroring_sink_get_negotiated_video_resolution(MMHandleType handle, int *width, int *height);
+int _scmirroring_sink_get_negotiated_video_frame_rate(MMHandleType handle, int *frame_rate);
+int _scmirroring_sink_get_negotiated_audio_codec(MMHandleType handle, scmirroring_audio_codec_e *codec);
+int _scmirroring_sink_get_negotiated_audio_channel(MMHandleType handle, int *channel);
+int _scmirroring_sink_get_negotiated_audio_sample_rate(MMHandleType handle, int *sample_rate);
+int _scmirroring_sink_get_negotiated_audio_bitwidth(MMHandleType handle, int *bitwidth);
+int _scmirroring_sink_get_current_state(MMHandleType handle, scmirroring_sink_state_e *state);
 
 #ifdef __cplusplus
 }

diff --git a/src/scmirroring_primary_sink.c b/src/scmirroring_primary_sink.c
index 3df36101a8ac63048022140e9192fd5ba44dc631..a70992873c7427a599312104c94a95633b1a6420 100644 (file)
--- a/src/scmirroring_primary_sink.c
+++ b/src/scmirroring_primary_sink.c
@@ -277,211 +277,74 @@ int scmirroring_primary_sink_resume(scmirroring_primary_sink_h scmirroring_prima
 
 int scmirroring_primary_sink_get_negotiated_video_codec(scmirroring_primary_sink_h scmirroring_primary_sink, scmirroring_video_codec_e *codec)
 {
-       int ret = SCMIRRORING_ERROR_NONE;
-       int mm_codec = MM_WFD_SINK_VIDEO_CODEC_NONE;
-
        scmirroring_primary_sink_s *handle = (scmirroring_primary_sink_s *)scmirroring_primary_sink;
-       scmirroring_debug_fenter();
 
        scmirroring_retvm_if(!__is_valid_handle(handle), SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring_primary_sink is invalid");
-       scmirroring_retvm_if(codec == NULL, SCMIRRORING_ERROR_INVALID_PARAMETER, "codec is NULL");
-
-       *codec = SCMIRRORING_VIDEO_CODEC_NONE;
-
-       ret = mm_wfd_sink_get_negotiated_video_codec(handle->mm_handle, &mm_codec);
-       ret = _scmirroring_error_convert(__func__, ret);
-       if (ret != SCMIRRORING_ERROR_NONE)
-               return ret;
-
-       switch (mm_codec) {
-       case MM_WFD_SINK_VIDEO_CODEC_H264:
-               *codec = SCMIRRORING_VIDEO_CODEC_H264;
-               break;
-       default:
-               *codec = SCMIRRORING_VIDEO_CODEC_NONE;
-               break;
-       }
-
-       scmirroring_debug("codec: %d", *codec);
-       scmirroring_debug_fleave();
 
-       return ret;
+       return _scmirroring_sink_get_negotiated_video_codec(handle->mm_handle, codec);
 }
 
 int scmirroring_primary_sink_get_negotiated_video_resolution(scmirroring_primary_sink_h scmirroring_primary_sink, int *width, int *height)
 {
-       int ret = SCMIRRORING_ERROR_NONE;
-
        scmirroring_primary_sink_s *handle = (scmirroring_primary_sink_s *)scmirroring_primary_sink;
-       scmirroring_debug_fenter();
 
        scmirroring_retvm_if(!__is_valid_handle(handle), SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring_primary_sink is invalid");
-       scmirroring_retvm_if(width == NULL, SCMIRRORING_ERROR_INVALID_PARAMETER, "width is NULL");
-       scmirroring_retvm_if(height == NULL, SCMIRRORING_ERROR_INVALID_PARAMETER, "height is NULL");
-
-       *width = 0;
-       *height = 0;
-
-       ret = mm_wfd_sink_get_negotiated_video_resolution(handle->mm_handle, width, height);
-       ret = _scmirroring_error_convert(__func__, ret);
-       if (ret != SCMIRRORING_ERROR_NONE)
-               return ret;
-
-       scmirroring_debug("width: %d, height: %d", *width, *height);
-       scmirroring_debug_fleave();
 
-       return ret;
+       return _scmirroring_sink_get_negotiated_video_resolution(handle->mm_handle, width, height);
 }
 
 int scmirroring_primary_sink_get_negotiated_video_frame_rate(scmirroring_primary_sink_h scmirroring_primary_sink, int *frame_rate)
 {
-       int ret = SCMIRRORING_ERROR_NONE;
-
        scmirroring_primary_sink_s *handle = (scmirroring_primary_sink_s *)scmirroring_primary_sink;
-       scmirroring_debug_fenter();
 
        scmirroring_retvm_if(!__is_valid_handle(handle), SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring_primary_sink is invalid");
-       scmirroring_retvm_if(frame_rate == NULL, SCMIRRORING_ERROR_INVALID_PARAMETER, "frame_rate is NULL");
 
-       *frame_rate = 0;
-
-       ret = mm_wfd_sink_get_negotiated_video_frame_rate(handle->mm_handle, frame_rate);
-       ret = _scmirroring_error_convert(__func__, ret);
-       if (ret != SCMIRRORING_ERROR_NONE)
-               return ret;
-
-       scmirroring_debug("frame rate: %d", *frame_rate);
-       scmirroring_debug_fleave();
-
-       return ret;
+       return _scmirroring_sink_get_negotiated_video_frame_rate(handle->mm_handle, frame_rate);
 }
 
 int scmirroring_primary_sink_get_negotiated_audio_codec(scmirroring_primary_sink_h scmirroring_primary_sink, scmirroring_audio_codec_e *codec)
 {
-       int ret = SCMIRRORING_ERROR_NONE;
-       int mm_codec = MM_WFD_SINK_AUDIO_CODEC_NONE;
-
        scmirroring_primary_sink_s *handle = (scmirroring_primary_sink_s *)scmirroring_primary_sink;
-       scmirroring_debug_fenter();
 
        scmirroring_retvm_if(!__is_valid_handle(handle), SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring_primary_sink is invalid");
-       scmirroring_retvm_if(codec == NULL, SCMIRRORING_ERROR_INVALID_PARAMETER, "codec is NULL");
-
-       *codec = SCMIRRORING_AUDIO_CODEC_NONE;
-
-       ret = mm_wfd_sink_get_negotiated_audio_codec(handle->mm_handle, &mm_codec);
-       ret = _scmirroring_error_convert(__func__, ret);
-       if (ret != SCMIRRORING_ERROR_NONE)
-               return ret;
-
-       switch (mm_codec) {
-       case MM_WFD_SINK_AUDIO_CODEC_AAC:
-               *codec = SCMIRRORING_AUDIO_CODEC_AAC;
-               break;
-       case MM_WFD_SINK_AUDIO_CODEC_AC3:
-               *codec = SCMIRRORING_AUDIO_CODEC_AC3;
-               break;
-       case MM_WFD_SINK_AUDIO_CODEC_LPCM:
-               *codec = SCMIRRORING_AUDIO_CODEC_LPCM;
-               break;
-       default:
-               *codec = SCMIRRORING_AUDIO_CODEC_NONE;
-               break;
-       }
-
-       scmirroring_debug("codec: %d", *codec);
-       scmirroring_debug_fleave();
 
-       return ret;
+       return _scmirroring_sink_get_negotiated_audio_codec(handle->mm_handle, codec);
 }
 
 int scmirroring_primary_sink_get_negotiated_audio_channel(scmirroring_primary_sink_h scmirroring_primary_sink, int *channel)
 {
-       int ret = SCMIRRORING_ERROR_NONE;
-
        scmirroring_primary_sink_s *handle = (scmirroring_primary_sink_s *)scmirroring_primary_sink;
-       scmirroring_debug_fenter();
 
        scmirroring_retvm_if(!__is_valid_handle(handle), SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring_primary_sink is invalid");
-       scmirroring_retvm_if(channel == NULL, SCMIRRORING_ERROR_INVALID_PARAMETER, "channel is NULL");
-
-       *channel = 0;
 
-       ret = mm_wfd_sink_get_negotiated_audio_channel(handle->mm_handle, channel);
-       ret = _scmirroring_error_convert(__func__, ret);
-       if (ret != SCMIRRORING_ERROR_NONE)
-               return ret;
-
-       scmirroring_debug("channel: %d", *channel);
-       scmirroring_debug_fleave();
-
-       return ret;
+       return _scmirroring_sink_get_negotiated_audio_channel(handle->mm_handle, channel);
 }
 
 int scmirroring_primary_sink_get_negotiated_audio_sample_rate(scmirroring_primary_sink_h scmirroring_primary_sink, int *sample_rate)
 {
-       int ret = SCMIRRORING_ERROR_NONE;
-
        scmirroring_primary_sink_s *handle = (scmirroring_primary_sink_s *)scmirroring_primary_sink;
-       scmirroring_debug_fenter();
 
        scmirroring_retvm_if(!__is_valid_handle(handle), SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring_primary_sink is invalid");
-       scmirroring_retvm_if(sample_rate == NULL, SCMIRRORING_ERROR_INVALID_PARAMETER, "sample_rate is NULL");
-
-       *sample_rate = 0;
-
-       ret = mm_wfd_sink_get_negotiated_audio_sample_rate(handle->mm_handle, sample_rate);
-       ret = _scmirroring_error_convert(__func__, ret);
-       if (ret != SCMIRRORING_ERROR_NONE)
-               return ret;
 
-       scmirroring_debug("sample rate: %d", *sample_rate);
-       scmirroring_debug_fleave();
-
-       return ret;
+       return _scmirroring_sink_get_negotiated_audio_sample_rate(handle->mm_handle, sample_rate);
 }
 
 int scmirroring_primary_sink_get_negotiated_audio_bitwidth(scmirroring_primary_sink_h scmirroring_primary_sink, int *bitwidth)
 {
-       int ret = SCMIRRORING_ERROR_NONE;
-
        scmirroring_primary_sink_s *handle = (scmirroring_primary_sink_s *)scmirroring_primary_sink;
-       scmirroring_debug_fenter();
 
        scmirroring_retvm_if(!__is_valid_handle(handle), SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring_primary_sink is invalid");
-       scmirroring_retvm_if(bitwidth == NULL, SCMIRRORING_ERROR_INVALID_PARAMETER, "bitwidth is NULL");
 
-       *bitwidth = 0;
-
-       ret = mm_wfd_sink_get_negotiated_audio_bitwidth(handle->mm_handle, bitwidth);
-       ret = _scmirroring_error_convert(__func__, ret);
-       if (ret != SCMIRRORING_ERROR_NONE)
-               return ret;
-
-       scmirroring_debug("bitwidth: %d", *bitwidth);
-       scmirroring_debug_fleave();
-
-       return ret;
+       return _scmirroring_sink_get_negotiated_audio_bitwidth(handle->mm_handle, bitwidth);
 }
 
 int scmirroring_primary_sink_get_current_state(scmirroring_primary_sink_h scmirroring_primary_sink, scmirroring_sink_state_e *state)
 {
-       int result = MM_ERROR_NONE;
-       int mm_state = MM_WFD_SINK_STATE_NONE;
        scmirroring_primary_sink_s *handle = (scmirroring_primary_sink_s *)(scmirroring_primary_sink);
 
-       scmirroring_debug_fenter();
        scmirroring_retvm_if(!__is_valid_handle(handle), SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring_primary_sink is invalid");
-       scmirroring_retvm_if(state == NULL, SCMIRRORING_ERROR_INVALID_PARAMETER, "state is NULL");
-
 
-       result = mm_wfd_sink_get_current_state(handle->mm_handle, &mm_state);
-       if (result == MM_ERROR_NONE) {
-               *state = _scmirroring_sink_state_convert(mm_state);
-               scmirroring_debug("ScreenMirroring current state is [%d]", *state);
-       }
-       scmirroring_debug_fleave();
-       return _scmirroring_error_convert(__func__, result);
+       return _scmirroring_sink_get_current_state(handle->mm_handle, state);
 }
 
 int scmirroring_primary_sink_set_coupled_sink(scmirroring_primary_sink_h scmirroring_primary_sink, gchar* address)

diff --git a/src/scmirroring_secondary_sink.c b/src/scmirroring_secondary_sink.c
index 6c3826f09b937775f5330ac3782ca3904f7e6cd9..8a2f260fdda149763e429883e2667cda00f42682 100755 (executable)
--- a/src/scmirroring_secondary_sink.c
+++ b/src/scmirroring_secondary_sink.c
@@ -229,129 +229,47 @@ int scmirroring_secondary_sink_resume(scmirroring_secondary_sink_h scmirroring_s
 
 int scmirroring_secondary_sink_get_negotiated_audio_codec(scmirroring_secondary_sink_h scmirroring_secondary_sink, scmirroring_audio_codec_e *codec)
 {
-       int ret = SCMIRRORING_ERROR_NONE;
-       int mm_codec = MM_WFD_SINK_AUDIO_CODEC_NONE;
-
        scmirroring_secondary_sink_s *handle = (scmirroring_secondary_sink_s*)scmirroring_secondary_sink;
-       scmirroring_debug_fenter();
 
        scmirroring_retvm_if(!__is_valid_handle(handle), SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring_secondary_sink is invalid");
-       scmirroring_retvm_if(codec == NULL, SCMIRRORING_ERROR_INVALID_PARAMETER, "codec is NULL");
-
-       *codec = SCMIRRORING_AUDIO_CODEC_NONE;
-
-       ret = mm_wfd_sink_get_negotiated_audio_codec(handle->mm_handle, &mm_codec);
-       ret = _scmirroring_error_convert(__func__, ret);
-       if (ret != SCMIRRORING_ERROR_NONE)
-               return ret;
-
-       switch (mm_codec) {
-       case MM_WFD_SINK_AUDIO_CODEC_AAC:
-               *codec = SCMIRRORING_AUDIO_CODEC_AAC;
-               break;
-       case MM_WFD_SINK_AUDIO_CODEC_AC3:
-               *codec = SCMIRRORING_AUDIO_CODEC_AC3;
-               break;
-       case MM_WFD_SINK_AUDIO_CODEC_LPCM:
-               *codec = SCMIRRORING_AUDIO_CODEC_LPCM;
-               break;
-       default:
-               *codec = SCMIRRORING_AUDIO_CODEC_NONE;
-               break;
-       }
 
-       scmirroring_debug("codec: %d", *codec);
-       scmirroring_debug_fleave();
-
-       return ret;
+       return _scmirroring_sink_get_negotiated_audio_codec(handle->mm_handle, codec);
 }
 
 int scmirroring_secondary_sink_get_negotiated_audio_channel(scmirroring_secondary_sink_h scmirroring_secondary_sink, int *channel)
 {
-       int ret = SCMIRRORING_ERROR_NONE;
-
        scmirroring_secondary_sink_s *handle = (scmirroring_secondary_sink_s*)scmirroring_secondary_sink;
-       scmirroring_debug_fenter();
 
        scmirroring_retvm_if(!__is_valid_handle(handle), SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring_secondary_sink is invalid");
-       scmirroring_retvm_if(channel == NULL, SCMIRRORING_ERROR_INVALID_PARAMETER, "channel is NULL");
-
-       *channel = 0;
-
-       ret = mm_wfd_sink_get_negotiated_audio_channel(handle->mm_handle, channel);
-       ret = _scmirroring_error_convert(__func__, ret);
-       if (ret != SCMIRRORING_ERROR_NONE)
-               return ret;
-
-       scmirroring_debug("channel: %d", *channel);
-       scmirroring_debug_fleave();
 
-       return ret;
+       return _scmirroring_sink_get_negotiated_audio_channel(handle->mm_handle, channel);
 }
 
 int scmirroring_secondary_sink_get_negotiated_audio_sample_rate(scmirroring_secondary_sink_h scmirroring_secondary_sink, int *sample_rate)
 {
-       int ret = SCMIRRORING_ERROR_NONE;
-
        scmirroring_secondary_sink_s *handle = (scmirroring_secondary_sink_s*)scmirroring_secondary_sink;
-       scmirroring_debug_fenter();
 
        scmirroring_retvm_if(!__is_valid_handle(handle), SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring_secondary_sink is invalid");
-       scmirroring_retvm_if(sample_rate == NULL, SCMIRRORING_ERROR_INVALID_PARAMETER, "sample_rate is NULL");
-
-       *sample_rate = 0;
-
-       ret = mm_wfd_sink_get_negotiated_audio_sample_rate(handle->mm_handle, sample_rate);
-       ret = _scmirroring_error_convert(__func__, ret);
-       if (ret != SCMIRRORING_ERROR_NONE)
-               return ret;
 
-       scmirroring_debug("sample rate: %d", *sample_rate);
-       scmirroring_debug_fleave();
-
-       return ret;
+       return _scmirroring_sink_get_negotiated_audio_sample_rate(handle->mm_handle, sample_rate);
 }
 
 int scmirroring_secondary_sink_get_negotiated_audio_bitwidth(scmirroring_secondary_sink_h scmirroring_secondary_sink, int *bitwidth)
 {
-       int ret = SCMIRRORING_ERROR_NONE;
-
        scmirroring_secondary_sink_s *handle = (scmirroring_secondary_sink_s*)scmirroring_secondary_sink;
-       scmirroring_debug_fenter();
 
        scmirroring_retvm_if(!__is_valid_handle(handle), SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring_secondary_sink is invalid");
-       scmirroring_retvm_if(bitwidth == NULL, SCMIRRORING_ERROR_INVALID_PARAMETER, "bitwidth is NULL");
-
-       *bitwidth = 0;
-
-       ret = mm_wfd_sink_get_negotiated_audio_bitwidth(handle->mm_handle, bitwidth);
-       ret = _scmirroring_error_convert(__func__, ret);
-       if (ret != SCMIRRORING_ERROR_NONE)
-               return ret;
-
-       scmirroring_debug("bitwidth: %d", *bitwidth);
-       scmirroring_debug_fleave();
 
-       return ret;
+       return _scmirroring_sink_get_negotiated_audio_bitwidth(handle->mm_handle, bitwidth);
 }
 
 int scmirroring_secondary_sink_get_current_state(scmirroring_secondary_sink_h scmirroring_secondary_sink, scmirroring_sink_state_e *state)
 {
-       int result = MM_ERROR_NONE;
-       int mm_state = MM_WFD_SINK_STATE_NONE;
        scmirroring_secondary_sink_s *handle = (scmirroring_secondary_sink_s *)(scmirroring_secondary_sink);
 
-       scmirroring_debug_fenter();
        scmirroring_retvm_if(!__is_valid_handle(handle), SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring_secondary_sink is invalid");
-       scmirroring_retvm_if(state == NULL, SCMIRRORING_ERROR_INVALID_PARAMETER, "state is NULL");
 
-       result = mm_wfd_sink_get_current_state(handle->mm_handle, &mm_state);
-       if (result == MM_ERROR_NONE) {
-               *state = _scmirroring_sink_state_convert(mm_state);
-               scmirroring_debug("ScreenMirroring current state is [%d]", *state);
-       }
-       scmirroring_debug_fleave();
-       return _scmirroring_error_convert(__func__, result);
+       return _scmirroring_sink_get_current_state(handle->mm_handle, state);
 }
 
 int scmirroring_secondary_sink_set_coupled_sink(scmirroring_secondary_sink_h scmirroring_secondary_sink, gchar* address)

diff --git a/src/scmirroring_sink.c b/src/scmirroring_sink.c
index c6e3f427abbb92da9c217ff08f7b98696b7ea7dd..681f8d57fbe978ddbd0cdf5faf4ba546ff7301df 100644 (file)
--- a/src/scmirroring_sink.c
+++ b/src/scmirroring_sink.c
@@ -247,229 +247,93 @@ int scmirroring_sink_resume(scmirroring_sink_h scmirroring_sink)
 
 int scmirroring_sink_get_negotiated_video_codec(scmirroring_sink_h *scmirroring_sink, scmirroring_video_codec_e *codec)
 {
-       int ret = SCMIRRORING_ERROR_NONE;
-       int mm_codec = MM_WFD_SINK_VIDEO_CODEC_NONE;
-
        scmirroring_sink_s *handle = NULL;
-       scmirroring_debug_fenter();
 
        scmirroring_retvm_if(scmirroring_sink == NULL, SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring_sink* is NULL");
-       scmirroring_retvm_if(codec == NULL, SCMIRRORING_ERROR_INVALID_PARAMETER, "codec is NULL");
 
        handle = (scmirroring_sink_s *)(*scmirroring_sink);
        scmirroring_retvm_if(!__is_valid_handle(handle), SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring_sink is invalid");
 
-       *codec = SCMIRRORING_VIDEO_CODEC_NONE;
-
-       ret = mm_wfd_sink_get_negotiated_video_codec(handle->mm_handle, &mm_codec);
-       ret = _scmirroring_error_convert(__func__, ret);
-       if (ret != SCMIRRORING_ERROR_NONE)
-               return ret;
-
-       switch (mm_codec) {
-       case MM_WFD_SINK_VIDEO_CODEC_H264:
-               *codec = SCMIRRORING_VIDEO_CODEC_H264;
-               break;
-       default:
-               *codec = SCMIRRORING_VIDEO_CODEC_NONE;
-               break;
-       }
-
-       scmirroring_debug("codec: %d", *codec);
-       scmirroring_debug_fleave();
-
-       return ret;
+       return _scmirroring_sink_get_negotiated_video_codec(handle->mm_handle, codec);
 }
 
 int scmirroring_sink_get_negotiated_video_resolution(scmirroring_sink_h *scmirroring_sink, int *width, int *height)
 {
-       int ret = SCMIRRORING_ERROR_NONE;
-
        scmirroring_sink_s *handle = NULL;
-       scmirroring_debug_fenter();
 
        scmirroring_retvm_if(scmirroring_sink == NULL, SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring_sink* is NULL");
-       scmirroring_retvm_if(width == NULL, SCMIRRORING_ERROR_INVALID_PARAMETER, "width is NULL");
-       scmirroring_retvm_if(height == NULL, SCMIRRORING_ERROR_INVALID_PARAMETER, "height is NULL");
 
        handle = (scmirroring_sink_s *)(*scmirroring_sink);
        scmirroring_retvm_if(!__is_valid_handle(handle), SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring_sink is invalid");
 
-       *width = 0;
-       *height = 0;
-
-       ret = mm_wfd_sink_get_negotiated_video_resolution(handle->mm_handle, width, height);
-       ret = _scmirroring_error_convert(__func__, ret);
-       if (ret != SCMIRRORING_ERROR_NONE)
-               return ret;
-
-       scmirroring_debug("width: %d, height: %d", *width, *height);
-       scmirroring_debug_fleave();
-
-       return ret;
+       return _scmirroring_sink_get_negotiated_video_resolution(handle->mm_handle, width, height);
 }
 
 int scmirroring_sink_get_negotiated_video_frame_rate(scmirroring_sink_h *scmirroring_sink, int *frame_rate)
 {
-       int ret = SCMIRRORING_ERROR_NONE;
-
        scmirroring_sink_s *handle = NULL;
-       scmirroring_debug_fenter();
 
        scmirroring_retvm_if(scmirroring_sink == NULL, SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring_sink* is NULL");
-       scmirroring_retvm_if(frame_rate == NULL, SCMIRRORING_ERROR_INVALID_PARAMETER, "frame_rate is NULL");
 
        handle = (scmirroring_sink_s *)(*scmirroring_sink);
        scmirroring_retvm_if(!__is_valid_handle(handle), SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring_sink is invalid");
 
-       *frame_rate = 0;
-
-       ret = mm_wfd_sink_get_negotiated_video_frame_rate(handle->mm_handle, frame_rate);
-       ret = _scmirroring_error_convert(__func__, ret);
-       if (ret != SCMIRRORING_ERROR_NONE)
-               return ret;
-
-       scmirroring_debug("frame rate: %d", *frame_rate);
-       scmirroring_debug_fleave();
-
-       return ret;
+       return _scmirroring_sink_get_negotiated_video_frame_rate(handle->mm_handle, frame_rate);
 }
 
 int scmirroring_sink_get_negotiated_audio_codec(scmirroring_sink_h *scmirroring_sink, scmirroring_audio_codec_e *codec)
 {
-       int ret = SCMIRRORING_ERROR_NONE;
-       int mm_codec = MM_WFD_SINK_AUDIO_CODEC_NONE;
-
        scmirroring_sink_s *handle = NULL;
-       scmirroring_debug_fenter();
 
        scmirroring_retvm_if(scmirroring_sink == NULL, SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring_sink* is NULL");
-       scmirroring_retvm_if(codec == NULL, SCMIRRORING_ERROR_INVALID_PARAMETER, "codec is NULL");
 
        handle = (scmirroring_sink_s *)(*scmirroring_sink);
        scmirroring_retvm_if(!__is_valid_handle(handle), SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring_sink is invalid");
 
-       *codec = SCMIRRORING_AUDIO_CODEC_NONE;
-
-       ret = mm_wfd_sink_get_negotiated_audio_codec(handle->mm_handle, &mm_codec);
-       ret = _scmirroring_error_convert(__func__, ret);
-       if (ret != SCMIRRORING_ERROR_NONE)
-               return ret;
-
-       switch (mm_codec) {
-       case MM_WFD_SINK_AUDIO_CODEC_AAC:
-               *codec = SCMIRRORING_AUDIO_CODEC_AAC;
-               break;
-       case MM_WFD_SINK_AUDIO_CODEC_AC3:
-               *codec = SCMIRRORING_AUDIO_CODEC_AC3;
-               break;
-       case MM_WFD_SINK_AUDIO_CODEC_LPCM:
-               *codec = SCMIRRORING_AUDIO_CODEC_LPCM;
-               break;
-       default:
-               *codec = SCMIRRORING_AUDIO_CODEC_NONE;
-               break;
-       }
-
-       scmirroring_debug("codec: %d", *codec);
-       scmirroring_debug_fleave();
-
-       return ret;
+       return _scmirroring_sink_get_negotiated_audio_codec(handle->mm_handle, codec);
 }
 
 int scmirroring_sink_get_negotiated_audio_channel(scmirroring_sink_h *scmirroring_sink, int *channel)
 {
-       int ret = SCMIRRORING_ERROR_NONE;
-
        scmirroring_sink_s *handle = NULL;
-       scmirroring_debug_fenter();
 
        scmirroring_retvm_if(scmirroring_sink == NULL, SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring_sink* is NULL");
-       scmirroring_retvm_if(channel == NULL, SCMIRRORING_ERROR_INVALID_PARAMETER, "channel is NULL");
 
        handle = (scmirroring_sink_s *)(*scmirroring_sink);
        scmirroring_retvm_if(!__is_valid_handle(handle), SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring_sink is invalid");
 
-       *channel = 0;
-
-       ret = mm_wfd_sink_get_negotiated_audio_channel(handle->mm_handle, channel);
-       ret = _scmirroring_error_convert(__func__, ret);
-       if (ret != SCMIRRORING_ERROR_NONE)
-               return ret;
-
-       scmirroring_debug("channel: %d", *channel);
-       scmirroring_debug_fleave();
-
-       return ret;
+       return _scmirroring_sink_get_negotiated_audio_channel(handle->mm_handle, channel);
 }
 
 int scmirroring_sink_get_negotiated_audio_sample_rate(scmirroring_sink_h *scmirroring_sink, int *sample_rate)
 {
-       int ret = SCMIRRORING_ERROR_NONE;
-
        scmirroring_sink_s *handle = NULL;
-       scmirroring_debug_fenter();
 
        scmirroring_retvm_if(scmirroring_sink == NULL, SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring_sink* is NULL");
-       scmirroring_retvm_if(sample_rate == NULL, SCMIRRORING_ERROR_INVALID_PARAMETER, "sample_rate is NULL");
 
        handle = (scmirroring_sink_s *)(*scmirroring_sink);
        scmirroring_retvm_if(!__is_valid_handle(handle), SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring_sink is invalid");
 
-       *sample_rate = 0;
-
-       ret = mm_wfd_sink_get_negotiated_audio_sample_rate(handle->mm_handle, sample_rate);
-       ret = _scmirroring_error_convert(__func__, ret);
-       if (ret != SCMIRRORING_ERROR_NONE)
-               return ret;
-
-       scmirroring_debug("sample rate: %d", *sample_rate);
-       scmirroring_debug_fleave();
-
-       return ret;
+       return _scmirroring_sink_get_negotiated_audio_sample_rate(handle->mm_handle, sample_rate);
 }
 
 int scmirroring_sink_get_negotiated_audio_bitwidth(scmirroring_sink_h *scmirroring_sink, int *bitwidth)
 {
-       int ret = SCMIRRORING_ERROR_NONE;
-
        scmirroring_sink_s *handle = NULL;
-       scmirroring_debug_fenter();
 
        scmirroring_retvm_if(scmirroring_sink == NULL, SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring_sink* is NULL");
-       scmirroring_retvm_if(bitwidth == NULL, SCMIRRORING_ERROR_INVALID_PARAMETER, "bitwidth is NULL");
 
        handle = (scmirroring_sink_s *)(*scmirroring_sink);
        scmirroring_retvm_if(!__is_valid_handle(handle), SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring_sink is invalid");
 
-       *bitwidth = 0;
-
-       ret = mm_wfd_sink_get_negotiated_audio_bitwidth(handle->mm_handle, bitwidth);
-       ret = _scmirroring_error_convert(__func__, ret);
-       if (ret != SCMIRRORING_ERROR_NONE)
-               return ret;
-
-       scmirroring_debug("bitwidth: %d", *bitwidth);
-       scmirroring_debug_fleave();
-
-       return ret;
+       return _scmirroring_sink_get_negotiated_audio_bitwidth(handle->mm_handle, bitwidth);
 }
 
 int scmirroring_sink_get_current_state(scmirroring_sink_h scmirroring_sink, scmirroring_sink_state_e *state)
 {
-       int result = MM_ERROR_NONE;
-       int mm_state = MM_WFD_SINK_STATE_NONE;
        scmirroring_sink_s *handle = (scmirroring_sink_s *)(scmirroring_sink);
 
-       scmirroring_debug_fenter();
-       scmirroring_retvm_if(scmirroring_sink == NULL, SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring_sink* is NULL");
        scmirroring_retvm_if(!__is_valid_handle(handle), SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring_sink is invalid");
 
-       result = mm_wfd_sink_get_current_state(handle->mm_handle, &mm_state);
-       if (result == MM_ERROR_NONE) {
-               *state = _scmirroring_sink_state_convert(mm_state);
-               scmirroring_debug("ScreenMirroring current state is [%d]", *state);
-       }
-       scmirroring_debug_fleave();
-       return _scmirroring_error_convert(__func__, result);
+       return _scmirroring_sink_get_current_state(handle->mm_handle, state);
 }

diff --git a/src/scmirroring_util.c b/src/scmirroring_util.c
index 907af488977a877d34f23c8ff66deb531594dacd..75f2a0f95c52d2377e3d88291478a932c15a57cb 100644 (file)
--- a/src/scmirroring_util.c
+++ b/src/scmirroring_util.c
@@ -221,3 +221,169 @@ int _scmirroring_sink_set_resolution(MMHandleType handle, int resolution)
 
        return _scmirroring_error_convert(__func__, ret);
 }
+
+int _scmirroring_sink_get_negotiated_video_codec(MMHandleType handle, scmirroring_video_codec_e *codec)
+{
+       int ret = SCMIRRORING_ERROR_NONE;
+       int mm_codec = MM_WFD_SINK_VIDEO_CODEC_NONE;
+
+       scmirroring_debug_fenter();
+
+       scmirroring_retvm_if(!codec, SCMIRRORING_ERROR_INVALID_PARAMETER, "codec is NULL");
+
+       ret = mm_wfd_sink_get_negotiated_video_codec(handle, &mm_codec);
+       if (ret != MM_ERROR_NONE)
+               return _scmirroring_error_convert(__func__, ret);
+
+       switch (mm_codec) {
+       case MM_WFD_SINK_VIDEO_CODEC_H264:
+               *codec = SCMIRRORING_VIDEO_CODEC_H264;
+               break;
+       default:
+               *codec = SCMIRRORING_VIDEO_CODEC_NONE;
+               break;
+       }
+
+       scmirroring_debug("video codec: %d", *codec);
+
+       return SCMIRRORING_ERROR_NONE;
+}
+
+int _scmirroring_sink_get_negotiated_video_resolution(MMHandleType handle, int *width, int *height)
+{
+       int ret = SCMIRRORING_ERROR_NONE;
+
+       scmirroring_debug_fenter();
+
+       scmirroring_retvm_if(!width, SCMIRRORING_ERROR_INVALID_PARAMETER, "width is NULL");
+       scmirroring_retvm_if(!height, SCMIRRORING_ERROR_INVALID_PARAMETER, "height is NULL");
+
+       ret = mm_wfd_sink_get_negotiated_video_resolution(handle, width, height);
+       if (ret != MM_ERROR_NONE)
+               return _scmirroring_error_convert(__func__, ret);
+
+       scmirroring_debug("width: %d, height: %d", *width, *height);
+
+       return SCMIRRORING_ERROR_NONE;
+}
+
+int _scmirroring_sink_get_negotiated_video_frame_rate(MMHandleType handle, int *frame_rate)
+{
+       int ret = SCMIRRORING_ERROR_NONE;
+
+       scmirroring_debug_fenter();
+
+       scmirroring_retvm_if(!frame_rate, SCMIRRORING_ERROR_INVALID_PARAMETER, "frame_rate is NULL");
+
+       ret = mm_wfd_sink_get_negotiated_video_frame_rate(handle, frame_rate);
+       if (ret != MM_ERROR_NONE)
+               return _scmirroring_error_convert(__func__, ret);
+
+       scmirroring_debug("frame rate: %d", *frame_rate);
+
+       return SCMIRRORING_ERROR_NONE;
+}
+
+int _scmirroring_sink_get_negotiated_audio_codec(MMHandleType handle, scmirroring_audio_codec_e *codec)
+{
+       int ret = SCMIRRORING_ERROR_NONE;
+       int mm_codec = MM_WFD_SINK_AUDIO_CODEC_NONE;
+
+       scmirroring_debug_fenter();
+
+       scmirroring_retvm_if(!codec, SCMIRRORING_ERROR_INVALID_PARAMETER, "codec is NULL");
+
+       ret = mm_wfd_sink_get_negotiated_audio_codec(handle, &mm_codec);
+       if (ret != MM_ERROR_NONE)
+               return _scmirroring_error_convert(__func__, ret);
+
+       switch (mm_codec) {
+       case MM_WFD_SINK_AUDIO_CODEC_AAC:
+               *codec = SCMIRRORING_AUDIO_CODEC_AAC;
+               break;
+       case MM_WFD_SINK_AUDIO_CODEC_AC3:
+               *codec = SCMIRRORING_AUDIO_CODEC_AC3;
+               break;
+       case MM_WFD_SINK_AUDIO_CODEC_LPCM:
+               *codec = SCMIRRORING_AUDIO_CODEC_LPCM;
+               break;
+       default:
+               *codec = SCMIRRORING_AUDIO_CODEC_NONE;
+               break;
+       }
+
+       scmirroring_debug("audio codec: %d", *codec);
+
+       return SCMIRRORING_ERROR_NONE;
+}
+
+int _scmirroring_sink_get_negotiated_audio_channel(MMHandleType handle, int *channel)
+{
+       int ret = SCMIRRORING_ERROR_NONE;
+
+       scmirroring_debug_fenter();
+
+       scmirroring_retvm_if(!channel, SCMIRRORING_ERROR_INVALID_PARAMETER, "channel is NULL");
+
+       ret = mm_wfd_sink_get_negotiated_audio_channel(handle, channel);
+       if (ret != MM_ERROR_NONE)
+               return _scmirroring_error_convert(__func__, ret);
+
+       scmirroring_debug("channel: %d", *channel);
+
+       return SCMIRRORING_ERROR_NONE;
+}
+
+int _scmirroring_sink_get_negotiated_audio_sample_rate(MMHandleType handle, int *sample_rate)
+{
+       int ret = SCMIRRORING_ERROR_NONE;
+
+       scmirroring_debug_fenter();
+
+       scmirroring_retvm_if(!sample_rate, SCMIRRORING_ERROR_INVALID_PARAMETER, "sample_rate is NULL");
+
+       ret = mm_wfd_sink_get_negotiated_audio_sample_rate(handle, sample_rate);
+       if (ret != MM_ERROR_NONE)
+               return _scmirroring_error_convert(__func__, ret);
+
+       scmirroring_debug("sample rate: %d", *sample_rate);
+
+       return SCMIRRORING_ERROR_NONE;
+}
+
+int _scmirroring_sink_get_negotiated_audio_bitwidth(MMHandleType handle, int *bitwidth)
+{
+       int ret = SCMIRRORING_ERROR_NONE;
+
+       scmirroring_debug_fenter();
+
+       scmirroring_retvm_if(!bitwidth, SCMIRRORING_ERROR_INVALID_PARAMETER, "bitwidth is NULL");
+
+       ret = mm_wfd_sink_get_negotiated_audio_bitwidth(handle, bitwidth);
+       if (ret != MM_ERROR_NONE)
+               return _scmirroring_error_convert(__func__, ret);
+
+       scmirroring_debug("bitwidth: %d", *bitwidth);
+
+       return SCMIRRORING_ERROR_NONE;
+}
+
+int _scmirroring_sink_get_current_state(MMHandleType handle, scmirroring_sink_state_e *state)
+{
+       int ret = SCMIRRORING_ERROR_NONE;
+       int mm_state = MM_WFD_SINK_STATE_NONE;
+
+       scmirroring_debug_fenter();
+
+       scmirroring_retvm_if(!state, SCMIRRORING_ERROR_INVALID_PARAMETER, "state is NULL");
+
+       ret =  mm_wfd_sink_get_current_state(handle, &mm_state);
+       if (ret != MM_ERROR_NONE)
+               return _scmirroring_error_convert(__func__, ret);
+
+       *state = _scmirroring_sink_state_convert(mm_state);
+
+       scmirroring_debug("ScreenMirroring current state is [%d]", *state);
+
+       return SCMIRRORING_ERROR_NONE;
+}