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