4 * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
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>
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
13 * http://www.apache.org/licenses/LICENSE-2.0
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.
23 #ifndef __MM_PLAYER_H__
24 #define __MM_PLAYER_H__
27 /*===========================================================================================
31 ========================================================================================== */
36 #include <mm_message.h>
37 #include <media_packet.h>
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.
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.
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.
64 Player can have 5 states, and each state can be changed by calling
65 described functions on "Figure1. State of Player".
68 @image html player_state.jpg "Figure1. State of Player" width=12cm
69 @image latex player_state.jpg "Figure1. State of Player" width=12cm
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.
78 Note that "None" and Null" state could be reached from any state
79 by calling mm_player_destroy() and mm_player_unrealize().
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>
90 <td>mm_player_create()</td>
96 <td>mm_player_destroy()</td>
102 <td>mm_player_realize()</td>
108 <td>mm_player_unrealize()</td>
114 <td>mm_player_start()</td>
120 <td>mm_player_stop()</td>
126 <td>mm_player_pause()</td>
132 <td>mm_player_resume()</td>
138 <td>mm_player_set_message_callback()</td>
144 <td>mm_player_get_state()</td>
150 <td>mm_player_set_volume()</td>
156 <td>mm_player_get_volume()</td>
162 <td>mm_player_set_position()</td>
168 <td>mm_player_get_position()</td>
174 <td>mm_player_get_attribute()</td>
180 <td>mm_player_set_attribute()</td>
188 Following are the attributes supported in player which may be set after initialization. \n
189 Those are handled as a string.
199 <td>"profile_uri"</td>
204 <td>"content_duration"</td>
209 <td>"content_video_width"</td>
214 <td>"content_video_height"</td>
219 <td>"display_evas_do_scaling"</td>
224 <td>"display_evas_surface_sink"</td>
229 <td>"profile_user_param"</td>
234 <td>"profile_play_count"</td>
239 <td>"streaming_type"</td>
244 <td>"streaming_udp_timeout"</td>
249 <td>"streaming_user_agent"</td>
254 <td>"streaming_wap_profile"</td>
259 <td>"streaming_network_bandwidth"</td>
264 <td>"streaming_cookie"</td>
269 <td>"streaming_proxy_ip"</td>
274 <td>"streaming_proxy_port"</td>
279 <td>"streaming_timeout"</td>
284 <td>"display_overlay"</td>
289 <td>"display_rotation"</td>
294 <td>"subtitle_uri"</td>
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.
312 <td>"content_video_found"</td>
317 <td>"content_video_codec"</td>
322 <td>"content_video_track_num"</td>
327 <td>"content_audio_found"</td>
332 <td>"content_audio_codec"</td>
337 <td>"content_audio_bitrate"</td>
342 <td>"content_audio_channels"</td>
347 <td>"content_audio_samplerate"</td>
352 <td>"content_audio_track_num"</td>
357 <td>"content_text_track_num"</td>
362 <td>"tag_artist"</td>
382 <td>"tag_author"</td>
387 <td>"tag_copyright"</td>
397 <td>"tag_description"</td>
402 <td>"tag_track_num"</td>
411 /*===========================================================================================
413 | GLOBAL DEFINITIONS AND DECLARATIONS |
415 ========================================================================================== */
420 * uri to play (string)
423 #define MM_PLAYER_CONTENT_URI "profile_uri"
425 * MM_PLAYER_CONTENT_DURATION:
427 * get the duration (int) as millisecond, It's guaranteed after calling mm_player_start() or
428 * receiving MM_MESSAGE_BEGIN_OF_STREAM.
431 #define MM_PLAYER_CONTENT_DURATION "content_duration"
433 * MM_PLAYER_VIDEO_ROTATION
435 * can change video angle (int)
436 * @see MMDisplayRotationType
438 #define MM_PLAYER_VIDEO_ROTATION "display_rotation"
440 * MM_PLAYER_VIDEO_WIDTH:
442 * get the video width (int), It's guaranteed after calling mm_player_start() or
443 * receiving MM_MESSAGE_BEGIN_OF_STREAM.
446 #define MM_PLAYER_VIDEO_WIDTH "content_video_width"
448 * MM_PLAYER_VIDEO_HEIGHT:
450 * get the video height (int), It's guaranteed after calling mm_player_start() or
451 * receiving MM_MESSAGE_BEGIN_OF_STREAM.
454 #define MM_PLAYER_VIDEO_HEIGHT "content_video_height"
456 * MM_PLAYER_VIDEO_EVAS_SURFACE_DO_SCALING:
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.
463 #define MM_PLAYER_VIDEO_EVAS_SURFACE_DO_SCALING "display_evas_do_scaling"
465 * MM_PLAYER_VIDEO_EVAS_SURFACE_SINK:
467 * get the video evas surface sink plugin name (string), It's guaranteed after calling mm_player_create()
470 #define MM_PLAYER_VIDEO_EVAS_SURFACE_SINK "display_evas_surface_sink"
474 * set memory pointer to play (data)
477 #define MM_PLAYER_MEMORY_SRC "profile_user_param"
479 * MM_PLAYER_PLAYBACK_COUNT
481 * can set playback count (int), Default value is 1 and -1 is for infinity playing until releasing it.
484 #define MM_PLAYER_PLAYBACK_COUNT "profile_play_count"
486 * MM_PLAYER_SUBTITLE_URI
488 * set the subtitle path (string)
490 #define MM_PLAYER_SUBTITLE_URI "subtitle_uri"
492 * MM_PLAYER_STREAMING_TYPE
494 * set the streaming type (int)
495 * @see MMStreamingType
497 #define MM_PLAYER_STREAMING_TYPE "streaming_type"
499 * MM_PLAYER_STREAMING_UDP_TIMEOUT
501 * set the streaming udp timeout(int)
503 #define MM_PLAYER_STREAMING_UDP_TIMEOUT "streaming_udp_timeout"
505 * MM_PLAYER_STREAMING_USER_AGENT
507 * set the streaming user agent (string)
509 #define MM_PLAYER_STREAMING_USER_AGENT "streaming_user_agent"
511 * MM_PLAYER_STREAMING_WAP_PROFILE
513 * set the streaming wap profile (int)
515 #define MM_PLAYER_STREAMING_WAP_PROFILE "streaming_wap_profile"
517 * MM_PLAYER_STREAMING_NET_BANDWIDTH
519 * set the streaming network bandwidth (int)
521 #define MM_PLAYER_STREAMING_NET_BANDWIDTH "streaming_network_bandwidth"
523 * MM_PLAYER_STREAMING_COOKIE
525 * set the streaming cookie (int)
527 #define MM_PLAYER_STREAMING_COOKIE "streaming_cookie"
529 * MM_PLAYER_STREAMING_PROXY_IP
531 * set the streaming proxy ip (string)
533 #define MM_PLAYER_STREAMING_PROXY_IP "streaming_proxy_ip"
535 * MM_PLAYER_STREAMING_PROXY_PORT
537 * set the streaming proxy port (int)
539 #define MM_PLAYER_STREAMING_PROXY_PORT "streaming_proxy_port"
541 * MM_PLAYER_STREAMING_TIMEOUT
543 * set the streaming timeout (int)
545 #define MM_PLAYER_STREAMING_TIMEOUT "streaming_timeout"
547 * MM_PLAYER_VIDEO_CODEC
549 * codec the video data is stored in (string)
551 #define MM_PLAYER_VIDEO_CODEC "content_video_codec"
553 * MM_PLAYER_VIDEO_TRACK_NUM
555 * track number inside a collection (int)
557 #define MM_PLAYER_VIDEO_TRACK_NUM "content_video_track_num"
559 * MM_PLAYER_AUDIO_CODEC
561 * codec the audio data is stored in (string)
563 #define MM_PLAYER_AUDIO_CODEC "content_audio_codec"
565 * MM_PLAYER_AUDIO_BITRATE
567 * set the streaming proxy port (int)
569 #define MM_PLAYER_AUDIO_BITRATE "content_audio_bitrate"
571 * MM_PLAYER_AUDIO_CHANNEL
573 * the number of audio channel (int)
575 #define MM_PLAYER_AUDIO_CHANNEL "content_audio_channels"
577 * MM_PLAYER_AUDIO_SAMPLERATE
579 * audio samplerate (int)
581 #define MM_PLAYER_AUDIO_SAMPLERATE "content_audio_samplerate"
583 * MM_PLAYER_AUDIO_TRACK_NUM
585 * track number inside a collection (int)
587 #define MM_PLAYER_AUDIO_TRACK_NUM "content_audio_track_num"
589 * MM_PLAYER_TEXT_TRACK_NUM
591 * track number inside a collection (int)
593 #define MM_PLAYER_TEXT_TRACK_NUM "content_text_track_num"
595 * MM_PLAYER_TAG_ARTIST
597 * person(s) responsible for the recording (string)
599 #define MM_PLAYER_TAG_ARTIST "tag_artist"
601 * MM_PLAYER_TAG_ARTIST
605 #define MM_PLAYER_TAG_TITLE "tag_title"
607 * MM_PLAYER_TAG_ARTIST
609 * album containing this data (string)
611 #define MM_PLAYER_TAG_ALBUM "tag_album"
613 * MM_PLAYER_TAG_ARTIST
615 * genre this data belongs to (string)
617 #define MM_PLAYER_TAG_GENRE "tag_genre"
619 * MM_PLAYER_TAG_ARTIST
623 #define MM_PLAYER_TAG_AUTHOUR "tag_author"
625 * MM_PLAYER_TAG_ARTIST
627 * copyright notice of the data (string)
629 #define MM_PLAYER_TAG_COPYRIGHT "tag_copyright"
631 * MM_PLAYER_TAG_ARTIST
633 * date the data was created (string)
635 #define MM_PLAYER_TAG_DATE "tag_date"
637 * MM_PLAYER_TAG_ARTIST
639 * short text describing the content of the data (string)
641 #define MM_PLAYER_TAG_DESCRIPRION "tag_description"
643 * MM_PLAYER_TAG_ARTIST
645 * track number inside a collection (int)
647 #define MM_PLAYER_TAG_TRACK_NUM "tag_track_num"
651 * progressive download mode (int)
653 #define MM_PLAYER_PD_MODE "pd_mode"
658 * dynamic resolution change mode (int)
660 #define MM_PLAYER_DRC_MODE "drc_mode"
663 * MM_PLAYER_GAPLESS_MODE
665 * gapless playback mode (int)
667 #define MM_PLAYER_GAPLESS_MODE "gapless_mode"
670 * MM_PLAYER_ENABLE_VIDEO_DECODED_CB
672 * enable video decoded callback (int)
674 #define MM_PLAYER_ENABLE_VIDEO_DECODED_CB "enable_video_decoded_cb"
676 #define BUFFER_MAX_PLANE_NUM (4)
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;
692 * Enumerations of player state.
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 */
704 * Enumerations of position formats.
705 * Used while invoking mm_player_get_position/mm_player_set_position APIs
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;
714 * Enumeration for attribute values types.
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 */
728 * Enumeration for attribute validation type.
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;
740 * Enumeration for attribute access flag.
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 */
748 MM_PLAYER_ATTRS_FLAG_RW = MM_PLAYER_ATTRS_FLAG_READABLE | MM_PLAYER_ATTRS_FLAG_WRITABLE, /**< Readable and Writable */
752 * Enumeration for progressive download
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
761 * Enumeration of track types
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
771 * Enumeration of runtime buffering mode
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;
781 * Enumeration of audio channel for video share
785 MM_PLAYER_AUDIO_CH_MONO_LEFT = 0,
786 MM_PLAYER_AUDIO_CH_MONO_RIGHT,
787 MM_PLAYER_AUDIO_CH_STEREO,
788 } MMPlayerAudioChannel;
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;
805 * Edge Properties of the text.
809 MM_PLAYER_EDGE_RAISED,
810 MM_PLAYER_EDGE_DEPRESSED,
811 MM_PLAYER_EDGE_UNIFORM,
812 MM_PLAYER_EDGE_DROPSHADOW
813 } MMPlayerSubtitleEdge;
816 * Enumeration of media stream buffer status
820 MM_PLAYER_MEDIA_STREAM_BUFFER_UNDERRUN,
821 MM_PLAYER_MEDIA_STREAM_BUFFER_OVERFLOW,
822 } MMPlayerMediaStreamBufferStatus;
825 * Enumeration for stream type.
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;
837 * Attribute validity structure
840 MMPlayerAttrsType type;
841 MMPlayerAttrsValidType validity_type;
842 MMPlayerAttrsFlag flag;
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.
850 * Validity structure for integer array.
853 int *array; /**< a pointer of array */
854 int count; /**< size of array */
858 * Validity structure for integer range.
861 int min; /**< minimum range */
862 int max; /**< maximum range */
866 * Validity structure for double array.
869 double * array; /**< a pointer of array */
870 int count; /**< size of array */
874 * Validity structure for double range.
877 double min; /**< minimum range */
878 double max; /**< maximum range */
887 * @see mm_player_set_volume, mm_player_get_volume
890 float level[MM_VOLUME_CHANNEL_NUM]; /**< Relative volume factor for each channels */
891 } MMPlayerVolumeType;
894 * Video stream info in external demux case
897 typedef struct _VideoStreamInfo
900 unsigned int framerate_num;
901 unsigned int framerate_den;
904 unsigned char *codec_extradata;
905 unsigned int extradata_size;
906 unsigned int version;
907 }MMPlayerVideoStreamInfo;
910 * Audio stream info in external demux case
913 typedef struct _AudioStreamInfo
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;
924 // unsigned int width;
925 // unsigned int depth;
926 // unsigned int endianness;
928 }MMPlayerAudioStreamInfo;
931 * Subtitle stream info in external demux case
934 typedef struct _SubtitleStreamInfo
937 unsigned int codec_tag;
938 void *context; //for smpte text
939 }MMPlayerSubtitleStreamInfo;
942 * Audio stream callback function type.
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
949 * @return This callback function have to return MM_ERROR_NONE.
951 typedef bool (*mm_player_audio_stream_callback) (void *stream, int stream_size, void *user_param);
955 * selected subtitle track number callback function type.
957 * @param track_num [in] Track number of subtitle
958 * @param user_param [in] User defined parameter
961 * @return This callback function have to return MM_ERROR_NONE.
963 typedef bool (*mm_player_track_selected_subtitle_language_callback)(int track_num, void *user_param);
966 * Buffer underrun / overflow data callback function type.
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
972 * @return This callback function have to return MM_ERROR_NONE.
974 typedef bool (*mm_player_media_stream_buffer_status_callback) (MMPlayerStreamType type, MMPlayerMediaStreamBufferStatus status, unsigned long long bytes, void *user_param);
977 * Buffer seek data callback function type.
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
983 * @return This callback function have to return MM_ERROR_NONE.
985 typedef bool (*mm_player_media_stream_seek_data_callback) (MMPlayerStreamType type, unsigned long long offset, void *user_param);
988 * Called to notify the stream changed.
990 * @param user_data [in] The user data passed from the callback registration function
992 * @return This callback function have to return MM_ERROR_NONE.
994 typedef bool (*mm_player_stream_changed_callback) (void *user_param);
997 /*===========================================================================================
999 | GLOBAL FUNCTION PROTOTYPES |
1001 ========================================================================================== */
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.
1009 * @param player [out] Handle of player
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.
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.
1022 char *g_err_attr_name = NULL;
1024 if (mm_player_create(&g_player) != MM_ERROR_NONE)
1026 LOGE("failed to create player\n");
1029 if (mm_player_set_attribute(g_player,
1031 "profile_uri", filename, strlen(filename),
1032 "display_overlay", (void*)&g_win.xid, sizeof(g_win.xid),
1033 NULL) != MM_ERROR_NONE)
1035 LOGE("failed to set %s attribute\n", g_err_attr_name);
1036 free(g_err_attr_name);
1039 mm_player_set_message_callback(g_player, msg_callback, (void*)g_player);
1042 int mm_player_create(MMHandleType *player);
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.
1048 * @param player [in] Handle of player
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.
1060 if (mm_player_destroy(g_player) != MM_ERROR_NONE)
1062 LOGE("failed to destroy player\n");
1066 int mm_player_destroy(MMHandleType player);
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
1072 * @param player [in] Handle of player
1073 * @param pid [in] application PID
1075 * @return This function returns zero on success, or negative value with error code.
1077 * @pre Player state should be MM_PLAYER_STATE_NULL.
1080 int mm_player_sound_register(MMHandleType player, int pid);
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
1086 * @param player [in] Handle of player
1087 * @param pid [out] application PID
1089 * @return This function returns zero on success, or negative value with error code.
1091 * @pre Player state should be MM_PLAYER_STATE_NULL.
1094 int mm_player_get_client_pid (MMHandleType player, int* pid);
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
1100 * @param player [in] Handle of player
1102 * @return This function returns zero on success, or negative value with error code.
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
1110 if (mm_player_realize(g_player) != MM_ERROR_NONE)
1112 LOGE("failed to realize player\n");
1116 int mm_player_realize(MMHandleType player) ;
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.
1123 * @param player [in] Handle of player
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.
1134 if (mm_player_unrealize(g_player) != MM_ERROR_NONE)
1136 LOGE("failed to unrealize player\n");
1140 int mm_player_unrealize(MMHandleType player);
1143 * This function is to get current state of player. \n
1144 * Application have to check current state before doing some action.
1146 * @param player [in] Handle of player
1147 * @param state [out] current state of player on success
1149 * @return This function returns zero on success, or negative value with error code.
1151 * @see MMPlayerStateType
1155 if (mm_player_get_state(g_player, &state) != MM_ERROR_NONE)
1157 LOGE("failed to get state\n");
1161 int mm_player_get_state(MMHandleType player, MMPlayerStateType *state);
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.
1168 * @param player [in] Handle of player
1169 * @param volume [in] Volume factor of each channel
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.
1176 MMPlayerVolumeType volume;
1179 for (i = 0; i < MM_VOLUME_CHANNEL_NUM; i++)
1180 volume.level[i] = MM_VOLUME_LEVEL_MAX;
1182 if (mm_player_set_volume(g_player, &volume) != MM_ERROR_NONE)
1184 LOGE("failed to set volume\n");
1188 int mm_player_set_volume(MMHandleType player, MMPlayerVolumeType *volume);
1191 * This function is to get current volume factor of player.
1193 * @param player [in] Handle of player.
1194 * @param volume [out] Volume factor of each channel.
1196 * @return This function returns zero on success, or negative value with error code.
1198 * @see MMPlayerVolumeType, mm_player_set_volume
1202 MMPlayerVolumeType volume;
1205 if (mm_player_get_volume(g_player, &volume) != MM_ERROR_NONE)
1207 LOGW("failed to get volume\n");
1210 for (i = 0; i < MM_VOLUME_CHANNEL_NUM; i++)
1211 LOGD("channel[%d] = %d \n", i, volume.level[i]);
1214 int mm_player_get_volume(MMHandleType player, MMPlayerVolumeType *volume);
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().
1221 * @param player [in] Handle of player
1223 * @return This function returns zero on success, or negative value with error code.
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
1232 if (mm_player_start(g_player) != MM_ERROR_NONE)
1234 LOGE("failed to start player\n");
1238 int mm_player_start(MMHandleType player);
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.
1245 * @param player [in] Handle of player
1247 * @return This function returns zero on success, or negative value with error code.
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
1255 if (mm_player_stop(g_player) != MM_ERROR_NONE)
1257 LOGE("failed to stop player\n");
1261 int mm_player_stop(MMHandleType player);
1264 * This function is to pause playing media contents.
1266 * @param player [in] Handle of player.
1268 * @return This function returns zero on success, or negative value with error code.
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
1276 if (mm_player_pause(g_player) != MM_ERROR_NONE)
1278 LOGE("failed to pause player\n");
1282 int mm_player_pause(MMHandleType player);
1285 * This function is to resume paused media contents.
1287 * @param player [in] Handle of player.
1289 * @return This function returns zero on success, or negative value with error code.
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
1297 if (mm_player_resume(g_player) != MM_ERROR_NONE)
1299 LOGE("failed to resume player\n");
1303 int mm_player_resume(MMHandleType player);
1306 * This function is to set the position for playback. \n
1307 * So, it can be seeked to requested position. \n
1309 * @param player [in] Handle of player
1310 * @param format [in] Format of position.
1311 * @param pos [in] Position for playback
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.
1318 int position = 1000; //1sec
1320 if (mm_player_set_position(g_player, MM_PLAYER_POS_FORMAT_TIME, position) != MM_ERROR_NONE)
1322 LOGE("failed to set position\n");
1326 int mm_player_set_position(MMHandleType player, MMPlayerPosFormatType format, int pos);
1329 * This function is to get current position of playback content.
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.
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.
1343 mm_player_get_position(g_player, MM_PLAYER_POS_FORMAT_TIME, &position);
1345 mm_player_get_attribute(g_player, &g_err_name, "content_duration", &duration, NULL);
1347 LOGD("pos: [%d/%d] msec\n", position, duration);
1350 int mm_player_get_position(MMHandleType player, MMPlayerPosFormatType format, unsigned long *pos);
1353 * This function is to get current buffer position of playback content.
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.
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.
1365 int start_pos = 0, stop_pos = 0;
1367 mm_player_get_buffer_position(g_player, MM_PLAYER_POS_FORMAT_PERCENT, &start_pos, &stop_pos );
1369 LOGD("buffer position: [%d] ~ [%d] \%\n", start_pos, stop_pos );
1372 int mm_player_get_buffer_position(MMHandleType player, MMPlayerPosFormatType format, unsigned long *start_pos, unsigned long *stop_pos);
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.
1379 * @param player [in] Handle of player.
1380 * @param start_pos [in] start position.
1381 * @param end_pos [in] end position.
1383 * @return This function returns zero on success, or negative value with error code.
1384 * @see mm_player_deactivate_section_repeat
1389 int endtime = 4000; //msec
1391 mm_player_get_position(g_player, MM_PLAYER_POS_FORMAT_TIME, &position);
1393 mm_player_activate_section_repeat(g_player, position, position+endtime);
1396 int mm_player_activate_section_repeat(MMHandleType player, int start_pos, int end_pos);
1399 * This function is to deactivate the section repeat.
1401 * @param player [in] Handle of player.
1403 * @return This function returns zero on success, or negative value with error code.
1404 * @see mm_player_activate_section_repeat
1408 if ( mm_player_deactivate_section_repeat(g_player) != MM_ERROR_NONE)
1410 LOGW("failed to deactivate section repeat\n");
1414 int mm_player_deactivate_section_repeat(MMHandleType player);
1417 * This function sets callback function for receiving messages from player.
1418 * So, player can notify warning, error and normal cases to application.
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.
1424 * @return This function returns zero on success, or negative value with error code.
1425 * @see MMMessageCallback
1429 int msg_callback(int message, MMMessageParamType *param, void *user_param)
1433 case MM_MESSAGE_ERROR:
1437 case MM_MESSAGE_END_OF_STREAM:
1441 case MM_MESSAGE_STATE_CHANGED:
1445 case MM_MESSAGE_BEGIN_OF_STREAM:
1455 mm_player_set_message_callback(g_player, msg_callback, (void*)g_player);
1458 int mm_player_set_message_callback(MMHandleType player, MMMessageCallback callback, void *user_param);
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.
1467 * @param player [in] Handle of player.
1468 * @param callback [in] Audio stream callback function.
1469 * @param user_param [in] User parameter.
1471 * @return This function returns zero on success, or negative value with error
1473 * @see mm_player_audio_stream_callback
1474 * @remark It can be used for audio playback only.
1477 bool audio_callback(void *stream, int stream_size, void *user_param)
1479 LOGD("audio stream callback\n");
1482 mm_player_set_audio_stream_callback(g_player, audio_callback, NULL);
1485 int mm_player_set_audio_stream_callback(MMHandleType player, mm_player_audio_stream_callback callback, void *user_param);
1488 * This function is to mute volume of player
1490 * @param player [in] Handle of player
1491 * @param mute [in] Mute(1) or not mute(0)
1493 * @return This function returns zero on success, or negative value with error code
1494 * @see mm_player_get_mute
1498 if (mm_player_set_mute(g_player, TRUE) != MM_ERROR_NONE)
1500 LOGW("failed to set mute\n");
1504 int mm_player_set_mute(MMHandleType player, int mute);
1507 * This function is to get mute value of player
1509 * @param player [in] Handle of player
1510 * @param mute [out] Sound is muted
1512 * @return This function returns zero on success, or negative value with error code
1513 * @see mm_player_set_mute
1519 if (mm_player_get_mute(g_player, &mute) != MM_ERROR_NONE)
1521 LOGW("failed to get mute\n");
1524 LOGD("mute status:%d\n", mute);
1527 int mm_player_get_mute(MMHandleType player, int *mute);
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
1533 * @param player [in] Handle of player
1534 * @param pos [in] postion to be adjusted
1536 * @return This function returns zero on success, or negative value with error
1538 * @see mm_player_adjust_subtitle_position
1545 if (mm_player_adjust_subtitle_position(g_player, MM_PLAYER_POS_FORMAT_TIME, pos) != MM_ERROR_NONE)
1547 LOGW("failed to adjust subtitle postion.\n");
1552 int mm_player_adjust_subtitle_position(MMHandleType player, MMPlayerPosFormatType format, int pos);
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
1561 int mm_player_adjust_video_position(MMHandleType player,int offset);
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.
1570 * @param player [in] Handle of player
1571 * @param silent [in] silent(integer value except 0) or not silent(0)
1573 * @return This function returns zero on success, or negative value with error
1575 * @see mm_player_get_subtitle_silent, MM_MESSAGE_UPDATE_SUBTITLE
1579 mm_player_set_attribute(g_player,
1581 "subtitle_uri", g_subtitle_uri, strlen(g_subtitle_uri),
1585 if (mm_player_set_subtitle_silent(g_player, TRUE) != MM_ERROR_NONE)
1587 LOGW("failed to set subtitle silent\n");
1591 int mm_player_set_subtitle_silent(MMHandleType player, int silent);
1594 * This function is to get silent status of subtitle.
1596 * @param player [in] Handle of player
1597 * @param silent [out] subtitle silent property
1599 * @return This function returns zero on success, or negative value with error
1601 * @see mm_player_set_subtitle_silent, MM_MESSAGE_UPDATE_SUBTITLE
1607 if (mm_player_get_subtitle_silent(g_player, &silent) != MM_ERROR_NONE)
1609 LOGW("failed to set subtitle silent\n");
1613 int mm_player_get_subtitle_silent(MMHandleType player, int *silent);
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
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.
1625 * @return This function returns zero on success, or negative value with error code.
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.
1632 char *g_err_attr_name = NULL;
1634 if (mm_player_set_attribute(g_player,
1636 "profile_uri", filename, strlen(filename),
1637 "profile_play_count", count,
1638 NULL) != MM_ERROR_NONE)
1640 LOGW("failed to set %s attribute\n", g_err_attr_name);
1641 free(g_err_attr_name);
1646 int mm_player_set_attribute(MMHandleType player, char **err_attr_name, const char *first_attribute_name, ...)G_GNUC_NULL_TERMINATED;
1649 * This function is to get attributes from player. Multiple attributes can be got simultaneously.
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.
1657 * @return This function returns zero on success, or negative value with error
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.
1664 char *g_err_attr_name = NULL;
1666 if (mm_player_get_attribute(g_player, &g_err_attr_name, "content_duration", &duration, NULL) != MM_ERROR_NONE)
1668 LOGW("failed to set %s attribute\n", g_err_attr_name);
1669 free(g_err_attr_name);
1673 int mm_player_get_attribute(MMHandleType player, char **err_attr_name, const char *first_attribute_name, ...)G_GNUC_NULL_TERMINATED;
1676 * This function is to get detail information of attribute.
1678 * @param player [in] Handle of player.
1679 * @param attribute_name [in] Name of the attribute to get
1680 * @param info [out] Attribute infomation
1682 * @return This function returns zero on success, or negative value with error
1685 * @see mm_player_set_attribute, mm_player_get_attribute
1689 if (mm_player_get_attribute_info (g_player, "display_method", &method_info) != MM_ERROR_NONE)
1691 LOGW("failed to get info\n");
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..
1698 if (method_info. validity_type == MM_PLAYER_ATTRS_VALID_TYPE_INT_RANGE)
1700 LOGD("range min:%d\n", method_info.int_range.min);
1701 LOGD("range max:%d\n", method_info.int_range.max);
1705 int mm_player_get_attribute_info(MMHandleType player, const char *attribute_name, MMPlayerAttrsInfo *info);
1708 * This function is to get download position and total size of progressive download
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)
1714 * @return This function returns zero on success, or negative value with error code.
1720 guint64 current_pos = 0LLU;
1721 guint64 total_size = 0LLU;
1723 if (mm_player_get_pd_status(g_player, ¤t_pos, &total_size, NULL) != MM_ERROR_NONE)
1725 LOGD("current download pos = %llu, total size = %llu\n", current_pos, total_size);
1729 int mm_player_get_pd_status(MMHandleType player, guint64 *current_pos, guint64 *total_size);
1732 * This function sets callback function for receiving messages of PD downloader.
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.
1738 * @return This function returns zero on success, or negative value with error code.
1743 int msg_callback(int message, MMMessageParamType *param, void *user_param)
1747 case MM_MESSAGE_PD_DOWNLOADER_START:
1748 LOGD("Progressive download is started...\n");
1750 case MM_MESSAGE_PD_DOWNLOADER_END:
1751 LOGD("Progressive download is ended...\n");
1759 mm_player_set_pd_message_callback(g_player, msg_callback, NULL);
1762 int mm_player_set_pd_message_callback(MMHandleType player, MMMessageCallback callback, void *user_param);
1765 * This function is to get the track count
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
1771 * @return This function returns zero on success, or negative value with error
1778 gint audio_count = 0;
1780 if (mm_player_get_track_count (g_player, MM_PLAYER_TRACK_TYPE_AUDIO, &audio_count) != MM_ERROR_NONE)
1782 LOGW("failed to get audio track count\n");
1785 LOGD("audio track count : %d \n", audio_count);
1788 int mm_player_get_track_count(MMHandleType player, MMPlayerTrackType type, int *count);
1791 * This function is to select the track
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
1797 * @return This function returns zero on success, or negative value with error
1803 int mm_player_select_track(MMHandleType player, MMPlayerTrackType type, int index);
1806 * This function is to add the track when user want multi subtitle
1808 * @param player [in] handle of player.
1809 * @param index [in] the index of the track
1811 * @return This function returns zero on success, or negative value with error
1817 int mm_player_track_add_subtitle_language(MMHandleType player, int index);
1820 * This function is to remove the track when user want multi subtitle
1822 * @param player [in] handle of player.
1823 * @param index [in] the index of the track
1825 * @return This function returns zero on success, or negative value with error
1831 int mm_player_track_remove_subtitle_language(MMHandleType player, int index);
1834 * This function is to notify which sutitle track is in use
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
1840 * @return This function returns zero on success, or negative value with error
1846 int mm_player_track_foreach_selected_subtitle_language(MMHandleType player, mm_player_track_selected_subtitle_language_callback callback, void *user_param);
1849 * This function is to get the track language
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)
1856 * @return This function returns zero on success, or negative value with error
1862 int mm_player_get_track_language_code(MMHandleType player, MMPlayerTrackType type, int index, char **code);
1865 * This function is to get the current running track
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
1871 * @return This function returns zero on success, or negative value with error
1878 int mm_player_get_current_track(MMHandleType hplayer, MMPlayerTrackType type, int *index);
1881 * This function is to set the buffer size for streaming playback. \n
1883 * @param player [in] Handle of player
1884 * @param second [in] Size of initial buffer
1886 * @return This function returns zero on success, or negative value with error code.
1890 gint second = 10; //10sec
1892 if (mm_player_set_prepare_buffering_time(g_player, second) != MM_ERROR_NONE)
1894 LOGE("failed to set buffer size\n");
1899 int mm_player_set_prepare_buffering_time(MMHandleType player, int second);
1902 * This function is to set the runtime buffering mode for streaming playback. \n
1904 * @param player [in] Handle of player
1905 * @param mode [in] mode of runtime buffering
1906 * @param second [in] max size of buffering
1908 * @return This function returns zero on success, or negative value with error code.
1913 if (mm_player_set_runtime_buffering_mode(g_player, MM_PLAYER_BUFFERING_MODE_ADAPTIVE, 10) != MM_ERROR_NONE)
1915 LOGE("failed to set buffering mode\n");
1920 int mm_player_set_runtime_buffering_mode(MMHandleType player, MMPlayerBufferingMode mode, int second);
1923 * This function is to set the start position of zoom
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
1930 * @return This function returns zero on success, or negative value with error
1936 int mm_player_set_display_zoom(MMHandleType player, float level, int x, int y);
1939 * This function is to get the start position of zoom
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
1946 * @return This function returns zero on success, or negative value with error
1952 int mm_player_get_display_zoom(MMHandleType player, float *level, int *x, int *y);
1955 * This function is to set the subtitle path
1957 * @param player [in] handle of player
1958 * @param path [in] subtitle path
1960 * @return This function returns zero on success, or negative value with error code.
1965 int mm_player_set_external_subtitle_path(MMHandleType player, const char* path);
1968 * This function is to set the clock which is from master player
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.
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);
1983 * This function is to get the master clock
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.
1994 int mm_player_get_video_share_master_clock(MMHandleType player, long long *video_time, long long *media_clock, long long *audio_time);
1996 * This function is to set audio channel
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.
2005 int mm_player_gst_set_audio_channel(MMHandleType player, MMPlayerAudioChannel ch);
2008 * This function is to get the content angle
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.
2017 int mm_player_get_video_rotate_angle(MMHandleType player, int *angle);
2020 * This function is to set download mode of video hub
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.
2029 int mm_player_set_video_hub_download_mode(MMHandleType player, bool mode);
2032 * This function is to set using sync handler.
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.
2041 int mm_player_enable_sync_handler(MMHandleType player, bool enable);
2044 * This function is to set uri.
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.
2053 int mm_player_set_uri(MMHandleType player, const char *uri);
2056 * This function is to set next uri.
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.
2065 int mm_player_set_next_uri(MMHandleType player, const char *uri);
2068 * This function is to get next uri.
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.
2077 int mm_player_get_next_uri(MMHandleType player, char **uri);
2080 * This function is to increase reference count of internal buffer.
2082 * @param buffer [in] video callback internal buffer
2083 * @return This function returns buffer point;
2088 void * mm_player_media_packet_video_stream_internal_buffer_ref(void *buffer);
2091 * This function is to decrease reference count of internal buffer.
2093 * @param buffer [in] video callback internal buffer
2099 void mm_player_media_packet_video_stream_internal_buffer_unref(void *buffer);
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.
2113 int mm_player_submit_packet(MMHandleType player, media_packet_h packet);
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.
2124 int mm_player_set_video_info (MMHandleType player, media_format_h format);
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.
2135 int mm_player_set_audio_info (MMHandleType player, media_format_h format);
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.
2146 int mm_player_set_subtitle_info (MMHandleType player, MMPlayerSubtitleStreamInfo *info);
2149 * This function set callback function for receiving need or enough data message from player.
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.
2156 * @return This function returns zero on success, or negative value with error
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);
2165 * This function set callback function for receiving seek data message from player.
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.
2172 * @return This function returns zero on success, or negative value with error
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);
2181 * This function is to set max size of buffer(appsrc).
2183 * @param player [in] Handle of player.
2184 * @param type [in] stream type
2185 * @param max_size [in] max bytes of buffer.
2187 * @return This function returns zero on success, or negative value with error
2193 int mm_player_set_media_stream_buffer_max_size(MMHandleType player, MMPlayerStreamType type, unsigned long long max_size);
2196 * This function is to get max size of buffer(appsrc).
2198 * @param player [in] Handle of player.
2199 * @param type [in] stream type
2200 * @param max_size [out] max bytes of buffer.
2202 * @return This function returns zero on success, or negative value with error
2208 int mm_player_get_media_stream_buffer_max_size(MMHandleType player, MMPlayerStreamType type, unsigned long long *max_size);
2211 * This function is to set min percent of buffer(appsrc).
2213 * @param player [in] Handle of player.
2214 * @param type [in] stream type
2215 * @param min_percent [in] min percent of buffer.
2217 * @return This function returns zero on success, or negative value with error
2223 int mm_player_set_media_stream_buffer_min_percent(MMHandleType player, MMPlayerStreamType type, unsigned min_percent);
2226 * This function is to get min percent of buffer(appsrc).
2228 * @param player [in] Handle of player.
2229 * @param type [in] stream type
2230 * @param min_percent [out] min percent of buffer.
2232 * @return This function returns zero on success, or negative value with error
2238 int mm_player_get_media_stream_buffer_min_percent(MMHandleType player, MMPlayerStreamType type, unsigned int *min_percent);
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
2244 * @param player [in] Handle of player.
2245 * @param callback [in] Audio stream changed callback function.
2246 * @param user_param [in] User parameter.
2248 * @return This function returns zero on success, or negative value with error
2250 * @see mm_player_stream_changed_callback
2253 int mm_player_set_audio_stream_changed_callback(MMHandleType player, mm_player_stream_changed_callback callback, void *user_param);
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
2259 * @param player [in] Handle of player.
2260 * @param callback [in] Video stream changed callback function.
2261 * @param user_param [in] User parameter.
2263 * @return This function returns zero on success, or negative value with error
2265 * @see mm_player_stream_changed_callback
2268 int mm_player_set_video_stream_changed_callback(MMHandleType player, mm_player_stream_changed_callback callback, void *user_param);
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
2274 * @param player [in] Handle of player.
2275 * @param timeout [out] timeout value (sec).
2277 * @return This function returns zero on success, or negative value with error
2281 int mm_player_get_timeout(MMHandleType player, int *timeout);
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
2287 * @param player [in] Handle of player.
2288 * @param num [out] num of buffers.
2289 * @param extra_num [out] extra num of buffers.
2291 * @return This function returns zero on success, or negative value with error
2295 int mm_player_get_num_of_video_out_buffers(MMHandleType player, int *num, int *extra_num);
2298 * This function is to set the dynamic resolution information. \n
2299 * It's only supported when video stream is included in file. \n
2301 * @param player [in] Handle of player.
2302 * @param drc [in] dynamic resolution info of media stream data
2304 * @return This function returns zero on success, or negative value with error
2308 int mm_player_set_media_stream_dynamic_resolution(MMHandleType player, bool drc);
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
2314 * @param player [in] Handle of player.
2315 * @param bo [in] bo address to be released
2317 * @return This function returns zero on success, or negative value with error
2321 int mm_player_release_video_stream_bo(MMHandleType player, void* bo);
2324 * This function is to set http file buffering path
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.
2333 int mm_player_set_file_buffering_path(MMHandleType player, const char *file_path);
2336 * This function is to set sound stream info
2338 int mm_player_set_sound_stream_info(MMHandleType player, char *stream_type, int stream_index);
2341 * This function is to manage the playback according to the external storage state
2343 int mm_player_manage_external_storage_state(MMHandleType player, int state);
2345 int mm_player_get_adaptive_variant_info(MMHandleType player, int *num, char **var_info);
2347 int mm_player_set_max_adaptive_variant_limit(MMHandleType player, int bandwidth, int width, int height);
2349 int mm_player_get_max_adaptive_variant_limit(MMHandleType player, int *bandwidth, int *width, int *height);
2359 #endif /* __MM_PLAYER_H__ */