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