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 /**
 656  * MM_PLAYER_DRC_MODE
 657  *
 658  * dynamic resolution change mode (int)
 659  */
 660 #define MM_PLAYER_DRC_MODE                                              "drc_mode"
 661
 662 /**
 663  * MM_PLAYER_GAPLESS
 664  *
 665  * gapless playback mode (int)
 666  */
 667 #define MM_PLAYER_GAPLESS_MODE                                  "gapless_mode"
 668
 669 #define BUFFER_MAX_PLANE_NUM (4)
 670
 671 typedef struct {
 672         MMPixelFormatType format;                       /**< image format */
 673         int width;                                              /**< width of video buffer */
 674         int height;                                             /**< height of video buffer */
 675         unsigned int timestamp;                         /**< timestamp of stream buffer (msec)*/
 676         unsigned int length_total;                      /**< total length of stream buffer (in byte)*/
 677         void *data[BUFFER_MAX_PLANE_NUM];
 678         void *bo[BUFFER_MAX_PLANE_NUM];  /**< TBM buffer object */
 679         void *internal_buffer;                          /**< Internal buffer pointer */
 680         int stride[BUFFER_MAX_PLANE_NUM];               /**< stride of plane */
 681         int elevation[BUFFER_MAX_PLANE_NUM];    /**< elevation of plane */
 682 }MMPlayerVideoStreamDataType;
 683
 684 /**
 685  * Enumerations of player state.
 686  */
 687 typedef enum {
 688         MM_PLAYER_STATE_NULL,                           /**< Player is created, but not realized yet */
 689         MM_PLAYER_STATE_READY,                          /**< Player is ready to play media */
 690         MM_PLAYER_STATE_PLAYING,                        /**< Player is now playing media */
 691         MM_PLAYER_STATE_PAUSED,                         /**< Player is paused while playing media */
 692         MM_PLAYER_STATE_NONE,                           /**< Player is not created yet */
 693         MM_PLAYER_STATE_NUM,                            /**< Number of player states */
 694 } MMPlayerStateType;
 695
 696 /**
 697  * Enumerations of position formats.
 698  * Used while invoking mm_player_get_position/mm_player_set_position APIs
 699  */
 700 typedef enum {
 701         MM_PLAYER_POS_FORMAT_TIME,                      /**< Format for time based */
 702         MM_PLAYER_POS_FORMAT_PERCENT,                   /**< Format for percentage */
 703         MM_PLAYER_POS_FORMAT_NUM,                       /**< Number of position formats */
 704 } MMPlayerPosFormatType;
 705
 706 /**
 707  * Enumeration for attribute values types.
 708  */
 709 typedef enum {
 710  MM_PLAYER_ATTRS_TYPE_INVALID = -1,        /**< Type is invalid */
 711  MM_PLAYER_ATTRS_TYPE_INT,                 /**< Integer type */
 712  MM_PLAYER_ATTRS_TYPE_DOUBLE,              /**< Double type */
 713  MM_PLAYER_ATTRS_TYPE_STRING,              /**< UTF-8 String type */
 714  MM_PLAYER_ATTRS_TYPE_DATA,                /**< Pointer type */
 715  MM_PLAYER_ATTRS_TYPE_ARRAY,               /**< Array type */
 716  MM_PLAYER_ATTRS_TYPE_RANGE,               /**< Range type */
 717  MM_PLAYER_ATTRS_TYPE_NUM,                 /**< Number of attribute type */
 718 } MMPlayerAttrsType;
 719
 720 /**
 721  * Enumeration for attribute validation type.
 722  */
 723 typedef enum {
 724  MM_PLAYER_ATTRS_VALID_TYPE_INVALID = -1,               /**< Invalid validation type */
 725  MM_PLAYER_ATTRS_VALID_TYPE_NONE,                               /**< Do not check validity */
 726  MM_PLAYER_ATTRS_VALID_TYPE_INT_ARRAY,          /**< validity checking type of integer array */
 727  MM_PLAYER_ATTRS_VALID_TYPE_INT_RANGE,          /**< validity checking type of integer range */
 728  MM_PLAYER_ATTRS_VALID_TYPE_DOUBLE_ARRAY,               /**< validity checking type of double array */
 729  MM_PLAYER_ATTRS_VALID_TYPE_DOUBLE_RANGE,       /**< validity checking type of double range */
 730 } MMPlayerAttrsValidType;
 731
 732 /**
 733  * Enumeration for attribute access flag.
 734  */
 735 typedef enum {
 736  MM_PLAYER_ATTRS_FLAG_NONE = 0,                                 /**< None flag is set */
 737  MM_PLAYER_ATTRS_FLAG_READABLE = 1 << 0,                        /**< Readable */
 738  MM_PLAYER_ATTRS_FLAG_WRITABLE = 1 << 1,                        /**< Writable */
 739  MM_PLAYER_ATTRS_FLAG_MODIFIED = 1 << 2,                        /**< Modified */
 740
 741  MM_PLAYER_ATTRS_FLAG_RW = MM_PLAYER_ATTRS_FLAG_READABLE | MM_PLAYER_ATTRS_FLAG_WRITABLE, /**< Readable and Writable */
 742 } MMPlayerAttrsFlag;
 743
 744 /**
 745  * Enumeration for progressive download
 746  */
 747 typedef enum {
 748         MM_PLAYER_PD_MODE_NONE,
 749         MM_PLAYER_PD_MODE_URI,
 750         MM_PLAYER_PD_MODE_FILE  // not tested yet, because of no fixed scenario
 751 }MMPlayerPDMode;
 752
 753 /**
 754  * Enumeration of track types
 755  */
 756 typedef enum {
 757         MM_PLAYER_TRACK_TYPE_AUDIO = 0,
 758         MM_PLAYER_TRACK_TYPE_VIDEO,
 759         MM_PLAYER_TRACK_TYPE_TEXT,
 760         MM_PLAYER_TRACK_TYPE_MAX
 761 }MMPlayerTrackType;
 762
 763 /**
 764  * Enumeration of runtime buffering mode
 765  */
 766 typedef enum {
 767         MM_PLAYER_BUFFERING_MODE_ADAPTIVE = 0,  /**< default, If buffering is occurred, player will consider the bandwidth to adjust buffer setting. */
 768         MM_PLAYER_BUFFERING_MODE_FIXED,                 /**< player will set buffer size with this fixed size value. */
 769         MM_PLAYER_BUFFERING_MODE_SLINK,                 /**< If buffering is occurred, player will adjust buffer setting and no more buffering will be occurred again. */
 770         MM_PLAYER_BUFFERING_MODE_MAX = MM_PLAYER_BUFFERING_MODE_SLINK,
 771 }MMPlayerBufferingMode;
 772
 773 /**
 774  * Enumeration of audio channel for video share
 775  */
 776 typedef enum
 777 {
 778         MM_PLAYER_AUDIO_CH_MONO_LEFT = 0,
 779         MM_PLAYER_AUDIO_CH_MONO_RIGHT,
 780         MM_PLAYER_AUDIO_CH_STEREO,
 781 } MMPlayerAudioChannel;
 782
 783 typedef enum
 784 {
 785         MM_PLAYER_FOCUS_CHANGED_COMPLETED = 0,
 786         MM_PLAYER_FOCUS_CHANGED_BY_MEDIA,
 787         MM_PLAYER_FOCUS_CHANGED_BY_CALL,
 788         MM_PLAYER_FOCUS_CHANGED_BY_EARJACK_UNPLUG,
 789         MM_PLAYER_FOCUS_CHANGED_BY_RESOURCE_CONFLICT,
 790         MM_PLAYER_FOCUS_CHANGED_BY_ALARM,
 791         MM_PLAYER_FOCUS_CHANGED_BY_EMERGENCY,
 792         MM_PLAYER_FOCUS_CHANGED_BY_NOTIFICATION,
 793         MM_PLAYER_FOCUS_CHANGED_BY_UNKNOWN,
 794 } MMPlayerFocusChangedMsg;
 795
 796
 797 /**
 798  * Edge Properties of the text.
 799  */
 800 typedef enum {
 801         MM_PLAYER_EDGE_NO,
 802         MM_PLAYER_EDGE_RAISED,
 803         MM_PLAYER_EDGE_DEPRESSED,
 804         MM_PLAYER_EDGE_UNIFORM,
 805         MM_PLAYER_EDGE_DROPSHADOW
 806 } MMPlayerSubtitleEdge;
 807
 808 /**
 809  * Enumeration of media stream buffer status
 810  */
 811 typedef enum
 812 {
 813         MM_PLAYER_MEDIA_STREAM_BUFFER_UNDERRUN,
 814         MM_PLAYER_MEDIA_STREAM_BUFFER_OVERFLOW,
 815 } MMPlayerMediaStreamBufferStatus;
 816
 817 /**
 818  * Enumeration for stream type.
 819  */
 820 typedef enum
 821 {
 822         MM_PLAYER_STREAM_TYPE_DEFAULT,  /**< Container type */
 823         MM_PLAYER_STREAM_TYPE_AUDIO,    /**< Audio element stream type */
 824         MM_PLAYER_STREAM_TYPE_VIDEO,    /**< Video element stream type */
 825         MM_PLAYER_STREAM_TYPE_TEXT,     /**< Text type */
 826         MM_PLAYER_STREAM_TYPE_MAX,
 827 } MMPlayerStreamType;
 828
 829 /**
 830  * Enumeration for pipeline type.
 831  */
 832 typedef enum
 833 {
 834         MM_PLAYER_PIPELINE_LEGACY,      /**< Legacy pipeline */
 835         MM_PLAYER_PIPELINE_SERVER,      /**< Pipeline for server(src,decoder,demux...) */
 836         MM_PLAYER_PIPELINE_CLIENT,      /**< Pipeline for client(sink)*/
 837         MM_PLAYER_PIPELINE_MAX
 838 } MMPlayerPipelineType;
 839
 840 /**
 841  * Attribute validity structure
 842  */
 843 typedef struct {
 844          MMPlayerAttrsType type;
 845          MMPlayerAttrsValidType validity_type;
 846          MMPlayerAttrsFlag flag;
 847         /**
 848           * a union that describes validity of the attribute.
 849           * Only when type is 'MM_ATTRS_TYPE_INT' or 'MM_ATTRS_TYPE_DOUBLE',
 850           * the attribute can have validity.
 851          */
 852          union {
 853                 /**
 854                    * Validity structure for integer array.
 855                  */
 856                 struct {
 857                         int *array;  /**< a pointer of array */
 858                         int count;   /**< size of array */
 859                         int d_val;
 860                 } int_array;
 861                 /**
 862                    * Validity structure for integer range.
 863                  */
 864                 struct {
 865                         int min;   /**< minimum range */
 866                         int max;   /**< maximum range */
 867                         int d_val;
 868                 } int_range;
 869                 /**
 870                 * Validity structure for double array.
 871                 */
 872                 struct {
 873                         double   * array;  /**< a pointer of array */
 874                         int    count;   /**< size of array */
 875                         double d_val;
 876                 } double_array;
 877                 /**
 878                 * Validity structure for double range.
 879                 */
 880                 struct {
 881                         double   min;   /**< minimum range */
 882                         double   max;   /**< maximum range */
 883                         double d_val;
 884                 } double_range;
 885         };
 886 } MMPlayerAttrsInfo;
 887
 888 /**
 889  * Volume type.
 890  *
 891  * @see         mm_player_set_volume, mm_player_get_volume
 892  */
 893 typedef struct {
 894         float   level[MM_VOLUME_CHANNEL_NUM];   /**< Relative volume factor for each channels */
 895 } MMPlayerVolumeType;
 896
 897 /**
 898  * Video stream info in external demux case
 899  *
 900 **/
 901 typedef struct _VideoStreamInfo
 902 {
 903         const char *mime;
 904         unsigned int framerate_num;
 905         unsigned int framerate_den;
 906         unsigned int width;
 907         unsigned int height;
 908         unsigned char *codec_extradata;
 909         unsigned int extradata_size;
 910         unsigned int version;
 911 }MMPlayerVideoStreamInfo;
 912
 913 /**
 914  * Audio stream info in external demux case
 915  *
 916 **/
 917 typedef struct _AudioStreamInfo
 918 {
 919         const char *mime;
 920         unsigned int channels;
 921         unsigned int sample_rate;
 922         unsigned char *codec_extradata;
 923         unsigned int extradata_size;
 924         unsigned int version;
 925         unsigned int user_info;
 926
 927         /* for pcm */
 928 //      unsigned int width;
 929 //      unsigned int depth;
 930 //      unsigned int endianness;
 931 //      bool signedness;
 932 }MMPlayerAudioStreamInfo;
 933
 934 /**
 935  * Subtitle stream info in external demux case
 936  *
 937 **/
 938 typedef struct _SubtitleStreamInfo
 939 {
 940         const char *mime;
 941         unsigned int codec_tag;
 942         void *context;  //for smpte text
 943 }MMPlayerSubtitleStreamInfo;
 944
 945 /**
 946  * Audio stream callback function type.
 947  *
 948  * @param       stream          [in]    Reference pointer to audio frame data
 949  * @param       stream_size     [in]    Size of audio frame data
 950  * @param       user_param      [in]    User defined parameter which is passed when set
 951  *                                                              audio stream callback
 952  *
 953  * @return      This callback function have to return MM_ERROR_NONE.
 954  */
 955 typedef bool    (*mm_player_audio_stream_callback) (void *stream, int stream_size, void *user_param);
 956
 957
 958 /**
 959  * selected subtitle track number callback function type.
 960  *
 961  * @param       track_num       [in]    Track number of subtitle
 962  * @param       user_param      [in]    User defined parameter
 963  *
 964  *
 965  * @return      This callback function have to return MM_ERROR_NONE.
 966  */
 967 typedef bool            (*mm_player_track_selected_subtitle_language_callback)(int track_num, void *user_param);
 968
 969 /**
 970  * Buffer underrun / overflow data callback function type.
 971  *
 972  * @param       status     [in] buffer status
 973  * @param       user_param [in] User defined parameter which is passed when set
 974  *                              to enough data callback or need data callback
 975  *
 976  * @return      This callback function have to return MM_ERROR_NONE.
 977  */
 978 typedef bool    (*mm_player_media_stream_buffer_status_callback) (MMPlayerStreamType type, MMPlayerMediaStreamBufferStatus status, unsigned long long bytes, void *user_param);
 979
 980 /**
 981  * Buffer seek data callback function type.
 982  *
 983  * @param       offset     [in] offset for the buffer playback
 984  * @param       user_param [in] User defined parameter which is passed when set
 985  *                              to seek data callback
 986  *
 987  * @return      This callback function have to return MM_ERROR_NONE.
 988  */
 989 typedef bool    (*mm_player_media_stream_seek_data_callback) (MMPlayerStreamType type, unsigned long long offset, void *user_param);
 990
 991 /**
 992  * Called to notify the stream changed.
 993  *
 994  * @param user_data [in] The user data passed from the callback registration function
 995  *
 996  * @return      This callback function have to return MM_ERROR_NONE.
 997  */
 998 typedef bool    (*mm_player_stream_changed_callback) (void *user_param);
 999
1000
1001 /*===========================================================================================
1002 |                                                                                           |
1003 |  GLOBAL FUNCTION PROTOTYPES                                        |
1004 |                                                                                           |
1005 ========================================================================================== */
1006
1007 /**
1008  * This function creates a player object for playing multimedia contents. \n
1009  * The attributes of player are created to get/set some values with application. \n
1010  * And, mutex, gstreamer and other resources are initialized at this time. \n
1011  * If player is created, the state will become MM_PLAYER_STATE_NULL.
1012  *
1013  * @param       player          [out]   Handle of player
1014  *
1015  * @return      This function returns zero on success, or negative value with error code. \n
1016  *                      Please refer 'mm_error.h' to know it in detail.
1017  * @pre         None
1018  * @post        MM_PLAYER_STATE_NULL
1019  * @see         mm_player_destroy
1020  * @remark      You can create multiple handles on a context at the same time. \n
1021  *                      However, player cannot guarantee proper operation because of limitation of resources, \n
1022  *                      such as audio device or display device.
1023  *
1024  * @par Example
1025  * @code
1026 char *g_err_attr_name = NULL;
1027
1028 if (mm_player_create(&g_player) != MM_ERROR_NONE)
1029 {
1030         LOGE("failed to create player\n");
1031 }
1032
1033 if (mm_player_set_attribute(g_player,
1034                                                 &g_err_attr_name,
1035                                                 "profile_uri", filename, strlen(filename),
1036                                                 "display_overlay", (void*)&g_win.xid, sizeof(g_win.xid),
1037                                                 NULL) != MM_ERROR_NONE)
1038 {
1039         LOGE("failed to set %s attribute\n", g_err_attr_name);
1040         free(g_err_attr_name);
1041 }
1042
1043 mm_player_set_message_callback(g_player, msg_callback, (void*)g_player);
1044  * @endcode
1045  */
1046 int mm_player_create(MMHandleType *player);
1047
1048 /**
1049  * This function releases player object and all resources which were created by mm_player_create(). \n
1050  * And, player handle will also be destroyed.
1051  *
1052  * @param       player          [in]    Handle of player
1053  *
1054  * @return      This function returns zero on success, or negative value with error code.
1055  * @pre         Player state may be MM_PLAYER_STATE_NULL. \n
1056  *                      But, it can be called in any state.
1057  * @post                Because handle is released, there is no any state.
1058  * @see         mm_player_create
1059  * @remark      This method can be called with a valid player handle from any state to \n
1060  *                      completely shutdown the player operation.
1061  *
1062  * @par Example
1063  * @code
1064 if (mm_player_destroy(g_player) != MM_ERROR_NONE)
1065 {
1066         LOGE("failed to destroy player\n");
1067 }
1068  * @endcode
1069  */
1070 int mm_player_destroy(MMHandleType player);
1071
1072 /**
1073  * This function register the sound focus using application PID \n
1074  * So, application PID should be set before realizing with mm_player_set_attribute(). \n
1075  *
1076  * @param       player          [in]    Handle of player
1077  * @param       pid                     [in]    application PID
1078  *
1079  * @return      This function returns zero on success, or negative value with error code.
1080  *
1081  * @pre         Player state should be MM_PLAYER_STATE_NULL.
1082  * @remark      None
1083  */
1084 int mm_player_sound_register(MMHandleType player, int pid);
1085
1086 /**
1087  * This function get the application PID that is registered \n
1088  * So, application PID should be set before realizing with mm_player_set_attribute(). \n
1089  *
1090  * @param       player          [in]    Handle of player
1091  * @param       pid                     [out]   application PID
1092  *
1093  * @return      This function returns zero on success, or negative value with error code.
1094  *
1095  * @pre         Player state should be MM_PLAYER_STATE_NULL.
1096  * @remark      None
1097  */
1098 int mm_player_get_client_pid (MMHandleType player, int* pid);
1099
1100 /**
1101  * This function parses uri and makes gstreamer pipeline by uri scheme. \n
1102  * So, uri should be set before realizing with mm_player_set_attribute(). \n
1103  *
1104  * @param       player          [in]    Handle of player
1105  *
1106  * @return      This function returns zero on success, or negative value with error code.
1107  *
1108  * @pre         Player state should be MM_PLAYER_STATE_NULL.
1109  * @post                Player state will be MM_PLAYER_STATE_READY.
1110  * @see         mm_player_unrealize
1111  * @remark      None
1112  * @par Example
1113  * @code
1114 if (mm_player_realize(g_player) != MM_ERROR_NONE)
1115 {
1116         LOGE("failed to realize player\n");
1117 }
1118  * @endcode
1119  */
1120 int mm_player_realize(MMHandleType player) ;
1121
1122 /**
1123  * This function uninitializes player object. So, resources and allocated memory \n
1124  * will be freed. And, gstreamer pipeline is also destroyed. So, if you want to play \n
1125  * other contents, player should be created again after destruction or realized with new uri.
1126  *
1127  * @param       player          [in]    Handle of player
1128  *
1129  * @return      This function returns zero on success, or negative value with error code.
1130  * @pre         Player state may be MM_PLAYER_STATE_READY to unrealize. \n
1131  *                      But, it can be called in any state.
1132  * @post                Player state will be MM_PLAYER_STATE_NULL.
1133  * @see         mm_player_realize
1134  * @remark      This method can be called with a valid player handle from any state.
1135  *
1136  * @par Example
1137  * @code
1138 if (mm_player_unrealize(g_player) != MM_ERROR_NONE)
1139 {
1140         LOGE("failed to unrealize player\n");
1141 }
1142  * @endcode
1143  */
1144 int mm_player_unrealize(MMHandleType player);
1145
1146 /**
1147  * This function is to get current state of player. \n
1148  * Application have to check current state before doing some action.
1149  *
1150  * @param       player          [in]    Handle of player
1151  * @param       state       [out] current state of player on success
1152  *
1153  * @return      This function returns zero on success, or negative value with error code.
1154  *
1155  * @see         MMPlayerStateType
1156  * @remark      None
1157  * @par Example
1158  * @code
1159 if (mm_player_get_state(g_player, &state) != MM_ERROR_NONE)
1160 {
1161         LOGE("failed to get state\n");
1162 }
1163  * @endcode
1164  */
1165 int mm_player_get_state(MMHandleType player, MMPlayerStateType *state);
1166
1167 /**
1168  * This function is to set relative volume of player. \n
1169  * So, It controls logical volume value. \n
1170  * But, if developer want to change system volume, mm sound api should be used.
1171  *
1172  * @param       player          [in]    Handle of player
1173  * @param       volume          [in]    Volume factor of each channel
1174  *
1175  * @return      This function returns zero on success, or negative value with error code.
1176  * @see         MMPlayerVolumeType, mm_player_get_volume
1177  * @remark      The range of factor range is from 0 to 1.0. (1.0 = 100%) And, default value is 1.0.
1178  * @par Example
1179  * @code
1180 MMPlayerVolumeType volume;
1181 int i = 0;
1182
1183 for (i = 0; i < MM_VOLUME_CHANNEL_NUM; i++)
1184         volume.level[i] = MM_VOLUME_LEVEL_MAX;
1185
1186 if (mm_player_set_volume(g_player, &volume) != MM_ERROR_NONE)
1187 {
1188     LOGE("failed to set volume\n");
1189 }
1190  * @endcode
1191  */
1192 int mm_player_set_volume(MMHandleType player, MMPlayerVolumeType *volume);
1193
1194 /**
1195  * This function is to get current volume factor of player.
1196  *
1197  * @param       player          [in]    Handle of player.
1198  * @param       volume          [out]   Volume factor of each channel.
1199  *
1200  * @return      This function returns zero on success, or negative value with error code.
1201  *
1202  * @see         MMPlayerVolumeType, mm_player_set_volume
1203  * @remark      None
1204  * @par Example
1205  * @code
1206 MMPlayerVolumeType volume;
1207 int i;
1208
1209 if (mm_player_get_volume(g_player, &volume) != MM_ERROR_NONE)
1210 {
1211         LOGW("failed to get volume\n");
1212 }
1213
1214 for (i = 0; i < MM_VOLUME_CHANNEL_NUM; i++)
1215         LOGD("channel[%d] = %d \n", i, volume.level[i]);
1216  * @endcode
1217  */
1218 int mm_player_get_volume(MMHandleType player, MMPlayerVolumeType *volume);
1219
1220 /**
1221  * This function is to start playing media contents. Demux(parser), codec and related plugins are decided \n
1222  * at this time. And, MM_MESSAGE_BEGIN_OF_STREAM will be posted through callback function registered \n
1223  * by mm_player_set_message_callback().
1224  *
1225  * @param       player          [in]    Handle of player
1226  *
1227  * @return      This function returns zero on success, or negative value with error code.
1228  * @remark
1229  *
1230  * @pre         Player state may be MM_PLAYER_STATE_READY.
1231  * @post                Player state will be MM_PLAYER_STATE_PLAYING.
1232  * @see         mm_player_stop
1233  * @remark      None
1234  * @par Example
1235  * @code
1236 if (mm_player_start(g_player) != MM_ERROR_NONE)
1237 {
1238         LOGE("failed to start player\n");
1239 }
1240  * @endcode
1241  */
1242 int mm_player_start(MMHandleType player);
1243
1244 /**
1245  * This function is to stop playing media contents and it's different with pause. \n
1246  * If mm_player_start() is called after this, content will be started again from the beginning. \n
1247  * So, it can be used to close current playback.
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_READY.
1255  * @see         mm_player_start
1256  * @remark      None
1257  * @par Example
1258  * @code
1259 if (mm_player_stop(g_player) != MM_ERROR_NONE)
1260 {
1261         LOGE("failed to stop player\n");
1262 }
1263  * @endcode
1264  */
1265 int mm_player_stop(MMHandleType player);
1266
1267 /**
1268  * This function is to pause playing 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_PLAYING.
1275  * @post                Player state will be MM_PLAYER_STATE_PAUSED.
1276  * @see         mm_player_resume
1277  * @remark      None
1278  * @par Example
1279  * @code
1280 if (mm_player_pause(g_player) != MM_ERROR_NONE)
1281 {
1282         LOGE("failed to pause player\n");
1283 }
1284  * @endcode
1285  */
1286 int mm_player_pause(MMHandleType player);
1287
1288 /**
1289  * This function is to resume paused media contents.
1290  *
1291  * @param       player          [in]    Handle of player.
1292  *
1293  * @return      This function returns zero on success, or negative value with error code.
1294  *
1295  * @pre         Player state may be MM_PLAYER_STATE_PAUSED.
1296  * @post                Player state will be MM_PLAYER_STATE_PLAYING.
1297  * @see         mm_player_pause
1298  * @remark      None
1299  * @par Example
1300  * @code
1301 if (mm_player_resume(g_player) != MM_ERROR_NONE)
1302 {
1303         LOGE("failed to resume player\n");
1304 }
1305  * @endcode
1306  */
1307 int mm_player_resume(MMHandleType player);
1308
1309 /**
1310  * This function is to set the position for playback. \n
1311  * So, it can be seeked to requested position. \n
1312  *
1313  * @param       player          [in]    Handle of player
1314  * @param       format          [in]    Format of position.
1315  * @param       pos                     [in]    Position for playback
1316  *
1317  * @return      This function returns zero on success, or negative value with error code.
1318  * @see         MMPlayerPosFormatType, mm_player_get_position
1319  * @remark  the unit of time-based format is millisecond and other case is percent.
1320  * @par Example
1321  * @code
1322 int position = 1000; //1sec
1323
1324 if (mm_player_set_position(g_player, MM_PLAYER_POS_FORMAT_TIME, position) != MM_ERROR_NONE)
1325 {
1326         LOGE("failed to set position\n");
1327 }
1328  * @endcode
1329  */
1330 int mm_player_set_position(MMHandleType player, MMPlayerPosFormatType format, int pos);
1331
1332 /**
1333  * This function is to get current position of playback content.
1334  *
1335  * @param       player          [in]    Handle of player.
1336  * @param       format          [in]    Format of position.
1337  * @param    pos        [out] contains current position on success or zero in case of failure.
1338  *
1339  * @return      This function returns zero on success, or negative value with errors
1340  * @see         MMPlayerPosFormatType, mm_player_set_position
1341  * @remark      the unit of time-based format is millisecond and other case is percent.
1342  * @par Example
1343  * @code
1344 int position = 0;
1345 int duration = 0;
1346
1347 mm_player_get_position(g_player, MM_PLAYER_POS_FORMAT_TIME, &position);
1348
1349 mm_player_get_attribute(g_player, &g_err_name, "content_duration", &duration, NULL);
1350
1351 LOGD("pos: [%d/%d] msec\n", position, duration);
1352  * @endcode
1353  */
1354 int mm_player_get_position(MMHandleType player, MMPlayerPosFormatType format, unsigned long *pos);
1355
1356 /**
1357  * This function is to get current buffer position of playback content.
1358  *
1359  * @param       player          [in]    Handle of player.
1360  * @param       format          [in]    Format of position.
1361  * @param       start_pos               [out] contains buffer start  position on success or zero in case of failure.
1362  * @param       stop_pos        [out] contains buffer current  position on success or zero in case of failure.
1363  *
1364  * @return      This function returns zero on success, or negative value with errors
1365  * @see         MMPlayerPosFormatType, mm_player_set_position
1366  * @remark      the unit of time-based format is millisecond and other case is percent.
1367  * @par Example
1368  * @code
1369 int start_pos = 0, stop_pos = 0;
1370
1371 mm_player_get_buffer_position(g_player, MM_PLAYER_POS_FORMAT_PERCENT, &start_pos, &stop_pos );
1372
1373 LOGD("buffer position: [%d] ~ [%d] \%\n", start_pos, stop_pos );
1374  * @endcode
1375  */
1376 int mm_player_get_buffer_position(MMHandleType player, MMPlayerPosFormatType format, unsigned long *start_pos, unsigned long *stop_pos);
1377
1378 /**
1379  * This function is to activate the section repeat. If it's set, selected section will be played \n
1380  * continually before deactivating it by mm_player_deactivate_section_repeat(). \n
1381  * The unit for setting is millisecond.
1382  *
1383  * @param       player          [in]    Handle of player.
1384  * @param       start_pos               [in]    start position.
1385  * @param       end_pos                 [in]    end position.
1386  *
1387  * @return      This function returns zero on success, or negative value with error code.
1388  * @see         mm_player_deactivate_section_repeat
1389  * @remark      None
1390  * @par Example
1391  * @code
1392 int position;
1393 int endtime = 4000; //msec
1394
1395 mm_player_get_position(g_player, MM_PLAYER_POS_FORMAT_TIME, &position);
1396
1397 mm_player_activate_section_repeat(g_player, position, position+endtime);
1398  * @endcode
1399  */
1400 int mm_player_activate_section_repeat(MMHandleType player, int start_pos, int end_pos);
1401
1402 /**
1403  * This function is to deactivate the section repeat.
1404  *
1405  * @param       player          [in]    Handle of player.
1406  *
1407  * @return      This function returns zero on success, or negative value with error code.
1408  * @see         mm_player_activate_section_repeat
1409  * @remark      None
1410  * @par Example
1411  * @code
1412 if ( mm_player_deactivate_section_repeat(g_player) != MM_ERROR_NONE)
1413 {
1414         LOGW("failed to deactivate section repeat\n");
1415 }
1416  * @endcode
1417  */
1418 int mm_player_deactivate_section_repeat(MMHandleType player);
1419
1420 /**
1421  * This function sets callback function for receiving messages from player.
1422  * So, player can notify warning, error and normal cases to application.
1423  *
1424  * @param       player          [in]    Handle of player.
1425  * @param       callback        [in]    Message callback function.
1426  * @param       user_param      [in]    User parameter which is passed to callback function.
1427  *
1428  * @return      This function returns zero on success, or negative value with error code.
1429  * @see         MMMessageCallback
1430  * @remark      None
1431  * @par Example
1432  * @code
1433 int msg_callback(int message, MMMessageParamType *param, void *user_param)
1434 {
1435         switch (message)
1436         {
1437                 case MM_MESSAGE_ERROR:
1438                         //do something
1439                         break;
1440
1441                 case MM_MESSAGE_END_OF_STREAM:
1442                         //do something
1443                         break;
1444
1445                 case MM_MESSAGE_STATE_CHANGED:
1446                         //do something
1447                         break;
1448
1449                 case MM_MESSAGE_BEGIN_OF_STREAM:
1450                         //do something
1451                         break;
1452
1453                 default:
1454                         break;
1455         }
1456         return TRUE;
1457 }
1458
1459 mm_player_set_message_callback(g_player, msg_callback, (void*)g_player);
1460  * @endcode
1461  */
1462 int mm_player_set_message_callback(MMHandleType player, MMMessageCallback callback, void *user_param);
1463
1464 /**
1465  * This function set callback function for receiving audio stream from player. \n
1466  * So, application can get raw audio data and modify it. \n
1467  * But, if callback don't return or holds it for long time, performance can be deteriorated. \n
1468  * It's only supported when audio stream is included in file. \n
1469  * So, if there is video stream or DRM content, it can't be used.
1470  *
1471  * @param       player          [in]    Handle of player.
1472  * @param       callback                [in]    Audio stream callback function.
1473  * @param       user_param      [in]    User parameter.
1474  *
1475  * @return      This function returns zero on success, or negative value with error
1476  *                      code.
1477  * @see         mm_player_audio_stream_callback
1478  * @remark      It can be used for audio playback only.
1479  * @par Example
1480  * @code
1481 bool audio_callback(void *stream, int stream_size, void *user_param)
1482 {
1483         LOGD("audio stream callback\n");
1484         return TRUE;
1485 }
1486 mm_player_set_audio_stream_callback(g_player, audio_callback, NULL);
1487  * @endcode
1488  */
1489  int mm_player_set_audio_stream_callback(MMHandleType player, mm_player_audio_stream_callback callback, void *user_param);
1490
1491 /**
1492  * This function is to mute volume of player
1493  *
1494  * @param       player  [in]    Handle of player
1495  * @param       mute    [in]    Mute(1) or not mute(0)
1496  *
1497  * @return      This function returns zero on success, or negative value with error code
1498  * @see         mm_player_get_mute
1499  * @remark      None
1500  * @par Example
1501  * @code
1502 if (mm_player_set_mute(g_player, TRUE) != MM_ERROR_NONE)
1503 {
1504         LOGW("failed to set mute\n");
1505 }
1506  * @endcode
1507  */
1508 int mm_player_set_mute(MMHandleType player, int mute);
1509
1510 /**
1511  * This function is to get mute value of player
1512  *
1513  * @param       player  [in]    Handle of player
1514  * @param       mute    [out]   Sound is muted
1515  *
1516  * @return      This function returns zero on success, or negative value with error code
1517  * @see         mm_player_set_mute
1518  * @remark      None
1519  * @par Example
1520  * @code
1521 int mute;
1522
1523 if (mm_player_get_mute(g_player, &mute) != MM_ERROR_NONE)
1524 {
1525         LOGW("failed to get mute\n");
1526 }
1527
1528 LOGD("mute status:%d\n", mute);
1529  * @endcode
1530  */
1531 int mm_player_get_mute(MMHandleType player, int *mute);
1532
1533 /**
1534  * This function is to adjust subtitle postion. So, subtitle can show at the adjusted position. \n
1535  * If pos is negative, subtitle will be displayed previous time, the other hand forward time. \n
1536  *
1537  * @param       player  [in]    Handle of player
1538  * @param       pos             [in]    postion to be adjusted
1539  *
1540  * @return      This function returns zero on success, or negative value with error
1541  *                      code
1542  * @see         mm_player_adjust_subtitle_position
1543  * @remark      None
1544  * @par Example
1545  * @code
1546 int pos;
1547
1548 pos = 5000;
1549 if (mm_player_adjust_subtitle_position(g_player, MM_PLAYER_POS_FORMAT_TIME, pos) != MM_ERROR_NONE)
1550 {
1551         LOGW("failed to adjust subtitle postion.\n");
1552 }
1553  * @endcode
1554  */
1555
1556 int mm_player_adjust_subtitle_position(MMHandleType player, MMPlayerPosFormatType format, int pos);
1557
1558 /**
1559  * This function is to set the offset in timestamps of video so as to bring the a/v sync
1560  * @param      player          Handle of player
1561  * @param      offset          offset to be set in milliseconds(can be positive or negative both)
1562  * postive offset to make video lag
1563  * negative offset to make video lead
1564  */
1565 int mm_player_adjust_video_position(MMHandleType player,int offset);
1566 /**
1567  * This function is to set subtitle silent status. So, subtitle can show or hide during playback \n
1568  * by this value. But, one subtitle file should be set with "subtitle_uri" attribute before calling mm_player_realize(); \n
1569  * Player FW parses subtitle file and send text data including timestamp to application \n
1570  * through message callback with MM_MESSAGE_UPDATE_SUBTITLE will be. \n
1571  * So, application have to render it. And, subtitle can be supported only in a seprate file. \n
1572  * So, it's not supported for embedded case.
1573  *
1574  * @param       player  [in]    Handle of player
1575  * @param       silent  [in]    silent(integer value except 0) or not silent(0)
1576  *
1577  * @return      This function returns zero on success, or negative value with error
1578  *                      code
1579  * @see         mm_player_get_subtitle_silent, MM_MESSAGE_UPDATE_SUBTITLE
1580  * @remark      None
1581  * @par Example
1582  * @code
1583 mm_player_set_attribute(g_player,
1584                                         &g_err_name,
1585                                         "subtitle_uri", g_subtitle_uri, strlen(g_subtitle_uri),
1586                                         NULL
1587                                         );
1588
1589 if (mm_player_set_subtitle_silent(g_player, TRUE) != MM_ERROR_NONE)
1590 {
1591         LOGW("failed to set subtitle silent\n");
1592 }
1593  * @endcode
1594  */
1595 int mm_player_set_subtitle_silent(MMHandleType player, int silent);
1596
1597 /**
1598  * This function is to get silent status of subtitle.
1599  *
1600  * @param       player  [in]    Handle of player
1601  * @param       silent  [out]   subtitle silent property
1602  *
1603  * @return      This function returns zero on success, or negative value with error
1604  *                      code
1605  * @see         mm_player_set_subtitle_silent, MM_MESSAGE_UPDATE_SUBTITLE
1606  * @remark      None
1607  * @par Example
1608  * @code
1609 int silent = FALSE;
1610
1611 if (mm_player_get_subtitle_silent(g_player, &silent) != MM_ERROR_NONE)
1612 {
1613         LOGW("failed to set subtitle silent\n");
1614 }
1615  * @endcode
1616  */
1617 int mm_player_get_subtitle_silent(MMHandleType player, int *silent);
1618
1619 /**
1620  * This function is to set attributes into player. Multiple attributes can be set simultaneously. \n
1621  * If one of attribute fails, this function will stop at the point and let you know the name which is failed. \n
1622  *
1623  * @param       player                          [in]    Handle of player.
1624  * @param       err_attr_name                   [out]  Name of attribute which is failed to set
1625  * @param       first_attribute_name    [in]    Name of the first attribute to set
1626  * @param   ...                                 [in]    Value for the first attribute, followed optionally by more name/value pairs, terminated by NULL.
1627  *                                                                       But, in the case of data or string type, it should be name/value/size.
1628  *
1629  * @return      This function returns zero on success, or negative value with error code.
1630  *
1631  * @see         mm_player_get_attribute
1632  * @remark      This function must be terminated by NULL argument.
1633  *                      And, if this function is failed, err_attr_name param must be free.
1634  * @par Example
1635  * @code
1636 char *g_err_attr_name = NULL;
1637
1638 if (mm_player_set_attribute(g_player,
1639                                                 &g_err_attr_name,
1640                                                 "profile_uri", filename, strlen(filename),
1641                                                 "profile_play_count", count,
1642                                                 NULL) != MM_ERROR_NONE)
1643 {
1644         LOGW("failed to set %s attribute\n", g_err_attr_name);
1645         free(g_err_attr_name);
1646 }
1647
1648  * @endcode
1649  */
1650 int mm_player_set_attribute(MMHandleType player,  char **err_attr_name, const char *first_attribute_name, ...)G_GNUC_NULL_TERMINATED;
1651
1652 /**
1653  * This function is to get attributes from player. Multiple attributes can be got simultaneously.
1654  *
1655  * @param       player                          [in]    Handle of player.
1656  * @param       err_attr_name                   [out]  Name of attribute which is failed to get
1657  * @param       first_attribute_name    [in]    Name of the first attribute to get
1658  * @param       ...                                     [out] Value for the first attribute, followed optionally by more name/value pairs, terminated by NULL.
1659  *                                                                       But, in the case of data or string type, it should be name/value/size.
1660  *
1661  * @return      This function returns zero on success, or negative value with error
1662  *                      code.
1663  * @see         mm_player_set_attribute
1664  * @remark      This function must be terminated by NULL argument.
1665  *                      And, if this function is failed, err_attr_name param must be free.
1666  * @par Example
1667  * @code
1668 char *g_err_attr_name = NULL;
1669
1670 if (mm_player_get_attribute(g_player, &g_err_attr_name, "content_duration", &duration, NULL) != MM_ERROR_NONE)
1671 {
1672         LOGW("failed to set %s attribute\n", g_err_attr_name);
1673         free(g_err_attr_name);
1674 }
1675  * @endcode
1676  */
1677 int mm_player_get_attribute(MMHandleType player,  char **err_attr_name, const char *first_attribute_name, ...)G_GNUC_NULL_TERMINATED;
1678
1679 /**
1680  * This function is to get detail information of attribute.
1681  *
1682  * @param       player                           [in]   Handle of player.
1683  * @param   attribute_name               [in]   Name of the attribute to get
1684  * @param   info                                 [out]  Attribute infomation
1685  *
1686  * @return      This function returns zero on success, or negative value with error
1687  *                      code.
1688  *
1689  * @see         mm_player_set_attribute, mm_player_get_attribute
1690  * @remark      None
1691  * @par Example
1692  * @code
1693 if (mm_player_get_attribute_info (g_player, "display_method", &method_info) != MM_ERROR_NONE)
1694 {
1695         LOGW("failed to get info\n");
1696 }
1697
1698 LOGD("type:%d \n", method_info.type); //int, double..
1699 LOGD("flag:%d \n", method_info.flag); //readable, writable..
1700 LOGD("validity type:%d \n", method_info.validity_type); //range, array..
1701
1702 if (method_info. validity_type == MM_PLAYER_ATTRS_VALID_TYPE_INT_RANGE)
1703 {
1704         LOGD("range min:%d\n", method_info.int_range.min);
1705         LOGD("range max:%d\n", method_info.int_range.max);
1706 }
1707  * @endcode
1708  */
1709 int mm_player_get_attribute_info(MMHandleType player,  const char *attribute_name, MMPlayerAttrsInfo *info);
1710
1711 /**
1712  * This function is to get download position and total size of progressive download
1713  *
1714  * @param       player          [in]    Handle of player.
1715  * @param       current_pos     [in]    Download position currently (bytes)
1716  * @param       total_size      [in]    Total size of file (bytes)
1717  *
1718  * @return      This function returns zero on success, or negative value with error code.
1719  *
1720  * @see
1721  * @remark
1722  * @par Example
1723  * @code
1724 guint64 current_pos = 0LLU;
1725 guint64 total_size = 0LLU;
1726
1727 if (mm_player_get_pd_status(g_player, &current_pos, &total_size, NULL) != MM_ERROR_NONE)
1728 {
1729         LOGD("current download pos = %llu, total size = %llu\n", current_pos, total_size);
1730 }
1731  * @endcode
1732  */
1733 int mm_player_get_pd_status(MMHandleType player, guint64 *current_pos, guint64 *total_size);
1734
1735 /**
1736  * This function sets callback function for receiving messages of PD downloader.
1737  *
1738  * @param       player          [in]    Handle of player.
1739  * @param       callback                [in]    Message callback function.
1740  * @param       user_param      [in]    User parameter which is passed to callback function.
1741  *
1742  * @return      This function returns zero on success, or negative value with error code.
1743  * @see
1744  * @remark      None
1745  * @par Example
1746  * @code
1747 int msg_callback(int message, MMMessageParamType *param, void *user_param)
1748 {
1749         switch (message)
1750         {
1751                 case MM_MESSAGE_PD_DOWNLOADER_START:
1752                         LOGD("Progressive download is started...\n");
1753                         break;
1754                 case MM_MESSAGE_PD_DOWNLOADER_END:
1755                         LOGD("Progressive download is ended...\n");
1756                         break;
1757                 default:
1758                         break;
1759         }
1760         return TRUE;
1761 }
1762
1763 mm_player_set_pd_message_callback(g_player, msg_callback, NULL);
1764  * @endcode
1765  */
1766 int mm_player_set_pd_message_callback(MMHandleType player, MMMessageCallback callback, void *user_param);
1767
1768 /**
1769  * This function is to get the track count
1770  *
1771  * @param       player          [in]    handle of player.
1772  * @param       track                   [in]    type of the track type
1773  * @param       info                    [out]   the count of the track
1774  *
1775  * @return      This function returns zero on success, or negative value with error
1776  *                      code.
1777  *
1778  * @see
1779  * @remark      None
1780  * @par Example
1781  * @code
1782 gint audio_count = 0;
1783
1784 if (mm_player_get_track_count (g_player, MM_PLAYER_TRACK_TYPE_AUDIO, &audio_count) != MM_ERROR_NONE)
1785 {
1786         LOGW("failed to get audio track count\n");
1787 }
1788
1789 LOGD("audio track count : %d \n", audio_count);
1790  * @endcode
1791  */
1792 int mm_player_get_track_count(MMHandleType player,  MMPlayerTrackType type, int *count);
1793
1794 /**
1795  * This function is to select the track
1796  *
1797  * @param       player          [in]    handle of player.
1798  * @param       type                    [in]    type of the track type
1799  * @param       index           [in]    the index of the track
1800  *
1801  * @return      This function returns zero on success, or negative value with error
1802  *                      code.
1803  *
1804  * @see
1805  * @remark      None
1806  */
1807 int mm_player_select_track(MMHandleType player, MMPlayerTrackType type, int index);
1808 #ifdef _MULTI_TRACK
1809 /**
1810  * This function is to add the track when user want multi subtitle
1811  *
1812  * @param       player          [in]    handle of player.
1813  * @param       index           [in]    the index of the track
1814  *
1815  * @return      This function returns zero on success, or negative value with error
1816  *                      code.
1817  *
1818  * @see
1819  * @remark      None
1820  */
1821 int mm_player_track_add_subtitle_language(MMHandleType player, int index);
1822
1823 /**
1824  * This function is to remove the track when user want multi subtitle
1825  *
1826  * @param       player          [in]    handle of player.
1827  * @param       index           [in]    the index of the track
1828  *
1829  * @return      This function returns zero on success, or negative value with error
1830  *                      code.
1831  *
1832  * @see
1833  * @remark      None
1834  */
1835 int mm_player_track_remove_subtitle_language(MMHandleType player, int index);
1836
1837 /**
1838  * This function is to notify which sutitle track is in use
1839  *
1840  * @param       player          [in]    handle of player.
1841  * @param       callback                        [in]    callback function to register
1842  * @param       user_data       [in]    user data to be passed to the callback function
1843  *
1844  * @return      This function returns zero on success, or negative value with error
1845  *                      code.
1846  *
1847  * @see
1848  * @remark      None
1849  */
1850 int mm_player_track_foreach_selected_subtitle_language(MMHandleType player, mm_player_track_selected_subtitle_language_callback callback, void *user_param);
1851 #endif
1852 /**
1853  * This function is to get the track language
1854  *
1855  * @param       player          [in]    handle of player.
1856  * @param       type                    [in]    type of the track type
1857  * @param       index           [in]    the index of the track
1858  * @param       code                    [out] language code in ISO 639-1(string)
1859  *
1860  * @return      This function returns zero on success, or negative value with error
1861  *                      code.
1862  *
1863  * @see
1864  * @remark      None
1865  */
1866 int mm_player_get_track_language_code(MMHandleType player,  MMPlayerTrackType type, int index, char **code);
1867
1868 /**
1869  * This function is to get the current running track
1870  *
1871  * @param       player          [in]    handle of player.
1872  * @param       type                    [in]    type of the track type
1873  * @param       index           [out]    the index of the track
1874  *
1875  * @return      This function returns zero on success, or negative value with error
1876  *                      code.
1877  *
1878  * @see
1879  * @remark      None
1880  */
1881
1882 int mm_player_get_current_track(MMHandleType hplayer, MMPlayerTrackType type, int *index);
1883
1884 /**
1885  * This function is to set the buffer size for streaming playback. \n
1886  *
1887  * @param       player          [in]    Handle of player
1888  * @param       second          [in]    Size of initial buffer
1889  *
1890  * @return      This function returns zero on success, or negative value with error code.
1891  * @remark  None
1892  * @par Example
1893  * @code
1894 gint second = 10; //10sec
1895
1896 if (mm_player_set_prepare_buffering_time(g_player, second) != MM_ERROR_NONE)
1897 {
1898         LOGE("failed to set buffer size\n");
1899 }
1900  * @endcode
1901  */
1902
1903 int mm_player_set_prepare_buffering_time(MMHandleType player, int second);
1904
1905 /**
1906  * This function is to set the runtime buffering mode for streaming playback. \n
1907  *
1908  * @param       player          [in]    Handle of player
1909  * @param       mode            [in]    mode of runtime buffering
1910  * @param       second          [in]    max size of buffering
1911  *
1912  * @return      This function returns zero on success, or negative value with error code.
1913  * @remark  None
1914  * @par Example
1915  * @code
1916
1917 if (mm_player_set_runtime_buffering_mode(g_player, MM_PLAYER_BUFFERING_MODE_ADAPTIVE, 10) != MM_ERROR_NONE)
1918 {
1919         LOGE("failed to set buffering mode\n");
1920 }
1921  * @endcode
1922  */
1923
1924 int mm_player_set_runtime_buffering_mode(MMHandleType player, MMPlayerBufferingMode mode, int second);
1925
1926 /**
1927  * This function is to set the start position of zoom
1928  *
1929  * @param       player          [in]    handle of player
1930  * @param       level           [in]    level of zoom
1931  * @param       x               [in]    start x position
1932  * @param       y               [in]    start y position
1933  *
1934  * @return      This function returns zero on success, or negative value with error
1935  *                      code.
1936  *
1937  * @see
1938  * @remark      None
1939  */
1940 int mm_player_set_display_zoom(MMHandleType player, float level, int x, int y);
1941
1942 /**
1943  * This function is to get the start position of zoom
1944  *
1945  * @param       player           [in]    handle of player
1946  * @param       type            [out]    current level of zoom
1947  * @param       x               [out]    start x position
1948  * @param       y               [out]    start y position
1949  *
1950  * @return      This function returns zero on success, or negative value with error
1951  *                      code.
1952  *
1953  * @see
1954  * @remark      None
1955  */
1956 int mm_player_get_display_zoom(MMHandleType player, float *level, int *x, int *y);
1957
1958 /**
1959  * This function is to set the subtitle path
1960  *
1961  * @param       player  [in]    handle of player
1962  * @param       path    [in]    subtitle path
1963  *
1964  * @return      This function returns zero on success, or negative value with error code.
1965  *
1966  * @see
1967  * @remark      None
1968  */
1969 int mm_player_set_external_subtitle_path(MMHandleType player, const char* path);
1970
1971 /**
1972  * This function is to set the clock which is from master player
1973  *
1974  * @param       player  [in]    handle of player
1975  * @param       clock   [in]    clock of master player
1976  * @param       clock_delta [in]        clock difference between master and slave
1977  * @param       video_time      [in]    current playing position
1978  * @param       media_clock     [in]    media clock information
1979  * @param       audio_time      [in]    audio timestamp information
1980  * @return      This function returns zero on success, or negative value with error code.
1981  *
1982  * @see
1983  * @remark      None
1984  */
1985 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);
1986 /**
1987  * This function is to get the master clock
1988  *
1989  * @param       player          [in]    handle of player
1990  * @param       video_time      [out]   current playing position
1991  * @param       media_clock     [out]   media clock information
1992  * @param       audio_time      [out]   audio timestamp information
1993  * @return      This function returns zero on success, or negative value with error code.
1994  *
1995  * @see
1996  * @remark      None
1997  */
1998 int mm_player_get_video_share_master_clock(MMHandleType player, long long *video_time, long long *media_clock, long long *audio_time);
1999 /**
2000  * This function is to set audio channel
2001  *
2002  * @param       player          [in]    handle of player
2003  * @param       ch                      [in]    audio channel
2004  * @return      This function returns zero on success, or negative value with error code.
2005  *
2006  * @see
2007  * @remark      None
2008  */
2009 int mm_player_gst_set_audio_channel(MMHandleType player, MMPlayerAudioChannel ch);
2010
2011 /**
2012  * This function is to get the content angle
2013  *
2014  * @param       player          [in]    handle of player
2015  * @param       angle           [out]   orignal angle from content
2016  * @return      This function returns zero on success, or negative value with error code.
2017  *
2018  * @see
2019  * @remark      None
2020  */
2021 int mm_player_get_video_rotate_angle(MMHandleType player, int *angle);
2022
2023 /**
2024  * This function is to set download mode of video hub
2025  *
2026  * @param       player          [in]    handle of player
2027  * @param       mode            [in]    download mode
2028  * @return      This function returns zero on success, or negative value with error code.
2029  *
2030  * @see
2031  * @remark      None
2032  */
2033 int mm_player_set_video_hub_download_mode(MMHandleType player, bool mode);
2034
2035 /**
2036  * This function is to set using sync handler.
2037  *
2038  * @param       player          [in]    handle of player
2039  * @param       enable          [in]    enable/disable
2040  * @return      This function returns zero on success, or negative value with error code.
2041  *
2042  * @see
2043  * @remark      None
2044  */
2045 int mm_player_enable_sync_handler(MMHandleType player, bool enable);
2046
2047 /**
2048  * This function is to set uri.
2049  *
2050  * @param       player          [in]    handle of player
2051  * @param       uri             [in]    uri
2052  * @return      This function returns zero on success, or negative value with error code.
2053  *
2054  * @see
2055  * @remark      None
2056  */
2057 int mm_player_set_uri(MMHandleType player, const char *uri);
2058
2059 /**
2060  * This function is to set next uri.
2061  *
2062  * @param       player          [in]    handle of player
2063  * @param       uri             [in]    uri
2064  * @return      This function returns zero on success, or negative value with error code.
2065  *
2066  * @see
2067  * @remark      None
2068  */
2069 int mm_player_set_next_uri(MMHandleType player, const char *uri);
2070
2071 /**
2072  * This function is to get next uri.
2073  *
2074  * @param       player          [in]    handle of player
2075  * @param       uri             [out]   uri
2076  * @return      This function returns zero on success, or negative value with error code.
2077  *
2078  * @see
2079  * @remark      None
2080  */
2081 int mm_player_get_next_uri(MMHandleType player, char **uri);
2082
2083 int mm_player_enable_media_packet_video_stream(MMHandleType player, bool enable);
2084
2085 /**
2086  * This function is to increase reference count of internal buffer.
2087  *
2088  * @param       buffer          [in]   video callback internal buffer
2089  * @return      This function returns buffer point;
2090  *
2091  * @see
2092  * @remark      None
2093  */
2094 void * mm_player_media_packet_video_stream_internal_buffer_ref(void *buffer);
2095
2096 /**
2097  * This function is to decrease reference count of internal buffer.
2098  *
2099  * @param       buffer          [in]   video callback internal buffer
2100  * @return      None;
2101  *
2102  * @see
2103  * @remark      None
2104  */
2105 void mm_player_media_packet_video_stream_internal_buffer_unref(void *buffer);
2106
2107 /**mm_player_submit_packet
2108  * This function is to submit buffer to appsrc.  \n
2109  * @param       player                  [in]    Handle of player.
2110  * @param       buf             [in]    buffer to be submit in appsrc in external feeder case.
2111  * @param       len                             [in]    length of buffer.
2112  * @param       pts                             [in]    timestamp of buffer.
2113  * @param       streamtype              [in]    stream type of buffer.
2114  * @return      This function returns zero on success, or negative value with error code.
2115  * @par Example
2116  *
2117  * @endcode
2118  */
2119 int mm_player_submit_packet(MMHandleType player, media_packet_h packet);
2120
2121 /**mm_player_set_video_info
2122  * This function is to set caps of src pad of video appsrc in external feeder case.  \n
2123  * @param       player                          [in]    Handle of player.
2124  * @param       media_format_h                  [in]    Video stream info.
2125  * @return      This function returns zero on success, or negative value with error code.
2126  * @par Example
2127  *
2128  * @endcode
2129  */
2130 int mm_player_set_video_info (MMHandleType player, media_format_h format);
2131
2132 /**mm_player_set_audio_info
2133  * This function is to set caps of src pad of Audio appsrc in external feeder case.  \n
2134  * @param       player                       [in]    Handle of player.
2135  * @param       media_format_h               [in]    Audio stream info.
2136  * @return      This function returns zero on success, or negative value with error code.
2137  * @par Example
2138  *
2139  * @endcode
2140  */
2141 int mm_player_set_audio_info (MMHandleType player, media_format_h format);
2142
2143 /**mm_player_set_subtitle_info
2144  * This function is to set caps of src pad of subtitle appsrc in external feeder case.  \n
2145  * @param       player                          [in]    Handle of player.
2146  * @param       subtitle_stream_info               [in]    Subtitle stream info.
2147  * @return      This function returns zero on success, or negative value with error code.
2148  * @par Example
2149  *
2150  * @endcode
2151  */
2152 int mm_player_set_subtitle_info (MMHandleType player, MMPlayerSubtitleStreamInfo *info);
2153
2154 /**
2155  * This function set callback function for receiving need or enough data message from player.
2156  *
2157  * @param       player          [in]    Handle of player.
2158  * @param       type            [in]    stream type
2159  * @param       callback        [in]    data callback function for stream type.
2160  * @param       user_param      [in]    User parameter.
2161  *
2162  * @return      This function returns zero on success, or negative value with error
2163  *                      code.
2164  * @remark
2165  * @see
2166  * @since
2167  */
2168 int mm_player_set_media_stream_buffer_status_callback(MMHandleType player, MMPlayerStreamType type, mm_player_media_stream_buffer_status_callback callback, void * user_param);
2169
2170 /**
2171  * This function set callback function for receiving seek data message from player.
2172  *
2173  * @param       player          [in]    Handle of player.
2174  * @param       type            [in]    stream type
2175  * @param       callback        [in]    Seek data callback function for stream type.
2176  * @param       user_param      [in]    User parameter.
2177  *
2178  * @return      This function returns zero on success, or negative value with error
2179  *                      code.
2180  * @remark
2181  * @see
2182  * @since
2183  */
2184 int mm_player_set_media_stream_seek_data_callback(MMHandleType player, MMPlayerStreamType type, mm_player_media_stream_seek_data_callback callback, void * user_param);
2185
2186 /**
2187  * This function is to set max size of buffer(appsrc).
2188  *
2189  * @param       player          [in]    Handle of player.
2190  * @param       type            [in]    stream type
2191  * @param       max_size        [in]    max bytes of buffer.
2192  *
2193  * @return      This function returns zero on success, or negative value with error
2194  *                      code.
2195  * @remark
2196  * @see
2197  * @since
2198  */
2199 int mm_player_set_media_stream_buffer_max_size(MMHandleType player, MMPlayerStreamType type, unsigned long long max_size);
2200
2201 /**
2202  * This function is to get max size of buffer(appsrc).
2203  *
2204  * @param       player          [in]    Handle of player.
2205  * @param       type            [in]    stream type
2206  * @param       max_size        [out]   max bytes of buffer.
2207  *
2208  * @return      This function returns zero on success, or negative value with error
2209  *                      code.
2210  * @remark
2211  * @see
2212  * @since
2213  */
2214 int mm_player_get_media_stream_buffer_max_size(MMHandleType player, MMPlayerStreamType type, unsigned long long *max_size);
2215
2216 /**
2217  * This function is to set min percent of buffer(appsrc).
2218  *
2219  * @param       player          [in]    Handle of player.
2220  * @param       type            [in]    stream type
2221  * @param       min_percent     [in]    min percent of buffer.
2222  *
2223  * @return      This function returns zero on success, or negative value with error
2224  *                      code.
2225  * @remark
2226  * @see
2227  * @since
2228  */
2229 int mm_player_set_media_stream_buffer_min_percent(MMHandleType player, MMPlayerStreamType type, unsigned min_percent);
2230
2231 /**
2232  * This function is to get min percent of buffer(appsrc).
2233  *
2234  * @param       player          [in]    Handle of player.
2235  * @param       type            [in]    stream type
2236  * @param       min_percent     [out]   min percent of buffer.
2237  *
2238  * @return      This function returns zero on success, or negative value with error
2239  *                      code.
2240  * @remark
2241  * @see
2242  * @since
2243  */
2244 int mm_player_get_media_stream_buffer_min_percent(MMHandleType player, MMPlayerStreamType type, unsigned int *min_percent);
2245
2246 /**
2247  * This function set callback function for changing audio stream from player. \n
2248  * It's only supported when audio stream is included in file. \n
2249  *
2250  * @param       player   [in] Handle of player.
2251  * @param       callback [in] Audio stream changed callback function.
2252  * @param       user_param [in] User parameter.
2253  *
2254  * @return      This function returns zero on success, or negative value with error
2255  *                      code.
2256  * @see         mm_player_stream_changed_callback
2257  * @since
2258  */
2259 int mm_player_set_audio_stream_changed_callback(MMHandleType player, mm_player_stream_changed_callback callback, void *user_param);
2260
2261 /**
2262  * This function set callback function for changing video stream from player. \n
2263  * It's only supported when video stream is included in file. \n
2264  *
2265  * @param       player   [in] Handle of player.
2266  * @param       callback [in] Video stream changed callback function.
2267  * @param       user_param [in] User parameter.
2268  *
2269  * @return      This function returns zero on success, or negative value with error
2270  *                      code.
2271  * @see         mm_player_stream_changed_callback
2272  * @since
2273  */
2274 int mm_player_set_video_stream_changed_callback(MMHandleType player, mm_player_stream_changed_callback callback, void *user_param);
2275
2276 /**
2277  * This function is to get timeout value according to the content type for muse. \n
2278  * It's only supported when video stream is included in file. \n
2279  *
2280  * @param       player  [in] Handle of player.
2281  * @param       timeout [out] timeout value (sec).
2282  *
2283  * @return      This function returns zero on success, or negative value with error
2284  *                      code.
2285  * @since 3.0
2286  */
2287 int mm_player_get_timeout(MMHandleType player, int *timeout);
2288
2289 /**
2290  * This function is to get the number of video output buffers. \n
2291  * It's only supported when video stream is included in file. \n
2292  *
2293  * @param       player  [in] Handle of player.
2294  * @param       num     [out] num of buffers.
2295  * @param       extra_num [out] extra num of buffers.
2296  *
2297  * @return      This function returns zero on success, or negative value with error
2298  *                      code.
2299  * @since 3.0
2300  */
2301 int mm_player_get_num_of_video_out_buffers(MMHandleType player, int *num, int *extra_num);
2302
2303 /**
2304  * This function is to set the dynamic resolution information. \n
2305  * It's only supported when video stream is included in file. \n
2306  *
2307  * @param       player  [in] Handle of player.
2308  * @param       drc     [in] dynamic resolution info of media stream data
2309  *
2310  * @return      This function returns zero on success, or negative value with error
2311  *                      code.
2312  * @since 3.0
2313  */
2314 int mm_player_set_media_stream_dynamic_resolution(MMHandleType player, bool drc);
2315
2316 /**
2317         @}
2318  */
2319
2320 #ifdef __cplusplus
2321         }
2322 #endif
2323
2324 #endif  /* __MM_PLAYER_H__ */