AC_SUBST(ICU_CFLAGS)
AC_SUBST(ICU_LIBS)
+
+PKG_CHECK_MODULES(MEDIAPACKET, capi-media-tool)
+AC_SUBST(MEDIAPACKET_CFLAGS)
+AC_SUBST(MEDIAPACKET_LIBS)
+
AC_ARG_ENABLE(sdk, AC_HELP_STRING([--enable-sdk], [sdk build]),
[
case "${enableval}" in
Name: libmm-player
Summary: Multimedia Framework Player Library
-Version: 0.5.56
-Release: 3
+Version: 0.5.60
+Release: 0
Group: Multimedia/Libraries
License: Apache-2.0
URL: http://source.tizen.org
BuildRequires: pkgconfig(iniparser)
BuildRequires: pkgconfig(vconf)
BuildRequires: pkgconfig(icu-i18n)
+BuildRequires: pkgconfig(capi-media-tool)
%description
Multimedia Framework Player Library files.
%build
%if %{with x}
-CFLAGS+=" -Wall -D_FILE_OFFSET_BITS=64 -DHAVE_X11 -DEXPORT_API=\"__attribute__((visibility(\\\"default\\\")))\" "; export CFLAGS
+CFLAGS+=" -Wall -D_FILE_OFFSET_BITS=64 -DTEST_ES -DHAVE_X11 -DEXPORT_API=\"__attribute__((visibility(\\\"default\\\")))\" "; export CFLAGS
%endif
%if %{with wayland}
-CFLAGS+=" -Wall -D_FILE_OFFSET_BITS=64 -DHAVE_WAYLAND -DEXPORT_API=\"__attribute__((visibility(\\\"default\\\")))\" "; export CFLAGS
+CFLAGS+=" -Wall -D_FILE_OFFSET_BITS=64 -DTEST_ES -DHAVE_WAYLAND -DEXPORT_API=\"__attribute__((visibility(\\\"default\\\")))\" "; export CFLAGS
%endif
LDFLAGS+="-Wl,--rpath=%{_prefix}/lib -Wl,--hash-style=both -Wl,--as-needed"; export LDFLAGS
./autogen.sh
mm_player_priv.c \
mm_player_ini.c \
mm_player_utils.c \
+ mm_player_asm.c \
mm_player_attrs.c \
mm_player_capture.c \
mm_player_pd.c \
mm_player_streaming.c \
mm_player_tracks.c \
- mm_player_audioeffect.c
+ mm_player_audioeffect.c \
+ mm_player_es.c
libmmfplayer_la_CFLAGS = -I$(srcdir)/include \
$(MMCOMMON_CFLAGS) \
$(GST_CFLAGS) \
$(GST_VIDEO_CFLAGS) \
$(GST_APP_CFLAGS) \
+ $(MMSESSION_CFLAGS) \
$(MMSOUND_CFLAGS) \
+ $(AUDIOSESSIONMGR_CFLAGS) \
$(VCONF_CFLAGS) \
- $(ICU_CFLAGS)
+ $(ICU_CFLAGS) \
+ $(UTILX_CFLAGS) \
+ $(MEDIAPACKET_CFLAGS) \
+ -Wno-deprecated -Wno-deprecated-declarations
noinst_HEADERS = include/mm_player_utils.h \
include/mm_player_ini.h \
include/mm_player_priv.h \
+ include/mm_player_asm.h \
include/mm_player_attrs.h \
include/mm_player_capture.h \
include/mm_player_pd.h \
include/mm_player_tracks.h \
- include/mm_player_streaming.h
+ include/mm_player_streaming.h \
+ include/mm_player_es.h
libmmfplayer_la_LIBADD = $(GST_LIBS) \
$(MMCOMMON_LIBS) \
$(GST_VIDEO_LIBS) \
$(GST_APP_LIBS) \
$(INIPARSER_LIBS) \
+ $(MMSESSION_LIBS) \
$(MMSOUND_LIBS) \
+ $(AUDIOSESSIONMGR_LIBS) \
$(VCONF_LIBS) \
- $(ICU_LIBS)
+ $(ICU_LIBS) \
+ $(MEDIAPACKET_LIBS) \
+ $(UTILX_LIBS)
libmmfplayer_la_CFLAGS += $(MMLOG_CFLAGS) -DMMF_LOG_OWNER=0x008 -DMMF_DEBUG_PREFIX=\"MMF-PLAYER\" -D_INTERNAL_SESSION_MANAGER_
libmmfplayer_la_LIBADD += $(MMLOG_LIBS)
#include <mm_types.h>
#include <mm_message.h>
+#include <media_packet.h>
#ifdef __cplusplus
extern "C" {
int height; /**< height of video buffer */
unsigned int timestamp; /**< timestamp of stream buffer (msec)*/
unsigned int length_total; /**< total length of stream buffer (in byte)*/
- void *data;
+ void *data[BUFFER_MAX_PLANE_NUM];
void *bo[BUFFER_MAX_PLANE_NUM]; /**< TBM buffer object */
void *internal_buffer; /**< Internal buffer pointer */
+ int stride[BUFFER_MAX_PLANE_NUM]; /**< stride of plane */
+ int elevation[BUFFER_MAX_PLANE_NUM]; /**< elevation of plane */
}MMPlayerVideoStreamDataType;
/**
*/
typedef enum {
MM_PLAYER_TRACK_TYPE_AUDIO = 0,
-#ifdef _USE_M_V_INPUT_SELECTOR_
MM_PLAYER_TRACK_TYPE_VIDEO,
-#endif
MM_PLAYER_TRACK_TYPE_TEXT,
MM_PLAYER_TRACK_TYPE_MAX
}MMPlayerTrackType;
MM_PLAYER_SOUND_RESOURCE_PRELISTENING_MEDIA,
} MMPlayerSoundResource;
+
/**
* Edge Properties of the text.
*/
MM_PLAYER_EDGE_DROPSHADOW
} MMPlayerSubtitleEdge;
+/**
+ * Enumeration of media stream buffer status
+ */
+typedef enum
+{
+ MM_PLAYER_MEDIA_STREAM_BUFFER_UNDERRUN,
+ MM_PLAYER_MEDIA_STREAM_BUFFER_OVERFLOW,
+} MMPlayerMediaStreamBufferStatus;
+
+/**
+ * Enumeration for stream type.
+ */
+typedef enum
+{
+ MM_PLAYER_STREAM_TYPE_DEFAULT, /**< Container type */
+ MM_PLAYER_STREAM_TYPE_AUDIO, /**< Audio element stream type */
+ MM_PLAYER_STREAM_TYPE_VIDEO, /**< Video element stream type */
+ MM_PLAYER_STREAM_TYPE_TEXT, /**< Text type */
+ MM_PLAYER_STREAM_TYPE_MAX,
+} MMPlayerStreamType;
/**
* Attribute validity structure
float level[MM_VOLUME_CHANNEL_NUM]; /**< Relative volume factor for each channels */
} MMPlayerVolumeType;
+#ifdef TEST_ES
+/**
+ * Video stream info in external demux case
+ *
+**/
+typedef struct _VideoStreamInfo
+{
+ const char *mime;
+ unsigned int framerate_num;
+ unsigned int framerate_den;
+ unsigned int width;
+ unsigned int height;
+ unsigned char *codec_extradata;
+ unsigned int extradata_size;
+ unsigned int version;
+}MMPlayerVideoStreamInfo;
+
+/**
+ * Audio stream info in external demux case
+ *
+**/
+typedef struct _AudioStreamInfo
+{
+ const char *mime;
+ unsigned int channels;
+ unsigned int sample_rate;
+ unsigned char *codec_extradata;
+ unsigned int extradata_size;
+ unsigned int version;
+ unsigned int user_info;
+
+ /* for pcm */
+// unsigned int width;
+// unsigned int depth;
+// unsigned int endianness;
+// bool signedness;
+}MMPlayerAudioStreamInfo;
+
+/**
+ * Subtitle stream info in external demux case
+ *
+**/
+typedef struct _SubtitleStreamInfo
+{
+ const char *mime;
+ unsigned int codec_tag;
+ void *context; //for smpte text
+}MMPlayerSubtitleStreamInfo;
+
+#endif
+
/**
* Audio stream callback function type.
*
*/
typedef bool (*mm_player_track_selected_subtitle_language_callback)(int track_num, void *user_param);
+/**
+ * Buffer underrun / overflow data callback function type.
+ *
+ * @param status [in] buffer status
+ * @param user_param [in] User defined parameter which is passed when set
+ * to enough data callback or need data callback
+ *
+ * @return This callback function have to return MM_ERROR_NONE.
+ */
+typedef bool (*mm_player_media_stream_buffer_status_callback) (MMPlayerStreamType type, MMPlayerMediaStreamBufferStatus status, void *user_param);
+
+/**
+ * Buffer seek data callback function type.
+ *
+ * @param offset [in] offset for the buffer playback
+ * @param user_param [in] User defined parameter which is passed when set
+ * to seek data callback
+ *
+ * @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);
+
+/**
+ * Called to notify the stream changed.
+ *
+ * @param user_data [in] The user data passed from the callback registration function
+ *
+ * @return This callback function have to return MM_ERROR_NONE.
+ */
+typedef bool (*mm_player_stream_changed_callback) (void *user_param);
+
/*===========================================================================================
| |
int mm_player_enable_media_packet_video_stream(MMHandleType player, bool enable);
+/**
+ * This function is to increase reference count of internal buffer.
+ *
+ * @param buffer [in] video callback internal buffer
+ * @return This function returns buffer point;
+ *
+ * @see
+ * @remark None
+ */
+void * mm_player_media_packet_video_stream_internal_buffer_ref(void *buffer);
+
+/**
+ * This function is to decrease reference count of internal buffer.
+ *
+ * @param buffer [in] video callback internal buffer
+ * @return None;
+ *
+ * @see
+ * @remark None
+ */
+void mm_player_media_packet_video_stream_internal_buffer_unref(void *buffer);
+
+#ifdef TEST_ES
+
+/**mm_player_submit_packet
+ * This function is to submit buffer to appsrc. \n
+ * @param player [in] Handle of player.
+ * @param buf [in] buffer to be submit in appsrc in external feeder case.
+ * @param len [in] length of buffer.
+ * @param pts [in] timestamp of buffer.
+ * @param streamtype [in] stream type of buffer.
+ * @return This function returns zero on success, or negative value with error code.
+ * @par Example
+ *
+ * @endcode
+ */
+int mm_player_submit_packet(MMHandleType player, media_packet_h packet);
+
+/**mm_player_set_video_info
+ * This function is to set caps of src pad of video appsrc in external feeder case. \n
+ * @param player [in] Handle of player.
+ * @param media_format_h [in] Video stream info.
+ * @return This function returns zero on success, or negative value with error code.
+ * @par Example
+ *
+ * @endcode
+ */
+
+int mm_player_set_video_info (MMHandleType player, media_format_h format);
+
+/**mm_player_set_audio_info
+ * This function is to set caps of src pad of Audio appsrc in external feeder case. \n
+ * @param player [in] Handle of player.
+ * @param media_format_h [in] Audio stream info.
+ * @return This function returns zero on success, or negative value with error code.
+ * @par Example
+ *
+ * @endcode
+ */
+
+int mm_player_set_audio_info (MMHandleType player, media_format_h format);
+
+/**mm_player_set_subtitle_info
+ * This function is to set caps of src pad of subtitle appsrc in external feeder case. \n
+ * @param player [in] Handle of player.
+ * @param subtitle_stream_info [in] Subtitle stream info.
+ * @return This function returns zero on success, or negative value with error code.
+ * @par Example
+ *
+ * @endcode
+ */
+
+int mm_player_set_subtitle_info (MMHandleType player, MMPlayerSubtitleStreamInfo *info);
+
+/**
+ * This function set callback function for receiving need or enough data message from player.
+ *
+ * @param player [in] Handle of player.
+ * @param type [in] stream type
+ * @param callback [in] data callback function for stream type.
+ * @param user_param [in] User parameter.
+ *
+ * @return This function returns zero on success, or negative value with error
+ * code.
+ * @remark
+ * @see
+ * @since
+ */
+int mm_player_set_media_stream_buffer_status_callback(MMHandleType player, MMPlayerStreamType type, mm_player_media_stream_buffer_status_callback callback, void * user_param);
+
+/**
+ * This function set callback function for receiving seek data message from player.
+ *
+ * @param player [in] Handle of player.
+ * @param type [in] stream type
+ * @param callback [in] Seek data callback function for stream type.
+ * @param user_param [in] User parameter.
+ *
+ * @return This function returns zero on success, or negative value with error
+ * code.
+ * @remark
+ * @see
+ * @since
+ */
+int mm_player_set_media_stream_seek_data_callback(MMHandleType player, MMPlayerStreamType type, mm_player_media_stream_seek_data_callback callback, void * user_param);
+
+/**
+ * This function is to set max size of buffer(appsrc).
+ *
+ * @param player [in] Handle of player.
+ * @param type [in] stream type
+ * @param max_size [in] max bytes of buffer.
+ *
+ * @return This function returns zero on success, or negative value with error
+ * code.
+ * @remark
+ * @see
+ * @since
+ */
+int mm_player_set_media_stream_buffer_max_size(MMHandleType player, MMPlayerStreamType type, unsigned long long max_size);
+
+/**
+ * This function is to get max size of buffer(appsrc).
+ *
+ * @param player [in] Handle of player.
+ * @param type [in] stream type
+ * @param max_size [out] max bytes of buffer.
+ *
+ * @return This function returns zero on success, or negative value with error
+ * code.
+ * @remark
+ * @see
+ * @since
+ */
+int mm_player_get_media_stream_buffer_max_size(MMHandleType player, MMPlayerStreamType type, unsigned long long *max_size);
+
+/**
+ * This function is to set min percent of buffer(appsrc).
+ *
+ * @param player [in] Handle of player.
+ * @param type [in] stream type
+ * @param min_percent [in] min percent of buffer.
+ *
+ * @return This function returns zero on success, or negative value with error
+ * code.
+ * @remark
+ * @see
+ * @since
+ */
+int mm_player_set_media_stream_buffer_min_percent(MMHandleType player, MMPlayerStreamType type, unsigned min_percent);
+
+/**
+ * This function is to get min percent of buffer(appsrc).
+ *
+ * @param player [in] Handle of player.
+ * @param type [in] stream type
+ * @param min_percent [out] min percent of buffer.
+ *
+ * @return This function returns zero on success, or negative value with error
+ * code.
+ * @remark
+ * @see
+ * @since
+ */
+int mm_player_get_media_stream_buffer_min_percent(MMHandleType player, MMPlayerStreamType type, unsigned int *min_percent);
+
+/**
+ * This function set callback function for changing audio stream from player. \n
+ * It's only supported when audio stream is included in file. \n
+ *
+ * @param player [in] Handle of player.
+ * @param callback [in] Audio stream changed callback function.
+ * @param user_param [in] User parameter.
+ *
+ * @return This function returns zero on success, or negative value with error
+ * code.
+ * @see mm_player_stream_changed_callback
+ * @since
+ */
+int mm_player_set_audio_stream_changed_callback(MMHandleType player, mm_player_stream_changed_callback callback, void *user_param);
+
+/**
+ * This function set callback function for changing video stream from player. \n
+ * It's only supported when video stream is included in file. \n
+ *
+ * @param player [in] Handle of player.
+ * @param callback [in] Video stream changed callback function.
+ * @param user_param [in] User parameter.
+ *
+ * @return This function returns zero on success, or negative value with error
+ * code.
+ * @see mm_player_stream_changed_callback
+ * @since
+ */
+int mm_player_set_video_stream_changed_callback(MMHandleType player, mm_player_stream_changed_callback callback, void *user_param);
+
+#endif
/**
@}
--- /dev/null
+/*
+ * libmm-player
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: JongHyuk Choi <jhchoi.choi@samsung.com>, YeJin Cho <cho.yejin@samsung.com>,
+ * Seungbae Shin <seungbae.shin@samsung.com>, YoungHwan An <younghwan_.an@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#ifndef __MM_PLAYER_ASM_H__
+#define __MM_PLAYER_ASM_H__
+
+#include <glib.h>
+#include <mm_types.h>
+
+#include <mm_session.h>
+#include <mm_session_private.h>
+#include <audio-session-manager.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+ int handle;
+ int pid;
+ bool by_asm_cb;
+ int antishock;
+ int event_src;
+ int skip_session;
+ bool keep_last_pos;
+ int user_route_policy;
+ ASM_sound_states_t state;
+ ASM_sound_events_t event;
+ ASM_resource_t resource;
+ bool exit_cb;
+ bool cb_pending;
+} MMPlayerASM;
+
+gint _mmplayer_asm_register(MMPlayerASM* sm, ASM_sound_cb_t callback, void* param);
+gint _mmplayer_asm_unregister(MMPlayerASM* sm);
+gint _mmplayer_asm_set_state(MMHandleType player, ASM_sound_states_t state, gboolean enable_safety_vol);
+gint _mmplayer_asm_ignore_session(MMHandleType player);
+gint _mmplayer_asm_set_sound_resource(MMHandleType player, MMPlayerSoundResource mode);
+ASM_cb_result_t __mmplayer_asm_callback(int handle, ASM_event_sources_t event_src, ASM_sound_commands_t command, unsigned int sound_status, void* cb_data);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __MM_PLAYER_ASM_H__ */
--- /dev/null
+/*
+ * libmm-player
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: JongHyuk Choi <jhchoi.choi@samsung.com>, heechul jeon <heechul.jeon@samsung.co>,
+ * YoungHwan An <younghwan_.an@samsung.com>, Eunhae Choi <eunhae1.choi@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#ifndef __MM_PLAYER_ES_H__
+#define __MM_PLAYER_ES_H__
+
+/*=======================================================================================
+| INCLUDE FILES |
+========================================================================================*/
+#include <mm_types.h>
+#include "mm_player_priv.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/*=======================================================================================
+| GLOBAL FUNCTION PROTOTYPES |
+========================================================================================*/
+
+int _mmplayer_set_video_info (MMHandleType player, media_format_h format);
+
+int _mmplayer_set_audio_info (MMHandleType player, media_format_h format);
+
+int _mmplayer_set_subtitle_info (MMHandleType player, MMPlayerSubtitleStreamInfo * info);
+
+int _mmplayer_submit_packet (MMHandleType player, media_packet_h packet);
+
+int _mmplayer_set_media_stream_buffer_status_cb (MMHandleType player,
+ MMPlayerStreamType type,
+ mm_player_media_stream_buffer_status_callback callback,
+ void * user_param);
+
+int _mmplayer_set_media_stream_seek_data_cb (MMHandleType player,
+ MMPlayerStreamType type,
+ mm_player_media_stream_seek_data_callback callback,
+ void * user_param);
+
+int _mmplayer_set_media_stream_max_size (MMHandleType hplayer,
+ MMPlayerStreamType type,
+ guint64 max_size);
+
+int _mmplayer_get_media_stream_max_size(MMHandleType hplayer,
+ MMPlayerStreamType type,
+ guint64 *max_size);
+
+int _mmplayer_set_media_stream_min_percent(MMHandleType hplayer,
+ MMPlayerStreamType type,
+ guint min_percent);
+
+int _mmplayer_get_media_stream_min_percent(MMHandleType hplayer,
+ MMPlayerStreamType type,
+ guint *min_percent);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
gchar videosink_element_fake[PLAYER_INI_MAX_STRLEN];
gchar name_of_audio_resampler[PLAYER_INI_MAX_STRLEN];
gchar name_of_audiosink[PLAYER_INI_MAX_STRLEN];
- gchar name_of_drmsrc[PLAYER_INI_MAX_STRLEN];
gchar name_of_video_converter[PLAYER_INI_MAX_STRLEN];
gboolean skip_rescan;
gboolean generate_dot;
gint localplayback_state_change_timeout;
gint delay_before_repeat;
gint eos_delay;
- gboolean multiple_codec_supported;
gchar gst_param[5][PLAYER_INI_MAX_PARAM_STRLEN];
gchar exclude_element_keyword[PLAYER_INI_MAX_ELEMENT][PLAYER_INI_MAX_STRLEN];
guint rtsp_buffering_time;
guint rtsp_rebuffering_time;
gboolean rtsp_do_typefinding;
- gboolean rtsp_error_concealment; /* testing purpose */
-
- /* hw accelation */
- gboolean use_video_hw_accel;
-
- /* priority */
- gboolean use_priority_setting;
- gint demux_priority;
- gint audiosink_priority;
- gint videosink_priority;
- gint ringbuffer_priority;
/* dump buffer for debug */
gchar dump_element_keyword[PLAYER_INI_MAX_ELEMENT][PLAYER_INI_MAX_STRLEN];
#define DEFAULT_PROVIDE_CLOCK_FOR_MOVIE FALSE
#define DEFAULT_DELAY_BEFORE_REPEAT 50 /* msec */
#define DEFAULT_EOS_DELAY 150 /* msec */
-#define DEFAULT_DRMSRC "drmsrc"
#define DEFAULT_VIDEOSINK_X "xvimagesink"
#define DEFAULT_VIDEOSINK_EVAS "evasimagesink"
#define DEFAULT_VIDEOSINK_FAKE "fakesink"
#define DEFAULT_AUDIORESAMPLER "audioresample"
-#define DEFAULT_AUDIOSINK "avsysaudiosink"
+#define DEFAULT_AUDIOSINK "pulsesink"
#define DEFAULT_GST_PARAM ""
#define DEFAULT_EXCLUDE_KEYWORD ""
#define DEFAULT_ASYNC_START TRUE
#define DEFAULT_DISABLE_SEGTRAP TRUE
#define DEFAULT_VIDEO_CONVERTER ""
-#define DEFAULT_MULTIPLE_CODEC_SUPPORTED TRUE
#define DEFAULT_LIVE_STATE_CHANGE_TIMEOUT 30 /* sec */
#define DEFAULT_LOCALPLAYBACK_STATE_CHANGE_TIMEOUT 10 /* sec */
/* http streaming */
#define DEFAULT_RTSP_BUFFERING 5000 /* msec */
#define DEFAULT_RTSP_REBUFFERING 15000 /* msec */
#define DEFAULT_RTSP_DO_TYPEFINDING FALSE
-#define DEFAULT_RTSP_ERROR_CONCEALMENT TRUE
-/* hw accel */
-#define DEFAULT_USE_VIDEO_HW_ACCEL FALSE
-/* priority */
-#define DEFAULT_USE_PRIORITY_SETTING FALSE
-#define DEFAULT_PRIORITY_DEMUX 96
-#define DEFAULT_PRIORITY_VIDEO_SINK 97
-#define DEFAULT_PRIORITY_AUDIO_SINK 98
-#define DEFAULT_PRIORITY_RINGBUFFER 99
/* dump buffer for debug */
#define DEFAULT_DUMP_ELEMENT_KEYWORD ""
"\
[general] \n\
\n\
-use sink handler = yes \n\
-\n\
disable segtrap = yes ; same effect with --gst-disable-segtrap \n\
\n\
; set default video sink but, it can be replaced with others selected by application\n\
\n\
video converter element = \n\
\n\
-audiosink element = avsysaudiosink \n\
-\n\
-drmsrc element = drmsrc \n\
+audiosink element = pulsesink \n\
\n\
; if yes. gstreamer will not update registry \n\
skip rescan = yes \n\
\n\
async start = yes \n\
\n\
-multiple codec supported = yes \n\
-\n\
; parameters for initializing gstreamer \n\
gstparam1 = \n\
gstparam2 = \n\
\n\
rtsp do typefinding = no; if no, caps on rtspsrc:src pad will be used for autoplugging \n\
\n\
-rtsp error concealment = yes \n\
-\n\
-\n\
-[hw accelation] \n\
-use video hw accel = yes \n\
-\n\
-\n\
-[priority] \n\
-\n\
-use priority setting = no \n\
-\n\
-demux = 95 \n\
-\n\
-videosink = 96 \n\
-\n\
-audiosink = 97\n\
-\n\
-ringbuffer = 98 \n\
-\n\
"
int
unsigned int orientation; /* content orientation */
}MMPlayerVideoCapture;
-/**
- * Buffer need data callback function type.
- *
- * @param size [in] size required for the buffer playback
- * @param user_param [in] User defined parameter which is passed when set
- * to need data callback
- *
- * @return This callback function have to return MM_ERROR_NONE.
- */
-typedef bool (*mm_player_buffer_need_data_callback) (unsigned int size, void *user_param);
-
-/**
- * Buffer enough data callback function type.
- *
- * @param user_param [in] User defined parameter which is passed when set
- * to enough data callback
- *
- * @return This callback function have to return MM_ERROR_NONE.
- */
-typedef bool (*mm_player_buffer_enough_data_callback) (void *user_param);
-
-/**
- * Buffer seek data callback function type.
- *
- * @param offset [in] offset for the buffer playback
- * @param user_param [in] User defined parameter which is passed when set
- * to seek data callback
- *
- * @return This callback function have to return MM_ERROR_NONE.
- */
-typedef bool (*mm_player_buffer_seek_data_callback) (unsigned long long offset, void *user_param);
+typedef struct
+{
+ void *data;
+ int data_size;
+ int channel;
+ int bitrate;
+ int depth;
+ bool is_little_endian;
+ guint64 channel_mask;
+}MMPlayerAudioStreamDataType;
/**
* Video stream callback function type.
typedef bool (*mm_player_video_frame_render_error_callback) (void *error_id, void *user_param);
/**
+ * Audio stream callback function type.
+ *
+ * @param stream [in] Reference pointer to audio frame data
+ * @param user_param [in] User defined parameter which is passed when set
+ * audio stream callback
+ *
+ * @return This callback function have to return MM_ERROR_NONE.
+ */
+typedef bool (*mm_player_audio_stream_callback_ex) (MMPlayerAudioStreamDataType *stream, void *user_param);
+/**
* This function is to set play speed for playback.
*
* @param player [in] Handle of player.
int mm_player_set_video_stream_callback(MMHandleType player, mm_player_video_stream_callback callback, void *user_param);
/**
+ * This function set callback function for receiving audio stream from player.
+ *
+ * @param player [in] Handle of player.
+ * @param sync [in] sync Sync on the clock.
+ * @param callback [in] audio stream callback function.
+ * @param user_param [in] User parameter.
+ *
+ * @return This function returns zero on success, or negative value with error
+ * code.
+ * @remark
+ * @see mm_player_audio_stream_callback_ex
+ * @since
+ */
+int mm_player_set_audio_stream_callback_ex(MMHandleType player, bool sync, mm_player_audio_stream_callback_ex callback, void *user_param);
+
+/**
* This function set callback function for rendering error information of video render plug-in.
*
* @param player [in] Handle of player.
int mm_player_do_video_capture(MMHandleType player);
/**
- * This function set callback function for receiving need data message from player.
- *
- * @param player [in] Handle of player.
- * @param callback [in] Need data callback function.
- * @param user_param [in] User parameter.
- *
- * @return This function returns zero on success, or negative value with error
- * code.
- * @remark
- * @see mm_player_set_buffer_enough_data_callback
- * @since
- */
-int mm_player_set_buffer_need_data_callback(MMHandleType player, mm_player_buffer_need_data_callback callback , void *user_param);
-
-/**
- * This function set callback function for receiving enough data message from player.
- *
- * @param player [in] Handle of player.
- * @param callback [in] Enough data callback function.
- * @param user_param [in] User parameter.
- *
- * @return This function returns zero on success, or negative value with error
- * code.
- * @remark
- * @see mm_player_set_buffer_need_data_callback
- * @since
- */
-int mm_player_set_buffer_enough_data_callback(MMHandleType player, mm_player_buffer_enough_data_callback callback, void *user_param);
-
-/**
- * This function set callback function for receiving seek data message from player.
- *
- * @param player [in] Handle of player.
- * @param callback [in] Seek data callback function.
- * @param user_param [in] User parameter.
- *
- * @return This function returns zero on success, or negative value with error
- * code.
- * @remark
- * @see
- * @since
- */
-int mm_player_set_buffer_seek_data_callback(MMHandleType player, mm_player_buffer_seek_data_callback callback, void *user_param);
-
-/**
* This function set callback function for putting data into player.
*
* @param player [in] Handle of player.
#include "mm_player_audioeffect.h"
#include "mm_message.h"
#include "mm_player_ini.h"
-//#include "mm_player_asm.h"
+#include "mm_player_asm.h"
#include "mm_player_pd.h"
#include "mm_player_streaming.h"
MM_PLAYER_URI_TYPE_FILE, /**< Player URI type File */
MM_PLAYER_URI_TYPE_URL, /**< Player URI type URL */
MM_PLAYER_URI_TYPE_BUFF, /**< Player URI type Buffer */
+#ifdef TEST_ES
+ MM_PLAYER_URI_TYPE_ES_BUFF, /**< Player URI type ES Buffer */
+#endif
MM_PLAYER_URI_TYPE_HLS, /**< Player URI type http live streaming */
MM_PLAYER_URI_TYPE_SS, /**< Player URI type Smooth streaming */
MM_PLAYER_URI_TYPE_DASH, /**< Player URI type Mpeg Dash */
{
MMPLAYER_M_PIPE = 0, /* NOTE : MMPLAYER_M_PIPE should be zero */
MMPLAYER_M_SRC,
+#ifdef TEST_ES
+ MMPLAYER_M_2ND_SRC, /* 2nd Source Element for es buff src */
+#endif
MMPLAYER_M_SUBSRC,
/* it could be a decodebin or could be a typefind. depends on player ini */
MMPLAYER_M_TYPEFIND,
MMPLAYER_M_AUTOPLUG,
+#ifdef TEST_ES
+ MMPLAYER_M_AUTOPLUG_V_DEC,
+ MMPLAYER_M_AUTOPLUG_A_DEC,
+#endif
+
/* NOTE : we need two fakesink to autoplug without decodebin.
* first one will hold whole pipeline state. and second one will hold state of
* a sink-decodebin for an elementary stream. no metter if there's more then one
MMPLAYER_M_DEMUXED_S_BUFFER,
MMPLAYER_M_ID3DEMUX,
+#ifdef TEST_ES
+ /* es buff src queue */
+ MMPLAYER_M_V_BUFFER,
+ MMPLAYER_M_A_BUFFER,
+ MMPLAYER_M_S_BUFFER,
+#endif
+
/* FIXIT : if there's really no usage for following IDs. remove it */
MMPLAYER_M_DEC1,
MMPLAYER_M_DEC2,
MMPLAYER_A_CAPS_DEFAULT,
MMPLAYER_A_SINK,
MMPLAYER_A_RESAMPLER,
+ MMPLAYER_A_DEINTERLEAVE,
MMPLAYER_A_NUM
};
GList *uri_list;
}MMPlayerUriList;
-/* image buffer definition ***************************************************
-
- +------------------------------------------+ ---
- | | ^
- | a[], p[] | |
- | +---------------------------+ --- | |
- | | | ^ | |
- | |<---------- w[] ---------->| | | |
- | | | | | |
- | | | |
- | | | h[] | e[]
- | | | |
- | | | | | |
- | | | | | |
- | | | v | |
- | +---------------------------+ --- | |
- | | v
- +------------------------------------------+ ---
-
- |<----------------- s[] ------------------>|
-*/
-typedef struct
-{
- /* width of each image plane */
- int w[MM_PLAYER_IMGB_MPLANE_MAX];
- /* height of each image plane */
- int h[MM_PLAYER_IMGB_MPLANE_MAX];
- /* stride of each image plane */
- int s[MM_PLAYER_IMGB_MPLANE_MAX];
- /* elevation of each image plane */
- int e[MM_PLAYER_IMGB_MPLANE_MAX];
- /* user space address of each image plane */
- void *a[MM_PLAYER_IMGB_MPLANE_MAX];
- /* physical address of each image plane, if needs */
- void *p[MM_PLAYER_IMGB_MPLANE_MAX];
- /* color space type of image */
- int cs;
- /* left postion, if needs */
- int x;
- /* top position, if needs */
- int y;
- /* to align memory */
- int __dummy2;
- /* arbitrary data */
- int data[16];
- /* dmabuf or ion fd */
- int fd[MM_PLAYER_IMGB_MPLANE_MAX];
- /* flag for buffer share */
- int buf_share_method;
- /* Y plane size */
- int y_size;
- /* UV plane size */
- int uv_size;
- /* Tizen buffer object of each image plane */
- void *bo[MM_PLAYER_IMGB_MPLANE_MAX];
- /* JPEG data */
- void *jpeg_data;
- /* JPEG size */
- int jpeg_size;
- /* tzmem buffer */
- int tz_enable;
-} MMPlayerMPlaneImage;
-
typedef struct {
gint active_pad_index;
gint total_track_num;
GMutex capture_thread_mutex;
MMPlayerVideoCapture capture;
MMPlayerVideoColorspace video_cs;
- MMPlayerMPlaneImage captured;
+ MMVideoBuffer captured;
/* fakesink handling lock */
GMutex fsink_lock;
/* pad */
GstPad *ghost_pad_for_videobin;
- /* buffering support cbs*/
- mm_player_buffer_need_data_callback need_data_cb;
- mm_player_buffer_enough_data_callback enough_data_cb;
- mm_player_buffer_seek_data_callback seek_data_cb;
+#ifdef TEST_ES
+ guint64 media_stream_buffer_max_size[MM_PLAYER_STREAM_TYPE_MAX];
+ guint media_stream_buffer_min_percent[MM_PLAYER_STREAM_TYPE_MAX];
+ mm_player_media_stream_buffer_status_callback media_stream_buffer_status_cb[MM_PLAYER_STREAM_TYPE_MAX];
+ mm_player_media_stream_seek_data_callback media_stream_seek_data_cb[MM_PLAYER_STREAM_TYPE_MAX];
+#endif
void* buffer_cb_user_param;
+ /* video stream changed callback */
+ mm_player_stream_changed_callback video_stream_changed_cb;
+ void* video_stream_changed_cb_user_param;
+
+ /* audio stream changed callback */
+ mm_player_stream_changed_callback audio_stream_changed_cb;
+ void* audio_stream_changed_cb_user_param;
+
/* video stream callback */
mm_player_video_stream_callback video_stream_cb;
void* video_stream_cb_user_param;
/* audio stram callback */
mm_player_audio_stream_callback audio_stream_cb;
void* audio_stream_cb_user_param;
+ bool audio_stream_sink_sync;
+
+ /* audio buffer callback */
+ mm_player_audio_stream_callback_ex audio_stream_render_cb_ex;
/* video capture callback*/
gulong video_capture_cb_probe_id;
gboolean is_nv12_tiled;
gboolean is_drm_file;
- //MMPlayerASM sm;
+ MMPlayerASM sm;
gboolean is_subtitle_off;
gboolean is_external_subtitle_present;
gboolean has_closed_caption;
GstElement *video_fakesink;
+#ifdef TEST_ES
+ /* audio stream caps parsed by demuxer or set by external demuxer */
+ GstCaps* a_stream_caps;
+
+ /* subtitle stream caps parsed by demuxer or set by external demuxer */
+ GstCaps* s_stream_caps;
+
+ /*es player using feed-data callback or calling app_src_push_buffer directly*/
+ gboolean es_player_push_mode;
+
+#endif
} mm_player_t;
typedef struct
int _mmplayer_activate_section_repeat(MMHandleType hplayer, unsigned long start, unsigned long end);
int _mmplayer_deactivate_section_repeat(MMHandleType hplayer);
int _mmplayer_push_buffer(MMHandleType hplayer, unsigned char *buf, int size);
-int _mmplayer_set_buffer_need_data_cb(MMHandleType hplayer,mm_player_buffer_need_data_callback callback, void *user_param);
-int _mmplayer_set_buffer_enough_data_cb(MMHandleType hplayer,mm_player_buffer_enough_data_callback callback, void *user_param);
-int _mmplayer_set_buffer_seek_data_cb(MMHandleType hplayer,mm_player_buffer_seek_data_callback callback, void *user_param);
int _mmplayer_set_playspeed(MMHandleType hplayer, float rate);
int _mmplayer_set_playspeed_ex(MMHandleType hplayer, gdouble rate);
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_set_audiostream_changed_cb(MMHandleType hplayer, mm_player_stream_changed_callback callback, void *user_param);
int _mmplayer_set_videostream_cb(MMHandleType hplayer,mm_player_video_stream_callback callback, void *user_param);
int _mmplayer_set_audiostream_cb(MMHandleType hplayer,mm_player_audio_stream_callback callback, void *user_param);
int _mmplayer_set_videoframe_render_error_cb(MMHandleType hplayer, mm_player_video_frame_render_error_callback callback, void *user_param);
int _mmplayer_change_videosink(MMHandleType handle, MMDisplaySurfaceType surface_type, void *display_overlay);
int _mmplayer_audio_effect_custom_apply(mm_player_t *player);
+int _mmplayer_set_audiostream_cb_ex(MMHandleType hplayer, bool sync, mm_player_audio_stream_callback_ex callback, void *user_param);
gboolean __mmplayer_post_message(mm_player_t* player, enum MMMessageType msgtype, MMMessageParamType* param);
gboolean __mmplayer_is_streaming(mm_player_t* player);
int _mmplayer_get_next_uri(MMHandleType hplayer, char** uri);
int _mmplayer_has_closed_caption(MMHandleType hplayer, bool* exist);
int _mmplayer_enable_media_packet_video_stream(MMHandleType hplayer, bool enable);
+void * _mm_player_media_packet_video_stream_internal_buffer_ref(void *buffer);
+void _mm_player_media_packet_video_stream_internal_buffer_unref(void *buffer);
+
#ifdef __cplusplus
}
#endif
#define MMPLAYER_IS_HTTP_LIVE_STREAMING(x_player) __is_http_live_streaming(x_player)
#define MMPLAYER_IS_LIVE_STREAMING(x_player) __is_live_streaming(x_player)
#define MMPLAYER_IS_DASH_STREAMING(x_player) __is_dash_streaming(x_player)
-#define MMPLAYER_IS_SMOOTH_STREAMING(x_player) __is_smooth_streaming(x_player)
+#define MMPLAYER_IS_SMOOTH_STREAMING(x_player) __is_smooth_streaming(x_player)
+#ifdef TEST_ES
+#define MMPLAYER_IS_ES_BUFF_SRC(x_player) __is_es_buff_src(x_player)
+#endif
#define MMPLAYER_URL_HAS_DASH_SUFFIX(x_player) __has_suffix(x_player, "mpd")
#define MMPLAYER_URL_HAS_HLS_SUFFIX(x_player) __has_suffix(x_player, "m3u8")
};
bool util_is_sdp_file ( const char *path );
-int64_t uti_get_time ( void );
int util_get_rank_increase ( const char *factory_class );
int util_factory_rank_compare(GstPluginFeature *f1, GstPluginFeature *f2); // @
int util_exist_file_path(const char *file_path);
const char* util_get_charset(const char *file_path);
int util_get_is_connected_external_display(void);
-gboolean util_is_miracast_connected(void);
int util_get_pixtype(unsigned int fourcc);
#ifdef __cplusplus
#include "mm_debug.h"
#include "mm_player_capture.h"
#include "mm_player_tracks.h"
+#include "mm_player_es.h"
int mm_player_create(MMHandleType *player)
{
return_val_if_fail(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
-// if (!g_thread_supported ())
-// g_thread_init (NULL); g_thread_init has been deprecated since version 2.32 and should not be used in newly-written code. This function is no longer necessary. The GLib threading system is automatically initialized at the start of your program.
/* alloc player structure */
new_player = g_malloc(sizeof(mm_player_t));
if ( new_player )
{
+ _mmplayer_destroy( (MMHandleType)new_player );
g_mutex_clear(&new_player->cmd_lock);
g_mutex_clear(&new_player->playback_lock);
- _mmplayer_destroy( (MMHandleType)new_player );
-
MMPLAYER_FREEIF( new_player );
}
return result;
}
-int mm_player_set_video_stream_callback(MMHandleType player, mm_player_video_stream_callback callback, void *user_param)
+int mm_player_set_audio_stream_callback_ex(MMHandleType player, bool sync, mm_player_audio_stream_callback_ex callback, void *user_param)
{
int result = MM_ERROR_NONE;
MMPLAYER_CMD_LOCK( player );
- result = _mmplayer_set_videostream_cb(player, callback, user_param);
+ result = _mmplayer_set_audiostream_cb_ex(player, sync, callback, user_param);
MMPLAYER_CMD_UNLOCK( player );
return result;
}
-int mm_player_set_video_frame_render_error_callback(MMHandleType player, mm_player_video_frame_render_error_callback callback, void *user_param)
-{
- int result = MM_ERROR_NONE;
-
- return_val_if_fail(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
-
- MMPLAYER_CMD_LOCK( player );
-
- result = _mmplayer_set_videoframe_render_error_cb(player, callback, user_param);
-
- MMPLAYER_CMD_UNLOCK( player );
-
- return result;
-}
-
-int mm_player_do_video_capture(MMHandleType player)
-{
- int result = MM_ERROR_NONE;
-
- return_val_if_fail(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
-
- MMPLAYER_CMD_LOCK( player );
-
- result = _mmplayer_do_video_capture(player);
-
- MMPLAYER_CMD_UNLOCK( player );
-
- return result;
-}
-
-int mm_player_set_prepare_buffering_time(MMHandleType player, int second)
+int mm_player_set_video_stream_callback(MMHandleType player, mm_player_video_stream_callback callback, void *user_param)
{
int result = MM_ERROR_NONE;
MMPLAYER_CMD_LOCK( player );
- result = _mmplayer_set_prepare_buffering_time(player, second);
+ result = _mmplayer_set_videostream_cb(player, callback, user_param);
MMPLAYER_CMD_UNLOCK( player );
return result;
}
-int mm_player_set_runtime_buffering_mode(MMHandleType player, MMPlayerBufferingMode mode, int second)
+int mm_player_set_video_frame_render_error_callback(MMHandleType player, mm_player_video_frame_render_error_callback callback, void *user_param)
{
int result = MM_ERROR_NONE;
MMPLAYER_CMD_LOCK( player );
- result = _mmplayer_set_runtime_buffering_mode(player, mode, second);
+ result = _mmplayer_set_videoframe_render_error_cb(player, callback, user_param);
MMPLAYER_CMD_UNLOCK( player );
return result;
}
-int mm_player_set_buffer_need_data_callback(MMHandleType player, mm_player_buffer_need_data_callback callback, void * user_param)
+int mm_player_do_video_capture(MMHandleType player)
{
int result = MM_ERROR_NONE;
MMPLAYER_CMD_LOCK( player );
- result = _mmplayer_set_buffer_need_data_cb(player, callback, user_param);
+ result = _mmplayer_do_video_capture(player);
MMPLAYER_CMD_UNLOCK( player );
return result;
}
-int mm_player_set_buffer_enough_data_callback(MMHandleType player, mm_player_buffer_enough_data_callback callback, void * user_param)
+int mm_player_set_prepare_buffering_time(MMHandleType player, int second)
{
int result = MM_ERROR_NONE;
MMPLAYER_CMD_LOCK( player );
- result = _mmplayer_set_buffer_enough_data_cb(player, callback, user_param);
+ result = _mmplayer_set_prepare_buffering_time(player, second);
MMPLAYER_CMD_UNLOCK( player );
return result;
}
-
-int mm_player_set_buffer_seek_data_callback(MMHandleType player, mm_player_buffer_seek_data_callback callback, void * user_param)
+int mm_player_set_runtime_buffering_mode(MMHandleType player, MMPlayerBufferingMode mode, int second)
{
int result = MM_ERROR_NONE;
MMPLAYER_CMD_LOCK( player );
- result = _mmplayer_set_buffer_seek_data_cb(player, callback, user_param);
+ result = _mmplayer_set_runtime_buffering_mode(player, mode, second);
MMPLAYER_CMD_UNLOCK( player );
return_val_if_fail(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
-// result = _mmplayer_asm_ignore_session(player);
+ result = _mmplayer_asm_ignore_session(player);
return result;
}
return result;
}
+
+void * mm_player_media_packet_video_stream_internal_buffer_ref(void *buffer)
+{
+ void * result;
+ result = _mm_player_media_packet_video_stream_internal_buffer_ref(buffer);
+
+ return result;
+}
+
+void mm_player_media_packet_video_stream_internal_buffer_unref(void *buffer)
+{
+ _mm_player_media_packet_video_stream_internal_buffer_unref(buffer);
+}
+
+#ifdef TEST_ES
+int mm_player_submit_packet(MMHandleType player, media_packet_h packet)
+{
+
+ int result = MM_ERROR_NONE;
+
+ return_val_if_fail(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
+
+ /* no lock here, otherwise callback for the "need-data" signal of appsrc will be blocking */
+ //MMPLAYER_CMD_LOCK( player );
+
+ result = _mmplayer_submit_packet(player, packet);
+
+ //MMPLAYER_CMD_UNLOCK( player );
+
+ return result;
+}
+
+int mm_player_set_video_info (MMHandleType player, media_format_h format)
+{
+ int result = MM_ERROR_NONE;
+
+ debug_log("\n");
+
+ return_val_if_fail(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
+
+ MMPLAYER_CMD_LOCK( player );
+
+ result = _mmplayer_set_video_info(player, format);
+
+ MMPLAYER_CMD_UNLOCK( player );
+
+ return result;
+
+}
+
+int mm_player_set_audio_info (MMHandleType player, media_format_h format)
+{
+ int result = MM_ERROR_NONE;
+
+ debug_log("\n");
+
+ return_val_if_fail(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
+
+ MMPLAYER_CMD_LOCK( player );
+
+ result = _mmplayer_set_audio_info(player, format);
+
+ MMPLAYER_CMD_UNLOCK( player );
+
+ return result;
+}
+
+int mm_player_set_subtitle_info (MMHandleType player, MMPlayerSubtitleStreamInfo *subtitle_stream_info)
+{
+ int result = MM_ERROR_NONE;
+
+ debug_log("\n");
+
+ return_val_if_fail(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
+
+ MMPLAYER_CMD_LOCK( player );
+
+ result = _mmplayer_set_subtitle_info(player, subtitle_stream_info);
+
+ MMPLAYER_CMD_UNLOCK( player );
+
+ return result;
+}
+
+int mm_player_set_media_stream_buffer_max_size(MMHandleType player, MMPlayerStreamType type, unsigned long long max_size)
+{
+ int result = MM_ERROR_NONE;
+
+ debug_log("\n");
+
+ return_val_if_fail(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
+
+ MMPLAYER_CMD_LOCK( player );
+
+ result = _mmplayer_set_media_stream_max_size(player, type, max_size);
+
+ MMPLAYER_CMD_UNLOCK( player );
+
+ return result;
+}
+
+int mm_player_get_media_stream_buffer_max_size(MMHandleType player, MMPlayerStreamType type, unsigned long long *max_size)
+{
+ int result = MM_ERROR_NONE;
+
+ debug_log("\n");
+
+ return_val_if_fail(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
+ return_val_if_fail(max_size, MM_ERROR_INVALID_ARGUMENT);
+
+ MMPLAYER_CMD_LOCK( player );
+
+ result = _mmplayer_get_media_stream_max_size(player, type, max_size);
+
+ MMPLAYER_CMD_UNLOCK( player );
+
+ return result;
+}
+
+int mm_player_set_media_stream_buffer_min_percent(MMHandleType player, MMPlayerStreamType type, unsigned min_percent)
+{
+ int result = MM_ERROR_NONE;
+
+ debug_log("\n");
+
+ return_val_if_fail(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
+
+ MMPLAYER_CMD_LOCK( player );
+
+ result = _mmplayer_set_media_stream_min_percent(player, type, min_percent);
+
+ MMPLAYER_CMD_UNLOCK( player );
+
+ return result;
+}
+
+int mm_player_get_media_stream_buffer_min_percent(MMHandleType player, MMPlayerStreamType type, unsigned int *min_percent)
+{
+ int result = MM_ERROR_NONE;
+
+ debug_log("\n");
+
+ return_val_if_fail(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
+ return_val_if_fail(min_percent, MM_ERROR_INVALID_ARGUMENT);
+
+ MMPLAYER_CMD_LOCK( player );
+
+ result = _mmplayer_get_media_stream_min_percent(player, type, min_percent);
+
+ MMPLAYER_CMD_UNLOCK( player );
+
+ 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 result = MM_ERROR_NONE;
+
+ debug_log("\n");
+
+ return_val_if_fail(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
+
+ MMPLAYER_CMD_LOCK( player );
+
+ result = _mmplayer_set_media_stream_buffer_status_cb(player, type, callback, user_param);
+
+ MMPLAYER_CMD_UNLOCK( player );
+
+ 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 result = MM_ERROR_NONE;
+
+ debug_log("\n");
+
+ return_val_if_fail(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
+
+ MMPLAYER_CMD_LOCK( player );
+
+ result = _mmplayer_set_media_stream_seek_data_cb(player, type, callback, user_param);
+
+ MMPLAYER_CMD_UNLOCK( player );
+
+ return result;
+}
+
+int mm_player_set_audio_stream_changed_callback(MMHandleType player, mm_player_stream_changed_callback callback, void *user_param)
+{
+ int result = MM_ERROR_NONE;
+
+ return_val_if_fail(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
+
+ MMPLAYER_CMD_LOCK( player );
+
+ result = _mmplayer_set_audiostream_changed_cb(player, callback, user_param);
+
+ MMPLAYER_CMD_UNLOCK( player );
+
+ return result;
+}
+
+int mm_player_set_video_stream_changed_callback(MMHandleType player, mm_player_stream_changed_callback callback, void *user_param)
+{
+ int result = MM_ERROR_NONE;
+
+ return_val_if_fail(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
+
+ MMPLAYER_CMD_LOCK( player );
+
+ result = _mmplayer_set_videostream_changed_cb(player, callback, user_param);
+
+ MMPLAYER_CMD_UNLOCK( player );
+
+ return result;
+}
+
+#endif
--- /dev/null
+/*
+ * libmm-player
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: JongHyuk Choi <jhchoi.choi@samsung.com>, YeJin Cho <cho.yejin@samsung.com>,
+ * Seungbae Shin <seungbae.shin@samsung.com>, YoungHwan An <younghwan_.an@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <mm_debug.h>
+#include <mm_error.h>
+#include "mm_player_utils.h"
+#include "mm_player_priv.h"
+#include "mm_player_asm.h"
+#include <vconf.h>
+#include <vconf-internal-sound-keys.h>
+
+#define MMPLAYER_CHECK_SESSION_SKIP(x_player_asm) \
+do \
+{ \
+ if (x_player_asm->skip_session == TRUE) \
+ { \
+ debug_log("skip session"); \
+ return MM_ERROR_NONE; \
+ } \
+}while(0);
+
+#define MMPLAYER_CHECK_SESSION_INSTANCE(x_player_asm) \
+do \
+{ \
+ if (!x_player_asm) \
+ { \
+ debug_log("no session instance");\
+ return MM_ERROR_SOUND_NOT_INITIALIZED; \
+ } \
+}while(0);
+
+static ASM_sound_events_t __mmplayer_asm_get_event_type(gint type);
+
+const gchar *
+__mmplayer_asm_get_state_name ( int state )
+{
+ switch ( state )
+ {
+ case ASM_STATE_NONE:
+ return "NONE";
+ case ASM_STATE_PLAYING:
+ return "PLAYING";
+ case ASM_STATE_PAUSE:
+ return "PAUSED";
+ case ASM_STATE_STOP:
+ return "STOP";
+ case ASM_STATE_WAITING:
+ return "BUFFERING";
+ default:
+ return "INVAID";
+ }
+}
+
+#define MMPLAYER_ASM_STATE_GET_NAME(state) __mmplayer_asm_get_state_name(state)
+
+gint
+_mmplayer_asm_register(MMPlayerASM* sm, ASM_sound_cb_t callback, void* param)
+{
+ return MM_ERROR_NONE;
+
+ gint session_type = MM_SESSION_TYPE_MEDIA;
+ gint session_options = 0;
+ gint errorcode = MM_ERROR_NONE;
+ gint asm_handle = -1;
+ gint event_type = ASM_EVENT_NONE;
+ gint pid = -1;
+
+ MMPLAYER_FENTER();
+
+ MMPLAYER_CHECK_SESSION_INSTANCE(sm);
+ MMPLAYER_CHECK_SESSION_SKIP(sm);
+
+ /* check if it's running on the media_server */
+ if ( sm->pid > 0 )
+ {
+ pid = sm->pid;
+ debug_log("mm-player is running on different process. Just faking pid to [%d]. :-p\n", pid);
+ }
+
+ /* read session information */
+ errorcode = _mm_session_util_read_information(pid, &session_type, &session_options);
+ if ( errorcode )
+ {
+ debug_warning("Read Session Type failed. use default \"media\" type\n");
+ session_type = MM_SESSION_TYPE_MEDIA;
+ }
+
+ /* interpret session information */
+ event_type = __mmplayer_asm_get_event_type(session_type);
+
+ /* check if it's one of CALL series */
+ if ( event_type == ASM_EVENT_CALL ||
+ event_type == ASM_EVENT_VIDEOCALL ||
+ event_type == ASM_EVENT_VOIP)
+ {
+ debug_warning("session type is one of CALL series(%d), skip registering ASM\n", session_type);
+ sm->event = event_type;
+ sm->skip_session = TRUE;
+ return MM_ERROR_NONE;
+ }
+
+ /* register audio-session-manager handle and callback */
+ if( ! ASM_register_sound(pid, &asm_handle, event_type, ASM_STATE_NONE, callback, (void*)param, ASM_RESOURCE_NONE, &errorcode))
+ {
+ debug_error("ASM_register_sound() failed, error(%x)\n", errorcode);
+ return errorcode;
+ }
+ /* set session options */
+ if (session_options)
+ {
+ if( ! ASM_set_session_option(asm_handle, session_options, &errorcode))
+ {
+ debug_error("ASM_set_session_options() failed, error(%x)\n", errorcode);
+ return errorcode;
+ }
+ }
+
+ /* now succeed to register our callback. take result */
+ sm->handle = asm_handle;
+ sm->state = ASM_STATE_NONE;
+ sm->event = event_type;
+
+ MMPLAYER_FLEAVE();
+
+ return MM_ERROR_NONE;
+}
+
+gint
+_mmplayer_asm_unregister(MMPlayerASM* sm)
+{
+ gint event_type = ASM_EVENT_NONE;
+ gint errorcode = 0;
+ gint pid = -1;
+
+ MMPLAYER_FENTER();
+
+ MMPLAYER_CHECK_SESSION_INSTANCE(sm);
+ MMPLAYER_CHECK_SESSION_SKIP(sm);
+
+ /* check if it's running on the media_server */
+ if ( sm->pid > 0 )
+ {
+ pid = sm->pid;
+ debug_log("mm-player is running on different process. Just faking pid to [%d]. :-p\n", pid);
+ }
+
+ event_type = sm->event;
+
+ if (sm->handle)
+ {
+ if( ! ASM_unregister_sound( sm->handle, event_type, &errorcode) )
+ {
+ debug_error("Unregister sound failed 0x%X\n", errorcode);
+ return MM_ERROR_POLICY_INTERNAL;
+ }
+ }
+ debug_warning("asm unregistered");
+
+ MMPLAYER_FLEAVE();
+
+ return MM_ERROR_NONE;
+}
+
+gint _mmplayer_asm_set_state(MMHandleType hplayer, ASM_sound_states_t state, gboolean enable_safety_vol)
+{
+ return MM_ERROR_NONE;
+
+ gint event_type = ASM_EVENT_NONE;
+ gint pid = -1;
+// int vconf_safety_vol_val = 0;
+ ASM_resource_t resource = ASM_RESOURCE_NONE;
+ mm_player_t *player = (mm_player_t *)hplayer;
+ MMPlayerASM* sm = &player->sm;
+ MMPLAYER_FENTER();
+
+#if 0
+ if (player->set_mode.safety_volume)
+ {
+ /* get safety volume */
+ if (vconf_get_int(VCONFKEY_SOUND_ENABLE_SAFETY_VOL, &vconf_safety_vol_val))
+ {
+ debug_error ("failed to get safety volume");
+ }
+
+ if (enable_safety_vol)
+ {
+ vconf_safety_vol_val = vconf_safety_vol_val | VCONFKEY_SOUND_SAFETY_VOL_FW_MMPLAYER;
+ }
+ else
+ {
+ vconf_safety_vol_val = vconf_safety_vol_val & ~VCONFKEY_SOUND_SAFETY_VOL_FW_MMPLAYER;
+ }
+
+ /* set safety volume */
+ if (vconf_set_int(VCONFKEY_SOUND_ENABLE_SAFETY_VOL, vconf_safety_vol_val))
+ {
+ debug_error ("failed to set safety volume");
+ }
+ debug_log("safety vol : %d(0:false, 1:true), current result of vconf val : 0x%x", enable_safety_vol, vconf_safety_vol_val);
+ }
+#endif
+ MMPLAYER_CHECK_SESSION_INSTANCE(sm);
+ MMPLAYER_CHECK_SESSION_SKIP(sm);
+
+ /* check if it's running on the media_server */
+ if ( sm->pid > 0 )
+ {
+ pid = sm->pid;
+ debug_log("mm-player is running on different process. Just faking pid to [%d]. :-p\n", pid);
+ }
+
+ /* in case of stop, it should be stop first and post interrupt message to application */
+ if ( !sm->by_asm_cb || state == ASM_STATE_STOP)//|| sm->state == ASM_STATE_PLAYING )
+ {
+ int ret = 0;
+ event_type = sm->event;
+ resource = sm->resource;
+
+ /* check if there is video */
+ /* NOTE: resource can be set as NONE when it's not occupied or unknown resource is used. */
+ if(ASM_STATE_PLAYING == state || ASM_STATE_PAUSE == state || ASM_STATE_WAITING == state)
+ {
+ int surface_type = 0;
+ mm_attrs_get_int_by_name (player->attrs, "display_surface_type", &surface_type);
+ debug_log("surface type = %d", surface_type);
+
+ if (player->pipeline && player->pipeline->videobin)
+ {
+ if(surface_type == MM_DISPLAY_SURFACE_X)
+ {
+ resource = ASM_RESOURCE_VIDEO_OVERLAY | ASM_RESOURCE_HW_DECODER;
+ }
+ else if (surface_type == MM_DISPLAY_SURFACE_EVAS)
+ {
+ resource = ASM_RESOURCE_HW_DECODER;
+ }
+ }
+
+ if( __mmplayer_is_streaming (player))
+ resource = resource | ASM_RESOURCE_STREAMING;
+
+ /* reset */
+ sm->keep_last_pos = FALSE;
+ }
+
+ if( ((sm->state != state) || (sm->resource != resource)) && ! ASM_set_sound_state( sm->handle, event_type, state, resource, &ret) )
+ {
+ gint retval = MM_ERROR_POLICY_INTERNAL;
+
+ debug_error("Set state to [%d] failed 0x%X\n", state, ret);
+ switch(ret)
+ {
+ case ERR_ASM_POLICY_CANNOT_PLAY:
+ case ERR_ASM_POLICY_CANNOT_PLAY_BY_CALL:
+ case ERR_ASM_POLICY_CANNOT_PLAY_BY_ALARM:
+ retval = MM_ERROR_POLICY_BLOCKED;
+ break;
+ default:
+ retval = MM_ERROR_POLICY_INTERNAL;
+ break;
+ }
+
+ return retval;
+ }
+ }
+ else
+ {
+ sm->by_asm_cb = FALSE;
+ }
+
+ sm->state = state;
+
+ /* waiting to be changed because callback can be called */
+ if (ASM_STATE_STOP == state)
+ {
+ ASM_sound_states_t session_state;
+ ASM_get_sound_state(sm->handle, event_type, &session_state, NULL);
+ }
+
+ debug_error("ASM state changed to [%s]", MMPLAYER_ASM_STATE_GET_NAME(state));
+ MMPLAYER_FLEAVE();
+ return MM_ERROR_NONE;
+}
+
+static ASM_sound_events_t
+__mmplayer_asm_get_event_type(gint type)
+{
+ gint event_type = ASM_EVENT_NONE;
+
+ /* interpret session type */
+ switch(type)
+ {
+ case MM_SESSION_TYPE_CALL:
+ event_type = ASM_EVENT_CALL;
+ break;
+
+ case MM_SESSION_TYPE_VIDEOCALL:
+ event_type = ASM_EVENT_VIDEOCALL;
+ break;
+
+ case MM_SESSION_TYPE_VOIP:
+ event_type = ASM_EVENT_VOIP;
+ break;
+
+ case MM_SESSION_TYPE_MEDIA:
+// case MM_SESSION_TYPE_MEDIA_RECORD:
+ event_type = ASM_EVENT_MEDIA_MMPLAYER;
+ break;
+
+ case MM_SESSION_TYPE_NOTIFY:
+ event_type = ASM_EVENT_NOTIFY;
+ break;
+
+ case MM_SESSION_TYPE_ALARM:
+ event_type = ASM_EVENT_ALARM;
+ break;
+
+ case MM_SESSION_TYPE_EMERGENCY:
+ event_type = ASM_EVENT_EMERGENCY;
+ break;
+#if 0
+ case MM_SESSION_TYPE_RECORD_VIDEO:
+ case MM_SESSION_TYPE_RECORD_AUDIO:
+ event_type = ASM_EVENT_MEDIA_MMPLAYER;
+ break;
+#endif
+
+ default:
+ debug_msg("unexpected case!\n");
+ event_type = ASM_EVENT_MEDIA_MMPLAYER;
+ break;
+ }
+
+ return event_type;
+}
+
+gint
+_mmplayer_asm_ignore_session(MMHandleType hplayer)
+{
+ mm_player_t *player = (mm_player_t *)hplayer;
+
+ MMPLAYER_FENTER();
+
+ return_val_if_fail (player, MM_ERROR_PLAYER_NOT_INITIALIZED);
+
+ /* check state */
+ if (player->state != MM_PLAYER_STATE_NULL)
+ {
+ debug_log("invalid state to make session mix");
+ return MM_ERROR_PLAYER_INVALID_STATE;
+ }
+
+ if (player->sm.skip_session == FALSE && player->sm.handle)
+ {
+ int error_code = 0;
+
+ if (!ASM_unregister_sound(player->sm.handle, player->sm.event, &error_code))
+ {
+ debug_error("Unregister sound failed 0x%X", error_code);
+ return MM_ERROR_POLICY_INTERNAL;
+ }
+ player->sm.skip_session = TRUE;
+ player->sm.handle = 0;
+
+ debug_log("session skip enabled");
+ }
+
+ MMPLAYER_FLEAVE();
+
+ return MM_ERROR_NONE;
+}
MMPLAYER_MAX_INT
},
{
+ "sound_stream_type",
+ MM_ATTRS_TYPE_STRING,
+ MM_ATTRS_FLAG_RW,
+ (void *) NULL,
+ MM_ATTRS_VALID_TYPE_NONE,
+ 0,
+ 0
+ },
+ {
+ "sound_stream_index",
+ MM_ATTRS_TYPE_INT,
+ MM_ATTRS_FLAG_RW,
+ 0,
+ MM_ATTRS_VALID_TYPE_INT_RANGE,
+ 0,
+ MMPLAYER_MAX_INT
+ },
+ {
"sound_route",
MM_ATTRS_TYPE_INT,
MM_ATTRS_FLAG_RW,
{
mm_player_t *player = NULL;
int result = MM_ERROR_NONE;
- mm_sound_device_in device_in = MM_SOUND_DEVICE_IN_NONE;
- mm_sound_device_out device_out = MM_SOUND_DEVICE_OUT_NONE;
+ mm_sound_device_flags_e flags = MM_SOUND_DEVICE_IO_DIRECTION_OUT_FLAG | MM_SOUND_DEVICE_STATE_ACTIVATED_FLAG;
+ MMSoundDeviceList_t device_list;
+ MMSoundDevice_t device_h = NULL;
+ mm_sound_device_type_e device_type;
int i = 0;
MMPLAYER_FENTER();
player = MM_PLAYER_CAST(hplayer);
/* get status if speaker is activated */
- result = mm_sound_get_active_device(&device_in, &device_out);
+ /* (1) get current device list */
+ result = mm_sound_get_current_device_list(flags, &device_list);
+
+ if ( result ) {
+ debug_error("mm_sound_get_current_device_list() failed [%x]!!", result);
+ MMPLAYER_FLEAVE();
+ return result;
+ }
+
+ /* (2) get device handle of device list */
+ result = mm_sound_get_next_device (device_list, &device_h);
+
+ if ( result ) {
+ debug_error("mm_sound_get_next_device() failed [%x]!!", result);
+ MMPLAYER_FLEAVE();
+ return result;
+ }
+
+ /* (3) get device type */
+ result = mm_sound_get_device_type(device_h, &device_type);
+
if ( result ) {
+ debug_error("mm_sound_get_device_type() failed [%x]!!", result);
MMPLAYER_FLEAVE();
- debug_error("mm_sound_get_active_device() failed [%x]!!", result);
return result;
}
{
if (player->ini.audio_effect_preset_list[i] )
{
- if (device_out == MM_SOUND_DEVICE_OUT_SPEAKER &&
+ if (device_type == MM_SOUND_DEVICE_TYPE_BUILTIN_SPEAKER &&
player->ini.audio_effect_preset_earphone_only_list[i])
{
continue;
{
if (player->ini.audio_effect_custom_list[i] )
{
- if (device_out == MM_SOUND_DEVICE_OUT_SPEAKER &&
+ if (device_type == MM_SOUND_DEVICE_TYPE_BUILTIN_SPEAKER &&
player->ini.audio_effect_custom_earphone_only_list[i])
{
continue;
__mmplayer_audio_set_output_type (mm_player_t *player, MMAudioEffectType effect_type, int effect)
{
GstElement *audio_effect_element = NULL;
- mm_sound_device_in device_in = MM_SOUND_DEVICE_IN_NONE;
- mm_sound_device_out device_out = MM_SOUND_DEVICE_OUT_NONE;
+ mm_sound_device_flags_e flags = MM_SOUND_DEVICE_ALL_FLAG;
+ MMSoundDeviceList_t device_list;
+ MMSoundDevice_t device_h = NULL;
+ mm_sound_device_type_e device_type;
int output_type = 0;
int result = MM_ERROR_NONE;
audio_effect_element = player->pipeline->audiobin[MMPLAYER_A_FILTER].gst;
- result = mm_sound_get_active_device(&device_in, &device_out);
+ /* (1) get current device list */
+ result = mm_sound_get_current_device_list(flags, &device_list);
if ( result ) {
- debug_error("mm_sound_get_active_device() failed [%x]!!", result);
+ debug_error("mm_sound_get_current_device_list() failed [%x]!!", result);
+ MMPLAYER_FLEAVE();
+ return result;
+ }
+
+ /* (2) get device handle of device list */
+ result = mm_sound_get_next_device (device_list, &device_h);
+
+ if ( result ) {
+ debug_error("mm_sound_get_next_device() failed [%x]!!", result);
+ MMPLAYER_FLEAVE();
+ return result;
+ }
+
+ /* (3) get device type */
+ result = mm_sound_get_device_type(device_h, &device_type);
+
+ if ( result ) {
+ debug_error("mm_sound_get_device_type() failed [%x]!!", result);
MMPLAYER_FLEAVE();
return result;
}
/* SPEAKER case */
- if (device_out == MM_SOUND_DEVICE_OUT_SPEAKER)
+ if (device_type == MM_SOUND_DEVICE_TYPE_BUILTIN_SPEAKER)
{
if ( MM_AUDIO_EFFECT_TYPE_SQUARE != effect_type ) {
if (__mmplayer_is_earphone_only_effect_type(player, effect_type, effect))
output_type = MM_AUDIO_EFFECT_OUTPUT_SPK;
}
-// else if (device_out == MM_SOUND_DEVICE_OUT_MIRRORING)
-// {
-// output_type = MM_AUDIO_EFFECT_OUTPUT_OTHERS;
-// }
- else if (device_out == MM_SOUND_DEVICE_OUT_HDMI)
+ else if (device_type == MM_SOUND_DEVICE_TYPE_MIRRORING)
+ {
+ output_type = MM_AUDIO_EFFECT_OUTPUT_OTHERS;
+ }
+ else if (device_type == MM_SOUND_DEVICE_TYPE_HDMI)
{
output_type = MM_AUDIO_EFFECT_OUTPUT_HDMI;
}
- else if(device_out == MM_SOUND_DEVICE_OUT_BT_A2DP)
+ else if (device_type == MM_SOUND_DEVICE_TYPE_BLUETOOTH)
{
output_type = MM_AUDIO_EFFECT_OUTPUT_BT;
}
-// else if(device_out == MM_SOUND_DEVICE_OUT_DOCK)
-// {
-// output_type = MM_AUDIO_EFFECT_OUTPUT_DOCK;
-// }
-// else if(device_out == MM_SOUND_DEVICE_OUT_MULTIMEDIA_DOCK)
-// {
-// output_type = MM_AUDIO_EFFECT_OUTPUT_MULTIMEDIA_DOCK;
-// }
- else if(device_out == MM_SOUND_DEVICE_OUT_USB_AUDIO)
+ else if (device_type == MM_SOUND_DEVICE_TYPE_USB_AUDIO)
{
output_type = MM_AUDIO_EFFECT_OUTPUT_USB_AUDIO;
}
_mmplayer_is_supported_effect_type(mm_player_t* player, MMAudioEffectType effect_type, int effect)
{
gboolean result = TRUE;
- mm_sound_device_in device_in = MM_SOUND_DEVICE_IN_NONE;
- mm_sound_device_out device_out = MM_SOUND_DEVICE_OUT_NONE;
+ mm_sound_device_flags_e flags = MM_SOUND_DEVICE_ALL_FLAG;
+ MMSoundDeviceList_t device_list;
+ MMSoundDevice_t device_h = NULL;
+ mm_sound_device_type_e device_type;
int ret = MM_ERROR_NONE;
MMPLAYER_FENTER();
/* get status if speaker is activated */
- ret = mm_sound_get_active_device(&device_in, &device_out);
- if ( ret ) {
+ /* (1) get current device list */
+ ret = mm_sound_get_current_device_list(flags, &device_list);
+ if (ret) {
MMPLAYER_FLEAVE();
- debug_error("mm_sound_get_active_device() failed [%x]!!", ret);
- result = FALSE;
+ debug_error("mm_sound_get_current_device_list() failed [%x]!!", ret);
+ return FALSE;
}
- else
+
+ /* (2) get device handle of device list */
+ ret = mm_sound_get_next_device (device_list, &device_h);
+
+ if (ret) {
+ debug_error("mm_sound_get_next_device() failed [%x]!!", ret);
+ MMPLAYER_FLEAVE();
+ return FALSE;
+ }
+
+ /* (3) get device type */
+ ret = mm_sound_get_device_type(device_h, &device_type);
+
+ if (ret) {
+ debug_error("mm_sound_get_device_type() failed [%x]!!", ret);
+ MMPLAYER_FLEAVE();
+ return FALSE;
+ }
+
+ /* preset */
+ if (effect_type == MM_AUDIO_EFFECT_TYPE_PRESET)
{
- /* preset */
- if (effect_type == MM_AUDIO_EFFECT_TYPE_PRESET)
+ if ( effect < MM_AUDIO_EFFECT_PRESET_AUTO || effect >= MM_AUDIO_EFFECT_PRESET_NUM )
+ {
+ debug_error("out of range, preset effect(%d)", effect);
+ result = FALSE;
+ }
+ else
{
- if ( effect < MM_AUDIO_EFFECT_PRESET_AUTO || effect >= MM_AUDIO_EFFECT_PRESET_NUM )
+ if (!player->ini.audio_effect_preset_list[effect])
{
- debug_error("out of range, preset effect(%d)", effect);
+ debug_error("this effect(%d) is not supported", effect);
result = FALSE;
}
else
{
- if (!player->ini.audio_effect_preset_list[effect])
+ if (device_type == MM_SOUND_DEVICE_TYPE_BUILTIN_SPEAKER &&
+ player->ini.audio_effect_preset_earphone_only_list[effect])
{
- debug_error("this effect(%d) is not supported", effect);
result = FALSE;
}
- else
- {
- if (device_out == MM_SOUND_DEVICE_OUT_SPEAKER &&
- player->ini.audio_effect_preset_earphone_only_list[effect])
- {
- result = FALSE;
- }
- }
}
}
- /* custom */
- else if (effect_type == MM_AUDIO_EFFECT_TYPE_CUSTOM)
+ }
+ /* custom */
+ else if (effect_type == MM_AUDIO_EFFECT_TYPE_CUSTOM)
+ {
+ if ( effect < MM_AUDIO_EFFECT_CUSTOM_EQ || effect >= MM_AUDIO_EFFECT_CUSTOM_NUM )
{
- if ( effect < MM_AUDIO_EFFECT_CUSTOM_EQ || effect >= MM_AUDIO_EFFECT_CUSTOM_NUM )
+ debug_error("out of range, custom effect(%d)", effect);
+ result = FALSE;
+ }
+ else
+ {
+ if (!player->ini.audio_effect_custom_list[effect])
{
- debug_error("out of range, custom effect(%d)", effect);
+ debug_error("this custom effect(%d) is not supported", effect);
result = FALSE;
}
else
{
- if (!player->ini.audio_effect_custom_list[effect])
+ if (device_type == MM_SOUND_DEVICE_TYPE_BUILTIN_SPEAKER &&
+ player->ini.audio_effect_custom_earphone_only_list[effect])
{
- debug_error("this custom effect(%d) is not supported", effect);
result = FALSE;
}
- else
- {
- if (device_out == MM_SOUND_DEVICE_OUT_SPEAKER &&
- player->ini.audio_effect_custom_earphone_only_list[effect])
- {
- result = FALSE;
- }
- }
}
}
- else if (effect_type == MM_AUDIO_EFFECT_TYPE_SQUARE)
- {
- if (!player->ini.use_audio_effect_custom)
- {
- debug_error("Square effect is not supported");
- result = FALSE;
- }
- }
- else
+ }
+ else if (effect_type == MM_AUDIO_EFFECT_TYPE_SQUARE)
+ {
+ if (!player->ini.use_audio_effect_custom)
{
- debug_error("invalid effect type(%d)", effect_type);
+ debug_error("Square effect is not supported");
result = FALSE;
}
}
+ else
+ {
+ debug_error("invalid effect type(%d)", effect_type);
+ result = FALSE;
+ }
+
MMPLAYER_FLEAVE();
/* create video capture thread */
player->capture_thread =
- g_thread_try_new ("capture_thread",__mmplayer_capture_thread, (gpointer)player, NULL);
+ g_thread_try_new ("capture_thread",__mmplayer_capture_thread, (gpointer)player, NULL);
if ( ! player->capture_thread )
{
{
return_val_if_fail ( player, MM_ERROR_PLAYER_NOT_INITIALIZED );
/* release capture thread */
- if (player->capture_thread)
- {
- g_mutex_lock(&player->capture_thread_mutex);
- player->capture_thread_exit = TRUE;
- g_cond_signal( &player->capture_thread_cond );
- g_mutex_unlock(&player->capture_thread_mutex);
+ g_mutex_lock(&player->capture_thread_mutex);
+ player->capture_thread_exit = TRUE;
+ g_cond_signal( &player->capture_thread_cond );
+ g_mutex_unlock(&player->capture_thread_mutex);
- debug_log("waitting for capture thread exit");
- g_thread_join ( player->capture_thread );
- g_mutex_clear(&player->capture_thread_mutex );
- g_cond_clear(&player->capture_thread_cond );
- debug_log("capture thread released");
- }
+ debug_log("waitting for capture thread exit");
+ g_thread_join ( player->capture_thread );
+ g_mutex_clear(&player->capture_thread_mutex );
+ g_cond_clear(&player->capture_thread_cond );
+ debug_log("capture thread released");
return MM_ERROR_NONE;
}
return_val_if_fail(player && player->pipeline, MM_ERROR_PLAYER_NOT_INITIALIZED);
/* capturing or not */
- if (player->video_capture_cb_probe_id || player->capture.data || player->captured.a[0] || player->captured.a[1])
+ if (player->video_capture_cb_probe_id || player->capture.data
+ || player->captured.data[0] || player->captured.data[1]
+ )
{
debug_warning("capturing... we can't do any more");
return MM_ERROR_PLAYER_INVALID_STATE;
if (orientation == 90 || orientation == 270)
{
- dst_width = player->captured.h[0];
- dst_height = player->captured.w[0];
+ dst_width = player->captured.height[0];
+ dst_height = player->captured.width[0];
debug_log ("interchange width & height");
}
else if (orientation == 180)
{
- dst_width = player->captured.w[0];
- dst_height = player->captured.h[0];
+ dst_width = player->captured.width[0];
+ dst_height = player->captured.height[0];
}
else if (orientation == 0)
{
debug_error ("no need handle orientation : %d", orientation);
- player->capture.width = player->captured.w[0];
- player->capture.height = player->captured.h[0];
+ player->capture.width = player->captured.width[0];
+ player->capture.height = player->captured.height[0];
return MM_ERROR_NONE;
}
else
debug_log ("source buffer for rotation = %p and rotation = %d", src_buffer, rot_enum);
- ret = mm_util_rotate_image (src_buffer, player->captured.w[0], player->captured.h[0], format,
- dst_frame, &dst_width, &dst_height, rot_enum);
+ ret = mm_util_rotate_image (src_buffer,
+ player->captured.width[0], player->captured.height[0], format,
+ dst_frame, &dst_width, &dst_height, rot_enum);
if (ret != MM_ERROR_NONE)
{
debug_error("failed to do rotate image");
player->capture.width = dst_width;
player->capture.height= dst_height;
- player->captured.w[0] = player->captured.s[0] = dst_width;
- player->captured.h[0] = player->captured.e[0] = dst_height;
+ player->captured.width[0] = player->captured.stride_width[0] = dst_width;
+ player->captured.height[0] = player->captured.stride_height[0] = dst_height;
return ret;
}
return_val_if_fail(player, NULL);
- g_mutex_lock(&player->capture_thread_mutex);
-
while (!player->capture_thread_exit)
{
debug_log("capture thread started. waiting for signal");
+ g_mutex_lock(&player->capture_thread_mutex);
g_cond_wait(&player->capture_thread_cond, &player->capture_thread_mutex );
if ( player->capture_thread_exit )
int ret = 0;
int linear_y_plane_size;
int linear_uv_plane_size;
+ int width = player->captured.width[0];
+ int height = player->captured.height[0];
unsigned char * src_buffer = NULL;
- linear_y_plane_size = (player->captured.w[0] * player->captured.h[0]);
- linear_uv_plane_size = (player->captured.w[0] * player->captured.h[0]/2);
+ linear_y_plane_size = (width * height);
+ linear_uv_plane_size = (width * height / 2);
linear_y_plane = (unsigned char*) g_try_malloc(linear_y_plane_size);
if (linear_y_plane == NULL)
goto ERROR;
}
/* NV12 tiled to linear */
- __csc_tiled_to_linear_crop(linear_y_plane, player->captured.a[0], player->captured.w[0], player->captured.h[0], 0,0,0,0);
- __csc_tiled_to_linear_crop(linear_uv_plane, player->captured.a[1], player->captured.w[0], player->captured.h[0]/2, 0,0,0,0);
+ __csc_tiled_to_linear_crop(linear_y_plane,
+ player->captured.data[0], width, height, 0,0,0,0);
+ __csc_tiled_to_linear_crop(linear_uv_plane,
+ player->captured.data[1], width, height / 2, 0,0,0,0);
- MMPLAYER_FREEIF(player->captured.a[0]);
- MMPLAYER_FREEIF(player->captured.a[1]);
+ MMPLAYER_FREEIF(player->captured.data[0]);
+ MMPLAYER_FREEIF(player->captured.data[1]);
src_buffer = (unsigned char*) g_try_malloc(linear_y_plane_size+linear_uv_plane_size);
/* NV12 linear to RGB888 */
ret = __mm_player_convert_colorspace(player, src_buffer, MM_UTIL_IMG_FMT_NV12,
- player->captured.w[0], player->captured.h[0], MM_UTIL_IMG_FMT_RGB888);
+ width, height, MM_UTIL_IMG_FMT_RGB888);
if (ret != MM_ERROR_NONE)
{
int ret = 0;
char *src_buffer = NULL;
/* using original width otherwises, app can't know aligned to resize */
- int width_align = player->captured.w[0];//MM_ALIGN(player->captured.w[0], 8);
- int src_buffer_size = width_align * player->captured.h[0] * 3/2;
+ int width_align = player->captured.width[0];
+ int src_buffer_size = width_align * player->captured.height[0] * 3/2;
int i, j;
char*temp = NULL;
char*dst_buf = NULL;
memset(src_buffer, 0x00, src_buffer_size);
- temp = player->captured.a[0];
+ temp = player->captured.data[0];
dst_buf = src_buffer;
/* set Y plane */
- for (i = 0; i < player->captured.h[0]; i++) {
+ for (i = 0; i < player->captured.height[0]; i++) {
memcpy(dst_buf, temp, width_align);
dst_buf += width_align;
- temp += player->captured.s[0];
+ temp += player->captured.stride_width[0];
}
- temp = player->captured.a[1];
+ temp = player->captured.data[1];
/* set UV plane*/
- for (j = 0; j < player->captured.h[1]; j++) {
+ for (j = 0; j < player->captured.height[1]; j++) {
memcpy(dst_buf, temp, width_align);
dst_buf += width_align;
- temp += player->captured.s[0];
+ temp += player->captured.stride_width[0];
}
/* free captured buf */
- MMPLAYER_FREEIF(player->captured.a[0]);
- MMPLAYER_FREEIF(player->captured.a[1]);
+ MMPLAYER_FREEIF(player->captured.data[0]);
+ MMPLAYER_FREEIF(player->captured.data[1]);
/* NV12 -> RGB888 */
ret = __mm_player_convert_colorspace(player, (unsigned char*)src_buffer, MM_UTIL_IMG_FMT_NV12,
- width_align, player->captured.h[0], MM_UTIL_IMG_FMT_RGB888);
+ width_align, player->captured.height[0], MM_UTIL_IMG_FMT_RGB888);
if (ret != MM_ERROR_NONE)
{
debug_error("failed to convert nv12 linear");
/* clean */
MMPLAYER_FREEIF(linear_y_plane);
MMPLAYER_FREEIF(linear_uv_plane);
- MMPLAYER_FREEIF(player->captured.a[0]);
- MMPLAYER_FREEIF(player->captured.a[1]);
+ MMPLAYER_FREEIF(player->captured.data[0]);
+ MMPLAYER_FREEIF(player->captured.data[1]);
}
msg.union_type = MM_MSG_UNION_CODE;
{
debug_msg ("captured format is ST12\n");
- MMPlayerMPlaneImage *proved = NULL;
+ MMVideoBuffer *proved = NULL;
player->video_cs = MM_PLAYER_COLORSPACE_NV12_TILED;
/* get video frame info from proved buffer */
-// memory = gst_buffer_get_memory(buffer, 1);
memory = gst_buffer_get_all_memory(buffer);
gst_memory_map(memory, &mapinfo, GST_MAP_READ);
- proved = (MMPlayerMPlaneImage *)mapinfo.data;
+ proved = (MMVideoBuffer *)mapinfo.data;
- if ( !proved || !proved->a[0] || !proved->a[1] )
+ if ( !proved || !proved->data[0] || !proved->data[1] )
return MM_ERROR_PLAYER_INTERNAL;
- yplane_size = proved->y_size;
- uvplane_size = proved->uv_size;
+ yplane_size = proved->size[0];
+ uvplane_size = proved->size[1];
debug_msg ("yplane_size=%d, uvplane_size=%d\n", yplane_size, uvplane_size);
- memset(&player->captured, 0x00, sizeof(MMPlayerMPlaneImage));
- memcpy(&player->captured, proved, sizeof(MMPlayerMPlaneImage));
+ memset(&player->captured, 0x00, sizeof(MMVideoBuffer));
+ memcpy(&player->captured, proved, sizeof(MMVideoBuffer));
- player->captured.a[0] = g_try_malloc(yplane_size);
- if ( !player->captured.a[0] ) {
+ player->captured.data[0] = g_try_malloc(yplane_size);
+ if ( !player->captured.data[0] ) {
gst_memory_unmap(memory, &mapinfo);
return MM_ERROR_SOUND_NO_FREE_SPACE;
}
- player->captured.a[1] = g_try_malloc(uvplane_size);
- if ( !player->captured.a[1] ) {
+ player->captured.data[1] = g_try_malloc(uvplane_size);
+ if ( !player->captured.data[1] ) {
gst_memory_unmap(memory, &mapinfo);
return MM_ERROR_SOUND_NO_FREE_SPACE;
}
- memcpy(player->captured.a[0], proved->a[0], yplane_size);
- memcpy(player->captured.a[1], proved->a[1], uvplane_size);
+ memcpy(player->captured.data[0], proved->data[0], yplane_size);
+ memcpy(player->captured.data[1], proved->data[1], uvplane_size);
gst_memory_unmap(memory, &mapinfo);
--- /dev/null
+/*
+ * libmm-player
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: JongHyuk Choi <jhchoi.choi@samsung.com>, heechul jeon <heechul.jeon@samsung.co>,
+ * YoungHwan An <younghwan_.an@samsung.com>, Eunhae Choi <eunhae1.choi@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*===========================================================================================
+| |
+| INCLUDE FILES |
+| |
+========================================================================================== */
+#include "mm_player_es.h"
+#include "mm_player_utils.h"
+#include "mm_player_internal.h"
+
+#include <gst/app/gstappsrc.h>
+
+/*---------------------------------------------------------------------------
+| LOCAL VARIABLE DEFINITIONS for internal |
+---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------
+| 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);
+
+/*===========================================================================================
+| |
+| FUNCTION DEFINITIONS |
+| |
+========================================================================================== */
+
+static int
+_convert_media_format_video_mime_to_str (MMPlayerVideoStreamInfo * video,
+ media_format_mimetype_e mime)
+{
+ return_val_if_fail (video, MM_ERROR_INVALID_ARGUMENT);
+
+ switch (mime) {
+ case MEDIA_FORMAT_MPEG4_SP:
+ video->mime = g_strdup ("video/mpeg");
+ video->version = 4;
+ break;
+ case MEDIA_FORMAT_H264_SP:
+ case MEDIA_FORMAT_H264_MP:
+ case MEDIA_FORMAT_H264_HP:
+ video->mime = g_strdup ("video/x-h264");
+ break;
+ default:
+ video->mime = g_strdup ("unknown");
+ break;
+ }
+
+ return MM_ERROR_NONE;
+}
+
+static int
+_convert_media_format_audio_mime_to_str (MMPlayerAudioStreamInfo * audio,
+ media_format_mimetype_e mime)
+{
+ return_val_if_fail (audio, MM_ERROR_INVALID_ARGUMENT);
+
+ switch (mime) {
+ case MEDIA_FORMAT_AAC:
+ audio->mime = g_strdup ("audio/mpeg");
+ audio->version = 2;
+ break;
+ default:
+ audio->mime = g_strdup ("unknown");
+ break;
+ }
+
+ return MM_ERROR_NONE;
+}
+
+static int
+_parse_media_format (MMPlayerVideoStreamInfo * video,
+ MMPlayerAudioStreamInfo * audio, media_format_h format)
+{
+ if (audio) {
+ media_format_mimetype_e mime;
+ int channel;
+ int samplerate;
+ int avg_bps;
+
+ if (media_format_get_audio_info (format, &mime, &channel, &samplerate, NULL,
+ &avg_bps) != MEDIA_FORMAT_ERROR_NONE) {
+ debug_error ("media_format_get_audio_info failed");
+ return MM_ERROR_PLAYER_INTERNAL;
+ }
+
+ _convert_media_format_audio_mime_to_str (audio, mime);
+ audio->sample_rate = samplerate;
+ audio->channels = channel;
+//video->user_info = ;
+ }
+
+ if (video) {
+ media_format_mimetype_e mime;
+ int width;
+ int height;
+ int avg_bps;
+
+ if (media_format_get_video_info (format, &mime, &width, &height, &avg_bps,
+ NULL) != MEDIA_FORMAT_ERROR_NONE) {
+ debug_error ("media_format_get_video_info failed");
+ return MM_ERROR_PLAYER_INTERNAL;
+ }
+
+ _convert_media_format_video_mime_to_str (video, mime);
+ video->width = width;
+ video->height = height;
+ }
+
+ return MM_ERROR_NONE;
+}
+
+static gboolean
+_mmplayer_update_video_info(MMHandleType hplayer, media_format_h fmt)
+{
+ mm_player_t *player = (mm_player_t *) hplayer;
+ gboolean ret = FALSE;
+ GstStructure *str = NULL;
+ media_format_mimetype_e mimetype = 0;
+ gint cur_width = 0, width = 0;
+ gint cur_height = 0, height = 0;
+
+ MMPLAYER_FENTER ();
+
+ return_val_if_fail (player, FALSE);
+ return_val_if_fail (fmt, FALSE);
+
+ if (player->v_stream_caps)
+ {
+ str = gst_caps_get_structure (player->v_stream_caps, 0);
+ if ( !gst_structure_get_int (str, "width", &cur_width))
+ {
+ debug_log ("missing 'width' field in video caps");
+ }
+
+ if ( !gst_structure_get_int (str, "height", &cur_height))
+ {
+ debug_log ("missing 'height' field in video caps");
+ }
+
+ media_format_get_video_info(fmt, &mimetype, &width, &height, NULL, NULL);
+ if ((cur_width != width) || (cur_height != height))
+ {
+ debug_warning ("resolution is changed %dx%d -> %dx%d",
+ cur_width, cur_height, width, height);
+ _mmplayer_set_video_info(hplayer, fmt);
+ ret = TRUE;
+ }
+ }
+
+ MMPLAYER_FLEAVE ();
+ return ret;
+}
+
+
+int
+_mmplayer_set_media_stream_buffer_status_cb(MMHandleType hplayer,
+ MMPlayerStreamType type,
+ mm_player_media_stream_buffer_status_callback callback,
+ void *user_param)
+{
+ mm_player_t *player = (mm_player_t *) hplayer;
+
+ MMPLAYER_FENTER ();
+
+ return_val_if_fail (player, MM_ERROR_PLAYER_NOT_INITIALIZED);
+
+ if ((type < MM_PLAYER_STREAM_TYPE_DEFAULT) || (type > MM_PLAYER_STREAM_TYPE_TEXT))
+ return MM_ERROR_INVALID_ARGUMENT;
+
+ if (player->media_stream_buffer_status_cb[type])
+ {
+ if (!callback)
+ {
+ debug_log ("[type:%d] will be clear.\n", type);
+ }
+ else
+ {
+ debug_log ("[type:%d] will be overwritten.\n", type);
+ }
+ }
+
+ player->media_stream_buffer_status_cb[type] = callback;
+ player->buffer_cb_user_param = user_param;
+
+ debug_log ("player handle %p, type %d, callback %p\n", player, type,
+ player->media_stream_buffer_status_cb[type]);
+
+ MMPLAYER_FLEAVE ();
+
+ return MM_ERROR_NONE;
+}
+
+int
+_mmplayer_set_media_stream_seek_data_cb(MMHandleType hplayer,
+ MMPlayerStreamType type,
+ mm_player_media_stream_seek_data_callback callback,
+ void *user_param)
+{
+ mm_player_t *player = (mm_player_t *) hplayer;
+
+ MMPLAYER_FENTER ();
+
+ return_val_if_fail (player, MM_ERROR_PLAYER_NOT_INITIALIZED);
+
+ if ((type < MM_PLAYER_STREAM_TYPE_DEFAULT) || (type > MM_PLAYER_STREAM_TYPE_TEXT))
+ return MM_ERROR_INVALID_ARGUMENT;
+
+ if (player->media_stream_seek_data_cb[type])
+ {
+ if (!callback)
+ {
+ debug_log ("[type:%d] will be clear.\n", type);
+ }
+ else
+ {
+ debug_log ("[type:%d] will be overwritten.\n", type);
+ }
+ }
+
+ player->media_stream_seek_data_cb[type] = callback;
+ player->buffer_cb_user_param = user_param;
+
+ debug_log ("player handle %p, type %d, callback %p\n", player, type,
+ player->media_stream_seek_data_cb[type]);
+
+ MMPLAYER_FLEAVE ();
+
+ return MM_ERROR_NONE;
+}
+
+int
+_mmplayer_set_media_stream_max_size(MMHandleType hplayer, MMPlayerStreamType type, guint64 max_size)
+{
+ mm_player_t *player = (mm_player_t *) hplayer;
+
+ MMPLAYER_FENTER ();
+
+ return_val_if_fail (player, MM_ERROR_PLAYER_NOT_INITIALIZED);
+
+ if ((type < MM_PLAYER_STREAM_TYPE_DEFAULT) || (type > MM_PLAYER_STREAM_TYPE_TEXT))
+ return MM_ERROR_INVALID_ARGUMENT;
+
+ player->media_stream_buffer_max_size[type] = max_size;
+
+ debug_log ("type %d, max_size %llu\n",
+ type, player->media_stream_buffer_max_size[type]);
+
+ MMPLAYER_FLEAVE ();
+
+ return MM_ERROR_NONE;
+}
+
+int
+_mmplayer_get_media_stream_max_size(MMHandleType hplayer, MMPlayerStreamType type, guint64 *max_size)
+{
+ mm_player_t *player = (mm_player_t *) hplayer;
+
+ MMPLAYER_FENTER ();
+
+ return_val_if_fail (player, MM_ERROR_PLAYER_NOT_INITIALIZED);
+ return_val_if_fail (max_size, MM_ERROR_INVALID_ARGUMENT);
+
+ if ((type < MM_PLAYER_STREAM_TYPE_DEFAULT) || (type > MM_PLAYER_STREAM_TYPE_TEXT))
+ return MM_ERROR_INVALID_ARGUMENT;
+
+ *max_size = player->media_stream_buffer_max_size[type];
+
+ MMPLAYER_FLEAVE ();
+
+ return MM_ERROR_NONE;
+}
+
+int
+_mmplayer_set_media_stream_min_percent(MMHandleType hplayer, MMPlayerStreamType type, guint min_percent)
+{
+ mm_player_t *player = (mm_player_t *) hplayer;
+
+ MMPLAYER_FENTER ();
+
+ return_val_if_fail (player, MM_ERROR_PLAYER_NOT_INITIALIZED);
+
+ if ((type < MM_PLAYER_STREAM_TYPE_DEFAULT) || (type > MM_PLAYER_STREAM_TYPE_TEXT))
+ return MM_ERROR_INVALID_ARGUMENT;
+
+ player->media_stream_buffer_min_percent[type] = min_percent;
+
+ debug_log ("type %d, min_per %u\n",
+ type, player->media_stream_buffer_min_percent[type]);
+
+ MMPLAYER_FLEAVE ();
+
+ return MM_ERROR_NONE;
+}
+
+int
+_mmplayer_get_media_stream_min_percent(MMHandleType hplayer, MMPlayerStreamType type, guint *min_percent)
+{
+ mm_player_t *player = (mm_player_t *) hplayer;
+
+ MMPLAYER_FENTER ();
+
+ return_val_if_fail (player, MM_ERROR_PLAYER_NOT_INITIALIZED);
+ return_val_if_fail (min_percent, MM_ERROR_INVALID_ARGUMENT);
+
+ if ((type < MM_PLAYER_STREAM_TYPE_DEFAULT) || (type > MM_PLAYER_STREAM_TYPE_TEXT))
+ return MM_ERROR_INVALID_ARGUMENT;
+
+ *min_percent = player->media_stream_buffer_min_percent[type];
+
+ MMPLAYER_FLEAVE ();
+
+ return MM_ERROR_NONE;
+}
+
+int
+_mmplayer_submit_packet (MMHandleType hplayer, media_packet_h packet)
+{
+ int ret = MM_ERROR_NONE;
+ GstBuffer *_buffer;
+ mm_player_t *player = (mm_player_t *) hplayer;
+ guint8 *buf = NULL;
+ MMPlayerTrackType streamtype = MM_PLAYER_TRACK_TYPE_AUDIO;
+ media_format_h fmt = NULL;
+
+ return_val_if_fail (player, MM_ERROR_PLAYER_NOT_INITIALIZED);
+ return_val_if_fail (packet, MM_ERROR_INVALID_ARGUMENT);
+
+ /* get data */
+ media_packet_get_buffer_data_ptr (packet, (void **) &buf);
+
+ if (buf != NULL) {
+ GstMapInfo buff_info = GST_MAP_INFO_INIT;
+ uint64_t size = 0;
+ uint64_t pts = 0;
+ bool flag = FALSE;
+
+ /* get size */
+ media_packet_get_buffer_size (packet, &size);
+
+ _buffer = gst_buffer_new_and_alloc (size);
+ if (gst_buffer_map (_buffer, &buff_info, GST_MAP_READWRITE)) {
+
+ memcpy (buff_info.data, buf, size);
+ buff_info.size = size;
+
+ gst_buffer_unmap (_buffer, &buff_info);
+ }
+
+ /* get pts */
+ media_packet_get_pts (packet, &pts);
+ GST_BUFFER_PTS (_buffer) = (GstClockTime) (pts * 1000000);
+
+ /* get stream type if audio or video */
+ media_packet_is_audio (packet, &flag);
+ if (flag) {
+ streamtype = MM_PLAYER_TRACK_TYPE_AUDIO;
+ } else {
+ media_packet_is_video (packet, &flag);
+
+ if (flag)
+ streamtype = MM_PLAYER_TRACK_TYPE_VIDEO;
+ else
+ streamtype = MM_PLAYER_TRACK_TYPE_TEXT;
+ }
+
+ if (streamtype == MM_PLAYER_TRACK_TYPE_AUDIO) {
+#if 0 // TO CHECK : has gone (set to pad)
+ if (GST_CAPS_IS_SIMPLE (player->a_stream_caps))
+ GST_BUFFER_CAPS (_buffer) = gst_caps_copy (player->a_stream_caps);
+ else
+ debug_error ("External Demuxer case: Audio Buffer Caps not set.");
+#endif
+ if (player->pipeline->mainbin[MMPLAYER_M_2ND_SRC].gst)
+ gst_app_src_push_buffer (GST_APP_SRC (player->pipeline->mainbin[MMPLAYER_M_2ND_SRC].gst), _buffer);
+ else if (g_strrstr (GST_ELEMENT_NAME (player->pipeline->mainbin[MMPLAYER_M_SRC].gst), "audio_appsrc"))
+ gst_app_src_push_buffer (GST_APP_SRC (player->pipeline->mainbin[MMPLAYER_M_SRC].gst), _buffer);
+ } else if (streamtype == MM_PLAYER_TRACK_TYPE_VIDEO) {
+#if 0 // TO CHECK : has gone (set to pad)
+ if (GST_CAPS_IS_SIMPLE (player->v_stream_caps))
+ GST_BUFFER_CAPS (_buffer) = gst_caps_copy (player->v_stream_caps);
+ else
+ debug_error ("External Demuxer case: Video Buffer Caps not set.");
+#endif
+ /* get format to check video format */
+ media_packet_get_format (packet, &fmt);
+ if (fmt)
+ {
+ gboolean ret = FALSE;
+ ret = _mmplayer_update_video_info(hplayer, fmt);
+ if (ret)
+ {
+ g_object_set(G_OBJECT(player->pipeline->mainbin[MMPLAYER_M_SRC].gst),
+ "caps", player->v_stream_caps, NULL);
+ }
+ }
+
+ gst_app_src_push_buffer (GST_APP_SRC (player->pipeline->mainbin[MMPLAYER_M_SRC].gst), _buffer);
+ } else if (streamtype == MM_PLAYER_TRACK_TYPE_TEXT) {
+#if 0 // TO CHECK : has gone (set to pad)
+ if (GST_CAPS_IS_SIMPLE (player->s_stream_caps))
+ GST_BUFFER_CAPS (_buffer) = gst_caps_copy (player->s_stream_caps);
+ else
+ debug_error ("External Demuxer case: Subtitle Buffer Caps not set.");
+#endif
+ gst_app_src_push_buffer (GST_APP_SRC (player->pipeline->mainbin[MMPLAYER_M_SUBSRC].gst), _buffer);
+ } else {
+ debug_error ("Not a valid packet from external demux");
+ return FALSE;
+ }
+ } else {
+ debug_log ("Sending EOS on pipeline...");
+ if (streamtype == MM_PLAYER_TRACK_TYPE_AUDIO) {
+ if (player->pipeline->mainbin[MMPLAYER_M_2ND_SRC].gst)
+ g_signal_emit_by_name (player->pipeline->
+ mainbin[MMPLAYER_M_2ND_SRC].gst, "end-of-stream", &ret);
+ else
+ g_signal_emit_by_name (player->pipeline->mainbin[MMPLAYER_M_SRC].gst,
+ "end-of-stream", &ret);
+ } else if (streamtype == MM_PLAYER_TRACK_TYPE_VIDEO) {
+ g_signal_emit_by_name (player->pipeline->mainbin[MMPLAYER_M_SRC].gst,
+ "end-of-stream", &ret);
+ } else if (streamtype == MM_PLAYER_TRACK_TYPE_TEXT) {
+ g_signal_emit_by_name (player->pipeline->mainbin[MMPLAYER_M_SUBSRC].gst,
+ "end-of-stream", &ret);
+ }
+ }
+
+ if (MMPLAYER_PENDING_STATE (player) == MM_PLAYER_STATE_PLAYING) {
+ //ret = __mmplayer_set_state(player, MM_PLAYER_STATE_PLAYING);
+ }
+
+ return ret;
+}
+
+int
+_mmplayer_video_caps_new (MMHandleType hplayer, MMPlayerVideoStreamInfo * 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_FENTER ();
+ return_val_if_fail (player, MM_ERROR_PLAYER_NOT_INITIALIZED);
+ return_val_if_fail (video, MM_ERROR_PLAYER_NOT_INITIALIZED);
+
+ debug_log ("width=%d height=%d framerate num=%d, den=%d",
+ video->width, video->height, video->framerate_num, video->framerate_den);
+
+ caps = gst_caps_new_simple (video->mime,
+ "width", G_TYPE_INT, video->width,
+ "height", G_TYPE_INT, video->height,
+ "framerate", GST_TYPE_FRACTION, video->framerate_num, video->framerate_den, NULL);
+
+ for (cap_size = 0; cap_size < gst_caps_get_size (caps); cap_size++) {
+ va_start (var_args, fieldname);
+ structure = gst_caps_get_structure (caps, cap_size);
+ gst_structure_set_valist (structure, fieldname, var_args);
+ va_end (var_args);
+ }
+
+ if (video->extradata_size) {
+ GstBuffer *buf = NULL;
+ GstMapInfo buff_info = GST_MAP_INFO_INIT;
+
+ buf = gst_buffer_new_and_alloc (video->extradata_size);
+
+ if (gst_buffer_map (buf, &buff_info, GST_MAP_READ)) {
+ memcpy (buff_info.data, video->codec_extradata, video->extradata_size);
+ buff_info.size = video->extradata_size;
+ gst_buffer_unmap (buf, &buff_info);
+ }
+
+ gst_caps_set_simple (caps, "codec_data", GST_TYPE_BUFFER, buf, NULL);
+ gst_buffer_unref (buf);
+ }
+
+ if (player->v_stream_caps)
+ {
+ debug_warning ("caps will be updated ");
+
+ gst_caps_unref(player->v_stream_caps);
+ player->v_stream_caps = NULL;
+ }
+
+ player->v_stream_caps = gst_caps_copy (caps);
+ MMPLAYER_LOG_GST_CAPS_TYPE (player->v_stream_caps);
+ gst_caps_unref (caps);
+
+ MMPLAYER_FLEAVE ();
+
+ return MM_ERROR_NONE;
+}
+
+int
+_mmplayer_set_video_info (MMHandleType hplayer, media_format_h format)
+{
+ mm_player_t *player = MM_PLAYER_CAST (hplayer);
+ MMPlayerVideoStreamInfo video = { 0, };
+ int ret = MM_ERROR_NONE;
+
+ MMPLAYER_FENTER ();
+
+ return_val_if_fail (player, MM_ERROR_PLAYER_NOT_INITIALIZED);
+
+ ret = _parse_media_format (&video, NULL, format);
+ if(ret != MM_ERROR_NONE)
+ return ret;
+
+ if (strstr (video.mime, "video/mpeg")) {
+ _mmplayer_video_caps_new (hplayer, &video,
+ "mpegversion", G_TYPE_INT, video.version,
+ "systemstream", G_TYPE_BOOLEAN, FALSE, NULL);
+ } else if (strstr (video.mime, "video/x-h264")) {
+ //if (info.colordepth)
+ {
+ // _mmplayer_video_caps_new(hplayer, &info,
+ // "colordepth", G_TYPE_INT, info.colordepth, NULL);
+ }
+ //else
+ {
+ _mmplayer_video_caps_new (hplayer, &video,
+ "stream-format", G_TYPE_STRING, "byte-stream",
+ "alignment", G_TYPE_STRING, "au", NULL);
+ }
+ }
+#if 0
+ else if (strstr (info->mime, "video/x-wmv")) {
+ _mmplayer_video_caps_new (hplayer, &info,
+ "wmvversion", G_TYPE_INT, info.version, NULL);
+ } else if (strstr (info.mime, "video/x-pn-realvideo")) {
+ _mmplayer_video_caps_new (hplayer, &info,
+ "rmversion", G_TYPE_INT, info.version, NULL);
+ } else if (strstr (info.mime, "video/x-msmpeg")) {
+ _mmplayer_video_caps_new (hplayer, &info,
+ "msmpegversion", G_TYPE_INT, info.version, NULL);
+ } else if (strstr (info.mime, "video/x-h265")) {
+ if (info.colordepth) {
+ _mmplayer_video_caps_new (hplayer, &info,
+ "colordepth", G_TYPE_INT, info.colordepth, NULL);
+ } else {
+ _mmplayer_video_caps_new (hplayer, &info, NULL);
+ }
+ } else {
+ _mmplayer_video_caps_new (hplayer, &info, NULL);
+ }
+#endif
+ g_free ((char *) video.mime);
+
+ MMPLAYER_FLEAVE ();
+
+ return MM_ERROR_NONE;
+}
+
+int
+_mmplayer_set_audio_info (MMHandleType hplayer, media_format_h format)
+{
+ mm_player_t *player = MM_PLAYER_CAST (hplayer);
+ GstCaps *caps = NULL;
+ MMPlayerAudioStreamInfo audio = { 0, };
+ int ret = MM_ERROR_NONE;
+
+ MMPLAYER_FENTER ();
+
+ return_val_if_fail (hplayer, MM_ERROR_PLAYER_NOT_INITIALIZED);
+
+ ret = _parse_media_format (NULL, &audio, format);
+ if(ret != MM_ERROR_NONE)
+ return ret;
+
+ audio.user_info = 0; //test
+
+ debug_log ("set audio player[%p] info [%p] version=%d rate=%d channel=%d",
+ player, audio, audio.version, audio.sample_rate, audio.channels);
+
+ if (strstr (audio.mime, "audio/mpeg")) {
+ if (audio.version == 1) { // mp3
+ caps = gst_caps_new_simple ("audio/mpeg",
+ "channels", G_TYPE_INT, audio.channels,
+ "rate", G_TYPE_INT, audio.sample_rate,
+ "mpegversion", G_TYPE_INT, audio.version,
+ "layer", G_TYPE_INT, audio.user_info, NULL);
+ } else { // aac
+ gchar *format = NULL;
+
+ if (audio.user_info == 0)
+ format = g_strdup ("raw");
+ else if (audio.user_info == 1)
+ format = g_strdup ("adts");
+ else if (audio.user_info == 2)
+ format = g_strdup ("adif");
+
+ caps = gst_caps_new_simple ("audio/mpeg",
+ "channels", G_TYPE_INT, audio.channels,
+ "rate", G_TYPE_INT, audio.sample_rate,
+ "mpegversion", G_TYPE_INT, audio.version,
+ "stream-format", G_TYPE_STRING, format, NULL);
+
+ g_free (format);
+ format = NULL;
+ }
+ }
+#if 0
+ else if (strstr (audio.mime, "audio/x-raw-int")) {
+ caps = gst_caps_new_simple ("audio/x-raw-int",
+ "width", G_TYPE_INT, audio.width,
+ "depth", G_TYPE_INT, audio.depth,
+ "endianness", G_TYPE_INT, audio.endianness,
+ "signed", G_TYPE_BOOLEAN, audio.signedness,
+ "channels", G_TYPE_INT, audio.channels,
+ "rate", G_TYPE_INT, audio.sample_rate, NULL);
+ } else {
+ caps = gst_caps_new_simple (audio.mime,
+ "channels", G_TYPE_INT, audio.channels,
+ "rate", G_TYPE_INT, audio.sample_rate, NULL);
+ }
+#endif
+
+ if (audio.extradata_size) {
+ GstBuffer *buf = NULL;
+ GstMapInfo buff_info = GST_MAP_INFO_INIT;
+
+ buf = gst_buffer_new_and_alloc (audio.extradata_size);
+
+ if (gst_buffer_map (buf, &buff_info, GST_MAP_READ)) {
+ memcpy (buff_info.data, audio.codec_extradata, audio.extradata_size);
+ gst_buffer_unmap (buf, &buff_info);
+ }
+
+ gst_caps_set_simple (caps, "codec_data", GST_TYPE_BUFFER, buf, NULL);
+ gst_buffer_unref (buf);
+ }
+
+ g_free ((char *) audio.mime);
+
+ player->a_stream_caps = gst_caps_copy (caps);
+ gst_caps_unref (caps);
+
+ MMPLAYER_FLEAVE ();
+
+ return MM_ERROR_NONE;
+}
+
+int
+_mmplayer_set_subtitle_info (MMHandleType hplayer,
+ MMPlayerSubtitleStreamInfo * subtitle)
+{
+#if 0 //todo
+
+ mm_player_t *player = MM_PLAYER_CAST (hplayer);
+ GstCaps *caps = NULL;
+
+ MMPLAYER_FENTER ();
+
+ return_val_if_fail (player, MM_ERROR_PLAYER_NOT_INITIALIZED);
+ return_val_if_fail (info, MM_ERROR_PLAYER_NOT_INITIALIZED);
+
+ debug_log ("set subtitle player[%p] info [%p]", player, info);
+
+
+ caps = gst_caps_new_simple (info->mime, NULL, NULL); // TO CHECK
+ if (NULL == caps)
+ return FALSE;
+
+ if (strstr (info->mime, "application/x-xsub")) {
+ gst_caps_set_simple (caps, "codec_tag", G_TYPE_UINT, info->codec_tag, NULL);
+ } else if (strstr (info->mime, "application/x-smpte-text")) {
+ if (info->context) {
+ gst_caps_set_simple (caps, "ttml_priv_data", G_TYPE_POINTER,
+ info->context, NULL);
+ }
+ }
+
+ player->s_stream_caps = gst_caps_copy (caps);
+
+ gst_caps_unref (caps);
+#endif
+
+ MMPLAYER_FLEAVE ();
+
+ return MM_ERROR_NONE;
+}
ini->localplayback_state_change_timeout = iniparser_getint(dict, "general:localplayback state change timeout", DEFAULT_LOCALPLAYBACK_STATE_CHANGE_TIMEOUT);
ini->eos_delay = iniparser_getint(dict, "general:eos delay", DEFAULT_EOS_DELAY);
ini->async_start = iniparser_getboolean(dict, "general:async start", DEFAULT_ASYNC_START);
- ini->multiple_codec_supported = iniparser_getboolean(dict, "general:multiple codec supported", DEFAULT_MULTIPLE_CODEC_SUPPORTED);
ini->delay_before_repeat = iniparser_getint(dict, "general:delay before repeat", DEFAULT_DELAY_BEFORE_REPEAT);
MMPLAYER_INI_GET_STRING(dict, ini->videosink_element_x, "general:videosink element x", DEFAULT_VIDEOSINK_X);
MMPLAYER_INI_GET_STRING(dict, ini->videosink_element_evas, "general:videosink element evas", DEFAULT_VIDEOSINK_EVAS);
MMPLAYER_INI_GET_STRING(dict, ini->videosink_element_fake, "general:videosink element fake", DEFAULT_VIDEOSINK_FAKE);
- MMPLAYER_INI_GET_STRING(dict, ini->name_of_drmsrc, "general:drmsrc element", DEFAULT_DRMSRC );
MMPLAYER_INI_GET_STRING(dict, ini->name_of_audio_resampler, "general:audio resampler element", DEFAULT_AUDIORESAMPLER );
MMPLAYER_INI_GET_STRING(dict, ini->name_of_audiosink, "general:audiosink element", DEFAULT_AUDIOSINK );
MMPLAYER_INI_GET_STRING(dict, ini->name_of_video_converter, "general:video converter element", DEFAULT_VIDEO_CONVERTER );
ini->rtsp_buffering_time = iniparser_getint(dict, "rtsp streaming:rtsp buffering time", DEFAULT_RTSP_BUFFERING);
ini->rtsp_rebuffering_time = iniparser_getint(dict, "rtsp streaming:rtsp rebuffering time", DEFAULT_RTSP_REBUFFERING);
ini->rtsp_do_typefinding = iniparser_getboolean(dict, "rtsp streaming:rtsp do typefinding", DEFAULT_RTSP_DO_TYPEFINDING);
- ini->rtsp_error_concealment = iniparser_getboolean(dict, "rtsp streaming:rtsp error concealment", DEFAULT_RTSP_ERROR_CONCEALMENT);
-
- /* hw accelation */
- ini->use_video_hw_accel = iniparser_getboolean(dict, "hw accelation:use video hw accel", DEFAULT_USE_VIDEO_HW_ACCEL);
-
- /* priority */
- ini->use_priority_setting = iniparser_getboolean(dict, "priority:use priority setting", DEFAULT_USE_PRIORITY_SETTING);
- ini->demux_priority = iniparser_getint(dict, "priority:demux", DEFAULT_PRIORITY_DEMUX);
- ini->videosink_priority = iniparser_getint(dict, "priority:videosink", DEFAULT_PRIORITY_VIDEO_SINK);
- ini->audiosink_priority = iniparser_getint(dict, "priority:audiosink", DEFAULT_PRIORITY_AUDIO_SINK);
- ini->ringbuffer_priority = iniparser_getint(dict, "priority:ringbuffer", DEFAULT_PRIORITY_RINGBUFFER);
/* dump buffer for debug */
__get_element_list(ini,
ini->live_state_change_timeout = DEFAULT_LIVE_STATE_CHANGE_TIMEOUT;
ini->localplayback_state_change_timeout = DEFAULT_LOCALPLAYBACK_STATE_CHANGE_TIMEOUT;
ini->eos_delay = DEFAULT_EOS_DELAY;
- ini->multiple_codec_supported = DEFAULT_MULTIPLE_CODEC_SUPPORTED;
ini->async_start = DEFAULT_ASYNC_START;
ini->delay_before_repeat = DEFAULT_DELAY_BEFORE_REPEAT;
- strncpy( ini->name_of_drmsrc, DEFAULT_DRMSRC, PLAYER_INI_MAX_STRLEN - 1 );
strncpy( ini->name_of_audio_resampler, DEFAULT_AUDIORESAMPLER, PLAYER_INI_MAX_STRLEN -1 );
strncpy( ini->name_of_audiosink, DEFAULT_AUDIOSINK, PLAYER_INI_MAX_STRLEN -1 );
strncpy( ini->name_of_video_converter, DEFAULT_VIDEO_CONVERTER, PLAYER_INI_MAX_STRLEN -1 );
ini->rtsp_buffering_time = DEFAULT_RTSP_BUFFERING;
ini->rtsp_rebuffering_time = DEFAULT_RTSP_REBUFFERING;
ini->rtsp_do_typefinding = DEFAULT_RTSP_DO_TYPEFINDING;
- ini->rtsp_error_concealment = DEFAULT_RTSP_ERROR_CONCEALMENT;
-
- /* hw accelation */
- ini->use_video_hw_accel = DEFAULT_USE_VIDEO_HW_ACCEL;
-
- /* priority */
- ini->use_priority_setting = DEFAULT_USE_PRIORITY_SETTING;
- ini->demux_priority = DEFAULT_PRIORITY_DEMUX;
- ini->videosink_priority = DEFAULT_PRIORITY_VIDEO_SINK;
- ini->audiosink_priority = DEFAULT_PRIORITY_AUDIO_SINK;
- ini->ringbuffer_priority = DEFAULT_PRIORITY_RINGBUFFER;
/* dump buffer for debug */
__get_element_list(ini, DEFAULT_DUMP_ELEMENT_KEYWORD, KEYWORD_DUMP);
debug_log("localplayback_state_change_timeout(sec) : %d\n", ini->localplayback_state_change_timeout);
debug_log("eos_delay(msec) : %d\n", ini->eos_delay);
debug_log("delay_before_repeat(msec) : %d\n", ini->delay_before_repeat);
- debug_log("name_of_drmsrc : %s\n", ini->name_of_drmsrc);
debug_log("name_of_audioresampler : %s\n", ini->name_of_audio_resampler);
debug_log("name_of_audiosink : %s\n", ini->name_of_audiosink);
debug_log("name_of_video_converter : %s\n", ini->name_of_video_converter);
debug_log("async_start : %d\n", ini->async_start);
- debug_log("multiple_codec_supported : %d\n", ini->multiple_codec_supported);
debug_log("gst_param1 : %s\n", ini->gst_param[0]);
debug_log("gst_param2 : %s\n", ini->gst_param[1]);
debug_log("rtsp_buffering_time(msec) : %d\n", ini->rtsp_buffering_time);
debug_log("rtsp_rebuffering_time(msec) : %d\n", ini->rtsp_rebuffering_time);
debug_log("rtsp_do_typefinding : %d \n", ini->rtsp_do_typefinding);
- debug_log("rtsp_error_concealment : %d \n", ini->rtsp_error_concealment);
-
- /* hw accel */
- debug_log("use_video_hw_accel : %d\n", ini->use_video_hw_accel);
-
- /* priority */
- debug_log("use_priority_setting : %d\n", ini->use_priority_setting);
- debug_log("demux_priority : %d\n", ini->demux_priority);
- debug_log("audiosink_priority : %d\n", ini->audiosink_priority);
- debug_log("videosink_priority : %d\n", ini->videosink_priority);
- debug_log("ringbuffer_priority : %d\n", ini->ringbuffer_priority);
return MM_ERROR_NONE;
}
#ifdef HAVE_WAYLAND
#include <gst/wayland/wayland.h>
#endif
+#include <gst/audio/gstaudiobasesink.h>
#include <unistd.h>
#include <sys/stat.h>
#include <string.h>
#include "mm_player_utils.h"
#include "mm_player_tracks.h"
#include <sched.h>
+
#include <mm_sound.h>
#define MM_SMOOTH_STREAMING
#define LAZY_PAUSE_TIMEOUT_MSEC 700
#define MM_PLAYER_NAME "mmplayer"
+#define SMOOTH_STREAMING_DEMUX "mssdemux"
+/*
+ * g_array_index(a,t,i) does not calculate gst private structure.
+ * It replaces the g_array_index(a,t,i)
+ */
+#define g_array_undef_struct_idx_p(a,t,i) ((t *)(void *)((a)->data + ((i) * (a)->len)))
+
//#define ENABLE_DRMSRC
/*---------------------------------------------------------------------------
static gboolean __mmplayer_can_extract_pcm( mm_player_t* player );
/*fadeout */
-//static void __mmplayer_do_sound_fadedown(mm_player_t* player, unsigned int time);
-//static void __mmplayer_undo_sound_fadedown(mm_player_t* player);
+static void __mmplayer_do_sound_fadedown(mm_player_t* player, unsigned int time);
+static void __mmplayer_undo_sound_fadedown(mm_player_t* player);
static void __mmplayer_add_new_caps(GstPad* pad, GParamSpec* unused, gpointer data);
static void __mmplayer_set_unlinked_mime_type(mm_player_t* player, GstCaps *caps);
static gboolean __is_dash_streaming( mm_player_t* player );
static gboolean __is_smooth_streaming( mm_player_t* player );
static gboolean __is_http_progressive_down(mm_player_t* player);
+#ifdef TEST_ES
+static gboolean __is_es_buff_src(mm_player_t* player);
+#endif
static gboolean __has_suffix(mm_player_t * player, const gchar * suffix);
static GstBusSyncReply __mmplayer_bus_sync_callback (GstBus * bus, GstMessage * message, gpointer data);
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_ignore_current_external_display_mode(mm_player_t* player);
#if 0 // We'll need this in future.
static int __mmplayer_gst_switching_element(mm_player_t *player, GstElement *search_from, const gchar *removal_name, const gchar *new_element_name);
#endif
static void __mmplayer_update_buffer_setting(mm_player_t *player, GstMessage *buffering_msg);
static GstElement *__mmplayer_element_create_and_link(mm_player_t *player, GstPad* pad, const char* name);
-//static gboolean __mmplayer_can_do_interrupt(mm_player_t *player);
+static gboolean __mmplayer_can_do_interrupt(mm_player_t *player);
/* device change post proc */
void __mmplayer_device_change_post_process(gpointer user);
static int __mmplayer_gst_create_plain_text_elements(mm_player_t* player);
static guint32 _mmplayer_convert_fourcc_string_to_value(const gchar* format_name);
-
-
+#ifdef TEST_ES
+static void __gst_appsrc_feed_audio_data(GstElement *element, guint size, gpointer user_data);
+static void __gst_appsrc_feed_video_data(GstElement *element, guint size, gpointer user_data);
+static void __gst_appsrc_feed_subtitle_data(GstElement *element, guint size, gpointer user_data);
+static void __gst_appsrc_enough_audio_data(GstElement *element, gpointer user_data);
+static void __gst_appsrc_enough_video_data(GstElement *element, gpointer user_data);
+static gboolean __gst_seek_audio_data (GstElement * appsrc, guint64 position, gpointer user_data);
+static gboolean __gst_seek_video_data (GstElement * appsrc, guint64 position, gpointer user_data);
+static gboolean __gst_seek_subtitle_data (GstElement * appsrc, guint64 position, gpointer user_data);
+#endif
/*===========================================================================================
| |
| FUNCTION DEFINITIONS |
debug_error("failed to set [%s] state\n", GST_ELEMENT_NAME(element));
/* dump state of all element */
- //__mmplayer_dump_pipeline_state( player );
+ __mmplayer_dump_pipeline_state( player );
return MM_ERROR_PLAYER_INTERNAL;
}
gst_element_state_get_name(element_pending_state) );
/* dump state of all element */
- //__mmplayer_dump_pipeline_state( player );
+ __mmplayer_dump_pipeline_state( player );
return MM_ERROR_PLAYER_INTERNAL;
}
/* clear stream data structure */
memset(&stream, 0x0, sizeof(MMPlayerVideoStreamDataType));
- stream.data = data;
+ stream.data[0] = data;
stream.length_total = width * height * 4; // for rgb 32bit
stream.height = height;
stream.width = width;
static void
__mmplayer_sound_device_info_changed_cb_func (MMSoundDevice_t device_h, int changed_info_type, void *user_data)
{
- int ret;
- mm_sound_device_type_e device_type;
+ int ret;
+ mm_sound_device_type_e device_type;
mm_player_t* player = (mm_player_t*) user_data;
return_if_fail( player );
if ( ! MMPLAYER_IS_STREAMING(player) )
return STREAMING_SERVICE_NONE;
- if (MMPLAYER_IS_RTSP_STREAMING(player))
- {
- /* get property from rtspsrc element */
- g_object_get(G_OBJECT(player->pipeline->mainbin[MMPLAYER_M_SRC].gst),
- "service_type", &streaming_type, NULL);
- }
- else if (MMPLAYER_IS_HTTP_STREAMING(player))
+ if (MMPLAYER_IS_HTTP_STREAMING(player))
{
streaming_type = (player->duration == 0) ?
STREAMING_SERVICE_LIVE : STREAMING_SERVICE_VOD;
__mmplayer_set_state(mm_player_t* player, int state) // @
{
MMMessageParamType msg = {0, };
-// int asm_result = MM_ERROR_NONE;
+ int asm_result = MM_ERROR_NONE;
gboolean post_bos = FALSE;
-// gboolean interrupted_by_asm = FALSE;
+ gboolean interrupted_by_asm = FALSE;
int ret = MM_ERROR_NONE;
return_val_if_fail ( player, FALSE );
MMPLAYER_PRINT_STATE(player);
/* do some FSM stuffs before posting new state to application */
-// interrupted_by_asm = player->sm.by_asm_cb;
+ interrupted_by_asm = player->sm.by_asm_cb;
switch ( MMPLAYER_CURRENT_STATE(player) )
{
{
if (player->cmd == MMPLAYER_COMMAND_STOP)
{
-// asm_result = _mmplayer_asm_set_state((MMHandleType)player, ASM_STATE_STOP, FALSE);
-// if ( asm_result != MM_ERROR_NONE )
-// {
-// debug_error("failed to set asm state to stop\n");
-// return MM_ERROR_POLICY_INTERNAL;
-// }
+ asm_result = _mmplayer_asm_set_state((MMHandleType)player, ASM_STATE_STOP, FALSE);
+ if ( asm_result != MM_ERROR_NONE )
+ {
+ debug_error("failed to set asm state to stop\n");
+ return MM_ERROR_POLICY_INTERNAL;
+ }
}
}
break;
}
/* add audio callback probe if condition is satisfied */
- if ( ! player->audio_cb_probe_id && player->set_mode.pcm_extraction )
+ if ( ! player->audio_cb_probe_id && player->set_mode.pcm_extraction && !player->audio_stream_render_cb_ex)
{
__mmplayer_configure_audio_callback(player);
/* FIXIT : handle return value */
if (!MMPLAYER_IS_STREAMING(player) || (player->streamer && !player->streamer->is_buffering))
{
-// asm_result = _mmplayer_asm_set_state((MMHandleType)player, ASM_STATE_PAUSE, FALSE);
-// if ( asm_result )
-// {
-// debug_error("failed to set asm state to PAUSE\n");
-// return MM_ERROR_POLICY_INTERNAL;
-// }
+ asm_result = _mmplayer_asm_set_state((MMHandleType)player, ASM_STATE_PAUSE, FALSE);
+ if ( asm_result )
+ {
+ debug_error("failed to set asm state to PAUSE\n");
+ return MM_ERROR_POLICY_INTERNAL;
+ }
}
}
break;
{
__mmplayer_handle_missed_plugin ( player );
}
-#if 0
+
/* update ASM state for video and streaming buffering */
asm_result = _mmplayer_asm_set_state((MMHandleType)player, ASM_STATE_PLAYING, TRUE);
if (asm_result != MM_ERROR_NONE)
return MM_ERROR_POLICY_INTERNAL;
}
-#endif
}
if ( player->resumed_by_rewind && player->playback_rate < 0.0 )
debug_log ("player reach the target state (%s)", MMPLAYER_STATE_GET_NAME(MMPLAYER_TARGET_STATE(player)));
/* state changed by asm callback */
-// if ( interrupted_by_asm )
-// {
-// msg.union_type = MM_MSG_UNION_CODE;
-// msg.code = player->sm.event_src;
-// MMPLAYER_POST_MSG( player, MM_MESSAGE_STATE_INTERRUPTED, &msg );
-// }
-// /* state changed by usecase */
-// else
+ if ( interrupted_by_asm )
+ {
+ msg.union_type = MM_MSG_UNION_CODE;
+ msg.code = player->sm.event_src;
+ MMPLAYER_POST_MSG( player, MM_MESSAGE_STATE_INTERRUPTED, &msg );
+ }
+ /* state changed by usecase */
+ else
{
MMPLAYER_POST_MSG( player, MM_MESSAGE_STATE_CHANGED, &msg );
}
return_val_if_fail ( player, NULL );
g_mutex_lock(&player->next_play_thread_mutex);
-
while ( ! player->next_play_thread_exit )
{
debug_log("next play thread started. waiting for signal.\n");
if ( player->next_play_thread_exit )
{
- MMPLAYER_PLAYBACK_UNLOCK(player);
-
+ if(player->pp_rebuilding)
+ {
+ player->pp_rebuilding = false;
+ MMPLAYER_PLAYBACK_UNLOCK(player);
+ }
debug_log("exiting next play thread\n");
break;
}
__mmplayer_activate_next_source(player, GST_STATE_PLAYING);
}
-
g_mutex_unlock(&player->next_play_thread_mutex);
return NULL;
return_val_if_fail ( player, NULL );
g_mutex_lock(&player->repeat_thread_mutex);
-
while ( ! player->repeat_thread_exit )
{
debug_log("repeat thread started. waiting for signal.\n");
- g_cond_wait(&player->repeat_thread_cond, &player->repeat_thread_mutex);
+ g_cond_wait(&player->repeat_thread_cond, &player->repeat_thread_mutex );
if ( player->repeat_thread_exit )
{
break;
}
- if (!(&player->cmd_lock) )
- {
- debug_log("can't get cmd lock\n");
- g_mutex_unlock(&player->repeat_thread_mutex);
- return NULL;
- }
/* lock */
g_mutex_lock(&player->cmd_lock);
}
g_mutex_unlock(&player->repeat_thread_mutex);
-
return NULL;
}
__mmplayer_drop_subtitle(player, TRUE);
- if ( (player->audio_stream_cb) && (player->set_mode.pcm_extraction) )
+ if ( (player->audio_stream_cb) && (player->set_mode.pcm_extraction) && (!player->audio_stream_render_cb_ex))
{
GstPad *pad = NULL;
case GST_MESSAGE_BUFFERING:
{
MMMessageParamType msg_param = {0, };
-// int asm_result = MM_ERROR_NONE;
+ int asm_result = MM_ERROR_NONE;
if (!MMPLAYER_IS_STREAMING(player))
break;
/* update ASM state to ASM_STATE_PLAYING */
/* fixed ASM_STATE_WAITING -> ASM_STATE_PLAYING for Samsunlink issue*/
-// if ((player->streamer) && (player->streamer->is_buffering == FALSE) && (MMPLAYER_CURRENT_STATE(player) != MM_PLAYER_STATE_PAUSED))
-// {
-// asm_result = _mmplayer_asm_set_state((MMHandleType)player, ASM_STATE_WAITING, TRUE);
-// if ( asm_result != MM_ERROR_NONE )
-// {
-// debug_warning("failed to set asm state to waiting, but keep going...\n");
-// }
-// }
+ if ((player->streamer) && (player->streamer->is_buffering == FALSE) && (MMPLAYER_CURRENT_STATE(player) != MM_PLAYER_STATE_PAUSED))
+ {
+ asm_result = _mmplayer_asm_set_state((MMHandleType)player, ASM_STATE_WAITING, TRUE);
+ if ( asm_result != MM_ERROR_NONE )
+ {
+ debug_warning("failed to set asm state to waiting, but keep going...\n");
+ }
+ }
__mmplayer_update_buffer_setting(player, msg);
gboolean prepare_async = FALSE;
gboolean is_drm = FALSE;
- if ( ! player->audio_cb_probe_id && player->set_mode.pcm_extraction)
+ if ( ! player->audio_cb_probe_id && player->set_mode.pcm_extraction && !player->audio_stream_render_cb_ex)
__mmplayer_configure_audio_callback(player);
if ( ! player->sent_bos && oldstate == GST_STATE_READY) // managed prepare async case
if( msg->src != (GstObject *)player->pipeline->mainbin[MMPLAYER_M_PIPE].gst )
break;
- if( !MMPLAYER_IS_RTSP_STREAMING(player) )
+ if (player->doing_seek)
{
- if (player->doing_seek)
+ if (MMPLAYER_TARGET_STATE(player) == MM_PLAYER_STATE_PAUSED)
{
- if (MMPLAYER_TARGET_STATE(player) == MM_PLAYER_STATE_PAUSED)
- {
- player->doing_seek = FALSE;
- MMPLAYER_POST_MSG ( player, MM_MESSAGE_SEEK_COMPLETED, NULL );
- }
- else if (MMPLAYER_TARGET_STATE(player) == MM_PLAYER_STATE_PLAYING)
+ player->doing_seek = FALSE;
+ MMPLAYER_POST_MSG ( player, MM_MESSAGE_SEEK_COMPLETED, NULL );
+ }
+ else if (MMPLAYER_TARGET_STATE(player) == MM_PLAYER_STATE_PLAYING)
+ {
+ if ((MMPLAYER_IS_HTTP_STREAMING(player)) &&
+ (player->streamer) &&
+ (player->streamer->streaming_buffer_type == BUFFER_TYPE_MUXED) &&
+ (player->streamer->is_buffering == FALSE))
{
- if ((MMPLAYER_IS_HTTP_STREAMING(player)) &&
- (player->streamer) &&
- (player->streamer->streaming_buffer_type == BUFFER_TYPE_MUXED) &&
- (player->streamer->is_buffering == FALSE))
- {
- GstQuery *query = NULL;
- gboolean busy = FALSE;
- gint percent = 0;
+ GstQuery *query = NULL;
+ gboolean busy = FALSE;
+ gint percent = 0;
- if (player->streamer->buffer_handle[BUFFER_TYPE_MUXED].buffer)
+ if (player->streamer->buffer_handle[BUFFER_TYPE_MUXED].buffer)
+ {
+ query = gst_query_new_buffering ( GST_FORMAT_PERCENT );
+ if ( gst_element_query (player->streamer->buffer_handle[BUFFER_TYPE_MUXED].buffer, query ) )
{
- query = gst_query_new_buffering ( GST_FORMAT_PERCENT );
- if ( gst_element_query (player->streamer->buffer_handle[BUFFER_TYPE_MUXED].buffer, query ) )
- {
- gst_query_parse_buffering_percent ( query, &busy, &percent);
- }
- gst_query_unref (query);
-
- debug_log("buffered percent(%s): %d\n",
- GST_ELEMENT_NAME(player->streamer->buffer_handle[BUFFER_TYPE_MUXED].buffer), percent);
+ gst_query_parse_buffering_percent ( query, &busy, &percent);
}
+ gst_query_unref (query);
- if (percent >= 100)
- {
- player->streamer->is_buffering = FALSE;
- __mmplayer_handle_buffering_message(player);
- }
+ debug_log("buffered percent(%s): %d\n",
+ GST_ELEMENT_NAME(player->streamer->buffer_handle[BUFFER_TYPE_MUXED].buffer), percent);
}
- async_done = TRUE;
+ if (percent >= 100)
+ {
+ player->streamer->is_buffering = FALSE;
+ __mmplayer_handle_buffering_message(player);
+ }
}
+
+ async_done = TRUE;
}
}
}
/* clear previous result*/
player->have_dynamic_pad = FALSE;
- if ( ! __mmplayer_try_to_plug( player, pad, caps ) )
+ if ( !__mmplayer_try_to_plug_decodebin(player, pad, caps))
{
debug_error("failed to autoplug for caps");
goto ERROR;
if (stype == MM_DISPLAY_SURFACE_NULL)
{
debug_log ("no video sink by null surface or multiple track");
+ gchar *caps_str = gst_caps_to_string(caps);
+ if (strstr(caps_str, "ST12") || strstr(caps_str, "SN12"))
+ {
+ player->set_mode.video_zc = TRUE;
+ }
+ MMPLAYER_FREEIF( caps_str );
+
if (player->v_stream_caps)
{
gst_caps_unref(player->v_stream_caps);
{
gint samplerate = 0;
gint channels = 0;
-
+#ifdef TEST_ES
+ if (MMPLAYER_IS_ES_BUFF_SRC(player))
+ {
+ __mmplayer_gst_decode_callback (elem, pad, player);
+ return;
+ }
+#endif
debug_log ("audio selector \n");
elemId = MMPLAYER_M_A_INPUT_SELECTOR;
stream_type = MM_PLAYER_TRACK_TYPE_AUDIO;
if (selector == NULL)
{
- if (strstr(name, "audio") || strstr(name, "video")) {
- selector = gst_element_factory_make ("input-selector", NULL);
- debug_log ("Creating input-selector\n");
- if (selector == NULL)
- {
- debug_error ("ERROR : input-selector create error\n");
- goto ERROR;
- }
- g_object_set (selector, "sync-streams", TRUE, NULL);
+ selector = gst_element_factory_make ("input-selector", NULL);
+ debug_log ("Creating input-selector\n");
+ if (selector == NULL)
+ {
+ debug_error ("ERROR : input-selector create error\n");
+ goto ERROR;
}
+ g_object_set (selector, "sync-streams", TRUE, NULL);
gst_bin_add (GST_BIN(pipeline), selector);
gst_element_set_state (selector, GST_STATE_PAUSED);
goto ERROR;
}
- if (first_track && (strstr(name, "audio") || strstr(name, "video")))
+ if (first_track)
{
debug_log ("this is first track --> active track \n");
g_object_set (selector, "active-pad", sinkpad, NULL);
- } else {
- debug_log ("subtitle is of internal type \n");
- if(!player->textsink_linked) {
- g_object_set (selector, "is-internal", TRUE, NULL);
- } else {
- debug_log ("this is first track --> active track \n");
- g_object_set (selector, "active-pad", sinkpad, NULL);
- }
}
_mmplayer_track_update_info(player, stream_type, sinkpad);
MMPLAYER_RELEASE_ELEMENT ( player, player->pipeline->audiobin, MMPLAYER_A_BIN );
MMPLAYER_FREEIF ( player->pipeline->audiobin )
}
+
+ if (player->num_dynamic_pad == 0)
+ {
+ __mmplayer_pipeline_complete (NULL, player);
+ }
}
- if (text_selector)
+#ifdef TEST_ES
+ if (!MMPLAYER_IS_ES_BUFF_SRC(player))
+#endif
{
- __mmplayer_handle_text_decode_path(player, text_selector);
+ if (text_selector)
+ {
+ __mmplayer_handle_text_decode_path(player, text_selector);
+ }
}
MMPLAYER_FLEAVE();
}
sinkbin = player->pipeline->textbin[MMPLAYER_T_BIN].gst;
- debug_log("creating textink bin success\n");
+ debug_log("creating textsink bin success\n");
/* FIXIT : track number shouldn't be hardcoded */
mm_attrs_set_int_by_name(attrs, "content_text_track_num", 1);
text_selector = mainbin[MMPLAYER_M_T_INPUT_SELECTOR].gst;
}
}
+
else
{
if (!player->textsink_linked)
}
}
- if (text_selector)
- {
- GstPad *srcpad = NULL;
-
- srcpad = gst_element_get_static_pad(player->pipeline->mainbin[MMPLAYER_M_T_INPUT_SELECTOR].gst,"src");
- if (!srcpad)
- {
- debug_error ("failed to get source pad");
- goto ERROR;
- }
-
- /* link input selector & textbin */
- if (gst_pad_link(srcpad,sinkpad)!= 0)
- {
- debug_warning("failed to link input selector and textbin ghost pad\n");
- goto ERROR;
- }
-
- sinkpad = gst_element_get_request_pad (player->pipeline->mainbin[MMPLAYER_M_T_INPUT_SELECTOR].gst, "sink_%u");
- if (sinkpad == NULL)
- {
- debug_error ("failed to get request pad from input selector");;
- goto ERROR;
- }
- }
-
/* link */
if (GST_PAD_LINK_OK != GST_PAD_LINK (pad, sinkpad))
{
if ( element && element->gst )
{
+#ifdef TEST_ES
+ /* If next element is audio appsrc then make a seprate audio pipeline */
+ if (!strcmp(GST_ELEMENT_NAME(GST_ELEMENT(element->gst)),"audio_appsrc") ||
+ !strcmp(GST_ELEMENT_NAME(GST_ELEMENT(element->gst)),"subtitle_appsrc"))
+ {
+ prv_element = element;
+ continue;
+ }
+#endif
if ( GST_ELEMENT_LINK(GST_ELEMENT(prv_element->gst), GST_ELEMENT(element->gst)) )
{
debug_log("linking [%s] to [%s] success\n",
return successful_add_count;
}
+static void __mmplayer_gst_caps_notify_cb (GstPad * pad, GParamSpec * unused, gpointer data)
+{
+ mm_player_t* player = (mm_player_t*) data;
+ GstCaps *caps = NULL;
+ GstStructure *str = NULL;
+ const char *name;
+
+ MMPLAYER_FENTER();
+
+ return_if_fail ( pad )
+ return_if_fail ( unused )
+ return_if_fail ( data )
+
+ caps = gst_pad_query_caps(pad, NULL);
+ if ( !caps )
+ {
+ return;
+ }
+
+ str = gst_caps_get_structure(caps, 0);
+ if ( !str )
+ {
+ goto ERROR;
+ }
+
+ name = gst_structure_get_name(str);
+ if ( !name )
+ {
+ goto ERROR;
+ }
+
+ debug_log("name = %s\n", name);
+
+ if (strstr(name, "audio"))
+ {
+ _mmplayer_update_content_attrs (player, ATTR_AUDIO);
+
+ if (player->audio_stream_changed_cb)
+ {
+ debug_error("call the audio stream changed cb\n");
+ player->audio_stream_changed_cb(player->audio_stream_changed_cb_user_param);
+ }
+ }
+ else if (strstr(name, "video"))
+ {
+ _mmplayer_update_content_attrs (player, ATTR_VIDEO);
+
+ if (player->video_stream_changed_cb)
+ {
+ debug_error("call the video stream changed cb\n");
+ player->video_stream_changed_cb(player->video_stream_changed_cb_user_param);
+ }
+ }
+ else
+ {
+ goto ERROR;
+ }
+
+ERROR:
+
+ gst_caps_unref(caps);
+
+ MMPLAYER_FLEAVE();
+
+ return;
+}
+
/**
element_bucket = g_list_append(element_bucket, &x_bin[x_id]);\
} while(0);
+static void
+__mmplayer_audio_stream_decoded_render_cb(GstElement* object, GstBuffer *buffer, GstPad *pad, gpointer data)
+{
+ mm_player_t* player = (mm_player_t*) data;
+
+ gint channel = 0;
+ gint rate = 0;
+ gint depth = 0;
+ gint endianness = 0;
+ guint64 channel_mask = 0;
+
+ MMPlayerAudioStreamDataType audio_stream = { 0, };
+ GstMapInfo mapinfo = GST_MAP_INFO_INIT;
+
+ MMPLAYER_FENTER();
+ return_if_fail(player->audio_stream_render_cb_ex);
+
+ debug_log ("__mmplayer_audio_stream_decoded_render_cb new pad: %s", GST_PAD_NAME (pad));
+
+ gst_buffer_map(buffer, &mapinfo, GST_MAP_READ);
+ audio_stream.data = mapinfo.data;
+ audio_stream.data_size = mapinfo.size;
+
+ GstCaps *caps = gst_pad_get_current_caps( pad );
+ GstStructure *structure = gst_caps_get_structure (caps, 0);
+
+ MMPLAYER_LOG_GST_CAPS_TYPE(caps);
+ gst_structure_get_int (structure, "rate", &rate);
+ gst_structure_get_int (structure, "channels", &channel);
+ gst_structure_get_int (structure, "depth", &depth);
+ gst_structure_get_int (structure, "endianness", &endianness);
+ gst_structure_get (structure, "channel-mask", GST_TYPE_BITMASK, &channel_mask, NULL);
+
+ gst_caps_unref(GST_CAPS(caps));
+
+ audio_stream.bitrate = rate;
+ audio_stream.channel = channel;
+ audio_stream.depth = depth;
+ audio_stream.is_little_endian = (endianness == 1234 ? 1 : 0);
+ audio_stream.channel_mask = channel_mask;
+ debug_log ("bitrate : %d channel : %d depth: %d ls_little_endian : %d channel_mask: %d, %p", rate, channel, depth, endianness, channel_mask, player->audio_stream_cb_user_param);
+ player->audio_stream_render_cb_ex(&audio_stream, player->audio_stream_cb_user_param);
+ gst_buffer_unmap(buffer, &mapinfo);
+
+ MMPLAYER_FLEAVE();
+}
+
+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;
+ GstPad* sinkpad = NULL;
+ GstElement *queue = NULL, *sink = NULL;
+
+ MMPLAYER_FENTER();
+ return_if_fail (player && player->pipeline && player->pipeline->mainbin);
+
+ queue = gst_element_factory_make ("queue", NULL);
+ if (queue == NULL)
+ {
+ debug_log ("fail make queue\n");
+ goto ERROR;
+ }
+
+ sink = gst_element_factory_make ("fakesink", NULL);
+ if (sink == NULL)
+ {
+ debug_log ("fail make fakesink\n");
+ goto ERROR;
+ }
+
+ gst_bin_add_many (GST_BIN(audiobin[MMPLAYER_A_BIN].gst), queue, sink, NULL);
+
+ if (!gst_element_link_pads_full (queue, "src", sink, "sink", GST_PAD_LINK_CHECK_NOTHING))
+ {
+ debug_warning("failed to link queue & sink\n");
+ goto ERROR;
+ }
+
+ sinkpad = gst_element_get_static_pad (queue, "sink");
+
+ if (GST_PAD_LINK_OK != gst_pad_link(pad, sinkpad))
+ {
+ debug_warning ("failed to link [%s:%s] to queue\n", GST_DEBUG_PAD_NAME(pad));
+ goto ERROR;
+ }
+
+ debug_error("player->audio_stream_sink_sync: %d\n", player->audio_stream_sink_sync);
+
+ gst_object_unref (sinkpad);
+ g_object_set (sink, "sync", player->audio_stream_sink_sync, NULL);
+ g_object_set (sink, "signal-handoffs", TRUE, NULL);
+
+ gst_element_set_state (sink, GST_STATE_PAUSED);
+ gst_element_set_state (queue, GST_STATE_PAUSED);
+
+ MMPLAYER_SIGNAL_CONNECT( player,
+ G_OBJECT(sink),
+ MM_PLAYER_SIGNAL_TYPE_AUDIOBIN,
+ "handoff",
+ G_CALLBACK(__mmplayer_audio_stream_decoded_render_cb),
+ (gpointer)player );
+
+ MMPLAYER_FLEAVE();
+ return ;
+
+ERROR:
+ debug_error("__mmplayer_gst_audio_deinterleave_pad_added ERROR\n");
+ if (queue)
+ {
+ gst_object_unref(GST_OBJECT(queue));
+ queue = NULL;
+ }
+ if (sink)
+ {
+ gst_object_unref(GST_OBJECT(sink));
+ sink = NULL;
+ }
+ if (sinkpad)
+ {
+ gst_object_unref ( GST_OBJECT(sinkpad) );
+ sinkpad = NULL;
+ }
+
+ return;
+}
+
+
/**
* AUDIO PIPELINE
* - Local playback : audiotp !audioconvert ! volume ! capsfilter ! audioeffect ! audioeffect_sec ! audiosink
* - Streaming : audiotp !audioconvert !volume ! audiosink
* - PCM extraction : audiotp !audioconvert ! audioresample ! capsfilter ! fakesink
*/
+void __mmplayer_gst_create_audiosink_configure(mm_player_t* player, MMHandleType attrs)
+{
+#define MAX_PROPS_LEN 64
+ gint volume_type = 0;
+ gint route_path = 0;
+ gint latency_mode = 0;
+ gchar *stream_type = NULL;
+ gint stream_id = 0;
+ gchar stream_props[MAX_PROPS_LEN] = {0,};
+ GstStructure *props = NULL;
+
+ /* set volume table
+ * It should be set after player creation through attribute.
+ * But, it can not be changed during playing.
+ */
+ MMPLAYER_FENTER();
+ mm_attrs_get_int_by_name(attrs, "sound_stream_index", &stream_id);
+ mm_attrs_get_string_by_name (attrs, "sound_stream_type", &stream_type );
+
+ if ( stream_id < 1 || !stream_type || strlen(stream_type) < 1)
+ {
+ debug_error("stream_id[%d] or stream_type[%s] is not valid.\n", stream_id, stream_type);
+ }
+ else
+ {
+ snprintf(stream_props, sizeof(stream_props)-1, "props,media.role=%s, media.parent_id=%d", stream_type, stream_id);
+ props = gst_structure_from_string(stream_props, NULL);
+ g_object_set(player->pipeline->audiobin[MMPLAYER_A_SINK].gst, "stream-properties", props, NULL);
+ }
+
+ debug_log("stream_id[%d], stream_type[%s], result[%s].\n", stream_id, stream_type, stream_props);
+
+/* for audio tunning */
+#ifndef IS_SDK
+ if (player->profile.play_mode == MM_PLAYER_MODE_MIDI)
+ {
+ volume_type |= MM_SOUND_VOLUME_GAIN_MIDI;
+ }
+#endif
+ /* hook sound_type if emergency case */
+ if (player->sm.event == ASM_EVENT_EMERGENCY)
+ {
+ debug_log ("This is emergency session, hook sound_type from [%d] to [%d]\n", volume_type, MM_SOUND_VOLUME_TYPE_EMERGENCY);
+ volume_type = MM_SOUND_VOLUME_TYPE_EMERGENCY;
+ }
+
+ mm_attrs_get_int_by_name(attrs, "sound_latency_mode", &latency_mode);
+
+ if (player->sm.user_route_policy != 0)
+ {
+ route_path = player->sm.user_route_policy;
+ }
+
+ g_object_set(player->pipeline->audiobin[MMPLAYER_A_SINK].gst,
+ "latency", latency_mode,
+ NULL);
+
+ debug_log("audiosink property status...volume type:%d, user-route=%d, latency=%d \n",
+ volume_type, route_path, latency_mode);
+ MMPLAYER_FLEAVE();
+}
+
static int
__mmplayer_gst_create_audio_pipeline(mm_player_t* player)
{
if (player->set_mode.pcm_extraction) // pcm extraction only and no sound output
{
- int dst_samplerate = 0;
- int dst_channels = 0;
- int dst_depth = 0;
- char *caps_str = NULL;
- GstCaps* caps = NULL;
-
- /* get conf. values */
- mm_attrs_multiple_get(player->attrs,
- NULL,
- "pcm_extraction_samplerate", &dst_samplerate,
- "pcm_extraction_channels", &dst_channels,
- "pcm_extraction_depth", &dst_depth,
- NULL);
+ if(player->audio_stream_render_cb_ex)
+ {
+ MMPLAYER_CREATE_ELEMENT(audiobin, MMPLAYER_A_DEINTERLEAVE, "deinterleave", "deinterleave", TRUE, player);
- /* capsfilter */
- MMPLAYER_CREATE_ELEMENT(audiobin, MMPLAYER_A_CAPS_DEFAULT, "capsfilter", "audio capsfilter", TRUE, player);
- caps = gst_caps_new_simple ("audio/x-raw",
- "rate", G_TYPE_INT, dst_samplerate,
- "channels", G_TYPE_INT, dst_channels,
- "depth", G_TYPE_INT, dst_depth,
- NULL);
- caps_str = gst_caps_to_string(caps);
- debug_log("new caps : %s\n", caps_str);
+ g_object_set (G_OBJECT (audiobin[MMPLAYER_A_DEINTERLEAVE].gst), "keep-positions", TRUE, NULL);
+ /* raw pad handling signal */
+ MMPLAYER_SIGNAL_CONNECT( player,
+ (audiobin[MMPLAYER_A_DEINTERLEAVE].gst),
+ MM_PLAYER_SIGNAL_TYPE_AUTOPLUG, "pad-added",
+ G_CALLBACK(__mmplayer_gst_audio_deinterleave_pad_added), player);
+ }
+ else
+ {
+ int dst_samplerate = 0;
+ int dst_channels = 0;
+ int dst_depth = 0;
+ char *caps_str = NULL;
+ GstCaps* caps = NULL;
- g_object_set (GST_ELEMENT(audiobin[MMPLAYER_A_CAPS_DEFAULT].gst), "caps", caps, NULL );
+ /* get conf. values */
+ mm_attrs_multiple_get(player->attrs,
+ NULL,
+ "pcm_extraction_samplerate", &dst_samplerate,
+ "pcm_extraction_channels", &dst_channels,
+ "pcm_extraction_depth", &dst_depth,
+ NULL);
+
+ /* capsfilter */
+ MMPLAYER_CREATE_ELEMENT(audiobin, MMPLAYER_A_CAPS_DEFAULT, "capsfilter", "audio capsfilter", TRUE, player);
+ caps = gst_caps_new_simple ("audio/x-raw",
+ "rate", G_TYPE_INT, dst_samplerate,
+ "channels", G_TYPE_INT, dst_channels,
+ "depth", G_TYPE_INT, dst_depth,
+ NULL);
+ caps_str = gst_caps_to_string(caps);
+ debug_log("new caps : %s\n", caps_str);
- /* clean */
- gst_caps_unref( caps );
- MMPLAYER_FREEIF( caps_str );
+ g_object_set (GST_ELEMENT(audiobin[MMPLAYER_A_CAPS_DEFAULT].gst), "caps", caps, NULL );
- /* fake sink */
- MMPLAYER_CREATE_ELEMENT(audiobin, MMPLAYER_A_SINK, "fakesink", "fakesink", TRUE, player);
+ /* clean */
+ gst_caps_unref( caps );
+ MMPLAYER_FREEIF( caps_str );
+
+ /* fake sink */
+ MMPLAYER_CREATE_ELEMENT(audiobin, MMPLAYER_A_SINK, "fakesink", "fakesink", TRUE, player);
- /* set sync */
- g_object_set (G_OBJECT (audiobin[MMPLAYER_A_SINK].gst), "sync", FALSE, NULL);
+ /* set sync */
+ g_object_set (G_OBJECT (audiobin[MMPLAYER_A_SINK].gst), "sync", FALSE, NULL);
+ }
}
else // normal playback
{
- typedef enum
- {
- GST_BASE_AUDIO_SINK_SLAVE_RESAMPLE = 0,
- GST_BASE_AUDIO_SINK_SLAVE_SKEW,
- GST_BASE_AUDIO_SINK_SLAVE_NONE
- } GstBaseAudioSinkSlaveMethod;
-
//GstCaps* caps = NULL;
gint channels = 0;
/* qos on */
g_object_set (G_OBJECT (audiobin[MMPLAYER_A_SINK].gst), "qos", TRUE, NULL); /* qos on */
- g_object_set (G_OBJECT (audiobin[MMPLAYER_A_SINK].gst), "slave-method", GST_BASE_AUDIO_SINK_SLAVE_NONE, NULL);
+ g_object_set (G_OBJECT (audiobin[MMPLAYER_A_SINK].gst), "slave-method", GST_AUDIO_BASE_SINK_SLAVE_NONE, NULL);
/* FIXIT : using system clock. isn't there another way? */
if (player->videodec_linked)
g_object_set (G_OBJECT (audiobin[MMPLAYER_A_SINK].gst), "provide-clock", player->ini.provide_clock_for_music, NULL);
}
- if ( g_strrstr(player->ini.name_of_audiosink, "avsysaudiosink") || g_strrstr(player->ini.name_of_audiosink, "pulsesink") )
+ if ( g_strrstr(player->ini.name_of_audiosink, "pulsesink") )
{
- gint volume_type = 0;
- gint audio_route = 0;
- gint sound_priority = FALSE;
- gint route_path = 0;
- gint latency_mode = 0;
- gint close_handle = 0;
-
- /* set volume table
- * It should be set after player creation through attribute.
- * But, it can not be changed during playing.
- */
- mm_attrs_get_int_by_name(attrs, "sound_volume_type", &volume_type);
- mm_attrs_get_int_by_name(attrs, "sound_route", &audio_route);
- mm_attrs_get_int_by_name(attrs, "sound_priority", &sound_priority);
- mm_attrs_get_int_by_name(attrs, "sound_spk_out_only", &route_path);
- mm_attrs_get_int_by_name(attrs, "sound_latency_mode", &latency_mode);
- mm_attrs_get_int_by_name(attrs, "sound_close_resource", &close_handle);
-/* for audio tunning */
-#ifndef IS_SDK
- if (player->profile.play_mode == MM_PLAYER_MODE_MIDI) {
- volume_type |= MM_SOUND_VOLUME_GAIN_MIDI;
- }
-#endif
-#if 0
- /* hook sound_type if emergency case */
- if (player->sm.event == ASM_EVENT_EMERGENCY) {
- debug_log ("This is emergency session, hook sound_type from [%d] to [%d]\n", volume_type, MM_SOUND_VOLUME_TYPE_EMERGENCY);
- volume_type = MM_SOUND_VOLUME_TYPE_EMERGENCY;
- }
-
- if (player->sm.user_route_policy != 0) {
- route_path = player->sm.user_route_policy;
- }
-#endif
- g_object_set(audiobin[MMPLAYER_A_SINK].gst,
- "volumetype", volume_type,
- "audio-route", audio_route,
- "priority", sound_priority,
- "user-route", route_path,
- "latency", latency_mode,
- "close-handle-on-prepare", close_handle,
- NULL);
-
- debug_log("audiosink property status...volume type:%d, route:%d, priority=%d, user-route=%d, latency=%d, close-resource=%d\n",
- volume_type, audio_route, sound_priority, route_path, latency_mode, close_handle);
+ __mmplayer_gst_create_audiosink_configure(player, attrs);
}
/* Antishock can be enabled when player is resumed by soundCM.
__mmplayer_set_antishock( player , FALSE );
}
+ if (audiobin[MMPLAYER_A_SINK].gst)
+ {
+ GstPad *sink_pad = NULL;
+ sink_pad = gst_element_get_static_pad(audiobin[MMPLAYER_A_SINK].gst, "sink");
+ MMPLAYER_SIGNAL_CONNECT (player, sink_pad, MM_PLAYER_SIGNAL_TYPE_AUDIOBIN,
+ "notify::caps", G_CALLBACK(__mmplayer_gst_caps_notify_cb), player);
+ gst_object_unref (GST_OBJECT(sink_pad));
+ }
+
__mmplayer_add_sink( player, audiobin[MMPLAYER_A_SINK].gst );
/* adding created elements to bin */
goto ERROR;
}
- /* get first element's sinkpad for creating ghostpad */
- first_element = (MMPlayerGstElement *)element_bucket->data;
+ /* get first element's sinkpad for creating ghostpad */
+ first_element = (MMPlayerGstElement *)element_bucket->data;
- pad = gst_element_get_static_pad(GST_ELEMENT(first_element->gst), "sink");
+ pad = gst_element_get_static_pad(GST_ELEMENT(first_element->gst), "sink");
if ( ! pad )
{
debug_error("failed to get pad from first element of audiobin\n");
{
GstCaps *caps = NULL;
MMPlayerVideoStreamDataType stream;
- MMPlayerMPlaneImage *scmn_imgb = NULL;
+ MMVideoBuffer *video_buffer = NULL;
GstMemory *dataBlock = NULL;
GstMemory *metaBlock = NULL;
GstMapInfo mapinfo = GST_MAP_INFO_INIT;
gst_buffer_n_memory(buffer) > 1) {
metaBlock = gst_buffer_peek_memory(buffer, 1);
gst_memory_map(metaBlock, &mapinfo, GST_MAP_READ);
- scmn_imgb = (MMPlayerMPlaneImage *)mapinfo.data;
+ video_buffer = (MMVideoBuffer *)mapinfo.data;
}
- /* set tbm bo */
- if (scmn_imgb) {
- /* copy pointer of tbm bo */
- memcpy(stream.bo, scmn_imgb->bo, sizeof(void *) * MM_PLAYER_IMGB_MPLANE_MAX);
-
- /*
- int i = 0;
- for (i = 0 ; i < BUFFER_MAX_PLANE_NUM ; i++) {
- debug_log("scmn bo %p, stream bo %p", scmn_imgb->bo[i], stream.bo[i]);
+ if (video_buffer) {
+ /* set tbm bo */
+ if (video_buffer->type == MM_VIDEO_BUFFER_TYPE_TBM_BO) {
+ /* copy pointer of tbm bo, stride, elevation */
+ memcpy(stream.bo, video_buffer->handle.bo,
+ sizeof(void *) * MM_VIDEO_BUFFER_PLANE_MAX);
}
- */
-
+ else if (video_buffer->type == MM_VIDEO_BUFFER_TYPE_PHYSICAL_ADDRESS) {
+ memcpy(stream.data, video_buffer->data,
+ sizeof(void *) * MM_VIDEO_BUFFER_PLANE_MAX);
+ }
+ memcpy(stream.stride, video_buffer->stride_width,
+ sizeof(int) * MM_VIDEO_BUFFER_PLANE_MAX);
+ memcpy(stream.elevation, video_buffer->stride_height,
+ sizeof(int) * MM_VIDEO_BUFFER_PLANE_MAX);
/* set gst buffer */
stream.internal_buffer = buffer;
} else {
gst_memory_map(dataBlock, &mapinfo, GST_MAP_READWRITE);
- stream.data = mapinfo.data;
+ stream.data[0] = mapinfo.data;
}
if (player->video_stream_cb) {
}
}
- if ( _mmplayer_update_video_param(player) != MM_ERROR_NONE)
+ if (_mmplayer_update_video_param(player) != MM_ERROR_NONE)
goto ERROR;
+ if (videobin[MMPLAYER_V_SINK].gst)
+ {
+ GstPad *sink_pad = NULL;
+ sink_pad = gst_element_get_static_pad(videobin[MMPLAYER_V_SINK].gst, "sink");
+ MMPLAYER_SIGNAL_CONNECT (player, sink_pad, MM_PLAYER_SIGNAL_TYPE_VIDEOBIN,
+ "notify::caps", G_CALLBACK(__mmplayer_gst_caps_notify_cb), player);
+ gst_object_unref (GST_OBJECT(sink_pad));
+ }
+
/* store it as it's sink element */
__mmplayer_add_sink( player, videobin[MMPLAYER_V_SINK].gst );
}
debug_log ("link text input selector and textbin ghost pad");
- if (!gst_element_link_pads (subparse, "src", player->pipeline->textbin[MMPLAYER_T_BIN].gst, "text_sink"))
- {
- debug_warning("failed to link subparse and textbin\n");
- goto ERROR;
- }
- player->textsink_linked = 1;
+ player->textsink_linked = 1;
player->external_text_idx = 0;
debug_msg("player->textsink_linked set to 1\n");
}
else
{
debug_log("text bin has been created. reuse it.");
-
- if (!gst_element_link_pads (subparse, "src", player->pipeline->textbin[MMPLAYER_T_BIN].gst, "text_sink"))
- {
- debug_warning("failed to link subparse and textbin\n");
- goto ERROR;
- }
-
player->external_text_idx = 1;
}
return MM_ERROR_NONE;
ERROR:
+ player->textsink_linked = 0;
return MM_ERROR_PLAYER_INTERNAL;
}
static void
__gst_appsrc_feed_data(GstElement *element, guint size, gpointer user_data) // @
{
- mm_player_t *player = (mm_player_t*)user_data;
+ mm_player_t *player = (mm_player_t*)user_data;
+ MMPlayerStreamType type = MM_PLAYER_STREAM_TYPE_DEFAULT;
return_if_fail ( player );
debug_msg("app-src: feed data\n");
- if(player->need_data_cb)
- player->need_data_cb(size, player->buffer_cb_user_param);
+ if (player->media_stream_buffer_status_cb[type])
+ player->media_stream_buffer_status_cb[type](type, MM_PLAYER_MEDIA_STREAM_BUFFER_UNDERRUN, player->buffer_cb_user_param);
}
static gboolean
__gst_appsrc_seek_data(GstElement *element, guint64 offset, gpointer user_data) // @
{
mm_player_t *player = (mm_player_t*)user_data;
+ MMPlayerStreamType type = MM_PLAYER_STREAM_TYPE_DEFAULT;
return_val_if_fail ( player, FALSE );
debug_msg("app-src: seek data\n");
- if(player->seek_data_cb)
- player->seek_data_cb(offset, player->buffer_cb_user_param);
+ if(player->media_stream_seek_data_cb[type])
+ player->media_stream_seek_data_cb[type](type, offset, player->buffer_cb_user_param);
return TRUE;
}
__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;
return_val_if_fail ( player, FALSE );
- debug_msg("app-src: enough data:%p\n", player->enough_data_cb);
+ debug_msg("app-src: enough data:%p\n", player->media_stream_buffer_status_cb[type]);
- if(player->enough_data_cb)
- player->enough_data_cb(player->buffer_cb_user_param);
+ if (player->media_stream_buffer_status_cb[type])
+ player->media_stream_buffer_status_cb[type](type, MM_PLAYER_MEDIA_STREAM_BUFFER_OVERFLOW, player->buffer_cb_user_param);
return TRUE;
}
return reply;
}
+#ifdef TEST_ES
+#if 0 // TO CHECK
+static void
+__mm_player_src_pad_block_cb (GstPad *pad, gboolean blocked, gpointer user_data)
+{
+ if (blocked)
+ {
+ debug_log("src pad is blocked");
+ }
+ else
+ {
+ debug_log("src pad is unblocked");
+ }
+}
+#endif
+static gboolean
+__mmplayer_gst_create_decoder ( mm_player_t *player,
+ MMPlayerTrackType track,
+ GstPad* srcpad,
+ enum MainElementID elemId,
+ const gchar* name)
+{
+ gboolean ret = TRUE;
+ GstPad *sinkpad = NULL;
+
+ MMPLAYER_FENTER();
+
+ return_val_if_fail( player &&
+ player->pipeline &&
+ player->pipeline->mainbin, FALSE);
+ return_val_if_fail((track == MM_PLAYER_TRACK_TYPE_AUDIO || track == MM_PLAYER_TRACK_TYPE_VIDEO), FALSE);
+ return_val_if_fail(srcpad, FALSE);
+ return_val_if_fail((player->pipeline->mainbin[elemId].gst == NULL), FALSE);
+
+ GstElement *decodebin = NULL;
+ GstCaps *dec_caps = NULL;
+
+ /* create decodebin */
+ decodebin = gst_element_factory_make("decodebin", name);
+
+ if (!decodebin)
+ {
+ debug_error("error : fail to create decodebin for %d decoder\n", track);
+ ret = FALSE;
+ goto ERROR;
+ }
+
+ /* raw pad handling signal */
+ MMPLAYER_SIGNAL_CONNECT( player, G_OBJECT(decodebin), MM_PLAYER_SIGNAL_TYPE_AUTOPLUG, "pad-added",
+ G_CALLBACK(__mmplayer_gst_decode_pad_added), player);
+
+ /* This signal is emitted whenever decodebin2 finds a new stream. It is emitted
+ before looking for any elements that can handle that stream.*/
+ MMPLAYER_SIGNAL_CONNECT( player, G_OBJECT(decodebin), MM_PLAYER_SIGNAL_TYPE_AUTOPLUG, "autoplug-select",
+ G_CALLBACK(__mmplayer_gst_decode_autoplug_select), player);
+
+ /* This signal is emitted when a element is added to the bin.*/
+ MMPLAYER_SIGNAL_CONNECT( player, G_OBJECT(decodebin), MM_PLAYER_SIGNAL_TYPE_AUTOPLUG, "element-added",
+ G_CALLBACK(__mmplayer_gst_element_added), player);
+
+ if (!gst_bin_add(GST_BIN(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst), decodebin))
+ {
+ debug_error("failed to add new decodebin\n");
+ ret = FALSE;
+ goto ERROR;
+ }
+
+ dec_caps = gst_pad_query_caps (srcpad, NULL);
+ if (dec_caps)
+ {
+ //debug_log ("got pad %s:%s , dec_caps %" GST_PTR_FORMAT, GST_DEBUG_PAD_NAME(srcpad), dec_caps);
+ g_object_set(G_OBJECT(decodebin), "sink-caps", dec_caps, NULL);
+ gst_caps_unref(dec_caps);
+ }
+
+ player->pipeline->mainbin[elemId].id = elemId;
+ player->pipeline->mainbin[elemId].gst = decodebin;
+
+ sinkpad = gst_element_get_static_pad (decodebin, "sink");
+
+ if (GST_PAD_LINK_OK != gst_pad_link(srcpad, sinkpad))
+ {
+ debug_warning ("failed to link [%s:%s] to decoder\n", GST_DEBUG_PAD_NAME(srcpad));
+ gst_object_unref (GST_OBJECT(decodebin));
+ }
+
+ if (GST_STATE_CHANGE_FAILURE == gst_element_sync_state_with_parent (decodebin))
+ {
+ debug_error("failed to sync second level decodebin state with parent\n");
+ }
+
+ debug_log ("unblocking %" GST_PTR_FORMAT, srcpad);
+// TO CHECK : gst_pad_set_blocked_async (srcpad, FALSE, __mm_player_src_pad_block_cb, NULL);
+
+ debug_log("Total num of %d tracks = %d \n", track, player->selector[track].total_track_num);
+
+ERROR:
+ if (sinkpad)
+ {
+ gst_object_unref ( GST_OBJECT(sinkpad) );
+ sinkpad = NULL;
+ }
+ MMPLAYER_FLEAVE();
+
+ return ret;
+}
+#endif
/**
* This function is to create audio or video pipeline for playing.
MMPlayerGstElement *mainbin = NULL;
MMHandleType attrs = 0;
GstElement* element = NULL;
+#ifdef TEST_ES
+ GstElement* elem_src_audio = NULL;
+ GstElement* elem_src_subtitle = NULL;
+ GstElement* es_video_queue = NULL;
+ GstElement* es_audio_queue = NULL;
+ GstElement* es_subtitle_queue = NULL;
+#endif
GList* element_bucket = NULL;
gboolean need_state_holder = TRUE;
gint i = 0;
secure_debug_log("user_agent : %s\n", user_agent);
secure_debug_log("wap_profile : %s\n", wap_profile);
- debug_log("network_bandwidth : %d\n", network_bandwidth);
- debug_log("buffering time : %d\n", player->ini.rtsp_buffering_time);
- debug_log("rebuffering time : %d\n", player->ini.rtsp_rebuffering_time);
/* setting property to streaming source */
g_object_set(G_OBJECT(element), "location", player->profile.uri, NULL);
- g_object_set(G_OBJECT(element), "bandwidth", network_bandwidth, NULL);
- g_object_set(G_OBJECT(element), "buffering_time", player->ini.rtsp_buffering_time, NULL);
- g_object_set(G_OBJECT(element), "rebuffering_time", player->ini.rtsp_rebuffering_time, NULL);
if ( user_agent )
g_object_set(G_OBJECT(element), "user_agent", user_agent, NULL);
if ( wap_profile )
case MM_PLAYER_URI_TYPE_FILE:
{
-#ifdef ENABLE_DRMSRC
-
- char* drmsrc = player->ini.name_of_drmsrc;
-
- debug_log("using [%s] for 'file://' handler.\n", drmsrc);
-
- element = gst_element_factory_make(drmsrc, "source");
- if ( !element )
- {
- debug_error("failed to create %s\n", drmsrc);
- break;
- }
-#else
debug_log("using filesrc for 'file://' handler.\n");
element = gst_element_factory_make("filesrc", "source");
debug_error("failed to create filesrc\n");
break;
}
-#endif
+
g_object_set(G_OBJECT(element), "location", (player->profile.uri)+7, NULL); /* uri+7 -> remove "file:// */
//g_object_set(G_OBJECT(element), "use-mmap", TRUE, NULL);
}
G_CALLBACK(__gst_appsrc_enough_data), player);
}
break;
+#ifdef TEST_ES
+ case MM_PLAYER_URI_TYPE_ES_BUFF:
+ {
+ debug_log("es buff src is selected\n");
+
+ if (player->v_stream_caps)
+ {
+ element = gst_element_factory_make("appsrc", "video_appsrc");
+ if ( !element )
+ {
+ debug_critical("failed to create video app source element[appsrc].\n" );
+ break;
+ }
+
+ if ( player->a_stream_caps )
+ {
+ elem_src_audio = gst_element_factory_make("appsrc", "audio_appsrc");
+ if ( !elem_src_audio )
+ {
+ debug_critical("failed to create audio app source element[appsrc].\n" );
+ break;
+ }
+ }
+ }
+ else if ( player->a_stream_caps )
+ {
+ /* no video, only audio pipeline*/
+ element = gst_element_factory_make("appsrc", "audio_appsrc");
+ if ( !element )
+ {
+ debug_critical("failed to create audio app source element[appsrc].\n" );
+ break;
+ }
+ }
+
+ if ( player->s_stream_caps )
+ {
+ elem_src_subtitle = gst_element_factory_make("appsrc", "subtitle_appsrc");
+ if ( !elem_src_subtitle )
+ {
+ debug_critical("failed to create subtitle app source element[appsrc].\n" );
+ break;
+ }
+ }
+
+ debug_log("setting app sources properties.\n");
+ debug_log("location : %s\n", player->profile.uri);
+
+ if ( player->v_stream_caps && element )
+ {
+ g_object_set(G_OBJECT(element), "format", GST_FORMAT_TIME,
+ "blocksize", (guint)1048576, /* size of many video frames are larger than default blocksize as 4096 */
+ "caps", player->v_stream_caps, NULL);
+
+ if ( player->media_stream_buffer_max_size[MM_PLAYER_STREAM_TYPE_VIDEO] > 0)
+ g_object_set(G_OBJECT(element), "max-bytes", player->media_stream_buffer_max_size[MM_PLAYER_STREAM_TYPE_VIDEO], NULL);
+ if ( player->media_stream_buffer_min_percent[MM_PLAYER_STREAM_TYPE_VIDEO] > 0)
+ g_object_set(G_OBJECT(element), "min-percent", player->media_stream_buffer_min_percent[MM_PLAYER_STREAM_TYPE_VIDEO], NULL);
+
+ /*Fix Seek External Demuxer: set audio and video appsrc as seekable */
+ gst_app_src_set_stream_type((GstAppSrc*)G_OBJECT(element), GST_APP_STREAM_TYPE_SEEKABLE);
+ MMPLAYER_SIGNAL_CONNECT( player, element, MM_PLAYER_SIGNAL_TYPE_OTHERS, "seek-data",
+ G_CALLBACK(__gst_seek_video_data), player);
+
+ if (player->a_stream_caps && elem_src_audio)
+ {
+ g_object_set(G_OBJECT(elem_src_audio), "format", GST_FORMAT_TIME,
+ "caps", player->a_stream_caps, NULL);
+
+ if ( player->media_stream_buffer_max_size[MM_PLAYER_STREAM_TYPE_AUDIO] > 0)
+ g_object_set(G_OBJECT(elem_src_audio), "max-bytes", player->media_stream_buffer_max_size[MM_PLAYER_STREAM_TYPE_AUDIO], NULL);
+ if ( player->media_stream_buffer_min_percent[MM_PLAYER_STREAM_TYPE_AUDIO] > 0)
+ g_object_set(G_OBJECT(elem_src_audio), "min-percent", player->media_stream_buffer_min_percent[MM_PLAYER_STREAM_TYPE_AUDIO], NULL);
+
+ /*Fix Seek External Demuxer: set audio and video appsrc as seekable */
+ gst_app_src_set_stream_type((GstAppSrc*)G_OBJECT(elem_src_audio), GST_APP_STREAM_TYPE_SEEKABLE);
+ MMPLAYER_SIGNAL_CONNECT( player, elem_src_audio, MM_PLAYER_SIGNAL_TYPE_OTHERS, "seek-data",
+ G_CALLBACK(__gst_seek_audio_data), player);
+ }
+ }
+ else if (player->a_stream_caps && element)
+ {
+ g_object_set(G_OBJECT(element), "format", GST_FORMAT_TIME,
+ "caps", player->a_stream_caps, NULL);
+
+ if ( player->media_stream_buffer_max_size[MM_PLAYER_STREAM_TYPE_AUDIO] > 0)
+ g_object_set(G_OBJECT(element), "max-bytes", player->media_stream_buffer_max_size[MM_PLAYER_STREAM_TYPE_AUDIO], NULL);
+ if ( player->media_stream_buffer_min_percent[MM_PLAYER_STREAM_TYPE_AUDIO] > 0)
+ g_object_set(G_OBJECT(element), "min-percent", player->media_stream_buffer_min_percent[MM_PLAYER_STREAM_TYPE_AUDIO], NULL);
+
+ /*Fix Seek External Demuxer: set audio and video appsrc as seekable */
+ gst_app_src_set_stream_type((GstAppSrc*)G_OBJECT(element), GST_APP_STREAM_TYPE_SEEKABLE);
+ MMPLAYER_SIGNAL_CONNECT( player, element, MM_PLAYER_SIGNAL_TYPE_OTHERS, "seek-data",
+ G_CALLBACK(__gst_seek_audio_data), player);
+ }
+
+ if (player->s_stream_caps && elem_src_subtitle)
+ {
+ g_object_set(G_OBJECT(elem_src_subtitle), "format", GST_FORMAT_TIME,
+ "caps", player->s_stream_caps, NULL);
+
+ if ( player->media_stream_buffer_max_size[MM_PLAYER_STREAM_TYPE_TEXT] > 0)
+ g_object_set(G_OBJECT(elem_src_subtitle), "max-bytes", player->media_stream_buffer_max_size[MM_PLAYER_STREAM_TYPE_TEXT], NULL);
+ if ( player->media_stream_buffer_min_percent[MM_PLAYER_STREAM_TYPE_TEXT] > 0)
+ g_object_set(G_OBJECT(elem_src_subtitle), "min-percent", player->media_stream_buffer_min_percent[MM_PLAYER_STREAM_TYPE_TEXT], NULL);
+
+ gst_app_src_set_stream_type((GstAppSrc*)G_OBJECT(elem_src_subtitle), GST_APP_STREAM_TYPE_SEEKABLE);
+
+ MMPLAYER_SIGNAL_CONNECT( player, elem_src_subtitle, MM_PLAYER_SIGNAL_TYPE_OTHERS, "seek-data",
+ G_CALLBACK(__gst_seek_subtitle_data), player);
+ }
+
+ if (!player->es_player_push_mode)
+ {
+ if (player->v_stream_caps && element)
+ {
+ MMPLAYER_SIGNAL_CONNECT( player, element, MM_PLAYER_SIGNAL_TYPE_OTHERS, "need-data",
+ G_CALLBACK(__gst_appsrc_feed_video_data), player);
+ MMPLAYER_SIGNAL_CONNECT( player, element, MM_PLAYER_SIGNAL_TYPE_OTHERS, "enough-data",
+ G_CALLBACK(__gst_appsrc_enough_video_data), player);
+
+ if (player->a_stream_caps && elem_src_audio)
+ {
+ MMPLAYER_SIGNAL_CONNECT( player, elem_src_audio, MM_PLAYER_SIGNAL_TYPE_OTHERS, "need-data",
+ G_CALLBACK(__gst_appsrc_feed_audio_data), player);
+ MMPLAYER_SIGNAL_CONNECT( player, element, MM_PLAYER_SIGNAL_TYPE_OTHERS, "enough-data",
+ G_CALLBACK(__gst_appsrc_enough_audio_data), player);
+ }
+ }
+ else if (player->a_stream_caps && element)
+ {
+ MMPLAYER_SIGNAL_CONNECT( player, element, MM_PLAYER_SIGNAL_TYPE_OTHERS, "need-data",
+ G_CALLBACK(__gst_appsrc_feed_audio_data), player);
+ MMPLAYER_SIGNAL_CONNECT( player, element, MM_PLAYER_SIGNAL_TYPE_OTHERS, "enough-data",
+ G_CALLBACK(__gst_appsrc_enough_audio_data), player);
+ }
+
+ if (player->s_stream_caps && elem_src_subtitle)
+ {
+ MMPLAYER_SIGNAL_CONNECT( player, elem_src_subtitle, MM_PLAYER_SIGNAL_TYPE_OTHERS, "need-data",
+ G_CALLBACK(__gst_appsrc_feed_subtitle_data), player);
+ }
+ }
+ need_state_holder = FALSE;
+ }
+ break;
+#endif
/* appsrc */
case MM_PLAYER_URI_TYPE_MEM:
{
NULL,
0);
}
+#ifdef TEST_ES
+ if (MMPLAYER_IS_ES_BUFF_SRC(player))
+ {
+ if (player->v_stream_caps)
+ {
+ es_video_queue = gst_element_factory_make("queue2", "video_queue");
+ if (!es_video_queue)
+ {
+ debug_error ("create es_video_queue for es player failed\n");
+ goto INIT_ERROR;
+ }
+ mainbin[MMPLAYER_M_V_BUFFER].id = MMPLAYER_M_V_BUFFER;
+ mainbin[MMPLAYER_M_V_BUFFER].gst = es_video_queue;
+ element_bucket = g_list_append(element_bucket, &mainbin[MMPLAYER_M_V_BUFFER]);
+
+ /* Adding audio appsrc to bucket */
+ if (player->a_stream_caps && elem_src_audio)
+ {
+ mainbin[MMPLAYER_M_2ND_SRC].id = MMPLAYER_M_2ND_SRC;
+ mainbin[MMPLAYER_M_2ND_SRC].gst = elem_src_audio;
+ element_bucket = g_list_append(element_bucket, &mainbin[MMPLAYER_M_2ND_SRC]);
+
+ es_audio_queue = gst_element_factory_make("queue2", "audio_queue");
+ if (!es_audio_queue)
+ {
+ debug_error ("create es_audio_queue for es player failed\n");
+ goto INIT_ERROR;
+ }
+ mainbin[MMPLAYER_M_A_BUFFER].id = MMPLAYER_M_A_BUFFER;
+ mainbin[MMPLAYER_M_A_BUFFER].gst = es_audio_queue;
+ element_bucket = g_list_append(element_bucket, &mainbin[MMPLAYER_M_A_BUFFER]);
+ }
+ }
+ /* Only audio stream, no video */
+ else if (player->a_stream_caps)
+ {
+ es_audio_queue = gst_element_factory_make("queue2", "audio_queue");
+ if (!es_audio_queue)
+ {
+ debug_error ("create es_audio_queue for es player failed\n");
+ goto INIT_ERROR;
+ }
+ mainbin[MMPLAYER_M_A_BUFFER].id = MMPLAYER_M_A_BUFFER;
+ mainbin[MMPLAYER_M_A_BUFFER].gst = es_audio_queue;
+ element_bucket = g_list_append(element_bucket, &mainbin[MMPLAYER_M_A_BUFFER]);
+ }
+
+ if (player->s_stream_caps && elem_src_subtitle)
+ {
+ mainbin[MMPLAYER_M_SUBSRC].id = MMPLAYER_M_SUBSRC;
+ mainbin[MMPLAYER_M_SUBSRC].gst = elem_src_subtitle;
+ element_bucket = g_list_append(element_bucket, &mainbin[MMPLAYER_M_SUBSRC]);
+
+ es_subtitle_queue = gst_element_factory_make("queue2", "subtitle_queue");
+ if (!es_subtitle_queue)
+ {
+ debug_error ("create es_subtitle_queue for es player failed\n");
+ goto INIT_ERROR;
+ }
+ mainbin[MMPLAYER_M_S_BUFFER].id = MMPLAYER_M_V_BUFFER;
+ mainbin[MMPLAYER_M_S_BUFFER].gst = es_subtitle_queue;
+ element_bucket = g_list_append(element_bucket, &mainbin[MMPLAYER_M_S_BUFFER]);
+ }
+ }
+#endif
/* create autoplugging element if src element is not a rtsp src */
if ((player->profile.uri_type != MM_PLAYER_URI_TYPE_URL_RTSP) &&
- (player->profile.uri_type != MM_PLAYER_URI_TYPE_URL_WFD))
+ (player->profile.uri_type != MM_PLAYER_URI_TYPE_URL_WFD)
+#ifdef TEST_ES
+ && (player->profile.uri_type != MM_PLAYER_URI_TYPE_ES_BUFF)
+#endif
+ )
{
element = NULL;
enum MainElementID elemId = MMPLAYER_M_NUM;
/* now we have completed mainbin. take it */
player->pipeline->mainbin = mainbin;
+#ifdef TEST_ES
+ if (MMPLAYER_IS_ES_BUFF_SRC(player))
+ {
+ GstPad *srcpad = NULL;
+
+ if (mainbin[MMPLAYER_M_V_BUFFER].gst)
+ {
+ srcpad = gst_element_get_static_pad(mainbin[MMPLAYER_M_V_BUFFER].gst, "src");
+ if (srcpad)
+ {
+ __mmplayer_gst_create_decoder ( player,
+ MM_PLAYER_TRACK_TYPE_VIDEO,
+ srcpad,
+ MMPLAYER_M_AUTOPLUG_V_DEC,
+ "video_decodebin");
+
+ gst_object_unref ( GST_OBJECT(srcpad) );
+ srcpad = NULL;
+ }
+ }
+
+ if ((player->a_stream_caps) && (mainbin[MMPLAYER_M_A_BUFFER].gst))
+ {
+ srcpad = gst_element_get_static_pad(mainbin[MMPLAYER_M_A_BUFFER].gst, "src");
+ if (srcpad)
+ {
+ __mmplayer_gst_create_decoder ( player,
+ MM_PLAYER_TRACK_TYPE_AUDIO,
+ srcpad,
+ MMPLAYER_M_AUTOPLUG_A_DEC,
+ "audio_decodebin");
+
+ gst_object_unref ( GST_OBJECT(srcpad) );
+ srcpad = NULL;
+ } // else error
+ } // else error
+
+ if (mainbin[MMPLAYER_M_S_BUFFER].gst)
+ {
+ __mmplayer_try_to_plug_decodebin(player, gst_element_get_static_pad(mainbin[MMPLAYER_M_S_BUFFER].gst, "src"), player->s_stream_caps);
+ }
+ }
+#endif
+
+
/* connect bus callback */
bus = gst_pipeline_get_bus(GST_PIPELINE(mainbin[MMPLAYER_M_PIPE].gst));
if ( !bus )
__mmplayer_cancel_eos_timer( player );
/* remove sound cb */
- /* remove sound cb */
if ( MM_ERROR_NONE != mm_sound_remove_device_information_changed_callback())
{
debug_error("failed to mm_sound_remove_device_information_changed_callback()");
gst_caps_unref(player->v_stream_caps);
player->v_stream_caps = NULL;
}
-
+#ifdef TEST_ES
+ if (player->a_stream_caps)
+ {
+ gst_caps_unref(player->a_stream_caps);
+ player->a_stream_caps = NULL;
+ }
+ if (player->s_stream_caps)
+ {
+ gst_caps_unref(player->s_stream_caps);
+ player->s_stream_caps = NULL;
+ }
+#endif
_mmplayer_track_destroy(player);
if ( player->sink_elements )
{
gboolean sound_extraction = 0;
int ret = MM_ERROR_NONE;
-
+#ifdef TEST_ES
+ gboolean async = FALSE;
+#endif
MMPLAYER_FENTER();
return_val_if_fail ( player && player->pipeline, MM_ERROR_PLAYER_NOT_INITIALIZED );
MMPLAYER_PENDING_STATE(player) = MM_PLAYER_STATE_PLAYING;
MMPLAYER_PRINT_STATE(player);
+#ifdef TEST_ES
+ /* set pipeline state to PLAYING */
+ if (player->es_player_push_mode)
+ {
+ async = TRUE;
+ }
+ /* set pipeline state to PLAYING */
+ ret = __mmplayer_gst_set_state(player,
+ player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, GST_STATE_PLAYING, async, MMPLAYER_STATE_CHANGE_TIMEOUT(player) );
+#else
/* set pipeline state to PLAYING */
ret = __mmplayer_gst_set_state(player,
player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, GST_STATE_PLAYING, FALSE, MMPLAYER_STATE_CHANGE_TIMEOUT(player) );
+#endif
if (ret == MM_ERROR_NONE)
{
MMPLAYER_SET_STATE(player, MM_PLAYER_STATE_PLAYING);
return ret;
}
-#if 0
+
static void __mmplayer_do_sound_fadedown(mm_player_t* player, unsigned int time)
{
MMPLAYER_FENTER();
MMPLAYER_FLEAVE();
}
-#endif
static int __gst_stop(mm_player_t* player) // @
{
gint timeout = 0;
int ret = MM_ERROR_NONE;
GstState state;
-
+#ifdef TEST_ES
+ gboolean async = FALSE;
+#endif
MMPLAYER_FENTER();
return_val_if_fail ( player && player->pipeline, MM_ERROR_PLAYER_NOT_INITIALIZED);
mm_attrs_get_int_by_name(attrs, "sound_fadedown", &fadedown);
/* enable fadedown */
-// if (fadedown || player->sm.by_asm_cb)
-// __mmplayer_do_sound_fadedown(player, MM_PLAYER_FADEOUT_TIME_DEFAULT);
+ if (fadedown || player->sm.by_asm_cb)
+ __mmplayer_do_sound_fadedown(player, MM_PLAYER_FADEOUT_TIME_DEFAULT);
/* Just set state to PAUESED and the rewind. it's usual player behavior. */
timeout = MMPLAYER_STATE_CHANGE_TIMEOUT ( player );
rewind = TRUE;
}
}
-
+#ifdef TEST_ES
+ if (player->es_player_push_mode)
+ {
+ async = TRUE;
+ }
+ /* set gst state */
+ ret = __mmplayer_gst_set_state( player, player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, state, async, timeout );
+#else
/* set gst state */
ret = __mmplayer_gst_set_state( player, player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, state, FALSE, timeout );
+#endif
/* disable fadeout */
-// if (fadedown || player->sm.by_asm_cb)
-// __mmplayer_undo_sound_fadedown(player);
+ if (fadedown || player->sm.by_asm_cb)
+ __mmplayer_undo_sound_fadedown(player);
/* return if set_state has failed */
if ( ret != MM_ERROR_NONE )
/* initialize */
player->sent_bos = FALSE;
+#ifdef TEST_ES
+ if (player->es_player_push_mode) //for cloudgame
+ {
+ timeout = 0;
+ }
+#endif
/* wait for seek to complete */
change_ret = gst_element_get_state (player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, NULL, NULL, timeout * GST_SECOND);
if ( change_ret == GST_STATE_CHANGE_SUCCESS || change_ret == GST_STATE_CHANGE_NO_PREROLL )
&& MMPLAYER_CURRENT_STATE(player) != MM_PLAYER_STATE_PAUSED )
goto PENDING;
- /* check duration */
- /* NOTE : duration cannot be zero except live streaming.
- * Since some element could have some timing problemn with quering duration, try again.
- */
- if ( !player->duration )
+#ifdef TEST_ES
+ if( !MMPLAYER_IS_ES_BUFF_SRC(player) )
+#endif
{
- if ( !gst_element_query_duration( player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, GST_FORMAT_TIME, &dur_nsec ))
+ /* check duration */
+ /* NOTE : duration cannot be zero except live streaming.
+ * Since some element could have some timing problemn with quering duration, try again.
+ */
+ if ( !player->duration )
{
- goto SEEK_ERROR;
+ if ( !gst_element_query_duration( player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, GST_FORMAT_TIME, &dur_nsec ))
+ {
+ goto SEEK_ERROR;
+ }
+ player->duration = dur_nsec;
}
- player->duration = dur_nsec;
- }
- if ( player->duration )
- {
- dur_msec = GST_TIME_AS_MSECONDS(player->duration);
- }
- else
- {
- debug_error("could not get the duration. fail to seek.\n");
- goto SEEK_ERROR;
+ if ( player->duration )
+ {
+ dur_msec = GST_TIME_AS_MSECONDS(player->duration);
+ }
+ else
+ {
+ debug_error("could not get the duration. fail to seek.\n");
+ goto SEEK_ERROR;
+ }
}
-
debug_log("playback rate: %f\n", player->playback_rate);
- mm_attrs_get_int_by_name(player->attrs,"accurate_seek", &accurated);
+ mm_attrs_get_int_by_name(player->attrs, "accurate_seek", &accurated);
if (accurated)
{
seek_flags |= GST_SEEK_FLAG_ACCURATE;
{
case MM_PLAYER_POS_FORMAT_TIME:
{
- /* check position is valid or not */
- if ( position > dur_msec )
- goto INVALID_ARGS;
+#ifdef TEST_ES
+ if( !MMPLAYER_IS_ES_BUFF_SRC(player) )
+#endif
+ {
+ /* check position is valid or not */
+ if ( position > dur_msec )
+ goto INVALID_ARGS;
- debug_log("seeking to (%lu) msec, duration is %d msec\n", position, dur_msec);
+ debug_log("seeking to (%lu) msec, duration is %d msec\n", position, dur_msec);
- if (player->doing_seek)
- {
- debug_log("not completed seek");
- return MM_ERROR_PLAYER_DOING_SEEK;
+ if ( player->doing_seek )
+ {
+ debug_log("not completed seek");
+ return MM_ERROR_PLAYER_DOING_SEEK;
+ }
}
- if ( !internal_called)
+ if ( !internal_called )
player->doing_seek = TRUE;
pos_nsec = position * G_GINT64_CONSTANT(1000000);
pos_msec = player->duration;
}
-// if (player->sm.keep_last_pos) {
-// debug_log("return last pos as stop by asm, %"GST_TIME_FORMAT, GST_TIME_ARGS(player->last_position));
-// pos_msec = player->last_position;
-// }
-// else {
-// player->last_position = pos_msec;
-// }
+ if (player->sm.keep_last_pos) {
+ debug_log("return last pos as stop by asm, %"GST_TIME_FORMAT, GST_TIME_ARGS(player->last_position));
+ pos_msec = player->last_position;
+ }
+ else {
+ player->last_position = pos_msec;
+ }
}
switch (format) {
debug_warning("could access %s.\n", path);
}
}
+#ifdef TEST_ES
+ else if ((path = strstr(uri, "es_buff://")))
+ {
+ if (strlen(path))
+ {
+ strcpy(data->uri, uri);
+ data->uri_type = MM_PLAYER_URI_TYPE_ES_BUFF;
+ ret = MM_ERROR_NONE;
+ }
+ }
+#endif
else if ((path = strstr(uri, "buff://")))
{
data->uri_type = MM_PLAYER_URI_TYPE_BUFF;
return ret;
}
-#if 0
+
gboolean _asm_postmsg(gpointer *data)
{
mm_player_t* player = (mm_player_t*)data;
goto FAILED;
}
- if (/*(player->sm.exit_cb) ||*/ (player->set_mode.pcm_extraction))
+ if ((player->sm.exit_cb) || (player->set_mode.pcm_extraction))
{
-// debug_warning("leave from asm cb right now, %d, %d", player->sm.exit_cb, player->set_mode.pcm_extraction);
+ debug_warning("leave from asm cb right now, %d, %d", player->sm.exit_cb, player->set_mode.pcm_extraction);
goto FAILED;
}
}
/* check other thread */
- if (player->cmd_lock)
+ if (!g_mutex_trylock(&player->cmd_lock))
{
- if (!g_mutex_trylock(player->cmd_lock))
- {
- debug_warning("locked already, cmd state : %d", player->cmd);
+ debug_warning("locked already, cmd state : %d", player->cmd);
- /* check application command */
- if (player->cmd == MMPLAYER_COMMAND_START || player->cmd == MMPLAYER_COMMAND_RESUME)
- {
- debug_warning("playing.. should wait cmd lock then, will be interrupted");
- g_mutex_lock(player->cmd_lock);
- goto INTERRUPT;
- }
- debug_warning("nothing to do");
- goto FAILED;
- }
- else
+ /* check application command */
+ if (player->cmd == MMPLAYER_COMMAND_START || player->cmd == MMPLAYER_COMMAND_RESUME)
{
- debug_warning("can interrupt immediately");
+ debug_warning("playing.. should wait cmd lock then, will be interrupted");
+ g_mutex_lock(&player->cmd_lock);
goto INTERRUPT;
}
+ debug_warning("nothing to do");
+ goto FAILED;
+ }
+ else
+ {
+ debug_warning("can interrupt immediately");
+ goto INTERRUPT;
}
FAILED:
/* video resource conflict */
if(player->pipeline->videobin)
{
- if (player->ini.multiple_codec_supported)
- {
- debug_log("video conflict but, can support multiple video");
- result = _mmplayer_pause((MMHandleType)player);
- cb_res = ASM_CB_RES_PAUSE;
- }
- else
- {
- debug_log("video conflict, can't support multiple video");
- result = _mmplayer_unrealize((MMHandleType)player);
- cb_res = ASM_CB_RES_STOP;
- }
+ debug_log("video conflict but, can support multiple video");
+ result = _mmplayer_pause((MMHandleType)player);
+ cb_res = ASM_CB_RES_PAUSE;
}
else if (player->pipeline->audiobin)
{
debug_warning("dispatched");
return cb_res;
}
-#endif
+
int
_mmplayer_create_player(MMHandleType handle) // @
{
debug_error("failed to register asm server\n");
return MM_ERROR_POLICY_INTERNAL;
}
-#endif
+
/* to add active device callback */
if ( MM_ERROR_NONE != mm_sound_add_device_information_changed_callback(MM_SOUND_DEVICE_STATE_ACTIVATED_FLAG, __mmplayer_sound_device_info_changed_cb_func, (void*)player))
{
debug_error("failed mm_sound_add_device_information_changed_callback \n");
}
+#endif
if (MMPLAYER_IS_HTTP_PD(player))
{
/* release next play thread */
if ( player->next_play_thread )
{
-
- MMPLAYER_PLAYBACK_LOCK(player);
player->next_play_thread_exit = TRUE;
g_cond_signal( &player->next_play_thread_cond );
}
_mmplayer_release_video_capture(player);
-#if 0
+
/* flush any pending asm_cb */
if (player->sm.cb_pending)
{
sched_yield();
MMPLAYER_CMD_LOCK(player);
}
-
+#if 0
/* withdraw asm */
if ( MM_ERROR_NONE != _mmplayer_asm_unregister(&player->sm) )
{
debug_error("failed to deregister asm server\n");
}
#endif
-
#ifdef USE_LAZY_PAUSE
if (player->lazy_pause_event_id)
{
}
mm_attrs_get_int_by_name(attrs, "sound_application_pid", &application_pid );
-// player->sm.pid = application_pid;
+ player->sm.pid = application_pid;
mm_attrs_get_string_by_name(attrs, "profile_uri", &uri);
mm_attrs_get_data_by_name(attrs, "profile_user_param", ¶m);
player->mem_buf.offset = 0;
}
+#ifdef TEST_ES // es_player_push_mode is needed?
+ if (player->profile.uri_type == MM_PLAYER_URI_TYPE_ES_BUFF)
+ {
+ if (strstr(uri, "es_buff://push_mode"))
+ {
+ player->es_player_push_mode = TRUE;
+ }
+ else
+ {
+ player->es_player_push_mode = FALSE;
+ }
+ }
+#endif
if (player->profile.uri_type == MM_PLAYER_URI_TYPE_URL_MMS)
{
debug_warning("mms protocol is not supported format.\n");
/* set asm stop if success */
if (MM_ERROR_NONE == ret)
{
-#if 0
if (player->sm.state != ASM_STATE_STOP)
{
/* NOTE : Stop asm after pipeline unrealize. Keep this sequence. */
return ret;
}
}
-#endif
}
else
{
return MM_ERROR_NONE;
}
- *pmute = player->sound.mute;
+ *pmute = player->sound.mute;
+
+ MMPLAYER_FLEAVE();
+
+ return MM_ERROR_NONE;
+}
+
+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_FENTER();
+
+ return_val_if_fail ( player, MM_ERROR_PLAYER_NOT_INITIALIZED );
+
+ player->video_stream_changed_cb = callback;
+ player->video_stream_changed_cb_user_param = user_param;
+ debug_log("Handle value is %p : %p\n", player, player->video_stream_changed_cb);
MMPLAYER_FLEAVE();
}
int
-_mmplayer_set_videostream_cb(MMHandleType hplayer, mm_player_video_stream_callback callback, void *user_param) // @
+_mmplayer_set_audiostream_changed_cb(MMHandleType hplayer, mm_player_stream_changed_callback callback, void *user_param)
{
mm_player_t* player = (mm_player_t*) hplayer;
return_val_if_fail ( player, MM_ERROR_PLAYER_NOT_INITIALIZED );
- player->video_stream_cb = callback;
- player->video_stream_cb_user_param = user_param;
- player->use_video_stream = TRUE;
- debug_log("Stream cb Handle value is %p : %p\n", player, player->video_stream_cb);
+ player->audio_stream_changed_cb = callback;
+ player->audio_stream_changed_cb_user_param = user_param;
+ debug_log("Handle value is %p : %p\n", player, player->audio_stream_changed_cb);
MMPLAYER_FLEAVE();
}
int
-_mmplayer_set_audiostream_cb(MMHandleType hplayer, mm_player_audio_stream_callback callback, void *user_param) // @
+_mmplayer_set_audiostream_cb_ex(MMHandleType hplayer, bool sync, mm_player_audio_stream_callback_ex callback, void *user_param) // @
{
mm_player_t* player = (mm_player_t*) hplayer;
return_val_if_fail ( player, MM_ERROR_PLAYER_NOT_INITIALIZED );
- player->audio_stream_cb = callback;
- player->audio_stream_cb_user_param = user_param;
- debug_log("Audio Stream cb Handle value is %p : %p\n", player, player->audio_stream_cb);
+ player->audio_stream_render_cb_ex = callback;
+ player->audio_stream_cb_user_param = user_param;
+ player->audio_stream_sink_sync = sync;
+ debug_log("Audio Stream cb Handle value is %p : %p audio_stream_sink_sync : %d\n", player, player->audio_stream_render_cb_ex, player->audio_stream_sink_sync);
MMPLAYER_FLEAVE();
}
int
-_mmplayer_set_buffer_need_data_cb(MMHandleType hplayer, mm_player_buffer_need_data_callback callback, void *user_param) // @
+_mmplayer_set_videostream_cb(MMHandleType hplayer, mm_player_video_stream_callback callback, void *user_param) // @
{
mm_player_t* player = (mm_player_t*) hplayer;
MMPLAYER_FENTER();
- return_val_if_fail ( player && player->pipeline, MM_ERROR_PLAYER_NOT_INITIALIZED );
- return_val_if_fail(callback, MM_ERROR_INVALID_ARGUMENT);
-
- player->need_data_cb = callback;
- player->buffer_cb_user_param = user_param;
+ return_val_if_fail ( player, MM_ERROR_PLAYER_NOT_INITIALIZED );
- debug_log("buffer need dataHandle value is %p : %p\n", player, player->need_data_cb);
+ player->video_stream_cb = callback;
+ player->video_stream_cb_user_param = user_param;
+ player->use_video_stream = TRUE;
+ debug_log("Stream cb Handle value is %p : %p\n", player, player->video_stream_cb);
MMPLAYER_FLEAVE();
}
int
-_mmplayer_set_buffer_enough_data_cb(MMHandleType hplayer, mm_player_buffer_enough_data_callback callback, void *user_param) // @
+_mmplayer_set_audiostream_cb(MMHandleType hplayer, mm_player_audio_stream_callback callback, void *user_param) // @
{
mm_player_t* player = (mm_player_t*) hplayer;
MMPLAYER_FENTER();
- return_val_if_fail ( player && player->pipeline, MM_ERROR_PLAYER_NOT_INITIALIZED );
- return_val_if_fail(callback, MM_ERROR_INVALID_ARGUMENT);
-
- player->enough_data_cb = callback;
- player->buffer_cb_user_param = user_param;
+ return_val_if_fail ( player, MM_ERROR_PLAYER_NOT_INITIALIZED );
- debug_log("buffer enough data cb Handle value is %p : %p\n", player, player->enough_data_cb);
+ player->audio_stream_cb = callback;
+ player->audio_stream_cb_user_param = user_param;
+ debug_log("Audio Stream cb Handle value is %p : %p\n", player, player->audio_stream_cb);
MMPLAYER_FLEAVE();
}
int
-_mmplayer_set_buffer_seek_data_cb(MMHandleType hplayer, mm_player_buffer_seek_data_callback callback, void *user_param) // @
-{
- mm_player_t* player = (mm_player_t*) hplayer;
-
- MMPLAYER_FENTER();
-
- return_val_if_fail ( player && player->pipeline, MM_ERROR_PLAYER_NOT_INITIALIZED );
- return_val_if_fail(callback, MM_ERROR_INVALID_ARGUMENT);
-
- player->seek_data_cb = callback;
- player->buffer_cb_user_param = user_param;
-
- debug_log("buffer seek data cb Handle value is %p : %p\n", player, player->seek_data_cb);
-
- MMPLAYER_FLEAVE();
-
- return MM_ERROR_NONE;
-}
-
-int
_mmplayer_set_videoframe_render_error_cb(MMHandleType hplayer, mm_player_video_frame_render_error_callback callback, void *user_param) // @
{
mm_player_t* player = (mm_player_t*) hplayer;
/* check current state */
MMPLAYER_CHECK_STATE_RETURN_IF_FAIL( player, MMPLAYER_COMMAND_START );
-// ret = _mmplayer_asm_set_state(hplayer, ASM_STATE_PLAYING, TRUE);
-// if ( ret != MM_ERROR_NONE )
-// {
-// debug_error("failed to set asm state to PLAYING\n");
-// return ret;
-// }
+ ret = _mmplayer_asm_set_state(hplayer, ASM_STATE_PLAYING, TRUE);
+ if ( ret != MM_ERROR_NONE )
+ {
+ debug_error("failed to set asm state to PLAYING\n");
+ return ret;
+ }
/* NOTE : we should check and create pipeline again if not created as we destroy
* whole pipeline when stopping in streamming playback
return_val_if_fail ( player, MM_ERROR_PLAYER_NOT_INITIALIZED );
-// ret = _mmplayer_asm_set_state(hplayer, ASM_STATE_PLAYING, TRUE);
-// if ( ret )
-// {
-// debug_error("failed to set asm state to PLAYING\n");
-// return ret;
-// }
+ ret = _mmplayer_asm_set_state(hplayer, ASM_STATE_PLAYING, TRUE);
+ if ( ret )
+ {
+ debug_error("failed to set asm state to PLAYING\n");
+ return ret;
+ }
/* check current state */
MMPLAYER_CHECK_STATE_RETURN_IF_FAIL( player, MMPLAYER_COMMAND_RESUME );
/* resume pipeline */
+#if 0
+#ifdef TEST_ES
+ if(MMPLAYER_IS_ES_BUFF_SRC(player))
+ //async = TRUE;
+#endif
+#endif
+
ret = __gst_resume( player, async );
if ( ret != MM_ERROR_NONE )
MMPLAYER_FENTER();
/* create decodebin */
- decodebin = gst_element_factory_make("decodebin", "decodebin");
+ decodebin = gst_element_factory_make("decodebin", NULL);
if (!decodebin)
{
return decodebin;
}
-static void
-__mmplayer_gst_id3_pad_added(GstElement *element, GstPad *pad, gpointer data)
-{
- mm_player_t* player = (mm_player_t*)data;
- GstCaps *caps = NULL;
- gchar *caps_str = NULL;
-
- MMPLAYER_FENTER();
- return_if_fail (player && pad);
-
- caps = gst_pad_query_caps(pad, NULL);
- caps_str = gst_caps_to_string(caps);
-
- debug_log("pad %s:%s, caps %s", GST_DEBUG_PAD_NAME(pad), caps_str);
- __mmplayer_try_to_plug_decodebin(player, pad, caps);
-
- MMPLAYER_FREEIF( caps_str );
- gst_caps_unref(caps);
-
- MMPLAYER_FLEAVE();
-}
-
static gboolean
__mmplayer_try_to_plug_decodebin(mm_player_t* player, GstPad *srcpad, const GstCaps *caps)
{
}
else
{
- if (!mainbin[MMPLAYER_M_ID3DEMUX].gst)
- {
- caps_str = gst_caps_to_string(caps);
- if (g_strrstr(caps_str, "application/x-id3"))
- {
- debug_log("create id3demux in front of queue2 \n");
-
- id3demux = gst_element_factory_make ("id3demux", NULL);
- if (!id3demux)
- {
- debug_error ("failed to create buffering id3demux element\n");
- goto ERROR;
- }
-
- MMPLAYER_SIGNAL_CONNECT( player, G_OBJECT(id3demux), MM_PLAYER_SIGNAL_TYPE_AUTOPLUG, "pad-added",
- G_CALLBACK(__mmplayer_gst_id3_pad_added), player);
-
- if (!gst_bin_add(GST_BIN(mainbin[MMPLAYER_M_PIPE].gst), id3demux))
- {
- debug_error("failed to add id3demux\n");
- goto ERROR;
- }
-
- sinkpad = gst_element_get_static_pad(id3demux, "sink");
-
- if (GST_PAD_LINK_OK != gst_pad_link(srcpad, sinkpad))
- {
- debug_error("failed to link buffering queue\n");
- goto ERROR;
- }
-
- if (GST_STATE_CHANGE_FAILURE == gst_element_sync_state_with_parent (id3demux))
- {
- debug_error("failed to sync id3demux state with parent\n");
- goto ERROR;
- }
-
- mainbin[MMPLAYER_M_ID3DEMUX].id = MMPLAYER_M_ID3DEMUX;
- mainbin[MMPLAYER_M_ID3DEMUX].gst = id3demux;
-
- gst_object_unref(GST_OBJECT(sinkpad));
- MMPLAYER_FREEIF( caps_str );
-
- MMPLAYER_FLEAVE();
- return TRUE;
- }
-
- MMPLAYER_FREEIF( caps_str );
- }
-
queue2 = gst_element_factory_make ("queue2", "queue2");
if (!queue2)
{
/* check factory class for filtering */
klass = gst_element_factory_get_klass(GST_ELEMENT_FACTORY(factory));
+#ifdef TEST_ES
+ /*parsers are not required in case of external feeder*/
+ if (g_strrstr(klass, "Codec/Parser") && MMPLAYER_IS_ES_BUFF_SRC(player))
+ continue;
+#endif
/* NOTE : msl don't need to use image plugins.
* So, those plugins should be skipped for error handling.
*/
}
DONE:
- MMPLAYER_FLEAVE();
+ MMPLAYER_FLEAVE();
return MM_ERROR_NONE;
}
return_if_fail( player );
/* remove fakesink. */
- if ( ! __mmplayer_gst_remove_fakesink( player,
- &player->pipeline->mainbin[MMPLAYER_M_SRC_FAKESINK]) )
+ if ( !__mmplayer_gst_remove_fakesink( player,
+ &player->pipeline->mainbin[MMPLAYER_M_SRC_FAKESINK]) )
{
/* NOTE : __mmplayer_pipeline_complete() can be called several time. because
* signaling mechanism ( pad-added, no-more-pad, new-decoded-pad ) from various
debug_log("pipeline has completely constructed\n");
- if ( ( player->ini.async_start ) &&
+ if (( player->ini.async_start ) &&
( player->msg_posted == FALSE ) &&
( player->cmd >= MMPLAYER_COMMAND_START ))
{
/* file source */
case MM_PLAYER_URI_TYPE_FILE:
{
-
-#ifdef ENABLE_DRMSRC
-
- char* drmsrc = player->ini.name_of_drmsrc;
-
- debug_log("using [%s] for 'file://' handler.\n", drmsrc);
-
- element = gst_element_factory_make(drmsrc, "source");
- if ( !element )
- {
- debug_error("failed to create %s\n", drmsrc);
- break;
- }
-#else
debug_log("using filesrc for 'file://' handler.\n");
element = gst_element_factory_make("filesrc", "source");
debug_error("failed to create filesrc\n");
break;
}
-#endif
+
g_object_set(G_OBJECT(element), "location", (player->profile.uri)+7, NULL); /* uri+7 -> remove "file:// */
break;
}
goto DONE;
}
+#ifdef TEST_ES
+ if ((MMPLAYER_IS_ES_BUFF_SRC(player)) &&
+ (g_strrstr(klass, "Codec/Demuxer") || (g_strrstr(klass, "Codec/Parser"))))
+ {
+ // TO CHECK : subtitle ÇÊ¿äÇÏ¸é ¿©±â¿¡ subparse exception Ãß°¡
+ debug_log("skipping parser/demuxer [%s] in es player by not required\n", factory_name);
+ result = GST_AUTOPLUG_SELECT_SKIP;
+ goto DONE;
+ }
+#endif
+
if (g_strrstr(factory_name, "mpegpsdemux"))
{
debug_log("skipping PS container - not support\n");
goto DONE;
}
- if (g_strrstr(factory_name, "mpegtsdemux") || g_strrstr(factory_name, "ssdemux"))
+ if (g_strrstr(factory_name, "mpegtsdemux") || g_strrstr(factory_name, SMOOTH_STREAMING_DEMUX))
{
- if (g_strrstr(factory_name, "ssdemux"))
+ if (g_strrstr(factory_name, SMOOTH_STREAMING_DEMUX))
player->smooth_streaming = TRUE;
if (g_strrstr(caps_str, "video/x-h264"))
gst_structure_get_int (str, "width", &width);
if (width != 0) {
- #define UHD_SIZE 3840*2160
- gint height = 0;
- gst_structure_get_int (str, "height", &height);
-
if (player->v_stream_caps) {
gst_caps_unref(player->v_stream_caps);
player->v_stream_caps = NULL;
player->v_stream_caps = gst_caps_copy(caps);
debug_log ("take caps for video state tune");
MMPLAYER_LOG_GST_CAPS_TYPE(player->v_stream_caps);
-
- /* check video resolution */
- if (width*height == UHD_SIZE) {
- if ((util_is_miracast_connected()) && (player->msg_posted == FALSE)) {
- MMMessageParamType msg = {0,};
- /*post error*/
- msg.code = MM_ERROR_PLAYER_RESOURCE_LIMIT;
- debug_error("can't play in miracast");
- MMPLAYER_POST_MSG(player, MM_MESSAGE_ERROR, &msg);
- player->msg_posted = TRUE;
- }
- }
}
}
- if ((g_strrstr(klass, "Codec/Parser/Audio")))
- {
- if (player->smooth_streaming && (g_strrstr(caps_str, "audio/mpeg")))
- {
- debug_log ("ssdemux can't use audio parse");
- result = GST_AUTOPLUG_SELECT_SKIP;
- goto DONE;
- }
-
- }
if (g_strrstr(klass, "Decoder"))
{
#endif
static GValueArray*
-__mmplayer_gst_decode_autoplug_sort(GstElement *bin, GstPad* pad,
-GstCaps* caps, GValueArray* factories, gpointer data) // @
+ __mmplayer_gst_decode_autoplug_sort(GstElement *bin, GstPad* pad,
+ GstCaps* caps, GValueArray* factories, gpointer data) // @
{
#define DEFAULT_IDX 0xFFFF
MMPLAYER_FREEIF(caps_str);
- for(idx=0; idx < factories->n_values;idx++)
+ for(idx=0; idx < factories->n_values; idx++)
{
- factory = g_value_get_object (g_value_array_get_nth (factories, idx));
-
+ factory = g_value_get_object(g_value_array_get_nth(factories, idx));
klass = gst_element_factory_get_klass(factory);
factory_name = GST_OBJECT_NAME (factory);
{
debug_log("[Re-arrange] factories sequence, new_pos : %d, elem_idx : %d\n", new_pos, elem_idx);
- new_factories = g_value_array_copy (factories);
+ new_factories = g_value_array_copy(factories);
// insert omx decoder in front of other decoders
- factory = g_value_get_object (g_value_array_get_nth (factories, elem_idx));
+ factory = g_value_get_object(g_value_array_get_nth(factories, elem_idx));
g_value_init (&val, G_TYPE_OBJECT);
g_value_set_object (&val, factory);
- g_value_array_insert (new_factories, new_pos, &val);
+ g_value_array_insert(new_factories, new_pos, &val);
g_value_unset (&val);
// remove duplicated omx element
g_value_array_remove(new_factories, elem_idx+1);
- for(idx=0; idx < new_factories->n_values;idx++)
+ for(idx=0; idx < new_factories->n_values; idx++)
{
- factory = g_value_get_object (g_value_array_get_nth (new_factories, idx));
+ factory = g_value_get_object(g_value_array_get_nth(new_factories, idx));
debug_log("[Re-arranged] Klass [%s] Factory [%s]\n",
gst_element_factory_get_klass(factory), GST_OBJECT_NAME (factory));
mm_attrs_get_int_by_name (player->attrs, "display_surface_type", &surface_type);
+#if 0 // this is for 0.10 plugin with downstream modification
/* playback protection if drm file */
if (player->use_video_stream || surface_type == MM_DISPLAY_SURFACE_EVAS || surface_type == MM_DISPLAY_SURFACE_X_EXT)
{
debug_log("playback can be protected if playready drm");
g_object_set (G_OBJECT(element), "playback-protection", TRUE, NULL);
}
+#endif
}
// to support trust-zone only
g_object_set (G_OBJECT(element), "downloading-mode", player->video_hub_download_mode, NULL);
}
}
- else if (g_strrstr(factory_name, "legacyh264parse")) // ssdemux
+ else if (g_strrstr(factory_name, "legacyh264parse")) // SMOOTH_STREAMING_DEMUX
{
- debug_log ("[ssdemux] output-format to legacyh264parse\n");
+ debug_log ("[%s] output-format to legacyh264parse\n", SMOOTH_STREAMING_DEMUX);
g_object_set (G_OBJECT(element), "output-format", 1, NULL); /* NALU/Byte Stream format */
}
else if (g_strrstr(factory_name, "mpegaudioparse"))
g_object_set(G_OBJECT(element), "http-pull-mp3dec", TRUE, NULL);
}
}
- else if (g_strrstr(factory_name, "omx_"))
+ else if (g_strrstr(factory_name, "omx"))
{
if (g_strrstr(klass, "Codec/Decoder/Video"))
{
player->video_stream_cb_user_param = NULL;
player->audio_stream_cb = NULL;
+ player->audio_stream_render_cb_ex = NULL;
player->audio_stream_cb_user_param = NULL;
+ player->audio_stream_sink_sync = false;
+
+ player->video_stream_changed_cb = NULL;
+ player->video_stream_changed_cb_user_param = NULL;
+
+ player->audio_stream_changed_cb = NULL;
+ player->audio_stream_changed_cb_user_param = NULL;
player->sent_bos = FALSE;
player->playback_rate = DEFAULT_PLAYBACK_RATE;
player->max_audio_channels = 0;
player->video_share_api_delta = 0;
player->video_share_clock_delta = 0;
-// player->sm.keep_last_pos = FALSE;
+ player->sm.keep_last_pos = FALSE;
player->is_subtitle_force_drop = FALSE;
player->play_subtitle = FALSE;
player->use_textoverlay = FALSE;
player->maximum_bitrate[i] = 0;
}
+ /* remove media stream cb (appsrc cb) */
+ for (i = 0; i < MM_PLAYER_STREAM_TYPE_MAX; i++)
+ {
+ player->media_stream_buffer_status_cb[i] = NULL;
+ player->media_stream_seek_data_cb[i] = NULL;
+ }
+
/* free memory related to audio effect */
MMPLAYER_FREEIF(player->audio_effect_info.custom_ext_level_for_plugin);
{
gchar *name = g_strdup(GST_ELEMENT_NAME( GST_PAD_PARENT ( srcpad )));
- if (g_strrstr(name, "mpegtsdemux")|| g_strrstr(name, "ssdemux"))
+ if (g_strrstr(name, "mpegtsdemux")|| g_strrstr(name, SMOOTH_STREAMING_DEMUX))
{
gchar *src_demux_caps_str = NULL;
gchar *needed_parser = NULL;
if (g_strrstr(src_demux_caps_str, "video/x-h264"))
{
- if (g_strrstr(name, "ssdemux"))
+ if (g_strrstr(name, SMOOTH_STREAMING_DEMUX))
{
needed_parser = g_strdup("legacyh264parse");
smooth_streaming = TRUE;
}
mm_attrs_get_int_by_name(attrs, "sound_fadeup", &antishock);
-/*
+
if (player->sm.antishock) {
antishock = TRUE;
player->sm.antishock = 0;
}
-*/
+
debug_log("setting antishock as (%d)\n", antishock);
if ( disable_by_force )
{
debug_log("sending event[%s] to sink element [%s] success!\n",
GST_EVENT_TYPE_NAME(event), GST_ELEMENT_NAME(sink) );
- break;
+#ifdef TEST_ES
+ if( MMPLAYER_IS_ES_BUFF_SRC(player))
+ {
+ sinks = g_list_next (sinks);
+ continue;
+ }
+ else
+#endif
+ break;
}
debug_log("sending event[%s] to sink element [%s] failed. try with next one.\n",
}
/*To get the new pad from the selector*/
- change_pad_name = g_strdup_printf ("sink%d", index);
+ change_pad_name = g_strdup_printf ("sink_%u", index);
if (change_pad_name == NULL)
{
result = MM_ERROR_PLAYER_INTERNAL;
sinkpad = gst_element_get_static_pad (mainbin[elemId].gst, change_pad_name);
if (sinkpad == NULL)
{
+ debug_log ("sinkpad is NULL");
result = MM_ERROR_PLAYER_INTERNAL;
goto EXIT;
}
{
return_val_if_fail ( player, FALSE );
- return ( __is_rtsp_streaming ( player ) || __is_wfd_streaming ( player ) || __is_http_streaming ( player )
+ return ( __is_http_progressive_down( player ) || __is_rtsp_streaming ( player ) || __is_wfd_streaming ( player ) || __is_http_streaming ( player )
|| __is_http_live_streaming ( player ) || __is_dash_streaming ( player ) || __is_smooth_streaming(player) ) ? TRUE : FALSE;
}
return ((player->pd_mode) ? TRUE:FALSE);
}
+#ifdef TEST_ES
+gboolean
+__is_es_buff_src( mm_player_t* player )
+{
+ return_val_if_fail ( player, FALSE );
+
+ return ( player->profile.uri_type == MM_PLAYER_URI_TYPE_ES_BUFF) ? TRUE : FALSE;
+}
+#endif
+
gboolean
__has_suffix(mm_player_t* player, const gchar* suffix)
{
return MM_ERROR_NONE;
}
+
+void * _mm_player_media_packet_video_stream_internal_buffer_ref(void *buffer)
+{
+ void * ret = NULL
+ MMPLAYER_FENTER();
+ /* increase ref count of gst buffer */
+ if (buffer)
+ ret = gst_buffer_ref((GstBuffer *)buffer);
+
+ MMPLAYER_FLEAVE();
+ return ret;
+}
+
+void _mm_player_media_packet_video_stream_internal_buffer_unref(void *buffer)
+{
+ MMPLAYER_FENTER();
+ if (buffer) {
+ gst_buffer_unref((GstBuffer *)buffer);
+ buffer = NULL;
+ }
+ MMPLAYER_FLEAVE();
+}
+
+void
+__gst_appsrc_feed_audio_data(GstElement *element, guint size, gpointer user_data)
+{
+ mm_player_t *player = (mm_player_t*)user_data;
+ MMPlayerStreamType type = MM_PLAYER_STREAM_TYPE_AUDIO;
+
+ return_if_fail ( player );
+
+ debug_msg("app-src: feed audio\n");
+
+ if (player->media_stream_buffer_status_cb[type])
+ {
+ player->media_stream_buffer_status_cb[type](type, MM_PLAYER_MEDIA_STREAM_BUFFER_UNDERRUN, player->buffer_cb_user_param);
+ }
+}
+
+void
+__gst_appsrc_feed_video_data(GstElement *element, guint size, gpointer user_data)
+{
+ mm_player_t *player = (mm_player_t*)user_data;
+ MMPlayerStreamType type = MM_PLAYER_STREAM_TYPE_VIDEO;
+
+ return_if_fail ( player );
+
+ debug_msg("app-src: feed video\n");
+
+ if (player->media_stream_buffer_status_cb[type])
+ {
+ player->media_stream_buffer_status_cb[type](type, MM_PLAYER_MEDIA_STREAM_BUFFER_UNDERRUN, player->buffer_cb_user_param);
+ }
+}
+
+void
+__gst_appsrc_feed_subtitle_data(GstElement *element, guint size, gpointer user_data)
+{
+ mm_player_t *player = (mm_player_t*)user_data;
+ MMPlayerStreamType type = MM_PLAYER_STREAM_TYPE_TEXT;
+
+ return_if_fail ( player );
+
+ debug_msg("app-src: feed subtitle\n");
+
+ if (player->media_stream_buffer_status_cb[type])
+ {
+ player->media_stream_buffer_status_cb[type](type, MM_PLAYER_MEDIA_STREAM_BUFFER_UNDERRUN, player->buffer_cb_user_param);
+ }
+}
+
+void
+__gst_appsrc_enough_audio_data(GstElement *element, gpointer user_data)
+{
+ mm_player_t *player = (mm_player_t*)user_data;
+ MMPlayerStreamType type = MM_PLAYER_STREAM_TYPE_AUDIO;
+
+ return_if_fail ( player );
+
+ debug_msg("app-src: audio buffer is full.\n");
+
+ if (player->media_stream_buffer_status_cb[type])
+ {
+ player->media_stream_buffer_status_cb[type](type, MM_PLAYER_MEDIA_STREAM_BUFFER_OVERFLOW, player->buffer_cb_user_param);
+ }
+}
+
+void
+__gst_appsrc_enough_video_data(GstElement *element, gpointer user_data)
+{
+ mm_player_t *player = (mm_player_t*)user_data;
+ MMPlayerStreamType type = MM_PLAYER_STREAM_TYPE_VIDEO;
+
+ return_if_fail ( player );
+
+ debug_msg("app-src: video buffer is full.\n");
+
+ if (player->media_stream_buffer_status_cb[type])
+ {
+ player->media_stream_buffer_status_cb[type](type, MM_PLAYER_MEDIA_STREAM_BUFFER_OVERFLOW, player->buffer_cb_user_param);
+ }
+}
+
+gboolean
+__gst_seek_audio_data (GstElement * appsrc, guint64 position, gpointer user_data)
+{
+ mm_player_t *player = (mm_player_t*)user_data;
+ MMPlayerStreamType type = MM_PLAYER_STREAM_TYPE_AUDIO;
+
+ return_val_if_fail( player, FALSE );
+
+ debug_log("app-src: seek audio data\n");
+
+ if (player->media_stream_seek_data_cb[type])
+ {
+ player->media_stream_seek_data_cb[type](type, position, player->buffer_cb_user_param);
+ }
+
+ return TRUE;
+}
+
+gboolean
+__gst_seek_video_data (GstElement * appsrc, guint64 position, gpointer user_data)
+{
+ mm_player_t *player = (mm_player_t*)user_data;
+ MMPlayerStreamType type = MM_PLAYER_STREAM_TYPE_VIDEO;
+
+ return_val_if_fail( player, FALSE );
+
+ debug_log("app-src: seek video data\n");
+
+ if (player->media_stream_seek_data_cb[type])
+ {
+ player->media_stream_seek_data_cb[type](type, position, player->buffer_cb_user_param);
+ }
+
+ return TRUE;
+}
+
+gboolean
+__gst_seek_subtitle_data (GstElement * appsrc, guint64 position, gpointer user_data)
+{
+ mm_player_t *player = (mm_player_t*)user_data;
+ MMPlayerStreamType type = MM_PLAYER_STREAM_TYPE_TEXT;
+
+ return_val_if_fail( player, FALSE );
+
+ debug_log("app-src: seek subtitle data\n");
+
+ if (player->media_stream_seek_data_cb[type])
+ {
+ player->media_stream_seek_data_cb[type](type, position, player->buffer_cb_user_param);
+ }
+
+ return TRUE;
+}
+
return -1;
}
-gboolean util_is_miracast_connected(void)
-{
- int is_connected = 0;
-
- if (vconf_get_bool(VCONFKEY_MIRACAST_WFD_SOURCE_STATUS, &is_connected) ) {
- debug_error("failed to get miracast status key");
- return FALSE;
- }
-
- if (VCONFKEY_MIRACAST_WFD_SOURCE_ON == is_connected) {
- debug_warning("miracast connected");
- return TRUE;
- }
-
- return FALSE;
-}
-
int util_get_pixtype(unsigned int fourcc)
{
int pixtype = MM_PIXEL_FORMAT_INVALID;
case GST_MAKE_FOURCC ('N', 'V', '1', '2'):
pixtype = MM_PIXEL_FORMAT_NV12;
break;
+ case GST_MAKE_FOURCC ('S', 'T', '1', '2'):
+ pixtype = MM_PIXEL_FORMAT_NV12T;
+ break;
case GST_MAKE_FOURCC ('S', 'N', '2', '1'):
case GST_MAKE_FOURCC ('N', 'V', '2', '1'):
pixtype = MM_PIXEL_FORMAT_NV21;
projects / platform / core / multimedia / libmm-player.git / commitdiff