src/include/mm_player.h

   1 /*
   2  * libmm-player
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: JongHyuk Choi <jhchoi.choi@samsung.com>, YeJin Cho <cho.yejin@samsung.com>,
   7  * Seungbae Shin <seungbae.shin@samsung.com>, YoungHwan An <younghwan_.an@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 #ifndef __MM_PLAYER_H__
  24 #define __MM_PLAYER_H__
  25
  26
  27 /*===========================================================================================
  28 |                                                                                           |
  29 |  INCLUDE FILES                                        |
  30 |                                                                                           |
  31 ========================================================================================== */
  32
  33 #include <glib.h>
  34
  35 #include <mm_types.h>
  36 #include <mm_message.h>
  37 #include <media_packet.h>
  38
  39 #ifdef __cplusplus
  40         extern "C" {
  41 #endif
  42
  43 /**
  44         @addtogroup PLAYER
  45         @{
  46
  47         @par
  48         This part describes APIs used for playback of multimedia contents.
  49         All multimedia contents are created by a media player through handle of playback.
  50         In creating a player, it displays the player's status or information
  51         by registering callback function.
  52
  53         @par
  54         In case of streaming playback, network has to be opend by using datanetwork API.
  55         If proxy, cookies and the other attributes for streaming playback are needed,
  56         set those attributes using mm_player_set_attribute() before create player.
  57
  58         @par
  59         The subtitle for local video playback is supported. Set "subtitle_uri" attribute
  60         using mm_player_set_attribute() before the application creates the player.
  61         Then the application could receive MMMessageParamType which includes subtitle string and duration.
  62
  63         @par
  64         Player can have 5 states, and each state can be changed by calling
  65         described functions on "Figure1. State of Player".
  66
  67         @par
  68         @image html             player_state.jpg        "Figure1. State of Player"      width=12cm
  69         @image latex    player_state.jpg        "Figure1. State of Player"      width=12cm
  70
  71         @par
  72         Most of functions which change player state work as synchronous. But, mm_player_start() should be used
  73         asynchronously. Both mm_player_pause() and mm_player_resume() should also be used asynchronously
  74         in the case of streaming data.
  75         So, application have to confirm the result of those APIs through message callback function.
  76
  77         @par
  78         Note that "None" and Null" state could be reached from any state
  79         by calling mm_player_destroy() and mm_player_unrealize().
  80
  81         @par
  82         <div><table>
  83         <tr>
  84         <td><B>FUNCTION</B></td>
  85         <td><B>PRE-STATE</B></td>
  86         <td><B>POST-STATE</B></td>
  87         <td><B>SYNC TYPE</B></td>
  88         </tr>
  89         <tr>
  90         <td>mm_player_create()</td>
  91         <td>NONE</td>
  92         <td>NULL</td>
  93         <td>SYNC</td>
  94         </tr>
  95         <tr>
  96         <td>mm_player_destroy()</td>
  97         <td>NULL</td>
  98         <td>NONE</td>
  99         <td>SYNC</td>
 100         </tr>
 101         <tr>
 102         <td>mm_player_realize()</td>
 103         <td>NULL</td>
 104         <td>READY</td>
 105         <td>SYNC</td>
 106         </tr>
 107         <tr>
 108         <td>mm_player_unrealize()</td>
 109         <td>READY</td>
 110         <td>NULL</td>
 111         <td>SYNC</td>
 112         </tr>
 113         <tr>
 114         <td>mm_player_start()</td>
 115         <td>READY</td>
 116         <td>PLAYING</td>
 117         <td>ASYNC</td>
 118         </tr>
 119         <tr>
 120         <td>mm_player_stop()</td>
 121         <td>PLAYING</td>
 122         <td>READY</td>
 123         <td>SYNC</td>
 124         </tr>
 125         <tr>
 126         <td>mm_player_pause()</td>
 127         <td>PLAYING</td>
 128         <td>PAUSED</td>
 129         <td>ASYNC</td>
 130         </tr>
 131         <tr>
 132         <td>mm_player_resume()</td>
 133         <td>PAUSED</td>
 134         <td>PLAYING</td>
 135         <td>ASYNC</td>
 136         </tr>
 137         <tr>
 138         <td>mm_player_set_message_callback()</td>
 139         <td>N/A</td>
 140         <td>N/A</td>
 141         <td>SYNC</td>
 142         </tr>
 143         <tr>
 144         <td>mm_player_get_state()</td>
 145         <td>N/A</td>
 146         <td>N/A</td>
 147         <td>SYNC</td>
 148         </tr>
 149         <tr>
 150         <td>mm_player_set_volume()</td>
 151         <td>N/A</td>
 152         <td>N/A</td>
 153         <td>SYNC</td>
 154         </tr>
 155         <tr>
 156         <td>mm_player_get_volume()</td>
 157         <td>N/A</td>
 158         <td>N/A</td>
 159         <td>SYNC</td>
 160         </tr>
 161         <tr>
 162         <td>mm_player_set_position()</td>
 163         <td>N/A</td>
 164         <td>N/A</td>
 165         <td>SYNC</td>
 166         </tr>
 167         <tr>
 168         <td>mm_player_get_position()</td>
 169         <td>N/A</td>
 170         <td>N/A</td>
 171         <td>SYNC</td>
 172         </tr>
 173         <tr>
 174         <td>mm_player_get_attribute()</td>
 175         <td>N/A</td>
 176         <td>N/A</td>
 177         <td>SYNC</td>
 178         </tr>
 179         <tr>
 180         <td>mm_player_set_attribute()</td>
 181         <td>N/A</td>
 182         <td>N/A</td>
 183         <td>SYNC</td>
 184         </tr>
 185         </table></div>
 186
 187         @par
 188         Following are the attributes supported in player which may be set after initialization. \n
 189         Those are handled as a string.
 190
 191         @par
 192         <div><table>
 193         <tr>
 194         <td>PROPERTY</td>
 195         <td>TYPE</td>
 196         <td>VALID TYPE</td>
 197         </tr>
 198         <tr>
 199         <td>"profile_uri"</td>
 200         <td>string</td>
 201         <td>N/A</td>
 202         </tr>
 203         <tr>
 204         <td>"content_duration"</td>
 205         <td>int</td>
 206         <td>range</td>
 207         </tr>
 208         <tr>
 209         <td>"content_video_width"</td>
 210         <td>int</td>
 211         <td>range</td>
 212         </tr>
 213         <tr>
 214         <td>"content_video_height"</td>
 215         <td>int</td>
 216         <td>range</td>
 217         </tr>
 218         <tr>
 219         <td>"display_evas_do_scaling"</td>
 220         <td>int</td>
 221         <td>range</td>
 222         </tr>
 223         <tr>
 224         <td>"display_evas_surface_sink"</td>
 225         <td>string</td>
 226         <td>N/A</td>
 227         </tr>
 228         <tr>
 229         <td>"profile_user_param"</td>
 230         <td>data</td>
 231         <td>N/A</td>
 232         </tr>
 233         <tr>
 234         <td>"profile_play_count"</td>
 235         <td>int</td>
 236         <td>range</td>
 237         </tr>
 238         <tr>
 239         <td>"streaming_type"</td>
 240         <td>int</td>
 241         <td>range</td>
 242         </tr>
 243         <tr>
 244         <td>"streaming_udp_timeout"</td>
 245         <td>int</td>
 246         <td>range</td>
 247         </tr>
 248         <tr>
 249         <td>"streaming_user_agent"</td>
 250         <td>string</td>
 251         <td>N/A</td>
 252         </tr>
 253         <tr>
 254         <td>"streaming_wap_profile"</td>
 255         <td>string</td>
 256         <td>N/A</td>
 257         </tr>
 258         <tr>
 259         <td>"streaming_network_bandwidth"</td>
 260         <td>int</td>
 261         <td>range</td>
 262         </tr>
 263         <tr>
 264         <td>"streaming_cookie"</td>
 265         <td>string</td>
 266         <td>N/A</td>
 267         </tr>
 268         <tr>
 269         <td>"streaming_proxy_ip"</td>
 270         <td>string</td>
 271         <td>N/A</td>
 272         </tr>
 273         <tr>
 274         <td>"streaming_proxy_port"</td>
 275         <td>int</td>
 276         <td>range</td>
 277         </tr>
 278         <tr>
 279         <td>"streaming_timeout"</td>
 280         <td>int</td>
 281         <td>range</td>
 282         </tr>
 283         <tr>
 284         <td>"display_overlay"</td>
 285         <td>data</td>
 286         <td>N/A</td>
 287         </tr>
 288         <tr>
 289         <td>"display_rotation"</td>
 290         <td>int</td>
 291         <td>range</td>
 292         </tr>
 293         <tr>
 294         <td>"subtitle_uri"</td>
 295         <td>string</td>
 296         <td>N/A</td>
 297         </tr>
 298         </table></div>
 299
 300         @par
 301         Following attributes are supported for playing stream data. Those value can be readable only and valid after starting playback.\n
 302         Please use mm_fileinfo for local playback.
 303
 304         @par
 305         <div><table>
 306         <tr>
 307         <td>PROPERTY</td>
 308         <td>TYPE</td>
 309         <td>VALID TYPE</td>
 310         </tr>
 311         <tr>
 312         <td>"content_video_found"</td>
 313         <td>string</td>
 314         <td>N/A</td>
 315         </tr>
 316         <tr>
 317         <td>"content_video_codec"</td>
 318         <td>string</td>
 319         <td>N/A</td>
 320         </tr>
 321         <tr>
 322         <td>"content_video_track_num"</td>
 323         <td>int</td>
 324         <td>range</td>
 325         </tr>
 326         <tr>
 327         <td>"content_audio_found"</td>
 328         <td>string</td>
 329         <td>N/A</td>
 330         </tr>
 331         <tr>
 332         <td>"content_audio_codec"</td>
 333         <td>string</td>
 334         <td>N/A</td>
 335         </tr>
 336         <tr>
 337         <td>"content_audio_bitrate"</td>
 338         <td>int</td>
 339         <td>array</td>
 340         </tr>
 341         <tr>
 342         <td>"content_audio_channels"</td>
 343         <td>int</td>
 344         <td>range</td>
 345         </tr>
 346         <tr>
 347         <td>"content_audio_samplerate"</td>
 348         <td>int</td>
 349         <td>array</td>
 350         </tr>
 351         <tr>
 352         <td>"content_audio_track_num"</td>
 353         <td>int</td>
 354         <td>range</td>
 355         </tr>
 356         <tr>
 357         <td>"content_text_track_num"</td>
 358         <td>int</td>
 359         <td>range</td>
 360         </tr>
 361         <tr>
 362         <td>"tag_artist"</td>
 363         <td>string</td>
 364         <td>N/A</td>
 365         </tr>
 366         <tr>
 367         <td>"tag_title"</td>
 368         <td>string</td>
 369         <td>N/A</td>
 370         </tr>
 371         <tr>
 372         <td>"tag_album"</td>
 373         <td>string</td>
 374         <td>N/A</td>
 375         </tr>
 376         <tr>
 377         <td>"tag_genre"</td>
 378         <td>string</td>
 379         <td>N/A</td>
 380         </tr>
 381         <tr>
 382         <td>"tag_author"</td>
 383         <td>string</td>
 384         <td>N/A</td>
 385         </tr>
 386         <tr>
 387         <td>"tag_copyright"</td>
 388         <td>string</td>
 389         <td>N/A</td>
 390         </tr>
 391         <tr>
 392         <td>"tag_date"</td>
 393         <td>string</td>
 394         <td>N/A</td>
 395         </tr>
 396         <tr>
 397         <td>"tag_description"</td>
 398         <td>string</td>
 399         <td>N/A</td>
 400         </tr>
 401         <tr>
 402         <td>"tag_track_num"</td>
 403         <td>int</td>
 404         <td>range</td>
 405         </tr>
 406         </table></div>
 407
 408  */
 409
 410
 411 /*===========================================================================================
 412 |                                                                                           |
 413 |  GLOBAL DEFINITIONS AND DECLARATIONS                                        |
 414 |                                                                                           |
 415 ========================================================================================== */
 416
 417 /**
 418  * MM_PLAYER_URI:
 419  *
 420  * uri to play (string)
 421  *
 422  */
 423 #define MM_PLAYER_CONTENT_URI                                   "profile_uri"
 424 /**
 425  * MM_PLAYER_CONTENT_DURATION:
 426  *
 427  * get the duration (int) as millisecond, It's guaranteed after calling mm_player_start() or
 428  * receiving MM_MESSAGE_BEGIN_OF_STREAM.
 429  *
 430  */
 431 #define MM_PLAYER_CONTENT_DURATION                      "content_duration"
 432 /**
 433  * MM_PLAYER_VIDEO_ROTATION
 434  *
 435  * can change video angle (int)
 436  * @see MMDisplayRotationType
 437  */
 438 #define MM_PLAYER_VIDEO_ROTATION                                "display_rotation"
 439 /**
 440  * MM_PLAYER_VIDEO_WIDTH:
 441  *
 442  * get the video width (int), It's guaranteed after calling mm_player_start() or
 443  * receiving MM_MESSAGE_BEGIN_OF_STREAM.
 444  *
 445  */
 446 #define MM_PLAYER_VIDEO_WIDTH                           "content_video_width"
 447 /**
 448  * MM_PLAYER_VIDEO_HEIGHT:
 449  *
 450  * get the video height (int), It's guaranteed after calling mm_player_start() or
 451  * receiving MM_MESSAGE_BEGIN_OF_STREAM.
 452  *
 453  */
 454 #define MM_PLAYER_VIDEO_HEIGHT                          "content_video_height"
 455 /**
 456  * MM_PLAYER_VIDEO_EVAS_SURFACE_DO_SCALING:
 457  *
 458  * set whether or not to scale frames size for evas surface.
 459  * if TRUE, it scales down width, height size of frames with given size.
 460  * if FALSE, it does not scale down any frames.
 461  *
 462  */
 463 #define MM_PLAYER_VIDEO_EVAS_SURFACE_DO_SCALING         "display_evas_do_scaling"
 464 /**
 465  * MM_PLAYER_VIDEO_EVAS_SURFACE_SINK:
 466  *
 467  * get the video evas surface sink plugin name (string), It's guaranteed after calling mm_player_create()
 468  *
 469  */
 470 #define MM_PLAYER_VIDEO_EVAS_SURFACE_SINK               "display_evas_surface_sink"
 471 /**
 472  * MM_PLAYER_MEM_SRC:
 473  *
 474  * set memory pointer to play (data)
 475  *
 476  */
 477 #define MM_PLAYER_MEMORY_SRC                                    "profile_user_param"
 478 /**
 479  * MM_PLAYER_PLAYBACK_COUNT
 480  *
 481  * can set playback count (int), Default value is 1 and -1 is for infinity playing until releasing it.
 482  *
 483  */
 484 #define MM_PLAYER_PLAYBACK_COUNT                                "profile_play_count"
 485 /**
 486  * MM_PLAYER_SUBTITLE_URI
 487  *
 488  * set the subtitle path (string)
 489  */
 490 #define MM_PLAYER_SUBTITLE_URI                                  "subtitle_uri"
 491 /**
 492  * MM_PLAYER_STREAMING_TYPE
 493  *
 494  * set the streaming type (int)
 495  * @see MMStreamingType
 496  */
 497 #define MM_PLAYER_STREAMING_TYPE                                "streaming_type"
 498 /**
 499  * MM_PLAYER_STREAMING_UDP_TIMEOUT
 500  *
 501  * set the streaming udp timeout(int)
 502  */
 503 #define MM_PLAYER_STREAMING_UDP_TIMEOUT         "streaming_udp_timeout"
 504 /**
 505  * MM_PLAYER_STREAMING_USER_AGENT
 506  *
 507  * set the streaming user agent (string)
 508  */
 509 #define MM_PLAYER_STREAMING_USER_AGENT          "streaming_user_agent"
 510 /**
 511  * MM_PLAYER_STREAMING_WAP_PROFILE
 512  *
 513  * set the streaming wap profile (int)
 514  */
 515 #define MM_PLAYER_STREAMING_WAP_PROFILE         "streaming_wap_profile"
 516 /**
 517  * MM_PLAYER_STREAMING_NET_BANDWIDTH
 518  *
 519  * set the streaming network bandwidth (int)
 520  */
 521 #define MM_PLAYER_STREAMING_NET_BANDWIDTH       "streaming_network_bandwidth"
 522 /**
 523  * MM_PLAYER_STREAMING_COOKIE
 524  *
 525  * set the streaming cookie (int)
 526  */
 527 #define MM_PLAYER_STREAMING_COOKIE                      "streaming_cookie"
 528 /**
 529  * MM_PLAYER_STREAMING_PROXY_IP
 530  *
 531  * set the streaming proxy ip (string)
 532  */
 533 #define MM_PLAYER_STREAMING_PROXY_IP                    "streaming_proxy_ip"
 534 /**
 535  * MM_PLAYER_STREAMING_PROXY_PORT
 536  *
 537  * set the streaming proxy port (int)
 538  */
 539 #define MM_PLAYER_STREAMING_PROXY_PORT          "streaming_proxy_port"
 540 /**
 541  * MM_PLAYER_STREAMING_TIMEOUT
 542  *
 543  * set the streaming timeout (int)
 544  */
 545 #define MM_PLAYER_STREAMING_TIMEOUT                     "streaming_timeout"
 546 /**
 547  * MM_PLAYER_VIDEO_CODEC
 548  *
 549  * codec the video data is stored in (string)
 550  */
 551 #define MM_PLAYER_VIDEO_CODEC                           "content_video_codec"
 552 /**
 553  * MM_PLAYER_VIDEO_TRACK_NUM
 554  *
 555  * track number inside a collection  (int)
 556  */
 557 #define MM_PLAYER_VIDEO_TRACK_NUM                       "content_video_track_num"
 558 /**
 559  * MM_PLAYER_AUDIO_CODEC
 560  *
 561  * codec the audio data is stored in (string)
 562  */
 563 #define MM_PLAYER_AUDIO_CODEC                           "content_audio_codec"
 564 /**
 565  * MM_PLAYER_AUDIO_BITRATE
 566  *
 567  * set the streaming proxy port (int)
 568  */
 569 #define MM_PLAYER_AUDIO_BITRATE                         "content_audio_bitrate"
 570 /**
 571  * MM_PLAYER_AUDIO_CHANNEL
 572  *
 573  * the number of audio channel (int)
 574  */
 575 #define MM_PLAYER_AUDIO_CHANNEL                         "content_audio_channels"
 576 /**
 577  * MM_PLAYER_AUDIO_SAMPLERATE
 578  *
 579  * audio samplerate  (int)
 580  */
 581 #define MM_PLAYER_AUDIO_SAMPLERATE                      "content_audio_samplerate"
 582 /**
 583  * MM_PLAYER_AUDIO_TRACK_NUM
 584  *
 585  * track number inside a collection (int)
 586  */
 587 #define MM_PLAYER_AUDIO_TRACK_NUM                       "content_audio_track_num"
 588 /**
 589  * MM_PLAYER_TEXT_TRACK_NUM
 590  *
 591  * track number inside a collection (int)
 592  */
 593 #define MM_PLAYER_TEXT_TRACK_NUM                        "content_text_track_num"
 594 /**
 595  * MM_PLAYER_TAG_ARTIST
 596  *
 597  * person(s) responsible for the recording (string)
 598  */
 599 #define MM_PLAYER_TAG_ARTIST                                    "tag_artist"
 600 /**
 601  * MM_PLAYER_TAG_ARTIST
 602  *
 603  * title (string)
 604  */
 605 #define MM_PLAYER_TAG_TITLE                                     "tag_title"
 606 /**
 607  * MM_PLAYER_TAG_ARTIST
 608  *
 609  * album containing this data (string)
 610  */
 611 #define MM_PLAYER_TAG_ALBUM                                     "tag_album"
 612 /**
 613  * MM_PLAYER_TAG_ARTIST
 614  *
 615  * genre this data belongs to (string)
 616  */
 617 #define MM_PLAYER_TAG_GENRE                                     "tag_genre"
 618 /**
 619  * MM_PLAYER_TAG_ARTIST
 620  *
 621  * author (string)
 622  */
 623 #define MM_PLAYER_TAG_AUTHOUR                           "tag_author"
 624 /**
 625  * MM_PLAYER_TAG_ARTIST
 626  *
 627  * copyright notice of the data (string)
 628  */
 629 #define MM_PLAYER_TAG_COPYRIGHT                         "tag_copyright"
 630 /**
 631  * MM_PLAYER_TAG_ARTIST
 632  *
 633  * date the data was created (string)
 634  */
 635 #define MM_PLAYER_TAG_DATE                                      "tag_date"
 636 /**
 637  * MM_PLAYER_TAG_ARTIST
 638  *
 639  * short text describing the content of the data (string)
 640  */
 641 #define MM_PLAYER_TAG_DESCRIPRION                               "tag_description"
 642 /**
 643  * MM_PLAYER_TAG_ARTIST
 644  *
 645  * track number inside a collection (int)
 646  */
 647 #define MM_PLAYER_TAG_TRACK_NUM                         "tag_track_num"
 648 /**
 649  * MM_PLAYER_PD_MODE
 650  *
 651  * progressive download mode (int)
 652  */
 653 #define MM_PLAYER_PD_MODE                                               "pd_mode"
 654
 655 #define BUFFER_MAX_PLANE_NUM (4)
 656
 657 typedef struct {
 658         MMPixelFormatType format;                       /**< image format */
 659         int width;                                              /**< width of video buffer */
 660         int height;                                             /**< height of video buffer */
 661         unsigned int timestamp;                         /**< timestamp of stream buffer (msec)*/
 662         unsigned int length_total;                      /**< total length of stream buffer (in byte)*/
 663         void *data[BUFFER_MAX_PLANE_NUM];
 664         void *bo[BUFFER_MAX_PLANE_NUM];  /**< TBM buffer object */
 665         void *internal_buffer;                          /**< Internal buffer pointer */
 666         int stride[BUFFER_MAX_PLANE_NUM];               /**< stride of plane */
 667         int elevation[BUFFER_MAX_PLANE_NUM];    /**< elevation of plane */
 668 }MMPlayerVideoStreamDataType;
 669
 670 /**
 671  * Enumerations of player state.
 672  */
 673 typedef enum {
 674         MM_PLAYER_STATE_NULL,                           /**< Player is created, but not realized yet */
 675         MM_PLAYER_STATE_READY,                          /**< Player is ready to play media */
 676         MM_PLAYER_STATE_PLAYING,                        /**< Player is now playing media */
 677         MM_PLAYER_STATE_PAUSED,                         /**< Player is paused while playing media */
 678         MM_PLAYER_STATE_NONE,                           /**< Player is not created yet */
 679         MM_PLAYER_STATE_NUM,                            /**< Number of player states */
 680 } MMPlayerStateType;
 681
 682 /**
 683  * Enumerations of position formats.
 684  * Used while invoking mm_player_get_position/mm_player_set_position APIs
 685  */
 686 typedef enum {
 687         MM_PLAYER_POS_FORMAT_TIME,                      /**< Format for time based */
 688         MM_PLAYER_POS_FORMAT_PERCENT,                   /**< Format for percentage */
 689         MM_PLAYER_POS_FORMAT_NUM,                       /**< Number of position formats */
 690 } MMPlayerPosFormatType;
 691
 692 /**
 693  * Enumeration for attribute values types.
 694  */
 695 typedef enum {
 696  MM_PLAYER_ATTRS_TYPE_INVALID = -1,        /**< Type is invalid */
 697  MM_PLAYER_ATTRS_TYPE_INT,                 /**< Integer type */
 698  MM_PLAYER_ATTRS_TYPE_DOUBLE,              /**< Double type */
 699  MM_PLAYER_ATTRS_TYPE_STRING,              /**< UTF-8 String type */
 700  MM_PLAYER_ATTRS_TYPE_DATA,                /**< Pointer type */
 701  MM_PLAYER_ATTRS_TYPE_ARRAY,               /**< Array type */
 702  MM_PLAYER_ATTRS_TYPE_RANGE,               /**< Range type */
 703  MM_PLAYER_ATTRS_TYPE_NUM,                 /**< Number of attribute type */
 704 } MMPlayerAttrsType;
 705
 706 /**
 707  * Enumeration for attribute validation type.
 708  */
 709 typedef enum {
 710  MM_PLAYER_ATTRS_VALID_TYPE_INVALID = -1,               /**< Invalid validation type */
 711  MM_PLAYER_ATTRS_VALID_TYPE_NONE,                               /**< Do not check validity */
 712  MM_PLAYER_ATTRS_VALID_TYPE_INT_ARRAY,          /**< validity checking type of integer array */
 713  MM_PLAYER_ATTRS_VALID_TYPE_INT_RANGE,          /**< validity checking type of integer range */
 714  MM_PLAYER_ATTRS_VALID_TYPE_DOUBLE_ARRAY,               /**< validity checking type of double array */
 715  MM_PLAYER_ATTRS_VALID_TYPE_DOUBLE_RANGE,       /**< validity checking type of double range */
 716 } MMPlayerAttrsValidType;
 717
 718 /**
 719  * Enumeration for attribute access flag.
 720  */
 721 typedef enum {
 722  MM_PLAYER_ATTRS_FLAG_NONE = 0,                                 /**< None flag is set */
 723  MM_PLAYER_ATTRS_FLAG_READABLE = 1 << 0,                        /**< Readable */
 724  MM_PLAYER_ATTRS_FLAG_WRITABLE = 1 << 1,                        /**< Writable */
 725  MM_PLAYER_ATTRS_FLAG_MODIFIED = 1 << 2,                        /**< Modified */
 726
 727  MM_PLAYER_ATTRS_FLAG_RW = MM_PLAYER_ATTRS_FLAG_READABLE | MM_PLAYER_ATTRS_FLAG_WRITABLE, /**< Readable and Writable */
 728 } MMPlayerAttrsFlag;
 729
 730 /**
 731  * Enumeration for progressive download
 732  */
 733 typedef enum {
 734         MM_PLAYER_PD_MODE_NONE,
 735         MM_PLAYER_PD_MODE_URI,
 736         MM_PLAYER_PD_MODE_FILE  // not tested yet, because of no fixed scenario
 737 }MMPlayerPDMode;
 738
 739 /**
 740  * Enumeration of track types
 741  */
 742 typedef enum {
 743         MM_PLAYER_TRACK_TYPE_AUDIO = 0,
 744         MM_PLAYER_TRACK_TYPE_VIDEO,
 745         MM_PLAYER_TRACK_TYPE_TEXT,
 746         MM_PLAYER_TRACK_TYPE_MAX
 747 }MMPlayerTrackType;
 748
 749 /**
 750  * Enumeration of runtime buffering mode
 751  */
 752 typedef enum {
 753         MM_PLAYER_BUFFERING_MODE_ADAPTIVE = 0,  /**< default, If buffering is occurred, player will consider the bandwidth to adjust buffer setting. */
 754         MM_PLAYER_BUFFERING_MODE_FIXED,                 /**< player will set buffer size with this fixed size value. */
 755         MM_PLAYER_BUFFERING_MODE_SLINK,                 /**< If buffering is occurred, player will adjust buffer setting and no more buffering will be occurred again. */
 756         MM_PLAYER_BUFFERING_MODE_MAX = MM_PLAYER_BUFFERING_MODE_SLINK,
 757 }MMPlayerBufferingMode;
 758
 759 /**
 760  * Enumeration of audio channel for video share
 761  */
 762 typedef enum
 763 {
 764         MM_PLAYER_AUDIO_CH_MONO_LEFT = 0,
 765         MM_PLAYER_AUDIO_CH_MONO_RIGHT,
 766         MM_PLAYER_AUDIO_CH_STEREO,
 767 } MMPlayerAudioChannel;
 768
 769 typedef enum
 770 {
 771         MM_PLAYER_SOUND_RESOURCE_PRELISTENING_RINGTONE = 0,
 772         MM_PLAYER_SOUND_RESOURCE_PRELISTENING_NOTIFICATION,
 773         MM_PLAYER_SOUND_RESOURCE_PRELISTENING_ALARM,
 774         MM_PLAYER_SOUND_RESOURCE_PRELISTENING_MEDIA,
 775 } MMPlayerSoundResource;
 776
 777 typedef enum
 778 {
 779         MM_PLAYER_FOCUS_CHANGED_COMPLETED = 0,
 780         MM_PLAYER_FOCUS_CHANGED_BY_MEDIA,
 781         MM_PLAYER_FOCUS_CHANGED_BY_CALL,
 782         MM_PLAYER_FOCUS_CHANGED_BY_EARJACK_UNPLUG,
 783         MM_PLAYER_FOCUS_CHANGED_BY_RESOURCE_CONFLICT,
 784         MM_PLAYER_FOCUS_CHANGED_BY_ALARM,
 785         MM_PLAYER_FOCUS_CHANGED_BY_EMERGENCY,
 786         MM_PLAYER_FOCUS_CHANGED_BY_NOTIFICATION,
 787         MM_PLAYER_FOCUS_CHANGED_BY_UNKNOWN,
 788 } MMPlayerFocusChangedMsg;
 789
 790
 791 /**
 792  * Edge Properties of the text.
 793  */
 794 typedef enum {
 795         MM_PLAYER_EDGE_NO,
 796         MM_PLAYER_EDGE_RAISED,
 797         MM_PLAYER_EDGE_DEPRESSED,
 798         MM_PLAYER_EDGE_UNIFORM,
 799         MM_PLAYER_EDGE_DROPSHADOW
 800 } MMPlayerSubtitleEdge;
 801
 802 /**
 803  * Enumeration of media stream buffer status
 804  */
 805 typedef enum
 806 {
 807         MM_PLAYER_MEDIA_STREAM_BUFFER_UNDERRUN,
 808         MM_PLAYER_MEDIA_STREAM_BUFFER_OVERFLOW,
 809 } MMPlayerMediaStreamBufferStatus;
 810
 811 /**
 812  * Enumeration for stream type.
 813  */
 814 typedef enum
 815 {
 816         MM_PLAYER_STREAM_TYPE_DEFAULT,  /**< Container type */
 817         MM_PLAYER_STREAM_TYPE_AUDIO,    /**< Audio element stream type */
 818         MM_PLAYER_STREAM_TYPE_VIDEO,    /**< Video element stream type */
 819         MM_PLAYER_STREAM_TYPE_TEXT,     /**< Text type */
 820         MM_PLAYER_STREAM_TYPE_MAX,
 821 } MMPlayerStreamType;
 822
 823 /**
 824  * Enumeration for pipeline type.
 825  */
 826 typedef enum
 827 {
 828         MM_PLAYER_PIPELINE_LEGACY,      /**< Legacy pipeline */
 829         MM_PLAYER_PIPELINE_SERVER,      /**< Pipeline for server(src,decoder,demux...) */
 830         MM_PLAYER_PIPELINE_CLIENT,      /**< Pipeline for client(sink)*/
 831         MM_PLAYER_PIPELINE_MAX
 832 } MMPlayerPipelineType;
 833
 834 /**
 835  * Attribute validity structure
 836  */
 837 typedef struct {
 838          MMPlayerAttrsType type;
 839          MMPlayerAttrsValidType validity_type;
 840          MMPlayerAttrsFlag flag;
 841         /**
 842           * a union that describes validity of the attribute.
 843           * Only when type is 'MM_ATTRS_TYPE_INT' or 'MM_ATTRS_TYPE_DOUBLE',
 844           * the attribute can have validity.
 845          */
 846          union {
 847                 /**
 848                    * Validity structure for integer array.
 849                  */
 850                 struct {
 851                         int *array;  /**< a pointer of array */
 852                         int count;   /**< size of array */
 853                         int d_val;
 854                 } int_array;
 855                 /**
 856                    * Validity structure for integer range.
 857                  */
 858                 struct {
 859                         int min;   /**< minimum range */
 860                         int max;   /**< maximum range */
 861                         int d_val;
 862                 } int_range;
 863                 /**
 864                 * Validity structure for double array.
 865                 */
 866                 struct {
 867                         double   * array;  /**< a pointer of array */
 868                         int    count;   /**< size of array */
 869                         double d_val;
 870                 } double_array;
 871                 /**
 872                 * Validity structure for double range.
 873                 */
 874                 struct {
 875                         double   min;   /**< minimum range */
 876                         double   max;   /**< maximum range */
 877                         double d_val;
 878                 } double_range;
 879         };
 880 } MMPlayerAttrsInfo;
 881
 882 /**
 883  * Volume type.
 884  *
 885  * @see         mm_player_set_volume, mm_player_get_volume
 886  */
 887 typedef struct {
 888         float   level[MM_VOLUME_CHANNEL_NUM];   /**< Relative volume factor for each channels */
 889 } MMPlayerVolumeType;
 890
 891 /**
 892  * Video stream info in external demux case
 893  *
 894 **/
 895 typedef struct _VideoStreamInfo
 896 {
 897         const char *mime;
 898         unsigned int framerate_num;
 899         unsigned int framerate_den;
 900         unsigned int width;
 901         unsigned int height;
 902         unsigned char *codec_extradata;
 903         unsigned int extradata_size;
 904         unsigned int version;
 905 }MMPlayerVideoStreamInfo;
 906
 907 /**
 908  * Audio stream info in external demux case
 909  *
 910 **/
 911 typedef struct _AudioStreamInfo
 912 {
 913         const char *mime;
 914         unsigned int channels;
 915         unsigned int sample_rate;
 916         unsigned char *codec_extradata;
 917         unsigned int extradata_size;
 918         unsigned int version;
 919         unsigned int user_info;
 920
 921         /* for pcm */
 922 //      unsigned int width;
 923 //      unsigned int depth;
 924 //      unsigned int endianness;
 925 //      bool signedness;
 926 }MMPlayerAudioStreamInfo;
 927
 928 /**
 929  * Subtitle stream info in external demux case
 930  *
 931 **/
 932 typedef struct _SubtitleStreamInfo
 933 {
 934         const char *mime;
 935         unsigned int codec_tag;
 936         void *context;  //for smpte text
 937 }MMPlayerSubtitleStreamInfo;
 938
 939 /**
 940  * Audio stream callback function type.
 941  *
 942  * @param       stream          [in]    Reference pointer to audio frame data
 943  * @param       stream_size     [in]    Size of audio frame data
 944  * @param       user_param      [in]    User defined parameter which is passed when set
 945  *                                                              audio stream callback
 946  *
 947  * @return      This callback function have to return MM_ERROR_NONE.
 948  */
 949 typedef bool    (*mm_player_audio_stream_callback) (void *stream, int stream_size, void *user_param);
 950
 951
 952 /**
 953  * selected subtitle track number callback function type.
 954  *
 955  * @param       track_num       [in]    Track number of subtitle
 956  * @param       user_param      [in]    User defined parameter
 957  *
 958  *
 959  * @return      This callback function have to return MM_ERROR_NONE.
 960  */
 961 typedef bool            (*mm_player_track_selected_subtitle_language_callback)(int track_num, void *user_param);
 962
 963 /**
 964  * Buffer underrun / overflow data callback function type.
 965  *
 966  * @param       status     [in] buffer status
 967  * @param       user_param [in] User defined parameter which is passed when set
 968  *                              to enough data callback or need data callback
 969  *
 970  * @return      This callback function have to return MM_ERROR_NONE.
 971  */
 972 typedef bool    (*mm_player_media_stream_buffer_status_callback) (MMPlayerStreamType type, MMPlayerMediaStreamBufferStatus status, void *user_param);
 973
 974 /**
 975  * Buffer seek data callback function type.
 976  *
 977  * @param       offset     [in] offset for the buffer playback
 978  * @param       user_param [in] User defined parameter which is passed when set
 979  *                              to seek data callback
 980  *
 981  * @return      This callback function have to return MM_ERROR_NONE.
 982  */
 983 typedef bool    (*mm_player_media_stream_seek_data_callback) (MMPlayerStreamType type, unsigned long long offset, void *user_param);
 984
 985 /**
 986  * Called to notify the stream changed.
 987  *
 988  * @param user_data [in] The user data passed from the callback registration function
 989  *
 990  * @return      This callback function have to return MM_ERROR_NONE.
 991  */
 992 typedef bool    (*mm_player_stream_changed_callback) (void *user_param);
 993
 994
 995 /*===========================================================================================
 996 |                                                                                           |
 997 |  GLOBAL FUNCTION PROTOTYPES                                        |
 998 |                                                                                           |
 999 ========================================================================================== */
1000
1001 /**
1002  * This function creates a player object for playing multimedia contents. \n
1003  * The attributes of player are created to get/set some values with application. \n
1004  * And, mutex, gstreamer and other resources are initialized at this time. \n
1005  * If player is created, the state will become MM_PLAYER_STATE_NULL.
1006  *
1007  * @param       player          [out]   Handle of player
1008  *
1009  * @return      This function returns zero on success, or negative value with error code. \n
1010  *                      Please refer 'mm_error.h' to know it in detail.
1011  * @pre         None
1012  * @post        MM_PLAYER_STATE_NULL
1013  * @see         mm_player_destroy
1014  * @remark      You can create multiple handles on a context at the same time. \n
1015  *                      However, player cannot guarantee proper operation because of limitation of resources, \n
1016  *                      such as audio device or display device.
1017  *
1018  * @par Example
1019  * @code
1020 char *g_err_attr_name = NULL;
1021
1022 if (mm_player_create(&g_player) != MM_ERROR_NONE)
1023 {
1024         LOGE("failed to create player\n");
1025 }
1026
1027 if (mm_player_set_attribute(g_player,
1028                                                 &g_err_attr_name,
1029                                                 "profile_uri", filename, strlen(filename),
1030                                                 "display_overlay", (void*)&g_win.xid, sizeof(g_win.xid),
1031                                                 NULL) != MM_ERROR_NONE)
1032 {
1033         LOGE("failed to set %s attribute\n", g_err_attr_name);
1034         free(g_err_attr_name);
1035 }
1036
1037 mm_player_set_message_callback(g_player, msg_callback, (void*)g_player);
1038  * @endcode
1039  */
1040 int mm_player_create(MMHandleType *player);
1041
1042 /**
1043  * This function releases player object and all resources which were created by mm_player_create(). \n
1044  * And, player handle will also be destroyed.
1045  *
1046  * @param       player          [in]    Handle of player
1047  *
1048  * @return      This function returns zero on success, or negative value with error code.
1049  * @pre         Player state may be MM_PLAYER_STATE_NULL. \n
1050  *                      But, it can be called in any state.
1051  * @post                Because handle is released, there is no any state.
1052  * @see         mm_player_create
1053  * @remark      This method can be called with a valid player handle from any state to \n
1054  *                      completely shutdown the player operation.
1055  *
1056  * @par Example
1057  * @code
1058 if (mm_player_destroy(g_player) != MM_ERROR_NONE)
1059 {
1060         LOGE("failed to destroy player\n");
1061 }
1062  * @endcode
1063  */
1064 int mm_player_destroy(MMHandleType player);
1065
1066 /**
1067  * This function register the sound focus using application PID \n
1068  * So, application PID should be set before realizing with mm_player_set_attribute(). \n
1069  *
1070  * @param       player          [in]    Handle of player
1071  *
1072  * @return      This function returns zero on success, or negative value with error code.
1073  *
1074  * @pre         Player state should be MM_PLAYER_STATE_NULL.
1075  * @remark      None
1076  */
1077 int mm_player_sound_register(MMHandleType player, int pid);
1078
1079 /**
1080  * This function parses uri and makes gstreamer pipeline by uri scheme. \n
1081  * So, uri should be set before realizing with mm_player_set_attribute(). \n
1082  *
1083  * @param       player          [in]    Handle of player
1084  *
1085  * @return      This function returns zero on success, or negative value with error code.
1086  *
1087  * @pre         Player state should be MM_PLAYER_STATE_NULL.
1088  * @post                Player state will be MM_PLAYER_STATE_READY.
1089  * @see         mm_player_unrealize
1090  * @remark      None
1091  * @par Example
1092  * @code
1093 if (mm_player_realize(g_player) != MM_ERROR_NONE)
1094 {
1095         LOGE("failed to realize player\n");
1096 }
1097  * @endcode
1098  */
1099 int mm_player_realize(MMHandleType player) ;
1100
1101 /**
1102  * This function uninitializes player object. So, resources and allocated memory \n
1103  * will be freed. And, gstreamer pipeline is also destroyed. So, if you want to play \n
1104  * other contents, player should be created again after destruction or realized with new uri.
1105  *
1106  * @param       player          [in]    Handle of player
1107  *
1108  * @return      This function returns zero on success, or negative value with error code.
1109  * @pre         Player state may be MM_PLAYER_STATE_READY to unrealize. \n
1110  *                      But, it can be called in any state.
1111  * @post                Player state will be MM_PLAYER_STATE_NULL.
1112  * @see         mm_player_realize
1113  * @remark      This method can be called with a valid player handle from any state.
1114  *
1115  * @par Example
1116  * @code
1117 if (mm_player_unrealize(g_player) != MM_ERROR_NONE)
1118 {
1119         LOGE("failed to unrealize player\n");
1120 }
1121  * @endcode
1122  */
1123 int mm_player_unrealize(MMHandleType player);
1124
1125 /**
1126  * This function is to get current state of player. \n
1127  * Application have to check current state before doing some action.
1128  *
1129  * @param       player          [in]    Handle of player
1130  * @param       state       [out] current state of player on success
1131  *
1132  * @return      This function returns zero on success, or negative value with error code.
1133  *
1134  * @see         MMPlayerStateType
1135  * @remark      None
1136  * @par Example
1137  * @code
1138 if (mm_player_get_state(g_player, &state) != MM_ERROR_NONE)
1139 {
1140         LOGE("failed to get state\n");
1141 }
1142  * @endcode
1143  */
1144 int mm_player_get_state(MMHandleType player, MMPlayerStateType *state);
1145
1146 /**
1147  * This function is to set relative volume of player. \n
1148  * So, It controls logical volume value. \n
1149  * But, if developer want to change system volume, mm sound api should be used.
1150  *
1151  * @param       player          [in]    Handle of player
1152  * @param       volume          [in]    Volume factor of each channel
1153  *
1154  * @return      This function returns zero on success, or negative value with error code.
1155  * @see         MMPlayerVolumeType, mm_player_get_volume
1156  * @remark      The range of factor range is from 0 to 1.0. (1.0 = 100%) And, default value is 1.0.
1157  * @par Example
1158  * @code
1159 MMPlayerVolumeType volume;
1160 int i = 0;
1161
1162 for (i = 0; i < MM_VOLUME_CHANNEL_NUM; i++)
1163         volume.level[i] = MM_VOLUME_LEVEL_MAX;
1164
1165 if (mm_player_set_volume(g_player, &volume) != MM_ERROR_NONE)
1166 {
1167     LOGE("failed to set volume\n");
1168 }
1169  * @endcode
1170  */
1171 int mm_player_set_volume(MMHandleType player, MMPlayerVolumeType *volume);
1172
1173 /**
1174  * This function is to get current volume factor of player.
1175  *
1176  * @param       player          [in]    Handle of player.
1177  * @param       volume          [out]   Volume factor of each channel.
1178  *
1179  * @return      This function returns zero on success, or negative value with error code.
1180  *
1181  * @see         MMPlayerVolumeType, mm_player_set_volume
1182  * @remark      None
1183  * @par Example
1184  * @code
1185 MMPlayerVolumeType volume;
1186 int i;
1187
1188 if (mm_player_get_volume(g_player, &volume) != MM_ERROR_NONE)
1189 {
1190         LOGW("failed to get volume\n");
1191 }
1192
1193 for (i = 0; i < MM_VOLUME_CHANNEL_NUM; i++)
1194         LOGD("channel[%d] = %d \n", i, volume.level[i]);
1195  * @endcode
1196  */
1197 int mm_player_get_volume(MMHandleType player, MMPlayerVolumeType *volume);
1198
1199 /**
1200  * This function is to start playing media contents. Demux(parser), codec and related plugins are decided \n
1201  * at this time. And, MM_MESSAGE_BEGIN_OF_STREAM will be posted through callback function registered \n
1202  * by mm_player_set_message_callback().
1203  *
1204  * @param       player          [in]    Handle of player
1205  *
1206  * @return      This function returns zero on success, or negative value with error code.
1207  * @remark
1208  *
1209  * @pre         Player state may be MM_PLAYER_STATE_READY.
1210  * @post                Player state will be MM_PLAYER_STATE_PLAYING.
1211  * @see         mm_player_stop
1212  * @remark      None
1213  * @par Example
1214  * @code
1215 if (mm_player_start(g_player) != MM_ERROR_NONE)
1216 {
1217         LOGE("failed to start player\n");
1218 }
1219  * @endcode
1220  */
1221 int mm_player_start(MMHandleType player);
1222
1223 /**
1224  * This function is to stop playing media contents and it's different with pause. \n
1225  * If mm_player_start() is called after this, content will be started again from the beginning. \n
1226  * So, it can be used to close current playback.
1227  *
1228  * @param       player          [in]    Handle of player
1229  *
1230  * @return      This function returns zero on success, or negative value with error code.
1231  *
1232  * @pre         Player state may be MM_PLAYER_STATE_PLAYING.
1233  * @post                Player state will be MM_PLAYER_STATE_READY.
1234  * @see         mm_player_start
1235  * @remark      None
1236  * @par Example
1237  * @code
1238 if (mm_player_stop(g_player) != MM_ERROR_NONE)
1239 {
1240         LOGE("failed to stop player\n");
1241 }
1242  * @endcode
1243  */
1244 int mm_player_stop(MMHandleType player);
1245
1246 /**
1247  * This function is to pause playing media contents.
1248  *
1249  * @param       player          [in]    Handle of player.
1250  *
1251  * @return      This function returns zero on success, or negative value with error code.
1252  *
1253  * @pre         Player state may be MM_PLAYER_STATE_PLAYING.
1254  * @post                Player state will be MM_PLAYER_STATE_PAUSED.
1255  * @see         mm_player_resume
1256  * @remark      None
1257  * @par Example
1258  * @code
1259 if (mm_player_pause(g_player) != MM_ERROR_NONE)
1260 {
1261         LOGE("failed to pause player\n");
1262 }
1263  * @endcode
1264  */
1265 int mm_player_pause(MMHandleType player);
1266
1267 /**
1268  * This function is to resume paused media contents.
1269  *
1270  * @param       player          [in]    Handle of player.
1271  *
1272  * @return      This function returns zero on success, or negative value with error code.
1273  *
1274  * @pre         Player state may be MM_PLAYER_STATE_PAUSED.
1275  * @post                Player state will be MM_PLAYER_STATE_PLAYING.
1276  * @see         mm_player_pause
1277  * @remark      None
1278  * @par Example
1279  * @code
1280 if (mm_player_resume(g_player) != MM_ERROR_NONE)
1281 {
1282         LOGE("failed to resume player\n");
1283 }
1284  * @endcode
1285  */
1286 int mm_player_resume(MMHandleType player);
1287
1288 /**
1289  * This function is to set the position for playback. \n
1290  * So, it can be seeked to requested position. \n
1291  *
1292  * @param       player          [in]    Handle of player
1293  * @param       format          [in]    Format of position.
1294  * @param       pos                     [in]    Position for playback
1295  *
1296  * @return      This function returns zero on success, or negative value with error code.
1297  * @see         MMPlayerPosFormatType, mm_player_get_position
1298  * @remark  the unit of time-based format is millisecond and other case is percent.
1299  * @par Example
1300  * @code
1301 int position = 1000; //1sec
1302
1303 if (mm_player_set_position(g_player, MM_PLAYER_POS_FORMAT_TIME, position) != MM_ERROR_NONE)
1304 {
1305         LOGE("failed to set position\n");
1306 }
1307  * @endcode
1308  */
1309 int mm_player_set_position(MMHandleType player, MMPlayerPosFormatType format, int pos);
1310
1311 /**
1312  * This function is to get current position of playback content.
1313  *
1314  * @param       player          [in]    Handle of player.
1315  * @param       format          [in]    Format of position.
1316  * @param    pos        [out] contains current position on success or zero in case of failure.
1317  *
1318  * @return      This function returns zero on success, or negative value with errors
1319  * @see         MMPlayerPosFormatType, mm_player_set_position
1320  * @remark      the unit of time-based format is millisecond and other case is percent.
1321  * @par Example
1322  * @code
1323 int position = 0;
1324 int duration = 0;
1325
1326 mm_player_get_position(g_player, MM_PLAYER_POS_FORMAT_TIME, &position);
1327
1328 mm_player_get_attribute(g_player, &g_err_name, "content_duration", &duration, NULL);
1329
1330 LOGD("pos: [%d/%d] msec\n", position, duration);
1331  * @endcode
1332  */
1333 int mm_player_get_position(MMHandleType player, MMPlayerPosFormatType format, unsigned long *pos);
1334
1335 /**
1336  * This function is to get current buffer position of playback content.
1337  *
1338  * @param       player          [in]    Handle of player.
1339  * @param       format          [in]    Format of position.
1340  * @param       start_pos               [out] contains buffer start  position on success or zero in case of failure.
1341  * @param       stop_pos        [out] contains buffer current  position on success or zero in case of failure.
1342  *
1343  * @return      This function returns zero on success, or negative value with errors
1344  * @see         MMPlayerPosFormatType, mm_player_set_position
1345  * @remark      the unit of time-based format is millisecond and other case is percent.
1346  * @par Example
1347  * @code
1348 int start_pos = 0, stop_pos = 0;
1349
1350 mm_player_get_buffer_position(g_player, MM_PLAYER_POS_FORMAT_PERCENT, &start_pos, &stop_pos );
1351
1352 LOGD("buffer position: [%d] ~ [%d] \%\n", start_pos, stop_pos );
1353  * @endcode
1354  */
1355 int mm_player_get_buffer_position(MMHandleType player, MMPlayerPosFormatType format, unsigned long *start_pos, unsigned long *stop_pos);
1356
1357 /**
1358  * This function is to activate the section repeat. If it's set, selected section will be played \n
1359  * continually before deactivating it by mm_player_deactivate_section_repeat(). \n
1360  * The unit for setting is millisecond.
1361  *
1362  * @param       player          [in]    Handle of player.
1363  * @param       start_pos               [in]    start position.
1364  * @param       end_pos                 [in]    end position.
1365  *
1366  * @return      This function returns zero on success, or negative value with error code.
1367  * @see         mm_player_deactivate_section_repeat
1368  * @remark      None
1369  * @par Example
1370  * @code
1371 int position;
1372 int endtime = 4000; //msec
1373
1374 mm_player_get_position(g_player, MM_PLAYER_POS_FORMAT_TIME, &position);
1375
1376 mm_player_activate_section_repeat(g_player, position, position+endtime);
1377  * @endcode
1378  */
1379 int mm_player_activate_section_repeat(MMHandleType player, int start_pos, int end_pos);
1380
1381 /**
1382  * This function is to deactivate the section repeat.
1383  *
1384  * @param       player          [in]    Handle of player.
1385  *
1386  * @return      This function returns zero on success, or negative value with error code.
1387  * @see         mm_player_activate_section_repeat
1388  * @remark      None
1389  * @par Example
1390  * @code
1391 if ( mm_player_deactivate_section_repeat(g_player) != MM_ERROR_NONE)
1392 {
1393         LOGW("failed to deactivate section repeat\n");
1394 }
1395  * @endcode
1396  */
1397 int mm_player_deactivate_section_repeat(MMHandleType player);
1398
1399 /**
1400  * This function sets callback function for receiving messages from player.
1401  * So, player can notify warning, error and normal cases to application.
1402  *
1403  * @param       player          [in]    Handle of player.
1404  * @param       callback        [in]    Message callback function.
1405  * @param       user_param      [in]    User parameter which is passed to callback function.
1406  *
1407  * @return      This function returns zero on success, or negative value with error code.
1408  * @see         MMMessageCallback
1409  * @remark      None
1410  * @par Example
1411  * @code
1412 int msg_callback(int message, MMMessageParamType *param, void *user_param)
1413 {
1414         switch (message)
1415         {
1416                 case MM_MESSAGE_ERROR:
1417                         //do something
1418                         break;
1419
1420                 case MM_MESSAGE_END_OF_STREAM:
1421                         //do something
1422                         break;
1423
1424                 case MM_MESSAGE_STATE_CHANGED:
1425                         //do something
1426                         break;
1427
1428                 case MM_MESSAGE_BEGIN_OF_STREAM:
1429                         //do something
1430                         break;
1431
1432                 default:
1433                         break;
1434         }
1435         return TRUE;
1436 }
1437
1438 mm_player_set_message_callback(g_player, msg_callback, (void*)g_player);
1439  * @endcode
1440  */
1441 int mm_player_set_message_callback(MMHandleType player, MMMessageCallback callback, void *user_param);
1442
1443 /**
1444  * This function set callback function for receiving audio stream from player. \n
1445  * So, application can get raw audio data and modify it. \n
1446  * But, if callback don't return or holds it for long time, performance can be deteriorated. \n
1447  * It's only supported when audio stream is included in file. \n
1448  * So, if there is video stream or DRM content, it can't be used.
1449  *
1450  * @param       player          [in]    Handle of player.
1451  * @param       callback                [in]    Audio stream callback function.
1452  * @param       user_param      [in]    User parameter.
1453  *
1454  * @return      This function returns zero on success, or negative value with error
1455  *                      code.
1456  * @see         mm_player_audio_stream_callback
1457  * @remark      It can be used for audio playback only.
1458  * @par Example
1459  * @code
1460 bool audio_callback(void *stream, int stream_size, void *user_param)
1461 {
1462         LOGD("audio stream callback\n");
1463         return TRUE;
1464 }
1465 mm_player_set_audio_stream_callback(g_player, audio_callback, NULL);
1466  * @endcode
1467  */
1468  int mm_player_set_audio_stream_callback(MMHandleType player, mm_player_audio_stream_callback callback, void *user_param);
1469
1470 /**
1471  * This function is to mute volume of player
1472  *
1473  * @param       player  [in]    Handle of player
1474  * @param       mute    [in]    Mute(1) or not mute(0)
1475  *
1476  * @return      This function returns zero on success, or negative value with error code
1477  * @see         mm_player_get_mute
1478  * @remark      None
1479  * @par Example
1480  * @code
1481 if (mm_player_set_mute(g_player, TRUE) != MM_ERROR_NONE)
1482 {
1483         LOGW("failed to set mute\n");
1484 }
1485  * @endcode
1486  */
1487 int mm_player_set_mute(MMHandleType player, int mute);
1488
1489 /**
1490  * This function is to get mute value of player
1491  *
1492  * @param       player  [in]    Handle of player
1493  * @param       mute    [out]   Sound is muted
1494  *
1495  * @return      This function returns zero on success, or negative value with error code
1496  * @see         mm_player_set_mute
1497  * @remark      None
1498  * @par Example
1499  * @code
1500 int mute;
1501
1502 if (mm_player_get_mute(g_player, &mute) != MM_ERROR_NONE)
1503 {
1504         LOGW("failed to get mute\n");
1505 }
1506
1507 LOGD("mute status:%d\n", mute);
1508  * @endcode
1509  */
1510 int mm_player_get_mute(MMHandleType player, int *mute);
1511
1512 /**
1513  * This function is to adjust subtitle postion. So, subtitle can show at the adjusted position. \n
1514  * If pos is negative, subtitle will be displayed previous time, the other hand forward time. \n
1515  *
1516  * @param       player  [in]    Handle of player
1517  * @param       pos             [in]    postion to be adjusted
1518  *
1519  * @return      This function returns zero on success, or negative value with error
1520  *                      code
1521  * @see         mm_player_adjust_subtitle_position
1522  * @remark      None
1523  * @par Example
1524  * @code
1525 int pos;
1526
1527 pos = 5000;
1528 if (mm_player_adjust_subtitle_position(g_player, MM_PLAYER_POS_FORMAT_TIME, pos) != MM_ERROR_NONE)
1529 {
1530         LOGW("failed to adjust subtitle postion.\n");
1531 }
1532  * @endcode
1533  */
1534
1535 int mm_player_adjust_subtitle_position(MMHandleType player, MMPlayerPosFormatType format, int pos);
1536
1537 /**
1538  * This function is to set the offset in timestamps of video so as to bring the a/v sync
1539  * @param      player          Handle of player
1540  * @param      offset          offset to be set in milliseconds(can be positive or negative both)
1541  * postive offset to make video lag
1542  * negative offset to make video lead
1543  */
1544 int mm_player_adjust_video_position(MMHandleType player,int offset);
1545 /**
1546  * This function is to set subtitle silent status. So, subtitle can show or hide during playback \n
1547  * by this value. But, one subtitle file should be set with "subtitle_uri" attribute before calling mm_player_realize(); \n
1548  * Player FW parses subtitle file and send text data including timestamp to application \n
1549  * through message callback with MM_MESSAGE_UPDATE_SUBTITLE will be. \n
1550  * So, application have to render it. And, subtitle can be supported only in a seprate file. \n
1551  * So, it's not supported for embedded case.
1552  *
1553  * @param       player  [in]    Handle of player
1554  * @param       silent  [in]    silent(integer value except 0) or not silent(0)
1555  *
1556  * @return      This function returns zero on success, or negative value with error
1557  *                      code
1558  * @see         mm_player_get_subtitle_silent, MM_MESSAGE_UPDATE_SUBTITLE
1559  * @remark      None
1560  * @par Example
1561  * @code
1562 mm_player_set_attribute(g_player,
1563                                         &g_err_name,
1564                                         "subtitle_uri", g_subtitle_uri, strlen(g_subtitle_uri),
1565                                         NULL
1566                                         );
1567
1568 if (mm_player_set_subtitle_silent(g_player, TRUE) != MM_ERROR_NONE)
1569 {
1570         LOGW("failed to set subtitle silent\n");
1571 }
1572  * @endcode
1573  */
1574 int mm_player_set_subtitle_silent(MMHandleType player, int silent);
1575
1576 /**
1577  * This function is to get silent status of subtitle.
1578  *
1579  * @param       player  [in]    Handle of player
1580  * @param       silent  [out]   subtitle silent property
1581  *
1582  * @return      This function returns zero on success, or negative value with error
1583  *                      code
1584  * @see         mm_player_set_subtitle_silent, MM_MESSAGE_UPDATE_SUBTITLE
1585  * @remark      None
1586  * @par Example
1587  * @code
1588 int silent = FALSE;
1589
1590 if (mm_player_get_subtitle_silent(g_player, &silent) != MM_ERROR_NONE)
1591 {
1592         LOGW("failed to set subtitle silent\n");
1593 }
1594  * @endcode
1595  */
1596 int mm_player_get_subtitle_silent(MMHandleType player, int *silent);
1597
1598 /**
1599  * This function is to set attributes into player. Multiple attributes can be set simultaneously. \n
1600  * If one of attribute fails, this function will stop at the point and let you know the name which is failed. \n
1601  *
1602  * @param       player                          [in]    Handle of player.
1603  * @param       err_attr_name                   [out]  Name of attribute which is failed to set
1604  * @param       first_attribute_name    [in]    Name of the first attribute to set
1605  * @param   ...                                 [in]    Value for the first attribute, followed optionally by more name/value pairs, terminated by NULL.
1606  *                                                                       But, in the case of data or string type, it should be name/value/size.
1607  *
1608  * @return      This function returns zero on success, or negative value with error code.
1609  *
1610  * @see         mm_player_get_attribute
1611  * @remark      This function must be terminated by NULL argument.
1612  *                      And, if this function is failed, err_attr_name param must be free.
1613  * @par Example
1614  * @code
1615 char *g_err_attr_name = NULL;
1616
1617 if (mm_player_set_attribute(g_player,
1618                                                 &g_err_attr_name,
1619                                                 "profile_uri", filename, strlen(filename),
1620                                                 "profile_play_count", count,
1621                                                 NULL) != MM_ERROR_NONE)
1622 {
1623         LOGW("failed to set %s attribute\n", g_err_attr_name);
1624         free(g_err_attr_name);
1625 }
1626
1627  * @endcode
1628  */
1629 int mm_player_set_attribute(MMHandleType player,  char **err_attr_name, const char *first_attribute_name, ...)G_GNUC_NULL_TERMINATED;
1630
1631 /**
1632  * This function is to get attributes from player. Multiple attributes can be got simultaneously.
1633  *
1634  * @param       player                          [in]    Handle of player.
1635  * @param       err_attr_name                   [out]  Name of attribute which is failed to get
1636  * @param       first_attribute_name    [in]    Name of the first attribute to get
1637  * @param       ...                                     [out] Value for the first attribute, followed optionally by more name/value pairs, terminated by NULL.
1638  *                                                                       But, in the case of data or string type, it should be name/value/size.
1639  *
1640  * @return      This function returns zero on success, or negative value with error
1641  *                      code.
1642  * @see         mm_player_set_attribute
1643  * @remark      This function must be terminated by NULL argument.
1644  *                      And, if this function is failed, err_attr_name param must be free.
1645  * @par Example
1646  * @code
1647 char *g_err_attr_name = NULL;
1648
1649 if (mm_player_get_attribute(g_player, &g_err_attr_name, "content_duration", &duration, NULL) != MM_ERROR_NONE)
1650 {
1651         LOGW("failed to set %s attribute\n", g_err_attr_name);
1652         free(g_err_attr_name);
1653 }
1654  * @endcode
1655  */
1656 int mm_player_get_attribute(MMHandleType player,  char **err_attr_name, const char *first_attribute_name, ...)G_GNUC_NULL_TERMINATED;
1657
1658 /**
1659  * This function is to get detail information of attribute.
1660  *
1661  * @param       player                           [in]   Handle of player.
1662  * @param   attribute_name               [in]   Name of the attribute to get
1663  * @param   info                                 [out]  Attribute infomation
1664  *
1665  * @return      This function returns zero on success, or negative value with error
1666  *                      code.
1667  *
1668  * @see         mm_player_set_attribute, mm_player_get_attribute
1669  * @remark      None
1670  * @par Example
1671  * @code
1672 if (mm_player_get_attribute_info (g_player, "display_method", &method_info) != MM_ERROR_NONE)
1673 {
1674         LOGW("failed to get info\n");
1675 }
1676
1677 LOGD("type:%d \n", method_info.type); //int, double..
1678 LOGD("flag:%d \n", method_info.flag); //readable, writable..
1679 LOGD("validity type:%d \n", method_info.validity_type); //range, array..
1680
1681 if (method_info. validity_type == MM_PLAYER_ATTRS_VALID_TYPE_INT_RANGE)
1682 {
1683         LOGD("range min:%d\n", method_info.int_range.min);
1684         LOGD("range max:%d\n", method_info.int_range.max);
1685 }
1686  * @endcode
1687  */
1688 int mm_player_get_attribute_info(MMHandleType player,  const char *attribute_name, MMPlayerAttrsInfo *info);
1689
1690 /**
1691  * This function is to get download position and total size of progressive download
1692  *
1693  * @param       player          [in]    Handle of player.
1694  * @param       current_pos     [in]    Download position currently (bytes)
1695  * @param       total_size      [in]    Total size of file (bytes)
1696  *
1697  * @return      This function returns zero on success, or negative value with error code.
1698  *
1699  * @see
1700  * @remark
1701  * @par Example
1702  * @code
1703 guint64 current_pos = 0LLU;
1704 guint64 total_size = 0LLU;
1705
1706 if (mm_player_get_pd_status(g_player, &current_pos, &total_size, NULL) != MM_ERROR_NONE)
1707 {
1708         LOGD("current download pos = %llu, total size = %llu\n", current_pos, total_size);
1709 }
1710  * @endcode
1711  */
1712 int mm_player_get_pd_status(MMHandleType player, guint64 *current_pos, guint64 *total_size);
1713
1714 /**
1715  * This function sets callback function for receiving messages of PD downloader.
1716  *
1717  * @param       player          [in]    Handle of player.
1718  * @param       callback                [in]    Message callback function.
1719  * @param       user_param      [in]    User parameter which is passed to callback function.
1720  *
1721  * @return      This function returns zero on success, or negative value with error code.
1722  * @see
1723  * @remark      None
1724  * @par Example
1725  * @code
1726 int msg_callback(int message, MMMessageParamType *param, void *user_param)
1727 {
1728         switch (message)
1729         {
1730                 case MM_MESSAGE_PD_DOWNLOADER_START:
1731                         LOGD("Progressive download is started...\n");
1732                         break;
1733                 case MM_MESSAGE_PD_DOWNLOADER_END:
1734                         LOGD("Progressive download is ended...\n");
1735                         break;
1736                 default:
1737                         break;
1738         }
1739         return TRUE;
1740 }
1741
1742 mm_player_set_pd_message_callback(g_player, msg_callback, NULL);
1743  * @endcode
1744  */
1745 int mm_player_set_pd_message_callback(MMHandleType player, MMMessageCallback callback, void *user_param);
1746
1747 /**
1748  * This function is to get the track count
1749  *
1750  * @param       player          [in]    handle of player.
1751  * @param       track                   [in]    type of the track type
1752  * @param       info                    [out]   the count of the track
1753  *
1754  * @return      This function returns zero on success, or negative value with error
1755  *                      code.
1756  *
1757  * @see
1758  * @remark      None
1759  * @par Example
1760  * @code
1761 gint audio_count = 0;
1762
1763 if (mm_player_get_track_count (g_player, MM_PLAYER_TRACK_TYPE_AUDIO, &audio_count) != MM_ERROR_NONE)
1764 {
1765         LOGW("failed to get audio track count\n");
1766 }
1767
1768 LOGD("audio track count : %d \n", audio_count);
1769  * @endcode
1770  */
1771 int mm_player_get_track_count(MMHandleType player,  MMPlayerTrackType type, int *count);
1772
1773 /**
1774  * This function is to select the track
1775  *
1776  * @param       player          [in]    handle of player.
1777  * @param       type                    [in]    type of the track type
1778  * @param       index           [in]    the index of the track
1779  *
1780  * @return      This function returns zero on success, or negative value with error
1781  *                      code.
1782  *
1783  * @see
1784  * @remark      None
1785  */
1786 int mm_player_select_track(MMHandleType player, MMPlayerTrackType type, int index);
1787 #ifdef _MULTI_TRACK
1788 /**
1789  * This function is to add the track when user want multi subtitle
1790  *
1791  * @param       player          [in]    handle of player.
1792  * @param       index           [in]    the index of the track
1793  *
1794  * @return      This function returns zero on success, or negative value with error
1795  *                      code.
1796  *
1797  * @see
1798  * @remark      None
1799  */
1800 int mm_player_track_add_subtitle_language(MMHandleType player, int index);
1801
1802 /**
1803  * This function is to remove the track when user want multi subtitle
1804  *
1805  * @param       player          [in]    handle of player.
1806  * @param       index           [in]    the index of the track
1807  *
1808  * @return      This function returns zero on success, or negative value with error
1809  *                      code.
1810  *
1811  * @see
1812  * @remark      None
1813  */
1814 int mm_player_track_remove_subtitle_language(MMHandleType player, int index);
1815
1816 /**
1817  * This function is to notify which sutitle track is in use
1818  *
1819  * @param       player          [in]    handle of player.
1820  * @param       callback                        [in]    callback function to register
1821  * @param       user_data       [in]    user data to be passed to the callback function
1822  *
1823  * @return      This function returns zero on success, or negative value with error
1824  *                      code.
1825  *
1826  * @see
1827  * @remark      None
1828  */
1829 int mm_player_track_foreach_selected_subtitle_language(MMHandleType player, mm_player_track_selected_subtitle_language_callback callback, void *user_param);
1830 #endif
1831 /**
1832  * This function is to get the track language
1833  *
1834  * @param       player          [in]    handle of player.
1835  * @param       type                    [in]    type of the track type
1836  * @param       index           [in]    the index of the track
1837  * @param       code                    [out] language code in ISO 639-1(string)
1838  *
1839  * @return      This function returns zero on success, or negative value with error
1840  *                      code.
1841  *
1842  * @see
1843  * @remark      None
1844  */
1845 int mm_player_get_track_language_code(MMHandleType player,  MMPlayerTrackType type, int index, char **code);
1846
1847 /**
1848  * This function is to get the current running track
1849  *
1850  * @param       player          [in]    handle of player.
1851  * @param       type                    [in]    type of the track type
1852  * @param       index           [out]    the index of the track
1853  *
1854  * @return      This function returns zero on success, or negative value with error
1855  *                      code.
1856  *
1857  * @see
1858  * @remark      None
1859  */
1860
1861 int mm_player_get_current_track(MMHandleType hplayer, MMPlayerTrackType type, int *index);
1862
1863 /**
1864  * This function is to set the buffer size for streaming playback. \n
1865  *
1866  * @param       player          [in]    Handle of player
1867  * @param       second          [in]    Size of initial buffer
1868  *
1869  * @return      This function returns zero on success, or negative value with error code.
1870  * @remark  None
1871  * @par Example
1872  * @code
1873 gint second = 10; //10sec
1874
1875 if (mm_player_set_prepare_buffering_time(g_player, second) != MM_ERROR_NONE)
1876 {
1877         LOGE("failed to set buffer size\n");
1878 }
1879  * @endcode
1880  */
1881
1882 int mm_player_set_prepare_buffering_time(MMHandleType player, int second);
1883
1884 /**
1885  * This function is to set the runtime buffering mode for streaming playback. \n
1886  *
1887  * @param       player          [in]    Handle of player
1888  * @param       mode            [in]    mode of runtime buffering
1889  * @param       second          [in]    max size of buffering
1890  *
1891  * @return      This function returns zero on success, or negative value with error code.
1892  * @remark  None
1893  * @par Example
1894  * @code
1895
1896 if (mm_player_set_runtime_buffering_mode(g_player, MM_PLAYER_BUFFERING_MODE_ADAPTIVE, 10) != MM_ERROR_NONE)
1897 {
1898         LOGE("failed to set buffering mode\n");
1899 }
1900  * @endcode
1901  */
1902
1903 int mm_player_set_runtime_buffering_mode(MMHandleType player, MMPlayerBufferingMode mode, int second);
1904
1905 /**
1906  * This function is to set the start position of zoom
1907  *
1908  * @param       player          [in]    handle of player
1909  * @param       level           [in]    level of zoom
1910  * @param       x               [in]    start x position
1911  * @param       y               [in]    start y position
1912  *
1913  * @return      This function returns zero on success, or negative value with error
1914  *                      code.
1915  *
1916  * @see
1917  * @remark      None
1918  */
1919 int mm_player_set_display_zoom(MMHandleType player, float level, int x, int y);
1920
1921 /**
1922  * This function is to get the start position of zoom
1923  *
1924  * @param       player           [in]    handle of player
1925  * @param       type            [out]    current level of zoom
1926  * @param       x               [out]    start x position
1927  * @param       y               [out]    start y position
1928  *
1929  * @return      This function returns zero on success, or negative value with error
1930  *                      code.
1931  *
1932  * @see
1933  * @remark      None
1934  */
1935 int mm_player_get_display_zoom(MMHandleType player, float *level, int *x, int *y);
1936
1937 /**
1938  * This function is to set the subtitle path
1939  *
1940  * @param       player  [in]    handle of player
1941  * @param       path    [in]    subtitle path
1942  *
1943  * @return      This function returns zero on success, or negative value with error code.
1944  *
1945  * @see
1946  * @remark      None
1947  */
1948 int mm_player_set_external_subtitle_path(MMHandleType player, const char* path);
1949
1950 /**
1951  * This function is to set the clock which is from master player
1952  *
1953  * @param       player  [in]    handle of player
1954  * @param       clock   [in]    clock of master player
1955  * @param       clock_delta [in]        clock difference between master and slave
1956  * @param       video_time      [in]    current playing position
1957  * @param       media_clock     [in]    media clock information
1958  * @param       audio_time      [in]    audio timestamp information
1959  * @return      This function returns zero on success, or negative value with error code.
1960  *
1961  * @see
1962  * @remark      None
1963  */
1964 int mm_player_set_video_share_master_clock(MMHandleType player, long long clock, long long clock_delta, long long video_time, long long media_clock, long long audio_time);
1965 /**
1966  * This function is to get the master clock
1967  *
1968  * @param       player          [in]    handle of player
1969  * @param       video_time      [out]   current playing position
1970  * @param       media_clock     [out]   media clock information
1971  * @param       audio_time      [out]   audio timestamp information
1972  * @return      This function returns zero on success, or negative value with error code.
1973  *
1974  * @see
1975  * @remark      None
1976  */
1977 int mm_player_get_video_share_master_clock(MMHandleType player, long long *video_time, long long *media_clock, long long *audio_time);
1978 /**
1979  * This function is to set audio channel
1980  *
1981  * @param       player          [in]    handle of player
1982  * @param       ch                      [in]    audio channel
1983  * @return      This function returns zero on success, or negative value with error code.
1984  *
1985  * @see
1986  * @remark      None
1987  */
1988 int mm_player_gst_set_audio_channel(MMHandleType player, MMPlayerAudioChannel ch);
1989
1990 /**
1991  * This function is to get the content angle
1992  *
1993  * @param       player          [in]    handle of player
1994  * @param       angle           [out]   orignal angle from content
1995  * @return      This function returns zero on success, or negative value with error code.
1996  *
1997  * @see
1998  * @remark      None
1999  */
2000 int mm_player_get_video_rotate_angle(MMHandleType player, int *angle);
2001
2002 /**
2003  * This function is to set download mode of video hub
2004  *
2005  * @param       player          [in]    handle of player
2006  * @param       mode            [in]    download mode
2007  * @return      This function returns zero on success, or negative value with error code.
2008  *
2009  * @see
2010  * @remark      None
2011  */
2012 int mm_player_set_video_hub_download_mode(MMHandleType player, bool mode);
2013
2014 /**
2015  * This function is to set using sync handler.
2016  *
2017  * @param       player          [in]    handle of player
2018  * @param       enable          [in]    enable/disable
2019  * @return      This function returns zero on success, or negative value with error code.
2020  *
2021  * @see
2022  * @remark      None
2023  */
2024 int mm_player_enable_sync_handler(MMHandleType player, bool enable);
2025
2026 /**
2027  * This function is to set uri.
2028  *
2029  * @param       player          [in]    handle of player
2030  * @param       uri             [in]    uri
2031  * @return      This function returns zero on success, or negative value with error code.
2032  *
2033  * @see
2034  * @remark      None
2035  */
2036 int mm_player_set_uri(MMHandleType player, const char *uri);
2037
2038 /**
2039  * This function is to set next uri.
2040  *
2041  * @param       player          [in]    handle of player
2042  * @param       uri             [in]    uri
2043  * @return      This function returns zero on success, or negative value with error code.
2044  *
2045  * @see
2046  * @remark      None
2047  */
2048 int mm_player_set_next_uri(MMHandleType player, const char *uri);
2049
2050 /**
2051  * This function is to get next uri.
2052  *
2053  * @param       player          [in]    handle of player
2054  * @param       uri             [out]   uri
2055  * @return      This function returns zero on success, or negative value with error code.
2056  *
2057  * @see
2058  * @remark      None
2059  */
2060 int mm_player_get_next_uri(MMHandleType player, char **uri);
2061
2062 int mm_player_enable_media_packet_video_stream(MMHandleType player, bool enable);
2063
2064 /**
2065  * This function is to increase reference count of internal buffer.
2066  *
2067  * @param       buffer          [in]   video callback internal buffer
2068  * @return      This function returns buffer point;
2069  *
2070  * @see
2071  * @remark      None
2072  */
2073 void * mm_player_media_packet_video_stream_internal_buffer_ref(void *buffer);
2074
2075 /**
2076  * This function is to decrease reference count of internal buffer.
2077  *
2078  * @param       buffer          [in]   video callback internal buffer
2079  * @return      None;
2080  *
2081  * @see
2082  * @remark      None
2083  */
2084 void mm_player_media_packet_video_stream_internal_buffer_unref(void *buffer);
2085
2086 /**mm_player_submit_packet
2087  * This function is to submit buffer to appsrc.  \n
2088  * @param       player                  [in]    Handle of player.
2089  * @param       buf             [in]    buffer to be submit in appsrc in external feeder case.
2090  * @param       len                             [in]    length of buffer.
2091  * @param       pts                             [in]    timestamp of buffer.
2092  * @param       streamtype              [in]    stream type of buffer.
2093  * @return      This function returns zero on success, or negative value with error code.
2094  * @par Example
2095  *
2096  * @endcode
2097  */
2098 int mm_player_submit_packet(MMHandleType player, media_packet_h packet);
2099
2100 /**mm_player_set_video_info
2101  * This function is to set caps of src pad of video appsrc in external feeder case.  \n
2102  * @param       player                          [in]    Handle of player.
2103  * @param       media_format_h                  [in]    Video stream info.
2104  * @return      This function returns zero on success, or negative value with error code.
2105  * @par Example
2106  *
2107  * @endcode
2108  */
2109 int mm_player_set_video_info (MMHandleType player, media_format_h format);
2110
2111 /**mm_player_set_audio_info
2112  * This function is to set caps of src pad of Audio appsrc in external feeder case.  \n
2113  * @param       player                       [in]    Handle of player.
2114  * @param       media_format_h               [in]    Audio stream info.
2115  * @return      This function returns zero on success, or negative value with error code.
2116  * @par Example
2117  *
2118  * @endcode
2119  */
2120 int mm_player_set_audio_info (MMHandleType player, media_format_h format);
2121
2122 /**mm_player_set_subtitle_info
2123  * This function is to set caps of src pad of subtitle appsrc in external feeder case.  \n
2124  * @param       player                          [in]    Handle of player.
2125  * @param       subtitle_stream_info               [in]    Subtitle stream info.
2126  * @return      This function returns zero on success, or negative value with error code.
2127  * @par Example
2128  *
2129  * @endcode
2130  */
2131 int mm_player_set_subtitle_info (MMHandleType player, MMPlayerSubtitleStreamInfo *info);
2132
2133 /**
2134  * This function set callback function for receiving need or enough data message from player.
2135  *
2136  * @param       player          [in]    Handle of player.
2137  * @param       type            [in]    stream type
2138  * @param       callback        [in]    data callback function for stream type.
2139  * @param       user_param      [in]    User parameter.
2140  *
2141  * @return      This function returns zero on success, or negative value with error
2142  *                      code.
2143  * @remark
2144  * @see
2145  * @since
2146  */
2147 int mm_player_set_media_stream_buffer_status_callback(MMHandleType player, MMPlayerStreamType type, mm_player_media_stream_buffer_status_callback callback, void * user_param);
2148
2149 /**
2150  * This function set callback function for receiving seek data message from player.
2151  *
2152  * @param       player          [in]    Handle of player.
2153  * @param       type            [in]    stream type
2154  * @param       callback        [in]    Seek data callback function for stream type.
2155  * @param       user_param      [in]    User parameter.
2156  *
2157  * @return      This function returns zero on success, or negative value with error
2158  *                      code.
2159  * @remark
2160  * @see
2161  * @since
2162  */
2163 int mm_player_set_media_stream_seek_data_callback(MMHandleType player, MMPlayerStreamType type, mm_player_media_stream_seek_data_callback callback, void * user_param);
2164
2165 /**
2166  * This function is to set max size of buffer(appsrc).
2167  *
2168  * @param       player          [in]    Handle of player.
2169  * @param       type            [in]    stream type
2170  * @param       max_size        [in]    max bytes of buffer.
2171  *
2172  * @return      This function returns zero on success, or negative value with error
2173  *                      code.
2174  * @remark
2175  * @see
2176  * @since
2177  */
2178 int mm_player_set_media_stream_buffer_max_size(MMHandleType player, MMPlayerStreamType type, unsigned long long max_size);
2179
2180 /**
2181  * This function is to get max size of buffer(appsrc).
2182  *
2183  * @param       player          [in]    Handle of player.
2184  * @param       type            [in]    stream type
2185  * @param       max_size        [out]   max bytes of buffer.
2186  *
2187  * @return      This function returns zero on success, or negative value with error
2188  *                      code.
2189  * @remark
2190  * @see
2191  * @since
2192  */
2193 int mm_player_get_media_stream_buffer_max_size(MMHandleType player, MMPlayerStreamType type, unsigned long long *max_size);
2194
2195 /**
2196  * This function is to set min percent of buffer(appsrc).
2197  *
2198  * @param       player          [in]    Handle of player.
2199  * @param       type            [in]    stream type
2200  * @param       min_percent     [in]    min percent of buffer.
2201  *
2202  * @return      This function returns zero on success, or negative value with error
2203  *                      code.
2204  * @remark
2205  * @see
2206  * @since
2207  */
2208 int mm_player_set_media_stream_buffer_min_percent(MMHandleType player, MMPlayerStreamType type, unsigned min_percent);
2209
2210 /**
2211  * This function is to get min percent of buffer(appsrc).
2212  *
2213  * @param       player          [in]    Handle of player.
2214  * @param       type            [in]    stream type
2215  * @param       min_percent     [out]   min percent of buffer.
2216  *
2217  * @return      This function returns zero on success, or negative value with error
2218  *                      code.
2219  * @remark
2220  * @see
2221  * @since
2222  */
2223 int mm_player_get_media_stream_buffer_min_percent(MMHandleType player, MMPlayerStreamType type, unsigned int *min_percent);
2224
2225 /**
2226  * This function set callback function for changing audio stream from player. \n
2227  * It's only supported when audio stream is included in file. \n
2228  *
2229  * @param       player   [in] Handle of player.
2230  * @param       callback [in] Audio stream changed callback function.
2231  * @param       user_param [in] User parameter.
2232  *
2233  * @return      This function returns zero on success, or negative value with error
2234  *                      code.
2235  * @see         mm_player_stream_changed_callback
2236  * @since
2237  */
2238 int mm_player_set_audio_stream_changed_callback(MMHandleType player, mm_player_stream_changed_callback callback, void *user_param);
2239
2240 /**
2241  * This function set callback function for changing video stream from player. \n
2242  * It's only supported when video stream is included in file. \n
2243  *
2244  * @param       player   [in] Handle of player.
2245  * @param       callback [in] Video stream changed callback function.
2246  * @param       user_param [in] User parameter.
2247  *
2248  * @return      This function returns zero on success, or negative value with error
2249  *                      code.
2250  * @see         mm_player_stream_changed_callback
2251  * @since
2252  */
2253 int mm_player_set_video_stream_changed_callback(MMHandleType player, mm_player_stream_changed_callback callback, void *user_param);
2254
2255 /**
2256  * This function check the content is streaming or not\n
2257  * It's only supported when video stream is included in file. \n
2258  *
2259  * @param       player   [in] Handle of player.
2260  * @param       is_streaming [out] flag of content type.
2261  *
2262  * @return      This function returns zero on success, or negative value with error
2263  *                      code.
2264  * @since 3.0
2265  */
2266 int mm_player_is_streaming(MMHandleType player, bool *is_streaming);
2267
2268 /**
2269         @}
2270  */
2271
2272 #ifdef __cplusplus
2273         }
2274 #endif
2275
2276 #endif  /* __MM_PLAYER_H__ */