Name: libmm-player
Summary: Multimedia Framework Player Library
-Version: 0.6.179
+Version: 0.6.180
Release: 0
Group: Multimedia/Libraries
License: Apache-2.0
int elevation[BUFFER_MAX_PLANE_NUM]; /**< elevation of plane */
int orientation; /**< orientation */
int bo_size; /**< TBM buffer object size */
-} MMPlayerVideoStreamDataType;
+} mmplayer_video_decoded_data_info_t;
/**
* Enumerations of player state.
MM_PLAYER_STATE_PAUSED, /**< Player is paused while playing media */
MM_PLAYER_STATE_NONE, /**< Player is not created yet */
MM_PLAYER_STATE_NUM, /**< Number of player states */
-} MMPlayerStateType;
-
-/**
- * Enumerations of position formats.
- */
-typedef enum {
- MM_PLAYER_POS_FORMAT_TIME, /**< Format for time based */
- MM_PLAYER_POS_FORMAT_PERCENT, /**< Format for percentage */
- MM_PLAYER_POS_FORMAT_NUM, /**< Number of position formats */
-} MMPlayerPosFormatType;
+} mmplayer_state_e;
/**
* Enumeration for attribute values types.
MM_PLAYER_ATTRS_TYPE_ARRAY, /**< Array type */
MM_PLAYER_ATTRS_TYPE_RANGE, /**< Range type */
MM_PLAYER_ATTRS_TYPE_NUM, /**< Number of attribute type */
-} MMPlayerAttrsType;
+} mmplayer_attrs_type_e;
/**
* Enumeration for attribute validation type.
MM_PLAYER_ATTRS_VALID_TYPE_INT_RANGE, /**< validity checking type of integer range */
MM_PLAYER_ATTRS_VALID_TYPE_DOUBLE_ARRAY, /**< validity checking type of double array */
MM_PLAYER_ATTRS_VALID_TYPE_DOUBLE_RANGE, /**< validity checking type of double range */
-} MMPlayerAttrsValidType;
+} mmplayer_attrs_valid_type_e;
/**
* Enumeration for attribute access flag.
MM_PLAYER_ATTRS_FLAG_MODIFIED = 1 << 2, /**< Modified */
MM_PLAYER_ATTRS_FLAG_RW = MM_PLAYER_ATTRS_FLAG_READABLE | MM_PLAYER_ATTRS_FLAG_WRITABLE, /**< Readable and Writable */
-} MMPlayerAttrsFlag;
+} mmplayer_attrs_flag_e;
/**
* Enumeration of track types
MM_PLAYER_TRACK_TYPE_VIDEO,
MM_PLAYER_TRACK_TYPE_TEXT,
MM_PLAYER_TRACK_TYPE_MAX
-} MMPlayerTrackType;
+} mmplayer_track_type_e;
/**
* Enumeration of runtime buffering mode
MM_PLAYER_BUFFERING_MODE_ADAPTIVE = 0, /**< default, If buffering is occurred, player will consider the bandwidth to adjust buffer setting. */
MM_PLAYER_BUFFERING_MODE_FIXED, /**< player will set buffer size with this fixed size value. */
MM_PLAYER_BUFFERING_MODE_MAX,
-} MMPlayerBufferingMode;
-
-/**
- * Edge Properties of the text.
- */
-typedef enum {
- MM_PLAYER_EDGE_NO,
- MM_PLAYER_EDGE_RAISED,
- MM_PLAYER_EDGE_DEPRESSED,
- MM_PLAYER_EDGE_UNIFORM,
- MM_PLAYER_EDGE_DROPSHADOW
-} MMPlayerSubtitleEdge;
+} mmplayer_buffering_mode_e;
/**
* Enumeration of media stream buffer status
typedef enum {
MM_PLAYER_MEDIA_STREAM_BUFFER_UNDERRUN,
MM_PLAYER_MEDIA_STREAM_BUFFER_OVERFLOW,
-} MMPlayerMediaStreamBufferStatus;
+} mmplayer_media_stream_buffer_status_e;
/**
* Enumeration for stream type.
MM_PLAYER_STREAM_TYPE_VIDEO, /**< Video element stream type */
MM_PLAYER_STREAM_TYPE_TEXT, /**< Text type */
MM_PLAYER_STREAM_TYPE_MAX,
-} MMPlayerStreamType;
+} mmplayer_stream_type_e;
typedef enum {
MM_PLAYER_CODEC_TYPE_DEFAULT = 0, /**< codec is selected by the priority */
MM_PLAYER_CODEC_TYPE_HW, /**< HW codec can only be selected */
MM_PLAYER_CODEC_TYPE_SW, /**< SW codec can only be selected */
-} MMPlayerVideoCodecType;
+} mmplayer_video_codec_type_e;
/**
* Attribute validity structure
*/
typedef struct {
- MMPlayerAttrsType type;
- MMPlayerAttrsValidType validity_type;
- MMPlayerAttrsFlag flag;
+ mmplayer_attrs_type_e type;
+ mmplayer_attrs_valid_type_e validity_type;
+ mmplayer_attrs_flag_e flag;
/**
* a union that describes validity of the attribute.
* Only when type is 'MM_ATTRS_TYPE_INT' or 'MM_ATTRS_TYPE_DOUBLE',
double d_val;
} double_range;
};
-} MMPlayerAttrsInfo;
+} mmplayer_attrs_info_t;
/**
* Volume type.
*/
typedef struct {
float level[MM_VOLUME_CHANNEL_NUM]; /**< Relative volume factor for each channels */
-} MMPlayerVolumeType;
+} mmplayer_volume_type_t;
/**
* Video stream info in external demux case
*
**/
-typedef struct _VideoStreamInfo {
+typedef struct {
const char *mime;
unsigned int framerate_num;
unsigned int framerate_den;
unsigned char *codec_extradata;
unsigned int extradata_size;
unsigned int version;
-} MMPlayerVideoStreamInfo;
+} mmplayer_video_stream_info_t;
/**
* Audio stream info in external demux case
*
**/
-typedef struct _AudioStreamInfo {
+typedef struct {
const char *mime;
unsigned int channels;
unsigned int sample_rate;
// unsigned int depth;
// unsigned int endianness;
// bool signedness;
-} MMPlayerAudioStreamInfo;
+} mmplayer_audio_stream_info_t;
/**
* Subtitle stream info in external demux case
const char *mime;
unsigned int codec_tag;
void *context; //for smpte text
-} MMPlayerSubtitleStreamInfo;
+} mmplayer_subtitle_stream_info_t;
/**
* selected subtitle track number callback function type.
*
* @return This callback function have to return MM_ERROR_NONE.
*/
-typedef bool (*mm_player_media_stream_buffer_status_callback)(MMPlayerStreamType type, MMPlayerMediaStreamBufferStatus status, unsigned long long bytes, void *user_param);
+typedef bool (*mm_player_media_stream_buffer_status_callback)(mmplayer_stream_type_e type, mmplayer_media_stream_buffer_status_e status, unsigned long long bytes, void *user_param);
/**
* Buffer seek data callback function type.
*
* @return This callback function have to return MM_ERROR_NONE.
*/
-typedef bool (*mm_player_media_stream_seek_data_callback)(MMPlayerStreamType type, unsigned long long offset, void *user_param);
+typedef bool (*mm_player_media_stream_seek_data_callback)(mmplayer_stream_type_e type, unsigned long long offset, void *user_param);
/**
* Called to notify the stream changed.
*
* @return This function returns zero on success, or negative value with error code.
*
- * @see MMPlayerStateType
+ * @see mmplayer_state_e
* @remark None
* @par Example
* @code
}
* @endcode
*/
-int mm_player_get_state(MMHandleType player, MMPlayerStateType *state);
+int mm_player_get_state(MMHandleType player, mmplayer_state_e *state);
/**
* This function is to set relative volume of player. \n
* @param volume [in] Volume factor of each channel
*
* @return This function returns zero on success, or negative value with error code.
- * @see MMPlayerVolumeType, mm_player_get_volume
+ * @see mmplayer_volume_type_t, mm_player_get_volume
* @remark The range of factor range is from 0 to 1.0. (1.0 = 100%) And, default value is 1.0.
* @par Example
* @code
-MMPlayerVolumeType volume;
+mmplayer_volume_type_t volume;
int i = 0;
for (i = 0; i < MM_VOLUME_CHANNEL_NUM; i++)
}
* @endcode
*/
-int mm_player_set_volume(MMHandleType player, MMPlayerVolumeType *volume);
+int mm_player_set_volume(MMHandleType player, mmplayer_volume_type_t *volume);
/**
* This function is to get current volume factor of player.
*
* @return This function returns zero on success, or negative value with error code.
*
- * @see MMPlayerVolumeType, mm_player_set_volume
+ * @see mmplayer_volume_type_t, mm_player_set_volume
* @remark None
* @par Example
* @code
-MMPlayerVolumeType volume;
+mmplayer_volume_type_t volume;
int i;
if (mm_player_get_volume(g_player, &volume) != MM_ERROR_NONE)
LOGD("channel[%d] = %d \n", i, volume.level[i]);
* @endcode
*/
-int mm_player_get_volume(MMHandleType player, MMPlayerVolumeType *volume);
+int mm_player_get_volume(MMHandleType player, mmplayer_volume_type_t *volume);
/**
* This function is to start playing media contents. Demux(parser), codec and related plugins are decided \n
* @param stop_pos [out] contains buffer current position on success or zero in case of failure.
*
* @return This function returns zero on success, or negative value with errors
- * @see MMPlayerPosFormatType, mm_player_set_position
+ * @see mm_player_set_position
* @remark the unit of time-based format is millisecond and other case is percent.
* @par Example
* @code
int pos;
pos = 5000;
-if (mm_player_adjust_subtitle_position(g_player, MM_PLAYER_POS_FORMAT_TIME, pos) != MM_ERROR_NONE)
+if (mm_player_adjust_subtitle_position(g_player, pos) != MM_ERROR_NONE)
{
LOGW("failed to adjust subtitle postion.\n");
}
* @endcode
*/
-int mm_player_adjust_subtitle_position(MMHandleType player, MMPlayerPosFormatType format, int pos);
+int mm_player_adjust_subtitle_position(MMHandleType player, int pos);
/**
* This function is to set subtitle silent status. So, subtitle can show or hide during playback \n
}
* @endcode
*/
-int mm_player_get_attribute_info(MMHandleType player, const char *attribute_name, MMPlayerAttrsInfo *info);
+int mm_player_get_attribute_info(MMHandleType player, const char *attribute_name, mmplayer_attrs_info_t *info);
/**
* This function is to get the track count
LOGD("audio track count : %d \n", audio_count);
* @endcode
*/
-int mm_player_get_track_count(MMHandleType player, MMPlayerTrackType type, int *count);
+int mm_player_get_track_count(MMHandleType player, mmplayer_track_type_e type, int *count);
/**
* This function is to select the track
* @return This function returns zero on success, or negative value with error
* code.
*/
-int mm_player_select_track(MMHandleType player, MMPlayerTrackType type, int index);
+int mm_player_select_track(MMHandleType player, mmplayer_track_type_e type, int index);
/**
* This function is to get the track language
* @return This function returns zero on success, or negative value with error
* code.
*/
-int mm_player_get_track_language_code(MMHandleType player, MMPlayerTrackType type, int index, char **code);
+int mm_player_get_track_language_code(MMHandleType player, mmplayer_track_type_e type, int index, char **code);
/**
* This function is to get the current running track
* code.
*/
-int mm_player_get_current_track(MMHandleType hplayer, MMPlayerTrackType type, int *index);
+int mm_player_get_current_track(MMHandleType hplayer, mmplayer_track_type_e type, int *index);
/**
* This function is to set the subtitle path
* @param subtitle_stream_info [in] Subtitle stream info.
* @return This function returns zero on success, or negative value with error code.
*/
-int mm_player_set_subtitle_info(MMHandleType player, MMPlayerSubtitleStreamInfo *info);
+int mm_player_set_subtitle_info(MMHandleType player, mmplayer_subtitle_stream_info_t *info);
/**
* This function set callback function for receiving need or enough data message from player.
* @return This function returns zero on success, or negative value with error
* code.
*/
-int mm_player_set_media_stream_buffer_status_callback(MMHandleType player, MMPlayerStreamType type, mm_player_media_stream_buffer_status_callback callback, void *user_param);
+int mm_player_set_media_stream_buffer_status_callback(MMHandleType player, mmplayer_stream_type_e type, mm_player_media_stream_buffer_status_callback callback, void *user_param);
/**
* This function set callback function for receiving seek data message from player.
* @return This function returns zero on success, or negative value with error
* code.
*/
-int mm_player_set_media_stream_seek_data_callback(MMHandleType player, MMPlayerStreamType type, mm_player_media_stream_seek_data_callback callback, void *user_param);
+int mm_player_set_media_stream_seek_data_callback(MMHandleType player, mmplayer_stream_type_e type, mm_player_media_stream_seek_data_callback callback, void *user_param);
/**
* This function is to set max size of buffer(appsrc).
* @return This function returns zero on success, or negative value with error
* code.
*/
-int mm_player_set_media_stream_buffer_max_size(MMHandleType player, MMPlayerStreamType type, unsigned long long max_size);
+int mm_player_set_media_stream_buffer_max_size(MMHandleType player, mmplayer_stream_type_e type, unsigned long long max_size);
/**
* This function is to get max size of buffer(appsrc).
* @return This function returns zero on success, or negative value with error
* code.
*/
-int mm_player_get_media_stream_buffer_max_size(MMHandleType player, MMPlayerStreamType type, unsigned long long *max_size);
+int mm_player_get_media_stream_buffer_max_size(MMHandleType player, mmplayer_stream_type_e type, unsigned long long *max_size);
/**
* This function is to set min percent of buffer(appsrc).
* @return This function returns zero on success, or negative value with error
* code.
*/
-int mm_player_set_media_stream_buffer_min_percent(MMHandleType player, MMPlayerStreamType type, unsigned min_percent);
+int mm_player_set_media_stream_buffer_min_percent(MMHandleType player, mmplayer_stream_type_e type, unsigned min_percent);
/**
* This function is to get min percent of buffer(appsrc).
* @return This function returns zero on success, or negative value with error
* code.
*/
-int mm_player_get_media_stream_buffer_min_percent(MMHandleType player, MMPlayerStreamType type, unsigned int *min_percent);
+int mm_player_get_media_stream_buffer_min_percent(MMHandleType player, mmplayer_stream_type_e type, unsigned int *min_percent);
/**
* This function set callback function for changing audio stream from player. \n
/**
* This function is to set codec type
*/
-int mm_player_set_codec_type(MMHandleType player, MMPlayerStreamType stream_type, MMPlayerVideoCodecType codec_type);
+int mm_player_set_codec_type(MMHandleType player, mmplayer_stream_type_e stream_type, mmplayer_video_codec_type_e codec_type);
/**
* These functions are to apply the replaygain
* @see
*
*/
-int _mmplayer_get_attributes_info(MMHandleType handle, const char *attribute_name, MMPlayerAttrsInfo *info);
+int _mmplayer_get_attributes_info(MMHandleType handle, const char *attribute_name, mmplayer_attrs_info_t *info);
/**
* This function allocates structure of attributes and sets initial values.
*
MM_AUDIO_EFFECT_PRESET_STUDIO, /**< Preset type Studio */
MM_AUDIO_EFFECT_PRESET_CLUB, /**< Preset type Club */
MM_AUDIO_EFFECT_PRESET_NUM, /**< Number of Preset type */
-} MMAudioEffectPresetType;
+} mm_audio_effect_preset_type_e;
/**
* Enumerations of Audio Effect Custom Type
MM_AUDIO_EFFECT_CUSTOM_REVERB_LEVEL, /**< Custom type Reverb Level */
MM_AUDIO_EFFECT_CUSTOM_CLARITY, /**< Custom type Clarity */
MM_AUDIO_EFFECT_CUSTOM_NUM, /**< Number of Custom type */
-} MMAudioEffectCustomType;
+} mm_audio_effect_custom_type_e;
/**
* Enumerations of Audio Effect Type
MM_AUDIO_EFFECT_TYPE_PRESET,
MM_AUDIO_EFFECT_TYPE_CUSTOM,
MM_AUDIO_EFFECT_TYPE_SQUARE,
-} MMAudioEffectType;
+} mm_audio_effect_type_e;
/**
MM_AUDIO_EFFECT_OUTPUT_USB_AUDIO,
MM_AUDIO_EFFECT_OUTPUT_HDMI,
MM_AUDIO_EFFECT_OUTPUT_NUM
-} MMAudioEffectOutputMode;
+} mm_audio_effect_output_mode_e;
/**
* Structure of AudioEffectInfo
*/
typedef struct {
- MMAudioEffectType effect_type; /**< effect type, (NONE,PRESET,CUSTOM)*/
- MMAudioEffectPresetType preset; /**< for preset type*/
+ mm_audio_effect_type_e effect_type; /**< effect type, (NONE,PRESET,CUSTOM)*/
+ mm_audio_effect_preset_type_e preset; /**< for preset type*/
int *custom_ext_level_for_plugin; /**< for custom type, level value list of Extension effects*/
int custom_eq_level[MM_AUDIO_EFFECT_EQ_BAND_NUM_MAX]; /**< for custom type, EQ info*/
int custom_ext_level[MM_AUDIO_EFFECT_CUSTOM_NUM-1]; /**< for custom type, Extension effect info*/
int square_row; /**< for square type, square row configure*/
int square_col; /**< for square type, square col configure*/
-} MMAudioEffectInfo;
+} mm_audio_effect_info_t;
/**
* @see
* @since
*/
-int mm_player_get_foreach_present_supported_effect_type(MMHandleType player, MMAudioEffectType effect_type, mmplayer_supported_audio_effect_cb foreach_cb, void *user_data);
+int mm_player_get_foreach_present_supported_effect_type(MMHandleType player, mm_audio_effect_type_e effect_type, mmplayer_supported_audio_effect_cb foreach_cb, void *user_data);
/**
* This function is to bypass audio effect.
* @return This function returns zero on success, or negative value with error code.
*
* @remark
- * @see MMAudioEffectCustomType
+ * @see mm_audio_effect_custom_type_e
* @since
*/
-int mm_player_audio_effect_custom_get_level(MMHandleType hplayer, MMAudioEffectCustomType type, int eq_index, int *level);
+int mm_player_audio_effect_custom_get_level(MMHandleType hplayer, mm_audio_effect_custom_type_e type, int eq_index, int *level);
/**
* This function is to get range of the level of the custom effect.
* @return This function returns zero on success, or negative value with error code.
*
* @remark
- * @see MMAudioEffectCustomType
+ * @see mm_audio_effect_custom_type_e
* @since
*/
-int mm_player_audio_effect_custom_get_level_range(MMHandleType hplayer, MMAudioEffectCustomType type, int *min, int *max);
+int mm_player_audio_effect_custom_get_level_range(MMHandleType hplayer, mm_audio_effect_custom_type_e type, int *min, int *max);
/**
* This function is to set the level of the custom effect.
* @return This function returns zero on success, or negative value with error code.
*
* @remark
- * @see MMAudioEffectCustomType
+ * @see mm_audio_effect_custom_type_e
* @since
*/
-int mm_player_audio_effect_custom_set_level(MMHandleType hplayer, MMAudioEffectCustomType effect_custom_type, int eq_index, int level);
+int mm_player_audio_effect_custom_set_level(MMHandleType hplayer, mm_audio_effect_custom_type_e effect_custom_type, int eq_index, int level);
/**
* This function is to set the bands level of equalizer custom effect using input list.
* @see
* @since
*/
-int mm_player_is_supported_preset_effect_type(MMHandleType hplayer, MMAudioEffectPresetType effect);
+int mm_player_is_supported_preset_effect_type(MMHandleType hplayer, mm_audio_effect_preset_type_e effect);
/**
* This function is to decide if the custom type effect is supported or not
* @see
* @since
*/
-int mm_player_is_supported_custom_effect_type(MMHandleType hplayer, MMAudioEffectCustomType effect);
+int mm_player_is_supported_custom_effect_type(MMHandleType hplayer, mm_audio_effect_custom_type_e effect);
/**
@}
* @see
*
*/
-int _mmplayer_initialize_video_capture(mm_player_t *player);
+int _mmplayer_initialize_video_capture(mmplayer_t *player);
/**
* This function is to release video capture
* @see
*
*/
-int _mmplayer_release_video_capture(mm_player_t *player);
+int _mmplayer_release_video_capture(mmplayer_t *player);
/**
* This function is to get video snapshot during playback.
int _mmplayer_set_audio_info(MMHandleType player, media_format_h format);
-int _mmplayer_set_subtitle_info(MMHandleType player, MMPlayerSubtitleStreamInfo *info);
+int _mmplayer_set_subtitle_info(MMHandleType player, mmplayer_subtitle_stream_info_t *info);
int _mmplayer_submit_packet(MMHandleType player, media_packet_h packet);
int _mmplayer_set_media_stream_buffer_status_cb(MMHandleType player,
- MMPlayerStreamType type,
+ mmplayer_stream_type_e type,
mm_player_media_stream_buffer_status_callback callback,
void *user_param);
int _mmplayer_set_media_stream_seek_data_cb(MMHandleType player,
- MMPlayerStreamType type,
+ mmplayer_stream_type_e type,
mm_player_media_stream_seek_data_callback callback,
void *user_param);
int _mmplayer_set_media_stream_max_size(MMHandleType hplayer,
- MMPlayerStreamType type,
+ mmplayer_stream_type_e type,
guint64 max_size);
int _mmplayer_get_media_stream_max_size(MMHandleType hplayer,
- MMPlayerStreamType type,
+ mmplayer_stream_type_e type,
guint64 *max_size);
int _mmplayer_set_media_stream_min_percent(MMHandleType hplayer,
- MMPlayerStreamType type,
+ mmplayer_stream_type_e type,
guint min_percent);
int _mmplayer_get_media_stream_min_percent(MMHandleType hplayer,
- MMPlayerStreamType type,
+ mmplayer_stream_type_e type,
guint *min_percent);
int _mmplayer_set_media_stream_dynamic_resolution(MMHandleType hplayer, bool drc);
| GLOBAL FUNCTION PROTOTYPES |
========================================================================================*/
-gint __mmplayer_gst_handle_core_error(mm_player_t *player, int code);
-gint __mmplayer_gst_handle_library_error(mm_player_t *player, int code);
-gint __mmplayer_gst_handle_resource_error(mm_player_t *player, int code, GstMessage *message);
-gint __mmplayer_gst_handle_stream_error(mm_player_t *player, GError *error, GstMessage *message);
+gint __mmplayer_gst_handle_core_error(mmplayer_t *player, int code);
+gint __mmplayer_gst_handle_library_error(mmplayer_t *player, int code);
+gint __mmplayer_gst_handle_resource_error(mmplayer_t *player, int code, GstMessage *message);
+gint __mmplayer_gst_handle_stream_error(mmplayer_t *player, GError *error, GstMessage *message);
-gboolean __mmplayer_handle_gst_error(mm_player_t *player, GstMessage *message, GError *error);
-int __mmplayer_gst_set_state(mm_player_t *player, GstElement *element, GstState state, gboolean async, gint timeout);
+gboolean __mmplayer_handle_gst_error(mmplayer_t *player, GstMessage *message, GError *error);
+int __mmplayer_gst_set_state(mmplayer_t *player, GstElement *element, GstState state, gboolean async, gint timeout);
-int __mmplayer_gst_start(mm_player_t *player);
-int __mmplayer_gst_stop(mm_player_t *player);
-int __mmplayer_gst_pause(mm_player_t *player, gboolean async);
-int __mmplayer_gst_resume(mm_player_t *player, gboolean async);
-gboolean __mmplayer_gst_send_event_to_sink(mm_player_t *player, GstEvent *event);
-gboolean __mmplayer_gst_seek(mm_player_t *player, GstElement *element, gdouble rate,
+int __mmplayer_gst_start(mmplayer_t *player);
+int __mmplayer_gst_stop(mmplayer_t *player);
+int __mmplayer_gst_pause(mmplayer_t *player, gboolean async);
+int __mmplayer_gst_resume(mmplayer_t *player, gboolean async);
+gboolean __mmplayer_gst_send_event_to_sink(mmplayer_t *player, GstEvent *event);
+gboolean __mmplayer_gst_seek(mmplayer_t *player, GstElement *element, gdouble rate,
GstFormat format, GstSeekFlags flags, GstSeekType cur_type,
gint64 cur, GstSeekType stop_type, gint64 stop);
-int __mmplayer_gst_set_position(mm_player_t *player, gint64 position, gboolean internal_called);
-int __mmplayer_gst_get_position(mm_player_t *player, gint64 *position);
-int __mmplayer_gst_get_buffer_position(mm_player_t *player, int *start_pos, int *end_pos);
-GstElement *__mmplayer_gst_create_source(mm_player_t *player);
-int __mmplayer_gst_build_es_pipeline(mm_player_t *player);
-int __mmplayer_gst_build_pipeline(mm_player_t *player);
-int __mmplayer_gst_add_bus_watch(mm_player_t *player);
+int __mmplayer_gst_set_position(mmplayer_t *player, gint64 position, gboolean internal_called);
+int __mmplayer_gst_get_position(mmplayer_t *player, gint64 *position);
+int __mmplayer_gst_get_buffer_position(mmplayer_t *player, int *start_pos, int *end_pos);
+GstElement *__mmplayer_gst_create_source(mmplayer_t *player);
+int __mmplayer_gst_build_es_pipeline(mmplayer_t *player);
+int __mmplayer_gst_build_pipeline(mmplayer_t *player);
+int __mmplayer_gst_add_bus_watch(mmplayer_t *player);
#ifdef __cplusplus
}
KEYWORD_A_OFFLOAD, // for audio device type which can support offload
};
-typedef struct __mm_player_ini {
+typedef struct {
/* general */
gchar videosink_element_overlay[PLAYER_INI_MAX_STRLEN];
gchar videosink_element_fake[PLAYER_INI_MAX_STRLEN];
gchar dump_element_keyword[PLAYER_INI_MAX_ELEMENT][PLAYER_INI_MAX_STRLEN];
gchar dump_element_path[PLAYER_INI_MAX_STRLEN];
gboolean set_dump_element_flag;
-} mm_player_ini_t;
+} mmplayer_ini_t;
/* default values if each values are not specified in inifile */
/* general */
"
int
-mm_player_ini_load(mm_player_ini_t *ini);
+mm_player_ini_load(mmplayer_ini_t *ini);
int
-mm_player_audio_effect_ini_load(mm_player_ini_t *ini);
+mm_player_audio_effect_ini_load(mmplayer_ini_t *ini);
#ifdef __cplusplus
}
MM_PLAYER_COLORSPACE_NV12,
MM_PLAYER_COLORSPACE_BGRx, /**< BGRx pixel format */
MM_PLAYER_COLORSPACE_MAX = 0x7FFFFFFF
-} MMPlayerVideoColorspace;
+} mmplayer_video_color_space_e;
typedef struct {
unsigned char *data; /* capture image buffer */
int size; /* capture image size */
- MMPlayerVideoColorspace fmt; /* color space type */
+ mmplayer_video_color_space_e fmt; /* color space type */
unsigned int width; /* width of captured image */
unsigned int height; /* height of captured image */
unsigned int orientation; /* content orientation */
-} MMPlayerVideoCapture;
+} mmplayer_video_capture_t;
typedef struct {
void *data;
int depth;
bool is_little_endian;
guint64 channel_mask;
-} MMPlayerAudioStreamDataType;
+} mmplayer_audio_decoded_data_info_t;
/**
* Video stream callback function type.
*
* @return This callback function have to return MM_ERROR_NONE.
*/
-typedef bool (*mm_player_audio_stream_callback)(MMPlayerAudioStreamDataType *stream, void *user_param);
+typedef bool (*mm_player_audio_stream_callback)(mmplayer_audio_decoded_data_info_t *stream, void *user_param);
/**
* This function is to set play speed for playback.
*
#define MM_PLAYER_IMGB_MPLANE_MAX 4
#define MM_PLAYER_STREAM_COUNT_MAX 3
-#define MM_PLAYER_CAST(x_player) ((mm_player_t *)(x_player))
+#define MM_PLAYER_CAST(x_player) ((mmplayer_t *)(x_player))
/**
* @x_player: MMHandleType of player
*
ATTR_ALL = 0x0020,
};
-enum MMPlayerSinkType {
+enum mmplayer_sink_type {
MMPLAYER_VIDEO_SINK = 0x01,
MMPLAYER_AUDIO_SINK = 0x02,
MMPLAYER_TEXT_SINK = 0x04,
/**
* Enumerations of Player Uri type
*/
-enum MMPlayerUriType {
+enum mmplayer_uri_type {
MM_PLAYER_URI_TYPE_NONE, /**< Player URI type None */
MM_PLAYER_URI_TYPE_URL_RTSP, /**< Player URI type RTSP */
MM_PLAYER_URI_TYPE_URL_HTTP, /**< Player URI type HTTP */
MM_PLAYER_URI_TYPE_TEMP, /**< Player URI type Temp */
};
-typedef enum _MissingCodec {
+typedef enum {
MISSING_PLUGIN_NONE = 0x00,
MISSING_PLUGIN_AUDIO = 0x01,
MISSING_PLUGIN_VIDEO = 0x02
-} MissingCodec;
+} missing_codec_e;
-typedef enum _FoundCodec {
+typedef enum {
FOUND_PLUGIN_NONE = 0x00,
FOUND_PLUGIN_AUDIO = 0x01,
FOUND_PLUGIN_VIDEO = 0x02
-} FoundCodec;
+} found_codec_e;
/**
* Enumeration of signal type
MM_PLAYER_SIGNAL_TYPE_OTHERS,
MM_PLAYER_SIGNAL_TYPE_ALL,
MM_PLAYER_SIGNAL_TYPE_MAX = MM_PLAYER_SIGNAL_TYPE_ALL,
-} MMPlayerSignalType;
+} mmplayer_signal_type_e;
/* main pipeline's element id */
-enum MainElementID {
+typedef enum {
MMPLAYER_M_PIPE = 0, /* NOTE : MMPLAYER_M_PIPE should be zero */
MMPLAYER_M_SRC,
MMPLAYER_M_2ND_SRC, /* 2nd Source Element for es buff src */
MMPLAYER_M_A_INPUT_SELECTOR, // audio input_select
MMPLAYER_M_T_INPUT_SELECTOR, // text input_select
MMPLAYER_M_NUM
-};
+} main_element_id_e;
/* audio pipeline's element id */
-enum AudioElementID {
+enum audio_element_id {
MMPLAYER_A_BIN = 0, /* NOTE : MMPLAYER_A_BIN should be zero */
MMPLAYER_A_CONV,
MMPLAYER_A_VOL,
};
/* video pipeline's element id */
-enum VideoElementID {
+enum video_element_id {
MMPLAYER_V_BIN = 0, /* NOTE : MMPLAYER_V_BIN should be zero */
MMPLAYER_V_CONV,
MMPLAYER_V_CAPS,
};
/* text pipeline's element id */
-enum TextElementID {
+enum text_element_id {
MMPLAYER_T_BIN = 0, /* NOTE : MMPLAYER_V_BIN should be zero */
MMPLAYER_T_QUEUE,
MMPLAYER_T_VIDEO_QUEUE,
MMPLAYER_T_NUM
};
-/* midi main pipeline's element id */
-enum MidiElementID {
- MMPLAYER_MIDI_PIPE,
- MMPLAYER_MIDI_PLAYER,
- MMPLAYER_MIDI_NUM
-};
-
-enum PlayerCommandState {
+typedef enum {
MMPLAYER_COMMAND_NONE,
MMPLAYER_COMMAND_CREATE,
MMPLAYER_COMMAND_DESTROY,
MMPLAYER_COMMAND_PAUSE,
MMPLAYER_COMMAND_RESUME,
MMPLAYER_COMMAND_NUM
-};
+} mmplayer_command_state_e;
-/* Note : StreamingSrcError is error enum for streaming source which post error message
+/* Note : mmplayer_streaming_src_error is error enum for streaming source which post error message
* using custom message made by itself. The enum value must start with zero,
* because the streaming source(secrtspsrc) also does.
*/
-enum StreamingSrcError {
+enum mmplayer_streaming_src_error {
MMPLAYER_STREAMING_ERROR_NONE = 0,
MMPLAYER_STREAMING_ERROR_UNSUPPORTED_AUDIO,
MMPLAYER_STREAMING_ERROR_UNSUPPORTED_VIDEO,
MMPLAYER_SEEK_NONE = 0,
MMPLAYER_SEEK_IN_PROGRESS,
MMPLAYER_SEEK_COMPLETED, /* after getting async done but before posting seek complete */
-} MMPlayerSeekState;
+} mmplayer_seek_state_e;
typedef enum {
MMPLAYER_PATH_VOD = 0,
MMPLAYER_PATH_TEXT,
MMPLAYER_PATH_MAX
-} MMPlayerPathType;
+} mmplayer_path_type_e;
/* Video360 related enums. These are duplication from video360.h from
* gst-plugins-tizen.
VIDEO360_MODE_STEREOSCOPIC_LEFT_RIGHT = 2,
VIDEO360_MODE_STEREOSCOPIC_STEREO_MESH = 3,
VIDEO360_MODE_LAST_ITEM
-} mm_player_stereo_mode_e;
+} mmplayer_stereo_mode_e;
typedef enum {
VIDEO360_PROJECTION_TYPE_UNKNOWN = -1,
VIDEO360_PROJECTION_TYPE_CUBEMAP = 1,
VIDEO360_PROJECTION_TYPE_MESH = 2,
VIDEO360_PROJECTION_TYPE_LAST_ITEM
-} mm_player_projection_type_e;
+} mmplayer_projection_type_e;
/* Spatial audio related enums. These are duplication from mm_file.h from
* libmm-fileinfo.
MMFILE_AMBISONIC_TYPE_UNKNOWN = 0,
MMFILE_AMBISONIC_TYPE_PERIPHONIC = 1, /**< To comply with Google's Spatial Audio RFC*/
MMFILE_AMBISONIC_TYPE_NON_PERIPHONIC = 2,
-} MMFILE_AMBISONIC_TYPE;
+} mmfile_ambisonic_type_e;
typedef enum {
MMFILE_AMBISONIC_FORMAT_UNKNOWN = 0,
MMFILE_AMBISONIC_FORMAT_AMBIX = 1, /**< AMBIX (Channel sequence: ACN, Normalization: SN3D) */
MMFILE_AMBISONIC_FORMAT_AMB = 2, /**< .AMB, Tetraproc (Channel sequence: FuMa, Normalization: FuMa) */
MMFILE_AMBISONIC_FORMAT_UA = 3, /**< Universal Ambisonics (Channel sequence: SID, Normalization: N3D) */
-} MMFILE_AMBISONIC_FORMAT;
+} mmfile_ambisonic_format_e;
typedef enum {
MMFILE_AMBISONIC_ORDER_UNKNOWN = 0,
MMFILE_AMBISONIC_ORDER_FOA = 1, /**< First order Ambisonics */
MMFILE_AMBISONIC_ORDER_SOA = 2, /**< Second order Ambisonics */
MMFILE_AMBISONIC_ORDER_TOA = 3, /**< Third order Ambisonics */
-} MMFILE_AMBISONIC_ORDER;
+} mmfile_ambisonic_order_e;
/*---------------------------------------------------------------------------
| GLOBAL DATA TYPE DEFINITIONS: |
typedef struct {
int id;
GstElement *gst;
-} MMPlayerGstElement;
+} mmplayer_gst_element_t;
typedef struct {
GstTagList *tag_list;
- MMPlayerGstElement *mainbin;
- MMPlayerGstElement *audiobin;
- MMPlayerGstElement *videobin;
- MMPlayerGstElement *textbin;
-} MMPlayerGstPipelineInfo;
+ mmplayer_gst_element_t *mainbin;
+ mmplayer_gst_element_t *audiobin;
+ mmplayer_gst_element_t *videobin;
+ mmplayer_gst_element_t *textbin;
+} mmplayer_pipeline_info_t;
typedef struct {
float volume;
int bluetooth; /* enable/disable */
int focus_id;
bool rg_enable;
-} MMPlayerSoundInfo;
+} mmplayer_sound_info_t;
typedef struct {
char *buf;
int len;
int offset;
-} MMPlayerInputBuffer;
+} mmplayer_input_buffer_t;
typedef struct {
int uri_type;
- MMPlayerInputBuffer input_mem;
+ mmplayer_input_buffer_t input_mem;
char uri[MM_MAX_URL_LEN];
char urgent[MM_MAX_FILENAME_LEN];
-} MMPlayerParseProfile;
+} mmplayer_parse_profile_t;
typedef struct {
storage_type_e type;
storage_state_e state;
int id;
char path[MM_MAX_URL_LEN];
-} MMPlayerStorageInfo;
+} mmplayer_storage_info_t;
typedef struct {
bool is_pending;
gint64 pos;
-} MMPlayerPendingSeek;
+} mmplayer_pending_seek_t;
typedef struct {
GObject *obj;
gulong sig;
-} MMPlayerSignalItem;
+} mmplayer_signal_item_t;
typedef struct {
bool rich_audio;
bool video_zc; // video zero-copy
bool subtitle_off;
bool media_packet_video_stream;
-} MMPlayerSetMode;
+} mmplayer_setting_mode_t; /* FIXME: renaming */
typedef struct {
GMainContext *global_default;
GMainContext *thread_default;
-} MMPlayerGMainContext;
+} mmplayer_context_info_t;
typedef struct {
gint uri_idx;
GList *uri_list;
-} MMPlayerUriList;
+} mmplayer_uri_list_t;
typedef struct {
double scale_x;
double scale_y;
double scale_width;
double scale_height;
-} MMPlayerVideoROI;
+} mmplayer_video_roi_t;
typedef struct {
gint active_pad_index;
GPtrArray *channels;
gulong block_id;
gulong event_probe_id;
-} mm_player_selector_t;
+} mmplayer_selector_t;
typedef struct {
gboolean running;
GstSegment segment[MM_PLAYER_TRACK_TYPE_MAX];
gboolean update_segment[MM_PLAYER_TRACK_TYPE_MAX];
-} mm_player_gapless_t;
+} mmplayer_gapless_t;
typedef struct {
int channel;
void *pcm_data;
int data_size;
int buff_size;
-} mm_player_audio_stream_buff_t;
+} mmplayer_audio_stream_buff_t;
/**
* @brief data of video_bo_list
typedef struct {
gboolean used;
void *bo;
-} mm_player_video_bo_info_t;
+} mmplayer_video_bo_info_t;
typedef struct {
gint bandwidth;
gint width;
gint height;
-} VariantData;
+} stream_variant_t;
typedef struct {
GList *var_list;
- VariantData limit;
-} MMAdaptiveVariantInfo;
+ stream_variant_t limit;
+} mmplayer_adaptive_variant_info_t;
typedef struct {
int is_spherical;
char *stitching_software;
char *projection_type_string;
char *stereo_mode_string;
- mm_player_projection_type_e projection_type;
- mm_player_stereo_mode_e stereo_mode;
+ mmplayer_projection_type_e projection_type;
+ mmplayer_stereo_mode_e stereo_mode;
int source_count;
int init_view_heading;
int init_view_pitch;
int ambisonic_type;
int ambisonic_format;
int ambisonic_order;
-} mm_player_spherical_metadata_t;
+} mmplayer_spherical_metadata_t;
typedef struct {
/* STATE */
gboolean gapless_play_thread_exit;
GCond gapless_play_thread_cond;
GMutex gapless_play_thread_mutex;
- mm_player_gapless_t gapless;
+ mmplayer_gapless_t gapless;
/* capture thread */
GThread *capture_thread;
gboolean capture_thread_exit;
GCond capture_thread_cond;
GMutex capture_thread_mutex;
- MMPlayerVideoCapture capture;
- MMPlayerVideoColorspace video_cs;
+ mmplayer_video_capture_t capture;
+ mmplayer_video_color_space_e video_cs;
MMVideoBuffer captured;
/* gst bus msg thread, create during realize */
void *msg_cb_param;
/* streaming player */
- mm_player_streaming_t *streamer;
+ mmplayer_streaming_t *streamer;
/* gstreamer pipeline */
- MMPlayerGstPipelineInfo *pipeline;
+ mmplayer_pipeline_info_t *pipeline;
/* pad */
GstPad *ghost_pad_for_videobin;
void *video_stream_cb_user_param;
GCond video_bo_cond;
GMutex video_bo_mutex;
- GList *video_bo_list; /* mm_player_video_bo_info_t, bo list for decoded video data by sw codec */
+ GList *video_bo_list; /* mmplayer_video_bo_info_t, bo list for decoded video data by sw codec */
int video_bo_size;
bool video_stream_prerolled;
mm_player_audio_stream_callback audio_stream_render_cb;
void *audio_stream_cb_user_param;
bool audio_stream_sink_sync;
- GList *audio_stream_buff_list; /* mm_player_audio_stream_buff_t, buff list of extract pcm data */
+ GList *audio_stream_buff_list; /* mmplayer_audio_stream_buff_t, buff list of extract pcm data */
/* video capture callback*/
gulong video_capture_cb_probe_id;
/* sound info */
- MMPlayerSoundInfo sound;
+ mmplayer_sound_info_t sound;
/* type string */
gchar *type;
GstCaps *v_stream_caps;
/* audio effect infomation */
- MMAudioEffectInfo audio_effect_info;
+ mm_audio_effect_info_t audio_effect_info;
gboolean bypass_audio_effect;
/* content profile */
- MMPlayerParseProfile profile;
- MMPlayerStorageInfo storage_info[MMPLAYER_PATH_MAX];
+ mmplayer_parse_profile_t profile;
+ mmplayer_storage_info_t storage_info[MMPLAYER_PATH_MAX];
/* streaming service type */
MMStreamingType streaming_type;
gint textsink_linked;
/* missing plugin during autoplugging */
- MissingCodec not_supported_codec;
+ missing_codec_e not_supported_codec;
/* unlinked audio/video mime type */
gchar *unlinked_video_mime;
gchar *unlinked_demuxer_mime;
/* found codec during autoplugging */
- FoundCodec can_support_codec;
+ found_codec_e can_support_codec;
gboolean not_found_demuxer;
/* support seek even though player is not start */
- MMPlayerPendingSeek pending_seek;
- MMPlayerSeekState seek_state;
+ mmplayer_pending_seek_t pending_seek;
+ mmplayer_seek_state_e seek_state;
/* prevent to post msg over and over */
gboolean msg_posted;
guint bus_watcher;
GQueue *bus_msg_q;
GMutex bus_msg_q_lock;
- MMPlayerGMainContext context;
- MMPlayerUriList uri_info;
+ mmplayer_context_info_t context;
+ mmplayer_uri_list_t uri_info;
gboolean is_sound_extraction;
/* To store the current running audio pad index of demuxer */
gint demux_pad_index;
- mm_player_selector_t selector[MM_PLAYER_TRACK_TYPE_MAX];
+ mmplayer_selector_t selector[MM_PLAYER_TRACK_TYPE_MAX];
guint internal_text_idx;
guint external_text_idx;
- MMPlayerSetMode set_mode;
+ mmplayer_setting_mode_t set_mode;
/* initialize values */
- mm_player_ini_t ini;
+ mmplayer_ini_t ini;
/* store dump pad list */
GList *dump_list;
/* tmb buffer manager for s/w codec tmb_bo */
tbm_bufmgr bufmgr;
- MMAdaptiveVariantInfo adaptive_info;
+ mmplayer_adaptive_variant_info_t adaptive_info;
/* Video360 related stuff
* */
gboolean is_360_feature_enabled;
gboolean is_content_spherical;
- mm_player_spherical_metadata_t video360_metadata;
+ mmplayer_spherical_metadata_t video360_metadata;
gboolean is_openal_plugin_used;
/* User settable values */
gboolean is_video360_enabled;
int video360_vertical_fov;
/* Video ROI area scale value */
- MMPlayerVideoROI video_roi;
+ mmplayer_video_roi_t video_roi;
/* build audio offload */
gboolean build_audio_offload;
guint audio_device_cb_id;
-} mm_player_t;
+} mmplayer_t;
typedef struct {
gchar *language_code;
gchar *language_key;
gboolean active;
-} MMPlayerLangStruct;
+} mmplayer_lang_info_t;
typedef struct {
GstPad *dump_pad;
gulong probe_handle_id;
FILE *dump_element_file;
-} mm_player_dump_t;
+} mmplayer_dump_t;
typedef struct {
char *name;
int valid_type; // validity type
int value_min; //<- set validity value range
int value_max; //->
-} MMPlayerAttrsSpec;
+} mmplayer_attrs_spec_t;
/*===========================================================================================
| |
int _mmplayer_realize(MMHandleType hplayer);
int _mmplayer_unrealize(MMHandleType hplayer);
int _mmplayer_get_state(MMHandleType hplayer, int *pstate);
-int _mmplayer_set_volume(MMHandleType hplayer, MMPlayerVolumeType volume);
-int _mmplayer_get_volume(MMHandleType hplayer, MMPlayerVolumeType *volume);
+int _mmplayer_set_volume(MMHandleType hplayer, mmplayer_volume_type_t volume);
+int _mmplayer_get_volume(MMHandleType hplayer, mmplayer_volume_type_t *volume);
int _mmplayer_set_mute(MMHandleType hplayer, int mute);
int _mmplayer_get_mute(MMHandleType hplayer, int *pmute);
int _mmplayer_start(MMHandleType hplayer);
int _mmplayer_set_position(MMHandleType hplayer, gint64 pos);
int _mmplayer_get_position(MMHandleType hplayer, gint64 *pos);
int _mmplayer_get_duration(MMHandleType hplayer, gint64 *duration);
-int _mmplayer_adjust_subtitle_postion(MMHandleType hplayer, int format, int pos);
+int _mmplayer_adjust_subtitle_postion(MMHandleType hplayer, int pos);
int _mmplayer_set_playspeed(MMHandleType hplayer, float rate, bool streaming);
int _mmplayer_set_message_callback(MMHandleType hplayer, MMMessageCallback callback, void *user_param);
int _mmplayer_set_videostream_changed_cb(MMHandleType hplayer, mm_player_stream_changed_callback callback, void *user_param);
int _mmplayer_get_subtitle_silent(MMHandleType hplayer, int *silent);
int _mmplayer_set_external_subtitle_path(MMHandleType hplayer, const char *filepath);
int _mmplayer_get_buffer_position(MMHandleType hplayer, int *start_pos, int *end_pos);
-int _mmplayer_update_video_param(mm_player_t *player, char *param_name);
+int _mmplayer_update_video_param(mmplayer_t *player, char *param_name);
int _mmplayer_change_videosink(MMHandleType handle, MMDisplaySurfaceType surface_type, void *display_overlay);
-int _mmplayer_audio_effect_custom_apply(mm_player_t *player);
+int _mmplayer_audio_effect_custom_apply(mmplayer_t *player);
int _mmplayer_set_audiostream_cb(MMHandleType hplayer, bool sync, mm_player_audio_stream_callback callback, void *user_param);
-int _mmplayer_change_track_language(MMHandleType hplayer, MMPlayerTrackType type, int index);
-int _mmplayer_sync_subtitle_pipeline(mm_player_t *player);
+int _mmplayer_change_track_language(MMHandleType hplayer, mmplayer_track_type_e type, int index);
+int _mmplayer_sync_subtitle_pipeline(mmplayer_t *player);
int _mmplayer_use_system_clock(MMHandleType hplayer);
int _mmplayer_set_uri(MMHandleType hplayer, const char *uri);
int _mmplayer_set_next_uri(MMHandleType hplayer, const char *uri, bool is_first_path);
int _mmplayer_get_timeout(MMHandleType hplayer, int *timeout);
int _mmplayer_get_num_of_video_out_buffers(MMHandleType hplayer, int *num, int *extra_num);
int _mmplayer_manage_external_storage_state(MMHandleType hplayer, int id, int state);
-int _mmplayer_video_stream_release_bo(mm_player_t *player, void *bo);
+int _mmplayer_video_stream_release_bo(mmplayer_t *player, void *bo);
int _mmplayer_get_adaptive_variant_info(MMHandleType hplayer, int *num, char **var_info);
int _mmplayer_set_max_adaptive_variant_limit(MMHandleType hplayer, int bandwidth, int width, int height);
int _mmplayer_get_max_adaptive_variant_limit(MMHandleType hplayer, int *bandwidth, int *width, int *height);
int _mmplayer_set_audio_only(MMHandleType hplayer, bool audio_only);
int _mmplayer_get_audio_only(MMHandleType hplayer, bool *paudio_only);
int _mmplayer_get_streaming_buffering_time(MMHandleType hplayer, int *prebuffer_ms, int *rebuffer_ms);
-int _mmplayer_set_codec_type(MMHandleType hplayer, MMPlayerStreamType stream_type, MMPlayerVideoCodecType codec_type);
+int _mmplayer_set_codec_type(MMHandleType hplayer, mmplayer_stream_type_e stream_type, mmplayer_video_codec_type_e codec_type);
int _mmplayer_set_replaygain_enabled(MMHandleType hplayer, bool enabled);
int _mmplayer_is_replaygain_enabled(MMHandleType hplayer, bool *enabled);
int _mmplayer_set_video_roi_area(MMHandleType hplayer, double scale_x, double scale_y, double scale_width, double scale_height);
/* internal */
void __mmplayer_bus_msg_thread_destroy(MMHandleType hplayer);
-void __mmplayer_set_state(mm_player_t *player, int state);
-int __mmplayer_check_state(mm_player_t *player, enum PlayerCommandState command);
-gboolean __mmplayer_update_content_attrs(mm_player_t *player, enum content_attr_flag flag);
-void __mmplayer_cancel_eos_timer(mm_player_t *player);
-void __mmplayer_audio_stream_clear_buffer(mm_player_t *player, gboolean send_all);
-MMStreamingType __mmplayer_get_stream_service_type(mm_player_t *player);
-int __mmplayer_get_video_angle(mm_player_t *player, int *display_angle, int *orientations);
-gboolean __mmplayer_gst_remove_fakesink(mm_player_t *player, MMPlayerGstElement *fakesink);
-void __mmplayer_add_signal_connection(mm_player_t *player, GObject *object, MMPlayerSignalType type, const gchar *signal, GCallback cb_funct, gpointer u_data);
+void __mmplayer_set_state(mmplayer_t *player, int state);
+int __mmplayer_check_state(mmplayer_t *player, mmplayer_command_state_e command);
+gboolean __mmplayer_update_content_attrs(mmplayer_t *player, enum content_attr_flag flag);
+void __mmplayer_cancel_eos_timer(mmplayer_t *player);
+void __mmplayer_audio_stream_clear_buffer(mmplayer_t *player, gboolean send_all);
+MMStreamingType __mmplayer_get_stream_service_type(mmplayer_t *player);
+int __mmplayer_get_video_angle(mmplayer_t *player, int *display_angle, int *orientations);
+gboolean __mmplayer_gst_remove_fakesink(mmplayer_t *player, mmplayer_gst_element_t *fakesink);
+void __mmplayer_add_signal_connection(mmplayer_t *player, GObject *object, mmplayer_signal_type_e type, const gchar *signal, GCallback cb_funct, gpointer u_data);
void __mmplayer_gst_decode_pad_added(GstElement *elem, GstPad *pad, gpointer data);
gint __mmplayer_gst_decode_autoplug_select(GstElement *bin, GstPad *pad, GstCaps *caps, GstElementFactory *factory, gpointer data);
-gboolean __mmplayer_gst_create_decoder(mm_player_t *player, GstPad *srcpad, const GstCaps *caps);
+gboolean __mmplayer_gst_create_decoder(mmplayer_t *player, GstPad *srcpad, const GstCaps *caps);
void __mmplayer_gst_element_added(GstElement *bin, GstElement *element, gpointer data);
-GstElement *__mmplayer_gst_make_decodebin(mm_player_t *player);
+GstElement *__mmplayer_gst_make_decodebin(mmplayer_t *player);
int __mmplayer_gst_element_add_bucket_to_bin(GstBin *bin, GList *element_bucket);
int __mmplayer_gst_element_link_bucket(GList *element_bucket);
void __mmplayer_typefind_have_type(GstElement *tf, guint probability, GstCaps *caps, gpointer data);
-int __mmplayer_parse_profile(const char *uri, void *param, MMPlayerParseProfile *data);
+int __mmplayer_parse_profile(const char *uri, void *param, mmplayer_parse_profile_t *data);
#ifdef __cplusplus
} while (0)
#define PLAYER_BUFFER_CAST(handle) ((streaming_buffer_t *)(handle))
-#define PLAYER_STREAM_CAST(sr) ((mm_player_streaming_t *)(sr))
+#define PLAYER_STREAM_CAST(sr) ((mmplayer_streaming_t *)(sr))
#define GET_CURRENT_BUFFERING_BYTE(handle) (PLAYER_BUFFER_CAST(handle)->buffering_bytes)
#define GET_CURRENT_BUFFERING_TIME(handle) (PLAYER_BUFFER_CAST(handle)->buffering_time)
BUFFER_TYPE_MUXED = BUFFER_TYPE_DEFAULT, /* queue2 */
BUFFER_TYPE_DEMUXED, /* multi Q in decodebin */
BUFFER_TYPE_MAX,
-} BufferType;
+} buffer_type_e;
typedef enum {
MUXED_BUFFER_TYPE_MEM_QUEUE, /* push mode in queue2 */
MUXED_BUFFER_TYPE_MEM_RING_BUFFER, /* pull mode in queue2 */
MUXED_BUFFER_TYPE_MAX,
-} MuxedBufferType;
+} muxed_buffer_type_e;
typedef enum {
MM_PLAYER_BUFFERING_DEFAULT = 0x00,
MM_PLAYER_BUFFERING_IN_PROGRESS = 0x01,
MM_PLAYER_BUFFERING_ABORT = 0x02,
MM_PLAYER_BUFFERING_COMPLETE = 0x04,
-} MMPlayerBufferingState;
+} mmplayer_buffering_state_e;
typedef struct {
- MMPlayerBufferingMode mode;
+ mmplayer_buffering_mode_e mode;
gboolean is_pre_buffering;
gint prebuffer_time; /* ms */
gint rebuffer_time; /* ms */
} streaming_default_t;
typedef struct {
- BufferType streaming_buffer_type;
+ buffer_type_e streaming_buffer_type;
streaming_buffer_t buffer_handle[BUFFER_TYPE_MAX]; /* front buffer : queue2 */
streaming_requirement_t buffering_req;
streaming_default_t default_val;
- MMPlayerBufferingState buffering_state;
+ mmplayer_buffering_state_e buffering_state;
gboolean is_adaptive_streaming;
gint buffering_percent;
gboolean need_update;
gboolean need_sync;
gint ring_buffer_size;
-} mm_player_streaming_t;
+} mmplayer_streaming_t;
-mm_player_streaming_t *__mm_player_streaming_create(void);
+mmplayer_streaming_t *__mm_player_streaming_create(void);
-void __mm_player_streaming_initialize(mm_player_streaming_t *streaming_player, gboolean buffer_init);
+void __mm_player_streaming_initialize(mmplayer_streaming_t *streaming_player, gboolean buffer_init);
-void __mm_player_streaming_destroy(mm_player_streaming_t *streaming_player);
+void __mm_player_streaming_destroy(mmplayer_streaming_t *streaming_player);
-void __mm_player_streaming_set_queue2(mm_player_streaming_t *streamer, GstElement *buffer,
- gboolean use_buffering, MuxedBufferType type, guint64 content_size);
+void __mm_player_streaming_set_queue2(mmplayer_streaming_t *streamer, GstElement *buffer,
+ gboolean use_buffering, muxed_buffer_type_e type, guint64 content_size);
-void __mm_player_streaming_set_multiqueue(mm_player_streaming_t *streamer, GstElement *buffer);
+void __mm_player_streaming_set_multiqueue(mmplayer_streaming_t *streamer, GstElement *buffer);
-void __mm_player_streaming_sync_property(mm_player_streaming_t *streamer, GstElement *decodebin);
+void __mm_player_streaming_sync_property(mmplayer_streaming_t *streamer, GstElement *decodebin);
-void __mm_player_streaming_buffering(mm_player_streaming_t *streamer, GstMessage *buffering_msg,
+void __mm_player_streaming_buffering(mmplayer_streaming_t *streamer, GstMessage *buffering_msg,
guint64 content_size, gint64 position, gint64 duration);
-void __mm_player_streaming_set_content_bitrate(mm_player_streaming_t *streaming_player, guint max_bitrate, guint avg_bitrate);
+void __mm_player_streaming_set_content_bitrate(mmplayer_streaming_t *streaming_player, guint max_bitrate, guint avg_bitrate);
#endif
#define DEFAULT_TRACK 0
-void __mmplayer_track_initialize(mm_player_t *player);
+void __mmplayer_track_initialize(mmplayer_t *player);
-void __mmplayer_track_destroy(mm_player_t *player);
+void __mmplayer_track_destroy(mmplayer_t *player);
-void __mmplayer_track_update_selector_info(mm_player_t *player, MMPlayerTrackType type, GstPad *sinkpad);
+void __mmplayer_track_update_selector_info(mmplayer_t *player, mmplayer_track_type_e type, GstPad *sinkpad);
-void __mmplayer_track_update_text_attr_info(mm_player_t *player, GstMessage *msg);
+void __mmplayer_track_update_text_attr_info(mmplayer_t *player, GstMessage *msg);
-int _mmplayer_get_track_count(MMHandleType hplayer, MMPlayerTrackType type, int *count);
+int _mmplayer_get_track_count(MMHandleType hplayer, mmplayer_track_type_e type, int *count);
-int _mmplayer_select_track(MMHandleType hplayer, MMPlayerTrackType type, int index);
+int _mmplayer_select_track(MMHandleType hplayer, mmplayer_track_type_e type, int index);
-int _mmplayer_get_track_language_code(MMHandleType hplayer, MMPlayerTrackType type, int index, char **code);
+int _mmplayer_get_track_language_code(MMHandleType hplayer, mmplayer_track_type_e type, int index, char **code);
-int _mmplayer_get_current_track(MMHandleType hplayer, MMPlayerTrackType type, int *index);
+int _mmplayer_get_current_track(MMHandleType hplayer, mmplayer_track_type_e type, int *index);
#ifdef __cplusplus
}
#endif
} \
} while (0)
-#define MMPLAYER_GET_ATTRS(x_player) ((mm_player_t *)x_player)->attrs
+#define MMPLAYER_GET_ATTRS(x_player) ((mmplayer_t *)x_player)->attrs
/* command */
-#define MMPLAYER_CMD_LOCK(x_player) g_mutex_lock(&((mm_player_t *)x_player)->cmd_lock)
-#define MMPLAYER_CMD_TRYLOCK(x_player) g_mutex_trylock(&((mm_player_t *)x_player)->cmd_lock)
-#define MMPLAYER_CMD_UNLOCK(x_player) g_mutex_unlock(&((mm_player_t *)x_player)->cmd_lock)
+#define MMPLAYER_CMD_LOCK(x_player) g_mutex_lock(&((mmplayer_t *)x_player)->cmd_lock)
+#define MMPLAYER_CMD_TRYLOCK(x_player) g_mutex_trylock(&((mmplayer_t *)x_player)->cmd_lock)
+#define MMPLAYER_CMD_UNLOCK(x_player) g_mutex_unlock(&((mmplayer_t *)x_player)->cmd_lock)
/* playback */
-#define MMPLAYER_PLAYBACK_LOCK(x_player) g_mutex_lock(&((mm_player_t *)x_player)->playback_lock)
-#define MMPLAYER_PLAYBACK_UNLOCK(x_player) g_mutex_unlock(&((mm_player_t *)x_player)->playback_lock)
+#define MMPLAYER_PLAYBACK_LOCK(x_player) g_mutex_lock(&((mmplayer_t *)x_player)->playback_lock)
+#define MMPLAYER_PLAYBACK_UNLOCK(x_player) g_mutex_unlock(&((mmplayer_t *)x_player)->playback_lock)
/* capture thread */
-#define MMPLAYER_CAPTURE_THREAD_LOCK(x_player) g_mutex_lock(&((mm_player_t *)x_player)->capture_thread_mutex)
-#define MMPLAYER_CAPTURE_THREAD_UNLOCK(x_player) g_mutex_unlock(&((mm_player_t *)x_player)->capture_thread_mutex)
-#define MMPLAYER_CAPTURE_THREAD_WAIT(x_player) g_cond_wait(&((mm_player_t *)x_player)->capture_thread_cond, &((mm_player_t *)x_player)->capture_thread_mutex)
-#define MMPLAYER_CAPTURE_THREAD_SIGNAL(x_player) g_cond_signal(&((mm_player_t *)x_player)->capture_thread_cond);
+#define MMPLAYER_CAPTURE_THREAD_LOCK(x_player) g_mutex_lock(&((mmplayer_t *)x_player)->capture_thread_mutex)
+#define MMPLAYER_CAPTURE_THREAD_UNLOCK(x_player) g_mutex_unlock(&((mmplayer_t *)x_player)->capture_thread_mutex)
+#define MMPLAYER_CAPTURE_THREAD_WAIT(x_player) g_cond_wait(&((mmplayer_t *)x_player)->capture_thread_cond, &((mmplayer_t *)x_player)->capture_thread_mutex)
+#define MMPLAYER_CAPTURE_THREAD_SIGNAL(x_player) g_cond_signal(&((mmplayer_t *)x_player)->capture_thread_cond);
/* gapless play thread */
-#define MMPLAYER_GAPLESS_PLAY_THREAD_LOCK(x_player) g_mutex_lock(&((mm_player_t *)x_player)->gapless_play_thread_mutex)
-#define MMPLAYER_GAPLESS_PLAY_THREAD_UNLOCK(x_player) g_mutex_unlock(&((mm_player_t *)x_player)->gapless_play_thread_mutex)
-#define MMPLAYER_GAPLESS_PLAY_THREAD_WAIT(x_player) g_cond_wait(&((mm_player_t *)x_player)->gapless_play_thread_cond, &((mm_player_t *)x_player)->gapless_play_thread_mutex)
-#define MMPLAYER_GAPLESS_PLAY_THREAD_SIGNAL(x_player) g_cond_signal(&((mm_player_t *)x_player)->gapless_play_thread_cond);
+#define MMPLAYER_GAPLESS_PLAY_THREAD_LOCK(x_player) g_mutex_lock(&((mmplayer_t *)x_player)->gapless_play_thread_mutex)
+#define MMPLAYER_GAPLESS_PLAY_THREAD_UNLOCK(x_player) g_mutex_unlock(&((mmplayer_t *)x_player)->gapless_play_thread_mutex)
+#define MMPLAYER_GAPLESS_PLAY_THREAD_WAIT(x_player) g_cond_wait(&((mmplayer_t *)x_player)->gapless_play_thread_cond, &((mmplayer_t *)x_player)->gapless_play_thread_mutex)
+#define MMPLAYER_GAPLESS_PLAY_THREAD_SIGNAL(x_player) g_cond_signal(&((mmplayer_t *)x_player)->gapless_play_thread_cond);
/* gst bus msg thread */
-#define MMPLAYER_BUS_MSG_THREAD_LOCK(x_player) g_mutex_lock(&((mm_player_t *)x_player)->bus_msg_thread_mutex)
-#define MMPLAYER_BUS_MSG_THREAD_UNLOCK(x_player) g_mutex_unlock(&((mm_player_t *)x_player)->bus_msg_thread_mutex)
-#define MMPLAYER_BUS_MSG_THREAD_WAIT(x_player) g_cond_wait(&((mm_player_t *)x_player)->bus_msg_thread_cond, &((mm_player_t *)x_player)->bus_msg_thread_mutex)
-#define MMPLAYER_BUS_MSG_THREAD_WAIT_UNTIL(x_player, end_time) g_cond_wait_until(&((mm_player_t *)x_player)->bus_msg_thread_cond, &((mm_player_t *)x_player)->bus_msg_thread_mutex, end_time)
-#define MMPLAYER_BUS_MSG_THREAD_SIGNAL(x_player) g_cond_signal(&((mm_player_t *)x_player)->bus_msg_thread_cond);
+#define MMPLAYER_BUS_MSG_THREAD_LOCK(x_player) g_mutex_lock(&((mmplayer_t *)x_player)->bus_msg_thread_mutex)
+#define MMPLAYER_BUS_MSG_THREAD_UNLOCK(x_player) g_mutex_unlock(&((mmplayer_t *)x_player)->bus_msg_thread_mutex)
+#define MMPLAYER_BUS_MSG_THREAD_WAIT(x_player) g_cond_wait(&((mmplayer_t *)x_player)->bus_msg_thread_cond, &((mmplayer_t *)x_player)->bus_msg_thread_mutex)
+#define MMPLAYER_BUS_MSG_THREAD_WAIT_UNTIL(x_player, end_time) g_cond_wait_until(&((mmplayer_t *)x_player)->bus_msg_thread_cond, &((mmplayer_t *)x_player)->bus_msg_thread_mutex, end_time)
+#define MMPLAYER_BUS_MSG_THREAD_SIGNAL(x_player) g_cond_signal(&((mmplayer_t *)x_player)->bus_msg_thread_cond);
/* handling fakesink */
-#define MMPLAYER_FSINK_LOCK(x_player) g_mutex_lock(&((mm_player_t *)x_player)->fsink_lock)
-#define MMPLAYER_FSINK_UNLOCK(x_player) g_mutex_unlock(&((mm_player_t *)x_player)->fsink_lock)
+#define MMPLAYER_FSINK_LOCK(x_player) g_mutex_lock(&((mmplayer_t *)x_player)->fsink_lock)
+#define MMPLAYER_FSINK_UNLOCK(x_player) g_mutex_unlock(&((mmplayer_t *)x_player)->fsink_lock)
/* handling update tag */
-#define MMPLAYER_UPDATE_TAG_LOCK(x_player) g_mutex_lock(&((mm_player_t *)x_player)->update_tag_lock)
-#define MMPLAYER_UPDATE_TAG_UNLOCK(x_player) g_mutex_unlock(&((mm_player_t *)x_player)->update_tag_lock)
+#define MMPLAYER_UPDATE_TAG_LOCK(x_player) g_mutex_lock(&((mmplayer_t *)x_player)->update_tag_lock)
+#define MMPLAYER_UPDATE_TAG_UNLOCK(x_player) g_mutex_unlock(&((mmplayer_t *)x_player)->update_tag_lock)
/* video stream bo */
-#define MMPLAYER_VIDEO_BO_LOCK(x_player) g_mutex_lock(&((mm_player_t *)x_player)->video_bo_mutex)
-#define MMPLAYER_VIDEO_BO_UNLOCK(x_player) g_mutex_unlock(&((mm_player_t *)x_player)->video_bo_mutex)
-#define MMPLAYER_VIDEO_BO_WAIT(x_player) g_cond_wait(&((mm_player_t *)x_player)->video_bo_cond, &((mm_player_t *)x_player)->video_bo_mutex)
-#define MMPLAYER_VIDEO_BO_WAIT_UNTIL(x_player, end_time) g_cond_wait_until(&((mm_player_t *)x_player)->video_bo_cond, &((mm_player_t *)x_player)->video_bo_mutex, end_time)
-#define MMPLAYER_VIDEO_BO_SIGNAL(x_player) g_cond_signal(&((mm_player_t *)x_player)->video_bo_cond);
+#define MMPLAYER_VIDEO_BO_LOCK(x_player) g_mutex_lock(&((mmplayer_t *)x_player)->video_bo_mutex)
+#define MMPLAYER_VIDEO_BO_UNLOCK(x_player) g_mutex_unlock(&((mmplayer_t *)x_player)->video_bo_mutex)
+#define MMPLAYER_VIDEO_BO_WAIT(x_player) g_cond_wait(&((mmplayer_t *)x_player)->video_bo_cond, &((mmplayer_t *)x_player)->video_bo_mutex)
+#define MMPLAYER_VIDEO_BO_WAIT_UNTIL(x_player, end_time) g_cond_wait_until(&((mmplayer_t *)x_player)->video_bo_cond, &((mmplayer_t *)x_player)->video_bo_mutex, end_time)
+#define MMPLAYER_VIDEO_BO_SIGNAL(x_player) g_cond_signal(&((mmplayer_t *)x_player)->video_bo_cond);
/* media stream lock */
-#define MMPLAYER_MEDIA_STREAM_CALLBACK_LOCK(x_player) g_mutex_lock(&((mm_player_t *)x_player)->media_stream_cb_lock)
-#define MMPLAYER_MEDIA_STREAM_CALLBACK_UNLOCK(x_player) g_mutex_unlock(&((mm_player_t *)x_player)->media_stream_cb_lock)
+#define MMPLAYER_MEDIA_STREAM_CALLBACK_LOCK(x_player) g_mutex_lock(&((mmplayer_t *)x_player)->media_stream_cb_lock)
+#define MMPLAYER_MEDIA_STREAM_CALLBACK_UNLOCK(x_player) g_mutex_unlock(&((mmplayer_t *)x_player)->media_stream_cb_lock)
/* subtitle info */
-#define MMPLAYER_SUBTITLE_INFO_LOCK(x_player) g_mutex_lock(&((mm_player_t *)x_player)->subtitle_info_mutex)
-#define MMPLAYER_SUBTITLE_INFO_UNLOCK(x_player) g_mutex_unlock(&((mm_player_t *)x_player)->subtitle_info_mutex)
-#define MMPLAYER_SUBTITLE_INFO_WAIT(x_player) g_cond_wait(&((mm_player_t *)x_player)->subtitle_info_cond, &((mm_player_t *)x_player)->subtitle_info_mutex)
-#define MMPLAYER_SUBTITLE_INFO_WAIT_UNTIL(x_player, end_time) g_cond_wait_until(&((mm_player_t *)x_player)->subtitle_info_cond, &((mm_player_t *)x_player)->subtitle_info_mutex, end_time)
-#define MMPLAYER_SUBTITLE_INFO_SIGNAL(x_player) g_cond_signal(&((mm_player_t *)x_player)->subtitle_info_cond);
+#define MMPLAYER_SUBTITLE_INFO_LOCK(x_player) g_mutex_lock(&((mmplayer_t *)x_player)->subtitle_info_mutex)
+#define MMPLAYER_SUBTITLE_INFO_UNLOCK(x_player) g_mutex_unlock(&((mmplayer_t *)x_player)->subtitle_info_mutex)
+#define MMPLAYER_SUBTITLE_INFO_WAIT(x_player) g_cond_wait(&((mmplayer_t *)x_player)->subtitle_info_cond, &((mmplayer_t *)x_player)->subtitle_info_mutex)
+#define MMPLAYER_SUBTITLE_INFO_WAIT_UNTIL(x_player, end_time) g_cond_wait_until(&((mmplayer_t *)x_player)->subtitle_info_cond, &((mmplayer_t *)x_player)->subtitle_info_mutex, end_time)
+#define MMPLAYER_SUBTITLE_INFO_SIGNAL(x_player) g_cond_signal(&((mmplayer_t *)x_player)->subtitle_info_cond);
#if 0
#define MMPLAYER_FENTER(); LOGD("<ENTER>");
/* signal manipulation */
#define MMPLAYER_SIGNAL_CONNECT(x_player, x_object, x_type, x_signal, x_callback, x_arg) \
do { \
- MMPlayerSignalItem *item = NULL; \
- item = (MMPlayerSignalItem *)g_malloc(sizeof(MMPlayerSignalItem)); \
+ mmplayer_signal_item_t *item = NULL; \
+ item = (mmplayer_signal_item_t *)g_malloc(sizeof(mmplayer_signal_item_t)); \
if (!item) { \
LOGE("cannot connect signal [%s]", x_signal); \
} else { \
} while (0)
/* state */
-#define MMPLAYER_PREV_STATE(x_player) ((mm_player_t *)x_player)->prev_state
-#define MMPLAYER_CURRENT_STATE(x_player) ((mm_player_t *)x_player)->state
-#define MMPLAYER_PENDING_STATE(x_player) ((mm_player_t *)x_player)->pending_state
-#define MMPLAYER_TARGET_STATE(x_player) ((mm_player_t *)x_player)->target_state
+#define MMPLAYER_PREV_STATE(x_player) ((mmplayer_t *)x_player)->prev_state
+#define MMPLAYER_CURRENT_STATE(x_player) ((mmplayer_t *)x_player)->state
+#define MMPLAYER_PENDING_STATE(x_player) ((mmplayer_t *)x_player)->pending_state
+#define MMPLAYER_TARGET_STATE(x_player) ((mmplayer_t *)x_player)->target_state
#define MMPLAYER_STATE_GET_NAME(state) __get_state_name(state)
#define MMPLAYER_PRINT_STATE(x_player) \
MMPLAYER_STATE_GET_NAME(MMPLAYER_TARGET_STATE(x_player))); \
} while (0)
-#define MMPLAYER_STATE_CHANGE_TIMEOUT(x_player) ((mm_player_t *)x_player)->state_change_timeout
+#define MMPLAYER_STATE_CHANGE_TIMEOUT(x_player) ((mmplayer_t *)x_player)->state_change_timeout
/* streaming */
#define MMPLAYER_IS_STREAMING(x_player) __is_streaming(x_player)
const gchar *__get_state_name(int state);
const gchar *__get_stream_type_name(int type);
-gboolean __is_streaming(mm_player_t *player);
-gboolean __is_rtsp_streaming(mm_player_t *player);
-gboolean __is_live_streaming(mm_player_t *player);
-gboolean __is_http_streaming(mm_player_t *player);
-gboolean __is_http_live_streaming(mm_player_t *player);
-gboolean __is_dash_streaming(mm_player_t *player);
-gboolean __is_smooth_streaming(mm_player_t *player);
-gboolean __is_ms_buff_src(mm_player_t *player);
-gboolean __has_suffix(mm_player_t *player, const gchar *suffix);
+gboolean __is_streaming(mmplayer_t *player);
+gboolean __is_rtsp_streaming(mmplayer_t *player);
+gboolean __is_live_streaming(mmplayer_t *player);
+gboolean __is_http_streaming(mmplayer_t *player);
+gboolean __is_http_live_streaming(mmplayer_t *player);
+gboolean __is_dash_streaming(mmplayer_t *player);
+gboolean __is_smooth_streaming(mmplayer_t *player);
+gboolean __is_ms_buff_src(mmplayer_t *player);
+gboolean __has_suffix(mmplayer_t *player, const gchar *suffix);
-gboolean __mmplayer_post_message(mm_player_t *player, enum MMMessageType msgtype, MMMessageParamType *param);
-gboolean __mmplayer_dump_pipeline_state(mm_player_t *player);
+gboolean __mmplayer_post_message(mmplayer_t *player, enum MMMessageType msgtype, MMMessageParamType *param);
+gboolean __mmplayer_dump_pipeline_state(mmplayer_t *player);
bool util_is_sdp_file(const char *path);
int util_exist_file_path(const char *file_path);
char **util_get_cookie_list(const char *cookies);
const char *util_get_charset(const char *file_path);
int util_get_pixtype(unsigned int fourcc);
-bool util_get_storage_info(const char *path, MMPlayerStorageInfo *storage_info);
+bool util_get_storage_info(const char *path, mmplayer_storage_info_t *storage_info);
#ifdef __cplusplus
}
int mm_player_create(MMHandleType *player)
{
int result = MM_ERROR_PLAYER_INTERNAL;
- mm_player_t *new_player = NULL;
+ mmplayer_t *new_player = NULL;
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
/* alloc player structure */
- new_player = g_try_new0(mm_player_t, 1);
+ new_player = g_try_new0(mmplayer_t, 1);
if (!new_player) {
LOGE("Cannot allocate memory for player\n");
result = MM_ERROR_PLAYER_RESOURCE_LIMIT;
MMPLAYER_CMD_UNLOCK(player);
- g_mutex_clear(&((mm_player_t *)player)->cmd_lock);
- g_mutex_clear(&((mm_player_t *)player)->playback_lock);
+ g_mutex_clear(&((mmplayer_t *)player)->cmd_lock);
+ g_mutex_clear(&((mmplayer_t *)player)->playback_lock);
- memset((mm_player_t *)player, 0x00, sizeof(mm_player_t));
+ memset((mmplayer_t *)player, 0x00, sizeof(mmplayer_t));
/* free player */
g_free((void *)player);
return result;
}
-int mm_player_set_volume(MMHandleType player, MMPlayerVolumeType *volume)
+int mm_player_set_volume(MMHandleType player, mmplayer_volume_type_t *volume)
{
int result = MM_ERROR_NONE;
return result;
}
-int mm_player_get_volume(MMHandleType player, MMPlayerVolumeType *volume)
+int mm_player_get_volume(MMHandleType player, mmplayer_volume_type_t *volume)
{
int result = MM_ERROR_NONE;
return result;
}
-int mm_player_get_state(MMHandleType player, MMPlayerStateType *state)
+int mm_player_get_state(MMHandleType player, mmplayer_state_e *state)
{
int result = MM_ERROR_NONE;
return result;
}
-int mm_player_adjust_subtitle_position(MMHandleType player, MMPlayerPosFormatType format, int pos)
+int mm_player_adjust_subtitle_position(MMHandleType player, int pos)
{
int result = MM_ERROR_NONE;
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
- if (format >= MM_PLAYER_POS_FORMAT_NUM) {
- LOGE("wrong format(%d)", format);
- return MM_ERROR_INVALID_ARGUMENT;
- }
-
MMPLAYER_CMD_LOCK(player);
- result = _mmplayer_adjust_subtitle_postion(player, format, pos);
+ result = _mmplayer_adjust_subtitle_postion(player, pos);
MMPLAYER_CMD_UNLOCK(player);
return result;
}
-int mm_player_get_attribute_info(MMHandleType player, const char *attribute_name, MMPlayerAttrsInfo *info)
+int mm_player_get_attribute_info(MMHandleType player, const char *attribute_name, mmplayer_attrs_info_t *info)
{
int result = MM_ERROR_NONE;
return result;
}
-int mm_player_get_track_count(MMHandleType player, MMPlayerTrackType type, int *count)
+int mm_player_get_track_count(MMHandleType player, mmplayer_track_type_e type, int *count)
{
int result = MM_ERROR_NONE;
return result;
}
-int mm_player_select_track(MMHandleType player, MMPlayerTrackType type, int index)
+int mm_player_select_track(MMHandleType player, mmplayer_track_type_e type, int index)
{
int result = MM_ERROR_NONE;
return result;
}
-int mm_player_get_current_track(MMHandleType player, MMPlayerTrackType type, int *index)
+int mm_player_get_current_track(MMHandleType player, mmplayer_track_type_e type, int *index)
{
int result = MM_ERROR_NONE;
return result;
}
-int mm_player_get_track_language_code(MMHandleType player, MMPlayerTrackType type, int index, char **code)
+int mm_player_get_track_language_code(MMHandleType player, mmplayer_track_type_e type, int index, char **code)
{
int result = MM_ERROR_NONE;
return result;
}
-int mm_player_set_subtitle_info(MMHandleType player, MMPlayerSubtitleStreamInfo *subtitle_stream_info)
+int mm_player_set_subtitle_info(MMHandleType player, mmplayer_subtitle_stream_info_t *subtitle_stream_info)
{
int result = MM_ERROR_NONE;
return result;
}
-int mm_player_set_media_stream_buffer_max_size(MMHandleType player, MMPlayerStreamType type, unsigned long long max_size)
+int mm_player_set_media_stream_buffer_max_size(MMHandleType player, mmplayer_stream_type_e type, unsigned long long max_size)
{
int result = MM_ERROR_NONE;
return result;
}
-int mm_player_get_media_stream_buffer_max_size(MMHandleType player, MMPlayerStreamType type, unsigned long long *max_size)
+int mm_player_get_media_stream_buffer_max_size(MMHandleType player, mmplayer_stream_type_e type, unsigned long long *max_size)
{
int result = MM_ERROR_NONE;
guint64 _max_size = 0;
return result;
}
-int mm_player_set_media_stream_buffer_min_percent(MMHandleType player, MMPlayerStreamType type, unsigned min_percent)
+int mm_player_set_media_stream_buffer_min_percent(MMHandleType player, mmplayer_stream_type_e type, unsigned min_percent)
{
int result = MM_ERROR_NONE;
return result;
}
-int mm_player_get_media_stream_buffer_min_percent(MMHandleType player, MMPlayerStreamType type, unsigned int *min_percent)
+int mm_player_get_media_stream_buffer_min_percent(MMHandleType player, mmplayer_stream_type_e type, unsigned int *min_percent)
{
int result = MM_ERROR_NONE;
return result;
}
-int mm_player_set_media_stream_buffer_status_callback(MMHandleType player, MMPlayerStreamType type, mm_player_media_stream_buffer_status_callback callback, void *user_param)
+int mm_player_set_media_stream_buffer_status_callback(MMHandleType player, mmplayer_stream_type_e type, mm_player_media_stream_buffer_status_callback callback, void *user_param)
{
int result = MM_ERROR_NONE;
return result;
}
-int mm_player_set_media_stream_seek_data_callback(MMHandleType player, MMPlayerStreamType type, mm_player_media_stream_seek_data_callback callback, void *user_param)
+int mm_player_set_media_stream_seek_data_callback(MMHandleType player, mmplayer_stream_type_e type, mm_player_media_stream_seek_data_callback callback, void *user_param)
{
int result = MM_ERROR_NONE;
return result;
}
-int mm_player_set_codec_type(MMHandleType player, MMPlayerStreamType stream_type, MMPlayerVideoCodecType codec_type)
+int mm_player_set_codec_type(MMHandleType player, mmplayer_stream_type_e stream_type, mmplayer_video_codec_type_e codec_type)
{
int result = MM_ERROR_NONE;
#include <glib.h>
static bool
-__mmplayer_check_video_360_used(mm_player_t *player)
+__mmplayer_check_video_360_used(mmplayer_t *player)
{
/* check video 360 plugin is created */
MMPLAYER_RETURN_VAL_IF_FAIL(player &&
}
static bool
-__mmplayer_check_audio_sink(mm_player_t *player)
+__mmplayer_check_audio_sink(mmplayer_t *player)
{
/* check audio sink is created */
MMPLAYER_RETURN_VAL_IF_FAIL(player &&
int
_mmplayer_360_is_content_spherical(MMHandleType hplayer, bool *is_spherical)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player && player->pipeline, MM_ERROR_PLAYER_NOT_INITIALIZED);
int
_mmplayer_360_set_enabled(MMHandleType hplayer, bool enabled)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
int
_mmplayer_360_is_enabled(MMHandleType hplayer, bool *enabled)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
gboolean is_enabled;
MMPLAYER_FENTER();
int
_mmplayer_360_set_direction_of_view(MMHandleType hplayer, float yaw, float pitch)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
int
_mmplayer_360_get_direction_of_view(MMHandleType hplayer, float *yaw, float *pitch)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
int yaw_degrees = 0;
int pitch_degrees = 0;
int
_mmplayer_360_set_zoom(MMHandleType hplayer, float level)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
int
_mmplayer_360_get_zoom(MMHandleType hplayer, float *level)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
float current_zoom = 0.0;
MMPLAYER_FENTER();
int
_mmplayer_360_set_field_of_view(MMHandleType hplayer, int horizontal_degrees, int vertical_degrees)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
int
_mmplayer_360_get_field_of_view(MMHandleType hplayer, int *horizontal_degrees, int *vertical_degrees)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
}
int
-_mmplayer_get_attributes_info(MMHandleType handle, const char *attribute_name, MMPlayerAttrsInfo *dst_info)
+_mmplayer_get_attributes_info(MMHandleType handle, const char *attribute_name, mmplayer_attrs_info_t *dst_info)
{
int result = MM_ERROR_NONE;
MMHandleType attrs = 0;
return result;
}
- memset(dst_info, 0x00, sizeof(MMPlayerAttrsInfo));
+ memset(dst_info, 0x00, sizeof(mmplayer_attrs_info_t));
dst_info->type = src_info.type;
dst_info->flag = src_info.flag;
int
__mmplayer_apply_attribute(MMHandleType handle, const char *attribute_name)
{
- mm_player_t *player = 0;
+ mmplayer_t *player = 0;
MMPLAYER_RETURN_VAL_IF_FAIL(handle, MM_ERROR_COMMON_INVALID_ARGUMENT);
MMPLAYER_RETURN_VAL_IF_FAIL(attribute_name, MM_ERROR_COMMON_INVALID_ARGUMENT);
player = MM_PLAYER_CAST(handle);
- MMPlayerGstPipelineInfo *pipeline = player->pipeline;
+ mmplayer_pipeline_info_t *pipeline = player->pipeline;
/* before preparing, just keep the attr value */
MMPLAYER_RETURN_VAL_IF_FAIL(pipeline && pipeline->mainbin, MM_ERROR_NONE);
MMPLAYER_RETURN_VAL_IF_FAIL(handle, 0);
- MMPlayerAttrsSpec player_attrs[] = {
+ mmplayer_attrs_spec_t player_attrs[] = {
{
"profile_uri", // name
MM_ATTRS_TYPE_STRING, // type
bool
_mmplayer_deconstruct_attribute(MMHandleType handle) // @
{
- mm_player_t *player = MM_PLAYER_CAST(handle);
+ mmplayer_t *player = MM_PLAYER_CAST(handle);
MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
int
-mm_player_get_foreach_present_supported_effect_type(MMHandleType hplayer, MMAudioEffectType effect_type, mmplayer_supported_audio_effect_cb foreach_cb, void *user_data)
+mm_player_get_foreach_present_supported_effect_type(MMHandleType hplayer, mm_audio_effect_type_e effect_type, mmplayer_supported_audio_effect_cb foreach_cb, void *user_data)
{
- mm_player_t *player = NULL;
+ mmplayer_t *player = NULL;
int result = MM_ERROR_NONE;
mm_sound_device_flags_e flags = MM_SOUND_DEVICE_IO_DIRECTION_OUT_FLAG | MM_SOUND_DEVICE_STATE_ACTIVATED_FLAG;
MMSoundDeviceList_t device_list = NULL;
int
-__mmplayer_set_harmony_effect(mm_player_t *player, GstElement *audio_effect_element)
+__mmplayer_set_harmony_effect(mmplayer_t *player, GstElement *audio_effect_element)
{
gint *ext_effect_level_list = NULL;
int count = 1; /* start from 1, because of excepting eq index */
gboolean
-__mmplayer_is_earphone_only_effect_type(mm_player_t *player, MMAudioEffectType effect_type, int effect)
+__mmplayer_is_earphone_only_effect_type(mmplayer_t *player, mm_audio_effect_type_e effect_type, int effect)
{
gboolean result = FALSE;
int i = 0;
}
int
-__mmplayer_audio_set_output_type(mm_player_t *player, MMAudioEffectType effect_type, int effect)
+__mmplayer_audio_set_output_type(mmplayer_t *player, mm_audio_effect_type_e effect_type, int effect)
{
GstElement *audio_effect_element = NULL;
mm_sound_device_flags_e flags = MM_SOUND_DEVICE_ALL_FLAG;
}
gboolean
-_mmplayer_is_supported_effect_type(mm_player_t *player, MMAudioEffectType effect_type, int effect)
+_mmplayer_is_supported_effect_type(mmplayer_t *player, mm_audio_effect_type_e effect_type, int effect)
{
gboolean result = TRUE;
mm_sound_device_flags_e flags = MM_SOUND_DEVICE_ALL_FLAG;
}
int
-_mmplayer_audio_effect_custom_apply(mm_player_t *player)
+_mmplayer_audio_effect_custom_apply(mmplayer_t *player)
{
GstElement *audio_effect_element = NULL;
int result = MM_ERROR_NONE;
}
int
-_mmplayer_audio_effect_custom_update_level(mm_player_t *player)
+_mmplayer_audio_effect_custom_update_level(mmplayer_t *player)
{
GstElement *audio_effect_element = NULL;
int result = MM_ERROR_NONE;
mm_player_audio_effect_custom_clear_eq_all(MMHandleType hplayer)
{
int result = MM_ERROR_NONE;
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
MMPLAYER_FENTER();
{
int i;
int result = MM_ERROR_NONE;
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
MMPLAYER_FENTER();
int
-mm_player_is_supported_preset_effect_type(MMHandleType hplayer, MMAudioEffectPresetType effect)
+mm_player_is_supported_preset_effect_type(MMHandleType hplayer, mm_audio_effect_preset_type_e effect)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
int result = MM_ERROR_NONE;
MMPLAYER_FENTER();
int
-mm_player_is_supported_custom_effect_type(MMHandleType hplayer, MMAudioEffectCustomType effect)
+mm_player_is_supported_custom_effect_type(MMHandleType hplayer, mm_audio_effect_custom_type_e effect)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
int result = MM_ERROR_NONE;
MMPLAYER_FENTER();
int
mm_player_audio_effect_custom_apply(MMHandleType hplayer)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
int result = MM_ERROR_NONE;
MMPLAYER_FENTER();
int
mm_player_audio_effect_bypass(MMHandleType hplayer)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
int result = MM_ERROR_NONE;
GstElement *audio_effect_element = NULL;
int
-_mmplayer_audio_effect_custom_set_level_ext(mm_player_t *player, MMAudioEffectCustomType custom_effect_type, int level)
+_mmplayer_audio_effect_custom_set_level_ext(mmplayer_t *player, mm_audio_effect_custom_type_e custom_effect_type, int level)
{
int effect_level_max = 0;
int effect_level_min = 0;
int
-_mmplayer_audio_effect_custom_set_level_eq(mm_player_t *player, int index, int level)
+_mmplayer_audio_effect_custom_set_level_eq(mmplayer_t *player, int index, int level)
{
gint eq_level_max = 0;
gint eq_level_min = 0;
/* NOTE : parameter eq_index is only used for _set_eq_level() */
int
-mm_player_audio_effect_custom_set_level(MMHandleType hplayer, MMAudioEffectCustomType effect_custom_type, int eq_index, int level)
+mm_player_audio_effect_custom_set_level(MMHandleType hplayer, mm_audio_effect_custom_type_e effect_custom_type, int eq_index, int level)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
int result = MM_ERROR_NONE;
MMPLAYER_FENTER();
int
mm_player_audio_effect_custom_get_eq_bands_number(MMHandleType hplayer, int *bands)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
int result = MM_ERROR_NONE;
MMPLAYER_FENTER();
int
mm_player_audio_effect_custom_get_eq_bands_width(MMHandleType hplayer, int band_idx, int *width)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
int result = MM_ERROR_NONE;
unsigned int eq_num = 0;
int
mm_player_audio_effect_custom_get_eq_bands_freq(MMHandleType hplayer, int band_idx, int *freq)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
int result = MM_ERROR_NONE;
unsigned int eq_num = 0;
int
-mm_player_audio_effect_custom_get_level(MMHandleType hplayer, MMAudioEffectCustomType type, int eq_index, int *level)
+mm_player_audio_effect_custom_get_level(MMHandleType hplayer, mm_audio_effect_custom_type_e type, int eq_index, int *level)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
int result = MM_ERROR_NONE;
MMPLAYER_FENTER();
int
-mm_player_audio_effect_custom_get_level_range(MMHandleType hplayer, MMAudioEffectCustomType type, int *min, int *max)
+mm_player_audio_effect_custom_get_level_range(MMHandleType hplayer, mm_audio_effect_custom_type_e type, int *min, int *max)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
int result = MM_ERROR_NONE;
int count = 1; /* start from 1, because of excepting eq index */
int ext_level_index = 1; /* start from 1, because of excepting eq index */
int
mm_player_audio_effect_custom_set_level_eq_from_list(MMHandleType hplayer, int *level_list, int size)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
gint i = 0;
gint eq_level_min = 0;
gint eq_level_max = 0;
| LOCAL FUNCTION PROTOTYPES: |
---------------------------------------------------------------------------*/
static GstPadProbeReturn __mmplayer_video_capture_probe(GstPad *pad, GstPadProbeInfo *info, gpointer u_data);
-static int __mmplayer_get_video_frame_from_buffer(mm_player_t *player, GstPad *pad, GstBuffer *buffer);
+static int __mmplayer_get_video_frame_from_buffer(mmplayer_t *player, GstPad *pad, GstBuffer *buffer);
static gpointer __mmplayer_capture_thread(gpointer data);
static void __csc_tiled_to_linear_crop(unsigned char *yuv420_dest, unsigned char *nv12t_src, int yuv420_width, int yuv420_height, int left, int top, int right, int buttom);
static int __tile_4x2_read(int x_size, int y_size, int x_pos, int y_pos);
-static int __mm_player_convert_colorspace(mm_player_t *player, unsigned char *src_data, size_t src_size, mm_util_color_format_e src_fmt, unsigned int src_w, unsigned int src_h, mm_util_color_format_e dst_fmt);
-static int __mm_player_convert_NV12_tiled(mm_player_t *player);
-static int __mm_player_convert_NV12(mm_player_t *player);
-static int __mm_player_convert_I420(mm_player_t *player);
-static int __mm_player_convert_BGRx(mm_player_t *player);
+static int __mm_player_convert_colorspace(mmplayer_t *player, unsigned char *src_data, size_t src_size, mm_util_color_format_e src_fmt, unsigned int src_w, unsigned int src_h, mm_util_color_format_e dst_fmt);
+static int __mm_player_convert_NV12_tiled(mmplayer_t *player);
+static int __mm_player_convert_NV12(mmplayer_t *player);
+static int __mm_player_convert_I420(mmplayer_t *player);
+static int __mm_player_convert_BGRx(mmplayer_t *player);
#ifdef CAPTURE_OUTPUT_DUMP
-static void capture_output_dump(mm_player_t *player);
+static void capture_output_dump(mmplayer_t *player);
#endif
/*===========================================================================================
| |
========================================================================================== */
int
-_mmplayer_initialize_video_capture(mm_player_t *player)
+_mmplayer_initialize_video_capture(mmplayer_t *player)
{
int ret = MM_ERROR_NONE;
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
}
int
-_mmplayer_release_video_capture(mm_player_t *player)
+_mmplayer_release_video_capture(mmplayer_t *player)
{
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
/* release capture thread */
int
_mmplayer_do_video_capture(MMHandleType hplayer)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
int ret = MM_ERROR_NONE;
GstPad *pad = NULL;
}
int
-__mmplayer_handle_orientation(mm_player_t *player, int orientation, int format)
+__mmplayer_handle_orientation(mmplayer_t *player, int orientation, int format)
{
unsigned char *src_buffer = NULL;
int ret = MM_ERROR_NONE;
static gpointer
__mmplayer_capture_thread(gpointer data)
{
- mm_player_t *player = (mm_player_t *)data;
+ mmplayer_t *player = (mmplayer_t *)data;
MMMessageParamType msg = {0, };
int orientation = 0;
int display_angle = 0;
* The output is fixed as RGB888
*/
static int
-__mmplayer_get_video_frame_from_buffer(mm_player_t *player, GstPad *pad, GstBuffer *buffer)
+__mmplayer_get_video_frame_from_buffer(mmplayer_t *player, GstPad *pad, GstBuffer *buffer)
{
gint i = 0;
guint plane_size = 0;
MMPLAYER_LOG_GST_CAPS_TYPE(caps);
/* init capture image buffer */
- memset(&player->capture, 0x00, sizeof(MMPlayerVideoCapture));
+ memset(&player->capture, 0x00, sizeof(mmplayer_video_capture_t));
gst_video_info_from_caps(&vinfo, caps);
static GstPadProbeReturn
__mmplayer_video_capture_probe(GstPad *pad, GstPadProbeInfo *info, gpointer u_data)
{
- mm_player_t *player = (mm_player_t *)u_data;
+ mmplayer_t *player = (mmplayer_t *)u_data;
GstBuffer *buffer = NULL;
int ret = MM_ERROR_NONE;
}
static int
-__mm_player_convert_colorspace(mm_player_t *player, unsigned char *src_data, size_t src_size, mm_util_color_format_e src_fmt, unsigned int src_w, unsigned int src_h, mm_util_color_format_e dst_fmt)
+__mm_player_convert_colorspace(mmplayer_t *player, unsigned char *src_data, size_t src_size, mm_util_color_format_e src_fmt, unsigned int src_w, unsigned int src_h, mm_util_color_format_e dst_fmt)
{
int ret = MM_ERROR_NONE;
mm_util_image_h src_image = NULL;
#ifdef CAPTURE_OUTPUT_DUMP /* for capture output dump */
static void
-capture_output_dump(mm_player_t *player)
+capture_output_dump(mmplayer_t *player)
{
unsigned char *temp = NULL;
char file[100] = { 0, };
#endif
static int
-__mm_player_convert_NV12_tiled(mm_player_t *player)
+__mm_player_convert_NV12_tiled(mmplayer_t *player)
{
/* Colorspace conversion : NV12T-> NV12-> RGB888 */
int i;
}
static int
-__mm_player_convert_NV12(mm_player_t *player)
+__mm_player_convert_NV12(mmplayer_t *player)
{
unsigned char *src_buffer = NULL;
unsigned char *p_buf = NULL;
}
static int
-__mm_player_convert_I420(mm_player_t *player)
+__mm_player_convert_I420(mmplayer_t *player)
{
unsigned char *src_buffer = NULL;
unsigned char *p_buf = NULL;
}
static int
-__mm_player_convert_BGRx(mm_player_t *player)
+__mm_player_convert_BGRx(mmplayer_t *player)
{
int i;
guint size;
/*---------------------------------------------------------------------------
| LOCAL FUNCTION PROTOTYPES: |
---------------------------------------------------------------------------*/
-static int __parse_media_format(MMPlayerVideoStreamInfo *video, MMPlayerAudioStreamInfo *audio, media_format_h format);
-static int __convert_media_format_video_mime_to_str(MMPlayerVideoStreamInfo *video, media_format_mimetype_e mime);
-static int __convert_media_format_audio_mime_to_str(MMPlayerAudioStreamInfo *audio, media_format_mimetype_e mime);
-static gboolean __mm_player_is_codec_data_changed(mm_player_t *player, media_packet_h packet, MMPlayerStreamType streamtype);
+static int __parse_media_format(mmplayer_video_stream_info_t *video, mmplayer_audio_stream_info_t *audio, media_format_h format);
+static int __convert_media_format_video_mime_to_str(mmplayer_video_stream_info_t *video, media_format_mimetype_e mime);
+static int __convert_media_format_audio_mime_to_str(mmplayer_audio_stream_info_t *audio, media_format_mimetype_e mime);
+static gboolean __mm_player_is_codec_data_changed(mmplayer_t *player, media_packet_h packet, mmplayer_stream_type_e streamtype);
/*===========================================================================================
| |
========================================================================================== */
static int
-__convert_media_format_video_mime_to_str(MMPlayerVideoStreamInfo *video,
+__convert_media_format_video_mime_to_str(mmplayer_video_stream_info_t *video,
media_format_mimetype_e mime)
{
MMPLAYER_RETURN_VAL_IF_FAIL(video, MM_ERROR_INVALID_ARGUMENT);
}
static int
-__convert_media_format_audio_mime_to_str(MMPlayerAudioStreamInfo *audio,
+__convert_media_format_audio_mime_to_str(mmplayer_audio_stream_info_t *audio,
media_format_mimetype_e mime)
{
MMPLAYER_RETURN_VAL_IF_FAIL(audio, MM_ERROR_INVALID_ARGUMENT);
}
static int
-__parse_media_format(MMPlayerVideoStreamInfo *video,
- MMPlayerAudioStreamInfo *audio, media_format_h format)
+__parse_media_format(mmplayer_video_stream_info_t *video,
+ mmplayer_audio_stream_info_t *audio, media_format_h format)
{
if (audio) {
media_format_mimetype_e mime;
static gboolean
__mmplayer_update_video_info(MMHandleType hplayer, media_format_h fmt)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
gboolean ret = FALSE;
GstStructure *str = NULL;
media_format_mimetype_e mimetype = 0;
int
_mmplayer_set_media_stream_buffer_status_cb(MMHandleType hplayer,
- MMPlayerStreamType type,
+ mmplayer_stream_type_e type,
mm_player_media_stream_buffer_status_callback callback,
void *user_param)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
MMPLAYER_FENTER();
int
_mmplayer_set_media_stream_seek_data_cb(MMHandleType hplayer,
- MMPlayerStreamType type,
+ mmplayer_stream_type_e type,
mm_player_media_stream_seek_data_callback callback,
void *user_param)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
MMPLAYER_FENTER();
}
static GstElement *
-__mmplayer_get_source_element(mm_player_t *player, MMPlayerStreamType type)
+__mmplayer_get_source_element(mmplayer_t *player, mmplayer_stream_type_e type)
{
- enum MainElementID elemId = MMPLAYER_M_NUM;
+ main_element_id_e elemId = MMPLAYER_M_NUM;
if (player && player->pipeline && player->pipeline->mainbin) {
/* get elem according to the stream type */
}
int
-_mmplayer_set_media_stream_max_size(MMHandleType hplayer, MMPlayerStreamType type, guint64 max_size)
+_mmplayer_set_media_stream_max_size(MMHandleType hplayer, mmplayer_stream_type_e type, guint64 max_size)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
GstElement *element = NULL;
MMPLAYER_FENTER();
}
int
-_mmplayer_get_media_stream_max_size(MMHandleType hplayer, MMPlayerStreamType type, guint64 *max_size)
+_mmplayer_get_media_stream_max_size(MMHandleType hplayer, mmplayer_stream_type_e type, guint64 *max_size)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
MMPLAYER_FENTER();
}
int
-_mmplayer_set_media_stream_min_percent(MMHandleType hplayer, MMPlayerStreamType type, guint min_percent)
+_mmplayer_set_media_stream_min_percent(MMHandleType hplayer, mmplayer_stream_type_e type, guint min_percent)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
GstElement *element = NULL;
MMPLAYER_FENTER();
}
int
-_mmplayer_get_media_stream_min_percent(MMHandleType hplayer, MMPlayerStreamType type, guint *min_percent)
+_mmplayer_get_media_stream_min_percent(MMHandleType hplayer, mmplayer_stream_type_e type, guint *min_percent)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
MMPLAYER_FENTER();
}
static int
-__mmplayer_check_buffer_level(mm_player_t *player, GstElement *element, MMPlayerStreamType type)
+__mmplayer_check_buffer_level(mmplayer_t *player, GstElement *element, mmplayer_stream_type_e type)
{
guint64 current_level_bytes = 0;
guint64 max_bytes = 0;
{
int ret = MM_ERROR_NONE;
GstBuffer *_buffer = NULL;
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
guint8 *buf = NULL;
uint64_t size = 0;
GstElement *element = NULL;
- MMPlayerStreamType streamtype = MM_PLAYER_STREAM_TYPE_AUDIO;
+ mmplayer_stream_type_e streamtype = MM_PLAYER_STREAM_TYPE_AUDIO;
media_format_h fmt = NULL;
bool flag = false;
bool is_eos = false;
}
static int
-__mmplayer_video_caps_new(MMHandleType hplayer, MMPlayerVideoStreamInfo *video,
+__mmplayer_video_caps_new(MMHandleType hplayer, mmplayer_video_stream_info_t *video,
const char *fieldname, ...)
{
int cap_size;
GstCaps *caps = NULL;
GstStructure *structure = NULL;
va_list var_args;
- mm_player_t *player = MM_PLAYER_CAST(hplayer);
+ mmplayer_t *player = MM_PLAYER_CAST(hplayer);
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
}
static void
-__mmplayer_set_uri_type(mm_player_t *player)
+__mmplayer_set_uri_type(mmplayer_t *player)
{
MMPLAYER_FENTER();
int
_mmplayer_set_video_info(MMHandleType hplayer, media_format_h format)
{
- mm_player_t *player = MM_PLAYER_CAST(hplayer);
- MMPlayerVideoStreamInfo video = { 0, };
+ mmplayer_t *player = MM_PLAYER_CAST(hplayer);
+ mmplayer_video_stream_info_t video = { 0, };
int ret = MM_ERROR_NONE;
gboolean drc = FALSE;
int
_mmplayer_set_audio_info(MMHandleType hplayer, media_format_h format)
{
- mm_player_t *player = MM_PLAYER_CAST(hplayer);
+ mmplayer_t *player = MM_PLAYER_CAST(hplayer);
GstCaps *caps = NULL;
- MMPlayerAudioStreamInfo audio = { 0, };
+ mmplayer_audio_stream_info_t audio = { 0, };
int ret = MM_ERROR_NONE;
MMPLAYER_FENTER();
int
_mmplayer_set_subtitle_info(MMHandleType hplayer,
- MMPlayerSubtitleStreamInfo *subtitle)
+ mmplayer_subtitle_stream_info_t *subtitle)
{
#if 0 //todo
- mm_player_t *player = MM_PLAYER_CAST(hplayer);
+ mmplayer_t *player = MM_PLAYER_CAST(hplayer);
GstCaps *caps = NULL;
MMPLAYER_FENTER();
int
_mmplayer_set_media_stream_dynamic_resolution(MMHandleType hplayer, bool drc)
{
- mm_player_t *player = MM_PLAYER_CAST(hplayer);
+ mmplayer_t *player = MM_PLAYER_CAST(hplayer);
int ret = MM_ERROR_NONE;
MMPLAYER_FENTER();
}
static gboolean
-__mm_player_is_codec_data_changed(mm_player_t *player, media_packet_h packet,
- MMPlayerStreamType streamtype)
+__mm_player_is_codec_data_changed(mmplayer_t *player, media_packet_h packet,
+ mmplayer_stream_type_e streamtype)
{
GstCaps *cur_caps = NULL;
GstCaps *new_caps = NULL;
========================================================================================== */
static gboolean
-__mmplayer_check_error_posted_from_activated_track(mm_player_t *player, gchar *src_element_name)
+__mmplayer_check_error_posted_from_activated_track(mmplayer_t *player, gchar *src_element_name)
{
/* check whether the error is posted from not-activated track or not */
int msg_src_pos = 0;
}
static int
-__mmplayer_gst_transform_error_decode(mm_player_t *player, const char *klass)
+__mmplayer_gst_transform_error_decode(mmplayer_t *player, const char *klass)
{
/* Demuxer can't parse one track because it's corrupted.
* So, the decoder for it is not linked.
}
static int
-__mmplayer_gst_transform_error_type(mm_player_t *player, GstElement *src_element)
+__mmplayer_gst_transform_error_type(mmplayer_t *player, GstElement *src_element)
{
if (src_element == player->pipeline->mainbin[MMPLAYER_M_SUBPARSE].gst) {
LOGE("Not supported subtitle.");
}
static int
-__mmplayer_gst_transform_error_failed(mm_player_t *player, const char *klass, GError *error)
+__mmplayer_gst_transform_error_failed(mmplayer_t *player, const char *klass, GError *error)
{
/* Decoder Custom Message */
if (!strstr(error->message, "ongoing"))
}
static int
-__mmplayer_gst_transform_error_decrypt(mm_player_t *player, GError *error)
+__mmplayer_gst_transform_error_decrypt(mmplayer_t *player, GError *error)
{
if (strstr(error->message, "rights expired"))
return MM_ERROR_PLAYER_DRM_EXPIRED;
/* NOTE : decide gstreamer state whether there is some playable track or not. */
static gint
-__mmplayer_gst_transform_gsterror(mm_player_t *player, GstMessage *message, GError *error)
+__mmplayer_gst_transform_gsterror(mmplayer_t *player, GstMessage *message, GError *error)
{
gchar *src_element_name = NULL;
GstElement *src_element = NULL;
}
gint
-__mmplayer_gst_handle_core_error(mm_player_t *player, int code)
+__mmplayer_gst_handle_core_error(mmplayer_t *player, int code)
{
gint trans_err = MM_ERROR_NONE;
}
gint
-__mmplayer_gst_handle_library_error(mm_player_t *player, int code)
+__mmplayer_gst_handle_library_error(mmplayer_t *player, int code)
{
gint trans_err = MM_ERROR_NONE;
}
gint
-__mmplayer_gst_handle_resource_error(mm_player_t *player, int code, GstMessage *message)
+__mmplayer_gst_handle_resource_error(mmplayer_t *player, int code, GstMessage *message)
{
gint trans_err = MM_ERROR_NONE;
break;
} else if (message != NULL && message->src != NULL) {
storage_state_e storage_state = STORAGE_STATE_UNMOUNTABLE;
- MMPlayerPathType path_type = MMPLAYER_PATH_MAX;
+ mmplayer_path_type_e path_type = MMPLAYER_PATH_MAX;
if (message->src == (GstObject *)player->pipeline->mainbin[MMPLAYER_M_SRC].gst)
path_type = MMPLAYER_PATH_VOD;
}
gint
-__mmplayer_gst_handle_stream_error(mm_player_t *player, GError *error, GstMessage *message)
+__mmplayer_gst_handle_stream_error(mmplayer_t *player, GError *error, GstMessage *message)
{
gint trans_err = MM_ERROR_NONE;
}
gboolean
-__mmplayer_handle_gst_error(mm_player_t *player, GstMessage *message, GError *error)
+__mmplayer_handle_gst_error(mmplayer_t *player, GstMessage *message, GError *error)
{
MMMessageParamType msg_param;
gchar *msg_src_element;
}
static gboolean
-__mmplayer_handle_streaming_error(mm_player_t *player, GstMessage *message)
+__mmplayer_handle_streaming_error(mmplayer_t *player, GstMessage *message)
{
LOGD("\n");
MMMessageParamType msg_param;
}
static void
-__mmplayer_get_metadata_360_from_tags(GstTagList *tags, mm_player_spherical_metadata_t *metadata)
+__mmplayer_get_metadata_360_from_tags(GstTagList *tags, mmplayer_spherical_metadata_t *metadata)
{
gst_tag_list_get_int(tags, "is_spherical", &metadata->is_spherical);
gst_tag_list_get_int(tags, "is_stitched", &metadata->is_stitched);
}
static gboolean
-__mmplayer_gst_extract_tag_from_msg(mm_player_t *player, GstMessage *msg)
+__mmplayer_gst_extract_tag_from_msg(mmplayer_t *player, GstMessage *msg)
{
/* macro for better code readability */
if (gst_tag_list_get_uint(tag_list, gsttag, &v_uint)) { \
if (v_uint) { \
int i = 0; \
- MMPlayerTrackType track_type = MM_PLAYER_TRACK_TYPE_AUDIO; \
+ mmplayer_track_type_e track_type = MM_PLAYER_TRACK_TYPE_AUDIO; \
if (strstr(GST_OBJECT_NAME(msg->src), "audio")) \
track_type = MM_PLAYER_TRACK_TYPE_AUDIO; \
else if (strstr(GST_OBJECT_NAME(msg->src), "video")) \
/* if retval is FALSE, it will be dropped for perfomance. */
static gboolean
-__mmplayer_gst_check_useful_message(mm_player_t *player, GstMessage *message)
+__mmplayer_gst_check_useful_message(mmplayer_t *player, GstMessage *message)
{
gboolean retval = FALSE;
}
static void
-__mmplayer_update_buffer_setting(mm_player_t *player, GstMessage *buffering_msg)
+__mmplayer_update_buffer_setting(mmplayer_t *player, GstMessage *buffering_msg)
{
guint64 data_size = 0;
gint64 pos_nsec = 0;
}
static int
-__mmplayer_handle_buffering_playback(mm_player_t *player)
+__mmplayer_handle_buffering_playback(mmplayer_t *player)
{
int ret = MM_ERROR_NONE;
- MMPlayerStateType prev_state = MM_PLAYER_STATE_NONE;
- MMPlayerStateType current_state = MM_PLAYER_STATE_NONE;
- MMPlayerStateType target_state = MM_PLAYER_STATE_NONE;
- MMPlayerStateType pending_state = MM_PLAYER_STATE_NONE;
+ mmplayer_state_e prev_state = MM_PLAYER_STATE_NONE;
+ mmplayer_state_e current_state = MM_PLAYER_STATE_NONE;
+ mmplayer_state_e target_state = MM_PLAYER_STATE_NONE;
+ mmplayer_state_e pending_state = MM_PLAYER_STATE_NONE;
if (!player || !player->streamer || (MMPLAYER_IS_LIVE_STREAMING(player) && MMPLAYER_IS_RTSP_STREAMING(player))) {
LOGW("do nothing for buffering msg");
return ret;
}
-static VariantData *
-__mmplayer_adaptive_var_info(const VariantData *self, gpointer user_data)
+static stream_variant_t *
+__mmplayer_adaptive_var_info(const stream_variant_t *self, gpointer user_data)
{
- VariantData *var_info = NULL;
+ stream_variant_t *var_info = NULL;
g_return_val_if_fail(self != NULL, NULL);
- var_info = g_new0(VariantData, 1);
+ var_info = g_new0(stream_variant_t, 1);
if (!var_info) return NULL;
var_info->bandwidth = self->bandwidth;
var_info->width = self->width;
}
static gboolean
-__mmplayer_gst_handle_duration(mm_player_t *player, GstMessage *msg)
+__mmplayer_gst_handle_duration(mmplayer_t *player, GstMessage *msg)
{
gint64 bytes = 0;
static gboolean
__mmplayer_eos_timer_cb(gpointer u_data)
{
- mm_player_t *player = NULL;
+ mmplayer_t *player = NULL;
MMHandleType attrs = 0;
int count = 0;
MMPLAYER_RETURN_VAL_IF_FAIL(u_data, FALSE);
- player = (mm_player_t *)u_data;
+ player = (mmplayer_t *)u_data;
attrs = MMPLAYER_GET_ATTRS(player);
mm_attrs_get_int_by_name(attrs, "profile_play_count", &count);
}
static void
-__mmplayer_handle_eos_delay(mm_player_t *player, int delay_in_ms)
+__mmplayer_handle_eos_delay(mmplayer_t *player, int delay_in_ms)
{
MMPLAYER_RETURN_IF_FAIL(player);
}
static int
-__mmplayer_gst_pending_seek(mm_player_t *player)
+__mmplayer_gst_pending_seek(mmplayer_t *player)
{
- MMPlayerStateType current_state = MM_PLAYER_STATE_NONE;
+ mmplayer_state_e current_state = MM_PLAYER_STATE_NONE;
int ret = MM_ERROR_NONE;
MMPLAYER_FENTER();
}
static void
-__mmplayer_gst_set_async(mm_player_t *player, gboolean async, enum MMPlayerSinkType type)
+__mmplayer_gst_set_async(mmplayer_t *player, gboolean async, enum mmplayer_sink_type type)
{
- MMPlayerGstElement *videobin = NULL, *audiobin = NULL, *textbin = NULL;
+ mmplayer_gst_element_t *videobin = NULL, *audiobin = NULL, *textbin = NULL;
MMPLAYER_RETURN_IF_FAIL(player && player->pipeline);
}
static void
-__mmplayer_drop_subtitle(mm_player_t *player, gboolean is_drop)
+__mmplayer_drop_subtitle(mmplayer_t *player, gboolean is_drop)
{
- MMPlayerGstElement *textbin;
+ mmplayer_gst_element_t *textbin;
MMPLAYER_FENTER();
MMPLAYER_RETURN_IF_FAIL(player &&
}
static void
-__mmplayer_gst_handle_eos_message(mm_player_t *player, GstMessage *msg)
+__mmplayer_gst_handle_eos_message(mmplayer_t *player, GstMessage *msg)
{
MMHandleType attrs = 0;
gint count = 0;
}
static void
-__mmplayer_gst_handle_error_message(mm_player_t *player, GstMessage *msg)
+__mmplayer_gst_handle_error_message(mmplayer_t *player, GstMessage *msg)
{
GError *error = NULL;
gchar *debug = NULL;
}
static void
-__mmplayer_gst_handle_buffering_message(mm_player_t *player, GstMessage *msg)
+__mmplayer_gst_handle_buffering_message(mmplayer_t *player, GstMessage *msg)
{
MMMessageParamType msg_param = {0, };
int bRet = MM_ERROR_NONE;
}
static void
-__mmplayer_gst_handle_state_message(mm_player_t *player, GstMessage *msg)
+__mmplayer_gst_handle_state_message(mmplayer_t *player, GstMessage *msg)
{
- MMPlayerGstElement *mainbin;
+ mmplayer_gst_element_t *mainbin;
const GValue *voldstate, *vnewstate, *vpending;
GstState oldstate = GST_STATE_NULL;
GstState newstate = GST_STATE_NULL;
}
static void
-__mmplayer_gst_handle_element_message(mm_player_t *player, GstMessage *msg)
+__mmplayer_gst_handle_element_message(mmplayer_t *player, GstMessage *msg)
{
const gchar *structure_name;
gint count = 0, idx = 0;
count = g_list_length(player->adaptive_info.var_list);
if (count > 0) {
- VariantData *temp = NULL;
+ stream_variant_t *temp = NULL;
/* print out for debug */
LOGD("num of variant_info %d", count);
}
static void
-__mmplayer_gst_handle_async_done_message(mm_player_t *player, GstMessage *msg)
+__mmplayer_gst_handle_async_done_message(mmplayer_t *player, GstMessage *msg)
{
- MMPlayerGstElement *mainbin;
+ mmplayer_gst_element_t *mainbin;
MMPLAYER_FENTER();
MMPLAYER_RETURN_IF_FAIL(player && player->pipeline && player->pipeline->mainbin);
static void
__mmplayer_gst_bus_msg_callback(GstMessage *msg, gpointer data)
{
- mm_player_t *player = (mm_player_t *)(data);
+ mmplayer_t *player = (mmplayer_t *)(data);
MMPLAYER_RETURN_IF_FAIL(player);
MMPLAYER_RETURN_IF_FAIL(msg && GST_IS_MESSAGE(msg));
static GstBusSyncReply
__mmplayer_gst_bus_sync_callback(GstBus *bus, GstMessage *message, gpointer data)
{
- mm_player_t *player = (mm_player_t *)data;
+ mmplayer_t *player = (mmplayer_t *)data;
GstBusSyncReply reply = GST_BUS_DROP;
if (!(player->pipeline && player->pipeline->mainbin)) {
__mmplayer_gst_appsrc_feed_data_mem(GstElement *element, guint size, gpointer user_data)
{
GstElement *appsrc = element;
- MMPlayerInputBuffer *buf = (MMPlayerInputBuffer *)user_data;
+ mmplayer_input_buffer_t *buf = (mmplayer_input_buffer_t *)user_data;
GstBuffer *buffer = NULL;
GstFlowReturn ret = GST_FLOW_OK;
gint len = size;
static gboolean
__mmplayer_gst_appsrc_seek_data_mem(GstElement *element, guint64 size, gpointer user_data)
{
- MMPlayerInputBuffer *buf = (MMPlayerInputBuffer *)user_data;
+ mmplayer_input_buffer_t *buf = (mmplayer_input_buffer_t *)user_data;
MMPLAYER_RETURN_VAL_IF_FAIL(buf, FALSE);
void
__mmplayer_gst_appsrc_feed_data(GstElement *element, guint size, gpointer user_data)
{
- mm_player_t *player = (mm_player_t *)user_data;
- MMPlayerStreamType type = MM_PLAYER_STREAM_TYPE_DEFAULT;
+ mmplayer_t *player = (mmplayer_t *)user_data;
+ mmplayer_stream_type_e type = MM_PLAYER_STREAM_TYPE_DEFAULT;
guint64 current_level_bytes = 0;
MMPLAYER_RETURN_IF_FAIL(player);
void
__mmplayer_gst_appsrc_enough_data(GstElement *element, gpointer user_data)
{
- mm_player_t *player = (mm_player_t *)user_data;
- MMPlayerStreamType type = MM_PLAYER_STREAM_TYPE_DEFAULT;
+ mmplayer_t *player = (mmplayer_t *)user_data;
+ mmplayer_stream_type_e type = MM_PLAYER_STREAM_TYPE_DEFAULT;
guint64 current_level_bytes = 0;
MMPLAYER_RETURN_IF_FAIL(player);
gboolean
__mmplayer_gst_appsrc_seek_data(GstElement *element, guint64 position, gpointer user_data)
{
- mm_player_t *player = (mm_player_t *)user_data;
- MMPlayerStreamType type = MM_PLAYER_STREAM_TYPE_DEFAULT;
+ mmplayer_t *player = (mmplayer_t *)user_data;
+ mmplayer_stream_type_e type = MM_PLAYER_STREAM_TYPE_DEFAULT;
MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
}
static gboolean
-__mmplayer_gst_create_es_decoder(mm_player_t *player, MMPlayerStreamType type, GstPad *srcpad)
+__mmplayer_gst_create_es_decoder(mmplayer_t *player, mmplayer_stream_type_e type, GstPad *srcpad)
{
#define MAX_LEN_NAME 20
GstPad *sinkpad = NULL;
gchar *prefix = NULL;
gchar dec_name[MAX_LEN_NAME] = {0, };
- enum MainElementID elem_id = MMPLAYER_M_NUM;
+ main_element_id_e elem_id = MMPLAYER_M_NUM;
- MMPlayerGstElement *mainbin = NULL;
+ mmplayer_gst_element_t *mainbin = NULL;
GstElement *decodebin = NULL;
GstCaps *dec_caps = NULL;
}
static gboolean
-__mmplayer_gst_create_es_path(mm_player_t *player, MMPlayerStreamType type, GstCaps *caps)
+__mmplayer_gst_create_es_path(mmplayer_t *player, mmplayer_stream_type_e type, GstCaps *caps)
{
#define MAX_LEN_NAME 20
- MMPlayerGstElement *mainbin = NULL;
+ mmplayer_gst_element_t *mainbin = NULL;
gchar *prefix = NULL;
- enum MainElementID src_id = MMPLAYER_M_NUM, queue_id = MMPLAYER_M_NUM;
+ main_element_id_e src_id = MMPLAYER_M_NUM, queue_id = MMPLAYER_M_NUM;
gchar src_name[MAX_LEN_NAME] = {0, }, queue_name[MAX_LEN_NAME] = {0, };
GstElement *src = NULL, *queue = NULL;
GstStructure *str = NULL;
const gchar *name = NULL;
- mm_player_t *player = (mm_player_t *)data;
+ mmplayer_t *player = (mmplayer_t *)data;
MMPLAYER_FENTER();
static void
__mmplayer_gst_rtp_no_more_pads(GstElement *element, gpointer data)
{
- mm_player_t *player = (mm_player_t *)data;
+ mmplayer_t *player = (mmplayer_t *)data;
MMPLAYER_FENTER();
}
static GstElement *
-__mmplayer_gst_make_rtsp_src(mm_player_t *player)
+__mmplayer_gst_make_rtsp_src(mmplayer_t *player)
{
GstElement *element = NULL;
gchar *user_agent = NULL;
}
static GstElement *
-__mmplayer_gst_make_http_src(mm_player_t *player)
+__mmplayer_gst_make_http_src(mmplayer_t *player)
{
GstElement *element = NULL;
MMHandleType attrs = 0;
}
static GstElement *
-__mmplayer_gst_make_file_src(mm_player_t *player)
+__mmplayer_gst_make_file_src(mmplayer_t *player)
{
GstElement *element = NULL;
static gboolean
__mmplayer_gst_msg_push(GstBus *bus, GstMessage *msg, gpointer data)
{
- mm_player_t *player = (mm_player_t *)data;
+ mmplayer_t *player = (mmplayer_t *)data;
g_return_val_if_fail(player, FALSE);
g_return_val_if_fail(msg && GST_IS_MESSAGE(msg), FALSE);
static gpointer __mmplayer_gst_bus_msg_thread(gpointer data)
{
- mm_player_t *player = (mm_player_t *)(data);
+ mmplayer_t *player = (mmplayer_t *)(data);
GstMessage *msg = NULL;
GstBus *bus = NULL;
}
static int
-__mmplayer_gst_check_duration(mm_player_t *player, gint64 position)
+__mmplayer_gst_check_duration(mmplayer_t *player, gint64 position)
{
gint64 dur_nsec = 0;
}
static gboolean
-__mmplayer_gst_check_seekable(mm_player_t *player)
+__mmplayer_gst_check_seekable(mmplayer_t *player)
{
GstQuery *query = NULL;
gboolean seekable = FALSE;
}
int
-__mmplayer_gst_set_state(mm_player_t *player, GstElement *element, GstState state, gboolean async, gint timeout)
+__mmplayer_gst_set_state(mmplayer_t *player, GstElement *element, GstState state, gboolean async, gint timeout)
{
GstState element_state = GST_STATE_VOID_PENDING;
GstState element_pending_state = GST_STATE_VOID_PENDING;
}
int
-__mmplayer_gst_start(mm_player_t *player)
+__mmplayer_gst_start(mmplayer_t *player)
{
int ret = MM_ERROR_NONE;
gboolean async = FALSE;
}
int
-__mmplayer_gst_stop(mm_player_t *player)
+__mmplayer_gst_stop(mmplayer_t *player)
{
GstStateChangeReturn change_ret = GST_STATE_CHANGE_SUCCESS;
MMHandleType attrs = 0;
}
int
-__mmplayer_gst_pause(mm_player_t *player, gboolean async)
+__mmplayer_gst_pause(mmplayer_t *player, gboolean async)
{
int ret = MM_ERROR_NONE;
}
int
-__mmplayer_gst_resume(mm_player_t *player, gboolean async)
+__mmplayer_gst_resume(mmplayer_t *player, gboolean async)
{
int ret = MM_ERROR_NONE;
gint timeout = 0;
/* sending event to one of sinkelements */
gboolean
-__mmplayer_gst_send_event_to_sink(mm_player_t *player, GstEvent *event)
+__mmplayer_gst_send_event_to_sink(mmplayer_t *player, GstEvent *event)
{
GstEvent *event2 = NULL;
GList *sinks = NULL;
}
gboolean
-__mmplayer_gst_seek(mm_player_t *player, GstElement *element, gdouble rate,
+__mmplayer_gst_seek(mmplayer_t *player, GstElement *element, gdouble rate,
GstFormat format, GstSeekFlags flags, GstSeekType cur_type,
gint64 cur, GstSeekType stop_type, gint64 stop)
{
}
int
-__mmplayer_gst_set_position(mm_player_t *player, gint64 position, gboolean internal_called)
+__mmplayer_gst_set_position(mmplayer_t *player, gint64 position, gboolean internal_called)
{
int ret = MM_ERROR_NONE;
gint64 pos_nsec = 0;
}
int
-__mmplayer_gst_get_position(mm_player_t *player, gint64 *position)
+__mmplayer_gst_get_position(mmplayer_t *player, gint64 *position)
{
#define TRICKPLAY_OFFSET GST_MSECOND
- MMPlayerStateType current_state = MM_PLAYER_STATE_NONE;
+ mmplayer_state_e current_state = MM_PLAYER_STATE_NONE;
gint64 pos_nsec = 0;
gboolean ret = TRUE;
}
int
-__mmplayer_gst_get_buffer_position(mm_player_t *player, int *start_pos, int *end_pos)
+__mmplayer_gst_get_buffer_position(mmplayer_t *player, int *start_pos, int *end_pos)
{
#define STREAMING_IS_FINISHED 0
#define BUFFERING_MAX_PER 100
#define DEFAULT_PER_VALUE -1
#define CHECK_PERCENT_VALUE(a, min, max)(((a) > (min)) ? (((a) < (max)) ? (a) : (max)) : (min))
- MMPlayerGstElement *mainbin = NULL;
+ mmplayer_gst_element_t *mainbin = NULL;
gint start_per = DEFAULT_PER_VALUE, end_per = DEFAULT_PER_VALUE;
gint64 buffered_total = 0;
gint64 position = 0;
}
GstElement *
-__mmplayer_gst_create_source(mm_player_t *player)
+__mmplayer_gst_create_source(mmplayer_t *player)
{
GstElement *element = NULL;
}
int
-__mmplayer_gst_build_es_pipeline(mm_player_t *player)
+__mmplayer_gst_build_es_pipeline(mmplayer_t *player)
{
MMHandleType attrs = 0;
}
int
-__mmplayer_gst_build_pipeline(mm_player_t *player)
+__mmplayer_gst_build_pipeline(mmplayer_t *player)
{
- MMPlayerGstElement *mainbin = NULL;
+ mmplayer_gst_element_t *mainbin = NULL;
GstElement *src_elem = NULL;
GstElement *autoplug_elem = NULL;
GList *element_bucket = NULL;
MMHandleType attrs = 0;
- enum MainElementID autoplug_elem_id = MMPLAYER_M_NUM;
+ main_element_id_e autoplug_elem_id = MMPLAYER_M_NUM;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player && player->pipeline &&
}
int
-__mmplayer_gst_add_bus_watch(mm_player_t *player)
+__mmplayer_gst_add_bus_watch(mmplayer_t *player)
{
GstBus *bus = NULL;
- MMPlayerGstElement *mainbin = NULL;
+ mmplayer_gst_element_t *mainbin = NULL;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player && player->pipeline &&
#ifdef MM_PLAYER_DEFAULT_INI
static gboolean __generate_default_ini(void);
#endif
-static void __get_element_list(mm_player_ini_t *ini, gchar *str, int keyword_type);
+static void __get_element_list(mmplayer_ini_t *ini, gchar *str, int keyword_type);
static void __mm_player_ini_check_ini_status(void);
} while (0)
int
-mm_player_ini_load(mm_player_ini_t *ini)
+mm_player_ini_load(mmplayer_ini_t *ini)
{
dictionary *dict = NULL;
gint idx = 0;
}
/* get ini values */
- memset(ini, 0, sizeof(mm_player_ini_t));
+ memset(ini, 0, sizeof(mmplayer_ini_t));
if (dict) {
/* if dict is available */
}
int
-mm_player_audio_effect_ini_load(mm_player_ini_t *ini)
+mm_player_audio_effect_ini_load(mmplayer_ini_t *ini)
{
dictionary *dict_audioeffect = NULL;
#endif
static void
-__get_element_list(mm_player_ini_t *ini, gchar *str, int keyword_type)
+__get_element_list(mmplayer_ini_t *ini, gchar *str, int keyword_type)
{
gchar **list = NULL;
gchar **walk = NULL;
/*---------------------------------------------------------------------------
| LOCAL FUNCTION PROTOTYPES: |
---------------------------------------------------------------------------*/
-static int __mmplayer_gst_create_pipeline(mm_player_t *player);
-static int __mmplayer_gst_destroy_pipeline(mm_player_t *player);
-static int __mmplayer_gst_create_text_pipeline(mm_player_t *player);
-static int __mmplayer_gst_create_video_sink_bin(mm_player_t *player, GstCaps *caps, MMDisplaySurfaceType surface_type);
-static int __mmplayer_gst_create_audio_sink_bin(mm_player_t *player);
-static int __mmplayer_gst_create_text_sink_bin(mm_player_t *player);
+static int __mmplayer_gst_create_pipeline(mmplayer_t *player);
+static int __mmplayer_gst_destroy_pipeline(mmplayer_t *player);
+static int __mmplayer_gst_create_text_pipeline(mmplayer_t *player);
+static int __mmplayer_gst_create_video_sink_bin(mmplayer_t *player, GstCaps *caps, MMDisplaySurfaceType surface_type);
+static int __mmplayer_gst_create_audio_sink_bin(mmplayer_t *player);
+static int __mmplayer_gst_create_text_sink_bin(mmplayer_t *player);
static GstPadProbeReturn __mmplayer_gst_selector_blocked(GstPad *pad, GstPadProbeInfo *info, gpointer data);
static void __mmplayer_gst_decode_no_more_pads(GstElement *elem, gpointer data);
static void __mmplayer_pipeline_complete(GstElement *decodebin, gpointer data);
static gboolean __mmplayer_is_midi_type(gchar *str_caps);
static gboolean __mmplayer_is_only_mp3_type(gchar *str_caps);
-static void __mmplayer_set_audio_attrs(mm_player_t *player, GstCaps *caps);
+static void __mmplayer_set_audio_attrs(mmplayer_t *player, GstCaps *caps);
static gboolean __mmplayer_update_subtitle(GstElement *object, GstBuffer *buffer, GstPad *pad, gpointer data);
-static void __mmplayer_release_misc(mm_player_t *player);
-static void __mmplayer_release_misc_post(mm_player_t *player);
-static gboolean __mmplayer_init_gstreamer(mm_player_t *player);
+static void __mmplayer_release_misc(mmplayer_t *player);
+static void __mmplayer_release_misc_post(mmplayer_t *player);
+static gboolean __mmplayer_init_gstreamer(mmplayer_t *player);
static void __mmplayer_video_stream_decoded_preroll_cb(GstElement *object, GstBuffer *buffer, GstPad *pad, gpointer data);
static void __mmplayer_video_stream_decoded_render_cb(GstElement *object, GstBuffer *buffer, GstPad *pad, gpointer data);
static GstPadProbeReturn __mmplayer_subtitle_adjust_position_probe(GstPad *pad, GstPadProbeInfo *info, gpointer u_data);
-static int __mmplayer_change_selector_pad(mm_player_t *player, MMPlayerTrackType type, int index);
-
-static gboolean __mmplayer_check_subtitle(mm_player_t *player);
-static int __mmplayer_handle_missed_plugin(mm_player_t *player);
-static int __mmplayer_check_not_supported_codec(mm_player_t *player, const gchar *factory_class, const gchar *mime);
-static void __mmplayer_add_sink(mm_player_t *player, GstElement *sink);
-static void __mmplayer_del_sink(mm_player_t *player, GstElement *sink);
-static void __mmplayer_release_signal_connection(mm_player_t *player, MMPlayerSignalType type);
+static int __mmplayer_change_selector_pad(mmplayer_t *player, mmplayer_track_type_e type, int index);
+
+static gboolean __mmplayer_check_subtitle(mmplayer_t *player);
+static int __mmplayer_handle_missed_plugin(mmplayer_t *player);
+static int __mmplayer_check_not_supported_codec(mmplayer_t *player, const gchar *factory_class, const gchar *mime);
+static void __mmplayer_add_sink(mmplayer_t *player, GstElement *sink);
+static void __mmplayer_del_sink(mmplayer_t *player, GstElement *sink);
+static void __mmplayer_release_signal_connection(mmplayer_t *player, mmplayer_signal_type_e type);
static gpointer __mmplayer_gapless_play_thread(gpointer data);
-static gboolean __mmplayer_add_dump_buffer_probe(mm_player_t *player, GstElement *element);
+static gboolean __mmplayer_add_dump_buffer_probe(mmplayer_t *player, GstElement *element);
static GstPadProbeReturn __mmplayer_dump_buffer_probe_cb(GstPad *pad, GstPadProbeInfo *info, gpointer u_data);
static void __mmplayer_release_dump_list(GList *dump_list);
-static int __mmplayer_gst_realize(mm_player_t *player);
-static int __mmplayer_gst_unrealize(mm_player_t *player);
-static int __mmplayer_gst_adjust_subtitle_position(mm_player_t *player, int format, int position);
-static int __mmplayer_gst_set_message_callback(mm_player_t *player, MMMessageCallback callback, gpointer user_param);
+static int __mmplayer_gst_realize(mmplayer_t *player);
+static int __mmplayer_gst_unrealize(mmplayer_t *player);
+static int __mmplayer_gst_adjust_subtitle_position(mmplayer_t *player, int position);
+static int __mmplayer_gst_set_message_callback(mmplayer_t *player, MMMessageCallback callback, gpointer user_param);
/* util */
-static gboolean __mmplayer_verify_gapless_play_path(mm_player_t *player);
-static void __mmplayer_activate_next_source(mm_player_t *player, GstState target);
-static void __mmplayer_check_pipeline(mm_player_t *player);
-static gboolean __mmplayer_deactivate_selector(mm_player_t *player, MMPlayerTrackType type);
-static void __mmplayer_deactivate_old_path(mm_player_t *player);
-static int __mmplayer_gst_create_plain_text_elements(mm_player_t *player);
+static gboolean __mmplayer_verify_gapless_play_path(mmplayer_t *player);
+static void __mmplayer_activate_next_source(mmplayer_t *player, GstState target);
+static void __mmplayer_check_pipeline(mmplayer_t *player);
+static gboolean __mmplayer_deactivate_selector(mmplayer_t *player, mmplayer_track_type_e type);
+static void __mmplayer_deactivate_old_path(mmplayer_t *player);
+static int __mmplayer_gst_create_plain_text_elements(mmplayer_t *player);
static guint32 _mmplayer_convert_fourcc_string_to_value(const gchar *format_name);
static void __mmplayer_gst_caps_notify_cb(GstPad *pad, GParamSpec *unused, gpointer data);
-static void __mmplayer_audio_stream_send_data(mm_player_t *player, mm_player_audio_stream_buff_t *a_buffer);
-static void __mmplayer_initialize_storage_info(mm_player_t *player, MMPlayerPathType path_type);
+static void __mmplayer_audio_stream_send_data(mmplayer_t *player, mmplayer_audio_stream_buff_t *a_buffer);
+static void __mmplayer_initialize_storage_info(mmplayer_t *player, mmplayer_path_type_e path_type);
static int __resource_release_cb(mm_resource_manager_h rm, mm_resource_manager_res_h res, void *user_data);
-static gboolean __mmplayer_update_duration_value(mm_player_t *player);
-static gboolean __mmplayer_update_audio_attrs(mm_player_t *player, MMHandleType attrs);
-static gboolean __mmplayer_update_video_attrs(mm_player_t *player, MMHandleType attrs);
-static gboolean __mmplayer_update_bitrate_attrs(mm_player_t *player, MMHandleType attrs);
-
-static void __mmplayer_copy_uri_and_set_type(MMPlayerParseProfile *data, const char *uri, int uri_type);
-static int __mmplayer_set_mem_uri(MMPlayerParseProfile *data, char *path, void *param);
-static int __mmplayer_set_file_uri(MMPlayerParseProfile *data, const char *uri);
-
-static MMPlayerVideoStreamDataType *__mmplayer_create_stream_from_pad(GstPad *pad);
-static void __mmplayer_zerocopy_set_stride_elevation_bo(MMPlayerVideoStreamDataType *stream, GstMemory *mem);
-static gboolean __mmplayer_swcodec_set_stride_elevation(MMPlayerVideoStreamDataType *stream);
-static gboolean __mmplayer_swcodec_set_bo(mm_player_t *player, MMPlayerVideoStreamDataType *stream, GstMemory *mem);
-
-static void __mmplayer_set_pause_state(mm_player_t *player);
-static void __mmplayer_set_playing_state(mm_player_t *player);
+static gboolean __mmplayer_update_duration_value(mmplayer_t *player);
+static gboolean __mmplayer_update_audio_attrs(mmplayer_t *player, MMHandleType attrs);
+static gboolean __mmplayer_update_video_attrs(mmplayer_t *player, MMHandleType attrs);
+static gboolean __mmplayer_update_bitrate_attrs(mmplayer_t *player, MMHandleType attrs);
+
+static void __mmplayer_copy_uri_and_set_type(mmplayer_parse_profile_t *data, const char *uri, int uri_type);
+static int __mmplayer_set_mem_uri(mmplayer_parse_profile_t *data, char *path, void *param);
+static int __mmplayer_set_file_uri(mmplayer_parse_profile_t *data, const char *uri);
+
+static mmplayer_video_decoded_data_info_t *__mmplayer_create_stream_from_pad(GstPad *pad);
+static void __mmplayer_zerocopy_set_stride_elevation_bo(mmplayer_video_decoded_data_info_t *stream, GstMemory *mem);
+static gboolean __mmplayer_swcodec_set_stride_elevation(mmplayer_video_decoded_data_info_t *stream);
+static gboolean __mmplayer_swcodec_set_bo(mmplayer_t *player, mmplayer_video_decoded_data_info_t *stream, GstMemory *mem);
+
+static void __mmplayer_set_pause_state(mmplayer_t *player);
+static void __mmplayer_set_playing_state(mmplayer_t *player);
/*===========================================================================================
| |
| FUNCTION DEFINITIONS |
/* This function should be called after the pipeline goes PAUSED or higher
state. */
gboolean
-__mmplayer_update_content_attrs(mm_player_t *player, enum content_attr_flag flag)
+__mmplayer_update_content_attrs(mmplayer_t *player, enum content_attr_flag flag)
{
static gboolean has_duration = FALSE;
static gboolean has_video_attrs = FALSE;
}
MMStreamingType
-__mmplayer_get_stream_service_type(mm_player_t *player)
+__mmplayer_get_stream_service_type(mmplayer_t *player)
{
MMStreamingType streaming_type = STREAMING_SERVICE_NONE;
* it to applicaton by calling callback function
*/
void
-__mmplayer_set_state(mm_player_t *player, int state)
+__mmplayer_set_state(mmplayer_t *player, int state)
{
MMMessageParamType msg = {0, };
}
int
-__mmplayer_check_state(mm_player_t *player, enum PlayerCommandState command)
+__mmplayer_check_state(mmplayer_t *player, mmplayer_command_state_e command)
{
- MMPlayerStateType current_state = MM_PLAYER_STATE_NUM;
- MMPlayerStateType pending_state = MM_PLAYER_STATE_NUM;
+ mmplayer_state_e current_state = MM_PLAYER_STATE_NUM;
+ mmplayer_state_e pending_state = MM_PLAYER_STATE_NUM;
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
static gpointer
__mmplayer_gapless_play_thread(gpointer data)
{
- mm_player_t *player = (mm_player_t *)data;
- MMPlayerGstElement *mainbin = NULL;
+ mmplayer_t *player = (mmplayer_t *)data;
+ mmplayer_gst_element_t *mainbin = NULL;
MMPLAYER_RETURN_VAL_IF_FAIL(player, NULL);
void
__mmplayer_bus_msg_thread_destroy(MMHandleType hplayer)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
GstMessage *msg = NULL;
GQueue *queue = NULL;
}
gboolean
-__mmplayer_gst_remove_fakesink(mm_player_t *player, MMPlayerGstElement *fakesink)
+__mmplayer_gst_remove_fakesink(mmplayer_t *player, mmplayer_gst_element_t *fakesink)
{
GstElement *parent = NULL;
}
static void
-__mmplayer_gst_selector_update_start_time(mm_player_t *player, MMPlayerTrackType stream_type)
+__mmplayer_gst_selector_update_start_time(mmplayer_t *player, mmplayer_track_type_e stream_type)
{
gint64 stop_running_time = 0;
gint64 position_running_time = 0;
{
GstPadProbeReturn ret = GST_PAD_PROBE_OK;
GstEvent *event = GST_PAD_PROBE_INFO_DATA(info);
- mm_player_t *player = (mm_player_t *)data;
+ mmplayer_t *player = (mmplayer_t *)data;
GstCaps *caps = NULL;
GstStructure *str = NULL;
const gchar *name = NULL;
- MMPlayerTrackType stream_type = MM_PLAYER_TRACK_TYPE_VIDEO;
+ mmplayer_track_type_e stream_type = MM_PLAYER_TRACK_TYPE_VIDEO;
gboolean caps_ret = TRUE;
if (GST_EVENT_IS_DOWNSTREAM(event) &&
/* create fakesink for audio or video path witout audiobin or videobin */
static void
-__mmplayer_gst_make_fakesink(mm_player_t *player, GstPad *pad, const gchar *name)
+__mmplayer_gst_make_fakesink(mmplayer_t *player, GstPad *pad, const gchar *name)
{
GstElement *pipeline = NULL;
GstElement *fakesink = NULL;
}
static GstElement *
-__mmplayer_gst_make_selector(mm_player_t *player, enum MainElementID elem_idx, MMPlayerTrackType stream_type)
+__mmplayer_gst_make_selector(mmplayer_t *player, main_element_id_e elem_idx, mmplayer_track_type_e stream_type)
{
GstElement *pipeline = NULL;
GstElement *selector = NULL;
void
__mmplayer_gst_decode_pad_added(GstElement *elem, GstPad *pad, gpointer data)
{
- mm_player_t *player = (mm_player_t *)data;
+ mmplayer_t *player = (mmplayer_t *)data;
GstElement *selector = NULL;
GstCaps *caps = NULL;
GstStructure *str = NULL;
gboolean first_track = FALSE;
gboolean caps_ret = TRUE;
- enum MainElementID elem_idx = MMPLAYER_M_NUM;
- MMPlayerTrackType stream_type = MM_PLAYER_TRACK_TYPE_AUDIO;
+ main_element_id_e elem_idx = MMPLAYER_M_NUM;
+ mmplayer_track_type_e stream_type = MM_PLAYER_TRACK_TYPE_AUDIO;
MMPLAYER_FENTER();
MMPLAYER_RETURN_IF_FAIL(elem && pad);
}
static gboolean
-__mmplayer_create_sink_path(mm_player_t *player, GstElement *selector, MMPlayerTrackType type)
+__mmplayer_create_sink_path(mmplayer_t *player, GstElement *selector, mmplayer_track_type_e type)
{
GstPad *srcpad = NULL;
}
static void
-__mmplayer_set_decode_track_info(mm_player_t *player, MMPlayerTrackType type)
+__mmplayer_set_decode_track_info(mmplayer_t *player, mmplayer_track_type_e type)
{
MMHandleType attrs = 0;
gint active_index = 0;
}
static gboolean
-__mmplayer_create_audio_sink_path(mm_player_t *player, GstElement *audio_selector)
+__mmplayer_create_audio_sink_path(mmplayer_t *player, GstElement *audio_selector)
{
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player && player->pipeline, FALSE);
}
static gboolean
-__mmplayer_create_text_sink_path(mm_player_t *player, GstElement *text_selector)
+__mmplayer_create_text_sink_path(mmplayer_t *player, GstElement *text_selector)
{
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player && text_selector, FALSE);
}
static gboolean
-__mmplayer_gst_set_queue2_buffering(mm_player_t *player)
+__mmplayer_gst_set_queue2_buffering(mmplayer_t *player)
{
gint64 dur_bytes = 0L;
static void
__mmplayer_gst_decode_no_more_pads(GstElement *elem, gpointer data)
{
- mm_player_t *player = NULL;
+ mmplayer_t *player = NULL;
GstElement *video_selector = NULL;
GstElement *audio_selector = NULL;
GstElement *text_selector = NULL;
MMPLAYER_FENTER();
- player = (mm_player_t *)data;
+ player = (mmplayer_t *)data;
LOGD("no-more-pad signal handling");
}
static gboolean
-__mmplayer_gst_add_sinkbin_to_pipeline(mm_player_t *player, GstElement *sinkbin, GstPad *pad, gboolean reusing, gchar *sink_pad_name)
+__mmplayer_gst_add_sinkbin_to_pipeline(mmplayer_t *player, GstElement *sinkbin, GstPad *pad, gboolean reusing, gchar *sink_pad_name)
{
gboolean ret = FALSE;
GstElement *pipeline = NULL;
static void
__mmplayer_gst_create_sinkbin(GstElement *elem, GstPad *pad, gpointer data)
{
- mm_player_t *player = NULL;
+ mmplayer_t *player = NULL;
GstCaps *caps = NULL;
gchar *caps_str = NULL;
GstStructure *str = NULL;
gchar *sink_pad_name = "sink";
/* check handles */
- player = (mm_player_t *)data;
+ player = (mmplayer_t *)data;
MMPLAYER_FENTER();
MMPLAYER_RETURN_IF_FAIL(elem && pad);
}
static gboolean
-__mmplayer_get_property_value_for_rotation(mm_player_t *player, int display_angle, int orientation, int *value)
+__mmplayer_get_property_value_for_rotation(mmplayer_t *player, int display_angle, int orientation, int *value)
{
int required_angle = 0; /* Angle required for straight view */
int rotation_angle = 0;
}
int
-__mmplayer_video_param_check_video_sink_bin(mm_player_t *player)
+__mmplayer_video_param_check_video_sink_bin(mmplayer_t *player)
{
/* check video sinkbin is created */
MMPLAYER_RETURN_VAL_IF_FAIL(player &&
}
int
-__mmplayer_get_video_angle(mm_player_t *player, int *display_angle, int *orientation)
+__mmplayer_get_video_angle(mmplayer_t *player, int *display_angle, int *orientation)
{
int display_rotation = 0;
gchar *org_orient = NULL;
}
void
-__mmplayer_video_param_set_display_rotation(mm_player_t *player)
+__mmplayer_video_param_set_display_rotation(mmplayer_t *player)
{
int rotation_value = 0;
int orientations = 0; // current supported angle values are 0, 90, 180, 270
}
void
-__mmplayer_video_param_set_display_visible(mm_player_t *player)
+__mmplayer_video_param_set_display_visible(mmplayer_t *player)
{
MMHandleType attrs = 0;
int visible = 0;
}
void
-__mmplayer_video_param_set_display_method(mm_player_t *player)
+__mmplayer_video_param_set_display_method(mmplayer_t *player)
{
MMHandleType attrs = 0;
int display_method = 0;
}
void
-__mmplayer_video_param_set_video_roi_area(mm_player_t *player)
+__mmplayer_video_param_set_video_roi_area(mmplayer_t *player)
{
MMHandleType attrs = 0;
void *handle = NULL;
}
void
-__mmplayer_video_param_set_roi_area(mm_player_t *player)
+__mmplayer_video_param_set_roi_area(mmplayer_t *player)
{
MMHandleType attrs = 0;
void *handle = NULL;
}
void
-__mmplayer_video_param_set_display_overlay(mm_player_t *player)
+__mmplayer_video_param_set_display_overlay(mmplayer_t *player)
{
MMHandleType attrs = 0;
void *handle = NULL;
}
int
-__mmplayer_update_wayland_videosink_video_param(mm_player_t *player, char *param_name)
+__mmplayer_update_wayland_videosink_video_param(mmplayer_t *player, char *param_name)
{
gboolean update_all_param = FALSE;
MMPLAYER_FENTER();
}
int
-_mmplayer_update_video_param(mm_player_t *player, char *param_name)
+_mmplayer_update_video_param(mmplayer_t *player, char *param_name)
{
MMHandleType attrs = 0;
int surface_type = 0;
_mmplayer_set_audio_only(MMHandleType hplayer, bool audio_only)
{
gboolean disable_overlay = FALSE;
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
int ret = MM_ERROR_NONE;
MMPLAYER_FENTER();
int
_mmplayer_get_audio_only(MMHandleType hplayer, bool *paudio_only)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
gboolean disable_overlay = FALSE;
MMPLAYER_FENTER();
__mmplayer_gst_element_link_bucket(GList *element_bucket)
{
GList *bucket = element_bucket;
- MMPlayerGstElement *element = NULL;
- MMPlayerGstElement *prv_element = NULL;
+ mmplayer_gst_element_t *element = NULL;
+ mmplayer_gst_element_t *prv_element = NULL;
gint successful_link_count = 0;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(element_bucket, -1);
- prv_element = (MMPlayerGstElement *)bucket->data;
+ prv_element = (mmplayer_gst_element_t *)bucket->data;
bucket = bucket->next;
for (; bucket; bucket = bucket->next) {
- element = (MMPlayerGstElement *)bucket->data;
+ element = (mmplayer_gst_element_t *)bucket->data;
if (element && element->gst) {
if (prv_element && prv_element->gst) {
__mmplayer_gst_element_add_bucket_to_bin(GstBin *bin, GList *element_bucket)
{
GList *bucket = element_bucket;
- MMPlayerGstElement *element = NULL;
+ mmplayer_gst_element_t *element = NULL;
int successful_add_count = 0;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(bin, 0);
for (; bucket; bucket = bucket->next) {
- element = (MMPlayerGstElement *)bucket->data;
+ element = (mmplayer_gst_element_t *)bucket->data;
if (element && element->gst) {
if (!gst_bin_add(bin, GST_ELEMENT(element->gst))) {
static void
__mmplayer_gst_caps_notify_cb(GstPad *pad, GParamSpec *unused, gpointer data)
{
- mm_player_t *player = (mm_player_t *)data;
+ mmplayer_t *player = (mmplayer_t *)data;
GstCaps *caps = NULL;
GstStructure *str = NULL;
const char *name;
} while (0);
void
-__mmplayer_audio_stream_clear_buffer(mm_player_t *player, gboolean send_all)
+__mmplayer_audio_stream_clear_buffer(mmplayer_t *player, gboolean send_all)
{
GList *l = NULL;
if (player->audio_stream_buff_list) {
for (l = g_list_first(player->audio_stream_buff_list); l; l = g_list_next(l)) {
- mm_player_audio_stream_buff_t *tmp = (mm_player_audio_stream_buff_t *)l->data;
+ mmplayer_audio_stream_buff_t *tmp = (mmplayer_audio_stream_buff_t *)l->data;
if (tmp) {
if (send_all) {
LOGD("[%"G_GUINT64_FORMAT"] send remained data.", tmp->channel_mask);
}
static void
-__mmplayer_audio_stream_send_data(mm_player_t *player, mm_player_audio_stream_buff_t *a_buffer)
+__mmplayer_audio_stream_send_data(mmplayer_t *player, mmplayer_audio_stream_buff_t *a_buffer)
{
- MMPlayerAudioStreamDataType audio_stream = { 0, };
+ mmplayer_audio_decoded_data_info_t audio_stream = { 0, };
MMPLAYER_FENTER();
MMPLAYER_RETURN_IF_FAIL(player && player->audio_stream_render_cb);
static void
__mmplayer_audio_stream_decoded_render_cb(GstElement *object, GstBuffer *buffer, GstPad *pad, gpointer data)
{
- mm_player_t *player = (mm_player_t *)data;
+ mmplayer_t *player = (mmplayer_t *)data;
gint channel = 0;
gint rate = 0;
gint depth = 0;
guint64 channel_mask = 0;
void *a_data = NULL;
gint a_size = 0;
- mm_player_audio_stream_buff_t *a_buffer = NULL;
+ mmplayer_audio_stream_buff_t *a_buffer = NULL;
GstMapInfo mapinfo = GST_MAP_INFO_INIT;
GList *l = NULL;
* The num of buffer list depends on the num of audio channels */
if (player->audio_stream_buff_list) {
for (l = g_list_first(player->audio_stream_buff_list); l; l = g_list_next(l)) {
- mm_player_audio_stream_buff_t *tmp = (mm_player_audio_stream_buff_t *)l->data;
+ mmplayer_audio_stream_buff_t *tmp = (mmplayer_audio_stream_buff_t *)l->data;
if (tmp) {
if (channel_mask == tmp->channel_mask) {
/* LOGD("[%"G_GUINT64_FORMAT"] total: %d, data: %d, buffer: %d", channel_mask, tmp->data_size, a_size, tmp->buff_size); */
}
/* create new audio stream data */
- a_buffer = (mm_player_audio_stream_buff_t *)g_try_malloc0(sizeof(mm_player_audio_stream_buff_t));
+ a_buffer = (mmplayer_audio_stream_buff_t *)g_try_malloc0(sizeof(mmplayer_audio_stream_buff_t));
if (a_buffer == NULL) {
LOGE("failed to alloc data.");
goto DONE;
static void
__mmplayer_gst_audio_deinterleave_pad_added(GstElement *elem, GstPad *pad, gpointer data)
{
- mm_player_t *player = (mm_player_t *)data;
- MMPlayerGstElement *audiobin = player->pipeline->audiobin;
+ mmplayer_t *player = (mmplayer_t *)data;
+ mmplayer_gst_element_t *audiobin = player->pipeline->audiobin;
GstPad *sinkpad = NULL;
GstElement *queue = NULL, *sink = NULL;
}
void
-__mmplayer_gst_set_pulsesink_property(mm_player_t *player, MMHandleType attrs)
+__mmplayer_gst_set_pulsesink_property(mmplayer_t *player, MMHandleType attrs)
{
#define MAX_PROPS_LEN 128
gint latency_mode = 0;
}
void
-__mmplayer_gst_set_openalsink_property(mm_player_t *player)
+__mmplayer_gst_set_openalsink_property(mmplayer_t *player)
{
- MMPlayerGstElement *audiobin = NULL;
+ mmplayer_gst_element_t *audiobin = NULL;
MMPLAYER_FENTER();
MMPLAYER_RETURN_IF_FAIL(player && player->pipeline && player->pipeline->audiobin);
}
static int
-__mmplayer_gst_fill_audio_bucket(mm_player_t *player, GList **bucket)
+__mmplayer_gst_fill_audio_bucket(mmplayer_t *player, GList **bucket)
{
- MMPlayerGstElement *audiobin = NULL;
+ mmplayer_gst_element_t *audiobin = NULL;
MMHandleType attrs = 0;
GList *element_bucket = NULL;
GstCaps *acaps = NULL;
}
static int
-__mmplayer_gst_create_audio_sink_bin(mm_player_t *player)
+__mmplayer_gst_create_audio_sink_bin(mmplayer_t *player)
{
- MMPlayerGstElement *first_element = NULL;
- MMPlayerGstElement *audiobin = NULL;
+ mmplayer_gst_element_t *first_element = NULL;
+ mmplayer_gst_element_t *audiobin = NULL;
GstPad *pad = NULL;
GstPad *ghostpad = NULL;
GList *element_bucket = NULL;
MMPLAYER_RETURN_VAL_IF_FAIL(player && player->pipeline, MM_ERROR_PLAYER_NOT_INITIALIZED);
/* alloc handles */
- audiobin = (MMPlayerGstElement *)g_try_malloc0(sizeof(MMPlayerGstElement) * MMPLAYER_A_NUM);
+ audiobin = (mmplayer_gst_element_t *)g_try_malloc0(sizeof(mmplayer_gst_element_t) * MMPLAYER_A_NUM);
if (!audiobin) {
LOGE("failed to allocate memory for audiobin");
return MM_ERROR_PLAYER_NO_FREE_SPACE;
goto ERROR;
/* get first element's sinkpad for creating ghostpad */
- first_element = (MMPlayerGstElement *)element_bucket->data;
+ first_element = (mmplayer_gst_element_t *)element_bucket->data;
if (!first_element) {
LOGE("failed to get first elem");
goto ERROR;
}
int
-_mmplayer_video_stream_release_bo(mm_player_t *player, void *bo)
+_mmplayer_video_stream_release_bo(mmplayer_t *player, void *bo)
{
int ret = MM_ERROR_NONE;
GList *l = NULL;
if (player->video_bo_list) {
for (l = g_list_first(player->video_bo_list); l; l = g_list_next(l)) {
- mm_player_video_bo_info_t *tmp = (mm_player_video_bo_info_t *)l->data;
+ mmplayer_video_bo_info_t *tmp = (mmplayer_video_bo_info_t *)l->data;
if (tmp && tmp->bo == bo) {
tmp->used = FALSE;
LOGD("release bo %p", bo);
}
static void
-__mmplayer_video_stream_destroy_bo_list(mm_player_t *player)
+__mmplayer_video_stream_destroy_bo_list(mmplayer_t *player)
{
GList *l = NULL;
if (player->video_bo_list) {
LOGD("destroy video_bo_list : %d", g_list_length(player->video_bo_list));
for (l = g_list_first(player->video_bo_list); l; l = g_list_next(l)) {
- mm_player_video_bo_info_t *tmp = (mm_player_video_bo_info_t *)l->data;
+ mmplayer_video_bo_info_t *tmp = (mmplayer_video_bo_info_t *)l->data;
if (tmp) {
if (tmp->bo)
tbm_bo_unref(tmp->bo);
}
static void *
-__mmplayer_video_stream_get_bo(mm_player_t *player, int size)
+__mmplayer_video_stream_get_bo(mmplayer_t *player, int size)
{
GList *l = NULL;
MMPLAYER_RETURN_VAL_IF_FAIL(player, NULL);
}
for (; idx < player->ini.num_of_video_bo; idx++) {
- mm_player_video_bo_info_t *bo_info = g_new(mm_player_video_bo_info_t, 1);
+ mmplayer_video_bo_info_t *bo_info = g_new(mmplayer_video_bo_info_t, 1);
if (!bo_info) {
LOGE("Fail to alloc bo_info.");
break;
while (TRUE) {
/* get bo from list*/
for (l = g_list_first(player->video_bo_list); l; l = g_list_next(l)) {
- mm_player_video_bo_info_t *tmp = (mm_player_video_bo_info_t *)l->data;
+ mmplayer_video_bo_info_t *tmp = (mmplayer_video_bo_info_t *)l->data;
if (tmp && (tmp->used == FALSE)) {
LOGD("found bo %p to use", tmp->bo);
tmp->used = TRUE;
static void
__mmplayer_video_stream_decoded_preroll_cb(GstElement *object, GstBuffer *buffer, GstPad *pad, gpointer data)
{
- mm_player_t *player = (mm_player_t *)data;
+ mmplayer_t *player = (mmplayer_t *)data;
MMPLAYER_FENTER();
MMPLAYER_RETURN_IF_FAIL(player && player->video_stream_cb);
static void
__mmplayer_video_stream_decoded_render_cb(GstElement *object, GstBuffer *buffer, GstPad *pad, gpointer data)
{
- mm_player_t *player = (mm_player_t *)data;
- MMPlayerVideoStreamDataType *stream = NULL;
+ mmplayer_t *player = (mmplayer_t *)data;
+ mmplayer_video_decoded_data_info_t *stream = NULL;
GstMemory *mem = NULL;
MMPLAYER_FENTER();
}
static void
-__mmplayer_gst_set_video360_property(mm_player_t *player)
+__mmplayer_gst_set_video360_property(mmplayer_t *player)
{
- MMPlayerGstElement *videobin = NULL;
+ mmplayer_gst_element_t *videobin = NULL;
MMPLAYER_FENTER();
MMPLAYER_RETURN_IF_FAIL(player && player->pipeline && player->pipeline->videobin);
}
static int
-__mmplayer_gst_create_video_filters(mm_player_t *player, MMDisplaySurfaceType surface_type, GList **bucket)
+__mmplayer_gst_create_video_filters(mmplayer_t *player, MMDisplaySurfaceType surface_type, GList **bucket)
{
gchar *video_csc = "videoconvert"; /* default colorspace converter */
GList *element_bucket = NULL;
}
static gchar *
-__mmplayer_get_videosink_factory_name(mm_player_t *player, MMDisplaySurfaceType surface_type)
+__mmplayer_get_videosink_factory_name(mmplayer_t *player, MMDisplaySurfaceType surface_type)
{
gchar *factory_name = NULL;
}
static int
-__mmplayer_gst_set_videosink_property(mm_player_t *player, MMDisplaySurfaceType surface_type)
+__mmplayer_gst_set_videosink_property(mmplayer_t *player, MMDisplaySurfaceType surface_type)
{
gchar *factory_name = NULL;
- MMPlayerGstElement *videobin = NULL;
+ mmplayer_gst_element_t *videobin = NULL;
MMHandleType attrs;
int gapless = 0;
* - video overlay surface(arm/x86) : tizenwlsink
*/
static int
-__mmplayer_gst_create_video_sink_bin(mm_player_t *player, GstCaps *caps, MMDisplaySurfaceType surface_type)
+__mmplayer_gst_create_video_sink_bin(mmplayer_t *player, GstCaps *caps, MMDisplaySurfaceType surface_type)
{
GstPad *pad = NULL;
GList *element_bucket = NULL;
- MMPlayerGstElement *first_element = NULL;
- MMPlayerGstElement *videobin = NULL;
+ mmplayer_gst_element_t *first_element = NULL;
+ mmplayer_gst_element_t *videobin = NULL;
gchar *videosink_factory_name = NULL;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player && player->pipeline, MM_ERROR_PLAYER_NOT_INITIALIZED);
/* alloc handles */
- videobin = (MMPlayerGstElement *)g_try_malloc0(sizeof(MMPlayerGstElement) * MMPLAYER_V_NUM);
+ videobin = (mmplayer_gst_element_t *)g_try_malloc0(sizeof(mmplayer_gst_element_t) * MMPLAYER_V_NUM);
if (!videobin)
return MM_ERROR_PLAYER_NO_FREE_SPACE;
}
/* get first element's sinkpad for creating ghostpad */
- first_element = (MMPlayerGstElement *)element_bucket->data;
+ first_element = (mmplayer_gst_element_t *)element_bucket->data;
if (!first_element) {
LOGE("failed to get first element from bucket");
goto ERROR;
}
static int
-__mmplayer_gst_create_plain_text_elements(mm_player_t *player)
+__mmplayer_gst_create_plain_text_elements(mmplayer_t *player)
{
GList *element_bucket = NULL;
- MMPlayerGstElement *textbin = player->pipeline->textbin;
+ mmplayer_gst_element_t *textbin = player->pipeline->textbin;
MMPLAYER_CREATE_ELEMENT(textbin, MMPLAYER_T_QUEUE, "queue", "text_queue", TRUE, player);
MMPLAYER_CREATE_ELEMENT(textbin, MMPLAYER_T_IDENTITY, "identity", "text_identity", TRUE, player);
}
static int
-__mmplayer_gst_create_text_sink_bin(mm_player_t *player)
+__mmplayer_gst_create_text_sink_bin(mmplayer_t *player)
{
- MMPlayerGstElement *textbin = NULL;
+ mmplayer_gst_element_t *textbin = NULL;
GList *element_bucket = NULL;
int surface_type = 0;
gint i = 0;
MMPLAYER_RETURN_VAL_IF_FAIL(player && player->pipeline, MM_ERROR_PLAYER_NOT_INITIALIZED);
/* alloc handles */
- textbin = (MMPlayerGstElement *)g_try_malloc0(sizeof(MMPlayerGstElement) * MMPLAYER_T_NUM);
+ textbin = (mmplayer_gst_element_t *)g_try_malloc0(sizeof(mmplayer_gst_element_t) * MMPLAYER_T_NUM);
if (!textbin) {
LOGE("failed to allocate memory for textbin");
return MM_ERROR_PLAYER_NO_FREE_SPACE;
}
static int
-__mmplayer_gst_create_text_pipeline(mm_player_t *player)
+__mmplayer_gst_create_text_pipeline(mmplayer_t *player)
{
- MMPlayerGstElement *mainbin = NULL;
- MMPlayerGstElement *textbin = NULL;
+ mmplayer_gst_element_t *mainbin = NULL;
+ mmplayer_gst_element_t *textbin = NULL;
MMHandleType attrs = 0;
GstElement *subsrc = NULL;
GstElement *subparse = NULL;
gboolean
__mmplayer_update_subtitle(GstElement *object, GstBuffer *buffer, GstPad *pad, gpointer data)
{
- mm_player_t *player = (mm_player_t *)data;
+ mmplayer_t *player = (mmplayer_t *)data;
MMMessageParamType msg = {0, };
GstClockTime duration = 0;
gpointer text = NULL;
static GstPadProbeReturn
__mmplayer_subtitle_adjust_position_probe(GstPad *pad, GstPadProbeInfo *info, gpointer u_data)
{
- mm_player_t *player = (mm_player_t *)u_data;
+ mmplayer_t *player = (mmplayer_t *)u_data;
GstClockTime cur_timestamp = 0;
gint64 adjusted_timestamp = 0;
GstBuffer *buffer = gst_pad_probe_info_get_buffer(info);
}
static int
-__mmplayer_gst_adjust_subtitle_position(mm_player_t *player, int format, int position)
+__mmplayer_gst_adjust_subtitle_position(mmplayer_t *player, int position)
{
MMPLAYER_FENTER();
return MM_ERROR_NONE;
}
- switch (format) {
- case MM_PLAYER_POS_FORMAT_TIME:
- {
- /* check current postion */
- player->adjust_subtitle_pos = position;
+ /* check current postion */
+ player->adjust_subtitle_pos = position;
- LOGD("save adjust_subtitle_pos in player") ;
- }
- break;
-
- default:
- {
- LOGW("invalid format.");
- MMPLAYER_FLEAVE();
- return MM_ERROR_INVALID_ARGUMENT;
- }
- }
+ LOGD("save adjust_subtitle_pos in player");
MMPLAYER_FLEAVE();
* @see
*/
static int
-__mmplayer_gst_create_pipeline(mm_player_t *player)
+__mmplayer_gst_create_pipeline(mmplayer_t *player)
{
int ret = MM_ERROR_NONE;
- MMPlayerGstElement *mainbin = NULL;
+ mmplayer_gst_element_t *mainbin = NULL;
MMHandleType attrs = 0;
MMPLAYER_FENTER();
goto INIT_ERROR;
}
- player->pipeline = (MMPlayerGstPipelineInfo *)g_malloc0(sizeof(MMPlayerGstPipelineInfo));
+ player->pipeline = (mmplayer_pipeline_info_t *)g_malloc0(sizeof(mmplayer_pipeline_info_t));
if (player->pipeline == NULL)
goto INIT_ERROR;
/* create mainbin */
- mainbin = (MMPlayerGstElement *)g_try_malloc0(sizeof(MMPlayerGstElement) * MMPLAYER_M_NUM);
+ mainbin = (mmplayer_gst_element_t *)g_try_malloc0(sizeof(mmplayer_gst_element_t) * MMPLAYER_M_NUM);
if (mainbin == NULL)
goto INIT_ERROR;
}
static void
-__mmplayer_reset_gapless_state(mm_player_t *player)
+__mmplayer_reset_gapless_state(mmplayer_t *player)
{
MMPLAYER_FENTER();
MMPLAYER_RETURN_IF_FAIL(player
&& player->pipeline->audiobin
&& player->pipeline->audiobin[MMPLAYER_A_BIN].gst);
- memset(&player->gapless, 0, sizeof(mm_player_gapless_t));
+ memset(&player->gapless, 0, sizeof(mmplayer_gapless_t));
MMPLAYER_FLEAVE();
return;
}
static int
-__mmplayer_gst_destroy_pipeline(mm_player_t *player)
+__mmplayer_gst_destroy_pipeline(mmplayer_t *player)
{
gint timeout = 0;
int ret = MM_ERROR_NONE;
/* cleanup gst stuffs */
if (player->pipeline) {
- MMPlayerGstElement *mainbin = player->pipeline->mainbin;
+ mmplayer_gst_element_t *mainbin = player->pipeline->mainbin;
GstTagList *tag_list = player->pipeline->tag_list;
/* first we need to disconnect all signal hander */
__mmplayer_release_signal_connection(player, MM_PLAYER_SIGNAL_TYPE_ALL);
if (mainbin) {
- MMPlayerGstElement *audiobin = player->pipeline->audiobin;
- MMPlayerGstElement *videobin = player->pipeline->videobin;
- MMPlayerGstElement *textbin = player->pipeline->textbin;
+ mmplayer_gst_element_t *audiobin = player->pipeline->audiobin;
+ mmplayer_gst_element_t *videobin = player->pipeline->videobin;
+ mmplayer_gst_element_t *textbin = player->pipeline->textbin;
GstBus *bus = gst_pipeline_get_bus(GST_PIPELINE(mainbin[MMPLAYER_M_PIPE].gst));
gst_bus_set_sync_handler(bus, NULL, NULL, NULL);
gst_object_unref(bus);
}
static int
-__mmplayer_gst_realize(mm_player_t *player)
+__mmplayer_gst_realize(mmplayer_t *player)
{
gint timeout = 0;
int ret = MM_ERROR_NONE;
}
static int
-__mmplayer_gst_unrealize(mm_player_t *player)
+__mmplayer_gst_unrealize(mmplayer_t *player)
{
int ret = MM_ERROR_NONE;
}
static int
-__mmplayer_gst_set_message_callback(mm_player_t *player, MMMessageCallback callback, gpointer user_param)
+__mmplayer_gst_set_message_callback(mmplayer_t *player, MMMessageCallback callback, gpointer user_param)
{
MMPLAYER_FENTER();
}
int
-__mmplayer_parse_profile(const char *uri, void *param, MMPlayerParseProfile *data)
+__mmplayer_parse_profile(const char *uri, void *param, mmplayer_parse_profile_t *data)
{
int ret = MM_ERROR_NONE;
char *path = NULL;
MMPLAYER_RETURN_VAL_IF_FAIL(data, MM_ERROR_PLAYER_INTERNAL);
MMPLAYER_RETURN_VAL_IF_FAIL((strlen(uri) <= MM_MAX_URL_LEN), MM_ERROR_PLAYER_INVALID_URI);
- memset(data, 0, sizeof(MMPlayerParseProfile));
+ memset(data, 0, sizeof(mmplayer_parse_profile_t));
if (strstr(uri, "es_buff://")) {
__mmplayer_copy_uri_and_set_type(data, uri, MM_PLAYER_URI_TYPE_MS_BUFF);
}
static gboolean
-__mmplayer_can_do_interrupt(mm_player_t *player)
+__mmplayer_can_do_interrupt(mmplayer_t *player)
{
if (!player || !player->pipeline || !player->attrs) {
LOGW("not initialized");
__resource_release_cb(mm_resource_manager_h rm, mm_resource_manager_res_h res,
void *user_data)
{
- mm_player_t *player = NULL;
+ mmplayer_t *player = NULL;
MMPLAYER_FENTER();
LOGE("- user_data is null");
return FALSE;
}
- player = (mm_player_t *)user_data;
+ player = (mmplayer_t *)user_data;
/* do something to release resource here.
* player stop and interrupt forwarding */
}
static void
-__mmplayer_initialize_video_roi(mm_player_t *player)
+__mmplayer_initialize_video_roi(mmplayer_t *player)
{
player->video_roi.scale_x = 0.0;
player->video_roi.scale_y = 0.0;
int ret = MM_ERROR_PLAYER_INTERNAL;
bool enabled = false;
- mm_player_t *player = MM_PLAYER_CAST(handle);
+ mmplayer_t *player = MM_PLAYER_CAST(handle);
MMPLAYER_FENTER();
}
static gboolean
-__mmplayer_init_gstreamer(mm_player_t *player)
+__mmplayer_init_gstreamer(mmplayer_t *player)
{
static gboolean initialized = FALSE;
static const int max_argc = 50;
}
static void
-__mmplayer_check_async_state_transition(mm_player_t *player)
+__mmplayer_check_async_state_transition(mmplayer_t *player)
{
GstState element_state = GST_STATE_VOID_PENDING;
GstState element_pending_state = GST_STATE_VOID_PENDING;
int
_mmplayer_destroy(MMHandleType handle)
{
- mm_player_t *player = MM_PLAYER_CAST(handle);
+ mmplayer_t *player = MM_PLAYER_CAST(handle);
MMPLAYER_FENTER();
int
_mmplayer_realize(MMHandleType hplayer)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
char *uri = NULL;
void *param = NULL;
MMHandleType attrs = 0;
int
_mmplayer_unrealize(MMHandleType hplayer)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
int ret = MM_ERROR_NONE;
MMPLAYER_FENTER();
int
_mmplayer_set_message_callback(MMHandleType hplayer, MMMessageCallback callback, gpointer user_param)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
int
_mmplayer_get_state(MMHandleType hplayer, int *state)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
MMPLAYER_RETURN_VAL_IF_FAIL(state, MM_ERROR_INVALID_ARGUMENT);
int
-_mmplayer_set_volume(MMHandleType hplayer, MMPlayerVolumeType volume)
+_mmplayer_set_volume(MMHandleType hplayer, mmplayer_volume_type_t volume)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
GstElement *vol_element = NULL;
int i = 0;
}
int
-_mmplayer_get_volume(MMHandleType hplayer, MMPlayerVolumeType *volume)
+_mmplayer_get_volume(MMHandleType hplayer, mmplayer_volume_type_t *volume)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
int i = 0;
MMPLAYER_FENTER();
int
_mmplayer_set_mute(MMHandleType hplayer, int mute)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
GstElement *vol_element = NULL;
MMPLAYER_FENTER();
int
_mmplayer_get_mute(MMHandleType hplayer, int *pmute)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
MMPLAYER_FENTER();
int
_mmplayer_set_videostream_changed_cb(MMHandleType hplayer, mm_player_stream_changed_callback callback, void *user_param)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
MMPLAYER_FENTER();
int
_mmplayer_set_audiostream_changed_cb(MMHandleType hplayer, mm_player_stream_changed_callback callback, void *user_param)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
MMPLAYER_FENTER();
int
_mmplayer_set_audiostream_cb(MMHandleType hplayer, bool sync, mm_player_audio_stream_callback callback, void *user_param)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
MMPLAYER_FENTER();
int
_mmplayer_set_videostream_cb(MMHandleType hplayer, mm_player_video_stream_callback callback, void *user_param)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
MMPLAYER_FENTER();
int
_mmplayer_start(MMHandleType hplayer)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
gint ret = MM_ERROR_NONE;
MMPLAYER_FENTER();
* Because GST_ERROR_MESSAGE is posted by other plugin internally.
*/
int
-__mmplayer_handle_missed_plugin(mm_player_t *player)
+__mmplayer_handle_missed_plugin(mmplayer_t *player)
{
MMMessageParamType msg_param;
memset(&msg_param, 0, sizeof(MMMessageParamType));
}
static void
-__mmplayer_check_pipeline(mm_player_t *player)
+__mmplayer_check_pipeline(mmplayer_t *player)
{
GstState element_state = GST_STATE_VOID_PENDING;
GstState element_pending_state = GST_STATE_VOID_PENDING;
int
_mmplayer_stop(MMHandleType hplayer)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
int ret = MM_ERROR_NONE;
MMPLAYER_FENTER();
int
_mmplayer_pause(MMHandleType hplayer)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
gint64 pos_nsec = 0;
gboolean async = FALSE;
gint ret = MM_ERROR_NONE;
int
_mmplayer_abort_pause(MMHandleType hplayer)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
int ret = MM_ERROR_NONE;
MMPLAYER_FENTER();
int
_mmplayer_resume(MMHandleType hplayer)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
int ret = MM_ERROR_NONE;
gboolean async = FALSE;
int
_mmplayer_set_playspeed(MMHandleType hplayer, float rate, bool streaming)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
gint64 pos_nsec = 0;
int ret = MM_ERROR_NONE;
int mute = FALSE;
signed long long start = 0, stop = 0;
- MMPlayerStateType current_state = MM_PLAYER_STATE_NONE;
+ mmplayer_state_e current_state = MM_PLAYER_STATE_NONE;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player && player->pipeline, MM_ERROR_PLAYER_NOT_INITIALIZED);
int
_mmplayer_set_position(MMHandleType hplayer, gint64 position)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
int ret = MM_ERROR_NONE;
MMPLAYER_FENTER();
int
_mmplayer_get_position(MMHandleType hplayer, gint64 *position)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
int ret = MM_ERROR_NONE;
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
int
_mmplayer_get_duration(MMHandleType hplayer, gint64 *duration)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
int ret = MM_ERROR_NONE;
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
int
_mmplayer_get_buffer_position(MMHandleType hplayer, int *start_pos, int *end_pos)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
int ret = MM_ERROR_NONE;
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
}
int
-_mmplayer_adjust_subtitle_postion(MMHandleType hplayer, int format, int position)
+_mmplayer_adjust_subtitle_postion(MMHandleType hplayer, int position)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
int ret = MM_ERROR_NONE;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
- ret = __mmplayer_gst_adjust_subtitle_position(player, format, position);
+ ret = __mmplayer_gst_adjust_subtitle_position(player, position);
MMPLAYER_FLEAVE();
}
static void
-__mmplayer_set_audio_attrs(mm_player_t *player, GstCaps *caps)
+__mmplayer_set_audio_attrs(mmplayer_t *player, GstCaps *caps)
{
GstStructure *caps_structure = NULL;
gint samplerate = 0;
}
static void
-__mmplayer_update_content_type_info(mm_player_t *player)
+__mmplayer_update_content_type_info(mmplayer_t *player)
{
MMPLAYER_FENTER();
MMPLAYER_RETURN_IF_FAIL(player && player->type);
__mmplayer_typefind_have_type(GstElement *tf, guint probability,
GstCaps *caps, gpointer data)
{
- mm_player_t *player = (mm_player_t *)data;
+ mmplayer_t *player = (mmplayer_t *)data;
GstPad *pad = NULL;
MMPLAYER_FENTER();
}
GstElement *
-__mmplayer_gst_make_decodebin(mm_player_t *player)
+__mmplayer_gst_make_decodebin(mmplayer_t *player)
{
GstElement *decodebin = NULL;
}
static GstElement *
-__mmplayer_gst_make_queue2(mm_player_t *player)
+__mmplayer_gst_make_queue2(mmplayer_t *player)
{
GstElement *queue2 = NULL;
gint64 dur_bytes = 0L;
- MMPlayerGstElement *mainbin = NULL;
- MuxedBufferType type = MUXED_BUFFER_TYPE_MEM_QUEUE;
+ mmplayer_gst_element_t *mainbin = NULL;
+ muxed_buffer_type_e type = MUXED_BUFFER_TYPE_MEM_QUEUE;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player && player->pipeline && player->pipeline->mainbin, NULL);
}
gboolean
-__mmplayer_gst_create_decoder(mm_player_t *player, GstPad *srcpad, const GstCaps *caps)
+__mmplayer_gst_create_decoder(mmplayer_t *player, GstPad *srcpad, const GstCaps *caps)
{
- MMPlayerGstElement *mainbin = NULL;
+ mmplayer_gst_element_t *mainbin = NULL;
GstElement *decodebin = NULL;
GstElement *queue2 = NULL;
GstPad *sinkpad = NULL;
}
static int
-__mmplayer_check_not_supported_codec(mm_player_t *player, const gchar *factory_class, const gchar *mime)
+__mmplayer_check_not_supported_codec(mmplayer_t *player, const gchar *factory_class, const gchar *mime)
{
MMPLAYER_FENTER();
static void
__mmplayer_pipeline_complete(GstElement *decodebin, gpointer data)
{
- mm_player_t *player = (mm_player_t *)data;
+ mmplayer_t *player = (mmplayer_t *)data;
MMPLAYER_FENTER();
}
static gboolean
-__mmplayer_get_next_uri(mm_player_t *player)
+__mmplayer_get_next_uri(mmplayer_t *player)
{
- MMPlayerParseProfile profile;
+ mmplayer_parse_profile_t profile;
gint uri_idx = 0;
guint num_of_list = 0;
char *uri = NULL;
}
static gboolean
-__mmplayer_verify_gapless_play_path(mm_player_t *player)
+__mmplayer_verify_gapless_play_path(mmplayer_t *player)
{
#define REPEAT_COUNT_INFINITELY -1
#define REPEAT_COUNT_MIN 2
}
static void
-__mmplayer_initialize_gapless_play(mm_player_t *player)
+__mmplayer_initialize_gapless_play(mmplayer_t *player)
{
int i;
}
static void
-__mmplayer_activate_next_source(mm_player_t *player, GstState target)
+__mmplayer_activate_next_source(mmplayer_t *player, GstState target)
{
- MMPlayerGstElement *mainbin = NULL;
+ mmplayer_gst_element_t *mainbin = NULL;
MMMessageParamType msg_param = {0,};
GstElement *element = NULL;
MMHandleType attrs = 0;
char *uri = NULL;
- enum MainElementID elem_idx = MMPLAYER_M_NUM;
+ main_element_id_e elem_idx = MMPLAYER_M_NUM;
MMPLAYER_FENTER();
}
static gboolean
-__mmplayer_deactivate_selector(mm_player_t *player, MMPlayerTrackType type)
+__mmplayer_deactivate_selector(mmplayer_t *player, mmplayer_track_type_e type)
{
- mm_player_selector_t *selector = &player->selector[type];
- MMPlayerGstElement *sinkbin = NULL;
- enum MainElementID selectorId = MMPLAYER_M_NUM;
- enum MainElementID sinkId = MMPLAYER_M_NUM;
+ mmplayer_selector_t *selector = &player->selector[type];
+ mmplayer_gst_element_t *sinkbin = NULL;
+ main_element_id_e selectorId = MMPLAYER_M_NUM;
+ main_element_id_e sinkId = MMPLAYER_M_NUM;
GstPad *srcpad = NULL;
GstPad *sinkpad = NULL;
gboolean send_notice = FALSE;
}
static void
-__mmplayer_deactivate_old_path(mm_player_t *player)
+__mmplayer_deactivate_old_path(mmplayer_t *player)
{
MMPLAYER_FENTER();
MMPLAYER_RETURN_IF_FAIL(player);
_mmplayer_set_uri(MMHandleType hplayer, const char *uri)
{
int result = MM_ERROR_NONE;
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
int
_mmplayer_set_next_uri(MMHandleType hplayer, const char *uri, bool is_first_path)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
guint num_of_list = 0;
MMPLAYER_FENTER();
int
_mmplayer_get_next_uri(MMHandleType hplayer, char **uri)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
char *next_uri = NULL;
guint num_of_list = 0;
__mmplayer_gst_decode_unknown_type(GstElement *elem, GstPad *pad,
GstCaps *caps, gpointer data)
{
- mm_player_t *player = (mm_player_t *)data;
+ mmplayer_t *player = (mmplayer_t *)data;
const gchar *klass = NULL;
const gchar *mime = NULL;
gchar *caps_str = NULL;
__mmplayer_gst_decode_autoplug_continue(GstElement *bin, GstPad *pad,
GstCaps *caps, gpointer data)
{
- mm_player_t *player = (mm_player_t *)data;
+ mmplayer_t *player = (mmplayer_t *)data;
const char *mime = NULL;
gboolean ret = TRUE;
}
static gboolean
-__mmplayer_is_audio_offload_device_type(mm_player_t *player)
+__mmplayer_is_audio_offload_device_type(mmplayer_t *player)
{
gboolean ret = TRUE;
GDBusConnection *conn = NULL;
return ret;
}
-static void __mmplayer_rebuild_audio_pipeline(mm_player_t *player)
+static void __mmplayer_rebuild_audio_pipeline(mmplayer_t *player)
{
- MMPlayerStateType current_state = MM_PLAYER_STATE_NONE;
+ mmplayer_state_e current_state = MM_PLAYER_STATE_NONE;
gint64 position = 0;
MMPLAYER_RETURN_IF_FAIL(player && player->attrs &&
void __mmplayer_audio_device_connected_cb(MMSoundDevice_t device_h, bool is_connected, void *user_data)
{
- mm_player_t *player = (mm_player_t *)user_data;
+ mmplayer_t *player = (mmplayer_t *)user_data;
mm_sound_device_type_e dev_type = MM_SOUND_DEVICE_TYPE_BUILTIN_SPEAKER;
gboolean is_supportable = FALSE;
}
static gboolean
-__mmplayer_add_audio_device_connected_cb(mm_player_t *player)
+__mmplayer_add_audio_device_connected_cb(mmplayer_t *player)
{
unsigned int id = 0;
}
static gboolean
-__mmplayer_can_build_audio_offload_path(mm_player_t *player)
+__mmplayer_can_build_audio_offload_path(mmplayer_t *player)
{
gboolean ret = FALSE;
GstElementFactory *factory = NULL;
}
static GstAutoplugSelectResult
-__mmplayer_check_codec_info(mm_player_t *player, const char *klass, GstCaps *caps, char *factory_name)
+__mmplayer_check_codec_info(mmplayer_t *player, const char *klass, GstCaps *caps, char *factory_name)
{
GstAutoplugSelectResult ret = GST_AUTOPLUG_SELECT_TRY;
int idx = 0;
GstCaps *caps, GstElementFactory *factory, gpointer data)
{
GstAutoplugSelectResult result = GST_AUTOPLUG_SELECT_TRY;
- mm_player_t *player = (mm_player_t *)data;
+ mmplayer_t *player = (mmplayer_t *)data;
gchar *factory_name = NULL;
gchar *caps_str = NULL;
__mmplayer_gst_decode_pad_removed(GstElement *elem, GstPad *new_pad,
gpointer data)
{
- //mm_player_t *player = (mm_player_t *)data;
+ //mmplayer_t *player = (mmplayer_t *)data;
GstCaps *caps = NULL;
LOGD("[Decodebin2] pad-removed signal");
static void
__mmplayer_gst_decode_drained(GstElement *bin, gpointer data)
{
- mm_player_t *player = (mm_player_t *)data;
+ mmplayer_t *player = (mmplayer_t *)data;
GstIterator *iter = NULL;
GValue item = { 0, };
GstPad *pad = NULL;
void
__mmplayer_gst_element_added(GstElement *bin, GstElement *element, gpointer data)
{
- mm_player_t *player = (mm_player_t *)data;
+ mmplayer_t *player = (mmplayer_t *)data;
const gchar *klass = NULL;
gchar *factory_name = NULL;
}
static void
-__mmplayer_release_misc(mm_player_t *player)
+__mmplayer_release_misc(mmplayer_t *player)
{
int i;
bool cur_mode = player->set_mode.rich_audio;
player->has_closed_caption = FALSE;
player->set_mode.media_packet_video_stream = false;
player->profile.uri_type = MM_PLAYER_URI_TYPE_NONE;
- memset(&player->set_mode, 0, sizeof(MMPlayerSetMode));
+ memset(&player->set_mode, 0, sizeof(mmplayer_setting_mode_t));
/* recover mode */
player->set_mode.rich_audio = cur_mode;
}
static void
-__mmplayer_release_misc_post(mm_player_t *player)
+__mmplayer_release_misc_post(mmplayer_t *player)
{
char *original_uri = NULL;
MMPLAYER_FENTER();
}
gboolean
-__mmplayer_check_subtitle(mm_player_t *player)
+__mmplayer_check_subtitle(mmplayer_t *player)
{
MMHandleType attrs = 0;
char *subtitle_uri = NULL;
}
void
-__mmplayer_cancel_eos_timer(mm_player_t *player)
+__mmplayer_cancel_eos_timer(mmplayer_t *player)
{
MMPLAYER_RETURN_IF_FAIL(player);
}
static void
-__mmplayer_add_sink(mm_player_t *player, GstElement *sink)
+__mmplayer_add_sink(mmplayer_t *player, GstElement *sink)
{
MMPLAYER_FENTER();
}
static void
-__mmplayer_del_sink(mm_player_t *player, GstElement *sink)
+__mmplayer_del_sink(mmplayer_t *player, GstElement *sink)
{
MMPLAYER_FENTER();
}
void
-__mmplayer_add_signal_connection(mm_player_t *player, GObject *object,
- MMPlayerSignalType type, const gchar *signal, GCallback cb_funct, gpointer u_data)
+__mmplayer_add_signal_connection(mmplayer_t *player, GObject *object,
+ mmplayer_signal_type_e type, const gchar *signal, GCallback cb_funct, gpointer u_data)
{
- MMPlayerSignalItem *item = NULL;
+ mmplayer_signal_item_t *item = NULL;
MMPLAYER_FENTER();
MMPLAYER_RETURN_IF_FAIL(player);
return;
}
- item = (MMPlayerSignalItem *)g_try_malloc(sizeof(MMPlayerSignalItem));
+ item = (mmplayer_signal_item_t *)g_try_malloc(sizeof(mmplayer_signal_item_t));
if (!item) {
LOGE("cannot connect signal [%s]", signal);
return;
* g_signal_handler_disconnect(instance, id);
*/
static void
-__mmplayer_release_signal_connection(mm_player_t *player, MMPlayerSignalType type)
+__mmplayer_release_signal_connection(mmplayer_t *player, mmplayer_signal_type_e type)
{
GList *sig_list = NULL;
- MMPlayerSignalItem *item = NULL;
+ mmplayer_signal_item_t *item = NULL;
MMPLAYER_FENTER();
int
_mmplayer_change_videosink(MMHandleType handle, MMDisplaySurfaceType surface_type, void *display_overlay)
{
- mm_player_t *player = 0;
+ mmplayer_t *player = 0;
int prev_display_surface_type = 0;
void *prev_display_overlay = NULL;
int
_mmplayer_set_subtitle_silent(MMHandleType hplayer, int silent)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
MMPLAYER_FENTER();
}
int
-_mmplayer_sync_subtitle_pipeline(mm_player_t *player)
+_mmplayer_sync_subtitle_pipeline(mmplayer_t *player)
{
- MMPlayerGstElement *mainbin = NULL;
- MMPlayerGstElement *textbin = NULL;
+ mmplayer_gst_element_t *mainbin = NULL;
+ mmplayer_gst_element_t *textbin = NULL;
GstStateChangeReturn ret = GST_STATE_CHANGE_FAILURE;
GstState current_state = GST_STATE_VOID_PENDING;
GstState element_state = GST_STATE_VOID_PENDING;
}
static int
-__mmplayer_change_external_subtitle_language(mm_player_t *player, const char *filepath)
+__mmplayer_change_external_subtitle_language(mmplayer_t *player, const char *filepath)
{
GstStateChangeReturn ret = GST_STATE_CHANGE_FAILURE;
GstState current_state = GST_STATE_VOID_PENDING;
MMHandleType attrs = 0;
- MMPlayerGstElement *mainbin = NULL;
- MMPlayerGstElement *textbin = NULL;
+ mmplayer_gst_element_t *mainbin = NULL;
+ mmplayer_gst_element_t *textbin = NULL;
gchar *subtitle_uri = NULL;
int result = MM_ERROR_NONE;
_mmplayer_set_external_subtitle_path(MMHandleType hplayer, const char *filepath)
{
int result = MM_ERROR_NONE;
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
char *path = NULL;
MMPLAYER_FENTER();
}
static int
-__mmplayer_change_selector_pad(mm_player_t *player, MMPlayerTrackType type, int index)
+__mmplayer_change_selector_pad(mmplayer_t *player, mmplayer_track_type_e type, int index)
{
int result = MM_ERROR_NONE;
gchar *change_pad_name = NULL;
GstPad *sinkpad = NULL;
- MMPlayerGstElement *mainbin = NULL;
- enum MainElementID elem_idx = MMPLAYER_M_NUM;
+ mmplayer_gst_element_t *mainbin = NULL;
+ main_element_id_e elem_idx = MMPLAYER_M_NUM;
GstCaps *caps = NULL;
gint total_track_num = 0;
}
int
-_mmplayer_change_track_language(MMHandleType hplayer, MMPlayerTrackType type, int index)
+_mmplayer_change_track_language(MMHandleType hplayer, mmplayer_track_type_e type, int index)
{
int result = MM_ERROR_NONE;
- mm_player_t *player = NULL;
- MMPlayerGstElement *mainbin = NULL;
+ mmplayer_t *player = NULL;
+ mmplayer_gst_element_t *mainbin = NULL;
gint current_active_index = 0;
MMPLAYER_FENTER();
- player = (mm_player_t *)hplayer;
+ player = (mmplayer_t *)hplayer;
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
if (!player->pipeline) {
int
_mmplayer_get_subtitle_silent(MMHandleType hplayer, int *silent)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
MMPLAYER_FENTER();
}
static gboolean
-__mmplayer_add_dump_buffer_probe(mm_player_t *player, GstElement *element)
+__mmplayer_add_dump_buffer_probe(mmplayer_t *player, GstElement *element)
{
MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
MMPLAYER_RETURN_VAL_IF_FAIL(element, FALSE);
for (idx = 0; player->ini.dump_element_keyword[idx][0] != '\0'; idx++) {
if (g_strrstr(factory_name, player->ini.dump_element_keyword[idx])) {
LOGD("dump [%s] sink pad", player->ini.dump_element_keyword[idx]);
- mm_player_dump_t *dump_s;
- dump_s = g_try_malloc(sizeof(mm_player_dump_t));
+ mmplayer_dump_t *dump_s;
+ dump_s = g_try_malloc(sizeof(mmplayer_dump_t));
if (dump_s == NULL) {
LOGE("malloc fail");
return FALSE;
return;
for (; d_list; d_list = g_list_next(d_list)) {
- mm_player_dump_t *dump_s = d_list->data;
+ mmplayer_dump_t *dump_s = d_list->data;
if (dump_s->dump_pad) {
if (dump_s->probe_handle_id)
gst_pad_remove_probe(dump_s->dump_pad, dump_s->probe_handle_id);
int
_mmplayer_has_closed_caption(MMHandleType hplayer, bool *exist)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
MMPLAYER_FENTER();
int
_mmplayer_get_timeout(MMHandleType hplayer, int *timeout)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
MMPLAYER_FENTER();
int
_mmplayer_get_num_of_video_out_buffers(MMHandleType hplayer, int *num, int *extra_num)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
MMPLAYER_FENTER();
}
static void
-__mmplayer_initialize_storage_info(mm_player_t *player, MMPlayerPathType path_type)
+__mmplayer_initialize_storage_info(mmplayer_t *player, mmplayer_path_type_e path_type)
{
int i = 0;
MMPLAYER_FENTER();
_mmplayer_manage_external_storage_state(MMHandleType hplayer, int id, int state)
{
int ret = MM_ERROR_NONE;
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
MMMessageParamType msg_param = {0, };
MMPLAYER_FENTER();
_mmplayer_get_adaptive_variant_info(MMHandleType hplayer, int *num, char **var_info)
{
int ret = MM_ERROR_NONE;
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
int idx = 0, total = 0;
gchar *result = NULL, *tmp = NULL;
result = g_strdup("");
for (idx = 0 ; idx < total ; idx++) {
- VariantData *v_data = NULL;
+ stream_variant_t *v_data = NULL;
v_data = g_list_nth_data(player->adaptive_info.var_list, idx);
if (v_data) {
_mmplayer_set_max_adaptive_variant_limit(MMHandleType hplayer, int bandwidth, int width, int height)
{
int ret = MM_ERROR_NONE;
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
_mmplayer_get_max_adaptive_variant_limit(MMHandleType hplayer, int *bandwidth, int *width, int *height)
{
int ret = MM_ERROR_NONE;
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
_mmplayer_get_streaming_buffering_time(MMHandleType hplayer, int *prebuffer_ms, int *rebuffer_ms)
{
int ret = MM_ERROR_NONE;
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player && player->streamer, MM_ERROR_PLAYER_NOT_INITIALIZED);
}
int
-_mmplayer_set_codec_type(MMHandleType hplayer, MMPlayerStreamType stream_type, MMPlayerVideoCodecType codec_type)
+_mmplayer_set_codec_type(MMHandleType hplayer, mmplayer_stream_type_e stream_type, mmplayer_video_codec_type_e codec_type)
{
#define IDX_FIRST_SW_CODEC 0
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
const char *attr_name = (stream_type == MM_PLAYER_STREAM_TYPE_AUDIO) ? (MM_PLAYER_AUDIO_CODEC_TYPE) : (MM_PLAYER_VIDEO_CODEC_TYPE);
MMHandleType attrs = 0;
int
_mmplayer_set_replaygain_enabled(MMHandleType hplayer, bool enabled)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
GstElement *rg_vol_element = NULL;
MMPLAYER_FENTER();
int
_mmplayer_is_replaygain_enabled(MMHandleType hplayer, bool *enabled)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
GstElement *rg_vol_element = NULL;
gboolean enable = FALSE;
int
_mmplayer_set_video_roi_area(MMHandleType hplayer, double scale_x, double scale_y, double scale_width, double scale_height)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
MMHandleType attrs = 0;
void *handle = NULL;
int ret = MM_ERROR_NONE;
int
_mmplayer_get_video_roi_area(MMHandleType hplayer, double *scale_x, double *scale_y, double *scale_width, double *scale_height)
{
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
int ret = MM_ERROR_NONE;
MMPLAYER_FENTER();
}
static gboolean
-__mmplayer_update_duration_value(mm_player_t *player)
+__mmplayer_update_duration_value(mmplayer_t *player)
{
gboolean ret = FALSE;
gint64 dur_nsec = 0;
}
static gboolean
-__mmplayer_update_audio_attrs(mm_player_t *player, MMHandleType attrs)
+__mmplayer_update_audio_attrs(mmplayer_t *player, MMHandleType attrs)
{
/* update audio params
NOTE : We need original audio params and it can be only obtained from src pad of audio
}
static gboolean
-__mmplayer_update_video_attrs(mm_player_t *player, MMHandleType attrs)
+__mmplayer_update_video_attrs(mmplayer_t *player, MMHandleType attrs)
{
LOGD("try to update video attrs");
}
static gboolean
-__mmplayer_update_bitrate_attrs(mm_player_t *player, MMHandleType attrs)
+__mmplayer_update_bitrate_attrs(mmplayer_t *player, MMHandleType attrs)
{
gboolean ret = FALSE;
guint64 data_size = 0;
}
static void
-__mmplayer_copy_uri_and_set_type(MMPlayerParseProfile *data, const char *uri, int uri_type)
+__mmplayer_copy_uri_and_set_type(mmplayer_parse_profile_t *data, const char *uri, int uri_type)
{
strncpy(data->uri, uri, MM_MAX_URL_LEN - 1);
data->uri_type = uri_type;
}
static int
-__mmplayer_set_mem_uri(MMPlayerParseProfile *data, char *path, void *param)
+__mmplayer_set_mem_uri(mmplayer_parse_profile_t *data, char *path, void *param)
{
int ret = MM_ERROR_PLAYER_INVALID_URI;
int mem_size = 0;
}
static int
-__mmplayer_set_file_uri(MMPlayerParseProfile *data, const char *uri)
+__mmplayer_set_file_uri(mmplayer_parse_profile_t *data, const char *uri)
{
gchar *location = NULL;
GError *err = NULL;
return ret;
}
-static MMPlayerVideoStreamDataType *
+static mmplayer_video_decoded_data_info_t *
__mmplayer_create_stream_from_pad(GstPad *pad)
{
GstCaps *caps = NULL;
GstStructure *structure = NULL;
unsigned int fourcc = 0;
const gchar *string_format = NULL;
- MMPlayerVideoStreamDataType *stream = NULL;
+ mmplayer_video_decoded_data_info_t *stream = NULL;
gint width, height;
MMPixelFormatType format;
return NULL;
}
- stream = (MMPlayerVideoStreamDataType *)g_try_malloc0(sizeof(MMPlayerVideoStreamDataType));
+ stream = (mmplayer_video_decoded_data_info_t *)g_try_malloc0(sizeof(mmplayer_video_decoded_data_info_t));
if (!stream) {
LOGE("failed to alloc mem for video data");
return NULL;
}
static void
-__mmplayer_zerocopy_set_stride_elevation_bo(MMPlayerVideoStreamDataType *stream, GstMemory *mem)
+__mmplayer_zerocopy_set_stride_elevation_bo(mmplayer_video_decoded_data_info_t *stream, GstMemory *mem)
{
unsigned int pitch = 0;
int index = 0;
}
static gboolean
-__mmplayer_swcodec_set_stride_elevation(MMPlayerVideoStreamDataType *stream)
+__mmplayer_swcodec_set_stride_elevation(mmplayer_video_decoded_data_info_t *stream)
{
if (stream->format == MM_PIXEL_FORMAT_I420) {
int ret = TBM_SURFACE_ERROR_NONE;
}
static gboolean
-__mmplayer_swcodec_set_bo(mm_player_t *player, MMPlayerVideoStreamDataType *stream, GstMemory *mem)
+__mmplayer_swcodec_set_bo(mmplayer_t *player, mmplayer_video_decoded_data_info_t *stream, GstMemory *mem)
{
tbm_bo_handle thandle;
gboolean is_mapped;
}
static void
-__mmplayer_set_pause_state(mm_player_t *player)
+__mmplayer_set_pause_state(mmplayer_t *player)
{
if (player->sent_bos)
return;
}
static void
-__mmplayer_set_playing_state(mm_player_t *player)
+__mmplayer_set_playing_state(mmplayer_t *player)
{
gchar *audio_codec = NULL;
gdouble high_watermark;
} streaming_buffer_info_t;
-static void streaming_set_buffer_watermark(mm_player_streaming_t *streamer, BufferType type, gdouble low_watermark, gdouble high_watermark);
-static void streaming_set_queue2_queue_type(mm_player_streaming_t *streamer, MuxedBufferType type);
-static void streaming_set_buffer_size(mm_player_streaming_t *streamer, BufferType type, guint buffering_bytes, gint buffering_time);
-static void streaming_update_buffering_status(mm_player_streaming_t *streamer, GstMessage *buffering_msg, gint64 position);
-static void streaming_get_current_bitrate_info(mm_player_streaming_t *streamer,
+static void streaming_set_buffer_watermark(mmplayer_streaming_t *streamer, buffer_type_e type, gdouble low_watermark, gdouble high_watermark);
+static void streaming_set_queue2_queue_type(mmplayer_streaming_t *streamer, muxed_buffer_type_e type);
+static void streaming_set_buffer_size(mmplayer_streaming_t *streamer, buffer_type_e type, guint buffering_bytes, gint buffering_time);
+static void streaming_update_buffering_status(mmplayer_streaming_t *streamer, GstMessage *buffering_msg, gint64 position);
+static void streaming_get_current_bitrate_info(mmplayer_streaming_t *streamer,
GstMessage *buffering_msg,
streaming_content_info_t content_info,
streaming_bitrate_info_t *bitrate_info);
static void
-streaming_handle_fixed_buffering_mode(mm_player_streaming_t *streamer,
+streaming_handle_fixed_buffering_mode(mmplayer_streaming_t *streamer,
gint byte_out_rate,
gint fixed_buffering_time,
streaming_buffer_info_t *buffer_info);
static void
-streaming_handle_adaptive_buffering_mode(mm_player_streaming_t *streamer,
+streaming_handle_adaptive_buffering_mode(mmplayer_streaming_t *streamer,
streaming_content_info_t content_info,
streaming_bitrate_info_t bitrate_info,
streaming_buffer_info_t *buffer_info,
gint expected_play_time);
static void
-streaming_update_buffer_setting(mm_player_streaming_t *streamer,
+streaming_update_buffer_setting(mmplayer_streaming_t *streamer,
GstMessage *buffering_msg,
guint64 content_size,
gint64 position,
gint64 duration);
-mm_player_streaming_t *__mm_player_streaming_create(void)
+mmplayer_streaming_t *__mm_player_streaming_create(void)
{
- mm_player_streaming_t *streamer = NULL;
+ mmplayer_streaming_t *streamer = NULL;
MMPLAYER_FENTER();
- streamer = (mm_player_streaming_t *)g_try_malloc0(sizeof(mm_player_streaming_t));
+ streamer = (mmplayer_streaming_t *)g_try_malloc0(sizeof(mmplayer_streaming_t));
if (!streamer) {
LOGE("fail to create streaming player handle..");
return NULL;
buffer_handle->is_live = FALSE;
}
-void __mm_player_streaming_initialize(mm_player_streaming_t *streamer, gboolean buffer_init)
+void __mm_player_streaming_initialize(mmplayer_streaming_t *streamer, gboolean buffer_init)
{
MMPLAYER_FENTER();
MMPLAYER_RETURN_IF_FAIL(streamer);
return;
}
-void __mm_player_streaming_destroy(mm_player_streaming_t *streamer)
+void __mm_player_streaming_destroy(mmplayer_streaming_t *streamer)
{
MMPLAYER_FENTER();
}
void __mm_player_streaming_set_content_bitrate(
- mm_player_streaming_t *streamer, guint max_bitrate, guint avg_bitrate)
+ mmplayer_streaming_t *streamer, guint max_bitrate, guint avg_bitrate)
{
gboolean is_update = FALSE;
return;
}
-static void streaming_calc_watermark(mm_player_streaming_t *streamer,
+static void streaming_calc_watermark(mmplayer_streaming_t *streamer,
guint expected_play_bytes, gint expected_play_time, gdouble *low_wm, gdouble *high_wm)
{
#define PORTION_OF_HIGH_WM 1.1 /* need to compensate about low level */
LOGD("new watermark value [%f ~ %f]", *low_wm, *high_wm);
}
-static void streaming_set_buffer_watermark(mm_player_streaming_t *streamer,
- BufferType type, gdouble low_watermark, gdouble high_watermark)
+static void streaming_set_buffer_watermark(mmplayer_streaming_t *streamer,
+ buffer_type_e type, gdouble low_watermark, gdouble high_watermark)
{
streaming_buffer_t *buffer_handle = NULL;
gchar *factory_name = NULL;
return;
}
-static void streaming_set_queue2_queue_type(mm_player_streaming_t *streamer, MuxedBufferType type)
+static void streaming_set_queue2_queue_type(mmplayer_streaming_t *streamer, muxed_buffer_type_e type)
{
streaming_buffer_t *buffer_handle = NULL;
guint64 buffer_size = 0; /* bytes */
return;
}
-static void streaming_set_buffer_size(mm_player_streaming_t *streamer,
- BufferType type, guint buffering_bytes, gint buffering_time)
+static void streaming_set_buffer_size(mmplayer_streaming_t *streamer,
+ buffer_type_e type, guint buffering_bytes, gint buffering_time)
{
streaming_buffer_t *buffer_handle = NULL;
return;
}
-void __mm_player_streaming_set_queue2(mm_player_streaming_t *streamer, GstElement *buffer,
- gboolean use_buffering, MuxedBufferType type, guint64 content_size)
+void __mm_player_streaming_set_queue2(mmplayer_streaming_t *streamer, GstElement *buffer,
+ gboolean use_buffering, muxed_buffer_type_e type, guint64 content_size)
{
guint queue_size_bytes = 0;
guint queue_size_time = 0;
return;
}
-void __mm_player_streaming_sync_property(mm_player_streaming_t *streamer, GstElement *decodebin)
+void __mm_player_streaming_sync_property(mmplayer_streaming_t *streamer, GstElement *decodebin)
{
streaming_buffer_t *buffer_handle = NULL;
streamer->need_sync = FALSE;
}
-void __mm_player_streaming_set_multiqueue(mm_player_streaming_t *streamer, GstElement *buffer)
+void __mm_player_streaming_set_multiqueue(mmplayer_streaming_t *streamer, GstElement *buffer)
{
streaming_buffer_t *buffer_handle = NULL;
gdouble high_wm = 0.0, low_wm = 0.0;
return;
}
-static void streaming_get_current_bitrate_info(mm_player_streaming_t *streamer,
+static void streaming_get_current_bitrate_info(mmplayer_streaming_t *streamer,
GstMessage *buffering_msg, streaming_content_info_t content_info, streaming_bitrate_info_t *bitrate_info)
{
GstQuery *query = NULL;
(*bitrate_info).time_rate = buffer_buffering_time;
}
-static void streaming_handle_fixed_buffering_mode(mm_player_streaming_t *streamer,
+static void streaming_handle_fixed_buffering_mode(mmplayer_streaming_t *streamer,
gint byte_out_rate, gint expected_play_time, streaming_buffer_info_t *buffer_info)
{
streaming_buffer_t *buffer_handle = NULL;
(*buffer_info).low_watermark = low_wm;
}
-static void streaming_handle_adaptive_buffering_mode(mm_player_streaming_t *streamer,
+static void streaming_handle_adaptive_buffering_mode(mmplayer_streaming_t *streamer,
streaming_content_info_t content_info, streaming_bitrate_info_t bitrate_info,
streaming_buffer_info_t *buffer_info, gint expected_play_time)
{
(*buffer_info).low_watermark = low_wm;
}
-static void streaming_update_buffer_setting(mm_player_streaming_t *streamer,
+static void streaming_update_buffer_setting(mmplayer_streaming_t *streamer,
GstMessage *buffering_msg, guint64 content_size, gint64 position, gint64 duration)
{
streaming_buffer_t *buffer_handle = NULL;
- MMPlayerBufferingMode buffering_mode = MM_PLAYER_BUFFERING_MODE_ADAPTIVE;
+ mmplayer_buffering_mode_e buffering_mode = MM_PLAYER_BUFFERING_MODE_ADAPTIVE;
gint expected_play_time = DEFAULT_REBUFFERING_TIME;
streaming_buffer_info_t buffer_info = {0,};
streamer->need_sync = TRUE;
}
-static void streaming_adjust_min_threshold(mm_player_streaming_t *streamer, gint64 position)
+static void streaming_adjust_min_threshold(mmplayer_streaming_t *streamer, gint64 position)
{
#define DEFAULT_TIME_PAD 1000 /* ms */
gint playing_time = 0;
streamer->default_val.prev_pos = position;
}
-static void streaming_update_buffering_status(mm_player_streaming_t *streamer, GstMessage *buffering_msg, gint64 position)
+static void streaming_update_buffering_status(mmplayer_streaming_t *streamer, GstMessage *buffering_msg, gint64 position)
{
gint buffer_percent = 0;
}
}
-void __mm_player_streaming_buffering(mm_player_streaming_t *streamer, GstMessage *buffering_msg,
+void __mm_player_streaming_buffering(mmplayer_streaming_t *streamer, GstMessage *buffering_msg,
guint64 content_size, gint64 position, gint64 duration)
{
MMPLAYER_FENTER();
/*---------------------------------------------------------------------------------------
| LOCAL FUNCTION PROTOTYPES: |
---------------------------------------------------------------------------------------*/
-static int __mmplayer_track_get_language(mm_player_t *player, MMPlayerTrackType type, gint stream_index, gchar **code);
+static int __mmplayer_track_get_language(mmplayer_t *player, mmplayer_track_type_e type, gint stream_index, gchar **code);
/*=======================================================================================
| FUNCTION DEFINITIONS |
=======================================================================================*/
int
-_mmplayer_get_track_count(MMHandleType hplayer, MMPlayerTrackType type, int *count)
+_mmplayer_get_track_count(MMHandleType hplayer, mmplayer_track_type_e type, int *count)
{
int ret = MM_ERROR_NONE;
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
MMHandleType attrs = 0;
MMPLAYER_FENTER();
}
int
-_mmplayer_select_track(MMHandleType hplayer, MMPlayerTrackType type, int index)
+_mmplayer_select_track(MMHandleType hplayer, mmplayer_track_type_e type, int index)
{
int ret = MM_ERROR_NONE;
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
if (type == MM_PLAYER_TRACK_TYPE_TEXT && player->subtitle_language_list) { /* external subtitle */
GstElement *subparse = NULL;
- MMPlayerLangStruct *temp = NULL;
+ mmplayer_lang_info_t *temp = NULL;
guint num_of_list = 0;
if (!player->pipeline || !player->pipeline->textbin[MMPLAYER_T_FAKE_SINK].gst) {
}
int
-_mmplayer_get_current_track(MMHandleType hplayer, MMPlayerTrackType type, int *index)
+_mmplayer_get_current_track(MMHandleType hplayer, mmplayer_track_type_e type, int *index)
{
int ret = MM_ERROR_NONE;
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
MMHandleType attrs = 0;
gint count = 0;
}
int
-_mmplayer_get_track_language_code(MMHandleType hplayer, MMPlayerTrackType type, int index, char **code)
+_mmplayer_get_track_language_code(MMHandleType hplayer, mmplayer_track_type_e type, int index, char **code)
{
int ret = MM_ERROR_NONE;
- mm_player_t *player = (mm_player_t *)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
gchar *lang_code = NULL;
MMPLAYER_FENTER();
MMPLAYER_SUBTITLE_INFO_LOCK(player);
if (type == MM_PLAYER_TRACK_TYPE_TEXT && player->subtitle_language_list) { /* external subtitle */
- MMPlayerLangStruct *language_list = NULL;
+ mmplayer_lang_info_t *language_list = NULL;
lang_code = (gchar *)g_malloc0(LANGUAGE_CODE_SIZE * sizeof(char));
}
void
-__mmplayer_track_initialize(mm_player_t *player)
+__mmplayer_track_initialize(mmplayer_t *player)
{
- MMPlayerTrackType type = MM_PLAYER_TRACK_TYPE_AUDIO;
+ mmplayer_track_type_e type = MM_PLAYER_TRACK_TYPE_AUDIO;
MMPLAYER_FENTER();
}
void
-__mmplayer_track_destroy(mm_player_t *player)
+__mmplayer_track_destroy(mmplayer_t *player)
{
- MMPlayerTrackType type = MM_PLAYER_TRACK_TYPE_AUDIO;
+ mmplayer_track_type_e type = MM_PLAYER_TRACK_TYPE_AUDIO;
MMHandleType attrs = 0;
MMPLAYER_FENTER();
}
void
-__mmplayer_track_update_selector_info(mm_player_t *player, MMPlayerTrackType type, GstPad *sinkpad)
+__mmplayer_track_update_selector_info(mmplayer_t *player, mmplayer_track_type_e type, GstPad *sinkpad)
{
MMPLAYER_FENTER();
}
void
-__mmplayer_track_update_text_attr_info(mm_player_t *player, GstMessage *msg)
+__mmplayer_track_update_text_attr_info(mmplayer_t *player, GstMessage *msg)
{
MMHandleType attrs = 0;
const GValue *lang_list = NULL;
- MMPlayerLangStruct *temp = NULL;
+ mmplayer_lang_info_t *temp = NULL;
gchar *current_lang = NULL;
gint track_index = INVALID_TRACK_INDEX;
guint track_count = 0, index = 0;
}
static int
-__mmplayer_track_get_language(mm_player_t *player, MMPlayerTrackType type, gint stream_index, gchar **code)
+__mmplayer_track_get_language(mmplayer_t *player, mmplayer_track_type_e type, gint stream_index, gchar **code)
{
GstTagList *tag_list = NULL;
gchar *tag = NULL;
}
gboolean
-__is_rtsp_streaming(mm_player_t *player)
+__is_rtsp_streaming(mmplayer_t *player)
{
MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
}
gboolean
-__is_http_streaming(mm_player_t *player)
+__is_http_streaming(mmplayer_t *player)
{
MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
}
gboolean
-__is_streaming(mm_player_t *player)
+__is_streaming(mmplayer_t *player)
{
MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
}
gboolean
-__is_live_streaming(mm_player_t *player)
+__is_live_streaming(mmplayer_t *player)
{
MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
}
gboolean
-__is_http_live_streaming(mm_player_t *player)
+__is_http_live_streaming(mmplayer_t *player)
{
MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
}
gboolean
-__is_dash_streaming(mm_player_t *player)
+__is_dash_streaming(mmplayer_t *player)
{
MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
}
gboolean
-__is_smooth_streaming(mm_player_t *player)
+__is_smooth_streaming(mmplayer_t *player)
{
MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
}
gboolean
-__is_ms_buff_src(mm_player_t *player)
+__is_ms_buff_src(mmplayer_t *player)
{
MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
}
gboolean
-__has_suffix(mm_player_t *player, const gchar *suffix)
+__has_suffix(mmplayer_t *player, const gchar *suffix)
{
MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
MMPLAYER_RETURN_VAL_IF_FAIL(suffix, FALSE);
}
gboolean
-__mmplayer_post_message(mm_player_t *player, enum MMMessageType msgtype, MMMessageParamType *param)
+__mmplayer_post_message(mmplayer_t *player, enum MMMessageType msgtype, MMMessageParamType *param)
{
MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
}
gboolean
-__mmplayer_dump_pipeline_state(mm_player_t *player)
+__mmplayer_dump_pipeline_state(mmplayer_t *player)
{
GstIterator *iter = NULL;
gboolean done = FALSE;
_util_storage_supported_cb(int storage_id, storage_type_e type,
storage_state_e state, const char *path, void *user_data)
{
- MMPlayerStorageInfo *storage_info = (MMPlayerStorageInfo *)user_data;
+ mmplayer_storage_info_t *storage_info = (mmplayer_storage_info_t *)user_data;
MMPLAYER_RETURN_VAL_IF_FAIL(storage_info, FALSE);
}
bool
-util_get_storage_info(const char *path, MMPlayerStorageInfo *storage_info)
+util_get_storage_info(const char *path, mmplayer_storage_info_t *storage_info)
{
int ret = 0;
const char *file_path = path;
int MMPlayerPriv::Create(void)
{
int ret = MM_ERROR_NONE;
- mm_player_t *new_player = NULL;
+ mmplayer_t *new_player = NULL;
/* alloc player structure */
- new_player = (mm_player_t *)g_malloc0(sizeof(mm_player_t));
+ new_player = (mmplayer_t *)g_malloc0(sizeof(mmplayer_t));
/* create player lock */
g_mutex_init(&new_player->cmd_lock);
MMPLAYER_CMD_UNLOCK(priv_player);
- g_mutex_clear(&((mm_player_t *)priv_player)->cmd_lock);
- g_mutex_clear(&((mm_player_t *)priv_player)->playback_lock);
+ g_mutex_clear(&((mmplayer_t *)priv_player)->cmd_lock);
+ g_mutex_clear(&((mmplayer_t *)priv_player)->playback_lock);
- memset((mm_player_t *)priv_player, 0x00, sizeof(mm_player_t));
+ memset((mmplayer_t *)priv_player, 0x00, sizeof(mmplayer_t));
/* free player */
g_free((void *)priv_player);
int ret = MM_ERROR_NONE;
MMPLAYER_CMD_LOCK(priv_player);
- ret= _mmplayer_set_uri(priv_player, uri);
+ ret = _mmplayer_set_uri(priv_player, uri);
MMPLAYER_CMD_UNLOCK(priv_player);
return ret;
return ret;
}
-int MMPlayerPriv::GetCurrentState(MMPlayerStateType *state)
+int MMPlayerPriv::GetCurrentState(mmplayer_state_e *state)
{
int ret = MM_ERROR_NONE;
int MMPlayerPriv::ParseProfile(const gchar *uri, int *uri_type)
{
int ret = MM_ERROR_NONE;
- MMPlayerParseProfile profile;
+ mmplayer_parse_profile_t profile;
- memset((void *)&profile, 0, sizeof(MMPlayerParseProfile));
+ memset((void *)&profile, 0, sizeof(mmplayer_parse_profile_t));
ret = __mmplayer_parse_profile(uri, NULL, &profile);
if (uri_type)
class MMPlayerPriv {
private:
- mm_player_t *priv_player;
+ mmplayer_t *priv_player;
public:
MMPlayerPriv();
int SetUri(const gchar *uri);
int Realize(void);
int Unrealize(void);
- int GetCurrentState(MMPlayerStateType *state);
+ int GetCurrentState(mmplayer_state_e *state);
int ParseProfile(const gchar *uri, int *uri_type);
};
void MMPlayerPrivTest::TearDown()
{
int ret = MM_ERROR_NONE;
- MMPlayerStateType state = MM_PLAYER_STATE_NULL;
+ mmplayer_state_e state = MM_PLAYER_STATE_NULL;
ret = priv_player.GetCurrentState(&state);
if (ret != MM_ERROR_NONE)
projects / platform / core / multimedia / libmm-player.git / commitdiff