sink/mm_wfd_sink.c

   1 /*
   2  * libmm-wfd
   3  *
   4  * Copyright (c) 2011 - 2013 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: JongHyuk Choi <jhchoi.choi@samsung.com>, ByungWook Jang <bw.jang@samsung.com>,
   7  * Maksym Ukhanov <m.ukhanov@samsung.com>, Hyunjun Ko <zzoon.ko@samsung.com>
   8  *
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  * http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  */
  22
  23 #include <gst/gst.h>
  24
  25 #include "mm_wfd_sink_util.h"
  26 #include "mm_wfd_sink.h"
  27 #include "mm_wfd_sink_priv.h"
  28 #include "mm_wfd_sink_dlog.h"
  29
  30 int mm_wfd_sink_create(MMHandleType *wfd_sink)
  31 {
  32         mm_wfd_sink_t *new_wfd_sink = NULL;
  33         int result = MM_ERROR_NONE;
  34
  35         wfd_sink_debug_fenter();
  36
  37         wfd_sink_return_val_if_fail(wfd_sink, MM_ERROR_WFD_NOT_INITIALIZED);
  38
  39         result = _mm_wfd_sink_create(&new_wfd_sink);
  40         if (result != MM_ERROR_NONE)
  41         {
  42                 wfd_sink_error("fail to create wi-fi display sink handle. ret[%d]", result);
  43                 *wfd_sink = (MMHandleType)NULL;
  44                 return result;
  45         }
  46
  47         /* init wfd lock */
  48         g_mutex_init(&new_wfd_sink->cmd_lock);
  49
  50         *wfd_sink = (MMHandleType)new_wfd_sink;
  51
  52         wfd_sink_debug_fleave();
  53
  54         return result;
  55
  56 }
  57
  58 int mm_wfd_sink_prepare(MMHandleType wfd_sink)
  59 {
  60         int result = MM_ERROR_NONE;
  61
  62         wfd_sink_return_val_if_fail (wfd_sink, MM_ERROR_WFD_NOT_INITIALIZED);
  63
  64         MMWFDSINK_CMD_LOCK(wfd_sink);
  65         result = _mm_wfd_sink_prepare((mm_wfd_sink_t *)wfd_sink);
  66         MMWFDSINK_CMD_UNLOCK(wfd_sink);
  67
  68         return result;
  69 }
  70
  71 int mm_wfd_sink_connect(MMHandleType wfd_sink, const char *uri)
  72 {
  73         int result = MM_ERROR_NONE;
  74
  75         wfd_sink_return_val_if_fail (wfd_sink, MM_ERROR_WFD_NOT_INITIALIZED);
  76         wfd_sink_return_val_if_fail (uri, MM_ERROR_WFD_INVALID_ARGUMENT);
  77
  78         MMWFDSINK_CMD_LOCK(wfd_sink);
  79         result = _mm_wfd_sink_connect((mm_wfd_sink_t *)wfd_sink, uri);
  80         MMWFDSINK_CMD_UNLOCK(wfd_sink);
  81
  82         return result;
  83 }
  84
  85 int mm_wfd_sink_start(MMHandleType wfd_sink)
  86 {
  87         int result = MM_ERROR_NONE;
  88
  89         wfd_sink_return_val_if_fail(wfd_sink, MM_ERROR_WFD_NOT_INITIALIZED);
  90
  91         MMWFDSINK_CMD_LOCK(wfd_sink);
  92         result = _mm_wfd_sink_start((mm_wfd_sink_t *)wfd_sink);
  93         MMWFDSINK_CMD_UNLOCK(wfd_sink);
  94
  95         return result;
  96 }
  97
  98 int mm_wfd_sink_disconnect(MMHandleType wfd_sink)
  99 {
 100         int result = MM_ERROR_NONE;
 101
 102         wfd_sink_return_val_if_fail(wfd_sink, MM_ERROR_WFD_NOT_INITIALIZED);
 103
 104         MMWFDSINK_CMD_LOCK(wfd_sink);
 105         result = _mm_wfd_sink_disconnect((mm_wfd_sink_t *)wfd_sink);
 106         MMWFDSINK_CMD_UNLOCK(wfd_sink);
 107
 108         return result;
 109 }
 110
 111 int mm_wfd_sink_unprepare(MMHandleType wfd_sink)
 112 {
 113         int result = MM_ERROR_NONE;
 114
 115         wfd_sink_return_val_if_fail (wfd_sink, MM_ERROR_WFD_NOT_INITIALIZED);
 116
 117         MMWFDSINK_CMD_LOCK(wfd_sink);
 118         result = _mm_wfd_sink_unprepare((mm_wfd_sink_t *)wfd_sink);
 119         MMWFDSINK_CMD_UNLOCK(wfd_sink);
 120
 121         return result;
 122 }
 123
 124 int mm_wfd_sink_destroy(MMHandleType wfd_sink)
 125 {
 126         int result = MM_ERROR_NONE;
 127         mm_wfd_sink_t * sink_handle = NULL;
 128
 129         wfd_sink_return_val_if_fail(wfd_sink, MM_ERROR_WFD_NOT_INITIALIZED);
 130
 131         MMWFDSINK_CMD_LOCK(wfd_sink);
 132         result = _mm_wfd_sink_destroy((mm_wfd_sink_t *)wfd_sink);
 133         MMWFDSINK_CMD_UNLOCK(wfd_sink);
 134
 135         g_mutex_clear(&(((mm_wfd_sink_t *)wfd_sink)->cmd_lock));
 136
 137         sink_handle = (mm_wfd_sink_t *)wfd_sink;
 138         MMWFDSINK_FREEIF(sink_handle);
 139
 140         return result;
 141 }
 142
 143 int mm_wfd_sink_set_message_callback(MMHandleType wfd_sink, MMWFDMessageCallback callback, void *user_data)
 144 {
 145         int result = MM_ERROR_NONE;
 146
 147         wfd_sink_return_val_if_fail(wfd_sink, MM_ERROR_WFD_NOT_INITIALIZED);
 148
 149         MMWFDSINK_CMD_LOCK(wfd_sink);
 150         result = _mm_wfd_set_message_callback((mm_wfd_sink_t *)wfd_sink, callback, user_data);
 151         MMWFDSINK_CMD_UNLOCK(wfd_sink);
 152
 153         return result;
 154 }
 155
 156 int mm_wfd_sink_set_attribute(MMHandleType wfd_sink,  char **err_attr_name, const char *first_attribute_name, ...)
 157 {
 158         int result = MM_ERROR_NONE;
 159         va_list var_args;
 160
 161         wfd_sink_return_val_if_fail(wfd_sink, MM_ERROR_WFD_NOT_INITIALIZED);
 162         wfd_sink_return_val_if_fail(first_attribute_name, MM_ERROR_WFD_INVALID_ARGUMENT);
 163
 164         MMWFDSINK_CMD_LOCK(wfd_sink);
 165         va_start (var_args, first_attribute_name);
 166         result = _mmwfd_set_attribute(MMWFDSINK_GET_ATTRS(wfd_sink), err_attr_name, first_attribute_name, var_args);
 167         va_end (var_args);
 168         MMWFDSINK_CMD_UNLOCK(wfd_sink);
 169
 170         return result;
 171 }
 172
 173 int mm_wfd_sink_get_video_resolution(MMHandleType wfd_sink, gint *width, gint *height)
 174 {
 175         mm_wfd_sink_t *wfd = (mm_wfd_sink_t *)wfd_sink;
 176
 177         wfd_sink_return_val_if_fail(wfd, MM_ERROR_WFD_NOT_INITIALIZED);
 178         wfd_sink_return_val_if_fail(width, MM_ERROR_WFD_INVALID_ARGUMENT);
 179         wfd_sink_return_val_if_fail(height, MM_ERROR_WFD_INVALID_ARGUMENT);
 180
 181         *width = wfd->stream_info.video_stream_info.width;
 182         *height =wfd->stream_info.video_stream_info.height;
 183
 184         return MM_ERROR_NONE;
 185 }
 186
 187 int mm_wfd_sink_get_video_framerate(MMHandleType wfd_sink, gint *frame_rate)
 188 {
 189         mm_wfd_sink_t *wfd = (mm_wfd_sink_t *)wfd_sink;
 190
 191         wfd_sink_return_val_if_fail(wfd, MM_ERROR_WFD_NOT_INITIALIZED);
 192         wfd_sink_return_val_if_fail(frame_rate, MM_ERROR_WFD_INVALID_ARGUMENT);
 193
 194         *frame_rate = wfd->stream_info.video_stream_info.frame_rate;
 195
 196         return MM_ERROR_NONE;
 197 }
 198