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