include/media_streamer.h

   1 /*
   2  * Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #ifndef __TIZEN_MEDIA_STREAMER_H__
  18 #define __TIZEN_MEDIA_STREAMER_H__
  19
  20 #include <tizen.h>
  21 #include <bundle.h>
  22 #include <media_format.h>
  23 #include <media_packet.h>
  24
  25 #ifdef __cplusplus
  26 extern "C" {
  27 #endif
  28
  29 /**
  30 * @file media_streamer.h
  31 * @brief This file contains the capi media streamer API.
  32 */
  33
  34 /**
  35 * @addtogroup CAPI_MEDIA_STREAMER_MODULE
  36 * @{
  37 */
  38
  39 /**
  40  * @brief Media Streamer handle type.
  41  *
  42  * @since_tizen 3.0
  43  */
  44 typedef void *media_streamer_h;
  45
  46 /**
  47  * @brief Media Streamer node handle type.
  48  *
  49  * @since_tizen 3.0
  50  */
  51 typedef void *media_streamer_node_h;
  52
  53 /**
  54  * @brief Enumeration for media streamer node type.
  55  *
  56  * @since_tizen 3.0
  57  */
  58 typedef enum {
  59         MEDIA_STREAMER_NODE_TYPE_NONE,                 /**<  Not defined type */
  60         MEDIA_STREAMER_NODE_TYPE_SRC,                  /**<  Source node type. Not available for media_streamer_node_create(). Use media_streamer_node_create_src() */
  61         MEDIA_STREAMER_NODE_TYPE_SINK,                 /**<  Sink node type. Not available for media_streamer_node_create(). Use media_streamer_node_create_sink() */
  62         MEDIA_STREAMER_NODE_TYPE_VIDEO_ENCODER,        /**<  Video encoder node type */
  63         MEDIA_STREAMER_NODE_TYPE_VIDEO_DECODER,        /**<  Video decoder node type */
  64         MEDIA_STREAMER_NODE_TYPE_AUDIO_ENCODER,        /**<  Audio encoder node type */
  65         MEDIA_STREAMER_NODE_TYPE_AUDIO_DECODER,        /**<  Audio decoder node type */
  66         MEDIA_STREAMER_NODE_TYPE_VIDEO_CONVERTER,      /**<  Video converter node type */
  67         MEDIA_STREAMER_NODE_TYPE_AUDIO_CONVERTER,      /**<  Audio converter node type */
  68         MEDIA_STREAMER_NODE_TYPE_AUDIO_RESAMPLE,       /**<  Audio resample node type */
  69         MEDIA_STREAMER_NODE_TYPE_VIDEO_PAY,            /**<  RTP video payloader */
  70         MEDIA_STREAMER_NODE_TYPE_AUDIO_PAY,            /**<  RTP audio payloader */
  71         MEDIA_STREAMER_NODE_TYPE_VIDEO_DEPAY,          /**<  RTP video depayloader */
  72         MEDIA_STREAMER_NODE_TYPE_AUDIO_DEPAY,          /**<  RTP audio depayloader */
  73         MEDIA_STREAMER_NODE_TYPE_VIDEO_RATE,           /**<  Rate node type */
  74         MEDIA_STREAMER_NODE_TYPE_VIDEO_SCALE,          /**<  Scale node type */
  75         MEDIA_STREAMER_NODE_TYPE_TEXT_OVERLAY,         /**<  Overlay node type */
  76         MEDIA_STREAMER_NODE_TYPE_PARSER,               /**<  Parser node type */
  77         MEDIA_STREAMER_NODE_TYPE_FILTER,               /**<  Filter node type, to limit formats of data */
  78         MEDIA_STREAMER_NODE_TYPE_TEE,                  /**<  Tee node type, splits data to multiple path */
  79         MEDIA_STREAMER_NODE_TYPE_QUEUE,                /**<  Queue node type */
  80         MEDIA_STREAMER_NODE_TYPE_MQUEUE,               /**<  Multiple data queue node type */
  81         MEDIA_STREAMER_NODE_TYPE_MUXER,                /**<  Muxer node type */
  82         MEDIA_STREAMER_NODE_TYPE_DEMUXER,              /**<  Demuxer node type */
  83         MEDIA_STREAMER_NODE_TYPE_RTP,                  /**<  RTP component to send and receive data */
  84         MEDIA_STREAMER_NODE_TYPE_INPUT_SELECTOR,       /**<  N-to-1 input stream selector */
  85         MEDIA_STREAMER_NODE_TYPE_OUTPUT_SELECTOR,      /**<  1-to-N output stream selector */
  86         MEDIA_STREAMER_NODE_TYPE_INTERLEAVE,           /**<  Folds many mono channel into one interleaved audio stream */
  87         MEDIA_STREAMER_NODE_TYPE_DEINTERLEAVE,         /**<  Splits multi channel audio into many mono audio */
  88         MEDIA_STREAMER_NODE_TYPE_WEBRTC                /**<  WebRTC component to send and receive data */
  89 } media_streamer_node_type_e;
  90
  91 /**
  92  * @brief Enumeration for media streamer source node type.
  93  *
  94  * @since_tizen 3.0
  95  */
  96 typedef enum {
  97         MEDIA_STREAMER_NODE_SRC_TYPE_NONE,           /**<  Not defined source type */
  98         MEDIA_STREAMER_NODE_SRC_TYPE_FILE,           /**<  Local file source type */
  99         MEDIA_STREAMER_NODE_SRC_TYPE_HTTP,           /**<  HTTP source type, Network internet feature is required */
 100         MEDIA_STREAMER_NODE_SRC_TYPE_RTSP,           /**<  RTSP source type, Network internet feature is required */
 101         MEDIA_STREAMER_NODE_SRC_TYPE_CAMERA,         /**<  Camera source type, Camera feature is required */
 102         MEDIA_STREAMER_NODE_SRC_TYPE_AUDIO_CAPTURE,  /**<  Audio capture source type, Microphone feature is required */
 103         MEDIA_STREAMER_NODE_SRC_TYPE_VIDEO_CAPTURE,  /**<  Video capture source type, Camera feature is required */
 104         MEDIA_STREAMER_NODE_SRC_TYPE_AUDIO_TEST,     /**<  Audio test source type */
 105         MEDIA_STREAMER_NODE_SRC_TYPE_VIDEO_TEST,     /**<  Video test source type */
 106         MEDIA_STREAMER_NODE_SRC_TYPE_CUSTOM,         /**<  Custom source type */
 107         MEDIA_STREAMER_NODE_SRC_TYPE_ADAPTIVE        /**<  Adaptive source type, Network internet feature is required */
 108 } media_streamer_node_src_type_e;
 109
 110 /**
 111  * @brief Enumeration for media streamer sink node type.
 112  *
 113  * @since_tizen 3.0
 114  */
 115 typedef enum {
 116         MEDIA_STREAMER_NODE_SINK_TYPE_NONE,   /**<  Not defined sink type */
 117         MEDIA_STREAMER_NODE_SINK_TYPE_FILE,   /**<  Local file sink type */
 118         MEDIA_STREAMER_NODE_SINK_TYPE_RTSP,   /**<  RTSP sink type, Network internet feature is required */
 119         MEDIA_STREAMER_NODE_SINK_TYPE_HTTP,   /**<  HTTP sink type, Network internet feature is required */
 120         MEDIA_STREAMER_NODE_SINK_TYPE_AUDIO,  /**<  Audio sink type */
 121         MEDIA_STREAMER_NODE_SINK_TYPE_OVERLAY,/**<  Overlay sink type */
 122         MEDIA_STREAMER_NODE_SINK_TYPE_FAKE,   /**<  Fake sink type */
 123         MEDIA_STREAMER_NODE_SINK_TYPE_CUSTOM, /**<  Custom sink type */
 124         MEDIA_STREAMER_NODE_SINK_TYPE_ADAPTIVE /**<  Adaptive sink type to generate fragmented files */
 125 } media_streamer_node_sink_type_e;
 126
 127 /**
 128  * @brief Enumeration for media streamer state.
 129  *
 130  * @since_tizen 3.0
 131  */
 132 typedef enum {
 133         MEDIA_STREAMER_STATE_NONE,    /**<  Streamer is not created */
 134         MEDIA_STREAMER_STATE_IDLE,    /**<  Streamer is created but not prepared */
 135         MEDIA_STREAMER_STATE_READY,   /**<  Streamer is ready to play */
 136         MEDIA_STREAMER_STATE_PLAYING, /**<  Streamer is playing */
 137         MEDIA_STREAMER_STATE_PAUSED,  /**<  Streamer is paused */
 138         MEDIA_STREAMER_STATE_SEEKING  /**<  Seek is under operation */
 139 } media_streamer_state_e;
 140
 141 /**
 142  * @brief Enumeration for media streamer error.
 143  *
 144  * @since_tizen 3.0
 145  */
 146 typedef enum {
 147         MEDIA_STREAMER_ERROR_NONE = TIZEN_ERROR_NONE,                                        /**< Successful */
 148         MEDIA_STREAMER_ERROR_INVALID_PARAMETER = TIZEN_ERROR_INVALID_PARAMETER,              /**< Invalid parameter */
 149         MEDIA_STREAMER_ERROR_INVALID_OPERATION  = TIZEN_ERROR_INVALID_OPERATION,             /**< Invalid operation */
 150         MEDIA_STREAMER_ERROR_FILE_NO_SPACE_ON_DEVICE = TIZEN_ERROR_FILE_NO_SPACE_ON_DEVICE,  /**< No space left on the device */
 151         MEDIA_STREAMER_ERROR_NOT_SUPPORTED  = TIZEN_ERROR_NOT_SUPPORTED,                     /**< The feature is not supported */
 152         MEDIA_STREAMER_ERROR_PERMISSION_DENIED = TIZEN_ERROR_PERMISSION_DENIED,              /**< Permission denied */
 153         MEDIA_STREAMER_ERROR_INVALID_STATE = TIZEN_ERROR_MEDIA_STREAMER | 0x01,              /**< Invalid state */
 154         MEDIA_STREAMER_ERROR_CONNECTION_FAILED = TIZEN_ERROR_MEDIA_STREAMER | 0x02,          /**< Connection failed */
 155         MEDIA_STREAMER_ERROR_RESOURCE_CONFLICT = TIZEN_ERROR_MEDIA_STREAMER | 0x03,          /**< Resource conflict */
 156         MEDIA_STREAMER_ERROR_SEEK_FAILED = TIZEN_ERROR_MEDIA_STREAMER | 0x04,                /**< Seek operation failure */
 157 } media_streamer_error_e;
 158
 159 /**
 160  * @brief Enumeration for media streamer buffer status of custom source.
 161  *
 162  * @since_tizen 3.0
 163  */
 164 typedef enum {
 165         MEDIA_STREAMER_CUSTOM_BUFFER_UNDERRUN,  /**< Buffer underrun of custom source */
 166         MEDIA_STREAMER_CUSTOM_BUFFER_OVERFLOW,  /**< Buffer overflow of custom source */
 167 } media_streamer_custom_buffer_status_e;
 168
 169 /**
 170  * @brief Enumeration for media streamer's interruption type.
 171  *
 172  * @since_tizen 3.0
 173  */
 174 typedef enum {
 175         MEDIA_STREAMER_INTERRUPTED_BY_RESOURCE_CONFLICT,    /**< Interrupted by a resource conflict */
 176         MEDIA_STREAMER_INTERRUPTED_BY_SECURITY,             /**< Interrupted by a security policy */
 177 } media_streamer_interrupted_code_e;
 178
 179 /**
 180  * @brief Definition for camera-id parameter of source node.
 181  * @details Index number of camera to activate.
 182  *          Data type is integer and default value is 0.
 183  * @since_tizen 3.0
 184  * @see media_streamer_node_get_params()
 185  */
 186 #define MEDIA_STREAMER_PARAM_CAMERA_ID "camera-id"
 187
 188 /**
 189  * @brief Definition for capture-width parameter of source node.
 190  * @details Width for camera size to capture.
 191  *          Data type is integer and default value is 1600.
 192  * @since_tizen 3.0
 193  * @see media_streamer_node_get_params()
 194  */
 195 #define MEDIA_STREAMER_PARAM_CAPTURE_WIDTH "capture-width"
 196
 197 /**
 198  * @brief Definition for capture-height parameter of source node.
 199  * @details Height for camera size to capture.
 200  *          Data type is integer and default value is 1200.
 201  * @since_tizen 3.0
 202  * @see media_streamer_node_get_params()
 203  */
 204 #define MEDIA_STREAMER_PARAM_CAPTURE_HEIGHT "capture-height"
 205
 206 /**
 207  * @brief Definition for is-live parameter of source node.
 208  * @details Whether to act as a live source.
 209  *          Data type is boolean and default value is false.
 210  * @since_tizen 3.0
 211  * @see media_streamer_node_get_params()
 212  */
 213 #define MEDIA_STREAMER_PARAM_IS_LIVE_STREAM "is-live"
 214
 215 /**
 216  * @brief Definition for uri parameter of source node.
 217  * @details URI to read from
 218  *          Data type is string.
 219  * @since_tizen 3.0
 220  * @see media_streamer_node_get_params()
 221  */
 222 #define MEDIA_STREAMER_PARAM_URI "uri"
 223
 224 /**
 225  * @brief Definition for user-agent parameter of source node.
 226  * @details Value of the User-Agent HTTP request header field.
 227  *          Data type is string.
 228  * @since_tizen 3.0
 229  * @see media_streamer_node_get_params()
 230  */
 231 #define MEDIA_STREAMER_PARAM_USER_AGENT "user-agent"
 232
 233 /**
 234  * @brief Definition for stream type parameter of source node.
 235  * @details The type of the push data stream.
 236  *          0:stream, 1:seekable, 2:random-access (default:0)
 237  * @since_tizen 3.0
 238  * @see media_streamer_node_get_params()
 239  */
 240 #define MEDIA_STREAMER_PARAM_STREAM_TYPE "stream-type"
 241
 242 /**
 243  * @brief Definition for port parameter of source or sink node.
 244  * @details The port to receive the packets from.
 245  *          Data type is integer and default value is 5004.
 246  * @since_tizen 3.0
 247  * @see media_streamer_node_get_params()
 248  */
 249 #define MEDIA_STREAMER_PARAM_PORT "port"
 250
 251 /**
 252  * @brief Definition for video port parameter of source node.
 253  * @details The port to receive the video packets from.
 254  *          Data type is integer.
 255  * @since_tizen 3.0
 256  * @see media_streamer_node_get_params()
 257  */
 258 #define MEDIA_STREAMER_PARAM_VIDEO_IN_PORT "video_in_port"
 259
 260 /**
 261  * @brief Definition for audio port parameter of source node.
 262  * @details The port to receive the audio packets from.
 263  *          Data type is integer.
 264  * @since_tizen 3.0
 265  * @see media_streamer_node_get_params()
 266  */
 267 #define MEDIA_STREAMER_PARAM_AUDIO_IN_PORT "audio_in_port"
 268
 269 /**
 270  * @brief Definition for video port parameter of sink node.
 271  * @details The port to send the video packets to.
 272  *          Data type is integer.
 273  * @since_tizen 3.0
 274  * @see media_streamer_node_get_params()
 275  */
 276 #define MEDIA_STREAMER_PARAM_VIDEO_OUT_PORT "video_out_port"
 277
 278 /**
 279  * @brief Definition for audio port parameter of sink node.
 280  * @details The port to send the audio packets to.
 281  *          Data type is integer.
 282  * @since_tizen 3.0
 283  * @see media_streamer_node_get_params()
 284  */
 285 #define MEDIA_STREAMER_PARAM_AUDIO_OUT_PORT "audio_out_port"
 286
 287 /**
 288  * @brief Definition for IP address parameter of source node.
 289  * @details IP address to send/receive packets for.
 290  *          Data type is string and default value is "0.0.0.0".
 291  * @since_tizen 3.0
 292  * @see media_streamer_node_get_params()
 293  */
 294 #define MEDIA_STREAMER_PARAM_IP_ADDRESS "address"
 295
 296 /**
 297  * @brief Definition for the peer type of WebRTC node.
 298  * @details The type of WebRTC peer, it can be "answer" or "offer".
 299  *          Data type is string and default value is "answer".
 300  * @since_tizen 6.0
 301  * @see media_streamer_node_get_params()
 302  */
 303 #define MEDIA_STREAMER_PARAM_WEBRTC_PEER_TYPE "webrtc-peer-type"
 304
 305 /**
 306  * @brief Definition for the STUN server URL for WebRTC node.
 307  * @details Data type is string and default value is "stun://stun.l.google.com:19302".
 308  * @since_tizen 6.0
 309  * @see media_streamer_node_get_params()
 310  */
 311 #define MEDIA_STREAMER_PARAM_WEBRTC_STUN_SERVER "webrtc-stun-server"
 312
 313 /**
 314  * @brief Definition for remote session description.
 315  * @details Value of the session description of the remote peer over its signaling channel.
 316  *          Data type is string.
 317  * @since_tizen 6.0
 318  * @see media_streamer_node_get_params() */
 319 #define MEDIA_STREAMER_PARAM_WEBRTC_REMOTE_SESSION_DESCRIPTION "webrtc-remote-session-description"
 320
 321 /**
 322  * @brief Definition for ICE candidate of WebRTC node.
 323  * @details Value of ICE candidate of the remote peer over its signaling channel.
 324  *          Data type is string.
 325  * @since_tizen 6.0
 326  * @see media_streamer_node_get_params() */
 327 #define MEDIA_STREAMER_PARAM_WEBRTC_ADD_ICE_CANDIDATE "webrtc-add-ice-candidate"
 328
 329 /**
 330  * @brief Definition for audio device name parameter of source or sink node.
 331  * @details ALSA device, as defined in an asound configuration file.
 332  *          ex) "hw:0,0", "hw:0,1"
 333  *          Data type is string and default value is "default".
 334  * @since_tizen 3.0
 335  * @see media_streamer_node_get_params()
 336  */
 337 #define MEDIA_STREAMER_PARAM_AUDIO_DEVICE "audio_device"
 338
 339 /**
 340  * @brief Definition for sync parameter of sink node.
 341  * @details Synchronize on the clock
 342  *          Data type is boolean and default value is true.
 343  * @since_tizen 3.0
 344  * @see media_streamer_node_get_params()
 345  */
 346 #define MEDIA_STREAMER_PARAM_CLOCK_SYNCHRONIZED "sync"
 347
 348 /**
 349  * @brief Definition for rotate parameter of sink node.
 350  * @details Rotate angle of display output.
 351  *          0:none/1:rotate 90 degree/2:rotate 180 degree/3:rotate 270 degree
 352  *          Default value is 3(rotate 270 degree).
 353  * @since_tizen 3.0
 354  * @see media_streamer_node_get_params()
 355  */
 356 #define MEDIA_STREAMER_PARAM_ROTATE "rotate"
 357
 358 /**
 359  * @brief Definition for flip parameter of sink node.
 360  * @details Flip for display.
 361  *          0:none, 1:horizontal, 2:vertical, 3:both
 362  *          Default value is 0.
 363  * @since_tizen 3.0
 364  * @see media_streamer_node_get_params()
 365  */
 366 #define MEDIA_STREAMER_PARAM_FLIP "flip"
 367
 368 /**
 369  * @brief Definition for display geometry method parameter of sink node.
 370  * @details Geometrical method for display.
 371  *          0:Letter box
 372  *          1:Original size
 373  *          2:Full-screen
 374  *          3:Cropped full screen
 375  *          4:Original size if surface size is larger than video size(width/height),
 376  *            or Letter box if video size(width/height) is larger than surface size.
 377  *          5:Custom ROI
 378  *          Default value is 0(Letter box).
 379  * @since_tizen 3.0
 380  * @see media_streamer_node_get_params()
 381  */
 382 #define MEDIA_STREAMER_PARAM_DISPLAY_GEOMETRY_METHOD "display-geometry-method"
 383
 384 /**
 385  * @brief Definition for display parameter of sink node.
 386  * @details It is a object to draw video frame on.
 387  *          Data type is pointer.
 388  * @since_tizen 3.0
 389  * @see media_streamer_node_get_params()
 390  */
 391 #define MEDIA_STREAMER_PARAM_DISPLAY "display"
 392
 393 /**
 394  * @brief Definition for visible parameter of sink node.
 395  * @details Draws screen or blacks out.
 396  *          Data type is boolean and default value is true(visible).
 397  * @since_tizen 3.0
 398  * @see media_streamer_node_get_params()
 399  */
 400 #define MEDIA_STREAMER_PARAM_VISIBLE "visible"
 401
 402 /**
 403  * @brief Definition for use-tbm parameter of sink node.
 404  * @details Use Tizen Buffer Memory instead of Shared Memory.
 405  *          The sink node must receive the tbm-buffer created by the previous node.
 406  *          The value is changeable only in the #MEDIA_STREAMER_STATE_IDLE state.
 407  *          Data type is boolean and default value is false.
 408  * @since_tizen 5.5
 409  * @see media_streamer_node_get_params()
 410  */
 411 #define MEDIA_STREAMER_PARAM_USE_TBM "use-tbm"
 412
 413 /**
 414  * @brief Definition for host parameter of sink node.
 415  * @details The host/IP/Multicast group to send the packets to.
 416  *          Data type is string and default value is "localhost".
 417  * @since_tizen 3.0
 418  * @see media_streamer_node_get_params()
 419  */
 420 #define MEDIA_STREAMER_PARAM_HOST "host"
 421
 422 /**
 423  * @brief Definition for segment location parameter of adaptive sink node.
 424  * @details Path for writing playlist from
 425  *          Data type is string.
 426  * @since_tizen 3.0
 427  * @see media_streamer_node_get_params()
 428  */
 429 #define MEDIA_STREAMER_PARAM_SEGMENT_LOCATION "location"
 430
 431 /**
 432  * @brief Definition for playlist location parameter of adaptive sink node.
 433  * @details Path for writing playlist from. Data type is string.
 434  * @since_tizen 3.0
 435  * @see media_streamer_node_get_params()
 436  */
 437 #define MEDIA_STREAMER_PARAM_PLAYLIST_LOCATION "playlist-location"
 438
 439 /**
 440  * @brief Called when error occurs in media streamer.
 441  * @since_tizen 3.0
 442  * @remarks Following error codes can be delivered.
 443  *          #MEDIA_STREAMER_ERROR_INVALID_OPERATION,
 444  *          #MEDIA_STREAMER_ERROR_FILE_NO_SPACE_ON_DEVICE,
 445  *          #MEDIA_STREAMER_ERROR_NOT_SUPPORTED,
 446  *          #MEDIA_STREAMER_ERROR_CONNECTION_FAILED,
 447  *          #MEDIA_STREAMER_ERROR_RESOURCE_CONFLICT
 448  * @param[in] streamer   Media streamer handle
 449  * @param[in] error      The error that occurred in media steamer
 450  * @param[in] user_data  The user data passed from the code where
 451  *                       media_streamer_set_error_cb() was invoked
 452  *                       This data will be accessible from media_streamer_error_cb()
 453  * @pre Create media streamer handle by calling media_streamer_create().
 454  * @see media_streamer_set_error_cb()
 455  * @see media_streamer_unset_error_cb()
 456  */
 457 typedef void (*media_streamer_error_cb)(media_streamer_h streamer,
 458                                         media_streamer_error_e error, void *user_data);
 459
 460 /**
 461  * @brief Called when media streamer state is changed.
 462  * @since_tizen 3.0
 463  * @param[in] streamer        Media streamer handle
 464  * @param[in] previous_state  The previous state of the media streamer
 465  * @param[in] current_state   The current state of media streamer
 466  * @param[in] user_data       The user data passed from the code where
 467  *                            media_streamer_set_state_changed_cb() was invoked
 468  *                            This data will be accessible from media_streamer_state_changed_cb()
 469  * @pre Create media streamer handle by calling media_streamer_create().
 470  * @see media_streamer_set_state_change_cb()
 471  * @see media_streamer_unset_state_change_cb()
 472  */
 473 typedef void (*media_streamer_state_changed_cb)(media_streamer_h streamer,
 474                                         media_streamer_state_e previous_state, media_streamer_state_e current_state, void *user_data);
 475
 476 /**
 477  * @brief Called when the custom source needs more data or has enough data.
 478  * @details This callback will be invoked when the buffer level drops below the threshold of max size
 479  *          or no free space in custom source buffer.
 480  * @since_tizen 3.0
 481  * @remarks Callback can be applied only for #MEDIA_STREAMER_NODE_SRC_TYPE_CUSTOM source type
 482  * @param[in] src       Media streamer source node handle
 483  * @param[in] status    Media streamer custom buffer status
 484  * @param[in] user_data The user data passed from the callback registration function
 485  * @see media_streamer_src_set_buffer_status_cb()
 486  * @see media_streamer_node_get_param()
 487  * @see media_streamer_node_set_param()
 488  */
 489 typedef void (*media_streamer_custom_buffer_status_cb)(media_streamer_node_h src,
 490                                         media_streamer_custom_buffer_status_e status, void *user_data);
 491
 492 /**
 493  * @brief Called when new data is available from custom sink.
 494  * @details This callback can be applied only to #MEDIA_STREAMER_NODE_SINK_TYPE_CUSTOM sink type
 495  * @since_tizen 3.0
 496  * @param[in] sink      Media streamer sink node handle
 497  * @param[in] user_data The user data passed from the code where
 498  *                       media_streamer_sink_set_data_ready_cb() was invoked
 499  *                       This data will be accessible from media_streamer_sink_data_ready_cb()
 500  * @pre media_streamer_sink_set_data_ready_cb()
 501  * @see MEDIA_STREAMER_NODE_SINK_TYPE_CUSTOM
 502  * @see media_streamer_sink_set_data_ready_cb()
 503  * @see media_streamer_sink_unset_data_ready_cb()
 504  */
 505 typedef void (*media_streamer_sink_data_ready_cb)(media_streamer_node_h sink, void *user_data);
 506
 507 /**
 508  * @brief  Called when the end-of-stream has been reached.
 509  * @details This callback can be applied only to #MEDIA_STREAMER_NODE_SINK_TYPE_CUSTOM sink type
 510  * @since_tizen 3.0
 511  * @param[in] sink      Media streamer sink node handle
 512  * @param[in] user_data The user data passed from the code where
 513  *                       media_streamer_sink_set_eos_cb() was invoked
 514  *                       This data will be accessible from media_streamer_sink_eos_cb()
 515  * @pre media_streamer_sink_set_eos_cb()
 516  * @see MEDIA_STREAMER_NODE_SINK_TYPE_CUSTOM
 517  * @see media_streamer_sink_set_eos_cb()
 518  * @see media_streamer_sink_unset_eos_cb()
 519  */
 520 typedef void (*media_streamer_sink_eos_cb)(media_streamer_node_h sink, void *user_data);
 521
 522 /**
 523  * @brief Called when the seek operation is completed.
 524  * @since_tizen 3.0
 525  * @param[in] user_data     The user data passed from the callback registration function
 526  * @see media_streamer_set_play_position()
 527  */
 528 typedef void (*media_streamer_position_changed_cb)(void *user_data);
 529
 530 /**
 531  * @brief Called when the media streamer is interrupted.
 532  * @since_tizen 3.0
 533  * @param[in] code       The interrupted error code
 534  * @param[in] user_data  The user data passed from the callback registration function
 535  * @see media_streamer_set_interrupted_cb()
 536  * @see media_streamer_unset_interrupted_cb()
 537  */
 538 typedef void (*media_streamer_interrupted_cb)(media_streamer_interrupted_code_e code, void *user_data);
 539
 540 /**
 541  * @brief Called when a source pad of a media streamer node is ready to provide decoded data.
 542  * @since_tizen 6.0
 543  * @param[in] node          Media streamer node handle
 544  * @param[in] src_pad_name  The source pad name that can give decoded data to another one
 545  * @param[in] media_type    The media type of the data from the given source pad such as 'video/x-raw', 'audio/x-raw', and so on
 546  * @param[in] user_data     The user data passed from the callback registration function
 547  * @see media_streamer_node_set_decoded_ready_cb()
 548  * @see media_streamer_node_link()
 549  * @see media_streamer_node_unset_decoded_ready_cb()
 550  */
 551 typedef void (*media_streamer_node_decoded_ready_cb)(media_streamer_node_h node, const char *src_pad_name, const char *media_type, void *user_data);
 552
 553 /**
 554  * @brief Called when the media streamer WebRTC node needs to send the message to the remote peer of the WebRTC connection.
 555  * @since_tizen 6.0
 556  * @remarks Two types will be delivered with @a message which is a JSON string.
 557  *          One is for the remote session description and the other is for a new ICE candidate.
 558  *          For the remote session description, @a message will be {"sdp":{"type":"offer or answer","sdp":"..."}}.
 559  *          For the new ICE candidate, @a message will be {"ice":{"candidate":"..."}}.
 560  * @param[in] webrtc     Media streamer WebRTC node handle
 561  * @param[in] message    The message to be passed to the remote peer over the signaling channel
 562  * @param[in] user_data  The user data passed from the callback registration function
 563  * @see media_streamer_webrtc_node_set_message_cb()
 564  * @see media_streamer_webrtc_node_unset_message_cb()
 565  */
 566 typedef void (*media_streamer_webrtc_message_cb)(media_streamer_node_h webrtc, const char *message, void *user_data);
 567
 568 /**
 569  * @brief Sets a error callback function to be invoked when an error occurs.
 570  * @details Following error codes can be delivered by error callback.
 571  *          #MEDIA_STREAMER_ERROR_INVALID_OPERATION,
 572  *          #MEDIA_STREAMER_ERROR_FILE_NO_SPACE_ON_DEVICE,
 573  *          #MEDIA_STREAMER_ERROR_NOT_SUPPORTED,
 574  *          #MEDIA_STREAMER_ERROR_CONNECTION_FAILED,
 575  *          #MEDIA_STREAMER_ERROR_RESOURCE_CONFLICT
 576  * @since_tizen 3.0
 577  * @param[in] streamer  Media streamer handle
 578  * @param[in] callback  Callback function pointer
 579  * @param[in] user_data The user data passed from the code where
 580  *                      media_streamer_set_error_cb() was invoked
 581  *                      This data will be accessible from media_streamer_error_cb()
 582  * @return @c 0 on success,
 583  *         otherwise a negative error value
 584  * @retval #MEDIA_STREAMER_ERROR_NONE Successful
 585  * @retval #MEDIA_STREAMER_ERROR_INVALID_PARAMETER Invalid parameter
 586  * @retval #MEDIA_STREAMER_ERROR_INVALID_OPERATION Invalid operation
 587  * @pre Create a media streamer handle by calling media_streamer_create().
 588  * @post media_streamer_error_cb() will be invoked.
 589  * @see media_streamer_unset_error_cb()
 590  * @see media_streamer_error_cb()
 591  */
 592 int media_streamer_set_error_cb(media_streamer_h streamer, media_streamer_error_cb callback, void *user_data);
 593
 594 /**
 595  * @brief Unsets the error callback function.
 596  * @since_tizen 3.0
 597  * @param[in] streamer  Media streamer handle
 598  * @return @c 0 on success,
 599  *         otherwise a negative error value
 600  * @retval #MEDIA_STREAMER_ERROR_NONE Successful
 601  * @retval #MEDIA_STREAMER_ERROR_INVALID_PARAMETER Invalid parameter
 602  * @retval #MEDIA_STREAMER_ERROR_INVALID_OPERATION Invalid operation
 603  * @see media_streamer_error_cb()
 604  */
 605 int media_streamer_unset_error_cb(media_streamer_h streamer);
 606
 607 /**
 608  * @brief Sets a callback that will be triggered after media streamer state is changed.
 609  * @since_tizen 3.0
 610  * @param[in] streamer  Media streamer handle
 611  * @param[in] callback  Callback function pointer
 612  * @param[in] user_data The user data passed from the code
 613  *                      where media_streamer_set_state_change_cb() was invoked
 614  *                      This data will be accessible from media_streamer_state_changed_cb()
 615  * @return @c 0 on success,
 616  *         otherwise a negative error value
 617  * @retval #MEDIA_STREAMER_ERROR_NONE Successful
 618  * @retval #MEDIA_STREAMER_ERROR_INVALID_PARAMETER Invalid parameter
 619  * @retval #MEDIA_STREAMER_ERROR_INVALID_OPERATION Invalid operation
 620  * @pre Create a media streamer handle by calling media_streamer_create().
 621  * @post media_streamer_state_changed_cb() will be invoked.
 622  * @see media_streamer_unset_state_change_cb()
 623  * @see media_streamer_state_changed_cb()
 624  */
 625 int media_streamer_set_state_change_cb(media_streamer_h streamer, media_streamer_state_changed_cb callback, void *user_data);
 626
 627 /**
 628  * @brief Unsets the state changed callback function.
 629  * @since_tizen 3.0
 630  * @param[in] streamer  Media streamer handle
 631  * @return @c 0 on success,
 632  *         otherwise a negative error value
 633  * @retval #MEDIA_STREAMER_ERROR_NONE Successful
 634  * @retval #MEDIA_STREAMER_ERROR_INVALID_PARAMETER Invalid parameter
 635  * @retval #MEDIA_STREAMER_ERROR_INVALID_OPERATION Invalid operation
 636  * @see media_streamer_set_state_change_cb()
 637  */
 638 int media_streamer_unset_state_change_cb(media_streamer_h streamer);
 639
 640 /**
 641  * @brief Sets a callback function to be invoked when the media streamer is interrupted.
 642  * @since_tizen 3.0
 643  * @param[in] streamer  Media streamer handle
 644  * @param[in] callback  The callback function to register
 645  * @param[in] user_data The user data to be passed to the callback function
 646  * @return @c 0 on success,
 647  *         otherwise a negative error value
 648  * @retval #MEDIA_STREAMER_ERROR_NONE Successful
 649  * @retval #MEDIA_STREAMER_ERROR_INVALID_PARAMETER Invalid parameter
 650  * @retval #MEDIA_STREAMER_ERROR_INVALID_OPERATION Invalid operation
 651  * @post media_streamer_interrupted_cb() will be invoked.
 652  * @see media_streamer_unset_interrupted_cb()
 653  * @see #media_streamer_interrupted_code_e
 654  */
 655 int media_streamer_set_interrupted_cb(media_streamer_h streamer, media_streamer_interrupted_cb callback, void *user_data);
 656
 657 /**
 658  * @brief Unsets the callback function.
 659  * @since_tizen 3.0
 660  * @param[in] streamer Media streamer handle
 661  * @return @c 0 on success,
 662  *         otherwise a negative error value
 663  * @retval #MEDIA_STREAMER_ERROR_NONE Successful
 664  * @retval #MEDIA_STREAMER_ERROR_INVALID_PARAMETER Invalid parameter
 665  * @retval #MEDIA_STREAMER_ERROR_INVALID_OPERATION Invalid operation
 666  * @see media_streamer_set_interrupted_cb()
 667  */
 668 int media_streamer_unset_interrupted_cb(media_streamer_h streamer);
 669
 670 /**
 671  * @brief Sets a callback function to be invoked when buffer underrun or overflow is occurred.
 672  * @details This function can be called only for #MEDIA_STREAMER_NODE_SRC_TYPE_CUSTOM source type
 673  * @since_tizen 3.0
 674  * @remarks This function is used for media stream playback only.
 675  * @param[in] src       Media streamer source node handle
 676  * @param[in] callback  The buffer status callback function to register
 677  * @param[in] user_data The user data passed from the code where
 678  *                       media_streamer_src_set_buffer_status_cb() was invoked
 679  *                       This data will be accessible from media_streamer_custom_buffer_status_cb()
 680  * @return @c 0 on success,
 681  *         otherwise a negative error value
 682  * @retval #MEDIA_STREAMER_ERROR_NONE Successful
 683  * @retval #MEDIA_STREAMER_ERROR_INVALID_PARAMETER Invalid parameter
 684  * @retval #MEDIA_STREAMER_ERROR_INVALID_OPERATION Invalid operation
 685  * @pre Create a media streamer source node handle by calling media_streamer_node_create_src().
 686  * @pre Add created media streamer source node to media streamer by calling media_streamer_node_add().
 687  * @post media_streamer_custom_buffer_status_cb() will be invoked.
 688  * @see media_streamer_src_unset_buffer_status_cb()
 689  * @see media_streamer_custom_buffer_status_cb()
 690  */
 691 int media_streamer_src_set_buffer_status_cb(media_streamer_node_h src, media_streamer_custom_buffer_status_cb callback, void *user_data);
 692
 693 /**
 694  * @brief Unsets the source buffer status callback function.
 695  * @since_tizen 3.0
 696  * @param[in] src    Media streamer source node handle
 697  * @return @c 0 on success,
 698  *         otherwise a negative error value
 699  * @retval #MEDIA_STREAMER_ERROR_NONE Successful
 700  * @retval #MEDIA_STREAMER_ERROR_INVALID_PARAMETER Invalid parameter
 701  * @retval #MEDIA_STREAMER_ERROR_INVALID_OPERATION Invalid operation
 702  * @see media_streamer_src_set_buffer_status_cb()
 703  */
 704 int media_streamer_src_unset_buffer_status_cb(media_streamer_node_h src);
 705
 706 /**
 707  * @brief Sets a callback function to be called when the custom sink is ready for data processing.
 708  * @details This function can be called only for #MEDIA_STREAMER_NODE_SINK_TYPE_CUSTOM sink type
 709  * @since_tizen 3.0
 710  * @param[in] sink      Media streamer sink node handle
 711  * @param[in] callback  Callback function pointer
 712  * @param[in] user_data The user data passed from the code where
 713  *                       media_streamer_sink_set_data_ready_cb() was invoked
 714  *                       This data will be accessible from media_streamer_sink_data_ready_cb()
 715  * @return @c 0 on success,
 716  *         otherwise a negative error value
 717  * @retval #MEDIA_STREAMER_ERROR_NONE Successful
 718  * @retval #MEDIA_STREAMER_ERROR_INVALID_PARAMETER Invalid parameter
 719  * @retval #MEDIA_STREAMER_ERROR_INVALID_OPERATION Invalid operation
 720  * @pre Create a media streamer sink handle by calling media_streamer_node_create_sink().
 721  * @pre Add created media streamer sink node to media streamer by calling media_streamer_node_add().
 722  * @post media_streamer_sink_data_ready_cb() will be invoked.
 723  * @see media_streamer_sink_unset_data_ready_cb()
 724  * @see media_streamer_sink_data_ready_cb()
 725  */
 726 int media_streamer_sink_set_data_ready_cb(media_streamer_node_h sink, media_streamer_sink_data_ready_cb callback, void *user_data);
 727
 728 /**
 729  * @brief Unsets the sink data ready callback function.
 730  * @since_tizen 3.0
 731  * @param[in] sink    Media streamer sink node handle
 732  * @return @c 0 on success,
 733  *         otherwise a negative error value
 734  * @retval #MEDIA_STREAMER_ERROR_NONE Successful
 735  * @retval #MEDIA_STREAMER_ERROR_INVALID_PARAMETER Invalid parameter
 736  * @retval #MEDIA_STREAMER_ERROR_INVALID_OPERATION Invalid operation
 737  * @see media_streamer_sink_set_data_ready_cb()
 738  */
 739 int media_streamer_sink_unset_data_ready_cb(media_streamer_node_h sink);
 740
 741 /**
 742  * @brief Sets a callback function to be called when custom sink detect the end-of-stream.
 743  * @since_tizen 3.0
 744  * @param[in] sink      Media streamer sink node handle
 745  * @param[in] callback  Callback function pointer
 746  * @param[in] user_data The user data passed from the code where
 747  *                       media_streamer_sink_set_eos_cb() was invoked.
 748  *                       This data will be accessible from media_streamer_sink_eos_cb()
 749  * @return @c 0 on success,
 750  *         otherwise a negative error value
 751  * @retval #MEDIA_STREAMER_ERROR_NONE Successful
 752  * @retval #MEDIA_STREAMER_ERROR_INVALID_PARAMETER Invalid parameter
 753  * @retval #MEDIA_STREAMER_ERROR_INVALID_OPERATION Invalid operation
 754  * @pre Create a media streamer sink handle by calling media_streamer_node_create_sink().
 755  * @pre Add created media streamer sink node to media streamer by calling media_streamer_node_add().
 756  * @post media_streamer_sink_eos_cb() will be invoked.
 757  * @see media_streamer_sink_unset_eos_cb()
 758  * @see media_streamer_sink_eos_cb()
 759  */
 760 int media_streamer_sink_set_eos_cb(media_streamer_node_h sink, media_streamer_sink_eos_cb callback, void *user_data);
 761
 762 /**
 763  * @brief Unsets the sink end-of-stream callback function.
 764  * @since_tizen 3.0
 765  * @param[in] sink    Media streamer sink node handle
 766  * @return @c 0 on success,
 767  *         otherwise a negative error value
 768  * @retval #MEDIA_STREAMER_ERROR_NONE Successful
 769  * @retval #MEDIA_STREAMER_ERROR_INVALID_PARAMETER Invalid parameter
 770  * @retval #MEDIA_STREAMER_ERROR_INVALID_OPERATION Invalid operation
 771  * @see media_streamer_sink_set_eos_cb()
 772  */
 773 int media_streamer_sink_unset_eos_cb(media_streamer_node_h sink);
 774
 775 /**
 776  * @brief Creates an instance of media streamer and
 777  *        passes the handle to the caller.
 778  * @since_tizen 3.0
 779  * @remarks You must release @a streamer using media_streamer_destroy()
 780  * @param[out] streamer    Media streamer handle
 781  * @return @c 0 on success,
 782  *         otherwise a negative error value
 783  * @retval #MEDIA_STREAMER_ERROR_NONE Successful
 784  * @retval #MEDIA_STREAMER_ERROR_INVALID_PARAMETER Invalid parameter
 785  * @retval #MEDIA_STREAMER_ERROR_INVALID_OPERATION Invalid operation
 786  * @post The media streamer state will be #MEDIA_STREAMER_STATE_IDLE.
 787  * @see media_streamer_destroy()
 788  */
 789 int media_streamer_create(media_streamer_h *streamer);
 790
 791 /**
 792  * @brief Sets media streamer state to #MEDIA_STREAMER_STATE_READY.
 793  * @since_tizen 3.0
 794  * @param[in] streamer     Media streamer handle
 795  * @return @c 0 on success,
 796  *         otherwise a negative error value
 797  * @retval #MEDIA_STREAMER_ERROR_NONE Successful
 798  * @retval #MEDIA_STREAMER_ERROR_INVALID_STATE Invalid state
 799  * @retval #MEDIA_STREAMER_ERROR_INVALID_PARAMETER Invalid parameter
 800  * @retval #MEDIA_STREAMER_ERROR_INVALID_OPERATION Invalid operation
 801  * @pre The media streamer state must be set to #MEDIA_STREAMER_STATE_IDLE
 802  *      by calling media_streamer_create() or media_streamer_unprepare().
 803  * @pre At least one source and one sink should be added and linked in the streamer
 804  *      by calling media_streamer_node_create_src(), media_streamer_node_create_sink() and media_streamer_node_link().
 805  * @post The media streamer state will be #MEDIA_STREAMER_STATE_READY.
 806  * @see media_streamer_unprepare()
 807  * @see media_streamer_create()
 808  */
 809 int media_streamer_prepare(media_streamer_h streamer);
 810
 811 /**
 812  * @brief Sets media streamer state to #MEDIA_STREAMER_STATE_IDLE.
 813  * @details The most recently used media is reset and no longer associated with the media streamer.
 814  * @since_tizen 3.0
 815  * @param[in] streamer     Media streamer handle
 816  * @return @c 0 on success,
 817  *         otherwise a negative error value
 818  * @retval #MEDIA_STREAMER_ERROR_NONE Successful
 819  * @retval #MEDIA_STREAMER_ERROR_INVALID_STATE Invalid state
 820  * @retval #MEDIA_STREAMER_ERROR_INVALID_PARAMETER Invalid parameter
 821  * @retval #MEDIA_STREAMER_ERROR_INVALID_OPERATION Invalid operation
 822  * @pre The media streamer state should be higher than #MEDIA_STREAMER_STATE_IDLE.
 823  * @post The media streamer state will be #MEDIA_STREAMER_STATE_IDLE.
 824  * @see media_streamer_prepare()
 825  */
 826 int media_streamer_unprepare(media_streamer_h streamer);
 827
 828 /**
 829  * @brief Sets media streamer state to #MEDIA_STREAMER_STATE_PLAYING.
 830  * @details Start running the current streamer, or resumes it if paused.
 831  * @since_tizen 3.0
 832  * @param[in] streamer     Media streamer handle
 833  * @return @c 0 on success,
 834  *         otherwise a negative error value
 835  * @retval #MEDIA_STREAMER_ERROR_NONE Successful
 836  * @retval #MEDIA_STREAMER_ERROR_INVALID_STATE Invalid state
 837  * @retval #MEDIA_STREAMER_ERROR_INVALID_PARAMETER Invalid parameter
 838  * @retval #MEDIA_STREAMER_ERROR_INVALID_OPERATION Invalid operation
 839  * @pre The media streamer state must be set to #MEDIA_STREAMER_STATE_READY by calling media_streamer_prepare() or
 840  *      set to #MEDIA_STREAMER_STATE_PAUSED by calling media_streamer_pause().
 841  * @post The media streamer state will be #MEDIA_STREAMER_STATE_PLAYING.
 842  * @see media_streamer_create()
 843  * @see media_streamer_pause()
 844  * @see media_streamer_stop()
 845  */
 846 int media_streamer_play(media_streamer_h streamer);
 847
 848 /**
 849  * @brief Pauses the media streamer.
 850  * @since_tizen 3.0
 851  * @param[in] streamer     Media streamer handle
 852  * @return @c 0 on success,
 853  *         otherwise a negative error value
 854  * @retval #MEDIA_STREAMER_ERROR_NONE Successful
 855  * @retval #MEDIA_STREAMER_ERROR_INVALID_STATE Invalid state
 856  * @retval #MEDIA_STREAMER_ERROR_INVALID_PARAMETER Invalid parameter
 857  * @retval #MEDIA_STREAMER_ERROR_INVALID_OPERATION Invalid operation
 858  * @pre The media streamer state must be set to #MEDIA_STREAMER_STATE_PLAYING.
 859  * @post The media streamer state will be #MEDIA_STREAMER_STATE_PAUSED.
 860  * @see media_streamer_create()
 861  * @see media_streamer_play()
 862  */
 863 int media_streamer_pause(media_streamer_h streamer);
 864
 865 /**
 866  * @brief Stops the media streamer.
 867  * @since_tizen 3.0
 868  * @param[in] streamer     Media streamer handle
 869  * @return @c 0 on success,
 870  *         otherwise a negative error value
 871  * @retval #MEDIA_STREAMER_ERROR_NONE Successful
 872  * @retval #MEDIA_STREAMER_ERROR_INVALID_STATE Invalid state
 873  * @retval #MEDIA_STREAMER_ERROR_INVALID_PARAMETER Invalid parameter
 874  * @retval #MEDIA_STREAMER_ERROR_INVALID_OPERATION Invalid operation
 875  * @pre The media streamer state must be set to #MEDIA_STREAMER_STATE_PLAYING by calling media_streamer_play() or
 876  *      set to #MEDIA_STREAMER_STATE_PAUSED by calling media_streamer_pause().
 877  * @post The media streamer state will be #MEDIA_STREAMER_STATE_READY.
 878  * @see media_streamer_create()
 879  * @see media_streamer_play()
 880  * @see media_streamer_pause()
 881  */
 882 int media_streamer_stop(media_streamer_h streamer);
 883
 884 /**
 885  * @brief Destroys media streamer.
 886  * @since_tizen 3.0
 887  * @remarks Nodes in streamer will be removed automatically.
 888  *          Don't need to remove nodes by calling media_streamer_node_remove().
 889  *          If you want to change the node without destroying streamer handle,
 890  *          you can call the media_streamer_node_remove().
 891  *          after setting the streamer state to #MEDIA_STREAMER_STATE_IDLE state.
 892  * @param[in] streamer     Media streamer handle
 893  * @return @c 0 on success,
 894  *         otherwise a negative error value
 895  * @retval #MEDIA_STREAMER_ERROR_NONE Successful
 896  * @retval #MEDIA_STREAMER_ERROR_INVALID_STATE Invalid state
 897  * @retval #MEDIA_STREAMER_ERROR_INVALID_PARAMETER Invalid parameter
 898  * @retval #MEDIA_STREAMER_ERROR_INVALID_OPERATION Invalid operation
 899  * @pre Create a media streamer handle by calling media_streamer_create().
 900  * @post The media streamer state will be #MEDIA_STREAMER_STATE_NONE.
 901  * @see media_streamer_create()
 902  */
 903 int media_streamer_destroy(media_streamer_h streamer);
 904
 905 /**
 906  * @brief Changes playback position to the defined time value, asynchronously.
 907  * @since_tizen 3.0
 908  * @param[in] streamer     Media streamer handle
 909  * @param[in] time         Time in millisecond
 910  * @param[in] accurate     If @c true, it will seek to the accurate position, but this might be considerably slower for some formats,
 911  *                         otherwise @c false, it will seek to the nearest keyframe
 912  * @param[in] callback     The callback function to register
 913  * @param[in] user_data    The user data to be passed to the callback function
 914  * @return @c 0 on success,
 915  *         otherwise a negative error value
 916  * @retval #MEDIA_STREAMER_ERROR_NONE    Successful
 917  * @retval #MEDIA_STREAMER_ERROR_INVALID_STATE Invalid state
 918  * @retval #MEDIA_STREAMER_ERROR_INVALID_PARAMETER Invalid parameter
 919  * @retval #MEDIA_STREAMER_ERROR_INVALID_OPERATION Invalid operation
 920  * @retval #MEDIA_STREAMER_ERROR_SEEK_FAILED Seek operation failure
 921  * @pre The media streamer state must be one of these: #MEDIA_STREAMER_STATE_PAUSED, or #MEDIA_STREAMER_STATE_PLAYING.
 922  * @post It invokes media_streamer_set_play_position() when seek operation completes, if you set a callback.
 923  * @see media_streamer_get_play_position()
 924  */
 925 int media_streamer_set_play_position(media_streamer_h streamer, int time,
 926                                         bool accurate, media_streamer_position_changed_cb callback, void *user_data);
 927
 928 /**
 929  * @brief Gets the current position in milliseconds.
 930  * @since_tizen 3.0
 931  * @param[in]  streamer     Media streamer handle
 932  * @param[out] time         The current position in milliseconds
 933  * @return @c 0 on success,
 934  *         otherwise a negative error value
 935  * @retval #MEDIA_STREAMER_ERROR_NONE Successful
 936  * @retval #MEDIA_STREAMER_ERROR_INVALID_STATE Invalid state
 937  * @retval #MEDIA_STREAMER_ERROR_INVALID_PARAMETER Invalid parameter
 938  * @retval #MEDIA_STREAMER_ERROR_INVALID_OPERATION Invalid operation
 939  * @pre The media streamer state must be one of these: #MEDIA_STREAMER_STATE_PAUSED, or #MEDIA_STREAMER_STATE_PLAYING.
 940  * @see media_streamer_set_play_position()
 941  */
 942 int media_streamer_get_play_position(media_streamer_h streamer, int *time);
 943
 944 /**
 945  * @brief Gets the total running time of the associated media.
 946  * @since_tizen 3.0
 947  * @remarks The streamer's source node type should be #MEDIA_STREAMER_NODE_SRC_TYPE_FILE or #MEDIA_STREAMER_NODE_SRC_TYPE_HTTP.
 948  *          If not, return value will be #MEDIA_STREAMER_ERROR_NONE and duration will be -1.
 949  * @param[in]  streamer     Media streamer handle
 950  * @param[out] duration     The duration in milliseconds
 951  * @return @c 0 on success,
 952  *         otherwise a negative error value
 953  * @retval #MEDIA_STREAMER_ERROR_NONE Successful
 954  * @retval #MEDIA_STREAMER_ERROR_INVALID_STATE Invalid state
 955  * @retval #MEDIA_STREAMER_ERROR_INVALID_PARAMETER Invalid parameter
 956  * @retval #MEDIA_STREAMER_ERROR_INVALID_OPERATION Invalid operation
 957  * @pre The media streamer state must be one of these: #MEDIA_STREAMER_STATE_PAUSED, or #MEDIA_STREAMER_STATE_PLAYING.
 958  */
 959 int media_streamer_get_duration(media_streamer_h streamer, int *duration);
 960
 961 /**
 962  * @brief Gets media streamer state.
 963  * @since_tizen 3.0
 964  * @param[in]  streamer     Media streamer handle
 965  * @param[out] state        Media streamer state
 966  * @return @c 0 on success,
 967  *         otherwise a negative error value
 968  * @retval #MEDIA_STREAMER_ERROR_NONE    Successful
 969  * @retval #MEDIA_STREAMER_ERROR_INVALID_PARAMETER Invalid parameter
 970  * @retval #MEDIA_STREAMER_ERROR_INVALID_OPERATION Invalid operation
 971  * @pre Create a media streamer handle by calling media_streamer_create().
 972  * @see #media_streamer_state_e
 973  */
 974 int media_streamer_get_state(media_streamer_h streamer, media_streamer_state_e *state);
 975
 976 /**
 977  * @brief Creates media streamer source node.
 978  * @since_tizen 3.0
 979  * @remarks The internet privilege(%http://tizen.org/privilege/internet) should be added if any URIs are used to play from network.
 980  *          The camera privilege(%http://tizen.org/privilege/camera) should be added if the source node handles the camera device.
 981  *          The recorder privilege(%http://tizen.org/privilege/recorder) should be added if the source node handles the recorder device.
 982  *          You can release source node using media_streamer_node_destroy().
 983  * @param[in]  type     Media streamer source node type
 984  * @param[out] src      Media streamer source node handle
 985  * @return @c 0 on success,
 986  *         otherwise a negative error value
 987  * @retval #MEDIA_STREAMER_ERROR_NONE Successful
 988  * @retval #MEDIA_STREAMER_ERROR_INVALID_PARAMETER Invalid parameter
 989  * @retval #MEDIA_STREAMER_ERROR_INVALID_OPERATION Invalid operation
 990  * @retval #MEDIA_STREAMER_ERROR_PERMISSION_DENIED Permission denied
 991  * @retval #MEDIA_STREAMER_ERROR_NOT_SUPPORTED Not supported
 992  * @see #media_streamer_node_src_type_e
 993  * @see media_streamer_node_destroy()
 994  */
 995 int media_streamer_node_create_src(media_streamer_node_src_type_e type, media_streamer_node_h *src);
 996
 997 /**
 998  * @brief Pushes packet into custom source node.
 999  * @details This function can be called only for #MEDIA_STREAMER_NODE_SRC_TYPE_CUSTOM.
1000  * @since_tizen 3.0
1001  * @param[in] src       Media streamer source node handle
1002  * @param[in] packet    Media packet handle
1003  * @return @c 0 on success,
1004  *         otherwise a negative error value
1005  * @retval #MEDIA_STREAMER_ERROR_NONE Successful
1006  * @retval #MEDIA_STREAMER_ERROR_INVALID_PARAMETER Invalid parameter
1007  * @retval #MEDIA_STREAMER_ERROR_INVALID_OPERATION Invalid operation
1008  * @pre Create a source node handle by calling media_streamer_node_create_src().
1009  * @pre The media streamer state must be set to #MEDIA_STREAMER_STATE_IDLE at least.
1010  * @see #media_packet_h
1011  */
1012 int media_streamer_node_push_packet(media_streamer_node_h src, media_packet_h packet);
1013
1014 /**
1015  * @brief Creates media streamer sink node.
1016  * @since_tizen 3.0
1017  * @remarks The internet privilege(%http://tizen.org/privilege/internet) should be added if any URIs are used to transmit the output data.
1018  *          You can release @a sink node using media_streamer_node_destroy()
1019  * @remarks If @a type is #MEDIA_STREAMER_NODE_SINK_TYPE_ADAPTIVE, the HTTP server will be started and the server will be able to transmit the output data to the other device.
1020  *          The application must have an authentication responsibility between a server and client because the data transmission is not secure.
1021  * @param[in]  type     Type of sink node to be created
1022  * @param[out] sink     Media streamer sink node handle
1023  * @return @c 0 on success,
1024  *         otherwise a negative error value
1025  * @retval #MEDIA_STREAMER_ERROR_NONE Successful
1026  * @retval #MEDIA_STREAMER_ERROR_INVALID_PARAMETER Invalid parameter
1027  * @retval #MEDIA_STREAMER_ERROR_INVALID_OPERATION Invalid operation
1028  * @retval #MEDIA_STREAMER_ERROR_PERMISSION_DENIED Permission denied
1029  * @retval #MEDIA_STREAMER_ERROR_NOT_SUPPORTED Not supported
1030  * @see #media_streamer_node_sink_type_e
1031  * @see media_streamer_node_destroy()
1032  */
1033 int media_streamer_node_create_sink(media_streamer_node_sink_type_e type, media_streamer_node_h *sink);
1034
1035 /**
1036  * @brief Pulls packet from custom sink node.
1037  * @details This function can be called only for #MEDIA_STREAMER_NODE_SINK_TYPE_CUSTOM
1038  * @since_tizen 3.0
1039  * @param[in] sink      Media streamer sink node handle
1040  * @param[out] packet   Media packet handle
1041  * @return @c 0 on success,
1042  *         otherwise a negative error value
1043  * @retval #MEDIA_STREAMER_ERROR_NONE Successful
1044  * @retval #MEDIA_STREAMER_ERROR_INVALID_STATE Invalid state
1045  * @retval #MEDIA_STREAMER_ERROR_INVALID_PARAMETER Invalid parameter
1046  * @retval #MEDIA_STREAMER_ERROR_INVALID_OPERATION Invalid operation
1047  * @pre Create a sink node handle by calling media_streamer_node_create_sink().
1048  * @pre Set media_streamer_sink_data_ready_cb by calling media_streamer_sink_set_data_ready_cb().
1049  * @see #media_packet_h
1050  * @see media_streamer_node_create_sink()
1051  */
1052 int media_streamer_node_pull_packet(media_streamer_node_h sink, media_packet_h *packet);
1053
1054 /**
1055  * @brief Creates media streamer node except #MEDIA_STREAMER_NODE_TYPE_SRC and #MEDIA_STREAMER_NODE_TYPE_SINK.
1056  * @details Creates node specific @a type with specific format of input
1057  *          and output data.
1058  * @since_tizen 3.0
1059  * @remarks The node type should not be #MEDIA_STREAMER_NODE_TYPE_SRC and #MEDIA_STREAMER_NODE_TYPE_SINK.
1060  *          To create source / sink type node, media_streamer_node_create_src() / media_streamer_node_create_sink() should be called.
1061  *          The internet privilege (%http://tizen.org/privilege/internet) should be added if #MEDIA_STREAMER_NODE_TYPE_WEBRTC is set.
1062  *          You can release @a node using media_streamer_node_destroy().
1063  * @param[in]  type      Created node type
1064  * @param[in]  in_fmt    Media format handle for input data
1065  * @param[in]  out_fmt   Media format handle for output data
1066  * @param[out] node      Media streamer node handle to be created
1067  * @return @c 0 on success,
1068  *         otherwise a negative error value
1069  * @retval #MEDIA_STREAMER_ERROR_NONE Successful
1070  * @retval #MEDIA_STREAMER_ERROR_INVALID_PARAMETER Invalid parameter
1071  * @retval #MEDIA_STREAMER_ERROR_INVALID_OPERATION Invalid operation
1072  * @retval #MEDIA_STREAMER_ERROR_PERMISSION_DENIED Permission denied
1073  * @retval #MEDIA_STREAMER_ERROR_NOT_SUPPORTED Not supported
1074  * @see #media_streamer_node_type_e
1075  * @see #media_format_h
1076  * @see media_streamer_node_destroy()
1077  */
1078 int media_streamer_node_create(media_streamer_node_type_e type, media_format_h in_fmt,
1079                                         media_format_h out_fmt, media_streamer_node_h *node);
1080
1081 /**
1082  * @brief Adds node to media streamer.
1083  * @since_tizen 3.0
1084  * @param[in] streamer    Media streamer handle
1085  * @param[in] node        Media streamer node handle to be added
1086  * @return @c 0 on success,
1087  *         otherwise a negative error value
1088  * @retval #MEDIA_STREAMER_ERROR_NONE Successful
1089  * @retval #MEDIA_STREAMER_ERROR_INVALID_STATE Invalid state
1090  * @retval #MEDIA_STREAMER_ERROR_INVALID_PARAMETER Invalid parameter
1091  * @retval #MEDIA_STREAMER_ERROR_INVALID_OPERATION Invalid operation
1092  * @pre Create media streamer handle by calling media_streamer_create().
1093  * @pre Create node handle by calling media_streamer_node_create().
1094  * @see media_streamer_create()
1095  * @see media_streamer_node_create()
1096  * @see media_streamer_node_create_src()
1097  * @see media_streamer_node_create_sink()
1098  */
1099 int media_streamer_node_add(media_streamer_h streamer, media_streamer_node_h node);
1100
1101 /**
1102  * @brief Destroys media streamer node.
1103  * @since_tizen 3.0
1104  * @param[in] node        Media streamer node handle
1105  * @return @c 0 on success,
1106  *         otherwise a negative error value
1107  * @retval #MEDIA_STREAMER_ERROR_NONE Successful
1108  * @retval #MEDIA_STREAMER_ERROR_INVALID_STATE Invalid state
1109  * @retval #MEDIA_STREAMER_ERROR_INVALID_PARAMETER Invalid parameter
1110  * @retval #MEDIA_STREAMER_ERROR_INVALID_OPERATION Invalid operation
1111  * @pre Create node handle by calling media_streamer_node_create().
1112  * @pre If the node was added to media streamer, it has to be removed by calling media_streamer_node_remove().
1113  * @see media_streamer_node_create()
1114  * @see media_streamer_node_create_src()
1115  * @see media_streamer_node_create_sink()
1116  * @see media_streamer_node_remove()
1117  */
1118 int media_streamer_node_destroy(media_streamer_node_h node);
1119
1120 /**
1121  * @brief Removes media streamer node from streamer.
1122  * @since_tizen 3.0
1123  * @remarks To remove node without error posting, the state of streamer should be #MEDIA_STREAMER_STATE_IDLE.
1124  *          If the node is linked, it will be unlinked before removing.
1125  * @param[in] streamer    Media streamer handle
1126  * @param[in] node        Media streamer node handle
1127  * @return @c 0 on success,
1128  *         otherwise a negative error value
1129  * @retval #MEDIA_STREAMER_ERROR_NONE Successful
1130  * @retval #MEDIA_STREAMER_ERROR_INVALID_STATE Invalid state
1131  * @retval #MEDIA_STREAMER_ERROR_INVALID_PARAMETER Invalid parameter
1132  * @retval #MEDIA_STREAMER_ERROR_INVALID_OPERATION Invalid operation
1133  * @pre Add node to streamer by calling media_streamer_node_add().
1134  * @see media_streamer_node_add()
1135  */
1136 int media_streamer_node_remove(media_streamer_h streamer, media_streamer_node_h node);
1137
1138 /**
1139  * @brief Links two media streamer nodes.
1140  * @since_tizen 3.0
1141  * @remarks Pads are node's input and output, where you can connect other nodes.
1142  *          (@a node1) - (@a node2)
1143  *          @a node1 and @a node2 are determined relatively.
1144  *          In case of (A)-(B)-(C),
1145  *          (B) can be @a node2 with (A) or (B) can be @a node1 with (C).
1146  *          However, source type node is always @a node1 and sink type node is always @a node2.
1147  *          (A) is source type node and it should be @a node1.
1148  *          (C) is sink type node and it should be @a node2.
1149  * @param[in] node1     Media streamer node handle which has the @a src_pad_name pad
1150  * @param[in] src_pad_name  The name of the source pad of the @a node1
1151  * @param[in] node2     Media streamer node handle which has the @a sink_pad_name pad
1152  * @param[in] sink_pad_name The name of the sink pad of the @a node2
1153  * @return @c 0 on success,
1154  *         otherwise a negative error value
1155  * @retval #MEDIA_STREAMER_ERROR_NONE Successful
1156  * @retval #MEDIA_STREAMER_ERROR_INVALID_STATE Invalid state
1157  * @retval #MEDIA_STREAMER_ERROR_INVALID_PARAMETER Invalid parameter
1158  * @retval #MEDIA_STREAMER_ERROR_INVALID_OPERATION Invalid operation
1159  * @pre Create node handles by calling media_streamer_node_create(), media_streamer_node_create_src(), or media_streamer_node_create_sink().
1160  *      And add the nodes into streamer by calling media_streamer_node_add().
1161  * @see media_streamer_node_create()
1162  * @see media_streamer_node_create_src()
1163  * @see media_streamer_node_create_sink()
1164  * @see media_streamer_node_add()
1165  */
1166 int media_streamer_node_link(media_streamer_node_h node1, const char *src_pad_name,
1167                                         media_streamer_node_h node2, const char *sink_pad_name);
1168
1169 /**
1170  * @brief Sets media format for pad of media streamer node.
1171  * @since_tizen 3.0
1172  * @param[in] node        Media streamer node handle
1173  * @param[in] pad_name    Pad name
1174  * @param[in] fmt         Media format handle
1175  * @return @c 0 on success,
1176  *         otherwise a negative error value
1177  * @retval #MEDIA_STREAMER_ERROR_NONE Successful
1178  * @retval #MEDIA_STREAMER_ERROR_INVALID_STATE Invalid state
1179  * @retval #MEDIA_STREAMER_ERROR_INVALID_PARAMETER Invalid parameter
1180  * @retval #MEDIA_STREAMER_ERROR_INVALID_OPERATION Invalid operation
1181  * @pre Create a node handle by calling media_streamer_node_create(), media_streamer_node_create_src(), or media_streamer_node_create_sink().
1182  * @pre Get pad name by calling media_streamer_node_get_pad_name().
1183  * @see #media_format_h
1184  */
1185 int media_streamer_node_set_pad_format(media_streamer_node_h node, const char *pad_name, media_format_h fmt);
1186
1187 /**
1188  * @brief Gets media format for pad of media streamer node.
1189  * @since_tizen 3.0
1190  * @param[in] node        Media streamer node handle
1191  * @param[in] pad_name    Pad name
1192  * @param[out] fmt        Media format handle
1193  * @return @c 0 on success,
1194  *         otherwise a negative error value
1195  * @retval #MEDIA_STREAMER_ERROR_NONE Successful
1196  * @retval #MEDIA_STREAMER_ERROR_INVALID_STATE Invalid state
1197  * @retval #MEDIA_STREAMER_ERROR_INVALID_PARAMETER Invalid parameter
1198  * @retval #MEDIA_STREAMER_ERROR_INVALID_OPERATION Invalid operation
1199  * @pre Create a node handle by calling media_streamer_node_create(), media_streamer_node_create_src(), or media_streamer_node_create_sink().
1200  * @pre Get pad name by calling media_streamer_node_get_pad_name().
1201  * @see #media_format_h
1202  */
1203 int media_streamer_node_get_pad_format(media_streamer_node_h node, const char *pad_name, media_format_h *fmt);
1204
1205 /**
1206  * @brief Gets name of node pads.
1207  * @since_tizen 3.0
1208  * @remarks After using the src_pad_name and sink_pad_name, it has to be freed.
1209  *          src_pad_name or sink_pad_name can be null according to the node type.
1210  *          In case of source type node, sink_pad_name will be null.
1211  *          In case of sink type node, src_pad_name will be null.
1212  * @param[in]  node            Media streamer node handle
1213  * @param[out] src_pad_name    Array of source pad name
1214  * @param[out] src_pad_num     The number of source pads
1215  * @param[out] sink_pad_name   Array of sink pad name
1216  * @param[out] sink_pad_num    The number of sink pads
1217  * @return @c 0 on success,
1218  *         otherwise a negative error value
1219  * @retval #MEDIA_STREAMER_ERROR_NONE Successful
1220  * @retval #MEDIA_STREAMER_ERROR_INVALID_PARAMETER Invalid parameter
1221  * @retval #MEDIA_STREAMER_ERROR_INVALID_OPERATION Invalid operation
1222  * @pre Create a node handle by calling media_streamer_node_create(), media_streamer_node_create_src(), or media_streamer_node_create_sink().
1223  * @see media_streamer_node_create()
1224  * @see media_streamer_node_create_src()
1225  * @see media_streamer_node_create_sink()
1226  */
1227 int media_streamer_node_get_pad_name(media_streamer_node_h node, char ***src_pad_name,
1228                                         int *src_pad_num, char ***sink_pad_name, int *sink_pad_num);
1229
1230 /**
1231  * @brief Sets parameters of node.
1232  * @details Many parameters can be set at one time all together by using bundle.
1233  * @since_tizen 3.0
1234  * @remarks The mediastorage privilege(%http://tizen.org/privilege/mediastorage) should be added if any video/audio files are written in the internal storage devices.
1235  *          The externalstorage privilege(%http://tizen.org/privilege/externalstorage) should be added if any video/audio files are written in the external storage devices.
1236  * @param[in] node        Media streamer node handle
1237  * @param[in] param_list  Key value array of media streamer node parameters
1238  * @return @c 0 on success,
1239  *         otherwise a negative error value
1240  * @retval #MEDIA_STREAMER_ERROR_NONE Successful
1241  * @retval #MEDIA_STREAMER_ERROR_INVALID_STATE Invalid state
1242  * @retval #MEDIA_STREAMER_ERROR_INVALID_PARAMETER Invalid parameter
1243  * @retval #MEDIA_STREAMER_ERROR_INVALID_OPERATION Invalid operation
1244  * @retval #MEDIA_STREAMER_ERROR_PERMISSION_DENIED Permission denied
1245  * @pre Create a node handle by calling media_streamer_node_create(), media_streamer_node_create_src(), or media_streamer_node_create_sink().
1246  * @pre Get param list to set by calling media_streamer_node_get_params().
1247  * @see media_streamer_node_create()
1248  * @see media_streamer_node_create_src()
1249  * @see media_streamer_node_create_sink()
1250  * @see media_streamer_node_get_params()
1251  */
1252 int media_streamer_node_set_params(media_streamer_node_h node, bundle *param_list);
1253 /**
1254  * @brief Gets node parameter list.
1255  * @since_tizen 3.0
1256  * @remarks After using param_list, it has to be freed by calling bundle_free() in bundle.h
1257  *          Refer to the "Parameter information of node" in this file to get info.
1258  * @param[in]  node         Media streamer node handle
1259  * @param[out] param_list   Key value array of media streamer node parameters
1260  * @return @c 0 on success,
1261  *         otherwise a negative error value
1262  * @retval #MEDIA_STREAMER_ERROR_NONE Successful
1263  * @retval #MEDIA_STREAMER_ERROR_INVALID_STATE Invalid state
1264  * @retval #MEDIA_STREAMER_ERROR_INVALID_PARAMETER Invalid parameter
1265  * @retval #MEDIA_STREAMER_ERROR_INVALID_OPERATION Invalid operation
1266  * @pre Create a node handle by calling media_streamer_node_create(), media_streamer_node_create_src(), or media_streamer_node_create_sink().
1267  * @post Set params which are needed to set by calling media_streamer_node_set_params() or media_streamer_node_set_param().
1268  * @see media_streamer_node_create()
1269  * @see media_streamer_node_create_src()
1270  * @see media_streamer_node_create_sink()
1271  * @see media_streamer_node_set_params()
1272  * @see media_streamer_node_set_param()
1273  */
1274 int media_streamer_node_get_params(media_streamer_node_h node, bundle **param_list);
1275
1276 /**
1277  * @brief Sets single parameter of node.
1278  * @details Sets parameter one by one without creating param bundle.
1279  * @since_tizen 3.0
1280  * @remarks The mediastorage privilege(%http://tizen.org/privilege/mediastorage) should be added if any video/audio files are written in the internal storage devices.
1281  *          The externalstorage privilege(%http://tizen.org/privilege/externalstorage) should be added if any video/audio files are written in the external storage devices.
1282  * @param[in] node        Media streamer node handle
1283  * @param[in] param_name  Param name of node
1284  * @param[in] param_value Param value of node
1285  * @return @c 0 on success,
1286  *         otherwise a negative error value
1287  * @retval #MEDIA_STREAMER_ERROR_NONE Successful
1288  * @retval #MEDIA_STREAMER_ERROR_INVALID_STATE Invalid state
1289  * @retval #MEDIA_STREAMER_ERROR_INVALID_PARAMETER Invalid parameter
1290  * @retval #MEDIA_STREAMER_ERROR_INVALID_OPERATION Invalid operation
1291  * @retval #MEDIA_STREAMER_ERROR_PERMISSION_DENIED Permission denied
1292  * @pre Create a node handle by calling media_streamer_node_create(), media_streamer_node_create_src(), or media_streamer_node_create_sink().
1293  * @pre Get param list to set by calling media_streamer_node_get_params().
1294  * @see media_streamer_node_create()
1295  * @see media_streamer_node_create_src()
1296  * @see media_streamer_node_create_sink()
1297  * @see media_streamer_node_get_params()
1298  * @see media_streamer_node_get_param()
1299  */
1300 int media_streamer_node_set_param(media_streamer_node_h node,
1301                                         const char *param_name, const char *param_value);
1302
1303 /**
1304  * @brief Gets value of parameter.
1305  * @details Gets parameter one by one without creating param bundle.
1306  * @since_tizen 3.0
1307  * @param[in] node         Media streamer node handle
1308  * @param[in] param_name   Param name of node
1309  * @param[out] param_value Param value of node
1310  * @return @c 0 on success,
1311  *         otherwise a negative error value
1312  * @retval #MEDIA_STREAMER_ERROR_NONE Successful
1313  * @retval #MEDIA_STREAMER_ERROR_INVALID_STATE Invalid state
1314  * @retval #MEDIA_STREAMER_ERROR_INVALID_PARAMETER Invalid parameter
1315  * @retval #MEDIA_STREAMER_ERROR_INVALID_OPERATION Invalid operation
1316  * @pre Create a node handle by calling media_streamer_node_create(), media_streamer_node_create_src(), or media_streamer_node_create_sink().
1317  * @pre Get param list to know the param name by calling media_streamer_node_get_params().
1318  * @see media_streamer_node_create()
1319  * @see media_streamer_node_create_src()
1320  * @see media_streamer_node_create_sink()
1321  * @see media_streamer_node_get_params()
1322  * @see media_streamer_node_set_param()
1323  */
1324 int media_streamer_node_get_param(media_streamer_node_h node,
1325                                         const char *param_name, char **param_value);
1326
1327 /**
1328  * @brief Sets a callback function to be invoked when a source pad of @a node is ready to give decoded data.
1329  * @since_tizen 6.0
1330  * @remarks The available type of @a node for this function is #MEDIA_STREAMER_NODE_TYPE_WEBRTC.
1331  * @param[in] node      Media streamer node handle
1332  * @param[in] callback  The decoded ready callback function to register
1333  * @param[in] user_data The user data to be passed to the callback function
1334  * @return @c 0 on success,
1335  *         otherwise a negative error value
1336  * @retval #MEDIA_STREAMER_ERROR_NONE Successful
1337  * @retval #MEDIA_STREAMER_ERROR_INVALID_PARAMETER Invalid parameter
1338  * @retval #MEDIA_STREAMER_ERROR_INVALID_OPERATION Invalid operation
1339  * @pre Create a media streamer node handle by calling media_streamer_node_create().
1340  * @post media_streamer_node_decoded_ready_cb() will be invoked.
1341  * @see media_streamer_node_unset_decoded_ready_cb()
1342  * @see media_streamer_node_decoded_ready_cb()
1343  */
1344 int media_streamer_node_set_decoded_ready_cb(media_streamer_node_h node, media_streamer_node_decoded_ready_cb callback, void *user_data);
1345
1346 /**
1347  * @brief Unsets the decoded ready callback function.
1348  * @since_tizen 6.0
1349  * @param[in] node    Media streamer node handle
1350  * @return @c 0 on success,
1351  *         otherwise a negative error value
1352  * @retval #MEDIA_STREAMER_ERROR_NONE Successful
1353  * @retval #MEDIA_STREAMER_ERROR_INVALID_PARAMETER Invalid parameter
1354  * @see media_streamer_node_set_decoded_ready_cb()
1355  */
1356 int media_streamer_node_unset_decoded_ready_cb(media_streamer_node_h node);
1357
1358 /**
1359  * @brief Sets a callback function to be invoked when WebRTC node needs to send a message to the remote peer of WebRTC connection.
1360  * @details This function can be called only for #MEDIA_STREAMER_NODE_TYPE_WEBRTC type node.
1361  * @since_tizen 6.0
1362  * @param[in] webrtc    Media streamer WebRTC node handle
1363  * @param[in] callback  The WebRTC message callback function to register
1364  * @param[in] user_data The user data to be passed to the callback function
1365  * @return @c 0 on success,
1366  *         otherwise a negative error value
1367  * @retval #MEDIA_STREAMER_ERROR_NONE Successful
1368  * @retval #MEDIA_STREAMER_ERROR_INVALID_PARAMETER Invalid parameter
1369  * @pre Create a media streamer WebRTC node handle by calling media_streamer_node_create().
1370  * @post media_streamer_webrtc_message_cb() will be invoked.
1371  * @see media_streamer_webrtc_node_unset_message_cb()
1372  * @see media_streamer_webrtc_message_cb()
1373  */
1374 int media_streamer_webrtc_node_set_message_cb(media_streamer_node_h webrtc, media_streamer_webrtc_message_cb callback, void *user_data);
1375
1376 /**
1377  * @brief Unsets the WebRTC message callback function.
1378  * @since_tizen 6.0
1379  * @param[in] webrtc    Media streamer WebRTC node handle
1380  * @return @c 0 on success,
1381  *         otherwise a negative error value
1382  * @retval #MEDIA_STREAMER_ERROR_NONE Successful
1383  * @retval #MEDIA_STREAMER_ERROR_INVALID_PARAMETER Invalid parameter
1384  * @see media_streamer_webrtc_node_set_message_cb()
1385  */
1386 int media_streamer_webrtc_node_unset_message_cb(media_streamer_node_h webrtc);
1387
1388 /**
1389  * @}
1390  */
1391
1392 #ifdef __cplusplus
1393 }
1394 #endif
1395
1396 #endif /* __TIZEN_MEDIA_STREAMER_H__ */