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