#include <sys/time.h>
#include <stdlib.h>
#include <dlog.h>
+#include <gio/gio.h>
#include <mm_error.h>
#include <mm_attrs.h>
+#include <mm_sound.h>
#include "mm_player_priv.h"
#include "mm_player_ini.h"
-#include "mm_player_attrs.h"
#include "mm_player_capture.h"
#include "mm_player_utils.h"
#include "mm_player_tracks.h"
#define MM_PLAYER_FADEOUT_TIME_DEFAULT 0
#define DEFAULT_PLAYBACK_RATE 1.0
-#define DEFAULT_NUM_OF_V_OUT_BUFFER 3
-
-#define MMPLAYER_USE_FILE_FOR_BUFFERING(player) \
- (((player)->profile.uri_type != MM_PLAYER_URI_TYPE_HLS) && \
- (player->ini.http_use_file_buffer) && \
- (player->http_file_buffering_path) && \
- (strlen(player->http_file_buffering_path) > 0))
#define PLAYER_DISPLAY_MODE_DST_ROI 5
#define ADAPTIVE_VARIANT_DEFAULT_VALUE -1 /* auto */
-/* For PD mode */
-#define PLAYER_PD_EXT_MAX_SIZE_BYTE 1024 * 1024 * 3
-#define PLAYER_PD_STATE_CHANGE_TIME 20 /* sec */
-
#define PLAYER_SPHERICAL_DEFAULT_YAW 0 /* sync from video360 plugin */
#define PLAYER_SPHERICAL_DEFAULT_PITCH 0
#define PLAYER_SPHERICAL_DEFAULT_H_FOV 120
#define FAKE_SINK_MAX_LATENESS G_GINT64_CONSTANT(20000000) /* set 20ms as waylandsink */
+#define DEFAULT_PCM_OUT_FORMAT "F32LE"
+#define DEFAULT_PCM_OUT_SAMPLERATE 44100
+#define DEFAULT_PCM_OUT_CHANNEL 2
+
/*---------------------------------------------------------------------------
| LOCAL CONSTANT DEFINITIONS: |
---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------
| LOCAL DATA TYPE DEFINITIONS: |
---------------------------------------------------------------------------*/
+/* NOTE : GstAutoplugSelectResult is defined in gstplay-enum.h but not exposed
+ We are defining our own and will be removed when it actually exposed */
+typedef enum {
+ GST_AUTOPLUG_SELECT_TRY,
+ GST_AUTOPLUG_SELECT_EXPOSE,
+ GST_AUTOPLUG_SELECT_SKIP
+} GstAutoplugSelectResult;
/*---------------------------------------------------------------------------
| GLOBAL VARIABLE DEFINITIONS: |
/*---------------------------------------------------------------------------
| LOCAL FUNCTION PROTOTYPES: |
---------------------------------------------------------------------------*/
-static int __mmplayer_gst_create_pipeline(mm_player_t* player);
-static int __mmplayer_gst_destroy_pipeline(mm_player_t* player);
-static int __mmplayer_gst_create_text_pipeline(mm_player_t* player);
-static int __mmplayer_gst_create_video_sink_bin(mm_player_t* player, GstCaps *caps, MMDisplaySurfaceType surface_type);
-static int __mmplayer_gst_create_audio_sink_bin(mm_player_t* player);
-static int __mmplayer_gst_create_text_sink_bin(mm_player_t* player);
-
-static GstPadProbeReturn __mmplayer_gst_selector_blocked(GstPad* pad, GstPadProbeInfo *info, gpointer data);
-static void __mmplayer_gst_decode_no_more_pads(GstElement* elem, gpointer data);
-static void __mmplayer_gst_create_sinkbin(GstElement *decodebin, GstPad *pad, gpointer data);
-static void __mmplayer_gst_decode_unknown_type(GstElement *elem, GstPad* pad, GstCaps *caps, gpointer data);
-static gboolean __mmplayer_gst_decode_autoplug_continue(GstElement *bin, GstPad* pad, GstCaps * caps, gpointer data);
-static void __mmplayer_gst_decode_pad_removed(GstElement *elem, GstPad* new_pad, gpointer data);
-static void __mmplayer_gst_decode_drained(GstElement *bin, gpointer data);
-static void __mmplayer_pipeline_complete(GstElement *decodebin, gpointer data);
-static gboolean __mmplayer_is_midi_type(gchar* str_caps);
+static int __mmplayer_gst_create_pipeline(mmplayer_t *player);
+static int __mmplayer_gst_destroy_pipeline(mmplayer_t *player);
+static int __mmplayer_gst_create_text_pipeline(mmplayer_t *player);
+static int __mmplayer_gst_create_video_sink_bin(mmplayer_t *player, GstCaps *caps, MMDisplaySurfaceType surface_type);
+static int __mmplayer_gst_create_audio_sink_bin(mmplayer_t *player);
+static int __mmplayer_gst_create_text_sink_bin(mmplayer_t *player);
+static void __mmplayer_gst_create_sink_bin(GstElement *decodebin, GstPad *pad, GstCaps *ref_caps, gpointer data);
+static gboolean __mmplayer_create_sink_path(mmplayer_t *player, GstElement *combiner, mmplayer_track_type_e type, GstCaps *caps);
+static gboolean __mmplayer_is_midi_type(gchar *str_caps);
static gboolean __mmplayer_is_only_mp3_type(gchar *str_caps);
-static void __mmplayer_set_audio_attrs(mm_player_t* player, GstCaps* caps);
-
-static gboolean __mmplayer_update_subtitle(GstElement* object, GstBuffer *buffer, GstPad *pad, gpointer data);
-static void __mmplayer_release_misc(mm_player_t* player);
-static void __mmplayer_release_misc_post(mm_player_t* player);
-static gboolean __mmplayer_init_gstreamer(mm_player_t* player);
-static void __mmplayer_video_stream_decoded_preroll_cb(GstElement* object, GstBuffer *buffer, GstPad *pad, gpointer data);
-static void __mmplayer_video_stream_decoded_render_cb(GstElement* object, GstBuffer *buffer, GstPad *pad, gpointer data);
+
+static gboolean __mmplayer_update_subtitle(GstElement *object, GstBuffer *buffer, GstPad *pad, gpointer data);
+static void __mmplayer_release_misc(mmplayer_t *player);
+static void __mmplayer_release_misc_post(mmplayer_t *player);
+static gboolean __mmplayer_init_gstreamer(mmplayer_t *player);
+static void __mmplayer_video_stream_decoded_preroll_cb(GstElement *object, GstBuffer *buffer, GstPad *pad, gpointer data);
+static void __mmplayer_video_stream_decoded_render_cb(GstElement *object, GstBuffer *buffer, GstPad *pad, gpointer data);
static GstPadProbeReturn __mmplayer_subtitle_adjust_position_probe(GstPad *pad, GstPadProbeInfo *info, gpointer u_data);
-static int __mmplayer_change_selector_pad(mm_player_t* player, MMPlayerTrackType type, int index);
-
-static gboolean __mmplayer_check_subtitle(mm_player_t* player);
-static int __mmplayer_handle_missed_plugin(mm_player_t* player);
-static int __mmplayer_check_not_supported_codec(mm_player_t* player, const gchar* factory_class, const gchar* mime);
-static void __mmplayer_add_sink(mm_player_t* player, GstElement* sink);
-static void __mmplayer_del_sink(mm_player_t* player, GstElement* sink);
-static void __mmplayer_release_signal_connection(mm_player_t* player, MMPlayerSignalType type);
+static int __mmplayer_change_selector_pad(mmplayer_t *player, mmplayer_track_type_e type, int index);
+
+static gboolean __mmplayer_check_subtitle(mmplayer_t *player);
+static int __mmplayer_handle_missed_plugin(mmplayer_t *player);
+static int __mmplayer_check_not_supported_codec(mmplayer_t *player, const gchar *factory_class, const gchar *mime);
+static void __mmplayer_add_sink(mmplayer_t *player, GstElement *sink);
+static void __mmplayer_del_sink(mmplayer_t *player, GstElement *sink);
+static void __mmplayer_release_signal_connection(mmplayer_t *player, mmplayer_signal_type_e type);
static gpointer __mmplayer_gapless_play_thread(gpointer data);
-static gboolean __mmplayer_add_dump_buffer_probe(mm_player_t *player, GstElement *element);
+static gboolean __mmplayer_add_dump_buffer_probe(mmplayer_t *player, GstElement *element);
static GstPadProbeReturn __mmplayer_dump_buffer_probe_cb(GstPad *pad, GstPadProbeInfo *info, gpointer u_data);
static void __mmplayer_release_dump_list(GList *dump_list);
-static int __mmplayer_gst_realize(mm_player_t* player);
-static int __mmplayer_gst_unrealize(mm_player_t* player);
-static int __mmplayer_gst_adjust_subtitle_position(mm_player_t* player, int format, int position);
-static int __mmplayer_gst_set_message_callback(mm_player_t* player, MMMessageCallback callback, gpointer user_param);
+static int __mmplayer_gst_realize(mmplayer_t *player);
+static int __mmplayer_gst_unrealize(mmplayer_t *player);
+static int __mmplayer_gst_adjust_subtitle_position(mmplayer_t *player, int position);
+static int __mmplayer_gst_set_message_callback(mmplayer_t *player, MMMessageCallback callback, gpointer user_param);
/* util */
-static int __mmplayer_realize_streaming_ext(mm_player_t* player);
-static int __mmplayer_unrealize_streaming_ext(mm_player_t *player);
-static int __mmplayer_start_streaming_ext(mm_player_t *player);
-static int __mmplayer_destroy_streaming_ext(mm_player_t* player);
-static gboolean __mmplayer_verify_gapless_play_path(mm_player_t *player);
-static void __mmplayer_activate_next_source(mm_player_t *player, GstState target);
-static void __mmplayer_check_pipeline(mm_player_t* player);
-static gboolean __mmplayer_deactivate_selector(mm_player_t *player, MMPlayerTrackType type);
-static void __mmplayer_deactivate_old_path(mm_player_t *player);
-static int __mmplayer_gst_create_plain_text_elements(mm_player_t* player);
-static guint32 _mmplayer_convert_fourcc_string_to_value(const gchar* format_name);
-static void __mmplayer_gst_caps_notify_cb(GstPad * pad, GParamSpec * unused, gpointer data);
-static void __mmplayer_audio_stream_send_data(mm_player_t* player, mm_player_audio_stream_buff_t *a_buffer);
-static void __mmplayer_initialize_storage_info(mm_player_t* player, MMPlayerPathType path_type);
-static int __resource_release_cb(mm_resource_manager_h rm, mm_resource_manager_res_h res, void *user_data);
-static gboolean __mmplayer_update_duration_attrs(mm_player_t *player, MMHandleType attrs);
-static gboolean __mmplayer_update_audio_attrs(mm_player_t *player, MMHandleType attrs);
-static gboolean __mmplayer_update_video_attrs(mm_player_t *player, MMHandleType attrs);
-static gboolean __mmplayer_update_bitrate_attrs(mm_player_t *player, MMHandleType attrs);
-
-static void __mmplayer_copy_uri_and_set_type(MMPlayerParseProfile* data, const char *uri, int uri_type);
-static int __mmplayer_set_mem_uri(MMPlayerParseProfile* data, char *path, void *param);
-static int __mmplayer_set_file_uri(MMPlayerParseProfile* data, const char *uri);
-
-static MMPlayerVideoStreamDataType* __mmplayer_create_stream_from_pad(GstPad *pad);
-static void __mmplayer_zerocopy_set_stride_elevation_bo(MMPlayerVideoStreamDataType *stream, GstMemory *mem);
-static gboolean __mmplayer_swcodec_set_stride_elevation(MMPlayerVideoStreamDataType *stream);
-static gboolean __mmplayer_swcodec_set_bo(mm_player_t *player, MMPlayerVideoStreamDataType *stream, GstMemory *mem);
-
-static void __mmplayer_set_pause_state(mm_player_t *player);
-static void __mmplayer_set_playing_state(mm_player_t *player);
+static gboolean __mmplayer_verify_gapless_play_path(mmplayer_t *player);
+static void __mmplayer_check_pipeline_reconfigure_state(mmplayer_t *player);
+static gboolean __mmplayer_deactivate_selector(mmplayer_t *player, mmplayer_track_type_e type);
+static gboolean __mmplayer_deactivate_combiner(mmplayer_t *player, mmplayer_track_type_e type);
+static void __mmplayer_deactivate_old_path(mmplayer_t *player);
+static int __mmplayer_gst_create_plain_text_elements(mmplayer_t *player);
+static guint32 _mmplayer_convert_fourcc_string_to_value(const gchar *format_name);
+static void __mmplayer_gst_caps_notify_cb(GstPad *pad, GParamSpec *unused, gpointer data);
+static void __mmplayer_audio_stream_send_data(mmplayer_t *player, mmplayer_audio_stream_buff_t *a_buffer);
+static void __mmplayer_initialize_storage_info(mmplayer_t *player, mmplayer_path_type_e path_type);
+static gboolean __mmplayer_update_duration_value(mmplayer_t *player);
+static gboolean __mmplayer_update_audio_attrs(mmplayer_t *player, MMHandleType attrs);
+static gboolean __mmplayer_update_video_attrs(mmplayer_t *player, MMHandleType attrs);
+static gboolean __mmplayer_update_bitrate_attrs(mmplayer_t *player, MMHandleType attrs);
+
+static void __mmplayer_copy_uri_and_set_type(mmplayer_parse_profile_t *data, const char *uri, int uri_type);
+static int __mmplayer_set_mem_uri(mmplayer_parse_profile_t *data, char *path, void *param);
+static int __mmplayer_set_file_uri(mmplayer_parse_profile_t *data, const char *uri);
+
+static mmplayer_video_decoded_data_info_t *__mmplayer_create_stream_from_pad(GstPad *pad);
+static void __mmplayer_zerocopy_set_stride_elevation_bo(mmplayer_video_decoded_data_info_t *stream, GstMemory *mem);
+static gboolean __mmplayer_swcodec_set_stride_elevation(mmplayer_video_decoded_data_info_t *stream);
+static gboolean __mmplayer_swcodec_set_bo(mmplayer_t *player, mmplayer_video_decoded_data_info_t *stream, GstMemory *mem);
+
+static void __mmplayer_set_pause_state(mmplayer_t *player);
+static void __mmplayer_set_playing_state(mmplayer_t *player);
/*===========================================================================================
| |
| FUNCTION DEFINITIONS |
| |
========================================================================================== */
-#if 0 //debug
-static void
-print_tag(const GstTagList * list, const gchar * tag, gpointer unused)
-{
- gint i, count;
-
- count = gst_tag_list_get_tag_size(list, tag);
-
- LOGD("count = %d", count);
-
- for (i = 0; i < count; i++) {
- gchar *str;
-
- if (gst_tag_get_type(tag) == G_TYPE_STRING) {
- if (!gst_tag_list_get_string_index(list, tag, i, &str))
- g_assert_not_reached();
- } else
- str = g_strdup_value_contents(gst_tag_list_get_value_index(list, tag, i));
-
- if (i == 0)
- g_print(" %15s: %s\n", gst_tag_get_nick(tag), str);
- else
- g_print(" : %s\n", str);
-
- g_free(str);
- }
-}
-#endif
-
/* This function should be called after the pipeline goes PAUSED or higher
state. */
gboolean
-__mmplayer_update_content_attrs(mm_player_t* player, enum content_attr_flag flag)
+_mmplayer_update_content_attrs(mmplayer_t *player, enum content_attr_flag flag)
{
static gboolean has_duration = FALSE;
static gboolean has_video_attrs = FALSE;
}
if ((flag & ATTR_DURATION) || (!has_duration && missing_only) || all)
- has_duration = __mmplayer_update_duration_attrs(player, attrs);
+ has_duration = __mmplayer_update_duration_value(player);
if ((flag & ATTR_AUDIO) || (!has_audio_attrs && missing_only) || all)
has_audio_attrs = __mmplayer_update_audio_attrs(player, attrs);
if ((flag & ATTR_BITRATE) || (!has_bitrate && missing_only) || all)
has_bitrate = __mmplayer_update_bitrate_attrs(player, attrs);
- /* validate all */
- if (mm_attrs_commit_all(attrs)) {
- LOGE("failed to update attributes\n");
- return FALSE;
- }
-
MMPLAYER_FLEAVE();
return TRUE;
}
-MMStreamingType __mmplayer_get_stream_service_type(mm_player_t* player)
+MMStreamingType
+_mmplayer_get_stream_service_type(mmplayer_t *player)
{
MMStreamingType streaming_type = STREAMING_SERVICE_NONE;
return streaming_type;
}
-
/* this function sets the player state and also report
* it to applicaton by calling callback function
*/
void
-__mmplayer_set_state(mm_player_t *player, int state)
+_mmplayer_set_state(mmplayer_t *player, int state)
{
MMMessageParamType msg = {0, };
MMPLAYER_RETURN_IF_FAIL(player);
if (MMPLAYER_CURRENT_STATE(player) == state) {
- LOGW("already same state(%s)\n", MMPLAYER_STATE_GET_NAME(state));
+ LOGW("already same state(%s)", MMPLAYER_STATE_GET_NAME(state));
MMPLAYER_PENDING_STATE(player) = MM_PLAYER_STATE_NONE;
return;
}
break;
case MM_PLAYER_STATE_NONE:
default:
- LOGW("invalid target state, there is nothing to do.\n");
+ LOGW("invalid target state, there is nothing to do.");
break;
}
LOGD("player reach the target state (%s)", MMPLAYER_STATE_GET_NAME(MMPLAYER_TARGET_STATE(player)));
/* state changed by resource callback */
- if (player->interrupted_by_resource) {
+ if (player->interrupted_by_resource)
MMPLAYER_POST_MSG(player, MM_MESSAGE_STATE_INTERRUPTED, &msg);
- } else { /* state changed by usecase */
+ else /* state changed by usecase */
MMPLAYER_POST_MSG(player, MM_MESSAGE_STATE_CHANGED, &msg);
- }
+
} else {
- LOGD("intermediate state, do nothing.\n");
+ LOGD("intermediate state, do nothing.");
MMPLAYER_PRINT_STATE(player);
return;
}
}
int
-__mmplayer_check_state(mm_player_t* player, enum PlayerCommandState command)
+_mmplayer_check_state(mmplayer_t *player, mmplayer_command_state_e command)
{
- MMPlayerStateType current_state = MM_PLAYER_STATE_NUM;
- MMPlayerStateType pending_state = MM_PLAYER_STATE_NUM;
+ mmplayer_state_e current_state = MM_PLAYER_STATE_NUM;
+ mmplayer_state_e pending_state = MM_PLAYER_STATE_NUM;
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
-
- //LOGD("incomming command : %d \n", command);
-
+#ifdef __DEBUG__
+ LOGD("incomming command : %d ", command);
+#endif
current_state = MMPLAYER_CURRENT_STATE(player);
pending_state = MMPLAYER_PENDING_STATE(player);
goto ALREADY_GOING;
} else if (pending_state == MM_PLAYER_STATE_PAUSED) {
LOGD("player is going to paused state, just change the pending state as playing");
- } else
+ } else {
goto INVALID_STATE;
+ }
}
break;
goto ALREADY_GOING;
} else if (pending_state == MM_PLAYER_STATE_PAUSED) {
LOGD("player is going to paused state, just change the pending state as playing");
- } else
+ } else {
goto INVALID_STATE;
+ }
}
break;
return MM_ERROR_PLAYER_NO_OP;
}
-static gpointer __mmplayer_gapless_play_thread(gpointer data)
+int _mmplayer_acquire_hw_resource(mmplayer_t *player, mmplayer_resource_type_e type)
+{
+ int rm_ret = MM_RESOURCE_MANAGER_ERROR_NONE;
+ mm_resource_manager_res_type_e rm_res_type = MM_RESOURCE_MANAGER_RES_TYPE_MAX;
+
+ switch (type) {
+ case MMPLAYER_RESOURCE_TYPE_VIDEO_DECODER:
+ rm_res_type = MM_RESOURCE_MANAGER_RES_TYPE_VIDEO_DECODER;
+ break;
+ case MMPLAYER_RESOURCE_TYPE_VIDEO_OVERLAY:
+ rm_res_type = MM_RESOURCE_MANAGER_RES_TYPE_VIDEO_OVERLAY;
+ break;
+ case MMPLAYER_RESOURCE_TYPE_AUDIO_OFFLOAD:
+ rm_res_type = MM_RESOURCE_MANAGER_RES_TYPE_AUDIO_OFFLOAD;
+ break;
+ default:
+ LOGE("invalid mmplayer resource type %d", type);
+ return MM_ERROR_PLAYER_INTERNAL;
+ }
+
+ if (player->hw_resource[type] != NULL) {
+ LOGD("[%d type] resource was already acquired", type);
+ return MM_ERROR_NONE;
+ }
+
+ LOGD("mark for acquire [%d type] resource", type);
+ rm_ret = mm_resource_manager_mark_for_acquire(player->resource_manager,
+ rm_res_type, MM_RESOURCE_MANAGER_RES_VOLUME_FULL, &player->hw_resource[type]);
+ if (rm_ret != MM_RESOURCE_MANAGER_ERROR_NONE) {
+ LOGE("failed to mark resource for acquire, ret(0x%x)", rm_ret);
+ return MM_ERROR_PLAYER_INTERNAL;
+ }
+
+ rm_ret = mm_resource_manager_commit(player->resource_manager);
+ if (rm_ret != MM_RESOURCE_MANAGER_ERROR_NONE) {
+ LOGE("failed to commit of resource, ret(0x%x)", rm_ret);
+ return MM_ERROR_PLAYER_INTERNAL;
+ }
+
+ MMPLAYER_FLEAVE();
+ return MM_ERROR_NONE;
+}
+
+static int __mmplayer_release_hw_resource(mmplayer_t *player, mmplayer_resource_type_e type)
+{
+ int rm_ret = MM_RESOURCE_MANAGER_ERROR_NONE;
+
+ MMPLAYER_FENTER();
+
+ if (player->hw_resource[type] == NULL) {
+ LOGD("there is no acquired [%d type] resource", type);
+ return MM_ERROR_NONE;
+ }
+
+ LOGD("mark for release [%d type] resource", type);
+ rm_ret = mm_resource_manager_mark_for_release(player->resource_manager, player->hw_resource[type]);
+ if (rm_ret != MM_RESOURCE_MANAGER_ERROR_NONE) {
+ LOGE("failed to mark resource for release, ret(0x%x)", rm_ret);
+ return MM_ERROR_PLAYER_INTERNAL;
+ }
+
+ player->hw_resource[type] = NULL;
+
+ rm_ret = mm_resource_manager_commit(player->resource_manager);
+ if (rm_ret != MM_RESOURCE_MANAGER_ERROR_NONE) {
+ LOGE("failed to commit of resource, ret(0x%x)", rm_ret);
+ return MM_ERROR_PLAYER_INTERNAL;
+ }
+
+ MMPLAYER_FLEAVE();
+ return MM_ERROR_NONE;
+}
+
+static void
+__mmplayer_initialize_gapless_play(mmplayer_t *player)
+{
+ int i;
+
+ MMPLAYER_FENTER();
+
+ player->smooth_streaming = FALSE;
+ player->videodec_linked = 0;
+ player->audiodec_linked = 0;
+ player->textsink_linked = 0;
+ player->is_external_subtitle_present = FALSE;
+ player->is_external_subtitle_added_now = FALSE;
+ player->not_supported_codec = MISSING_PLUGIN_NONE;
+ player->can_support_codec = FOUND_PLUGIN_NONE;
+ player->pending_seek.is_pending = false;
+ player->pending_seek.pos = 0;
+ player->msg_posted = FALSE;
+ player->has_many_types = FALSE;
+ player->no_more_pad = FALSE;
+ player->not_found_demuxer = 0;
+ player->seek_state = MMPLAYER_SEEK_NONE;
+ player->is_subtitle_force_drop = FALSE;
+ player->play_subtitle = FALSE;
+ player->adjust_subtitle_pos = 0;
+
+ player->total_bitrate = 0;
+ player->total_maximum_bitrate = 0;
+
+ _mmplayer_track_initialize(player);
+ __mmplayer_initialize_storage_info(player, MMPLAYER_PATH_MAX);
+
+ for (i = 0; i < MM_PLAYER_STREAM_COUNT_MAX; i++) {
+ player->bitrate[i] = 0;
+ player->maximum_bitrate[i] = 0;
+ }
+
+ if (player->v_stream_caps) {
+ gst_caps_unref(player->v_stream_caps);
+ player->v_stream_caps = NULL;
+ }
+
+ mm_player_set_attribute((MMHandleType)player, NULL, "content_video_found", 0, NULL);
+
+ /* clean found audio decoders */
+ if (player->audio_decoders) {
+ g_list_free_full(player->audio_decoders, (GDestroyNotify)g_free);
+ player->audio_decoders = NULL;
+ }
+
+ __mmplayer_release_hw_resource(player, MMPLAYER_RESOURCE_TYPE_VIDEO_DECODER);
+
+ MMPLAYER_FLEAVE();
+}
+
+void _mmplayer_set_reconfigure_state(mmplayer_t *player, gboolean state)
{
- mm_player_t* player = (mm_player_t*) data;
- MMPlayerGstElement *mainbin = NULL;
+ LOGI("set pipeline reconfigure state %d", state);
+ MMPLAYER_RECONFIGURE_LOCK(player);
+ player->gapless.reconfigure = state;
+ if (!state) /* wake up the waiting job */
+ MMPLAYER_RECONFIGURE_SIGNAL(player);
+ MMPLAYER_RECONFIGURE_UNLOCK(player);
+}
+
+static gpointer
+__mmplayer_gapless_play_thread(gpointer data)
+{
+ mmplayer_t *player = (mmplayer_t *)data;
+ mmplayer_gst_element_t *mainbin = NULL;
MMPLAYER_RETURN_VAL_IF_FAIL(player, NULL);
MMPLAYER_GAPLESS_PLAY_THREAD_LOCK(player);
while (!player->gapless_play_thread_exit) {
- LOGD("gapless play thread started. waiting for signal.\n");
+ LOGD("gapless play thread started. waiting for signal.");
MMPLAYER_GAPLESS_PLAY_THREAD_WAIT(player);
- LOGD("reconfigure pipeline for gapless play.\n");
+ LOGD("reconfigure pipeline for gapless play.");
if (player->gapless_play_thread_exit) {
- if (player->gapless.reconfigure) {
- player->gapless.reconfigure = false;
- MMPLAYER_PLAYBACK_UNLOCK(player);
- }
- LOGD("exiting gapless play thread\n");
+ _mmplayer_set_reconfigure_state(player, FALSE);
+ LOGD("exiting gapless play thread");
break;
}
MMPLAYER_RELEASE_ELEMENT(player, mainbin, MMPLAYER_M_TYPEFIND);
MMPLAYER_RELEASE_ELEMENT(player, mainbin, MMPLAYER_M_SRC);
- __mmplayer_activate_next_source(player, GST_STATE_PLAYING);
+ /* Initialize Player values */
+ __mmplayer_initialize_gapless_play(player);
+
+ _mmplayer_activate_next_source(player, GST_STATE_PLAYING);
}
MMPLAYER_GAPLESS_PLAY_THREAD_UNLOCK(player);
MMPLAYER_FENTER();
source = g_main_context_find_source_by_id(context, source_id);
-
if (source != NULL) {
LOGW("context: %p, source id: %d, source: %p", context, source_id, source);
g_source_destroy(source);
MMPLAYER_FLEAVE();
}
-void __mmplayer_bus_msg_thread_destroy(MMHandleType hplayer)
+void
+_mmplayer_watcher_removed_notify(gpointer data)
{
- mm_player_t* player = (mm_player_t*)hplayer;
- GstMessage *msg = NULL;
- GQueue *queue = NULL;
+ mmplayer_t *player = (mmplayer_t *)data;
+ MMPLAYER_RETURN_IF_FAIL(player);
+
+ MMPLAYER_BUS_WATCHER_LOCK(player);
+ player->bus_watcher = 0;
+ MMPLAYER_BUS_WATCHER_SIGNAL(player);
+ MMPLAYER_BUS_WATCHER_UNLOCK(player);
+}
+void
+_mmplayer_bus_watcher_remove(MMHandleType hplayer)
+{
+ mmplayer_t *player = (mmplayer_t *)hplayer;
+ gint64 end_time = 0;
MMPLAYER_FENTER();
MMPLAYER_RETURN_IF_FAIL(player);
/* disconnecting bus watch */
- if (player->bus_watcher)
+ if (player->bus_watcher > 0) {
__mmplayer_remove_g_source_from_context(player->context.thread_default, player->bus_watcher);
- player->bus_watcher = 0;
+ MMPLAYER_BUS_WATCHER_LOCK(player);
+ end_time = g_get_monotonic_time () + 2 * G_TIME_SPAN_SECOND;
+ while (player->bus_watcher > 0)
+ MMPLAYER_BUS_WATCHER_WAIT_UNTIL(player, end_time);
+ MMPLAYER_BUS_WATCHER_UNLOCK(player);
+
+ g_mutex_clear(&player->bus_watcher_mutex);
+ g_cond_clear(&player->bus_watcher_cond);
+ }
+
+ MMPLAYER_FLEAVE();
+}
+
+void
+_mmplayer_bus_msg_thread_destroy(MMHandleType hplayer)
+{
+ mmplayer_t *player = (mmplayer_t *)hplayer;
+ GstMessage *msg = NULL;
+ GQueue *queue = NULL;
+
+ MMPLAYER_FENTER();
+ MMPLAYER_RETURN_IF_FAIL(player);
/* destroy the gst bus msg thread */
if (player->bus_msg_thread) {
}
gboolean
-__mmplayer_gst_remove_fakesink(mm_player_t* player, MMPlayerGstElement* fakesink)
+_mmplayer_gst_remove_fakesink(mmplayer_t *player, mmplayer_gst_element_t *fakesink)
{
- GstElement* parent = NULL;
+ GstElement *parent = NULL;
MMPLAYER_RETURN_VAL_IF_FAIL(player && player->pipeline, FALSE);
-
- /* if we have no fakesink. this meas we are using decodebin which doesn'
- t need to add extra fakesink */
- MMPLAYER_RETURN_VAL_IF_FAIL(fakesink, TRUE);
+ MMPLAYER_RETURN_VAL_IF_FAIL(fakesink && fakesink->gst, TRUE);
/* lock */
MMPLAYER_FSINK_LOCK(player);
- if (!fakesink->gst)
- goto ERROR;
-
/* get parent of fakesink */
- parent = (GstElement*)gst_object_get_parent((GstObject*)fakesink->gst);
+ parent = (GstElement *)gst_object_get_parent((GstObject *)fakesink->gst);
if (!parent) {
- LOGD("fakesink already removed\n");
+ LOGD("fakesink already removed");
goto ERROR;
}
* so no need to wait for completion of state transiton
*/
if (GST_STATE_CHANGE_FAILURE == gst_element_set_state(fakesink->gst, GST_STATE_NULL))
- LOGE("fakesink state change failure!\n");
+ LOGE("fakesink state change failure!");
/* FIXIT : should I return here? or try to proceed to next? */
/* return FALSE; */
/* remove fakesink from it's parent */
if (!gst_bin_remove(GST_BIN(parent), fakesink->gst)) {
- LOGE("failed to remove fakesink\n");
+ LOGE("failed to remove fakesink");
gst_object_unref(parent);
gst_object_unref(parent);
- LOGD("state-holder removed\n");
+ LOGD("state-holder removed");
gst_element_set_locked_state(fakesink->gst, FALSE);
}
static GstPadProbeReturn
-__mmplayer_gst_selector_blocked(GstPad* pad, GstPadProbeInfo *info, gpointer data)
+__mmplayer_gst_selector_blocked(GstPad *pad, GstPadProbeInfo *info, gpointer data)
{
LOGD("pad(%s:%s) is blocked", GST_DEBUG_PAD_NAME(pad));
return GST_PAD_PROBE_OK;
}
static void
-__mmplayer_gst_selector_update_start_time(mm_player_t* player, MMPlayerTrackType stream_type)
+__mmplayer_gst_selector_update_start_time(mmplayer_t *player, mmplayer_track_type_e stream_type)
{
gint64 stop_running_time = 0;
gint64 position_running_time = 0;
for (idx = MM_PLAYER_TRACK_TYPE_AUDIO; idx < MM_PLAYER_TRACK_TYPE_TEXT; idx++) {
if ((player->gapless.update_segment[idx] == TRUE) ||
- !(player->selector[idx].event_probe_id)) {
- /* LOGW("[%d] skip", idx); */
+ !(player->track[idx].event_probe_id)) {
+#ifdef __DEBUG__
+ LOGW("[%d] skip", idx);
+#endif
continue;
}
{
GstPadProbeReturn ret = GST_PAD_PROBE_OK;
GstEvent *event = GST_PAD_PROBE_INFO_DATA(info);
- mm_player_t *player = (mm_player_t*)data;
+ mmplayer_t *player = (mmplayer_t *)data;
GstCaps *caps = NULL;
GstStructure *str = NULL;
const gchar *name = NULL;
- MMPlayerTrackType stream_type = MM_PLAYER_TRACK_TYPE_VIDEO;
+ mmplayer_track_type_e stream_type = MM_PLAYER_TRACK_TYPE_VIDEO;
gboolean caps_ret = TRUE;
- if (GST_EVENT_IS_DOWNSTREAM(event) &&
- GST_EVENT_TYPE(event) != GST_EVENT_STREAM_START &&
- GST_EVENT_TYPE(event) != GST_EVENT_FLUSH_STOP &&
- GST_EVENT_TYPE(event) != GST_EVENT_SEGMENT &&
- GST_EVENT_TYPE(event) != GST_EVENT_EOS) {
- return ret;
- } else if (GST_EVENT_IS_UPSTREAM(event) &&
- GST_EVENT_TYPE(event) != GST_EVENT_QOS) {
+ if (GST_EVENT_TYPE(event) != GST_EVENT_STREAM_START &&
+ GST_EVENT_TYPE(event) != GST_EVENT_FLUSH_STOP &&
+ GST_EVENT_TYPE(event) != GST_EVENT_SEGMENT &&
+ GST_EVENT_TYPE(event) != GST_EVENT_EOS &&
+ GST_EVENT_TYPE(event) != GST_EVENT_QOS)
return ret;
- }
- MMPLAYER_GST_GET_CAPS_INFO(pad, caps, str, name, caps_ret);
+ MMPLAYER_GST_GET_CAPS_INFO_FROM_PAD(pad, caps, str, name, caps_ret);
if (!caps_ret)
goto ERROR;
break;
}
+#ifdef __DEBUG__
LOGD("[%d] Adjusting QOS event: %" GST_TIME_FORMAT
" - %" GST_TIME_FORMAT " = %" GST_TIME_FORMAT,
stream_type, GST_TIME_ARGS(timestamp),
GST_TIME_ARGS(running_time_diff),
GST_TIME_ARGS(timestamp - running_time_diff));
+#endif
timestamp -= running_time_diff;
/* create fakesink for audio or video path witout audiobin or videobin */
static void
-__mmplayer_gst_make_fakesink(mm_player_t *player, GstPad *pad, const gchar *name)
+__mmplayer_gst_make_fakesink(mmplayer_t *player, GstPad *pad, const gchar *name)
{
GstElement *pipeline = NULL;
GstElement *fakesink = NULL;
return;
}
-static GstElement*
-__mmplayer_gst_make_selector(mm_player_t *player, enum MainElementID elem_idx, MMPlayerTrackType stream_type)
+static GstElement *
+__mmplayer_gst_make_concat(mmplayer_t *player, main_element_id_e elem_idx)
+{
+ GstElement *pipeline = NULL;
+ GstElement *concat = NULL;
+
+ MMPLAYER_FENTER();
+ MMPLAYER_RETURN_VAL_IF_FAIL(player && player->pipeline && player->pipeline->mainbin, NULL);
+
+ concat = gst_element_factory_make("concat", NULL);
+ if (!concat) {
+ LOGE("failed to create concat");
+ return NULL;
+ }
+
+ LOGD("Create concat [%d] element", elem_idx);
+
+ player->pipeline->mainbin[elem_idx].id = elem_idx;
+ player->pipeline->mainbin[elem_idx].gst = concat;
+
+ gst_element_set_state(concat, GST_STATE_PAUSED);
+
+ pipeline = player->pipeline->mainbin[MMPLAYER_M_PIPE].gst;
+ gst_bin_add(GST_BIN(pipeline), concat);
+
+ MMPLAYER_FLEAVE();
+ return concat;
+}
+
+static GstElement *
+__mmplayer_gst_make_selector(mmplayer_t *player, main_element_id_e elem_idx, mmplayer_track_type_e stream_type)
{
GstElement *pipeline = NULL;
GstElement *selector = NULL;
player->pipeline->mainbin[elem_idx].id = elem_idx;
player->pipeline->mainbin[elem_idx].gst = selector;
- /* player->selector[stream_type].active_pad_index = DEFAULT_TRACK; */
+ /* player->track[stream_type].active_track_index = DEFAULT_TRACK; */
srcpad = gst_element_get_static_pad(selector, "src");
LOGD("blocking %s:%s", GST_DEBUG_PAD_NAME(srcpad));
- player->selector[stream_type].block_id = gst_pad_add_probe(srcpad, GST_PAD_PROBE_TYPE_BLOCK_DOWNSTREAM,
+ player->track[stream_type].block_id = gst_pad_add_probe(srcpad, GST_PAD_PROBE_TYPE_BLOCK_DOWNSTREAM,
__mmplayer_gst_selector_blocked, NULL, NULL);
- player->selector[stream_type].event_probe_id = gst_pad_add_probe(srcpad, GST_PAD_PROBE_TYPE_EVENT_BOTH|GST_PAD_PROBE_TYPE_EVENT_FLUSH,
+ player->track[stream_type].event_probe_id = gst_pad_add_probe(srcpad, GST_PAD_PROBE_TYPE_EVENT_BOTH|GST_PAD_PROBE_TYPE_EVENT_FLUSH,
__mmplayer_gst_selector_event_probe, player, NULL);
gst_element_set_state(selector, GST_STATE_PAUSED);
pipeline = player->pipeline->mainbin[MMPLAYER_M_PIPE].gst;
gst_bin_add(GST_BIN(pipeline), selector);
+ gst_object_unref(GST_OBJECT(srcpad));
+
MMPLAYER_FLEAVE();
return selector;
}
void
-__mmplayer_gst_decode_pad_added(GstElement *elem, GstPad *pad, gpointer data)
+_mmplayer_gst_decode_pad_added(GstElement *elem, GstPad *pad, gpointer data)
{
- mm_player_t *player = NULL;
- GstElement *selector = NULL;
+ mmplayer_t *player = (mmplayer_t *)data;
+ GstElement *combiner = NULL;
GstCaps *caps = NULL;
GstStructure *str = NULL;
const gchar *name = NULL;
GstPad *sinkpad = NULL;
- GstPad *srcpad = NULL;
gboolean first_track = FALSE;
gboolean caps_ret = TRUE;
- enum MainElementID elem_idx = MMPLAYER_M_NUM;
- MMPlayerTrackType stream_type = MM_PLAYER_TRACK_TYPE_AUDIO;
-
- /* check handles */
- player = (mm_player_t*)data;
+ main_element_id_e elem_idx = MMPLAYER_M_NUM;
+ mmplayer_track_type_e stream_type = MM_PLAYER_TRACK_TYPE_AUDIO;
MMPLAYER_FENTER();
MMPLAYER_RETURN_IF_FAIL(elem && pad);
LOGD("pad-added signal handling");
/* get mimetype from caps */
- MMPLAYER_GST_GET_CAPS_INFO(pad, caps, str, name, caps_ret);
+ MMPLAYER_GST_GET_CAPS_INFO_FROM_PAD(pad, caps, str, name, caps_ret);
if (!caps_ret)
goto ERROR;
MMPLAYER_LOG_GST_CAPS_TYPE(caps);
- /* LOGD("detected mimetype : %s", name); */
+#ifdef __DEBUG__
+ LOGD("detected mimetype : %s", name);
+#endif
if (strstr(name, "video")) {
gint stype = 0;
caps_str = gst_caps_to_string(caps);
if (caps_str && (strstr(caps_str, "ST12") || strstr(caps_str, "SN12") ||
strstr(caps_str, "SN21") || strstr(caps_str, "S420") || strstr(caps_str, "SR32")))
- player->set_mode.video_zc = TRUE;
+ player->set_mode.video_zc = true;
MMPLAYER_FREEIF(caps_str);
- mm_attrs_set_int_by_name(player->attrs, "content_video_found", TRUE);
+ mm_player_set_attribute((MMHandleType)player, NULL, "content_video_found", TRUE, NULL);
mm_attrs_get_int_by_name(player->attrs, "display_surface_type", &stype);
LOGD("surface type : %d", stype);
if (MMPLAYER_IS_MS_BUFF_SRC(player)) {
- __mmplayer_gst_create_sinkbin(elem, pad, player);
+ __mmplayer_gst_create_sink_bin(elem, pad, caps, player);
goto DONE;
}
/* in case of exporting video frame, it requires the 360 video filter.
* it will be handled in _no_more_pads(). */
- if ((stype == MM_DISPLAY_SURFACE_NULL) && (!player->set_mode.media_packet_video_stream)){
+ if ((stype == MM_DISPLAY_SURFACE_NULL) && (!player->set_mode.video_export)) {
__mmplayer_gst_make_fakesink(player, pad, name);
goto DONE;
}
- LOGD("video selector is required");
- elem_idx = MMPLAYER_M_V_INPUT_SELECTOR;
+ if (MMPLAYER_USE_DECODEBIN(player)) {
+ LOGD("video selector is required");
+ elem_idx = MMPLAYER_M_V_INPUT_SELECTOR;
+ } else {
+ LOGD("video concat is required");
+ elem_idx = MMPLAYER_M_V_CONCAT;
+ }
stream_type = MM_PLAYER_TRACK_TYPE_VIDEO;
} else if (strstr(name, "audio")) {
gint samplerate = 0;
gint channels = 0;
- gst_structure_get_int(str, "rate", &samplerate);
- gst_structure_get_int(str, "channels", &channels);
-
- if (MMPLAYER_IS_MS_BUFF_SRC(player)) {
- __mmplayer_gst_create_sinkbin(elem, pad, player);
+ if (MMPLAYER_IS_MS_BUFF_SRC(player) || player->build_audio_offload) {
+ if (player->build_audio_offload)
+ player->no_more_pad = TRUE; /* remove state holder */
+ __mmplayer_gst_create_sink_bin(elem, pad, caps, player);
goto DONE;
}
+ gst_structure_get_int(str, "rate", &samplerate);
+ gst_structure_get_int(str, "channels", &channels);
+
if ((channels > 0 && samplerate == 0)) { /* exclude audio decoding */
__mmplayer_gst_make_fakesink(player, pad, name);
goto DONE;
}
-
- LOGD("audio selector is required");
- elem_idx = MMPLAYER_M_A_INPUT_SELECTOR;
+ if (MMPLAYER_USE_DECODEBIN(player)) {
+ LOGD("audio selector is required");
+ elem_idx = MMPLAYER_M_A_INPUT_SELECTOR;
+ } else {
+ LOGD("audio concat is required");
+ elem_idx = MMPLAYER_M_A_CONCAT;
+ }
stream_type = MM_PLAYER_TRACK_TYPE_AUDIO;
} else if (strstr(name, "text")) {
- LOGD("text selector is required");
- elem_idx = MMPLAYER_M_T_INPUT_SELECTOR;
+ if (MMPLAYER_USE_DECODEBIN(player)) {
+ LOGD("text selector is required");
+ elem_idx = MMPLAYER_M_T_INPUT_SELECTOR;
+ } else {
+ LOGD("text concat is required");
+ elem_idx = MMPLAYER_M_T_CONCAT;
+ }
stream_type = MM_PLAYER_TRACK_TYPE_TEXT;
} else {
LOGE("invalid caps info");
}
/* check selector and create it */
- if (!(selector = player->pipeline->mainbin[elem_idx].gst)) {
- selector = __mmplayer_gst_make_selector(player, elem_idx, stream_type);
- if (!selector)
+ if (!(combiner = player->pipeline->mainbin[elem_idx].gst)) {
+ if (MMPLAYER_USE_DECODEBIN(player))
+ combiner = __mmplayer_gst_make_selector(player, elem_idx, stream_type);
+ else
+ combiner = __mmplayer_gst_make_concat(player, elem_idx);
+
+ if (!combiner)
goto ERROR;
first_track = TRUE;
} else {
- LOGD("input-selector is already created.");
+ LOGD("Combiner element is already created.");
}
/* link */
- sinkpad = gst_element_get_request_pad(selector, "sink_%u");
+ sinkpad = gst_element_get_request_pad(combiner, "sink_%u");
LOGD("pad link: %s:%s - %s:%s", GST_DEBUG_PAD_NAME(pad), GST_DEBUG_PAD_NAME(sinkpad));
if (gst_pad_link(pad, sinkpad) != GST_PAD_LINK_OK) {
- LOGE("failed to link selector");
- gst_object_unref(GST_OBJECT(selector));
+ LOGE("failed to link combiner");
+ gst_object_unref(GST_OBJECT(combiner));
goto ERROR;
}
if (first_track) {
- LOGD("this track will be activated");
- g_object_set(selector, "active-pad", sinkpad, NULL);
+ if (MMPLAYER_USE_DECODEBIN(player)) {
+ LOGD("this track will be activated");
+ g_object_set(combiner, "active-pad", sinkpad, NULL);
+ }
}
- __mmplayer_track_update_info(player, stream_type, sinkpad);
+ if (MMPLAYER_USE_DECODEBIN(player))
+ _mmplayer_track_update_stream(player, stream_type, sinkpad);
+ else
+ __mmplayer_create_sink_path(player, combiner, stream_type, caps);
DONE:
ERROR:
sinkpad = NULL;
}
- if (srcpad) {
- gst_object_unref(GST_OBJECT(srcpad));
- srcpad = NULL;
- }
-
return;
}
-static gboolean __mmplayer_create_sink_path(mm_player_t* player, GstElement* selector, MMPlayerTrackType type)
+static gboolean
+__mmplayer_create_sink_path(mmplayer_t *player, GstElement *combiner, mmplayer_track_type_e type, GstCaps *caps)
{
- GstPad* srcpad = NULL;
+ GstPad *srcpad = NULL;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player && player->pipeline, FALSE);
LOGD("type %d", type);
- if (!selector) {
+ if (!combiner) {
LOGD("there is no %d track", type);
return TRUE;
}
- srcpad = gst_element_get_static_pad(selector, "src");
+ srcpad = gst_element_get_static_pad(combiner, "src");
if (!srcpad) {
- LOGE("failed to get srcpad from selector");
+ LOGE("failed to get srcpad from combiner");
return FALSE;
}
- LOGD("got pad %s:%s from selector", GST_DEBUG_PAD_NAME(srcpad));
+ LOGD("got pad %s:%s from combiner", GST_DEBUG_PAD_NAME(srcpad));
- __mmplayer_gst_create_sinkbin(selector, srcpad, player);
+ __mmplayer_gst_create_sink_bin(combiner, srcpad, caps, player);
LOGD("unblocking %s:%s", GST_DEBUG_PAD_NAME(srcpad));
- if (player->selector[type].block_id) {
- gst_pad_remove_probe(srcpad, player->selector[type].block_id);
- player->selector[type].block_id = 0;
+ if (player->track[type].block_id) {
+ gst_pad_remove_probe(srcpad, player->track[type].block_id);
+ player->track[type].block_id = 0;
}
if (srcpad) {
return TRUE;
}
-static void __mmplayer_set_decode_track_info(mm_player_t* player, MMPlayerTrackType type)
+static void
+__mmplayer_set_decode_track_info(mmplayer_t *player, mmplayer_track_type_e type)
{
- MMHandleType attrs = 0;
gint active_index = 0;
- gchar *attr_name = NULL;
MMPLAYER_FENTER();
MMPLAYER_RETURN_IF_FAIL(player);
- LOGD("type %d", type);
+ LOGD("type: %d, the num of track: %d", type, player->track[type].total_track_num);
/* change track to active pad */
- active_index = player->selector[type].active_pad_index;
+ active_index = player->track[type].active_track_index;
if ((active_index != DEFAULT_TRACK) &&
(__mmplayer_change_selector_pad(player, type, active_index) != MM_ERROR_NONE)) {
LOGW("failed to change %d type track to %d", type, active_index);
- player->selector[type].active_pad_index = DEFAULT_TRACK;
- }
-
- LOGD("Total num of tracks = %d", player->selector[type].total_track_num);
-
- if (type == MM_PLAYER_TRACK_TYPE_AUDIO) {
- attr_name = "content_audio_track_num";
- } else if (type == MM_PLAYER_TRACK_TYPE_TEXT) {
- attr_name = "content_text_track_num";
- } else {
- LOGE("invalid type info %d", type);
+ player->track[type].active_track_index = DEFAULT_TRACK;
return;
}
- attrs = MMPLAYER_GET_ATTRS(player);
- if (attrs) {
- mm_attrs_set_int_by_name(attrs, attr_name, (gint)player->selector[type].total_track_num);
- if (mm_attrs_commit_all(attrs))
- LOGW("failed to commit attrs.");
- } else {
- LOGW("cannot get content attribute");
- }
+ if (type == MM_PLAYER_TRACK_TYPE_TEXT)
+ mm_player_set_attribute((MMHandleType)player, NULL,
+ "content_text_track_num", player->track[type].total_track_num,
+ "current_text_track_index", player->track[type].active_track_index, NULL);
MMPLAYER_FLEAVE();
return;
}
-static gboolean __mmplayer_create_audio_sink_path(mm_player_t* player, GstElement* audio_selector)
+static gboolean
+__mmplayer_create_audio_sink_path(mmplayer_t *player, GstElement *audio_selector)
{
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player && player->pipeline, FALSE);
if (!audio_selector) {
- LOGD("there is no audio track");
+ LOGD("there is no audio track, num_dynamic_pad %d", player->num_dynamic_pad);
/* in case the source is changed, output can be changed. */
if ((player->pipeline->audiobin) && (player->pipeline->audiobin[MMPLAYER_A_BIN].gst)) {
}
if (player->num_dynamic_pad == 0) /* FIXME: num_dynamic_pad is only for rtsp? */
- __mmplayer_pipeline_complete(NULL, player);
+ _mmplayer_pipeline_complete(NULL, player);
return TRUE;
}
/* apply the audio track information */
- __mmplayer_set_decode_track_info(player, MM_PLAYER_TRACK_TYPE_AUDIO);
+ if (MMPLAYER_USE_DECODEBIN(player))
+ __mmplayer_set_decode_track_info(player, MM_PLAYER_TRACK_TYPE_AUDIO);
/* create audio sink path */
- if (!__mmplayer_create_sink_path(player, audio_selector, MM_PLAYER_TRACK_TYPE_AUDIO)) {
+ if (!__mmplayer_create_sink_path(player, audio_selector, MM_PLAYER_TRACK_TYPE_AUDIO, NULL)) {
LOGE("failed to create audio sink path");
return FALSE;
}
return TRUE;
}
-static gboolean __mmplayer_create_text_sink_path(mm_player_t* player, GstElement* text_selector)
+static gboolean
+__mmplayer_create_text_sink_path(mmplayer_t *player, GstElement *text_selector)
{
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player && text_selector, FALSE);
/* apply the text track information */
__mmplayer_set_decode_track_info(player, MM_PLAYER_TRACK_TYPE_TEXT);
- if (player->selector[MM_PLAYER_TRACK_TYPE_TEXT].total_track_num > 0)
+ if (player->track[MM_PLAYER_TRACK_TYPE_TEXT].total_track_num > 0)
player->has_closed_caption = TRUE;
/* create text decode path */
player->no_more_pad = TRUE;
- if (!__mmplayer_create_sink_path(player, text_selector, MM_PLAYER_TRACK_TYPE_TEXT)) {
+ if (!__mmplayer_create_sink_path(player, text_selector, MM_PLAYER_TRACK_TYPE_TEXT, NULL)) {
LOGE("failed to create text sink path");
return FALSE;
}
}
static gboolean
-__mmplayer_gst_set_queue2_buffering(mm_player_t *player)
+__mmplayer_gst_set_queue2_buffering(mmplayer_t *player)
{
-#define ESTIMATED_BUFFER_UNIT (1*1024*1024)
-
- gint init_buffering_time = 0;
- guint buffer_bytes = 0;
gint64 dur_bytes = 0L;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player && player->pipeline &&
player->pipeline->mainbin && player->streamer, FALSE);
- init_buffering_time = player->streamer->buffering_req.prebuffer_time;
- buffer_bytes = (guint)(init_buffering_time/1000) * ESTIMATED_BUFFER_UNIT;
-
- buffer_bytes = MAX(buffer_bytes, player->streamer->buffer_handle[BUFFER_TYPE_MUXED].buffering_bytes);
- LOGD("pre buffer time: %d ms, buffer size : %d", init_buffering_time, buffer_bytes);
-
- init_buffering_time = (init_buffering_time != 0) ? (init_buffering_time) : (player->ini.http_buffering_time);
-
if (!gst_element_query_duration(player->pipeline->mainbin[MMPLAYER_M_SRC].gst, GST_FORMAT_BYTES, &dur_bytes))
LOGE("fail to get duration.");
/* there is no mq, enable use-buffering on queue2 (ex) wav streaming
* use file information was already set on Q2 when it was created. */
- __mm_player_streaming_set_queue2(player->streamer,
+ _mm_player_streaming_set_queue2(player->streamer,
player->pipeline->mainbin[MMPLAYER_M_MUXED_S_BUFFER].gst,
TRUE, /* use_buffering */
- buffer_bytes,
- init_buffering_time,
- 1.0, /* low percent */
- player->ini.http_buffering_limit, /* high percent */
MUXED_BUFFER_TYPE_MAX, /* use previous buffer type setting */
- NULL,
((dur_bytes > 0) ? ((guint64)dur_bytes) : 0));
MMPLAYER_FLEAVE();
return TRUE;
}
-static void
-__mmplayer_gst_decode_no_more_pads(GstElement *elem, gpointer data)
+void
+_mmplayer_gst_decode_no_more_pads(GstElement *elem, gpointer data)
{
- mm_player_t *player = NULL;
+ mmplayer_t *player = NULL;
GstElement *video_selector = NULL;
GstElement *audio_selector = NULL;
GstElement *text_selector = NULL;
MMPLAYER_FENTER();
- player = (mm_player_t*) data;
+ player = (mmplayer_t *)data;
LOGD("no-more-pad signal handling");
goto EXIT;
}
- if ((!MMPLAYER_IS_HTTP_PD(player)) &&
- (MMPLAYER_IS_HTTP_STREAMING(player)) &&
+ if ((MMPLAYER_IS_HTTP_STREAMING(player)) &&
(!player->pipeline->mainbin[MMPLAYER_M_DEMUXED_S_BUFFER].gst) &&
(player->pipeline->mainbin[MMPLAYER_M_MUXED_S_BUFFER].gst)) {
if (!__mmplayer_gst_set_queue2_buffering(player)) {
audio_selector = player->pipeline->mainbin[MMPLAYER_M_A_INPUT_SELECTOR].gst;
text_selector = player->pipeline->mainbin[MMPLAYER_M_T_INPUT_SELECTOR].gst;
+ if (!video_selector && !audio_selector && !text_selector) {
+ LOGW("there is no selector");
+ player->no_more_pad = TRUE;
+ goto EXIT;
+ }
+
/* create video path followed by video-select */
if (video_selector && !audio_selector && !text_selector)
player->no_more_pad = TRUE;
- if (!__mmplayer_create_sink_path(player, video_selector, MM_PLAYER_TRACK_TYPE_VIDEO))
+ if (!__mmplayer_create_sink_path(player, video_selector, MM_PLAYER_TRACK_TYPE_VIDEO, NULL))
goto EXIT;
/* create audio path followed by audio-select */
if (!__mmplayer_create_audio_sink_path(player, audio_selector))
goto EXIT;
-
/* create text path followed by text-select */
__mmplayer_create_text_sink_path(player, text_selector);
EXIT:
- if (player->gapless.reconfigure) {
- player->gapless.reconfigure = FALSE;
- MMPLAYER_PLAYBACK_UNLOCK(player);
- }
-
+ _mmplayer_set_reconfigure_state(player, FALSE);
MMPLAYER_FLEAVE();
}
static gboolean
-__mmplayer_gst_add_sinkbin_to_pipeline(mm_player_t *player, GstElement *sinkbin, GstPad *pad, gboolean reusing, gchar *sink_pad_name)
+__mmplayer_gst_add_sinkbin_to_pipeline(mmplayer_t *player, GstElement *sinkbin, GstPad *pad, gboolean reusing, gchar *sink_pad_name)
{
gboolean ret = FALSE;
GstElement *pipeline = NULL;
MMPLAYER_FLEAVE();
return ret;
}
+
static void
-__mmplayer_gst_create_sinkbin(GstElement *elem, GstPad *pad, gpointer data)
+__mmplayer_gst_create_sink_bin(GstElement *elem, GstPad *pad, GstCaps *ref_caps, gpointer data)
{
- mm_player_t *player = NULL;
- MMHandleType attrs = 0;
+ mmplayer_t *player = NULL;
GstCaps *caps = NULL;
gchar *caps_str = NULL;
GstStructure *str = NULL;
gchar *sink_pad_name = "sink";
/* check handles */
- player = (mm_player_t*) data;
+ player = (mmplayer_t *)data;
MMPLAYER_FENTER();
MMPLAYER_RETURN_IF_FAIL(elem && pad);
MMPLAYER_RETURN_IF_FAIL(player && player->pipeline && MMPLAYER_GET_ATTRS(player));
+ MMPLAYER_GST_GET_CAPS_INFO_FROM_PAD(pad, caps, str, name, caps_ret);
+ if (!caps_ret) {
+ MMPLAYER_GST_GET_CAPS_INFO(ref_caps, str, name, caps_ret);
+ if (!caps_ret)
+ goto ERROR;
- MMPLAYER_GST_GET_CAPS_INFO(pad, caps, str, name, caps_ret);
- if (!caps_ret)
- goto ERROR;
+ caps = gst_caps_ref(ref_caps);
+ }
caps_str = gst_caps_to_string(caps);
-
- /* LOGD("detected mimetype : %s", name); */
+#ifdef __DEBUG__
+ LOGD("detected mimetype : %s", name);
+#endif
if (strstr(name, "audio")) {
if (player->pipeline->audiobin == NULL) {
+ const gchar *audio_format = gst_structure_get_string(str, "format");
+ if (audio_format) {
+ LOGD("original audio format %s", audio_format);
+ mm_player_set_attribute((MMHandleType)player, NULL,
+ "content_audio_format", audio_format, strlen(audio_format), NULL);
+ }
+
if (__mmplayer_gst_create_audio_sink_bin(player) != MM_ERROR_NONE) {
LOGE("failed to create audiobin. continuing without audio");
goto ERROR;
reusing = TRUE;
sinkbin = player->pipeline->audiobin[MMPLAYER_A_BIN].gst;
LOGD("reusing audiobin");
- __mmplayer_update_content_attrs(player, ATTR_AUDIO);
+ _mmplayer_update_content_attrs(player, ATTR_AUDIO);
}
} else if (strstr(name, "video")) {
/* 1. zero copy is updated at _decode_pad_added()
mm_attrs_get_int_by_name(player->attrs, "display_surface_type", &surface_type);
LOGD("display_surface_type (%d)", surface_type);
- if (surface_type == MM_DISPLAY_SURFACE_OVERLAY && player->video_overlay_resource == NULL) {
- LOGD("mark video overlay for acquire");
- if (mm_resource_manager_mark_for_acquire(player->resource_manager,
- MM_RESOURCE_MANAGER_RES_TYPE_VIDEO_OVERLAY,
- MM_RESOURCE_MANAGER_RES_VOLUME_FULL,
- &player->video_overlay_resource)
- != MM_RESOURCE_MANAGER_ERROR_NONE) {
- LOGE("could not mark video_overlay resource for acquire");
- goto ERROR;
- }
+ if ((surface_type == MM_DISPLAY_SURFACE_OVERLAY) &&
+ (_mmplayer_acquire_hw_resource(player, MMPLAYER_RESOURCE_TYPE_VIDEO_OVERLAY) != MM_ERROR_NONE)) {
+ LOGE("failed to acquire video overlay resource");
+ goto ERROR;
}
player->interrupted_by_resource = FALSE;
- if (mm_resource_manager_commit(player->resource_manager) !=
- MM_RESOURCE_MANAGER_ERROR_NONE) {
- LOGE("could not acquire resources for video playing");
- goto ERROR;
- }
-
if (__mmplayer_gst_create_video_sink_bin(player, caps, surface_type) != MM_ERROR_NONE) {
LOGE("failed to create videobin. continuing without video");
goto ERROR;
reusing = TRUE;
sinkbin = player->pipeline->videobin[MMPLAYER_V_BIN].gst;
LOGD("re-using videobin");
- __mmplayer_update_content_attrs(player, ATTR_VIDEO);
+ _mmplayer_update_content_attrs(player, ATTR_VIDEO);
}
} else if (strstr(name, "text")) {
if (player->pipeline->textbin == NULL) {
}
sinkbin = player->pipeline->textbin[MMPLAYER_T_BIN].gst;
- LOGD("creating textsink bin success");
-
- mm_attrs_set_int_by_name(attrs, "content_text_track_num", 1);
player->textsink_linked = 1;
-
+ LOGD("creating textsink bin success");
} else {
if (!player->textsink_linked) {
LOGD("re-using textbin");
LOGD("no more pads: %d, stream count dec : %d(num of dynamic pad)", player->no_more_pad, player->num_dynamic_pad);
if ((player->no_more_pad) && (player->num_dynamic_pad == 0))
- __mmplayer_pipeline_complete(NULL, player);
+ _mmplayer_pipeline_complete(NULL, player);
ERROR:
if (caps)
gst_caps_unref(caps);
- /* flusing out new attributes */
- if (mm_attrs_commit_all(attrs))
- LOGE("failed to comit attributes");
-
return;
}
static gboolean
-__mmplayer_get_property_value_for_rotation(mm_player_t* player, int display_angle, int orientation, int *value)
+__mmplayer_get_property_value_for_rotation(mmplayer_t *player, int display_angle, int orientation, int *value)
{
int required_angle = 0; /* Angle required for straight view */
int rotation_angle = 0;
break;
}
- LOGD("setting rotation property value : %d", value);
+ LOGD("setting rotation property value : %d", *value);
return TRUE;
}
int
-__mmplayer_video_param_check_video_sink_bin(mm_player_t* player)
-{
- /* check video sinkbin is created */
- MMPLAYER_RETURN_VAL_IF_FAIL(player &&
- player->pipeline &&
- player->pipeline->videobin &&
- player->pipeline->videobin[MMPLAYER_V_BIN].gst &&
- player->pipeline->videobin[MMPLAYER_V_SINK].gst,
- MM_ERROR_PLAYER_NOT_INITIALIZED);
-
- return MM_ERROR_NONE;
-}
-
-int
-__mmplayer_get_video_angle(mm_player_t* player, int *display_angle, int *orientation)
+_mmplayer_get_video_angle(mmplayer_t *player, int *display_angle, int *orientation)
{
int display_rotation = 0;
gchar *org_orient = NULL;
return MM_ERROR_NONE;
}
-void
-__mmplayer_video_param_set_display_rotation(mm_player_t* player)
+static void __mmplayer_video_param_set_display_rotation(mmplayer_t *player)
{
int rotation_value = 0;
int orientations = 0; // current supported angle values are 0, 90, 180, 270
MMPLAYER_FENTER();
/* check video sinkbin is created */
- if (MM_ERROR_NONE != __mmplayer_video_param_check_video_sink_bin(player))
+ if (!_mmplayer_is_videosink_ready(player, MM_DISPLAY_SURFACE_OVERLAY))
return;
- __mmplayer_get_video_angle(player, &display_angle, &orientations);
+ _mmplayer_get_video_angle(player, &display_angle, &orientations);
/* get rotation value to set */
__mmplayer_get_property_value_for_rotation(player, display_angle, orientations, &rotation_value);
LOGD("set video param : rotate %d", rotation_value);
}
-void
-__mmplayer_video_param_set_display_visible(mm_player_t* player)
+static void __mmplayer_video_param_set_display_visible(mmplayer_t *player)
{
MMHandleType attrs = 0;
int visible = 0;
MMPLAYER_FENTER();
/* check video sinkbin is created */
- if (MM_ERROR_NONE != __mmplayer_video_param_check_video_sink_bin(player))
+ if (!_mmplayer_is_videosink_ready(player, MM_DISPLAY_SURFACE_OVERLAY))
return;
attrs = MMPLAYER_GET_ATTRS(player);
LOGD("set video param : visible %d", visible);
}
-void
-__mmplayer_video_param_set_display_method(mm_player_t* player)
+static void __mmplayer_video_param_set_display_method(mmplayer_t *player)
{
MMHandleType attrs = 0;
int display_method = 0;
MMPLAYER_FENTER();
/* check video sinkbin is created */
- if (MM_ERROR_NONE != __mmplayer_video_param_check_video_sink_bin(player))
+ if (!_mmplayer_is_videosink_ready(player, MM_DISPLAY_SURFACE_OVERLAY))
return;
attrs = MMPLAYER_GET_ATTRS(player);
g_object_set(player->pipeline->videobin[MMPLAYER_V_SINK].gst, "display-geometry-method", display_method, NULL);
LOGD("set video param : method %d", display_method);
}
-void
-__mmplayer_video_param_set_video_roi_area(mm_player_t* player)
+
+static void __mmplayer_video_param_set_video_roi_area(mmplayer_t *player)
{
MMHandleType attrs = 0;
- void *handle = NULL;
+ int handle = 0;
MMPLAYER_FENTER();
/* check video sinkbin is created */
- if (__mmplayer_video_param_check_video_sink_bin(player) != MM_ERROR_NONE) {
- LOGW("There is no video sink");
+ if (!_mmplayer_is_videosink_ready(player, MM_DISPLAY_SURFACE_OVERLAY))
return;
- }
attrs = MMPLAYER_GET_ATTRS(player);
MMPLAYER_RETURN_IF_FAIL(attrs);
- mm_attrs_get_data_by_name(attrs, "display_overlay", &handle);
- if (handle) {
- gst_video_overlay_set_video_roi_area(
- GST_VIDEO_OVERLAY(player->pipeline->videobin[MMPLAYER_V_SINK].gst),
- player->video_roi.scale_x, player->video_roi.scale_y, player->video_roi.scale_width, player->video_roi.scale_height);
- LOGD("set video param : video roi area scale value: x(%f) y(%f) width(%f) height(%f)",
- player->video_roi.scale_x, player->video_roi.scale_y, player->video_roi.scale_width, player->video_roi.scale_height);
- }
+
+ mm_attrs_get_int_by_name(attrs, "display_overlay", &handle);
+ MMPLAYER_RETURN_IF_FAIL(handle);
+
+ gst_video_overlay_set_video_roi_area(
+ GST_VIDEO_OVERLAY(player->pipeline->videobin[MMPLAYER_V_SINK].gst),
+ player->video_roi.scale_x, player->video_roi.scale_y, player->video_roi.scale_width, player->video_roi.scale_height);
+ LOGD("set video param : video roi area scale value: x(%f) y(%f) width(%f) height(%f)",
+ player->video_roi.scale_x, player->video_roi.scale_y, player->video_roi.scale_width, player->video_roi.scale_height);
}
-void
-__mmplayer_video_param_set_roi_area(mm_player_t* player)
+static void __mmplayer_video_param_set_roi_area(mmplayer_t *player)
{
MMHandleType attrs = 0;
- void *handle = NULL;
+ int handle = 0;
/*set wl_display*/
int win_roi_x = 0;
int win_roi_y = 0;
MMPLAYER_FENTER();
/* check video sinkbin is created */
- if (__mmplayer_video_param_check_video_sink_bin(player) != MM_ERROR_NONE) {
- LOGW("There is no video sink");
+ if (!_mmplayer_is_videosink_ready(player, MM_DISPLAY_SURFACE_OVERLAY))
return;
- }
attrs = MMPLAYER_GET_ATTRS(player);
MMPLAYER_RETURN_IF_FAIL(attrs);
- mm_attrs_get_data_by_name(attrs, "display_overlay", &handle);
+ mm_attrs_get_int_by_name(attrs, "display_overlay", &handle);
+ MMPLAYER_RETURN_IF_FAIL(handle);
- if (handle) {
- /* It should be set after setting window */
- mm_attrs_get_int_by_name(attrs, "display_win_roi_x", &win_roi_x);
- mm_attrs_get_int_by_name(attrs, "display_win_roi_y", &win_roi_y);
- mm_attrs_get_int_by_name(attrs, "display_win_roi_width", &win_roi_width);
- mm_attrs_get_int_by_name(attrs, "display_win_roi_height", &win_roi_height);
+ /* It should be set after setting window */
+ mm_attrs_multiple_get(attrs, NULL,
+ "display_win_roi_x", &win_roi_x,
+ "display_win_roi_y", &win_roi_y,
+ "display_win_roi_width", &win_roi_width,
+ "display_win_roi_height", &win_roi_height, NULL);
- /* After setting window handle, set display roi area */
- gst_video_overlay_set_display_roi_area(
- GST_VIDEO_OVERLAY(player->pipeline->videobin[MMPLAYER_V_SINK].gst),
- win_roi_x, win_roi_y, win_roi_width, win_roi_height);
- LOGD("set video param : roi area : x(%d) y(%d) width(%d) height(%d)",
- win_roi_x, win_roi_y, win_roi_width, win_roi_height);
- }
+ /* After setting window handle, set display roi area */
+ gst_video_overlay_set_display_roi_area(
+ GST_VIDEO_OVERLAY(player->pipeline->videobin[MMPLAYER_V_SINK].gst),
+ win_roi_x, win_roi_y, win_roi_width, win_roi_height);
+ LOGD("set video param : roi area : x(%d) y(%d) width(%d) height(%d)",
+ win_roi_x, win_roi_y, win_roi_width, win_roi_height);
}
-void
-__mmplayer_video_param_set_display_overlay(mm_player_t* player)
+
+static void __mmplayer_video_param_set_display_overlay(mmplayer_t *player)
{
MMHandleType attrs = 0;
- void *handle = NULL;
+ int handle = 0;
/* check video sinkbin is created */
- if (MM_ERROR_NONE != __mmplayer_video_param_check_video_sink_bin(player))
+ if (!_mmplayer_is_videosink_ready(player, MM_DISPLAY_SURFACE_OVERLAY))
return;
attrs = MMPLAYER_GET_ATTRS(player);
MMPLAYER_RETURN_IF_FAIL(attrs);
/* common case if using overlay surface */
- mm_attrs_get_data_by_name(attrs, "display_overlay", &handle);
+ mm_attrs_get_int_by_name(attrs, "display_overlay", &handle);
+ MMPLAYER_RETURN_IF_FAIL(handle);
- if (handle) {
- /* default is using wl_surface_id */
- unsigned int wl_surface_id = 0;
- wl_surface_id = *(int*)handle;
- LOGD("set video param : wl_surface_id %d %p", wl_surface_id, *(int*)handle);
- gst_video_overlay_set_wl_window_wl_surface_id(
- GST_VIDEO_OVERLAY(player->pipeline->videobin[MMPLAYER_V_SINK].gst),
- *(int*)handle);
- } else
- /* FIXIT : is it error case? */
- LOGW("still we don't have a window handle on player attribute. create it's own surface.");
+ /* default is using wl_surface_id */
+ LOGD("set video param : wl_surface_id %d", handle);
+ gst_video_overlay_set_wl_window_wl_surface_id(
+ GST_VIDEO_OVERLAY(player->pipeline->videobin[MMPLAYER_V_SINK].gst),
+ handle);
}
-
int
-__mmplayer_update_wayland_videosink_video_param(mm_player_t* player, char *param_name)
+_mmplayer_update_video_overlay_param(mmplayer_t *player, const char *param_name)
{
- bool update_all_param = FALSE;
+ gboolean update_all_param = FALSE;
+
MMPLAYER_FENTER();
- /* check video sinkbin is created */
- if (MM_ERROR_NONE != __mmplayer_video_param_check_video_sink_bin(player))
+ if (!_mmplayer_is_videosink_ready(player, MM_DISPLAY_SURFACE_OVERLAY)) {
+ LOGW("videosink is not ready yet");
return MM_ERROR_PLAYER_NOT_INITIALIZED;
+ }
if (strcmp(player->ini.videosink_element_overlay, "tizenwlsink")) {
- LOGE("can not find tizenwlsink");
+ LOGE("invalid videosink [%s]", player->ini.videosink_element_overlay);
return MM_ERROR_PLAYER_INTERNAL;
}
if (update_all_param)
__mmplayer_video_param_set_video_roi_area(player);
- return MM_ERROR_NONE;
-}
-
-int
-_mmplayer_update_video_param(mm_player_t* player, char *param_name)
-{
- MMHandleType attrs = 0;
- int surface_type = 0;
- int ret = MM_ERROR_NONE;
-
- MMPLAYER_FENTER();
-
- /* check video sinkbin is created */
- if (MM_ERROR_NONE != __mmplayer_video_param_check_video_sink_bin(player))
- return MM_ERROR_PLAYER_NOT_INITIALIZED;
-
- attrs = MMPLAYER_GET_ATTRS(player);
- if (!attrs) {
- LOGE("cannot get content attribute");
- return MM_ERROR_PLAYER_INTERNAL;
- }
- LOGD("param_name : %s", param_name);
-
- /* update display surface */
- mm_attrs_get_int_by_name(attrs, "display_surface_type", &surface_type);
- LOGD("check display surface type attribute: %d", surface_type);
-
- /* configuring display */
- switch (surface_type) {
- case MM_DISPLAY_SURFACE_OVERLAY:
- {
- ret = __mmplayer_update_wayland_videosink_video_param(player, param_name);
- if (ret != MM_ERROR_NONE)
- return ret;
- }
- break;
- }
MMPLAYER_FLEAVE();
-
return MM_ERROR_NONE;
}
_mmplayer_set_audio_only(MMHandleType hplayer, bool audio_only)
{
gboolean disable_overlay = FALSE;
- mm_player_t* player = (mm_player_t*) hplayer;
- int ret = MM_ERROR_NONE;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player && player->pipeline, MM_ERROR_PLAYER_NOT_INITIALIZED);
g_object_set(player->pipeline->videobin[MMPLAYER_V_SINK].gst, "disable-overlay", TRUE, NULL);
/* release overlay resource */
- if (player->video_overlay_resource != NULL) {
- ret = mm_resource_manager_mark_for_release(player->resource_manager,
- player->video_overlay_resource);
- if (ret != MM_RESOURCE_MANAGER_ERROR_NONE) {
- LOGE("failed to mark overlay resource for release, ret(0x%x)\n", ret);
- goto ERROR;
- }
- player->video_overlay_resource = NULL;
- }
-
- ret = mm_resource_manager_commit(player->resource_manager);
- if (ret != MM_RESOURCE_MANAGER_ERROR_NONE) {
- LOGE("failed to commit acquiring of overlay resource, ret(0x%x)\n", ret);
+ if (__mmplayer_release_hw_resource(player, MMPLAYER_RESOURCE_TYPE_VIDEO_OVERLAY) != MM_ERROR_NONE) {
+ LOGE("failed to release overlay resource");
goto ERROR;
}
} else {
- /* mark video overlay for acquire */
- if (player->video_overlay_resource == NULL) {
- ret = mm_resource_manager_mark_for_acquire(player->resource_manager,
- MM_RESOURCE_MANAGER_RES_TYPE_VIDEO_OVERLAY,
- MM_RESOURCE_MANAGER_RES_VOLUME_FULL,
- &player->video_overlay_resource);
- if (ret != MM_RESOURCE_MANAGER_ERROR_NONE) {
- LOGE("could not prepare for video_overlay resource\n");
- goto ERROR;
- }
- }
-
- player->interrupted_by_resource = FALSE;
- /* acquire resources for video overlay */
- ret = mm_resource_manager_commit(player->resource_manager);
- if (ret != MM_RESOURCE_MANAGER_ERROR_NONE) {
- LOGE("could not acquire resources for video playing\n");
+ if (_mmplayer_acquire_hw_resource(player, MMPLAYER_RESOURCE_TYPE_VIDEO_OVERLAY) != MM_ERROR_NONE) {
+ LOGE("failed to acquire video overlay resource");
goto ERROR;
}
+ player->interrupted_by_resource = FALSE;
LOGD("enable overlay");
__mmplayer_video_param_set_display_overlay(player);
int
_mmplayer_get_audio_only(MMHandleType hplayer, bool *paudio_only)
{
- mm_player_t* player = (mm_player_t*) hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
gboolean disable_overlay = FALSE;
MMPLAYER_FENTER();
g_object_get(player->pipeline->videobin[MMPLAYER_V_SINK].gst, "disable-overlay", &disable_overlay, NULL);
- *paudio_only = (bool)(disable_overlay);
+ *paudio_only = (bool)disable_overlay;
LOGD("audio_only : %d", *paudio_only);
}
int
-__mmplayer_gst_element_link_bucket(GList* element_bucket)
+_mmplayer_gst_element_link_bucket(GList *element_bucket)
{
- GList* bucket = element_bucket;
- MMPlayerGstElement* element = NULL;
- MMPlayerGstElement* prv_element = NULL;
+ GList *bucket = element_bucket;
+ mmplayer_gst_element_t *element = NULL;
+ mmplayer_gst_element_t *prv_element = NULL;
+ GstElement *tee_element = NULL;
gint successful_link_count = 0;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(element_bucket, -1);
- prv_element = (MMPlayerGstElement*)bucket->data;
+ prv_element = (mmplayer_gst_element_t *)bucket->data;
bucket = bucket->next;
for (; bucket; bucket = bucket->next) {
- element = (MMPlayerGstElement*)bucket->data;
+ element = (mmplayer_gst_element_t *)bucket->data;
if (element && element->gst) {
if (prv_element && prv_element->gst) {
+ if (strstr(GST_ELEMENT_NAME(element->gst), "audio-tee-queue") && strcmp(GST_ELEMENT_NAME(prv_element->gst), "audio-tee")) {
+ if (tee_element) {
+ prv_element->gst = tee_element;
+ } else {
+ LOGD("failed to make new audio branch - linking [%s] to [%s] is not supported",
+ GST_ELEMENT_NAME(GST_ELEMENT(prv_element->gst)),
+ GST_ELEMENT_NAME(GST_ELEMENT(element->gst)));
+ return -1;
+ }
+ }
if (gst_element_link(GST_ELEMENT(prv_element->gst), GST_ELEMENT(element->gst))) {
- LOGD("linking [%s] to [%s] success\n",
+ LOGD("linking [%s] to [%s] success",
GST_ELEMENT_NAME(GST_ELEMENT(prv_element->gst)),
GST_ELEMENT_NAME(GST_ELEMENT(element->gst)));
successful_link_count++;
+ if (!strcmp(GST_ELEMENT_NAME(prv_element->gst), "audio-tee")) {
+ LOGD("keep audio-tee element for next audio pipeline branch");
+ tee_element = prv_element->gst;
+ }
} else {
- LOGD("linking [%s] to [%s] failed\n",
+ LOGD("linking [%s] to [%s] failed",
GST_ELEMENT_NAME(GST_ELEMENT(prv_element->gst)),
GST_ELEMENT_NAME(GST_ELEMENT(element->gst)));
return -1;
}
int
-__mmplayer_gst_element_add_bucket_to_bin(GstBin* bin, GList* element_bucket)
+_mmplayer_gst_element_add_bucket_to_bin(GstBin *bin, GList *element_bucket)
{
- GList* bucket = element_bucket;
- MMPlayerGstElement* element = NULL;
+ GList *bucket = element_bucket;
+ mmplayer_gst_element_t *element = NULL;
int successful_add_count = 0;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(bin, 0);
for (; bucket; bucket = bucket->next) {
- element = (MMPlayerGstElement*)bucket->data;
+ element = (mmplayer_gst_element_t *)bucket->data;
if (element && element->gst) {
if (!gst_bin_add(bin, GST_ELEMENT(element->gst))) {
- LOGD("__mmplayer_gst_element_link_bucket : Adding element [%s] to bin [%s] failed\n",
+ LOGD("_mmplayer_gst_element_link_bucket : Adding element [%s] to bin [%s] failed",
GST_ELEMENT_NAME(GST_ELEMENT(element->gst)),
GST_ELEMENT_NAME(GST_ELEMENT(bin)));
return 0;
return successful_add_count;
}
-static void __mmplayer_gst_caps_notify_cb(GstPad *pad, GParamSpec *unused, gpointer data)
+static void
+__mmplayer_gst_caps_notify_cb(GstPad *pad, GParamSpec *unused, gpointer data)
{
- mm_player_t *player = (mm_player_t*) data;
+ mmplayer_t *player = (mmplayer_t *)data;
GstCaps *caps = NULL;
GstStructure *str = NULL;
const char *name;
if (!caps)
return;
- MMPLAYER_GST_GET_CAPS_INFO(pad, caps, str, name, caps_ret);
+ MMPLAYER_GST_GET_CAPS_INFO_FROM_PAD(pad, caps, str, name, caps_ret);
if (!caps_ret)
goto ERROR;
LOGD("name = %s", name);
if (strstr(name, "audio")) {
- __mmplayer_update_content_attrs(player, ATTR_AUDIO);
+ _mmplayer_update_content_attrs(player, ATTR_AUDIO);
if (player->audio_stream_changed_cb) {
LOGE("call the audio stream changed cb");
if ((name = gst_structure_get_string(str, "format")))
player->set_mode.video_zc = name[0] == 'S';
- __mmplayer_update_content_attrs(player, ATTR_VIDEO);
-
- if (player->video_stream_changed_cb) {
- LOGE("call the video stream changed cb");
- player->video_stream_changed_cb(player->video_stream_changed_cb_user_param);
- }
+ _mmplayer_update_content_attrs(player, ATTR_VIDEO);
+ MMPLAYER_POST_MSG(player, MM_MESSAGE_VIDEO_STREAM_CHANGED, NULL);
} else {
LOGW("invalid caps info");
}
return;
}
-
-
-/**
- * This function is to create audio pipeline for playing.
- *
- * @param player [in] handle of player
- *
- * @return This function returns zero on success.
- * @remark
- * @see __mmplayer_gst_create_midi_pipeline, __mmplayer_gst_create_video_sink_bin
- */
-/* macro for code readability. just for sinkbin-creation functions */
-#define MMPLAYER_CREATE_ELEMENT(x_bin, x_id, x_factory, x_name, x_add_bucket, x_player) \
-do {\
- x_bin[x_id].id = x_id;\
- x_bin[x_id].gst = gst_element_factory_make(x_factory, x_name);\
- if (!x_bin[x_id].gst) {\
- LOGE("failed to create %s \n", x_factory);\
- goto ERROR;\
- } else {\
- if (x_player->ini.set_dump_element_flag)\
- __mmplayer_add_dump_buffer_probe(x_player, x_bin[x_id].gst);\
- } \
- if (x_add_bucket)\
- element_bucket = g_list_append(element_bucket, &x_bin[x_id]);\
-} while (0);
-
void
-__mmplayer_audio_stream_clear_buffer(mm_player_t* player, gboolean send_all)
+_mmplayer_audio_stream_clear_buffer(mmplayer_t *player, gboolean send_all)
{
GList *l = NULL;
if (player->audio_stream_buff_list) {
for (l = g_list_first(player->audio_stream_buff_list); l; l = g_list_next(l)) {
- mm_player_audio_stream_buff_t *tmp = (mm_player_audio_stream_buff_t *)l->data;
+ mmplayer_audio_stream_buff_t *tmp = (mmplayer_audio_stream_buff_t *)l->data;
if (tmp) {
if (send_all) {
LOGD("[%"G_GUINT64_FORMAT"] send remained data.", tmp->channel_mask);
__mmplayer_audio_stream_send_data(player, tmp);
}
- if (tmp->pcm_data)
- g_free(tmp->pcm_data);
- g_free(tmp);
+ MMPLAYER_FREEIF(tmp->pcm_data);
+ MMPLAYER_FREEIF(tmp);
}
}
g_list_free(player->audio_stream_buff_list);
}
static void
-__mmplayer_audio_stream_send_data(mm_player_t* player, mm_player_audio_stream_buff_t *a_buffer)
+__mmplayer_audio_stream_send_data(mmplayer_t *player, mmplayer_audio_stream_buff_t *a_buffer)
{
- MMPlayerAudioStreamDataType audio_stream = { 0, };
+ mmplayer_audio_decoded_data_info_t audio_stream = { 0, };
MMPLAYER_FENTER();
- MMPLAYER_RETURN_IF_FAIL(player && player->audio_stream_render_cb);
+ MMPLAYER_RETURN_IF_FAIL(player && player->audio_decoded_cb);
audio_stream.bitrate = a_buffer->bitrate;
audio_stream.channel = a_buffer->channel;
- audio_stream.depth = a_buffer->depth;
- audio_stream.is_little_endian = a_buffer->is_little_endian;
audio_stream.channel_mask = a_buffer->channel_mask;
audio_stream.data_size = a_buffer->data_size;
audio_stream.data = a_buffer->pcm_data;
-
- /* LOGD("[%"G_GUINT64_FORMAT"] send data size:%d, %p", audio_stream.channel_mask, audio_stream.data_size, player->audio_stream_cb_user_param); */
- player->audio_stream_render_cb(&audio_stream, player->audio_stream_cb_user_param);
+ audio_stream.pcm_format = a_buffer->pcm_format;
+#ifdef __DEBUG__
+ LOGD("[%"G_GUINT64_FORMAT"] send data size:%d, %p", audio_stream.channel_mask, audio_stream.data_size, player->audio_decoded_cb_user_param);
+#endif
+ player->audio_decoded_cb(&audio_stream, player->audio_decoded_cb_user_param);
MMPLAYER_FLEAVE();
}
static void
-__mmplayer_audio_stream_decoded_render_cb(GstElement* object, GstBuffer *buffer, GstPad *pad, gpointer data)
+__mmplayer_audio_stream_decoded_render_cb(GstElement *object, GstBuffer *buffer, GstPad *pad, gpointer data)
{
- mm_player_t* player = (mm_player_t*) data;
-
+ mmplayer_t *player = (mmplayer_t *)data;
+ const gchar *pcm_format = NULL;
gint channel = 0;
gint rate = 0;
- gint depth = 0;
- gint endianness = 0;
guint64 channel_mask = 0;
void *a_data = NULL;
gint a_size = 0;
- mm_player_audio_stream_buff_t *a_buffer = NULL;
+ mmplayer_audio_stream_buff_t *a_buffer = NULL;
GstMapInfo mapinfo = GST_MAP_INFO_INIT;
GList *l = NULL;
MMPLAYER_FENTER();
- MMPLAYER_RETURN_IF_FAIL(player && player->audio_stream_render_cb);
+ MMPLAYER_RETURN_IF_FAIL(player && player->audio_decoded_cb);
gst_buffer_map(buffer, &mapinfo, GST_MAP_READ);
a_data = mapinfo.data;
GstCaps *caps = gst_pad_get_current_caps(pad);
GstStructure *structure = gst_caps_get_structure(caps, 0);
-
- /* MMPLAYER_LOG_GST_CAPS_TYPE(caps); */
+#ifdef __DEBUG__
+ MMPLAYER_LOG_GST_CAPS_TYPE(caps);
+#endif
+ pcm_format = gst_structure_get_string(structure, "format");
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));
* The num of buffer list depends on the num of audio channels */
if (player->audio_stream_buff_list) {
for (l = g_list_first(player->audio_stream_buff_list); l; l = g_list_next(l)) {
- mm_player_audio_stream_buff_t *tmp = (mm_player_audio_stream_buff_t *)l->data;
+ mmplayer_audio_stream_buff_t *tmp = (mmplayer_audio_stream_buff_t *)l->data;
if (tmp) {
if (channel_mask == tmp->channel_mask) {
- /* LOGD("[%"G_GUINT64_FORMAT"] total: %d, data: %d, buffer: %d", channel_mask, tmp->data_size, a_size, tmp->buff_size); */
+#ifdef __DEBUG__
+ LOGD("[%"G_GUINT64_FORMAT"] total: %d, data: %d, buffer: %d", channel_mask, tmp->data_size, a_size, tmp->buff_size);
+#endif
if (tmp->data_size + a_size < tmp->buff_size) {
memcpy(tmp->pcm_data + tmp->data_size, a_data, a_size);
tmp->data_size += a_size;
}
}
- /* create new audio stream data */
- a_buffer = (mm_player_audio_stream_buff_t*)g_malloc0(sizeof(mm_player_audio_stream_buff_t));
+ /* create new audio stream data for newly found audio channel */
+ a_buffer = (mmplayer_audio_stream_buff_t *)g_try_malloc0(sizeof(mmplayer_audio_stream_buff_t));
if (a_buffer == NULL) {
LOGE("failed to alloc data.");
goto DONE;
}
a_buffer->bitrate = rate;
a_buffer->channel = channel;
- a_buffer->depth = depth;
- a_buffer->is_little_endian = (endianness == 1234 ? 1 : 0);
a_buffer->channel_mask = channel_mask;
a_buffer->data_size = a_size;
+ a_buffer->pcm_format = _mmplayer_convert_audio_pcm_str_to_media_format_mime(pcm_format);
- if (!player->audio_stream_sink_sync) {
+ if (player->audio_extract_opt & MM_PLAYER_AUDIO_EXTRACT_NO_SYNC_WITH_CLOCK) {
/* If sync is FALSE, use buffer list to reduce the IPC. */
a_buffer->buff_size = (a_size > player->ini.pcm_buffer_size) ? (a_size) : (player->ini.pcm_buffer_size);
- a_buffer->pcm_data = g_malloc(a_buffer->buff_size);
+ a_buffer->pcm_data = g_try_malloc(a_buffer->buff_size);
if (a_buffer->pcm_data == NULL) {
LOGE("failed to alloc data.");
- g_free(a_buffer);
+ MMPLAYER_FREEIF(a_buffer);
goto DONE;
}
memcpy(a_buffer->pcm_data, a_data, a_size);
- /* LOGD("new [%"G_GUINT64_FORMAT"] total:%d buff:%d", channel_mask, a_buffer->data_size, a_buffer->buff_size); */
+#ifdef __DEBUG__
+ LOGD("new [%"G_GUINT64_FORMAT"] total:%d buff:%d", channel_mask, a_buffer->data_size, a_buffer->buff_size);
+#endif
player->audio_stream_buff_list = g_list_append(player->audio_stream_buff_list, a_buffer);
} else {
/* If sync is TRUE, send data directly. */
a_buffer->pcm_data = a_data;
__mmplayer_audio_stream_send_data(player, a_buffer);
- g_free(a_buffer);
+ MMPLAYER_FREEIF(a_buffer);
}
DONE:
static void
__mmplayer_gst_audio_deinterleave_pad_added(GstElement *elem, GstPad *pad, gpointer data)
{
- mm_player_t* player = (mm_player_t*)data;
- MMPlayerGstElement* audiobin = player->pipeline->audiobin;
- GstPad* sinkpad = NULL;
+ mmplayer_t *player = (mmplayer_t *)data;
+ mmplayer_gst_element_t *audiobin = player->pipeline->audiobin;
+ GstPad *sinkpad = NULL;
GstElement *queue = NULL, *sink = NULL;
MMPLAYER_FENTER();
queue = gst_element_factory_make("queue", NULL);
if (queue == NULL) {
- LOGD("fail make queue\n");
+ LOGD("fail make queue");
goto ERROR;
}
sink = gst_element_factory_make("fakesink", NULL);
if (sink == NULL) {
- LOGD("fail make fakesink\n");
+ LOGD("fail make fakesink");
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)) {
- LOGW("failed to link queue & sink\n");
+ LOGW("failed to link queue & sink");
goto ERROR;
}
sinkpad = gst_element_get_static_pad(queue, "sink");
if (GST_PAD_LINK_OK != gst_pad_link(pad, sinkpad)) {
- LOGW("failed to link [%s:%s] to queue\n", GST_DEBUG_PAD_NAME(pad));
+ LOGW("failed to link [%s:%s] to queue", GST_DEBUG_PAD_NAME(pad));
goto ERROR;
}
- LOGE("player->audio_stream_sink_sync: %d\n", player->audio_stream_sink_sync);
+ LOGE("audio_extract_opt : 0x%X", player->audio_extract_opt);
gst_object_unref(sinkpad);
- g_object_set(sink, "sync", player->audio_stream_sink_sync, NULL);
+ if (!(player->audio_extract_opt & MM_PLAYER_AUDIO_EXTRACT_NO_SYNC_WITH_CLOCK))
+ g_object_set(sink, "sync", TRUE, 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);
+ /* keep the first sink reference only */
+ if (!audiobin[MMPLAYER_A_SINK].gst) {
+ audiobin[MMPLAYER_A_SINK].id = MMPLAYER_A_SINK;
+ audiobin[MMPLAYER_A_SINK].gst = sink;
+ }
+
- __mmplayer_add_signal_connection(player,
+ _mmplayer_add_signal_connection(player,
G_OBJECT(sink),
MM_PLAYER_SIGNAL_TYPE_AUDIOBIN,
"handoff",
G_CALLBACK(__mmplayer_audio_stream_decoded_render_cb),
(gpointer)player);
+ __mmplayer_add_sink(player, sink);
+
+ if (gst_element_sync_state_with_parent(queue) == GST_STATE_CHANGE_FAILURE) {
+ LOGE("failed to sync state");
+ goto ERROR;
+ }
+
+ if (gst_element_sync_state_with_parent(sink) == GST_STATE_CHANGE_FAILURE) {
+ LOGE("failed to sync state");
+ goto ERROR;
+ }
+
MMPLAYER_FLEAVE();
return;
ERROR:
- LOGE("__mmplayer_gst_audio_deinterleave_pad_added ERROR\n");
+ LOGE("__mmplayer_gst_audio_deinterleave_pad_added ERROR");
if (queue) {
gst_object_unref(GST_OBJECT(queue));
queue = NULL;
return;
}
-void __mmplayer_gst_set_pulsesink_property(mm_player_t* player, MMHandleType attrs)
+void
+__mmplayer_gst_audio_deinterleave_no_more_pads(GstElement* object, gpointer data)
+{
+ mmplayer_t *player = (mmplayer_t *)data;
+
+ MMPLAYER_FENTER();
+ MMPLAYER_RETURN_IF_FAIL(player && player->pipeline && player->pipeline->mainbin);
+
+ player->no_more_pad = TRUE;
+ _mmplayer_pipeline_complete(NULL, player);
+
+ MMPLAYER_FLEAVE();
+ return;
+}
+
+void
+__mmplayer_gst_set_pulsesink_property(mmplayer_t *player)
{
#define MAX_PROPS_LEN 128
+ mmplayer_gst_element_t *audiobin = NULL;
gint latency_mode = 0;
gchar *stream_type = NULL;
gchar *latency = NULL;
MMPLAYER_FENTER();
MMPLAYER_RETURN_IF_FAIL(player && player->pipeline && player->pipeline->audiobin);
- mm_attrs_get_int_by_name(attrs, "sound_stream_index", &stream_id);
- mm_attrs_get_string_by_name(attrs, "sound_stream_type", &stream_type);
+ audiobin = player->pipeline->audiobin;
- if (!stream_type) {
- LOGE("stream_type is null.");
- } else {
- if (player->sound.focus_id)
- snprintf(stream_props, sizeof(stream_props)-1, "props,media.role=%s, media.parent_id=%d, media.focus_id=%d",
- stream_type, stream_id, player->sound.focus_id);
- 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);
- LOGI("stream_type[%s], stream_id[%d], focus_id[%d], result[%s].",
- stream_type, stream_id, player->sound.focus_id, stream_props);
- gst_structure_free(props);
+ g_object_set(G_OBJECT(audiobin[MMPLAYER_A_SINK].gst), "volume", player->sound.volume, NULL);
+ if (player->sound.mute) {
+ LOGD("mute enabled");
+ g_object_set(G_OBJECT(audiobin[MMPLAYER_A_SINK].gst), "mute", player->sound.mute, NULL);
}
- mm_attrs_get_int_by_name(attrs, "sound_latency_mode", &latency_mode);
+ mm_attrs_get_int_by_name(player->attrs, "sound_stream_index", &stream_id);
+ mm_attrs_get_string_by_name(player->attrs, "sound_stream_type", &stream_type);
+
+ if (!stream_type)
+ snprintf(stream_props, sizeof(stream_props) - 1,
+ "props,application.process.id.origin=%d", player->client_pid);
+ else
+ snprintf(stream_props, sizeof(stream_props) - 1,
+ "props,media.role=%s, media.parent_id=%d, application.process.id.origin=%d",
+ stream_type, stream_id, player->client_pid);
+
+ props = gst_structure_from_string(stream_props, NULL);
+ g_object_set(audiobin[MMPLAYER_A_SINK].gst, "stream-properties", props, NULL);
+ LOGI("props result[%s].", stream_props);
+ gst_structure_free(props);
+
+ mm_attrs_get_int_by_name(player->attrs, "sound_latency_mode", &latency_mode);
switch (latency_mode) {
case AUDIO_LATENCY_MODE_LOW:
- latency = g_strndup("low", 3);
+ latency = g_strdup("low");
break;
case AUDIO_LATENCY_MODE_MID:
- latency = g_strndup("mid", 3);
+ latency = g_strdup("mid");
break;
case AUDIO_LATENCY_MODE_HIGH:
- latency = g_strndup("high", 4);
+ latency = g_strdup("high");
+ break;
+ default:
+ latency = g_strdup("mid");
break;
};
- g_object_set(player->pipeline->audiobin[MMPLAYER_A_SINK].gst,
- "latency", latency,
- NULL);
+ g_object_set(audiobin[MMPLAYER_A_SINK].gst, "latency", latency, NULL);
LOGD("audiosink property - latency=%s", latency);
- g_free(latency);
+ MMPLAYER_FREEIF(latency);
MMPLAYER_FLEAVE();
}
-void __mmplayer_gst_set_openalsink_property(mm_player_t* player)
+int
+__mmplayer_gst_set_openalsink_property(mmplayer_t *player)
{
- MMPlayerGstElement *audiobin = NULL;
+ mmplayer_gst_element_t *audiobin = NULL;
MMPLAYER_FENTER();
- MMPLAYER_RETURN_IF_FAIL(player && player->pipeline && player->pipeline->audiobin);
+ MMPLAYER_RETURN_VAL_IF_FAIL(player && player->pipeline &&
+ player->pipeline->audiobin, MM_ERROR_PLAYER_NOT_INITIALIZED);
audiobin = player->pipeline->audiobin;
g_object_set(G_OBJECT(audiobin[MMPLAYER_A_SINK].gst), "source-ambisonics-type", 1, NULL);
- sound_manager_create_stream_information(SOUND_STREAM_TYPE_MEDIA, NULL, NULL, &stream_info);
+ if (sound_manager_create_stream_information(SOUND_STREAM_TYPE_MEDIA, NULL, NULL, &stream_info)) {
+ LOGE("failed to create media stream info");
+ return MM_ERROR_PLAYER_INTERNAL;
+ }
+
g_object_set(G_OBJECT(audiobin[MMPLAYER_A_SINK].gst), "stream-info", stream_info, NULL);
if (player->video360_yaw_radians <= M_PI &&
player->video360_pitch_radians <= M_PI_2 &&
player->video360_pitch_radians >= -M_PI_2) {
g_object_set(G_OBJECT(audiobin[MMPLAYER_A_SINK].gst),
- "source-orientation-y", (int) (player->video360_yaw_radians * 180.0 / M_PI),
- "source-orientation-x", (int) (player->video360_pitch_radians * 180.0 / M_PI), NULL);
+ "source-orientation-y", (int)(player->video360_yaw_radians * 180.0 / M_PI),
+ "source-orientation-x", (int)(player->video360_pitch_radians * 180.0 / M_PI), NULL);
} else if (player->video360_metadata.init_view_heading || player->video360_metadata.init_view_pitch) {
g_object_set(G_OBJECT(audiobin[MMPLAYER_A_SINK].gst),
"source-orientation-y", player->video360_metadata.init_view_heading,
}
MMPLAYER_FLEAVE();
+ return MM_ERROR_NONE;
}
static int
-__mmplayer_gst_fill_audio_bucket(mm_player_t *player, GList **bucket)
+__mmplayer_gst_make_audio_playback_sink(mmplayer_t *player, GList **bucket)
{
- MMPlayerGstElement *audiobin = NULL;
- MMHandleType attrs = 0;
- GList *element_bucket = NULL;
- GstCaps *acaps = NULL;
+ mmplayer_gst_element_t *audiobin = NULL;
GstPad *sink_pad = NULL;
+ GstCaps *acaps = NULL;
+ gint channels = 0;
+ int pitch_control = 0;
+ double pitch_value = 1.0;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player && player->pipeline &&
player->pipeline->audiobin, MM_ERROR_PLAYER_NOT_INITIALIZED);
audiobin = player->pipeline->audiobin;
- attrs = MMPLAYER_GET_ATTRS(player);
-
- /* converter */
- MMPLAYER_CREATE_ELEMENT(audiobin, MMPLAYER_A_CONV, "audioconvert", "audio converter", TRUE, player);
-
- /* replaygain volume */
- MMPLAYER_CREATE_ELEMENT(audiobin, MMPLAYER_A_RGVOL, "rgvolume", "audio rgvolume", TRUE, player);
- if (player->sound.rg_enable)
- g_object_set(G_OBJECT(audiobin[MMPLAYER_A_RGVOL].gst), "enable-rgvolume", TRUE, NULL);
- else
- g_object_set(G_OBJECT(audiobin[MMPLAYER_A_RGVOL].gst), "enable-rgvolume", FALSE, NULL);
-
- /* resampler */
- MMPLAYER_CREATE_ELEMENT(audiobin, MMPLAYER_A_RESAMPLER, player->ini.audioresampler_element, "audio resampler", TRUE, player);
- if (player->audio_stream_render_cb) { /* pcm extraction only, no sound output */
- gchar *dst_format = NULL;
- int dst_len = 0;
- int dst_samplerate = 0;
- int dst_channels = 0;
- GstCaps *caps = NULL;
- char *caps_str = NULL;
+ LOGD("make element for normal audio playback");
- /* get conf. values */
- mm_attrs_multiple_get(player->attrs, NULL,
- "pcm_audioformat", &dst_format, &dst_len,
- "pcm_extraction_samplerate", &dst_samplerate,
- "pcm_extraction_channels", &dst_channels,
- NULL);
+ /* audio bin structure for playback. {} means optional.
+ optional : pitch, audioeq, custom audioeq, openalsink for 360 audio content
- LOGD("pcm info - format: %s(%d), samplerate : %d, channel: %d", dst_format, dst_len, dst_samplerate, dst_channels);
+ * src - ... - {aconv - pitch} - aconv - rgvolume - resample - volume -
+ {audioeq} - {custom audioeq} - pulsesink or {aconv - capsfilter - openalsink}
+ */
- /* capsfilter */
- MMPLAYER_CREATE_ELEMENT(audiobin, MMPLAYER_A_CAPS_DEFAULT, "capsfilter", "audio capsfilter", TRUE, player);
- caps = gst_caps_new_simple("audio/x-raw",
- "format", G_TYPE_STRING, dst_format,
- "rate", G_TYPE_INT, dst_samplerate,
- "channels", G_TYPE_INT, dst_channels,
+ /* for pitch control */
+ mm_attrs_multiple_get(player->attrs, NULL,
+ MM_PLAYER_PITCH_CONTROL, &pitch_control,
+ MM_PLAYER_PITCH_VALUE, &pitch_value,
NULL);
- caps_str = gst_caps_to_string(caps);
- LOGD("new caps : %s", caps_str);
-
- g_object_set(GST_ELEMENT(audiobin[MMPLAYER_A_CAPS_DEFAULT].gst), "caps", caps, NULL);
+ LOGD("pitch %d / %1.3f", pitch_control, pitch_value);
+ if (pitch_control && (player->videodec_linked == 0)) {
+ GstElementFactory *factory;
- /* clean */
- gst_caps_unref(caps);
- MMPLAYER_FREEIF(caps_str);
+ factory = gst_element_factory_find("pitch");
+ if (factory) {
+ gst_object_unref(factory);
- MMPLAYER_CREATE_ELEMENT(audiobin, MMPLAYER_A_DEINTERLEAVE, "deinterleave", "deinterleave", TRUE, player);
+ /* converter */
+ MMPLAYER_CREATE_ELEMENT(audiobin, MMPLAYER_A_CONV_PITCH, "audioconvert", "audio convert pitch", *bucket, player);
- g_object_set(G_OBJECT(audiobin[MMPLAYER_A_DEINTERLEAVE].gst), "keep-positions", TRUE, NULL);
+ /* pitch */
+ MMPLAYER_CREATE_ELEMENT(audiobin, MMPLAYER_A_PITCH, "pitch", "audio pitch", *bucket, player);
+ g_object_set(G_OBJECT(audiobin[MMPLAYER_A_PITCH].gst), "pitch", (gdouble)pitch_value, NULL);
+ } else {
+ LOGW("there is no pitch element");
+ }
+ }
- /* raw pad handling signal, audiosink will be added after getting signal */
- __mmplayer_add_signal_connection(player, G_OBJECT(audiobin[MMPLAYER_A_DEINTERLEAVE].gst),
- MM_PLAYER_SIGNAL_TYPE_AUTOPLUG, "pad-added", G_CALLBACK(__mmplayer_gst_audio_deinterleave_pad_added), (gpointer)player);
+ /* converter */
+ MMPLAYER_CREATE_ELEMENT(audiobin, MMPLAYER_A_CONV, "audioconvert", "audio converter", *bucket, player);
- } else {
+ /* replaygain volume */
+ MMPLAYER_CREATE_ELEMENT(audiobin, MMPLAYER_A_RGVOL, "rgvolume", "audio rgvolume", *bucket, player);
+ if (player->sound.rg_enable)
+ g_object_set(G_OBJECT(audiobin[MMPLAYER_A_RGVOL].gst), "enable-rgvolume", TRUE, NULL);
+ else
+ g_object_set(G_OBJECT(audiobin[MMPLAYER_A_RGVOL].gst), "enable-rgvolume", FALSE, NULL);
- /* normal playback */
- gint channels = 0;
+ /* resampler */
+ MMPLAYER_CREATE_ELEMENT(audiobin, MMPLAYER_A_RESAMPLER, player->ini.audioresampler_element, "audio resampler", *bucket, player);
- /* for logical volume control */
- MMPLAYER_CREATE_ELEMENT(audiobin, MMPLAYER_A_VOL, "volume", "volume", TRUE, player);
+ if (g_strrstr(player->ini.audiosink_element, "openalsink")) {
+ /* currently, only openalsink uses volume element */
+ MMPLAYER_CREATE_ELEMENT(audiobin, MMPLAYER_A_VOL, "volume", "volume", *bucket, player);
g_object_set(G_OBJECT(audiobin[MMPLAYER_A_VOL].gst), "volume", player->sound.volume, NULL);
if (player->sound.mute) {
LOGD("mute enabled");
g_object_set(G_OBJECT(audiobin[MMPLAYER_A_VOL].gst), "mute", player->sound.mute, NULL);
}
+ }
- /* check if multi-channels */
- if (player->pipeline->mainbin && player->pipeline->mainbin[MMPLAYER_M_DEMUX].gst) {
- GstPad *srcpad = NULL;
- GstCaps *caps = NULL;
-
- if ((srcpad = gst_element_get_static_pad(player->pipeline->mainbin[MMPLAYER_M_DEMUX].gst, "src"))) {
- if ((caps = gst_pad_query_caps(srcpad, NULL))) {
- /* MMPLAYER_LOG_GST_CAPS_TYPE(caps); */
- GstStructure *str = gst_caps_get_structure(caps, 0);
- if (str)
- gst_structure_get_int(str, "channels", &channels);
- gst_caps_unref(caps);
- }
- gst_object_unref(srcpad);
- }
- }
+ mm_attrs_get_int_by_name(player->attrs, "content_audio_channels", &channels);
- /* audio effect element. if audio effect is enabled */
- if ((strcmp(player->ini.audioeffect_element, ""))
- && (channels <= 2)
- && (player->ini.use_audio_effect_preset || player->ini.use_audio_effect_custom)) {
- MMPLAYER_CREATE_ELEMENT(audiobin, MMPLAYER_A_FILTER, player->ini.audioeffect_element, "audio effect filter", TRUE, player);
+ /* audio effect element. if audio effect is enabled */
+ if ((strcmp(player->ini.audioeffect_element, ""))
+ && (channels <= 2)
+ && (player->ini.use_audio_effect_preset || player->ini.use_audio_effect_custom)) {
+ MMPLAYER_CREATE_ELEMENT(audiobin, MMPLAYER_A_FILTER, player->ini.audioeffect_element, "audio effect filter", *bucket, player);
- LOGD("audio effect config. bypass = %d, effect type = %d", player->bypass_audio_effect, player->audio_effect_info.effect_type);
+ LOGD("audio effect config. bypass = %d, effect type = %d", player->bypass_audio_effect, player->audio_effect_info.effect_type);
- if ((!player->bypass_audio_effect)
- && (player->ini.use_audio_effect_preset || player->ini.use_audio_effect_custom)) {
- if (player->audio_effect_info.effect_type == MM_AUDIO_EFFECT_TYPE_CUSTOM) {
- if (!_mmplayer_audio_effect_custom_apply(player))
- LOGI("apply audio effect(custom) setting success");
- }
+ if ((!player->bypass_audio_effect)
+ && (player->ini.use_audio_effect_preset || player->ini.use_audio_effect_custom)) {
+ if (player->audio_effect_info.effect_type == MM_AUDIO_EFFECT_TYPE_CUSTOM) {
+ if (!_mmplayer_audio_effect_custom_apply(player))
+ LOGI("apply audio effect(custom) setting success");
}
-
- if ((strcmp(player->ini.audioeffect_element_custom, ""))
- && (player->set_mode.rich_audio))
- MMPLAYER_CREATE_ELEMENT(audiobin, MMPLAYER_A_FILTER_SEC, player->ini.audioeffect_element_custom, "audio effect filter custom", TRUE, player);
}
- /* create audio sink */
- LOGD("360 spherical %d, channels %d, ambisonic type %d, format %d, order %d",
- player->is_content_spherical, channels, player->video360_metadata.ambisonic_type,
- player->video360_metadata.ambisonic_format, player->video360_metadata.ambisonic_order);
+ if ((strcmp(player->ini.audioeffect_element_custom, ""))
+ && (player->set_mode.rich_audio)) {
+ MMPLAYER_CREATE_ELEMENT(audiobin, MMPLAYER_A_FILTER_SEC, player->ini.audioeffect_element_custom, "audio effect filter custom", *bucket, player);
+ }
+ }
- /* Note: qtdemux converts audio metadata defaults to openalsink defaults. */
- if (player->is_360_feature_enabled &&
- player->is_content_spherical &&
- channels == 4 &&
- player->video360_metadata.ambisonic_type == MMFILE_AMBISONIC_TYPE_PERIPHONIC &&
- player->video360_metadata.ambisonic_format == MMFILE_AMBISONIC_FORMAT_AMB &&
- player->video360_metadata.ambisonic_order == MMFILE_AMBISONIC_ORDER_FOA) {
+ /* create audio sink */
+ LOGD("spherical %d, channels %d, ambisonic type %d, format %d, order %d",
+ player->is_content_spherical, channels, player->video360_metadata.ambisonic_type,
+ player->video360_metadata.ambisonic_format, player->video360_metadata.ambisonic_order);
- strncpy(player->ini.audiosink_element, "openalsink", PLAYER_INI_MAX_STRLEN - 1);
+ /* Note: qtdemux converts audio metadata defaults to openalsink defaults. */
+ if (player->is_360_feature_enabled &&
+ player->is_content_spherical &&
+ channels == 4 &&
+ player->video360_metadata.ambisonic_type == MMFILE_AMBISONIC_TYPE_PERIPHONIC &&
+ player->video360_metadata.ambisonic_format == MMFILE_AMBISONIC_FORMAT_AMB &&
+ player->video360_metadata.ambisonic_order == MMFILE_AMBISONIC_ORDER_FOA) {
- MMPLAYER_CREATE_ELEMENT(audiobin, MMPLAYER_A_CONV_BFORMAT, "audioconvert", "audio-converter-bformat", TRUE, player);
+ strncpy(player->ini.audiosink_element, "openalsink", PLAYER_INI_MAX_STRLEN - 1);
- MMPLAYER_CREATE_ELEMENT(audiobin, MMPLAYER_A_CAPS_360, "capsfilter", "audio-caps-filter", TRUE, player);
- acaps = gst_caps_from_string(SPATIAL_AUDIO_CAPS);
- g_object_set(G_OBJECT(audiobin[MMPLAYER_A_CAPS_360].gst), "caps", acaps, NULL);
- gst_caps_unref(acaps);
+ MMPLAYER_CREATE_ELEMENT(audiobin, MMPLAYER_A_CONV_BFORMAT, "audioconvert", "audio-converter-bformat", *bucket, player);
- MMPLAYER_CREATE_ELEMENT(audiobin, MMPLAYER_A_SINK, "openalsink", "audiosink", TRUE, player);
+ MMPLAYER_CREATE_ELEMENT(audiobin, MMPLAYER_A_CAPS_360, "capsfilter", "audio-caps-filter", *bucket, player);
+ acaps = gst_caps_from_string(SPATIAL_AUDIO_CAPS);
+ g_object_set(G_OBJECT(audiobin[MMPLAYER_A_CAPS_360].gst), "caps", acaps, NULL);
+ gst_caps_unref(acaps);
- player->is_openal_plugin_used = TRUE;
- } else {
- if (player->is_360_feature_enabled && player->is_content_spherical)
- LOGW("Audio track isn't of the ambisonic type and can't be played back as a spatial sound.");
- MMPLAYER_CREATE_ELEMENT(audiobin, MMPLAYER_A_SINK, player->ini.audiosink_element, "audiosink", TRUE, player);
- }
+ MMPLAYER_CREATE_ELEMENT(audiobin, MMPLAYER_A_SINK, "openalsink", "audiosink", *bucket, player);
- if ((MMPLAYER_IS_RTSP_STREAMING(player)) ||
- (player->videodec_linked && player->ini.use_system_clock)) {
- LOGD("system clock will be used.");
- g_object_set(G_OBJECT(audiobin[MMPLAYER_A_SINK].gst), "provide-clock", FALSE, NULL);
- }
+ player->is_openal_plugin_used = TRUE;
+ } else {
+ if (player->is_360_feature_enabled && player->is_content_spherical)
+ LOGW("Audio track isn't of the ambisonic type and can't be played back as a spatial sound.");
+ MMPLAYER_CREATE_ELEMENT(audiobin, MMPLAYER_A_SINK, player->ini.audiosink_element, "audiosink", *bucket, player);
+ }
- if (g_strrstr(player->ini.audiosink_element, "pulsesink"))
- __mmplayer_gst_set_pulsesink_property(player, attrs);
- else if (g_strrstr(player->ini.audiosink_element, "openalsink"))
- __mmplayer_gst_set_openalsink_property(player);
+ if ((MMPLAYER_IS_RTSP_STREAMING(player)) ||
+ (player->videodec_linked && player->ini.use_system_clock)) {
+ LOGD("system clock will be used.");
+ g_object_set(G_OBJECT(audiobin[MMPLAYER_A_SINK].gst), "provide-clock", FALSE, NULL);
+ }
- /* 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_AUDIO_BASE_SINK_SLAVE_NONE, NULL);
+ if (g_strrstr(player->ini.audiosink_element, "pulsesink")) {
+ __mmplayer_gst_set_pulsesink_property(player);
+ } else if (g_strrstr(player->ini.audiosink_element, "openalsink")) {
+ if (__mmplayer_gst_set_openalsink_property(player) != MM_ERROR_NONE)
+ goto ERROR;
+ }
- sink_pad = gst_element_get_static_pad(audiobin[MMPLAYER_A_SINK].gst, "sink");
- __mmplayer_add_signal_connection(player, G_OBJECT(sink_pad), MM_PLAYER_SIGNAL_TYPE_AUDIOBIN,
- "notify::caps", G_CALLBACK(__mmplayer_gst_caps_notify_cb), (gpointer)player);
- gst_object_unref(GST_OBJECT(sink_pad));
+ /* 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_AUDIO_BASE_SINK_SLAVE_NONE, NULL);
- __mmplayer_add_sink(player, audiobin[MMPLAYER_A_SINK].gst);
- }
+ sink_pad = gst_element_get_static_pad(audiobin[MMPLAYER_A_SINK].gst, "sink");
+ _mmplayer_add_signal_connection(player, G_OBJECT(sink_pad), MM_PLAYER_SIGNAL_TYPE_AUDIOBIN,
+ "notify::caps", G_CALLBACK(__mmplayer_gst_caps_notify_cb), (gpointer)player);
+ gst_object_unref(GST_OBJECT(sink_pad));
- *bucket = element_bucket;
+ __mmplayer_add_sink(player, audiobin[MMPLAYER_A_SINK].gst);
MMPLAYER_FLEAVE();
return MM_ERROR_NONE;
-ERROR:
- g_list_free(element_bucket);
-
- *bucket = NULL;
+ERROR: /* MMPLAYER_CREATE_ELEMENT */
MMPLAYER_FLEAVE();
return MM_ERROR_PLAYER_INTERNAL;
}
static int
-__mmplayer_gst_create_audio_sink_bin(mm_player_t* player)
+__mmplayer_gst_make_audio_extract_sink(mmplayer_t *player, GList **bucket)
{
- MMPlayerGstElement *first_element = NULL;
- MMPlayerGstElement *audiobin = NULL;
- GstPad *pad = NULL;
- GstPad *ghostpad = NULL;
- GList *element_bucket = NULL;
- int i = 0;
+ mmplayer_gst_element_t *audiobin = NULL;
+ enum audio_element_id extract_sink_id = MMPLAYER_A_SINK;
+
+ gchar *dst_format = NULL;
+ int dst_len = 0;
+ int dst_samplerate = 0;
+ int dst_channels = 0;
+ GstCaps *caps = NULL;
+ char *caps_str = NULL;
MMPLAYER_FENTER();
- MMPLAYER_RETURN_VAL_IF_FAIL(player && player->pipeline, MM_ERROR_PLAYER_NOT_INITIALIZED);
+ MMPLAYER_RETURN_VAL_IF_FAIL(player && player->pipeline &&
+ player->pipeline->audiobin, MM_ERROR_PLAYER_NOT_INITIALIZED);
- /* alloc handles */
- audiobin = (MMPlayerGstElement*)g_malloc0(sizeof(MMPlayerGstElement) * MMPLAYER_A_NUM);
- if (!audiobin) {
- LOGE("failed to allocate memory for audiobin");
- return MM_ERROR_PLAYER_NO_FREE_SPACE;
- }
+ audiobin = player->pipeline->audiobin;
- /* create bin */
- audiobin[MMPLAYER_A_BIN].id = MMPLAYER_A_BIN;
- audiobin[MMPLAYER_A_BIN].gst = gst_bin_new("audiobin");
- if (!audiobin[MMPLAYER_A_BIN].gst) {
- LOGE("failed to create audiobin");
- goto ERROR;
- }
+ LOGD("make element for audio extract, option = 0x%X", player->audio_extract_opt);
- /* take it */
- player->pipeline->audiobin = audiobin;
+ /* audio bin structure according to the mmplayer_audio_extract_opt_e.
- /* create audio filters and audiosink */
- if (__mmplayer_gst_fill_audio_bucket(player, &element_bucket) != MM_ERROR_NONE)
- goto ERROR;
+ [case 1] extract interleave audio pcm without playback
+ : MM_PLAYER_AUDIO_EXTRACT_DEFAULT (sync)
+ MM_PLAYER_AUDIO_EXTRACT_NO_SYNC_WITH_CLOCK (non sync)
- /* adding created elements to bin */
- LOGD("adding created elements to bin");
- if (!__mmplayer_gst_element_add_bucket_to_bin(GST_BIN(audiobin[MMPLAYER_A_BIN].gst), element_bucket))
- goto ERROR;
+ * src - ... - aconv - resample - capsfilter - fakesink (sync or not)
- /* linking elements in the bucket by added order. */
- LOGD("Linking elements in the bucket by added order.");
- if (__mmplayer_gst_element_link_bucket(element_bucket) == -1)
- goto ERROR;
+ [case 2] deinterleave for each channel without playback
+ : MM_PLAYER_AUDIO_EXTRACT_DEINTERLEAVE (sync)
+ MM_PLAYER_AUDIO_EXTRACT_NO_SYNC_AND_DEINTERLEAVE (non sync)
- /* get first element's sinkpad for creating ghostpad */
- first_element = (MMPlayerGstElement *)element_bucket->data;
- if (!first_element) {
- LOGE("failed to get first elem");
- goto ERROR;
- }
+ * src - ... - aconv - resample - capsfilter - deinterleave - fakesink (sync or not)
+ - fakesink (sync or not)
+ - ... (sync or not)
- pad = gst_element_get_static_pad(GST_ELEMENT(first_element->gst), "sink");
- if (!pad) {
- LOGE("failed to get pad from first element of audiobin");
- goto ERROR;
- }
+ [case 3] [case 1(sync only)] + playback
+ : MM_PLAYER_AUDIO_EXTRACT_WITH_PLAYBACK
- ghostpad = gst_ghost_pad_new("sink", pad);
- if (!ghostpad) {
- LOGE("failed to create ghostpad");
- goto ERROR;
- }
+ * src - ... - tee - queue1 - playback path
+ - queue2 - [case1 pipeline with sync]
- if (!gst_element_add_pad(audiobin[MMPLAYER_A_BIN].gst, ghostpad)) {
- LOGE("failed to add ghostpad to audiobin");
- goto ERROR;
- }
+ [case 4] [case 2(sync only)] + playback
+ : MM_PLAYER_AUDIO_EXTRACT_DEINTERLEAVE_WITH_PLAYBACK
- gst_object_unref(pad);
+ * src - ... - tee - queue1 - playback path
+ - queue2 - [case2 pipeline with sync]
- g_list_free(element_bucket);
- MMPLAYER_FLEAVE();
+ */
- return MM_ERROR_NONE;
+ /* 1. create tee and playback path
+ 'tee' should be added at first to copy the decoded stream
+ */
+ if (player->audio_extract_opt & MM_PLAYER_AUDIO_EXTRACT_WITH_PLAYBACK) {
+ MMPLAYER_CREATE_ELEMENT(audiobin, MMPLAYER_A_TEE, "tee", "audio-tee", *bucket, player);
+ g_object_set(G_OBJECT(audiobin[MMPLAYER_A_TEE].gst), "num-src-pads", 2, NULL);
+
+ /* tee - path 1 : for playback path */
+ MMPLAYER_CREATE_ELEMENT(audiobin, MMPLAYER_A_TEE_Q1, "queue", "audio-tee-queue1", *bucket, player);
+ __mmplayer_gst_make_audio_playback_sink(player, bucket);
+
+ /* tee - path 2 : for extract path */
+ MMPLAYER_CREATE_ELEMENT(audiobin, MMPLAYER_A_TEE_Q2, "queue", "audio-tee-queue2", *bucket, player);
+ extract_sink_id = MMPLAYER_A_EXTRACT_SINK; /* there is another playback sink */
+ }
+
+ /* if there is tee, 'tee - path 2' is linked here */
+ /* converter */
+ MMPLAYER_CREATE_ELEMENT(audiobin, MMPLAYER_A_EXTRACT_CONV, "audioconvert", "audio-ext-conv", *bucket, player);
+
+ /* resampler */
+ MMPLAYER_CREATE_ELEMENT(audiobin, MMPLAYER_A_EXTRACT_RESAMPLER, player->ini.audioresampler_element, "audio-ext-resampler", *bucket, player);
+
+ /* 2. decide the extract pcm format */
+ mm_attrs_multiple_get(player->attrs, NULL,
+ MM_PLAYER_PCM_EXT_FORMAT, &dst_format, &dst_len,
+ MM_PLAYER_PCM_EXT_SAMPLERATE, &dst_samplerate,
+ MM_PLAYER_PCM_EXT_CHANNELS, &dst_channels,
+ NULL);
+
+ LOGD("required extract pcm format - format: %s(%d), samplerate : %d, channel: %d",
+ dst_format, dst_len, dst_samplerate, dst_channels);
+
+ if (dst_format == NULL || dst_len == 0 || dst_samplerate == 0 || dst_channels == 0) {
+ mm_attrs_multiple_get(player->attrs, NULL,
+ "content_audio_format", &dst_format, &dst_len, /* get string and len */
+ "content_audio_samplerate", &dst_samplerate,
+ "content_audio_channels", &dst_channels,
+ NULL);
+
+ LOGD("apply the decoded pcm format - format: %s(%d), samplerate : %d, channel: %d",
+ dst_format, dst_len, dst_samplerate, dst_channels);
+
+ /* If there is no enough information, set it to platform default value. */
+ if (dst_format == NULL || _mmplayer_convert_audio_pcm_str_to_media_format_mime(dst_format) == MEDIA_FORMAT_MAX) {
+ LOGD("set platform default format");
+ dst_format = DEFAULT_PCM_OUT_FORMAT;
+ }
+ if (dst_samplerate <= 0) dst_samplerate = DEFAULT_PCM_OUT_SAMPLERATE;
+ if (dst_channels <= 0) dst_channels = DEFAULT_PCM_OUT_CHANNEL;
+ }
+
+ /* 3. create capsfilter */
+ MMPLAYER_CREATE_ELEMENT(audiobin, MMPLAYER_A_EXTRACT_CAPS, "capsfilter", "audio-ext-caps", *bucket, player);
+ caps = gst_caps_new_simple("audio/x-raw",
+ "format", G_TYPE_STRING, dst_format,
+ "rate", G_TYPE_INT, dst_samplerate,
+ "channels", G_TYPE_INT, dst_channels,
+ NULL);
+
+ caps_str = gst_caps_to_string(caps);
+ LOGD("new caps : %s", caps_str);
+
+ g_object_set(GST_ELEMENT(audiobin[MMPLAYER_A_EXTRACT_CAPS].gst), "caps", caps, NULL);
+
+ /* clean */
+ gst_caps_unref(caps);
+ MMPLAYER_FREEIF(caps_str);
+
+ /* 4-1. create deinterleave to extract pcm for each channel */
+ if (player->audio_extract_opt & MM_PLAYER_AUDIO_EXTRACT_DEINTERLEAVE) {
+ MMPLAYER_CREATE_ELEMENT(audiobin, MMPLAYER_A_EXTRACT_DEINTERLEAVE, "deinterleave", "deinterleave", *bucket, player);
+ g_object_set(G_OBJECT(audiobin[MMPLAYER_A_EXTRACT_DEINTERLEAVE].gst), "keep-positions", TRUE, NULL);
+
+ /* audiosink will be added after getting signal for each channel */
+ _mmplayer_add_signal_connection(player, G_OBJECT(audiobin[MMPLAYER_A_EXTRACT_DEINTERLEAVE].gst),
+ MM_PLAYER_SIGNAL_TYPE_AUTOPLUG, "pad-added", G_CALLBACK(__mmplayer_gst_audio_deinterleave_pad_added), (gpointer)player);
+ _mmplayer_add_signal_connection(player, G_OBJECT(audiobin[MMPLAYER_A_EXTRACT_DEINTERLEAVE].gst),
+ MM_PLAYER_SIGNAL_TYPE_AUTOPLUG, "no-more-pads", G_CALLBACK(__mmplayer_gst_audio_deinterleave_no_more_pads), (gpointer)player);
+ player->no_more_pad = FALSE;
+ } else {
+ /* 4-2. create fakesink to extract interlevaed pcm */
+ LOGD("add audio fakesink for interleaved audio");
+ MMPLAYER_CREATE_ELEMENT(audiobin, extract_sink_id, "fakesink", "fakeaudiosink", *bucket, player);
+ if (!(player->audio_extract_opt & MM_PLAYER_AUDIO_EXTRACT_NO_SYNC_WITH_CLOCK))
+ g_object_set(G_OBJECT(audiobin[extract_sink_id].gst), "sync", TRUE, NULL);
+ g_object_set(G_OBJECT(audiobin[extract_sink_id].gst), "signal-handoffs", TRUE, NULL);
+
+ _mmplayer_add_signal_connection(player,
+ G_OBJECT(audiobin[extract_sink_id].gst),
+ MM_PLAYER_SIGNAL_TYPE_AUDIOBIN,
+ "handoff",
+ G_CALLBACK(__mmplayer_audio_stream_decoded_render_cb),
+ (gpointer)player);
+
+ __mmplayer_add_sink(player, audiobin[extract_sink_id].gst);
+ }
+
+ MMPLAYER_FLEAVE();
+ return MM_ERROR_NONE;
+
+ERROR: /* MMPLAYER_CREATE_ELEMENT */
+ MMPLAYER_FLEAVE();
+ return MM_ERROR_PLAYER_INTERNAL;
+}
+
+static int
+__mmplayer_gst_make_audio_bin_element(mmplayer_t *player, GList **bucket)
+{
+ int ret = MM_ERROR_NONE;
+ mmplayer_gst_element_t *audiobin = NULL;
+ GList *element_bucket = NULL;
+
+ MMPLAYER_FENTER();
+ MMPLAYER_RETURN_VAL_IF_FAIL(player && player->pipeline &&
+ player->pipeline->audiobin, MM_ERROR_PLAYER_NOT_INITIALIZED);
+
+ audiobin = player->pipeline->audiobin;
+
+ if (player->build_audio_offload) { /* skip all the audio filters */
+ LOGD("create audio offload sink : %s", player->ini.audio_offload_sink_element);
+
+ MMPLAYER_CREATE_ELEMENT(audiobin, MMPLAYER_A_SINK, player->ini.audio_offload_sink_element, "audiosink", element_bucket, player);
+ g_object_set(G_OBJECT(audiobin[MMPLAYER_A_SINK].gst), "sync", TRUE,
+ "volume", player->sound.volume, "mute", player->sound.mute, NULL);
+
+ __mmplayer_add_sink(player, audiobin[MMPLAYER_A_SINK].gst);
+ goto DONE;
+ }
+
+ /* FIXME: need to mention the supportable condition at API reference */
+ if (player->audio_decoded_cb && (!MMPLAYER_IS_RTSP_STREAMING(player)))
+ ret = __mmplayer_gst_make_audio_extract_sink(player, &element_bucket);
+ else
+ ret = __mmplayer_gst_make_audio_playback_sink(player, &element_bucket);
+
+ if (ret != MM_ERROR_NONE)
+ goto ERROR;
+DONE:
+ LOGD("success to make audio bin element");
+ *bucket = element_bucket;
+
+ MMPLAYER_FLEAVE();
+ return MM_ERROR_NONE;
+
+ERROR:
+ LOGE("failed to make audio bin element");
+ g_list_free(element_bucket);
+
+ *bucket = NULL;
+ MMPLAYER_FLEAVE();
+ return MM_ERROR_PLAYER_INTERNAL;
+}
+
+static int
+__mmplayer_gst_create_audio_sink_bin(mmplayer_t *player)
+{
+ mmplayer_gst_element_t *first_element = NULL;
+ mmplayer_gst_element_t *audiobin = NULL;
+ GstPad *pad = NULL;
+ GstPad *ghostpad = NULL;
+ GList *element_bucket = NULL;
+ int i = 0;
+
+ MMPLAYER_FENTER();
+ MMPLAYER_RETURN_VAL_IF_FAIL(player && player->pipeline, MM_ERROR_PLAYER_NOT_INITIALIZED);
+
+ /* alloc handles */
+ audiobin = (mmplayer_gst_element_t *)g_try_malloc0(sizeof(mmplayer_gst_element_t) * MMPLAYER_A_NUM);
+ if (!audiobin) {
+ LOGE("failed to allocate memory for audiobin");
+ return MM_ERROR_PLAYER_NO_FREE_SPACE;
+ }
+
+ /* create bin */
+ audiobin[MMPLAYER_A_BIN].id = MMPLAYER_A_BIN;
+ audiobin[MMPLAYER_A_BIN].gst = gst_bin_new("audiobin");
+ if (!audiobin[MMPLAYER_A_BIN].gst) {
+ LOGE("failed to create audiobin");
+ goto ERROR;
+ }
+
+ /* take it */
+ player->pipeline->audiobin = audiobin;
+
+ /* create audio filters and audiosink */
+ if (__mmplayer_gst_make_audio_bin_element(player, &element_bucket) != MM_ERROR_NONE)
+ goto ERROR;
+
+ /* adding created elements to bin */
+ LOGD("adding created elements to bin");
+ if (!_mmplayer_gst_element_add_bucket_to_bin(GST_BIN(audiobin[MMPLAYER_A_BIN].gst), element_bucket))
+ goto ERROR;
+
+ /* linking elements in the bucket by added order. */
+ LOGD("Linking elements in the bucket by added order.");
+ if (_mmplayer_gst_element_link_bucket(element_bucket) == -1)
+ goto ERROR;
+
+ /* get first element's sinkpad for creating ghostpad */
+ first_element = (mmplayer_gst_element_t *)element_bucket->data;
+ if (!first_element) {
+ LOGE("failed to get first elem");
+ goto ERROR;
+ }
+
+ pad = gst_element_get_static_pad(GST_ELEMENT(first_element->gst), "sink");
+ if (!pad) {
+ LOGE("failed to get pad from first element of audiobin");
+ goto ERROR;
+ }
+
+ ghostpad = gst_ghost_pad_new("sink", pad);
+ if (!ghostpad) {
+ LOGE("failed to create ghostpad");
+ goto ERROR;
+ }
+
+ if (!gst_element_add_pad(audiobin[MMPLAYER_A_BIN].gst, ghostpad)) {
+ LOGE("failed to add ghostpad to audiobin");
+ goto ERROR;
+ }
+
+ gst_object_unref(pad);
+
+ g_list_free(element_bucket);
+ MMPLAYER_FLEAVE();
+
+ return MM_ERROR_NONE;
ERROR:
LOGD("ERROR : releasing audiobin");
for (i = 1; i < MMPLAYER_A_NUM; i++) {
/* NOTE : skip bin */
if (audiobin[i].gst) {
- GstObject* parent = NULL;
+ GstObject *parent = NULL;
parent = gst_element_get_parent(audiobin[i].gst);
if (!parent) {
return MM_ERROR_PLAYER_INTERNAL;
}
-static guint32 _mmplayer_convert_fourcc_string_to_value(const gchar* format_name)
+static guint32
+_mmplayer_convert_fourcc_string_to_value(const gchar *format_name)
{
return format_name[0] | (format_name[1] << 8) | (format_name[2] << 16) | (format_name[3] << 24);
}
-int _mmplayer_video_stream_release_bo(mm_player_t* player, void* bo)
+int
+_mmplayer_video_stream_release_bo(mmplayer_t *player, void *bo)
{
int ret = MM_ERROR_NONE;
GList *l = NULL;
if (player->video_bo_list) {
for (l = g_list_first(player->video_bo_list); l; l = g_list_next(l)) {
- mm_player_video_bo_info_t* tmp = (mm_player_video_bo_info_t *)l->data;
+ mmplayer_video_bo_info_t *tmp = (mmplayer_video_bo_info_t *)l->data;
if (tmp && tmp->bo == bo) {
tmp->used = FALSE;
LOGD("release bo %p", bo);
LOGW("failed to find bo %p", bo);
return ret;
}
-
static void
-__mmplayer_video_stream_destroy_bo_list(mm_player_t* player)
+__mmplayer_video_stream_bo_list_free(mmplayer_video_bo_info_t *tmp)
{
- GList *l = NULL;
+ if (!tmp)
+ return;
+
+ if (tmp->bo)
+ tbm_bo_unref(tmp->bo);
+ g_free(tmp);
+}
+static void
+__mmplayer_video_stream_destroy_bo_list(mmplayer_t *player)
+{
MMPLAYER_FENTER();
MMPLAYER_RETURN_IF_FAIL(player);
MMPLAYER_VIDEO_BO_LOCK(player);
if (player->video_bo_list) {
LOGD("destroy video_bo_list : %d", g_list_length(player->video_bo_list));
- for (l = g_list_first(player->video_bo_list); l; l = g_list_next(l)) {
- mm_player_video_bo_info_t* tmp = (mm_player_video_bo_info_t *)l->data;
- if (tmp) {
- if (tmp->bo)
- tbm_bo_unref(tmp->bo);
- g_free(tmp);
- }
- }
- g_list_free(player->video_bo_list);
+ g_list_free_full(player->video_bo_list, (GDestroyNotify)__mmplayer_video_stream_bo_list_free);
player->video_bo_list = NULL;
}
player->video_bo_size = 0;
return;
}
-static void*
-__mmplayer_video_stream_get_bo(mm_player_t* player, int size)
+static void *
+__mmplayer_video_stream_get_bo(mmplayer_t *player, int size)
{
GList *l = NULL;
MMPLAYER_RETURN_VAL_IF_FAIL(player, NULL);
}
for (; idx < player->ini.num_of_video_bo; idx++) {
- mm_player_video_bo_info_t* bo_info = g_new(mm_player_video_bo_info_t, 1);
+ mmplayer_video_bo_info_t *bo_info = g_new(mmplayer_video_bo_info_t, 1);
if (!bo_info) {
LOGE("Fail to alloc bo_info.");
break;
bo_info->bo = tbm_bo_alloc(player->bufmgr, size, TBM_BO_DEFAULT);
if (!bo_info->bo) {
LOGE("Fail to tbm_bo_alloc.");
- g_free(bo_info);
+ MMPLAYER_FREEIF(bo_info);
break;
}
bo_info->used = FALSE;
}
/* update video num buffers */
- player->video_num_buffers = idx;
- if (idx == player->ini.num_of_video_bo)
- player->video_extra_num_buffers = player->ini.num_of_video_bo/2;
+ LOGD("video_num_buffers : %d", idx);
+ mm_player_set_attribute((MMHandleType)player, NULL,
+ MM_PLAYER_VIDEO_BUFFER_TOTAL_SIZE, idx,
+ MM_PLAYER_VIDEO_BUFFER_EXTRA_SIZE, MAX(DEFAULT_NUM_OF_V_OUT_BUFFER, (idx / 2)),
+ NULL);
if (idx == 0) {
MMPLAYER_VIDEO_BO_UNLOCK(player);
return NULL;
}
-
- LOGD("Num of video buffers(%d/%d)", player->video_num_buffers, player->video_extra_num_buffers);
}
while (TRUE) {
/* get bo from list*/
for (l = g_list_first(player->video_bo_list); l; l = g_list_next(l)) {
- mm_player_video_bo_info_t* tmp = (mm_player_video_bo_info_t *)l->data;
+ mmplayer_video_bo_info_t *tmp = (mmplayer_video_bo_info_t *)l->data;
if (tmp && (tmp->used == FALSE)) {
LOGD("found bo %p to use", tmp->bo);
tmp->used = TRUE;
if (player->ini.video_bo_timeout <= 0) {
MMPLAYER_VIDEO_BO_WAIT(player);
} else {
- gint64 timeout = g_get_monotonic_time() + player->ini.video_bo_timeout*G_TIME_SPAN_SECOND;
+ gint64 timeout = g_get_monotonic_time() + player->ini.video_bo_timeout * G_TIME_SPAN_SECOND;
ret = MMPLAYER_VIDEO_BO_WAIT_UNTIL(player, timeout);
}
continue;
}
static void
-__mmplayer_video_stream_decoded_preroll_cb(GstElement* object, GstBuffer *buffer, GstPad *pad, gpointer data)
+__mmplayer_video_stream_decoded_preroll_cb(GstElement *object, GstBuffer *buffer, GstPad *pad, gpointer data)
{
- mm_player_t* player = (mm_player_t*)data;
+ mmplayer_t *player = (mmplayer_t *)data;
MMPLAYER_FENTER();
- MMPLAYER_RETURN_IF_FAIL(player && player->video_stream_cb);
+ MMPLAYER_RETURN_IF_FAIL(player && player->video_decoded_cb);
/* send prerolled pkt */
- player->video_stream_prerolled = FALSE;
+ player->video_stream_prerolled = false;
__mmplayer_video_stream_decoded_render_cb(object, buffer, pad, data);
/* not to send prerolled pkt again */
- player->video_stream_prerolled = TRUE;
+ player->video_stream_prerolled = true;
}
static void
-__mmplayer_video_stream_decoded_render_cb(GstElement* object, GstBuffer *buffer, GstPad *pad, gpointer data)
+__mmplayer_video_stream_decoded_render_cb(GstElement *object, GstBuffer *buffer, GstPad *pad, gpointer data)
{
- mm_player_t* player = (mm_player_t*)data;
- MMPlayerVideoStreamDataType *stream = NULL;
+ mmplayer_t *player = (mmplayer_t *)data;
+ mmplayer_video_decoded_data_info_t *stream = NULL;
GstMemory *mem = NULL;
MMPLAYER_FENTER();
MMPLAYER_RETURN_IF_FAIL(player);
- MMPLAYER_RETURN_IF_FAIL(player->video_stream_cb);
+ MMPLAYER_RETURN_IF_FAIL(player->video_decoded_cb);
if (player->video_stream_prerolled) {
- player->video_stream_prerolled = FALSE;
+ player->video_stream_prerolled = false;
LOGD("skip the prerolled pkt not to send it again");
return;
}
return;
}
- __mmplayer_get_video_angle(player, NULL, &stream->orientation);
+ _mmplayer_get_video_angle(player, NULL, &stream->orientation);
/* set size and timestamp */
mem = gst_buffer_peek_memory(buffer, 0);
/* check zero-copy */
if (player->set_mode.video_zc &&
- player->set_mode.media_packet_video_stream &&
+ player->set_mode.video_export &&
gst_is_tizen_memory(mem)) {
__mmplayer_zerocopy_set_stride_elevation_bo(stream, mem);
stream->internal_buffer = gst_buffer_ref(buffer);
goto ERROR;
}
- if (!player->video_stream_cb(stream, player->video_stream_cb_user_param)) {
- LOGE("failed to send video stream data.");
+ if (!player->video_decoded_cb(stream, player->video_decoded_cb_user_param)) {
+ LOGE("failed to send video decoded data.");
goto ERROR;
}
if (stream->bo[0])
_mmplayer_video_stream_release_bo(player, stream->bo[0]);
}
- g_free(stream);
+ MMPLAYER_FREEIF(stream);
return;
}
static void
-__mmplayer_gst_set_video360_property(mm_player_t *player)
+__mmplayer_gst_set_video360_property(mmplayer_t *player)
{
- MMPlayerGstElement *videobin = NULL;
+ mmplayer_gst_element_t *videobin = NULL;
MMPLAYER_FENTER();
MMPLAYER_RETURN_IF_FAIL(player && player->pipeline && player->pipeline->videobin);
player->video360_pitch_radians <= M_PI_2 &&
player->video360_pitch_radians >= -M_PI_2) {
g_object_set(G_OBJECT(videobin[MMPLAYER_V_360].gst),
- "pose-yaw", (int) (player->video360_yaw_radians * 180.0 / M_PI),
- "pose-pitch", (int) (player->video360_pitch_radians * 180.0 / M_PI), NULL);
+ "pose-yaw", (int)(player->video360_yaw_radians * 180.0 / M_PI),
+ "pose-pitch", (int)(player->video360_pitch_radians * 180.0 / M_PI), NULL);
} else if (player->video360_metadata.init_view_heading || player->video360_metadata.init_view_pitch) {
g_object_set(G_OBJECT(videobin[MMPLAYER_V_360].gst),
"pose-yaw", player->video360_metadata.init_view_heading,
}
static int
-__mmplayer_gst_create_video_filters(mm_player_t *player, MMDisplaySurfaceType surface_type, GList **bucket)
+__mmplayer_gst_create_video_filters(mmplayer_t *player, MMDisplaySurfaceType surface_type, GList **bucket)
{
gchar *video_csc = "videoconvert"; /* default colorspace converter */
GList *element_bucket = NULL;
/* create video360 filter */
if (player->is_360_feature_enabled && player->is_content_spherical) {
LOGD("create video360 element");
- MMPLAYER_CREATE_ELEMENT(player->pipeline->videobin, MMPLAYER_V_360, "video360", "video-360", TRUE, player);
+ MMPLAYER_CREATE_ELEMENT(player->pipeline->videobin, MMPLAYER_V_360, "video360", "video-360", element_bucket, player);
__mmplayer_gst_set_video360_property(player);
goto EXIT;
}
/* in case of sw codec & overlay surface type, except 360 playback.
* if libav video decoder is selected, videoconvert is required to render the shm wl-buffer which support RGB only via tizenwlsink. */
LOGD("create video converter: %s", video_csc);
- MMPLAYER_CREATE_ELEMENT(player->pipeline->videobin, MMPLAYER_V_CONV, video_csc, "video converter", TRUE, player);
-
- /* set video rotator */
- MMPLAYER_CREATE_ELEMENT(player->pipeline->videobin, MMPLAYER_V_FLIP, "videoflip", "video rotator", TRUE, player);
+ MMPLAYER_CREATE_ELEMENT(player->pipeline->videobin, MMPLAYER_V_CONV, video_csc, "video converter", element_bucket, player);
EXIT:
*bucket = element_bucket;
return MM_ERROR_PLAYER_INTERNAL;
}
-static gchar*
-__mmplayer_get_videosink_factory_name(mm_player_t *player, MMDisplaySurfaceType surface_type)
+static gchar *
+__mmplayer_get_videosink_factory_name(mmplayer_t *player, MMDisplaySurfaceType surface_type)
{
gchar *factory_name = NULL;
}
static int
-__mmplayer_gst_set_videosink_property(mm_player_t *player, MMDisplaySurfaceType surface_type)
+__mmplayer_gst_set_videosink_property(mmplayer_t *player, MMDisplaySurfaceType surface_type)
{
gchar *factory_name = NULL;
- MMPlayerGstElement *videobin = NULL;
+ mmplayer_gst_element_t *videobin = NULL;
MMHandleType attrs;
int gapless = 0;
return MM_ERROR_PLAYER_INTERNAL;
}
- LOGD("surface type %d, videosink factory name is %s", surface_type, factory_name);
if (surface_type == MM_DISPLAY_SURFACE_OVERLAY) {
bool use_tbm = (player->set_mode.video_zc || (player->is_360_feature_enabled && player->is_content_spherical));
- if (!use_tbm) {
- /* support shard memory with S/W codec on HawkP */
- if (strncmp(factory_name, "tizenwlsink", strlen(factory_name)) == 0) {
- g_object_set(player->pipeline->videobin[MMPLAYER_V_SINK].gst,
- "use-tbm", use_tbm, NULL);
- }
+ if (strncmp(factory_name, "tizenwlsink", strlen(factory_name)) == 0) {
+ g_object_set(player->pipeline->videobin[MMPLAYER_V_SINK].gst,
+ "use-tbm", use_tbm, NULL);
}
+
+ if (_mmplayer_update_video_overlay_param(player, "update_all_param") != MM_ERROR_NONE)
+ return MM_ERROR_PLAYER_INTERNAL;
+
+ LOGI("videosink factory name is %s use-tbm : %d", factory_name, use_tbm);
+
} else {
g_object_set(G_OBJECT(player->pipeline->videobin[MMPLAYER_V_SINK].gst),
"sync", TRUE, "max-lateness", FAKE_SINK_MAX_LATENESS, NULL);
}
- mm_attrs_get_int_by_name(attrs, "gapless_mode", &gapless);
+ mm_attrs_get_int_by_name(attrs, MM_PLAYER_GAPLESS_MODE, &gapless);
if (gapless > 0) {
LOGD("disable last-sample");
g_object_set(player->pipeline->videobin[MMPLAYER_V_SINK].gst, "enable-last-sample", FALSE, NULL);
}
- if (player->set_mode.media_packet_video_stream) {
+ if (player->set_mode.video_export) {
int enable = 0;
mm_attrs_get_int_by_name(player->attrs, "enable_video_decoded_cb", &enable);
if (enable || (surface_type == MM_DISPLAY_SURFACE_REMOTE) || (surface_type == MM_DISPLAY_SURFACE_NULL))
g_object_set(G_OBJECT(player->pipeline->videobin[MMPLAYER_V_SINK].gst), "signal-handoffs", TRUE, NULL);
- __mmplayer_add_signal_connection(player,
+ _mmplayer_add_signal_connection(player,
G_OBJECT(player->pipeline->videobin[MMPLAYER_V_SINK].gst),
MM_PLAYER_SIGNAL_TYPE_VIDEOBIN,
"handoff",
G_CALLBACK(__mmplayer_video_stream_decoded_render_cb),
(gpointer)player);
- __mmplayer_add_signal_connection(player,
+ _mmplayer_add_signal_connection(player,
G_OBJECT(player->pipeline->videobin[MMPLAYER_V_SINK].gst),
MM_PLAYER_SIGNAL_TYPE_VIDEOBIN,
"preroll-handoff",
(gpointer)player);
}
- if (_mmplayer_update_video_param(player, "update_all_param") != MM_ERROR_NONE)
- return MM_ERROR_PLAYER_INTERNAL;
-
if (videobin[MMPLAYER_V_SINK].gst) {
GstPad *sink_pad = NULL;
sink_pad = gst_element_get_static_pad(videobin[MMPLAYER_V_SINK].gst, "sink");
if (sink_pad) {
- __mmplayer_add_signal_connection(player, G_OBJECT(sink_pad), MM_PLAYER_SIGNAL_TYPE_VIDEOBIN,
+ _mmplayer_add_signal_connection(player, G_OBJECT(sink_pad), MM_PLAYER_SIGNAL_TYPE_VIDEOBIN,
"notify::caps", G_CALLBACK(__mmplayer_gst_caps_notify_cb), (gpointer)player);
gst_object_unref(GST_OBJECT(sink_pad));
} else {
* - video overlay surface(arm/x86) : tizenwlsink
*/
static int
-__mmplayer_gst_create_video_sink_bin(mm_player_t* player, GstCaps* caps, MMDisplaySurfaceType surface_type)
+__mmplayer_gst_create_video_sink_bin(mmplayer_t *player, GstCaps *caps, MMDisplaySurfaceType surface_type)
{
GstPad *pad = NULL;
GList *element_bucket = NULL;
- MMPlayerGstElement *first_element = NULL;
- MMPlayerGstElement *videobin = NULL;
+ mmplayer_gst_element_t *first_element = NULL;
+ mmplayer_gst_element_t *videobin = NULL;
gchar *videosink_factory_name = NULL;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player && player->pipeline, MM_ERROR_PLAYER_NOT_INITIALIZED);
/* alloc handles */
- videobin = (MMPlayerGstElement*)g_malloc0(sizeof(MMPlayerGstElement) * MMPLAYER_V_NUM);
+ videobin = (mmplayer_gst_element_t *)g_try_malloc0(sizeof(mmplayer_gst_element_t) * MMPLAYER_V_NUM);
if (!videobin)
return MM_ERROR_PLAYER_NO_FREE_SPACE;
goto ERROR;
videosink_factory_name = __mmplayer_get_videosink_factory_name(player, surface_type);
- MMPLAYER_CREATE_ELEMENT(videobin, MMPLAYER_V_SINK, videosink_factory_name, "videosink", TRUE, player);
+ MMPLAYER_CREATE_ELEMENT(videobin, MMPLAYER_V_SINK, videosink_factory_name, "videosink", element_bucket, player);
/* additional setting for sink plug-in */
if (__mmplayer_gst_set_videosink_property(player, surface_type) != MM_ERROR_NONE) {
__mmplayer_add_sink(player, videobin[MMPLAYER_V_SINK].gst);
/* adding created elements to bin */
- if (!__mmplayer_gst_element_add_bucket_to_bin(GST_BIN(videobin[MMPLAYER_V_BIN].gst), element_bucket)) {
+ if (!_mmplayer_gst_element_add_bucket_to_bin(GST_BIN(videobin[MMPLAYER_V_BIN].gst), element_bucket)) {
LOGE("failed to add elements");
goto ERROR;
}
/* Linking elements in the bucket by added order */
- if (__mmplayer_gst_element_link_bucket(element_bucket) == -1) {
+ if (_mmplayer_gst_element_link_bucket(element_bucket) == -1) {
LOGE("failed to link elements");
goto ERROR;
}
/* get first element's sinkpad for creating ghostpad */
- first_element = (MMPlayerGstElement *)element_bucket->data;
+ first_element = (mmplayer_gst_element_t *)element_bucket->data;
if (!first_element) {
LOGE("failed to get first element from bucket");
goto ERROR;
return MM_ERROR_PLAYER_INTERNAL;
}
-static int __mmplayer_gst_create_plain_text_elements(mm_player_t* player)
+static int
+__mmplayer_gst_create_plain_text_elements(mmplayer_t *player)
{
GList *element_bucket = NULL;
- MMPlayerGstElement *textbin = player->pipeline->textbin;
+ mmplayer_gst_element_t *textbin = player->pipeline->textbin;
- MMPLAYER_CREATE_ELEMENT(textbin, MMPLAYER_T_QUEUE, "queue", "text_queue", TRUE, player);
- MMPLAYER_CREATE_ELEMENT(textbin, MMPLAYER_T_IDENTITY, "identity", "text_identity", TRUE, player);
+ MMPLAYER_CREATE_ELEMENT(textbin, MMPLAYER_T_QUEUE, "queue", "text_queue", element_bucket, player);
+ MMPLAYER_CREATE_ELEMENT(textbin, MMPLAYER_T_IDENTITY, "identity", "text_identity", element_bucket, player);
g_object_set(G_OBJECT(textbin[MMPLAYER_T_IDENTITY].gst),
"signal-handoffs", FALSE,
NULL);
- MMPLAYER_CREATE_ELEMENT(textbin, MMPLAYER_T_FAKE_SINK, "fakesink", "text_fakesink", TRUE, player);
- __mmplayer_add_signal_connection(player,
+ MMPLAYER_CREATE_ELEMENT(textbin, MMPLAYER_T_FAKE_SINK, "fakesink", "text_fakesink", element_bucket, player);
+ _mmplayer_add_signal_connection(player,
G_OBJECT(textbin[MMPLAYER_T_FAKE_SINK].gst),
MM_PLAYER_SIGNAL_TYPE_TEXTBIN,
"handoff",
"signal-handoffs", TRUE, "max-lateness", FAKE_SINK_MAX_LATENESS, NULL);
if (!player->play_subtitle) {
- LOGD("add textbin sink as sink element of whole pipeline.\n");
+ LOGD("add textbin sink as sink element of whole pipeline.");
__mmplayer_add_sink(player, GST_ELEMENT(textbin[MMPLAYER_T_FAKE_SINK].gst));
}
/* adding created elements to bin */
- LOGD("adding created elements to bin\n");
- if (!__mmplayer_gst_element_add_bucket_to_bin(GST_BIN(textbin[MMPLAYER_T_BIN].gst), element_bucket)) {
- LOGE("failed to add elements\n");
+ LOGD("adding created elements to bin");
+ if (!_mmplayer_gst_element_add_bucket_to_bin(GST_BIN(textbin[MMPLAYER_T_BIN].gst), element_bucket)) {
+ LOGE("failed to add elements");
goto ERROR;
}
GST_OBJECT_FLAG_UNSET(textbin[MMPLAYER_T_FAKE_SINK].gst, GST_ELEMENT_FLAG_SINK);
/* linking elements in the bucket by added order. */
- LOGD("Linking elements in the bucket by added order.\n");
- if (__mmplayer_gst_element_link_bucket(element_bucket) == -1) {
- LOGE("failed to link elements\n");
+ LOGD("Linking elements in the bucket by added order.");
+ if (_mmplayer_gst_element_link_bucket(element_bucket) == -1) {
+ LOGE("failed to link elements");
goto ERROR;
}
gst_object_unref(pad);
if (!ghostpad) {
- LOGE("failed to create ghostpad of textbin\n");
+ LOGE("failed to create ghostpad of textbin");
goto ERROR;
}
if (!gst_element_add_pad(textbin[MMPLAYER_T_BIN].gst, ghostpad)) {
- LOGE("failed to add ghostpad to textbin\n");
+ LOGE("failed to add ghostpad to textbin");
gst_object_unref(ghostpad);
goto ERROR;
}
return MM_ERROR_PLAYER_INTERNAL;
}
-static int __mmplayer_gst_create_text_sink_bin(mm_player_t* player)
+static int
+__mmplayer_gst_create_text_sink_bin(mmplayer_t *player)
{
- MMPlayerGstElement *textbin = NULL;
+ mmplayer_gst_element_t *textbin = NULL;
GList *element_bucket = NULL;
int surface_type = 0;
gint i = 0;
MMPLAYER_RETURN_VAL_IF_FAIL(player && player->pipeline, MM_ERROR_PLAYER_NOT_INITIALIZED);
/* alloc handles */
- textbin = (MMPlayerGstElement*)g_malloc0(sizeof(MMPlayerGstElement) * MMPLAYER_T_NUM);
+ textbin = (mmplayer_gst_element_t *)g_try_malloc0(sizeof(mmplayer_gst_element_t) * MMPLAYER_T_NUM);
if (!textbin) {
- LOGE("failed to allocate memory for textbin\n");
+ LOGE("failed to allocate memory for textbin");
return MM_ERROR_PLAYER_NO_FREE_SPACE;
}
textbin[MMPLAYER_T_BIN].id = MMPLAYER_T_BIN;
textbin[MMPLAYER_T_BIN].gst = gst_bin_new("textbin");
if (!textbin[MMPLAYER_T_BIN].gst) {
- LOGE("failed to create textbin\n");
+ LOGE("failed to create textbin");
goto ERROR;
}
case MM_DISPLAY_SURFACE_NULL:
case MM_DISPLAY_SURFACE_REMOTE:
if (__mmplayer_gst_create_plain_text_elements(player) != MM_ERROR_NONE) {
- LOGE("failed to make plain text elements\n");
+ LOGE("failed to make plain text elements");
goto ERROR;
}
break;
ERROR:
- LOGD("ERROR : releasing textbin\n");
+ LOGD("ERROR : releasing textbin");
g_list_free(element_bucket);
for (i = 1; i < MMPLAYER_T_NUM; i++) {
/* NOTE : skip bin */
if (textbin[i].gst) {
- GstObject* parent = NULL;
+ GstObject *parent = NULL;
parent = gst_element_get_parent(textbin[i].gst);
if (!parent) {
if (textbin[MMPLAYER_T_BIN].gst)
gst_object_unref(GST_OBJECT(textbin[MMPLAYER_T_BIN].gst));
- MMPLAYER_FREEIF(player->pipeline->textbin);
+ MMPLAYER_FREEIF(textbin);
player->pipeline->textbin = NULL;
MMPLAYER_FLEAVE();
return MM_ERROR_PLAYER_INTERNAL;
}
-
static int
-__mmplayer_gst_create_text_pipeline(mm_player_t* player)
+__mmplayer_gst_create_text_pipeline(mmplayer_t *player)
{
- MMPlayerGstElement* mainbin = NULL;
- MMPlayerGstElement* textbin = NULL;
+ mmplayer_gst_element_t *mainbin = NULL;
+ mmplayer_gst_element_t *textbin = NULL;
MMHandleType attrs = 0;
GstElement *subsrc = NULL;
GstElement *subparse = NULL;
attrs = MMPLAYER_GET_ATTRS(player);
if (!attrs) {
- LOGE("cannot get content attribute\n");
+ LOGE("cannot get content attribute");
return MM_ERROR_PLAYER_INTERNAL;
}
mm_attrs_get_string_by_name(attrs, "subtitle_uri", &subtitle_uri);
if (!subtitle_uri || strlen(subtitle_uri) < 1) {
- LOGE("subtitle uri is not proper filepath.\n");
+ LOGE("subtitle uri is not proper filepath.");
return MM_ERROR_PLAYER_INVALID_URI;
}
- if (!util_get_storage_info(subtitle_uri, &player->storage_info[MMPLAYER_PATH_TEXT])) {
+ if (!_mmplayer_get_storage_info(subtitle_uri, &player->storage_info[MMPLAYER_PATH_TEXT])) {
LOGE("failed to get storage info of subtitle path");
return MM_ERROR_PLAYER_INVALID_URI;
}
- SECURE_LOGD("subtitle file path is [%s].\n", subtitle_uri);
+ SECURE_LOGD("subtitle file path is [%s].", subtitle_uri);
MMPLAYER_SUBTITLE_INFO_LOCK(player);
player->subtitle_language_list = NULL;
/* create the subtitle source */
subsrc = gst_element_factory_make("filesrc", "subtitle_source");
if (!subsrc) {
- LOGE("failed to create filesrc element\n");
+ LOGE("failed to create filesrc element");
goto ERROR;
}
g_object_set(G_OBJECT(subsrc), "location", subtitle_uri, NULL);
mainbin[MMPLAYER_M_SUBSRC].gst = subsrc;
if (!gst_bin_add(GST_BIN(mainbin[MMPLAYER_M_PIPE].gst), subsrc)) {
- LOGW("failed to add queue\n");
+ LOGW("failed to add queue");
gst_object_unref(mainbin[MMPLAYER_M_SUBSRC].gst);
mainbin[MMPLAYER_M_SUBSRC].gst = NULL;
mainbin[MMPLAYER_M_SUBSRC].id = MMPLAYER_M_NUM;
/* subparse */
subparse = gst_element_factory_make("subparse", "subtitle_parser");
if (!subparse) {
- LOGE("failed to create subparse element\n");
+ LOGE("failed to create subparse element");
goto ERROR;
}
- charset = util_get_charset(subtitle_uri);
+ charset = _mmplayer_get_charset(subtitle_uri);
if (charset) {
- LOGD("detected charset is %s\n", charset);
+ LOGD("detected charset is %s", charset);
g_object_set(G_OBJECT(subparse), "subtitle-encoding", charset, NULL);
}
mainbin[MMPLAYER_M_SUBPARSE].gst = subparse;
if (!gst_bin_add(GST_BIN(mainbin[MMPLAYER_M_PIPE].gst), subparse)) {
- LOGW("failed to add subparse\n");
+ LOGW("failed to add subparse");
gst_object_unref(mainbin[MMPLAYER_M_SUBPARSE].gst);
mainbin[MMPLAYER_M_SUBPARSE].gst = NULL;
mainbin[MMPLAYER_M_SUBPARSE].id = MMPLAYER_M_NUM;
}
if (!gst_element_link_pads(subsrc, "src", subparse, "sink")) {
- LOGW("failed to link subsrc and subparse\n");
+ LOGW("failed to link subsrc and subparse");
goto ERROR;
}
player->play_subtitle = TRUE;
player->adjust_subtitle_pos = 0;
- LOGD("play subtitle using subtitle file\n");
+ LOGD("play subtitle using subtitle file");
if (player->pipeline->textbin == NULL) {
if (MM_ERROR_NONE != __mmplayer_gst_create_text_sink_bin(player)) {
- LOGE("failed to create text sink bin. continuing without text\n");
+ LOGE("failed to create text sink bin. continuing without text");
goto ERROR;
}
textbin = player->pipeline->textbin;
if (!gst_bin_add(GST_BIN(mainbin[MMPLAYER_M_PIPE].gst), GST_ELEMENT(textbin[MMPLAYER_T_BIN].gst))) {
- LOGW("failed to add textbin\n");
+ LOGW("failed to add textbin");
/* release signal */
__mmplayer_release_signal_connection(player, MM_PLAYER_SIGNAL_TYPE_TEXTBIN);
player->textsink_linked = 1;
player->external_text_idx = 0;
- LOGI("player->textsink_linked set to 1\n");
+ LOGI("textsink is linked");
} else {
textbin = player->pipeline->textbin;
LOGD("text bin has been created. reuse it.");
}
if (!gst_element_link_pads(subparse, "src", textbin[MMPLAYER_T_BIN].gst, "text_sink")) {
- LOGW("failed to link subparse and textbin\n");
+ LOGW("failed to link subparse and textbin");
goto ERROR;
}
}
gboolean
-__mmplayer_update_subtitle(GstElement* object, GstBuffer *buffer, GstPad *pad, gpointer data)
+__mmplayer_update_subtitle(GstElement *object, GstBuffer *buffer, GstPad *pad, gpointer data)
{
- mm_player_t* player = (mm_player_t*) data;
+ mmplayer_t *player = (mmplayer_t *)data;
MMMessageParamType msg = {0, };
GstClockTime duration = 0;
gpointer text = NULL;
gst_buffer_map(buffer, &mapinfo, GST_MAP_READ);
text = mapinfo.data;
text_size = mapinfo.size;
- duration = GST_BUFFER_DURATION(buffer);
if (player->set_mode.subtitle_off) {
- LOGD("subtitle is OFF.\n");
+ LOGD("subtitle is OFF.");
return TRUE;
}
if (!text || (text_size == 0)) {
- LOGD("There is no subtitle to be displayed.\n");
+ LOGD("There is no subtitle to be displayed.");
return TRUE;
}
- msg.data = (void *) text;
+ msg.data = (void *)text;
+
+ duration = GST_BUFFER_DURATION(buffer);
+
+ if (!GST_CLOCK_TIME_IS_VALID(duration)) {
+ if (player->duration > GST_BUFFER_PTS(buffer))
+ duration = player->duration - GST_BUFFER_PTS(buffer);
+ else
+ duration = 0;
+ LOGI("subtitle duration is invalid, subtitle duration change "
+ "GST_CLOCK_TIME_NONE -> %" GST_TIME_FORMAT, GST_TIME_ARGS(duration));
+ }
msg.subtitle.duration = GST_TIME_AS_MSECONDS(duration);
- LOGD("update subtitle : [%ld msec] %s\n'", msg.subtitle.duration, (char*)msg.data);
+ LOGD("update subtitle : [%ld msec] %s", msg.subtitle.duration, (char *)msg.data);
MMPLAYER_POST_MSG(player, MM_MESSAGE_UPDATE_SUBTITLE, &msg);
gst_buffer_unmap(buffer, &mapinfo);
static GstPadProbeReturn
__mmplayer_subtitle_adjust_position_probe(GstPad *pad, GstPadProbeInfo *info, gpointer u_data)
{
- mm_player_t *player = (mm_player_t *) u_data;
+ mmplayer_t *player = (mmplayer_t *)u_data;
GstClockTime cur_timestamp = 0;
gint64 adjusted_timestamp = 0;
GstBuffer *buffer = gst_pad_probe_info_get_buffer(info);
MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
if (player->set_mode.subtitle_off) {
- LOGD("subtitle is OFF.\n");
+ LOGD("subtitle is OFF.");
return TRUE;
}
}
cur_timestamp = GST_BUFFER_TIMESTAMP(buffer);
- adjusted_timestamp = (gint64) cur_timestamp +((gint64) player->adjust_subtitle_pos * G_GINT64_CONSTANT(1000000));
+ adjusted_timestamp = (gint64)cur_timestamp + ((gint64)player->adjust_subtitle_pos * G_GINT64_CONSTANT(1000000));
if (adjusted_timestamp < 0) {
LOGD("adjusted_timestamp under zero");
return GST_PAD_PROBE_OK;
}
-static int __mmplayer_gst_adjust_subtitle_position(mm_player_t* player, int format, int position)
+
+static int
+__mmplayer_gst_adjust_subtitle_position(mmplayer_t *player, int position)
{
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player->play_subtitle, MM_ERROR_NOT_SUPPORT_API);
if (position == 0) {
- LOGD("nothing to do\n");
+ LOGD("nothing to do");
MMPLAYER_FLEAVE();
return MM_ERROR_NONE;
}
- switch (format) {
- case MM_PLAYER_POS_FORMAT_TIME:
- {
- /* check current postion */
- player->adjust_subtitle_pos = position;
-
- LOGD("save adjust_subtitle_pos in player") ;
- }
- break;
+ /* check current postion */
+ player->adjust_subtitle_pos = position;
- default:
- {
- LOGW("invalid format.\n");
- MMPLAYER_FLEAVE();
- return MM_ERROR_INVALID_ARGUMENT;
- }
- }
+ LOGD("save adjust_subtitle_pos in player");
MMPLAYER_FLEAVE();
* @see
*/
static int
-__mmplayer_gst_create_pipeline(mm_player_t* player)
+__mmplayer_gst_create_pipeline(mmplayer_t *player)
{
int ret = MM_ERROR_NONE;
- MMPlayerGstElement *mainbin = NULL;
+ mmplayer_gst_element_t *mainbin = NULL;
MMHandleType attrs = 0;
- gint mode = MM_PLAYER_PD_MODE_NONE;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
goto INIT_ERROR;
}
- player->pipeline = (MMPlayerGstPipelineInfo*) g_malloc0(sizeof(MMPlayerGstPipelineInfo));
- if (player->pipeline == NULL)
- goto INIT_ERROR;
+ player->pipeline = (mmplayer_pipeline_info_t *)g_malloc0(sizeof(mmplayer_pipeline_info_t));
/* create mainbin */
- mainbin = (MMPlayerGstElement*) g_malloc0(sizeof(MMPlayerGstElement) * MMPLAYER_M_NUM);
+ mainbin = (mmplayer_gst_element_t *)g_try_malloc0(sizeof(mmplayer_gst_element_t) * MMPLAYER_M_NUM);
if (mainbin == NULL)
goto INIT_ERROR;
player->pipeline->mainbin = mainbin;
- /* check pd mode */
- mm_attrs_get_int_by_name(attrs, "pd_mode", &mode);
- player->pd_mode = mode;
-
/* create the source and decoder elements */
if (MMPLAYER_IS_MS_BUFF_SRC(player)) {
- ret = __mmplayer_gst_build_es_pipeline(player);
- } else if (MMPLAYER_IS_HTTP_STREAMING(player) && MMPLAYER_IS_HTTP_PD(player)) {
- ret = __mmplayer_gst_build_pd_pipeline(player);
+ ret = _mmplayer_gst_build_es_pipeline(player);
} else {
- ret = __mmplayer_gst_build_pipeline(player);
+ if (MMPLAYER_USE_DECODEBIN(player))
+ ret = _mmplayer_gst_build_pipeline(player); /* TEMP: previous pipeline, will be removed.*/
+ else
+ ret = _mmplayer_gst_build_pipeline_with_src(player);
}
if (ret != MM_ERROR_NONE) {
}
/* Note : check whether subtitle atrribute uri is set. If uri is set, then try to play subtitle file */
- if (__mmplayer_check_subtitle(player)) {
- if (__mmplayer_gst_create_text_pipeline(player) != MM_ERROR_NONE)
- LOGE("failed to create text pipeline");
- }
+ if (__mmplayer_check_subtitle(player)
+ && (__mmplayer_gst_create_text_pipeline(player) != MM_ERROR_NONE))
+ LOGE("failed to create text pipeline");
/* add bus watch */
- ret = __mmplayer_gst_add_bus_watch(player);
+ ret = _mmplayer_gst_add_bus_watch(player);
if (ret != MM_ERROR_NONE) {
LOGE("failed to add bus watch");
goto INIT_ERROR;
return MM_ERROR_NONE;
INIT_ERROR:
+ _mmplayer_bus_watcher_remove(player);
__mmplayer_gst_destroy_pipeline(player);
return MM_ERROR_PLAYER_INTERNAL;
}
static void
-__mmplayer_reset_gapless_state(mm_player_t* player)
+__mmplayer_reset_gapless_state(mmplayer_t *player)
{
MMPLAYER_FENTER();
MMPLAYER_RETURN_IF_FAIL(player
&& player->pipeline->audiobin
&& player->pipeline->audiobin[MMPLAYER_A_BIN].gst);
- memset(&player->gapless, 0, sizeof(mm_player_gapless_t));
+ memset(&player->gapless, 0, sizeof(mmplayer_gapless_t));
MMPLAYER_FLEAVE();
return;
}
static int
-__mmplayer_gst_destroy_pipeline(mm_player_t* player)
+__mmplayer_gst_destroy_pipeline(mmplayer_t *player)
{
gint timeout = 0;
int ret = MM_ERROR_NONE;
MMPLAYER_FREEIF(player->type);
player->no_more_pad = FALSE;
player->num_dynamic_pad = 0;
- player->demux_pad_index = 0;
MMPLAYER_SUBTITLE_INFO_LOCK(player);
player->subtitle_language_list = NULL;
MMPLAYER_SUBTITLE_INFO_UNLOCK(player);
+ MMPLAYER_RECONFIGURE_LOCK(player);
__mmplayer_reset_gapless_state(player);
+ MMPLAYER_RECONFIGURE_UNLOCK(player);
if (player->streamer) {
- __mm_player_streaming_deinitialize(player->streamer);
- __mm_player_streaming_destroy(player->streamer);
+ _mm_player_streaming_initialize(player->streamer, FALSE);
+ _mm_player_streaming_destroy(player->streamer);
player->streamer = NULL;
}
MMPLAYER_FREEIF(player->unlinked_demuxer_mime);
/* cleanup running stuffs */
- __mmplayer_cancel_eos_timer(player);
+ _mmplayer_cancel_eos_timer(player);
/* cleanup gst stuffs */
if (player->pipeline) {
- MMPlayerGstElement* mainbin = player->pipeline->mainbin;
- GstTagList* tag_list = player->pipeline->tag_list;
+ mmplayer_gst_element_t *mainbin = player->pipeline->mainbin;
+ GstTagList *tag_list = player->pipeline->tag_list;
/* first we need to disconnect all signal hander */
__mmplayer_release_signal_connection(player, MM_PLAYER_SIGNAL_TYPE_ALL);
if (mainbin) {
- MMPlayerGstElement* audiobin = player->pipeline->audiobin;
- MMPlayerGstElement* videobin = player->pipeline->videobin;
- MMPlayerGstElement* textbin = player->pipeline->textbin;
+ mmplayer_gst_element_t *audiobin = player->pipeline->audiobin;
+ mmplayer_gst_element_t *videobin = player->pipeline->videobin;
+ mmplayer_gst_element_t *textbin = player->pipeline->textbin;
GstBus *bus = gst_pipeline_get_bus(GST_PIPELINE(mainbin[MMPLAYER_M_PIPE].gst));
gst_bus_set_sync_handler(bus, NULL, NULL, NULL);
gst_object_unref(bus);
timeout = MMPLAYER_STATE_CHANGE_TIMEOUT(player);
- ret = __mmplayer_gst_set_state(player, mainbin[MMPLAYER_M_PIPE].gst, GST_STATE_NULL, FALSE, timeout);
+ ret = _mmplayer_gst_set_state(player, mainbin[MMPLAYER_M_PIPE].gst, GST_STATE_NULL, FALSE, timeout);
if (ret != MM_ERROR_NONE) {
- LOGE("fail to change state to NULL\n");
+ LOGE("fail to change state to NULL");
return MM_ERROR_PLAYER_INTERNAL;
}
- LOGW("succeeded in changing state to NULL\n");
+ LOGW("succeeded in changing state to NULL");
gst_object_unref(GST_OBJECT(mainbin[MMPLAYER_M_PIPE].gst));
}
if (tag_list)
- gst_tag_list_free(tag_list);
+ gst_tag_list_unref(tag_list);
MMPLAYER_FREEIF(player->pipeline);
}
gst_caps_unref(player->v_stream_caps);
player->v_stream_caps = NULL;
}
+
if (player->a_stream_caps) {
gst_caps_unref(player->a_stream_caps);
player->a_stream_caps = NULL;
gst_caps_unref(player->s_stream_caps);
player->s_stream_caps = NULL;
}
- __mmplayer_track_destroy(player);
+ _mmplayer_track_destroy(player);
if (player->sink_elements)
g_list_free(player->sink_elements);
player->bufmgr = NULL;
}
- LOGW("finished destroy pipeline\n");
+ LOGW("finished destroy pipeline");
MMPLAYER_FLEAVE();
return ret;
}
-static int __mmplayer_gst_realize(mm_player_t* player)
+static int
+__mmplayer_gst_realize(mmplayer_t *player)
{
gint timeout = 0;
int ret = MM_ERROR_NONE;
ret = __mmplayer_gst_create_pipeline(player);
if (ret) {
- LOGE("failed to create pipeline\n");
+ LOGE("failed to create pipeline");
return ret;
}
/* set pipeline state to READY */
/* NOTE : state change to READY must be performed sync. */
timeout = MMPLAYER_STATE_CHANGE_TIMEOUT(player);
- ret = __mmplayer_gst_set_state(player,
+ ret = _mmplayer_gst_set_state(player,
player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, GST_STATE_READY, FALSE, timeout);
if (ret != MM_ERROR_NONE) {
return ret;
}
-static int __mmplayer_gst_unrealize(mm_player_t* player)
+static int
+__mmplayer_gst_unrealize(mmplayer_t *player)
{
int ret = MM_ERROR_NONE;
/* destroy pipeline */
ret = __mmplayer_gst_destroy_pipeline(player);
if (ret != MM_ERROR_NONE) {
- LOGE("failed to destory pipeline\n");
+ LOGE("failed to destory pipeline");
return ret;
}
}
static int
-__mmplayer_gst_set_message_callback(mm_player_t* player, MMMessageCallback callback, gpointer user_param)
+__mmplayer_gst_set_message_callback(mmplayer_t *player, MMMessageCallback callback, gpointer user_param)
{
MMPLAYER_FENTER();
if (!player) {
- LOGW("set_message_callback is called with invalid player handle\n");
+ LOGW("set_message_callback is called with invalid player handle");
return MM_ERROR_PLAYER_NOT_INITIALIZED;
}
player->msg_cb = callback;
player->msg_cb_param = user_param;
- LOGD("msg_cb : %p msg_cb_param : %p\n", callback, user_param);
+ LOGD("msg_cb : %p msg_cb_param : %p", callback, user_param);
MMPLAYER_FLEAVE();
return MM_ERROR_NONE;
}
-int __mmplayer_parse_profile(const char *uri, void *param, MMPlayerParseProfile* data)
+int
+_mmplayer_parse_profile(const char *uri, void *param, mmplayer_parse_profile_t *data)
{
int ret = MM_ERROR_NONE;
char *path = NULL;
MMPLAYER_FENTER();
- MMPLAYER_RETURN_VAL_IF_FAIL(uri , FALSE);
- MMPLAYER_RETURN_VAL_IF_FAIL(data , FALSE);
- MMPLAYER_RETURN_VAL_IF_FAIL((strlen(uri) <= MM_MAX_URL_LEN), FALSE);
+ MMPLAYER_RETURN_VAL_IF_FAIL(uri, MM_ERROR_PLAYER_INVALID_URI);
+ MMPLAYER_RETURN_VAL_IF_FAIL(data, MM_ERROR_PLAYER_INTERNAL);
+ MMPLAYER_RETURN_VAL_IF_FAIL((strlen(uri) <= MM_MAX_URL_LEN), MM_ERROR_PLAYER_INVALID_URI);
- memset(data, 0, sizeof(MMPlayerParseProfile));
+ memset(data, 0, sizeof(mmplayer_parse_profile_t));
if (strstr(uri, "es_buff://")) {
__mmplayer_copy_uri_and_set_type(data, uri, MM_PLAYER_URI_TYPE_MS_BUFF);
ret = MM_ERROR_PLAYER_PERMISSION_DENIED;
/* dump parse result */
- SECURE_LOGW("incoming uri : %s\n", uri);
- LOGD("uri_type : %d, mem : %p, mem_size : %d, urgent : %s\n",
+ SECURE_LOGW("incoming uri : %s", uri);
+ LOGD("uri_type : %d, mem : %p, mem_size : %d, urgent : %s",
data->uri_type, data->input_mem.buf, data->input_mem.len, data->urgent);
MMPLAYER_FLEAVE();
}
static gboolean
-__mmplayer_can_do_interrupt(mm_player_t *player)
+__mmplayer_can_do_interrupt(mmplayer_t *player)
{
if (!player || !player->pipeline || !player->attrs) {
LOGW("not initialized");
goto FAILED;
}
- if (player->audio_stream_render_cb) {
+ if (player->audio_decoded_cb) {
LOGW("not support in pcm extraction mode");
goto FAILED;
}
FAILED: /* with CMD UNLOCKED */
return FALSE;
-INTERRUPT: /* with CMD LOCKED, released at mrp_resource_release_cb() */
+INTERRUPT: /* with CMD LOCKED, will do UNLOCK at __resource_release_cb() */
return TRUE;
}
__resource_release_cb(mm_resource_manager_h rm, mm_resource_manager_res_h res,
void *user_data)
{
- mm_player_t *player = NULL;
+ mmplayer_t *player = NULL;
+ MMMessageParamType msg = {0, };
+ gint64 pos = 0;
+ mmplayer_resource_type_e res_idx = MMPLAYER_RESOURCE_TYPE_MAX;
MMPLAYER_FENTER();
- if (user_data == NULL) {
- LOGE("- user_data is null\n");
+ if (!user_data) {
+ LOGE("user_data is null");
return FALSE;
}
- player = (mm_player_t *)user_data;
+ player = (mmplayer_t *)user_data;
- /* do something to release resource here.
- * player stop and interrupt forwarding */
if (!__mmplayer_can_do_interrupt(player)) {
LOGW("no need to interrupt, so leave");
+ /* FIXME: there is no way to avoid releasing resource. */
+ return FALSE;
+ }
+
+ player->interrupted_by_resource = TRUE;
+
+ /* get last play position */
+ if (_mmplayer_gst_get_position(player, &pos) == MM_ERROR_NONE) {
+ msg.union_type = MM_MSG_UNION_TIME;
+ msg.time.elapsed = pos;
+ MMPLAYER_POST_MSG(player, MM_MESSAGE_PLAY_POSITION, &msg);
} else {
- MMMessageParamType msg = {0, };
- gint64 pos = 0;
+ LOGW("failed to get play position.");
+ }
- player->interrupted_by_resource = TRUE;
+ LOGD("video resource conflict so, resource will be freed by unrealizing");
+ if (_mmplayer_unrealize((MMHandleType)player) != MM_ERROR_NONE)
+ LOGE("failed to unrealize");
- /* get last play position */
- if (_mmplayer_get_position((MMHandleType)player, &pos) != MM_ERROR_NONE) {
- LOGW("failed to get play position.");
- } else {
- msg.union_type = MM_MSG_UNION_TIME;
- msg.time.elapsed = pos;
- MMPLAYER_POST_MSG(player, MM_MESSAGE_PLAY_POSITION, &msg);
- }
- LOGD("video resource conflict so, resource will be freed by unrealizing");
- if (_mmplayer_unrealize((MMHandleType)player))
- LOGW("failed to unrealize");
+ /* lock is called in __mmplayer_can_do_interrupt() */
+ MMPLAYER_CMD_UNLOCK(player);
- /* lock is called in __mmplayer_can_do_interrupt() */
- MMPLAYER_CMD_UNLOCK(player);
+ for (res_idx = MMPLAYER_RESOURCE_TYPE_VIDEO_DECODER; res_idx < MMPLAYER_RESOURCE_TYPE_MAX; res_idx++) {
+ player->hw_resource[res_idx] = NULL;
}
- if (res == player->video_overlay_resource)
- player->video_overlay_resource = FALSE;
- else
- player->video_decoder_resource = FALSE;
-
MMPLAYER_FLEAVE();
-
- return FALSE;
+ return TRUE; /* release all the resources */
}
static void
-__mmplayer_initialize_video_roi(mm_player_t *player)
+__mmplayer_initialize_video_roi(mmplayer_t *player)
{
player->video_roi.scale_x = 0.0;
player->video_roi.scale_y = 0.0;
int ret = MM_ERROR_PLAYER_INTERNAL;
bool enabled = false;
- mm_player_t* player = MM_PLAYER_CAST(handle);
+ mmplayer_t *player = MM_PLAYER_CAST(handle);
MMPLAYER_FENTER();
player->attrs = _mmplayer_construct_attribute(handle);
if (!player->attrs) {
- LOGE("Failed to construct attributes\n");
+ LOGE("Failed to construct attributes");
return ret;
}
/* initialize gstreamer with configured parameter */
if (!__mmplayer_init_gstreamer(player)) {
- LOGE("Initializing gstreamer failed\n");
+ LOGE("Initializing gstreamer failed");
_mmplayer_deconstruct_attribute(handle);
return ret;
}
ret = _mmplayer_initialize_video_capture(player);
if (ret != MM_ERROR_NONE) {
- LOGE("failed to initialize video capture\n");
+ LOGE("failed to initialize video capture");
goto ERROR;
}
/* initialize resource manager */
- if (MM_RESOURCE_MANAGER_ERROR_NONE != mm_resource_manager_create(
- MM_RESOURCE_MANAGER_APP_CLASS_MEDIA, __resource_release_cb, player,
- &player->resource_manager)) {
- LOGE("failed to initialize resource manager\n");
+ if (mm_resource_manager_create(MM_RESOURCE_MANAGER_APP_CLASS_MEDIA,
+ __resource_release_cb, player, &player->resource_manager)
+ != MM_RESOURCE_MANAGER_ERROR_NONE) {
+ LOGE("failed to initialize resource manager");
ret = MM_ERROR_PLAYER_INTERNAL;
goto ERROR;
}
- if (MMPLAYER_IS_HTTP_PD(player)) {
- player->pd_downloader = NULL;
- player->pd_file_save_path = NULL;
- }
-
/* create video bo lock and cond */
g_mutex_init(&player->video_bo_mutex);
g_cond_init(&player->video_bo_cond);
- /* create media stream callback mutex */
- g_mutex_init(&player->media_stream_cb_lock);
-
/* create subtitle info lock and cond */
g_mutex_init(&player->subtitle_info_mutex);
g_cond_init(&player->subtitle_info_cond);
player->play_subtitle = FALSE;
player->has_closed_caption = FALSE;
- player->video_num_buffers = DEFAULT_NUM_OF_V_OUT_BUFFER;
- player->video_extra_num_buffers = DEFAULT_NUM_OF_V_OUT_BUFFER;
player->pending_resume = FALSE;
if (player->ini.dump_element_keyword[0][0] == '\0')
player->ini.set_dump_element_flag = FALSE;
MMPLAYER_STATE_CHANGE_TIMEOUT(player) = player->ini.localplayback_state_change_timeout;
MMPLAYER_SET_STATE(player, MM_PLAYER_STATE_NULL);
+ MMPLAYER_FLEAVE();
+
return MM_ERROR_NONE;
ERROR:
/* free lock */
g_mutex_clear(&player->fsink_lock);
-
/* free update tag lock */
g_mutex_clear(&player->update_tag_lock);
-
g_queue_free(player->bus_msg_q);
-
+ player->bus_msg_q = NULL;
/* free gapless play thread */
if (player->gapless_play_thread) {
MMPLAYER_GAPLESS_PLAY_THREAD_LOCK(player);
}
static gboolean
-__mmplayer_init_gstreamer(mm_player_t* player)
+__mmplayer_init_gstreamer(mmplayer_t *player)
{
static gboolean initialized = FALSE;
static const int max_argc = 50;
- gint* argc = NULL;
- gchar** argv = NULL;
- gchar** argv2 = NULL;
+ gint *argc = NULL;
+ gchar **argv = NULL;
+ gchar **argv2 = NULL;
GError *err = NULL;
int i = 0;
int arg_count = 0;
if (initialized) {
- LOGD("gstreamer already initialized.\n");
+ LOGD("gstreamer already initialized.");
return TRUE;
}
/* alloc */
argc = malloc(sizeof(int));
- argv = malloc(sizeof(gchar*) * max_argc);
- argv2 = malloc(sizeof(gchar*) * max_argc);
+ argv = malloc(sizeof(gchar *) * max_argc);
+ argv2 = malloc(sizeof(gchar *) * max_argc);
if (!argc || !argv || !argv2)
goto ERROR;
- memset(argv, 0, sizeof(gchar*) * max_argc);
- memset(argv2, 0, sizeof(gchar*) * max_argc);
+ memset(argv, 0, sizeof(gchar *) * max_argc);
+ memset(argv2, 0, sizeof(gchar *) * max_argc);
/* add initial */
*argc = 1;
(*argc)++;
}
- LOGD("initializing gstreamer with following parameter\n");
- LOGD("argc : %d\n", *argc);
+ LOGD("initializing gstreamer with following parameter");
+ LOGD("argc : %d", *argc);
arg_count = *argc;
for (i = 0; i < arg_count; i++) {
argv2[i] = argv[i];
- LOGD("argv[%d] : %s\n", i, argv2[i]);
+ LOGD("argv[%d] : %s", i, argv2[i]);
}
/* initializing gstreamer */
if (!gst_init_check(argc, &argv, &err)) {
- LOGE("Could not initialize GStreamer: %s\n", err ? err->message : "unknown error occurred");
+ LOGE("Could not initialize GStreamer: %s", err ? err->message : "unknown error occurred");
if (err)
g_error_free(err);
}
/* release */
for (i = 0; i < arg_count; i++) {
- //LOGD("release - argv[%d] : %s\n", i, argv2[i]);
+#ifdef __DEBUG__
+ LOGD("release - argv[%d] : %s", i, argv2[i]);
+#endif
MMPLAYER_FREEIF(argv2[i]);
}
/* release */
for (i = 0; i < arg_count; i++) {
- LOGD("free[%d] : %s\n", i, argv2[i]);
+ LOGD("free[%d] : %s", i, argv2[i]);
MMPLAYER_FREEIF(argv2[i]);
}
return FALSE;
}
-int
-__mmplayer_destroy_streaming_ext(mm_player_t* player)
-{
- MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
-
- if (player->pd_downloader || MMPLAYER_IS_HTTP_PD(player)) {
- _mmplayer_destroy_pd_downloader((MMHandleType)player);
- MMPLAYER_FREEIF(player->pd_file_save_path);
- }
-
- return MM_ERROR_NONE;
-}
-
static void
-__mmplayer_check_async_state_transition(mm_player_t* player)
+__mmplayer_check_async_state_transition(mmplayer_t *player)
{
GstState element_state = GST_STATE_VOID_PENDING;
GstState element_pending_state = GST_STATE_VOID_PENDING;
GstStateChangeReturn ret = GST_STATE_CHANGE_FAILURE;
- GstElement * element = NULL;
+ GstElement *element = NULL;
gboolean async = FALSE;
/* check player handle */
/* wait for state transition */
element = player->pipeline->mainbin[MMPLAYER_M_PIPE].gst;
- ret = gst_element_get_state(element, &element_state, &element_pending_state, 1*GST_SECOND);
+ ret = gst_element_get_state(element, &element_state, &element_pending_state, 1 * GST_SECOND);
if (ret == GST_STATE_CHANGE_FAILURE) {
- LOGE(" [%s] state : %s pending : %s \n",
+ LOGE(" [%s] state : %s pending : %s",
GST_ELEMENT_NAME(element),
gst_element_state_get_name(element_state),
gst_element_state_get_name(element_pending_state));
/* dump state of all element */
- __mmplayer_dump_pipeline_state(player);
+ _mmplayer_dump_pipeline_state(player);
return;
}
- LOGD("[%s] element state has changed\n", GST_ELEMENT_NAME(element));
+ LOGD("[%s] element state has changed", GST_ELEMENT_NAME(element));
return;
}
int
_mmplayer_destroy(MMHandleType handle)
{
- mm_player_t* player = MM_PLAYER_CAST(handle);
+ mmplayer_t *player = MM_PLAYER_CAST(handle);
MMPLAYER_FENTER();
/* check async state transition */
__mmplayer_check_async_state_transition(player);
- __mmplayer_destroy_streaming_ext(player);
-
/* release gapless play thread */
if (player->gapless_play_thread) {
MMPLAYER_GAPLESS_PLAY_THREAD_LOCK(player);
MMPLAYER_GAPLESS_PLAY_THREAD_SIGNAL(player);
MMPLAYER_GAPLESS_PLAY_THREAD_UNLOCK(player);
- LOGD("waitting for gapless play thread exit\n");
+ LOGD("waitting for gapless play thread exit");
g_thread_join(player->gapless_play_thread);
g_mutex_clear(&player->gapless_play_thread_mutex);
g_cond_clear(&player->gapless_play_thread_cond);
- LOGD("gapless play thread released\n");
+ LOGD("gapless play thread released");
}
_mmplayer_release_video_capture(player);
/* de-initialize resource manager */
if (MM_RESOURCE_MANAGER_ERROR_NONE != mm_resource_manager_destroy(
player->resource_manager))
- LOGE("failed to deinitialize resource manager\n");
+ LOGE("failed to deinitialize resource manager");
+
+ /* release miscellaneous information */
+ __mmplayer_release_misc(player);
/* release pipeline */
if (MM_ERROR_NONE != __mmplayer_gst_destroy_pipeline(player)) {
- LOGE("failed to destory pipeline\n");
+ LOGE("failed to destory pipeline");
return MM_ERROR_PLAYER_INTERNAL;
}
__mmplayer_release_dump_list(player->dump_list);
- /* release miscellaneous information */
- __mmplayer_release_misc(player);
-
/* release miscellaneous information.
these info needs to be released after pipeline is destroyed. */
__mmplayer_release_misc_post(player);
/* release attributes */
_mmplayer_deconstruct_attribute(handle);
+ if (player->uri_info.uri_list) {
+ g_list_free_full(player->uri_info.uri_list, (GDestroyNotify)g_free);
+ player->uri_info.uri_list = NULL;
+ }
+
/* release lock */
g_mutex_clear(&player->fsink_lock);
g_mutex_clear(&player->video_bo_mutex);
g_cond_clear(&player->video_bo_cond);
- /* release media stream callback lock */
- g_mutex_clear(&player->media_stream_cb_lock);
-
MMPLAYER_FLEAVE();
return MM_ERROR_NONE;
}
int
-__mmplayer_realize_streaming_ext(mm_player_t* player)
+_mmplayer_realize(MMHandleType hplayer)
{
+ mmplayer_t *player = (mmplayer_t *)hplayer;
int ret = MM_ERROR_NONE;
+ char *uri = NULL;
+ void *param = NULL;
+ MMHandleType attrs = 0;
MMPLAYER_FENTER();
- MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
- if (MMPLAYER_IS_HTTP_PD(player)) {
- gboolean bret = FALSE;
-
- player->pd_downloader = _mmplayer_create_pd_downloader();
- if (!player->pd_downloader) {
- LOGE("Unable to create PD Downloader...");
- ret = MM_ERROR_PLAYER_NO_FREE_SPACE;
- }
+ /* check player handle */
+ MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
- bret = _mmplayer_realize_pd_downloader((MMHandleType)player, player->profile.uri, player->pd_file_save_path, player->pipeline->mainbin[MMPLAYER_M_SRC].gst);
-
- if (FALSE == bret) {
- LOGE("Unable to create PD Downloader...");
- ret = MM_ERROR_PLAYER_NOT_INITIALIZED;
- }
- }
-
- MMPLAYER_FLEAVE();
- return ret;
-}
-
-int
-_mmplayer_realize(MMHandleType hplayer)
-{
- mm_player_t* player = (mm_player_t*)hplayer;
- char *uri = NULL;
- void *param = NULL;
- MMHandleType attrs = 0;
- int ret = MM_ERROR_NONE;
-
- MMPLAYER_FENTER();
-
- /* check player handle */
- MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
-
- /* check current state */
- MMPLAYER_CHECK_STATE(player, MMPLAYER_COMMAND_REALIZE);
+ /* check current state */
+ MMPLAYER_CHECK_STATE(player, MMPLAYER_COMMAND_REALIZE);
attrs = MMPLAYER_GET_ATTRS(player);
if (!attrs) {
- LOGE("fail to get attributes.\n");
+ LOGE("fail to get attributes.");
return MM_ERROR_PLAYER_INTERNAL;
}
mm_attrs_get_string_by_name(attrs, "profile_uri", &uri);
mm_attrs_get_data_by_name(attrs, "profile_user_param", ¶m);
if (player->profile.uri_type == MM_PLAYER_URI_TYPE_NONE) {
- ret = __mmplayer_parse_profile((const char*)uri, param, &player->profile);
+ ret = _mmplayer_parse_profile((const char *)uri, param, &player->profile);
if (ret != MM_ERROR_NONE) {
- LOGE("failed to parse profile\n");
+ LOGE("failed to parse profile");
return ret;
}
}
}
if (player->profile.uri_type == MM_PLAYER_URI_TYPE_URL_MMS) {
- LOGW("mms protocol is not supported format.\n");
+ LOGW("mms protocol is not supported format.");
return MM_ERROR_PLAYER_NOT_SUPPORTED_FORMAT;
}
- if (MMPLAYER_IS_HTTP_PD(player))
- MMPLAYER_STATE_CHANGE_TIMEOUT(player) = PLAYER_PD_STATE_CHANGE_TIME;
- else if (MMPLAYER_IS_STREAMING(player))
+ if (MMPLAYER_IS_STREAMING(player))
MMPLAYER_STATE_CHANGE_TIMEOUT(player) = player->ini.live_state_change_timeout;
else
MMPLAYER_STATE_CHANGE_TIMEOUT(player) = player->ini.localplayback_state_change_timeout;
player->is_subtitle_off = FALSE; /* set the subtitle ON default */
player->video360_metadata.is_spherical = -1;
player->is_openal_plugin_used = FALSE;
- player->demux_pad_index = 0;
player->subtitle_language_list = NULL;
player->is_subtitle_force_drop = FALSE;
- player->last_multiwin_status = FALSE;
- __mmplayer_track_initialize(player);
+ _mmplayer_track_initialize(player);
__mmplayer_initialize_storage_info(player, MMPLAYER_PATH_MAX);
if ((MMPLAYER_IS_STREAMING(player)) && (player->streamer == NULL)) {
- player->streamer = __mm_player_streaming_create();
- __mm_player_streaming_initialize(player->streamer);
+ gint prebuffer_ms = 0, rebuffer_ms = 0;
+
+ player->streamer = _mm_player_streaming_create();
+ _mm_player_streaming_initialize(player->streamer, TRUE);
+
+ mm_attrs_multiple_get(player->attrs, NULL,
+ MM_PLAYER_PREBUFFER_MS, &prebuffer_ms,
+ MM_PLAYER_REBUFFER_MS, &rebuffer_ms, NULL);
+
+ if (prebuffer_ms > 0) {
+ prebuffer_ms = MAX(prebuffer_ms, 1000);
+ player->streamer->buffering_req.prebuffer_time = prebuffer_ms;
+ }
+
+ if (rebuffer_ms > 0) {
+ player->streamer->buffering_req.mode = MM_PLAYER_BUFFERING_MODE_FIXED;
+ rebuffer_ms = MAX(rebuffer_ms, 1000);
+ player->streamer->buffering_req.rebuffer_time = rebuffer_ms;
+ }
+
+ LOGD("buffering time %d ms, %d ms", player->streamer->buffering_req.prebuffer_time,
+ player->streamer->buffering_req.rebuffer_time);
}
/* realize pipeline */
ret = __mmplayer_gst_realize(player);
if (ret != MM_ERROR_NONE)
- LOGE("fail to realize the player.\n");
- else
- ret = __mmplayer_realize_streaming_ext(player);
+ LOGE("fail to realize the player.");
MMPLAYER_BUS_MSG_THREAD_SIGNAL(player);
}
int
-__mmplayer_unrealize_streaming_ext(mm_player_t *player)
-{
- MMPLAYER_FENTER();
- MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
-
- /* destroy can called at anytime */
- if (player->pd_downloader && MMPLAYER_IS_HTTP_PD(player))
- _mmplayer_unrealize_pd_downloader((MMHandleType)player);
-
- MMPLAYER_FLEAVE();
- return MM_ERROR_NONE;
-}
-
-int
_mmplayer_unrealize(MMHandleType hplayer)
{
- mm_player_t* player = (mm_player_t*)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
int ret = MM_ERROR_NONE;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
MMPLAYER_CMD_UNLOCK(player);
+ _mmplayer_bus_watcher_remove(player);
/* destroy the gst bus msg thread which is created during realize.
this funct have to be called before getting cmd lock. */
- __mmplayer_bus_msg_thread_destroy(player);
+ _mmplayer_bus_msg_thread_destroy(player);
MMPLAYER_CMD_LOCK(player);
/* check current state */
/* check async state transition */
__mmplayer_check_async_state_transition(player);
- __mmplayer_unrealize_streaming_ext(player);
-
/* unrealize pipeline */
ret = __mmplayer_gst_unrealize(player);
- /* set asm stop if success */
- if (MM_ERROR_NONE == ret) {
- if (!player->interrupted_by_resource) {
- if (player->video_decoder_resource != NULL) {
- ret = mm_resource_manager_mark_for_release(player->resource_manager,
- player->video_decoder_resource);
- if (ret != MM_RESOURCE_MANAGER_ERROR_NONE)
- LOGE("failed to mark decoder resource for release, ret(0x%x)\n", ret);
- else
- player->video_decoder_resource = NULL;
- }
-
- if (player->video_overlay_resource != NULL) {
- ret = mm_resource_manager_mark_for_release(player->resource_manager,
- player->video_overlay_resource);
- if (ret != MM_RESOURCE_MANAGER_ERROR_NONE)
- LOGE("failed to mark overlay resource for release, ret(0x%x)\n", ret);
- else
- player->video_overlay_resource = NULL;
- }
+ if (!player->interrupted_by_resource) {
+ int rm_ret = MM_ERROR_NONE;
+ mmplayer_resource_type_e res_idx = MMPLAYER_RESOURCE_TYPE_MAX;
- ret = mm_resource_manager_commit(player->resource_manager);
- if (ret != MM_RESOURCE_MANAGER_ERROR_NONE)
- LOGE("failed to commit resource releases, ret(0x%x)\n", ret);
+ for (res_idx = MMPLAYER_RESOURCE_TYPE_VIDEO_DECODER; res_idx < MMPLAYER_RESOURCE_TYPE_MAX; res_idx++) {
+ rm_ret = __mmplayer_release_hw_resource(player, res_idx);
+ if (rm_ret != MM_ERROR_NONE)
+ LOGE("failed to release [%d] resources", res_idx);
}
- } else
- LOGE("failed and don't change asm state to stop");
+ }
MMPLAYER_FLEAVE();
-
return ret;
}
int
_mmplayer_set_message_callback(MMHandleType hplayer, MMMessageCallback callback, gpointer user_param)
{
- mm_player_t* player = (mm_player_t*)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
}
int
-_mmplayer_get_state(MMHandleType hplayer, int* state)
+_mmplayer_get_state(MMHandleType hplayer, int *state)
{
- mm_player_t *player = (mm_player_t*)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
MMPLAYER_RETURN_VAL_IF_FAIL(state, MM_ERROR_INVALID_ARGUMENT);
return MM_ERROR_NONE;
}
-
-int
-_mmplayer_set_volume(MMHandleType hplayer, MMPlayerVolumeType volume)
+static int
+__mmplayer_gst_set_volume_property(mmplayer_t *player, const char *prop_name)
{
- mm_player_t* player = (mm_player_t*) hplayer;
- GstElement* vol_element = NULL;
- int i = 0;
+ GstElement *vol_element = NULL;
+ enum audio_element_id volume_elem_id = MMPLAYER_A_VOL;
MMPLAYER_FENTER();
-
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
-
- LOGD("volume [L]=%f:[R]=%f\n",
- volume.level[MM_VOLUME_CHANNEL_LEFT], volume.level[MM_VOLUME_CHANNEL_RIGHT]);
-
- /* invalid factor range or not */
- for (i = 0; i < MM_VOLUME_CHANNEL_NUM; i++) {
- if (volume.level[i] < MM_VOLUME_FACTOR_MIN || volume.level[i] > MM_VOLUME_FACTOR_MAX) {
- LOGE("Invalid factor!(valid factor:0~1.0)\n");
- return MM_ERROR_INVALID_ARGUMENT;
- }
- }
-
- /* not support to set other value into each channel */
- if ((volume.level[MM_VOLUME_CHANNEL_LEFT] != volume.level[MM_VOLUME_CHANNEL_RIGHT]))
- return MM_ERROR_INVALID_ARGUMENT;
-
- /* Save volume to handle. Currently the first array element will be saved. */
- player->sound.volume = volume.level[MM_VOLUME_CHANNEL_LEFT];
+ MMPLAYER_RETURN_VAL_IF_FAIL(prop_name, MM_ERROR_INVALID_ARGUMENT);
/* check pipeline handle */
if (!player->pipeline || !player->pipeline->audiobin) {
- LOGD("audiobin is not created yet\n");
- LOGD("but, current stored volume will be set when it's created.\n");
+ LOGD("'%s' will be applied when audiobin is created", prop_name);
- /* NOTE : stored volume will be used in create_audiobin
+ /* NOTE : stored value will be used in create_audiobin
* returning MM_ERROR_NONE here makes application to able to
- * set volume at anytime.
+ * set audio volume or mute at anytime.
*/
return MM_ERROR_NONE;
}
- /* setting volume to volume element */
- vol_element = player->pipeline->audiobin[MMPLAYER_A_VOL].gst;
+ if (player->build_audio_offload || g_strrstr(player->ini.audiosink_element, "pulsesink"))
+ volume_elem_id = MMPLAYER_A_SINK;
- if (vol_element) {
- LOGD("volume is set [%f]\n", player->sound.volume);
- g_object_set(vol_element, "volume", player->sound.volume, NULL);
+ vol_element = player->pipeline->audiobin[volume_elem_id].gst;
+ if (!vol_element) {
+ LOGE("failed to get vol element %d", volume_elem_id);
+ return MM_ERROR_PLAYER_INTERNAL;
}
- MMPLAYER_FLEAVE();
+ LOGD("set '%s' property to element[%s]", prop_name, GST_ELEMENT_NAME(vol_element));
+
+ if (!g_object_class_find_property(G_OBJECT_GET_CLASS(vol_element), prop_name)) {
+ LOGE("there is no '%s' property", prop_name);
+ return MM_ERROR_PLAYER_INTERNAL;
+ }
+
+ if (!strcmp(prop_name, "volume")) {
+ g_object_set(vol_element, "volume", player->sound.volume, NULL);
+ } else if (!strcmp(prop_name, "mute")) {
+ g_object_set(vol_element, "mute", player->sound.mute, NULL);
+ } else {
+ LOGE("invalid property %s", prop_name);
+ return MM_ERROR_PLAYER_INTERNAL;
+ }
return MM_ERROR_NONE;
}
-
int
-_mmplayer_get_volume(MMHandleType hplayer, MMPlayerVolumeType* volume)
+_mmplayer_set_volume(MMHandleType hplayer, float volume)
{
- mm_player_t* player = (mm_player_t*) hplayer;
- int i = 0;
+ int ret = MM_ERROR_NONE;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
MMPLAYER_FENTER();
-
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
- MMPLAYER_RETURN_VAL_IF_FAIL(volume, MM_ERROR_INVALID_ARGUMENT);
- /* returning stored volume */
- for (i = 0; i < MM_VOLUME_CHANNEL_NUM; i++)
- volume->level[i] = player->sound.volume;
+ LOGD("volume = %f", volume);
- MMPLAYER_FLEAVE();
+ /* invalid factor range or not */
+ if (volume < MM_VOLUME_FACTOR_MIN || volume > MM_VOLUME_FACTOR_MAX) {
+ LOGE("Invalid volume value");
+ return MM_ERROR_INVALID_ARGUMENT;
+ }
- return MM_ERROR_NONE;
+ player->sound.volume = volume;
+
+ ret = __mmplayer_gst_set_volume_property(player, "volume");
+
+ MMPLAYER_FLEAVE();
+ return ret;
}
int
-_mmplayer_set_mute(MMHandleType hplayer, int mute)
+_mmplayer_get_volume(MMHandleType hplayer, float *volume)
{
- mm_player_t* player = (mm_player_t*) hplayer;
- GstElement* vol_element = NULL;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
+ MMPLAYER_RETURN_VAL_IF_FAIL(volume, MM_ERROR_INVALID_ARGUMENT);
- /* mute value shoud 0 or 1 */
- if (mute != 0 && mute != 1) {
- LOGE("bad mute value\n");
-
- /* FIXIT : definitly, we need _BAD_PARAM error code */
- return MM_ERROR_INVALID_ARGUMENT;
- }
-
- player->sound.mute = mute;
-
- /* just hold mute value if pipeline is not ready */
- if (!player->pipeline || !player->pipeline->audiobin) {
- LOGD("pipeline is not ready. holding mute value\n");
- return MM_ERROR_NONE;
- }
-
- vol_element = player->pipeline->audiobin[MMPLAYER_A_VOL].gst;
+ *volume = player->sound.volume;
- /* NOTE : volume will only created when the bt is enabled */
- if (vol_element) {
- LOGD("mute : %d\n", mute);
- g_object_set(vol_element, "mute", mute, NULL);
- } else
- LOGD("volume elemnet is not created. using volume in audiosink\n");
+ LOGD("current vol = %f", *volume);
MMPLAYER_FLEAVE();
-
return MM_ERROR_NONE;
}
int
-_mmplayer_get_mute(MMHandleType hplayer, int* pmute)
+_mmplayer_set_mute(MMHandleType hplayer, bool mute)
{
- mm_player_t* player = (mm_player_t*) hplayer;
+ int ret = MM_ERROR_NONE;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
MMPLAYER_FENTER();
-
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
- MMPLAYER_RETURN_VAL_IF_FAIL(pmute, MM_ERROR_INVALID_ARGUMENT);
- /* just hold mute value if pipeline is not ready */
- if (!player->pipeline || !player->pipeline->audiobin) {
- LOGD("pipeline is not ready. returning stored value\n");
- *pmute = player->sound.mute;
- return MM_ERROR_NONE;
- }
+ LOGD("mute = %d", mute);
- *pmute = player->sound.mute;
+ player->sound.mute = mute;
- MMPLAYER_FLEAVE();
+ ret = __mmplayer_gst_set_volume_property(player, "mute");
- return MM_ERROR_NONE;
+ MMPLAYER_FLEAVE();
+ return ret;
}
int
-_mmplayer_set_videostream_changed_cb(MMHandleType hplayer, mm_player_stream_changed_callback callback, void *user_param)
+_mmplayer_get_mute(MMHandleType hplayer, bool *mute)
{
- mm_player_t* player = (mm_player_t*) hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
+ MMPLAYER_RETURN_VAL_IF_FAIL(mute, MM_ERROR_INVALID_ARGUMENT);
+
+ *mute = player->sound.mute;
- player->video_stream_changed_cb = callback;
- player->video_stream_changed_cb_user_param = user_param;
- LOGD("Handle value is %p : %p\n", player, player->video_stream_changed_cb);
+ LOGD("current mute = %d", *mute);
MMPLAYER_FLEAVE();
int
_mmplayer_set_audiostream_changed_cb(MMHandleType hplayer, mm_player_stream_changed_callback callback, void *user_param)
{
- mm_player_t* player = (mm_player_t*) hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
MMPLAYER_FENTER();
player->audio_stream_changed_cb = callback;
player->audio_stream_changed_cb_user_param = user_param;
- LOGD("Handle value is %p : %p\n", player, player->audio_stream_changed_cb);
+ LOGD("Handle value is %p : %p", player, player->audio_stream_changed_cb);
MMPLAYER_FLEAVE();
}
int
-_mmplayer_set_audiostream_cb(MMHandleType hplayer, bool sync, mm_player_audio_stream_callback callback, void *user_param)
+_mmplayer_set_audio_decoded_cb(MMHandleType hplayer, mmplayer_audio_extract_opt_e opt, mm_player_audio_decoded_callback callback, void *user_param)
{
- mm_player_t *player = (mm_player_t*) hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
- player->audio_stream_render_cb = callback;
- player->audio_stream_cb_user_param = user_param;
- player->audio_stream_sink_sync = sync;
- LOGD("handle: %p, cb: %p, sync: %d", player, player->audio_stream_render_cb, player->audio_stream_sink_sync);
+ player->audio_decoded_cb = callback;
+ player->audio_decoded_cb_user_param = user_param;
+ player->audio_extract_opt = opt;
+ LOGD("handle: %p, cb: %p, opt: 0x%X", player, player->audio_decoded_cb, player->audio_extract_opt);
MMPLAYER_FLEAVE();
}
int
-_mmplayer_set_videostream_cb(MMHandleType hplayer, mm_player_video_stream_callback callback, void *user_param)
+_mmplayer_set_video_decoded_cb(MMHandleType hplayer, mm_player_video_decoded_callback callback, void *user_param)
{
- mm_player_t* player = (mm_player_t*) hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
MMPLAYER_FENTER();
if (callback && !player->bufmgr)
player->bufmgr = tbm_bufmgr_init(-1);
- player->set_mode.media_packet_video_stream = (callback) ? true : false;
- player->video_stream_cb = callback;
- player->video_stream_cb_user_param = user_param;
+ player->set_mode.video_export = (callback) ? true : false;
+ player->video_decoded_cb = callback;
+ player->video_decoded_cb_user_param = user_param;
- LOGD("Stream cb Handle value is %p : %p, enable:%d\n", player, player->video_stream_cb, player->set_mode.media_packet_video_stream);
+ LOGD("Stream cb Handle value is %p : %p, enable:%d", player, player->video_decoded_cb, player->set_mode.video_export);
MMPLAYER_FLEAVE();
return MM_ERROR_NONE;
}
-static int
-__mmplayer_start_streaming_ext(mm_player_t *player)
-{
- gint ret = MM_ERROR_NONE;
-
- MMPLAYER_FENTER();
- MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
-
- if (MMPLAYER_IS_HTTP_PD(player)) {
- if (!player->pd_downloader) {
- ret = __mmplayer_realize_streaming_ext(player);
-
- if (ret != MM_ERROR_NONE) {
- LOGE("failed to realize streaming ext\n");
- return ret;
- }
- }
-
- if (player->pd_downloader && player->pd_mode == MM_PLAYER_PD_MODE_URI) {
- ret = _mmplayer_start_pd_downloader((MMHandleType)player);
- if (!ret) {
- LOGE("ERROR while starting PD...\n");
- return MM_ERROR_PLAYER_NOT_INITIALIZED;
- }
- ret = MM_ERROR_NONE;
- }
- }
-
- MMPLAYER_FLEAVE();
- return ret;
-}
-
int
_mmplayer_start(MMHandleType hplayer)
{
- mm_player_t* player = (mm_player_t*) hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
gint ret = MM_ERROR_NONE;
MMPLAYER_FENTER();
/* check current state */
MMPLAYER_CHECK_STATE(player, MMPLAYER_COMMAND_START);
- /* PD - start streaming */
- ret = __mmplayer_start_streaming_ext(player);
- if (ret != MM_ERROR_NONE) {
- LOGE("failed to start streaming ext 0x%X", ret);
- return ret;
- }
-
/* start pipeline */
- ret = __mmplayer_gst_start(player);
+ ret = _mmplayer_gst_start(player);
if (ret != MM_ERROR_NONE)
- LOGE("failed to start player.\n");
+ LOGE("failed to start player.");
if ((player->streamer) && (player->streamer->buffering_state & MM_PLAYER_BUFFERING_IN_PROGRESS)) {
LOGD("force playing start even during buffering");
* Because GST_ERROR_MESSAGE is posted by other plugin internally.
*/
int
-__mmplayer_handle_missed_plugin(mm_player_t* player)
+__mmplayer_handle_missed_plugin(mmplayer_t *player)
{
MMMessageParamType msg_param;
memset(&msg_param, 0, sizeof(MMMessageParamType));
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
- LOGD("not_supported_codec = 0x%02x, can_support_codec = 0x%02x\n",
+ LOGD("not_supported_codec = 0x%02x, can_support_codec = 0x%02x",
player->not_supported_codec, player->can_support_codec);
if (player->not_found_demuxer) {
memset(&msg_param, 0, sizeof(MMMessageParamType));
if (player->not_supported_codec == MISSING_PLUGIN_AUDIO) {
- LOGW("not found AUDIO codec, posting error code to application.\n");
+ LOGW("not found AUDIO codec, posting error code to application.");
msg_param.code = MM_ERROR_PLAYER_AUDIO_CODEC_NOT_FOUND;
msg_param.data = g_strdup_printf("%s", player->unlinked_audio_mime);
} else if (player->not_supported_codec == MISSING_PLUGIN_VIDEO) {
- LOGW("not found VIDEO codec, posting error code to application.\n");
+ LOGW("not found VIDEO codec, posting error code to application.");
msg_param.code = MM_ERROR_PLAYER_VIDEO_CODEC_NOT_FOUND;
msg_param.data = g_strdup_printf("%s", player->unlinked_video_mime);
return MM_ERROR_NONE;
} else {
// no any supported codec case
- LOGW("not found any codec, posting error code to application.\n");
+ LOGW("not found any codec, posting error code to application.");
if (player->not_supported_codec == MISSING_PLUGIN_AUDIO) {
msg_param.code = MM_ERROR_PLAYER_AUDIO_CODEC_NOT_FOUND;
return MM_ERROR_NONE;
}
-static void __mmplayer_check_pipeline(mm_player_t* player)
+static void __mmplayer_check_pipeline_reconfigure_state(mmplayer_t *player)
{
GstState element_state = GST_STATE_VOID_PENDING;
GstState element_pending_state = GST_STATE_VOID_PENDING;
- gint timeout = 0;
- int ret = MM_ERROR_NONE;
+ GstStateChangeReturn result = GST_STATE_CHANGE_FAILURE;
+ gint timeout = MMPLAYER_STATE_CHANGE_TIMEOUT(player);
- if (player->gapless.reconfigure) {
- LOGW("pipeline is under construction.\n");
+ MMPLAYER_RETURN_IF_FAIL(player && player->pipeline);
- MMPLAYER_PLAYBACK_LOCK(player);
- MMPLAYER_PLAYBACK_UNLOCK(player);
+ MMPLAYER_RECONFIGURE_LOCK(player);
+ if (!player->gapless.reconfigure) {
+ MMPLAYER_RECONFIGURE_UNLOCK(player);
+ return;
+ }
- timeout = MMPLAYER_STATE_CHANGE_TIMEOUT(player);
+ LOGI("reconfigure is under process");
+ MMPLAYER_RECONFIGURE_WAIT(player);
+ MMPLAYER_RECONFIGURE_UNLOCK(player);
+ LOGI("reconfigure is completed.");
- /* wait for state transition */
- ret = gst_element_get_state(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, &element_state, &element_pending_state, timeout * GST_SECOND);
+ result = gst_element_get_state(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst,
+ &element_state, &element_pending_state, timeout * GST_SECOND);
+ if (result == GST_STATE_CHANGE_FAILURE)
+ LOGW("failed to get pipeline state in %d sec", timeout);
- if (ret == GST_STATE_CHANGE_FAILURE)
- LOGE("failed to change pipeline state within %d sec\n", timeout);
- }
+ return;
}
/* NOTE : it should be able to call 'stop' anytime*/
int
_mmplayer_stop(MMHandleType hplayer)
{
- mm_player_t* player = (mm_player_t*)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
int ret = MM_ERROR_NONE;
MMPLAYER_FENTER();
/* check current state */
MMPLAYER_CHECK_STATE(player, MMPLAYER_COMMAND_STOP);
- /* check pipline building state */
- __mmplayer_check_pipeline(player);
+ /* need to wait till the rebuilding pipeline is completed */
+ __mmplayer_check_pipeline_reconfigure_state(player);
+ MMPLAYER_RECONFIGURE_LOCK(player);
__mmplayer_reset_gapless_state(player);
+ MMPLAYER_RECONFIGURE_UNLOCK(player);
/* NOTE : application should not wait for EOS after calling STOP */
- __mmplayer_cancel_eos_timer(player);
-
- __mmplayer_unrealize_streaming_ext(player);
+ _mmplayer_cancel_eos_timer(player);
/* reset */
player->seek_state = MMPLAYER_SEEK_NONE;
/* stop pipeline */
- ret = __mmplayer_gst_stop(player);
+ ret = _mmplayer_gst_stop(player);
if (ret != MM_ERROR_NONE)
- LOGE("failed to stop player.\n");
+ LOGE("failed to stop player.");
MMPLAYER_FLEAVE();
int
_mmplayer_pause(MMHandleType hplayer)
{
- mm_player_t* player = (mm_player_t*)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
gint64 pos_nsec = 0;
gboolean async = FALSE;
gint ret = MM_ERROR_NONE;
/* check current state */
MMPLAYER_CHECK_STATE(player, MMPLAYER_COMMAND_PAUSE);
- /* check pipline building state */
- __mmplayer_check_pipeline(player);
+ /* check pipline reconfigure state */
+ __mmplayer_check_pipeline_reconfigure_state(player);
switch (MMPLAYER_CURRENT_STATE(player)) {
case MM_PLAYER_STATE_READY:
* elements
*/
if (!gst_element_query_position(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, GST_FORMAT_TIME, &pos_nsec))
- LOGW("getting current position failed in paused\n");
+ LOGW("getting current position failed in paused");
player->last_position = pos_nsec;
This causes problem is position calculation during normal pause resume scenarios also.
Currently during pause , we are sending the current position to rtspsrc module for position saving. */
if ((MMPLAYER_IS_RTSP_STREAMING(player)) &&
- (__mmplayer_get_stream_service_type(player) == STREAMING_SERVICE_VOD)) {
+ (_mmplayer_get_stream_service_type(player) == STREAMING_SERVICE_VOD)) {
g_object_set(player->pipeline->mainbin[MMPLAYER_M_SRC].gst, "resume-position", player->last_position, NULL);
}
}
}
/* pause pipeline */
- ret = __mmplayer_gst_pause(player, async);
+ ret = _mmplayer_gst_pause(player, async);
if (ret != MM_ERROR_NONE)
- LOGE("failed to pause player. ret : 0x%x\n", ret);
+ LOGE("failed to pause player. ret : 0x%x", ret);
if (MMPLAYER_PREV_STATE(player) == MM_PLAYER_STATE_READY && MMPLAYER_CURRENT_STATE(player) == MM_PLAYER_STATE_PAUSED) {
- if (MM_ERROR_NONE != _mmplayer_update_video_param(player, "display_rotation"))
+ if (_mmplayer_update_video_overlay_param(player, "display_rotation") != MM_ERROR_NONE)
LOGE("failed to update display_rotation");
}
int
_mmplayer_abort_pause(MMHandleType hplayer)
{
- mm_player_t* player = (mm_player_t*)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
int ret = MM_ERROR_NONE;
MMPLAYER_FENTER();
LOGD("set the pipeline state to READY");
/* set state to READY */
- ret = __mmplayer_gst_set_state(player, player->pipeline->mainbin[MMPLAYER_M_PIPE].gst,
+ ret = _mmplayer_gst_set_state(player, player->pipeline->mainbin[MMPLAYER_M_PIPE].gst,
GST_STATE_READY, FALSE, MMPLAYER_STATE_CHANGE_TIMEOUT(player));
if (ret != MM_ERROR_NONE) {
LOGE("fail to change state to READY");
return ret;
}
-
int
_mmplayer_resume(MMHandleType hplayer)
{
- mm_player_t* player = (mm_player_t*)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
int ret = MM_ERROR_NONE;
gboolean async = FALSE;
/* check current state */
MMPLAYER_CHECK_STATE(player, MMPLAYER_COMMAND_RESUME);
- ret = __mmplayer_gst_resume(player, async);
+ ret = _mmplayer_gst_resume(player, async);
if (ret != MM_ERROR_NONE)
- LOGE("failed to resume player.\n");
+ LOGE("failed to resume player.");
if ((player->streamer) && (player->streamer->buffering_state & MM_PLAYER_BUFFERING_IN_PROGRESS)) {
LOGD("force resume even during buffering");
int
_mmplayer_set_playspeed(MMHandleType hplayer, float rate, bool streaming)
{
- mm_player_t* player = (mm_player_t*)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
gint64 pos_nsec = 0;
int ret = MM_ERROR_NONE;
- int mute = FALSE;
+ bool mute = false;
signed long long start = 0, stop = 0;
- MMPlayerStateType current_state = MM_PLAYER_STATE_NONE;
+ mmplayer_state_e current_state = MM_PLAYER_STATE_NONE;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player && player->pipeline, MM_ERROR_PLAYER_NOT_INITIALIZED);
/* The sound of video is not supported under 0.0 and over 2.0. */
if (rate >= TRICK_PLAY_MUTE_THRESHOLD_MAX || rate < TRICK_PLAY_MUTE_THRESHOLD_MIN) {
if (player->can_support_codec & FOUND_PLUGIN_VIDEO)
- mute = TRUE;
+ mute = true;
}
_mmplayer_set_mute(hplayer, mute);
/* If the position is reached at start potion during fast backward, EOS is posted.
* So, This EOS have to be classified with it which is posted at reaching the end of stream.
- * */
+ */
player->playback_rate = rate;
current_state = MMPLAYER_CURRENT_STATE(player);
stop = pos_nsec;
}
- if (!__mmplayer_gst_seek(player, player->pipeline->mainbin[MMPLAYER_M_PIPE].gst,
+ if (!_mmplayer_gst_seek(player, player->pipeline->mainbin[MMPLAYER_M_PIPE].gst,
player->playback_rate,
GST_FORMAT_TIME,
(GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_ACCURATE),
GST_SEEK_TYPE_SET, start,
GST_SEEK_TYPE_SET, stop)) {
- LOGE("failed to set speed playback\n");
+ LOGE("failed to set speed playback");
return MM_ERROR_PLAYER_SEEK;
}
- LOGD("succeeded to set speed playback as %0.1f\n", rate);
+ LOGD("succeeded to set speed playback as %0.1f", rate);
MMPLAYER_FLEAVE();
int
_mmplayer_set_position(MMHandleType hplayer, gint64 position)
{
- mm_player_t* player = (mm_player_t*)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
int ret = MM_ERROR_NONE;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
- /* check pipline building state */
- __mmplayer_check_pipeline(player);
+ /* check pipline reconfigure state */
+ __mmplayer_check_pipeline_reconfigure_state(player);
- ret = __mmplayer_gst_set_position(player, position, FALSE);
+ ret = _mmplayer_gst_set_position(player, position, FALSE);
MMPLAYER_FLEAVE();
}
int
-_mmplayer_get_position(MMHandleType hplayer, gint64 *position)
-{
- mm_player_t* player = (mm_player_t*)hplayer;
- int ret = MM_ERROR_NONE;
-
- MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
-
- ret = __mmplayer_gst_get_position(player, position);
-
- return ret;
-}
-
-int
_mmplayer_get_duration(MMHandleType hplayer, gint64 *duration)
{
- mm_player_t* player = (mm_player_t*)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
int ret = MM_ERROR_NONE;
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
MMPLAYER_RETURN_VAL_IF_FAIL(duration, MM_ERROR_COMMON_INVALID_ARGUMENT);
+ if (g_strrstr(player->type, "video/mpegts"))
+ __mmplayer_update_duration_value(player);
+
*duration = player->duration;
return ret;
}
int
-_mmplayer_get_buffer_position(MMHandleType hplayer, int format, unsigned long* start_pos, unsigned long* stop_pos)
+_mmplayer_get_buffer_position(MMHandleType hplayer, int *start_pos, int *end_pos)
{
- mm_player_t* player = (mm_player_t*)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
int ret = MM_ERROR_NONE;
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
- ret = __mmplayer_gst_get_buffer_position(player, format, start_pos, stop_pos);
+ ret = _mmplayer_gst_get_buffer_position(player, start_pos, end_pos);
return ret;
}
int
-_mmplayer_adjust_subtitle_postion(MMHandleType hplayer, int format, int position)
+_mmplayer_adjust_subtitle_postion(MMHandleType hplayer, int position)
{
- mm_player_t* player = (mm_player_t*)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
int ret = MM_ERROR_NONE;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
- ret = __mmplayer_gst_adjust_subtitle_position(player, format, position);
+ ret = __mmplayer_gst_adjust_subtitle_position(player, position);
MMPLAYER_FLEAVE();
}
static gboolean
-__mmplayer_is_midi_type(gchar* str_caps)
+__mmplayer_is_midi_type(gchar *str_caps)
{
if ((g_strrstr(str_caps, "audio/midi")) ||
(g_strrstr(str_caps, "application/x-gst_ff-mmf")) ||
(g_strrstr(str_caps, "audio/mobile-xmf")) ||
(g_strrstr(str_caps, "audio/xmf")) ||
(g_strrstr(str_caps, "audio/mxmf"))) {
- LOGD("midi\n");
+ LOGD("midi");
return TRUE;
}
__mmplayer_is_only_mp3_type(gchar *str_caps)
{
if (g_strrstr(str_caps, "application/x-id3") ||
- (g_strrstr(str_caps, "audio/mpeg") && g_strrstr(str_caps, "mpegversion= (int)1")))
+ (g_strrstr(str_caps, "audio/mpeg") && g_strrstr(str_caps, "mpegversion=(int)1")))
return TRUE;
return FALSE;
}
-static void
-__mmplayer_set_audio_attrs(mm_player_t* player, GstCaps* caps)
+void
+_mmplayer_set_audio_attrs(mmplayer_t *player, GstCaps *caps)
{
- GstStructure* caps_structure = NULL;
+ GstStructure *caps_structure = NULL;
gint samplerate = 0;
gint channels = 0;
/* set stream information */
gst_structure_get_int(caps_structure, "rate", &samplerate);
- mm_attrs_set_int_by_name(player->attrs, "content_audio_samplerate", samplerate);
-
gst_structure_get_int(caps_structure, "channels", &channels);
- mm_attrs_set_int_by_name(player->attrs, "content_audio_channels", channels);
- LOGD("audio samplerate : %d channels : %d\n", samplerate, channels);
+ mm_player_set_attribute((MMHandleType)player, NULL,
+ "content_audio_samplerate", samplerate,
+ "content_audio_channels", channels, NULL);
+
+ LOGD("audio samplerate : %d channels : %d", samplerate, channels);
}
static void
-__mmplayer_update_content_type_info(mm_player_t* player)
+__mmplayer_update_content_type_info(mmplayer_t *player)
{
MMPLAYER_FENTER();
MMPLAYER_RETURN_IF_FAIL(player && player->type);
if (__mmplayer_is_midi_type(player->type)) {
player->bypass_audio_effect = TRUE;
- } else if (g_strrstr(player->type, "application/x-hls")) {
+ return;
+ }
+
+ if (!player->streamer) {
+ LOGD("no need to check streaming type");
+ return;
+ }
+
+ if (g_strrstr(player->type, "application/x-hls")) {
/* If it can't know exact type when it parses uri because of redirection case,
* it will be fixed by typefinder or when doing autoplugging.
*/
player->profile.uri_type = MM_PLAYER_URI_TYPE_HLS;
- if (player->streamer) {
- player->streamer->is_adaptive_streaming = TRUE;
- player->streamer->buffering_req.mode = MM_PLAYER_BUFFERING_MODE_FIXED;
- player->streamer->buffering_req.rebuffer_time = 5 * 1000;
- }
+ player->streamer->is_adaptive_streaming = TRUE;
} else if (g_strrstr(player->type, "application/dash+xml")) {
player->profile.uri_type = MM_PLAYER_URI_TYPE_DASH;
- if (player->streamer) {
- player->streamer->is_adaptive_streaming = TRUE;
- player->streamer->buffering_req.mode = MM_PLAYER_BUFFERING_MODE_FIXED;
+ player->streamer->is_adaptive_streaming = TRUE;
+ }
+
+ /* in case of TS, fixed buffering mode should be used because player can not get exact duration time */
+ if ((player->streamer->is_adaptive_streaming) || (g_strrstr(player->type, "video/mpegts"))) {
+ player->streamer->buffering_req.mode = MM_PLAYER_BUFFERING_MODE_FIXED;
+
+ if (player->streamer->buffering_req.rebuffer_time <= MIN_BUFFERING_TIME) { /* if user did not set the rebuffer value */
+ if (player->streamer->is_adaptive_streaming)
+ player->streamer->buffering_req.rebuffer_time = DEFAULT_ADAPTIVE_REBUFFER_TIME;
+ else
+ player->streamer->buffering_req.rebuffer_time = DEFAULT_REBUFFERING_TIME;
}
}
- LOGD("uri type : %d", player->profile.uri_type);
+ LOGD("uri type : %d, %d", player->profile.uri_type, player->streamer->buffering_req.rebuffer_time);
MMPLAYER_FLEAVE();
}
void
-__mmplayer_typefind_have_type(GstElement *tf, guint probability,
-GstCaps *caps, gpointer data)
+_mmplayer_typefind_have_type(GstElement *tf, guint probability,
+ GstCaps *caps, gpointer data)
{
- mm_player_t* player = (mm_player_t*)data;
- GstPad* pad = NULL;
+ mmplayer_t *player = (mmplayer_t *)data;
MMPLAYER_FENTER();
/* store type string */
MMPLAYER_FREEIF(player->type);
player->type = gst_caps_to_string(caps);
- if (player->type) {
- LOGD("[handle: %p] media type %s found, probability %d%% / %d\n",
+ if (player->type)
+ LOGD("[handle: %p] media type %s found, probability %d%% / %d",
player, player->type, probability, gst_caps_get_size(caps));
- }
if ((!MMPLAYER_IS_RTSP_STREAMING(player)) &&
(g_strrstr(player->type, "audio/x-raw-int"))) {
- LOGE("not support media format\n");
+ LOGE("not support media format");
if (player->msg_posted == FALSE) {
MMMessageParamType msg_param;
__mmplayer_update_content_type_info(player);
- pad = gst_element_get_static_pad(tf, "src");
- if (!pad) {
- LOGE("fail to get typefind src pad.\n");
- return;
- }
+ if (!player->pipeline->mainbin[MMPLAYER_M_AUTOPLUG].gst) {
+ GstPad *pad = NULL;
- if (!__mmplayer_gst_create_decoder(player, pad, caps)) {
- gboolean async = FALSE;
- LOGE("failed to autoplug %s\n", player->type);
+ pad = gst_element_get_static_pad(tf, "src");
+ if (!pad) {
+ LOGE("fail to get typefind src pad.");
+ return;
+ }
- mm_attrs_get_int_by_name(player->attrs, "profile_prepare_async", &async);
+ if (!_mmplayer_gst_create_decoder(player, pad, caps)) {
+ gboolean async = FALSE;
+ LOGE("failed to autoplug %s", player->type);
- if (async && player->msg_posted == FALSE)
- __mmplayer_handle_missed_plugin(player);
+ mm_attrs_get_int_by_name(player->attrs, "profile_prepare_async", &async);
- goto DONE;
+ if (async && player->msg_posted == FALSE)
+ __mmplayer_handle_missed_plugin(player);
+ }
+ gst_object_unref(GST_OBJECT(pad));
}
-
-DONE:
- gst_object_unref(GST_OBJECT(pad));
-
MMPLAYER_FLEAVE();
-
return;
}
GstElement *
-__mmplayer_gst_make_decodebin(mm_player_t* player)
+_mmplayer_gst_make_decodebin(mmplayer_t *player)
{
GstElement *decodebin = NULL;
decodebin = gst_element_factory_make("decodebin", NULL);
if (!decodebin) {
- LOGE("fail to create decodebin\n");
+ LOGE("fail to create decodebin");
goto ERROR;
}
/* raw pad handling signal */
- __mmplayer_add_signal_connection(player, G_OBJECT(decodebin), MM_PLAYER_SIGNAL_TYPE_AUTOPLUG, "pad-added",
- G_CALLBACK(__mmplayer_gst_decode_pad_added), (gpointer)player);
+ _mmplayer_add_signal_connection(player, G_OBJECT(decodebin), MM_PLAYER_SIGNAL_TYPE_AUTOPLUG, "pad-added",
+ G_CALLBACK(_mmplayer_gst_decode_pad_added), (gpointer)player);
/* no-more-pad pad handling signal */
- __mmplayer_add_signal_connection(player, G_OBJECT(decodebin), MM_PLAYER_SIGNAL_TYPE_AUTOPLUG, "no-more-pads",
- G_CALLBACK(__mmplayer_gst_decode_no_more_pads), (gpointer)player);
+ _mmplayer_add_signal_connection(player, G_OBJECT(decodebin), MM_PLAYER_SIGNAL_TYPE_AUTOPLUG, "no-more-pads",
+ G_CALLBACK(_mmplayer_gst_decode_no_more_pads), (gpointer)player);
- __mmplayer_add_signal_connection(player, G_OBJECT(decodebin), MM_PLAYER_SIGNAL_TYPE_AUTOPLUG, "pad-removed",
- G_CALLBACK(__mmplayer_gst_decode_pad_removed), (gpointer)player);
+ _mmplayer_add_signal_connection(player, G_OBJECT(decodebin), MM_PLAYER_SIGNAL_TYPE_AUTOPLUG, "pad-removed",
+ G_CALLBACK(_mmplayer_gst_decode_pad_removed), (gpointer)player);
/* This signal is emitted when a pad for which there is no further possible
decoding is added to the decodebin.*/
- __mmplayer_add_signal_connection(player, G_OBJECT(decodebin), MM_PLAYER_SIGNAL_TYPE_AUTOPLUG, "unknown-type",
- G_CALLBACK(__mmplayer_gst_decode_unknown_type), (gpointer)player);
+ _mmplayer_add_signal_connection(player, G_OBJECT(decodebin), MM_PLAYER_SIGNAL_TYPE_AUTOPLUG, "unknown-type",
+ G_CALLBACK(_mmplayer_gst_decode_unknown_type), (gpointer)player);
/* This signal is emitted whenever decodebin finds a new stream. It is emitted
before looking for any elements that can handle that stream.*/
- __mmplayer_add_signal_connection(player, G_OBJECT(decodebin), MM_PLAYER_SIGNAL_TYPE_AUTOPLUG, "autoplug-continue",
- G_CALLBACK(__mmplayer_gst_decode_autoplug_continue), (gpointer)player);
+ _mmplayer_add_signal_connection(player, G_OBJECT(decodebin), MM_PLAYER_SIGNAL_TYPE_AUTOPLUG, "autoplug-continue",
+ G_CALLBACK(_mmplayer_gst_decode_autoplug_continue), (gpointer)player);
+
+ if (player->need_video_dec_sorting || player->need_audio_dec_sorting)
+ _mmplayer_add_signal_connection(player, G_OBJECT(decodebin), MM_PLAYER_SIGNAL_TYPE_AUTOPLUG, "autoplug-sort",
+ G_CALLBACK(_mmplayer_gst_decode_autoplug_sort), (gpointer)player);
/* This signal is emitted whenever decodebin finds a new stream. It is emitted
before looking for any elements that can handle that stream.*/
- __mmplayer_add_signal_connection(player, G_OBJECT(decodebin), MM_PLAYER_SIGNAL_TYPE_AUTOPLUG, "autoplug-select",
- G_CALLBACK(__mmplayer_gst_decode_autoplug_select), (gpointer)player);
+ _mmplayer_add_signal_connection(player, G_OBJECT(decodebin), MM_PLAYER_SIGNAL_TYPE_AUTOPLUG, "autoplug-select",
+ G_CALLBACK(_mmplayer_gst_decode_autoplug_select), (gpointer)player);
/* This signal is emitted once decodebin has finished decoding all the data.*/
- __mmplayer_add_signal_connection(player, G_OBJECT(decodebin), MM_PLAYER_SIGNAL_TYPE_AUTOPLUG, "drained",
- G_CALLBACK(__mmplayer_gst_decode_drained), (gpointer)player);
+ _mmplayer_add_signal_connection(player, G_OBJECT(decodebin), MM_PLAYER_SIGNAL_TYPE_AUTOPLUG, "drained",
+ G_CALLBACK(_mmplayer_gst_decode_drained), (gpointer)player);
/* This signal is emitted when a element is added to the bin.*/
- __mmplayer_add_signal_connection(player, G_OBJECT(decodebin), MM_PLAYER_SIGNAL_TYPE_AUTOPLUG, "element-added",
- G_CALLBACK(__mmplayer_gst_element_added), (gpointer)player);
+ _mmplayer_add_signal_connection(player, G_OBJECT(decodebin), MM_PLAYER_SIGNAL_TYPE_AUTOPLUG, "element-added",
+ G_CALLBACK(_mmplayer_gst_element_added), (gpointer)player);
ERROR:
return decodebin;
}
-static GstElement*
-__mmplayer_gst_make_queue2(mm_player_t *player)
+static GstElement *
+__mmplayer_gst_make_queue2(mmplayer_t *player)
{
- GstElement* queue2 = NULL;
+ GstElement *queue2 = NULL;
gint64 dur_bytes = 0L;
- guint max_buffer_size_bytes = 0;
- MMPlayerGstElement *mainbin = NULL;
- MuxedBufferType type = MUXED_BUFFER_TYPE_MEM_QUEUE;
+ mmplayer_gst_element_t *mainbin = NULL;
+ muxed_buffer_type_e type = MUXED_BUFFER_TYPE_MEM_QUEUE;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player && player->pipeline && player->pipeline->mainbin, NULL);
}
if (!gst_element_query_duration(mainbin[MMPLAYER_M_SRC].gst, GST_FORMAT_BYTES, &dur_bytes))
- LOGE("failed to get duration from source %s", GST_ELEMENT_NAME(mainbin[MMPLAYER_M_SRC].gst));
+ LOGW("failed to get duration from source %s", GST_ELEMENT_NAME(mainbin[MMPLAYER_M_SRC].gst));
LOGD("dur_bytes = %"G_GINT64_FORMAT, dur_bytes);
+ /* NOTE : in case of ts streaming, player could not get the correct duration info *
+ * skip the pull mode(file or ring buffering) setting. */
if (dur_bytes > 0) {
- if (MMPLAYER_USE_FILE_FOR_BUFFERING(player)) {
- type = MUXED_BUFFER_TYPE_FILE;
- } else {
+ if (!g_strrstr(player->type, "video/mpegts")) {
type = MUXED_BUFFER_TYPE_MEM_RING_BUFFER;
player->streamer->ring_buffer_size = player->ini.http_ring_buffer_size;
}
dur_bytes = 0;
}
- /* NOTE : in case of ts streaming, player cannot get the correct duration info *
- * skip the pull mode(file or ring buffering) setting. */
- if (!g_strrstr(player->type, "video/mpegts")) {
- max_buffer_size_bytes = (type == MUXED_BUFFER_TYPE_FILE) ? (player->ini.http_max_size_bytes) : (5*1024*1024);
- LOGD("max_buffer_size_bytes = %d", max_buffer_size_bytes);
-
- __mm_player_streaming_set_queue2(player->streamer,
- queue2,
- FALSE,
- max_buffer_size_bytes,
- player->ini.http_buffering_time,
- 1.0, /* no meaning */
- player->ini.http_buffering_limit, /* no meaning */
- type,
- player->http_file_buffering_path,
- (guint64)dur_bytes);
- }
+ _mm_player_streaming_set_queue2(player->streamer,
+ queue2,
+ FALSE,
+ type,
+ (guint64)dur_bytes); /* no meaning at the moment */
return queue2;
}
gboolean
-__mmplayer_gst_create_decoder(mm_player_t* player, GstPad *srcpad, const GstCaps *caps)
+_mmplayer_gst_create_decoder(mmplayer_t *player, GstPad *srcpad, const GstCaps *caps)
{
- MMPlayerGstElement* mainbin = NULL;
- GstElement* decodebin = NULL;
- GstElement* queue2 = NULL;
- GstPad* sinkpad = NULL;
- GstPad* qsrcpad = NULL;
- gint init_buffering_time = player->streamer->buffering_req.prebuffer_time;
+ mmplayer_gst_element_t *mainbin = NULL;
+ GstElement *decodebin = NULL;
+ GstElement *queue2 = NULL;
+ GstPad *sinkpad = NULL;
+ GstPad *qsrcpad = NULL;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player && player->pipeline && player->pipeline->mainbin, FALSE);
mainbin = player->pipeline->mainbin;
- if ((!MMPLAYER_IS_HTTP_PD(player)) && (MMPLAYER_IS_HTTP_STREAMING(player))) {
+ if (MMPLAYER_IS_HTTP_STREAMING(player)) {
if (mainbin[MMPLAYER_M_MUXED_S_BUFFER].gst) {
LOGW("need to check: muxed buffer is not null");
}
/* create decodebin */
- decodebin = __mmplayer_gst_make_decodebin(player);
+ decodebin = _mmplayer_gst_make_decodebin(player);
if (!decodebin) {
LOGE("failed to make decodebin");
goto ERROR;
}
if (!gst_bin_add(GST_BIN(mainbin[MMPLAYER_M_PIPE].gst), decodebin)) {
- LOGE("failed to add decodebin\n");
+ LOGE("failed to add decodebin");
goto ERROR;
}
gst_object_unref(GST_OBJECT(sinkpad));
sinkpad = NULL;
+ gst_object_unref(GST_OBJECT(qsrcpad));
+ qsrcpad = NULL;
mainbin[MMPLAYER_M_AUTOPLUG].id = MMPLAYER_M_AUTOPLUG;
mainbin[MMPLAYER_M_AUTOPLUG].gst = decodebin;
/* set decodebin property about buffer in streaming playback. *
* in case of HLS/DASH, it does not need to have big buffer *
* because it is kind of adaptive streaming. */
- if (!MMPLAYER_IS_HTTP_PD(player) &&
- (MMPLAYER_IS_HTTP_STREAMING(player) || MMPLAYER_IS_HTTP_LIVE_STREAMING(player) || MMPLAYER_IS_DASH_STREAMING(player))) {
- gdouble high_percent = 0.0;
+ if (MMPLAYER_IS_HTTP_STREAMING(player) || MMPLAYER_IS_HTTP_LIVE_STREAMING(player) || MMPLAYER_IS_DASH_STREAMING(player)) {
+ gint init_buffering_time = DEFAULT_PREBUFFERING_TIME;
+ gint high_percent = 0;
- init_buffering_time = (init_buffering_time != 0) ? (init_buffering_time) : (player->ini.http_buffering_time);
- high_percent = (gdouble)(init_buffering_time * 100) / GET_MAX_BUFFER_TIME(player->streamer);
+ if (player->streamer->buffering_req.prebuffer_time > MIN_BUFFERING_TIME)
+ init_buffering_time = player->streamer->buffering_req.prebuffer_time;
- LOGD("decodebin setting - bytes: %d, time: %d ms, per: 1~%d",
- GET_MAX_BUFFER_BYTES(player->streamer), GET_MAX_BUFFER_TIME(player->streamer), (gint)high_percent);
+ high_percent = (gint)ceil((gdouble)(init_buffering_time * 100) / MAX_BUFFER_SIZE_TIME);
+
+ LOGD("buffering time %d, per: 1~%d", init_buffering_time, high_percent);
g_object_set(G_OBJECT(decodebin), "use-buffering", TRUE,
- "high-percent", (gint)high_percent,
- "low-percent", (gint)DEFAULT_BUFFER_LOW_PERCENT,
- "max-size-bytes", GET_MAX_BUFFER_BYTES(player->streamer),
- "max-size-time", (guint64)(GET_MAX_BUFFER_TIME(player->streamer) * GST_MSECOND),
+ "high-percent", high_percent,
+ "max-size-bytes", MAX_BUFFER_SIZE_BYTES,
+ "max-size-time", (guint64)(MAX_BUFFER_SIZE_TIME * GST_MSECOND),
"max-size-buffers", 0, NULL); // disable or automatic
}
- if (GST_STATE_CHANGE_FAILURE == gst_element_sync_state_with_parent(decodebin)) {
- LOGE("failed to sync decodebin state with parent\n");
+ if (gst_element_sync_state_with_parent(decodebin) == GST_STATE_CHANGE_FAILURE) {
+ LOGE("failed to sync decodebin state with parent");
goto ERROR;
}
if (sinkpad)
gst_object_unref(GST_OBJECT(sinkpad));
+ if (qsrcpad)
+ gst_object_unref(GST_OBJECT(qsrcpad));
+
if (queue2) {
/* NOTE : Trying to dispose element queue0, but it is in READY instead of the NULL state.
* You need to explicitly set elements to the NULL state before
}
static int
-__mmplayer_check_not_supported_codec(mm_player_t* player, const gchar* factory_class, const gchar* mime)
+__mmplayer_check_not_supported_codec(mmplayer_t *player, const gchar *factory_class, const gchar *mime)
{
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player && player->pipeline, MM_ERROR_PLAYER_NOT_INITIALIZED);
MMPLAYER_RETURN_VAL_IF_FAIL(mime, MM_ERROR_INVALID_ARGUMENT);
- LOGD("class : %s, mime : %s \n", factory_class, mime);
+ LOGD("class : %s, mime : %s", factory_class, mime);
/* add missing plugin */
/* NOTE : msl should check missing plugin for image mime type.
*/
if (!(player->pipeline->mainbin[MMPLAYER_M_DEMUX].gst)) {
if (!(player->can_support_codec | player->videodec_linked | player->audiodec_linked)) {
- LOGD("not found demuxer\n");
+ LOGD("not found demuxer");
player->not_found_demuxer = TRUE;
player->unlinked_demuxer_mime = g_strdup_printf("%s", mime);
if (!g_strrstr(factory_class, "Demuxer")) {
if ((g_str_has_prefix(mime, "video")) || (g_str_has_prefix(mime, "image"))) {
- LOGD("can support codec=0x%X, vdec_linked=%d, adec_linked=%d\n",
+ LOGD("can support codec=0x%X, vdec_linked=%d, adec_linked=%d",
player->can_support_codec, player->videodec_linked, player->audiodec_linked);
/* check that clip have multi tracks or not */
if ((player->can_support_codec & FOUND_PLUGIN_VIDEO) && (player->videodec_linked)) {
- LOGD("video plugin is already linked\n");
+ LOGD("video plugin is already linked");
} else {
- LOGW("add VIDEO to missing plugin\n");
+ LOGW("add VIDEO to missing plugin");
player->not_supported_codec |= MISSING_PLUGIN_VIDEO;
player->unlinked_video_mime = g_strdup_printf("%s", mime);
}
} else if (g_str_has_prefix(mime, "audio")) {
if ((player->can_support_codec & FOUND_PLUGIN_AUDIO) && (player->audiodec_linked)) {
- LOGD("audio plugin is already linked\n");
+ LOGD("audio plugin is already linked");
} else {
- LOGW("add AUDIO to missing plugin\n");
+ LOGW("add AUDIO to missing plugin");
player->not_supported_codec |= MISSING_PLUGIN_AUDIO;
player->unlinked_audio_mime = g_strdup_printf("%s", mime);
}
return MM_ERROR_NONE;
}
-
-static void
-__mmplayer_pipeline_complete(GstElement *decodebin, gpointer data)
+void
+_mmplayer_pipeline_complete(GstElement *decodebin, gpointer data)
{
- mm_player_t* player = (mm_player_t*)data;
+ mmplayer_t *player = (mmplayer_t *)data;
MMPLAYER_FENTER();
MMPLAYER_RETURN_IF_FAIL(player);
/* remove fakesink. */
- if (!__mmplayer_gst_remove_fakesink(player,
+ if (!_mmplayer_gst_remove_fakesink(player,
&player->pipeline->mainbin[MMPLAYER_M_SRC_FAKESINK])) {
- /* NOTE : __mmplayer_pipeline_complete() can be called several time. because
+ /* NOTE : _mmplayer_pipeline_complete() can be called several time. because
* signaling mechanism(pad-added, no-more-pad, new-decoded-pad) from various
* source element are not same. To overcome this situation, this function will called
* several places and several times. Therefore, this is not an error case.
LOGD("[handle: %p] pipeline has completely constructed", player);
- if ((player->ini.async_start) &&
- (player->msg_posted == FALSE) &&
+ if ((player->msg_posted == FALSE) &&
(player->cmd >= MMPLAYER_COMMAND_START))
__mmplayer_handle_missed_plugin(player);
}
static gboolean
-__mmplayer_get_next_uri(mm_player_t *player)
+__mmplayer_get_next_uri(mmplayer_t *player)
{
- MMPlayerParseProfile profile;
+ mmplayer_parse_profile_t profile;
gint uri_idx = 0;
guint num_of_list = 0;
char *uri = NULL;
LOGD("num of uri list = %d, current uri idx %d", num_of_list, uri_idx);
for (uri_idx++; uri_idx < num_of_list; uri_idx++) {
uri = g_list_nth_data(player->uri_info.uri_list, uri_idx);
- if (uri == NULL) {
+ if (!uri) {
LOGW("next uri does not exist");
continue;
}
- if (__mmplayer_parse_profile((const char*)uri, NULL, &profile) != MM_ERROR_NONE) {
+ if (_mmplayer_parse_profile((const char *)uri, NULL, &profile) != MM_ERROR_NONE) {
LOGE("failed to parse profile");
continue;
}
break;
}
- if (uri_idx == num_of_list) {
+ if (!uri || uri_idx == num_of_list) {
LOGE("failed to find next uri");
return FALSE;
}
player->uri_info.uri_idx = uri_idx;
- mm_attrs_set_string_by_name(player->attrs, "profile_uri", uri);
-
- if (mm_attrs_commit_all(player->attrs)) {
- LOGE("failed to commit");
+ if (mm_player_set_attribute((MMHandleType)player, NULL,
+ "profile_uri", uri, strlen(uri), NULL) != MM_ERROR_NONE) {
+ LOGE("failed to set attribute");
return FALSE;
}
}
static gboolean
-__mmplayer_verify_gapless_play_path(mm_player_t *player)
+__mmplayer_verify_gapless_play_path(mmplayer_t *player)
{
-#define REPEAT_COUNT_INFINITELY -1
+#define REPEAT_COUNT_INFINITE -1
#define REPEAT_COUNT_MIN 2
+#define ORIGINAL_URI_ONLY 1
MMHandleType attrs = 0;
- gint mode = MM_PLAYER_PD_MODE_NONE;
gint video = 0;
gint count = 0;
gint gapless = 0;
- guint num_of_list = 0;
+ guint num_of_uri = 0;
int profile_tv = -1;
MMPLAYER_FENTER();
LOGD("checking for gapless play option");
+ if (player->build_audio_offload) {
+ LOGE("offload path is not supportable.");
+ goto ERROR;
+ }
+
if (player->pipeline->textbin) {
- LOGE("subtitle path is enabled. gapless play is not supported.\n");
+ LOGE("subtitle path is enabled. gapless play is not supported.");
goto ERROR;
}
attrs = MMPLAYER_GET_ATTRS(player);
if (!attrs) {
- LOGE("fail to get attributes.\n");
+ LOGE("fail to get attributes.");
goto ERROR;
}
- mm_attrs_get_int_by_name(attrs, "content_video_found", &video);
+ mm_attrs_multiple_get(player->attrs, NULL,
+ "content_video_found", &video,
+ "profile_play_count", &count,
+ MM_PLAYER_GAPLESS_MODE, &gapless, NULL);
/* gapless playback is not supported in case of video at TV profile. */
profile_tv = __mmplayer_check_profile();
goto ERROR;
}
- if (mm_attrs_get_int_by_name(attrs, "pd_mode", &mode) == MM_ERROR_NONE) {
- if (mode == TRUE) {
- LOGW("pd mode\n");
- goto ERROR;
- }
- }
-
- if (mm_attrs_get_int_by_name(attrs, "profile_play_count", &count) != MM_ERROR_NONE)
- LOGE("failed to get play count");
-
- if (mm_attrs_get_int_by_name(attrs, "gapless_mode", &gapless) != MM_ERROR_NONE)
- LOGE("failed to get gapless mode");
-
/* check repeat count in case of audio */
if (!gapless &&
- (video || (count != REPEAT_COUNT_INFINITELY && count < REPEAT_COUNT_MIN))) {
+ (video || (count != REPEAT_COUNT_INFINITE && count < REPEAT_COUNT_MIN))) {
LOGW("gapless is disabled");
goto ERROR;
}
- num_of_list = g_list_length(player->uri_info.uri_list);
+ num_of_uri = g_list_length(player->uri_info.uri_list);
- LOGD("repeat count = %d, num_of_list = %d", count, num_of_list);
+ LOGD("repeat count = %d, num_of_list = %d", count, num_of_uri);
- if (num_of_list == 0) {
+ if (num_of_uri == ORIGINAL_URI_ONLY) {
/* audio looping path */
if (count >= REPEAT_COUNT_MIN) {
/* decrease play count */
/* we succeeded to rewind. update play count and then wait for next EOS */
count--;
-
- mm_attrs_set_int_by_name(attrs, "profile_play_count", count);
-
- /* commit attribute */
- if (mm_attrs_commit_all(attrs))
- LOGE("failed to commit attribute");
- } else if (count != REPEAT_COUNT_INFINITELY) {
+ mm_player_set_attribute((MMHandleType)player, NULL, "profile_play_count", count, NULL);
+ } else if (count != REPEAT_COUNT_INFINITE) {
LOGD("there is no next uri and no repeat");
goto ERROR;
}
-
LOGD("looping cnt %d", count);
} else {
/* gapless playback path */
goto ERROR;
}
}
-
return TRUE;
ERROR:
}
static void
-__mmplayer_initialize_gapless_play(mm_player_t *player)
+__mmplayer_remove_sinkpad (const GValue *item, gpointer user_data)
{
- int i;
-
- MMPLAYER_FENTER();
-
- player->smooth_streaming = FALSE;
- player->videodec_linked = 0;
- player->audiodec_linked = 0;
- player->textsink_linked = 0;
- player->is_external_subtitle_present = FALSE;
- player->is_external_subtitle_added_now = FALSE;
- player->not_supported_codec = MISSING_PLUGIN_NONE;
- player->can_support_codec = FOUND_PLUGIN_NONE;
- player->pending_seek.is_pending = FALSE;
- player->pending_seek.pos = 0;
- player->msg_posted = FALSE;
- player->has_many_types = FALSE;
- player->no_more_pad = FALSE;
- player->not_found_demuxer = 0;
- player->seek_state = MMPLAYER_SEEK_NONE;
- player->is_subtitle_force_drop = FALSE;
- player->play_subtitle = FALSE;
- player->adjust_subtitle_pos = 0;
+ GstPad *sinkpad = g_value_get_object (item);
+ GstElement *element = GST_ELEMENT(user_data);
+ LOGD("(%s)element release request pad(%s)", GST_ELEMENT_NAME(element), GST_PAD_NAME(sinkpad));
+ gst_element_release_request_pad(element, GST_PAD(sinkpad));
+}
- player->total_bitrate = 0;
- player->total_maximum_bitrate = 0;
+static gboolean
+__mmplayer_deactivate_combiner(mmplayer_t *player, mmplayer_track_type_e type)
+{
+ mmplayer_gst_element_t *sinkbin = NULL;
+ main_element_id_e concatId = MMPLAYER_M_NUM;
+ main_element_id_e sinkId = MMPLAYER_M_NUM;
+ gboolean send_notice = FALSE;
+ GstElement *element;
+ GstIterator *iter;
- __mmplayer_track_initialize(player);
- __mmplayer_initialize_storage_info(player, MMPLAYER_PATH_MAX);
+ MMPLAYER_FENTER();
+ MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
- for (i = 0; i < MM_PLAYER_STREAM_COUNT_MAX; i++) {
- player->bitrate[i] = 0;
- player->maximum_bitrate[i] = 0;
- }
+ LOGD("type %d", type);
- if (player->v_stream_caps) {
- gst_caps_unref(player->v_stream_caps);
- player->v_stream_caps = NULL;
- }
-
- mm_attrs_set_int_by_name(player->attrs, "content_video_found", 0);
-
- /* clean found parsers */
- if (player->parsers) {
- GList *parsers = player->parsers;
- for (; parsers; parsers = g_list_next(parsers)) {
- gchar *name = parsers->data;
- MMPLAYER_FREEIF(name);
- }
- g_list_free(player->parsers);
- player->parsers = NULL;
- }
-
- /* clean found audio decoders */
- if (player->audio_decoders) {
- GList *a_dec = player->audio_decoders;
- for (; a_dec; a_dec = g_list_next(a_dec)) {
- gchar *name = a_dec->data;
- MMPLAYER_FREEIF(name);
- }
- g_list_free(player->audio_decoders);
- player->audio_decoders = NULL;
- }
-
- MMPLAYER_FLEAVE();
-}
-
-static void
-__mmplayer_activate_next_source(mm_player_t *player, GstState target)
-{
- MMPlayerGstElement *mainbin = NULL;
- MMMessageParamType msg_param = {0,};
- GstElement *element = NULL;
- MMHandleType attrs = 0;
- char *uri = NULL;
- enum MainElementID elem_idx = MMPLAYER_M_NUM;
-
- MMPLAYER_FENTER();
-
- if (!player || !player->pipeline || !player->pipeline->mainbin) {
- LOGE("player is not initialized");
- goto ERROR;
- }
-
- mainbin = player->pipeline->mainbin;
- msg_param.code = MM_ERROR_PLAYER_INTERNAL;
-
- attrs = MMPLAYER_GET_ATTRS(player);
- if (!attrs) {
- LOGE("fail to get attributes");
- goto ERROR;
- }
-
- /* Initialize Player values */
- __mmplayer_initialize_gapless_play(player);
-
- mm_attrs_get_string_by_name(attrs, "profile_uri", &uri);
-
- if (__mmplayer_parse_profile((const char*)uri, NULL, &player->profile) != MM_ERROR_NONE) {
- LOGE("failed to parse profile");
- msg_param.code = MM_ERROR_PLAYER_INVALID_URI;
- goto ERROR;
- }
-
- if ((MMPLAYER_URL_HAS_DASH_SUFFIX(player)) ||
- (MMPLAYER_URL_HAS_HLS_SUFFIX(player))) {
- LOGE("dash or hls is not supportable");
- msg_param.code = MM_ERROR_PLAYER_INVALID_URI;
- goto ERROR;
- }
-
- element = __mmplayer_gst_create_source(player);
- if (!element) {
- LOGE("no source element was created");
- goto ERROR;
- }
-
- if (gst_bin_add(GST_BIN(mainbin[MMPLAYER_M_PIPE].gst), element) == FALSE) {
- LOGE("failed to add source element to pipeline");
- gst_object_unref(GST_OBJECT(element));
- element = NULL;
- goto ERROR;
- }
-
- /* take source element */
- mainbin[MMPLAYER_M_SRC].id = MMPLAYER_M_SRC;
- mainbin[MMPLAYER_M_SRC].gst = element;
-
- element = NULL;
-
- if (MMPLAYER_IS_HTTP_STREAMING(player)) {
- if (player->streamer == NULL) {
- player->streamer = __mm_player_streaming_create();
- __mm_player_streaming_initialize(player->streamer);
- }
-
- elem_idx = MMPLAYER_M_TYPEFIND;
- element = gst_element_factory_make("typefind", "typefinder");
- __mmplayer_add_signal_connection(player, G_OBJECT(element),
- MM_PLAYER_SIGNAL_TYPE_AUTOPLUG, "have-type", G_CALLBACK(__mmplayer_typefind_have_type), (gpointer)player);
- } else {
- elem_idx = MMPLAYER_M_AUTOPLUG;
- element = __mmplayer_gst_make_decodebin(player);
- }
-
- /* check autoplug element is OK */
- if (!element) {
- LOGE("can not create element(%d)", elem_idx);
- goto ERROR;
- }
-
- if (gst_bin_add(GST_BIN(mainbin[MMPLAYER_M_PIPE].gst), element) == FALSE) {
- LOGE("failed to add sinkbin to pipeline");
- gst_object_unref(GST_OBJECT(element));
- element = NULL;
- goto ERROR;
- }
-
- mainbin[elem_idx].id = elem_idx;
- mainbin[elem_idx].gst = element;
-
- if (gst_element_link(mainbin[MMPLAYER_M_SRC].gst, mainbin[elem_idx].gst) == FALSE) {
- LOGE("Failed to link src - autoplug(or typefind)");
- goto ERROR;
+ switch (type) {
+ case MM_PLAYER_TRACK_TYPE_AUDIO:
+ concatId = MMPLAYER_M_A_CONCAT;
+ sinkId = MMPLAYER_A_BIN;
+ sinkbin = player->pipeline->audiobin;
+ break;
+ case MM_PLAYER_TRACK_TYPE_VIDEO:
+ concatId = MMPLAYER_M_V_CONCAT;
+ sinkId = MMPLAYER_V_BIN;
+ sinkbin = player->pipeline->videobin;
+ send_notice = TRUE;
+ break;
+ case MM_PLAYER_TRACK_TYPE_TEXT:
+ concatId = MMPLAYER_M_T_CONCAT;
+ sinkId = MMPLAYER_T_BIN;
+ sinkbin = player->pipeline->textbin;
+ break;
+ default:
+ LOGE("requested type is not supportable");
+ return FALSE;
+ break;
}
- if (gst_element_set_state(mainbin[MMPLAYER_M_SRC].gst, target) == GST_STATE_CHANGE_FAILURE) {
- LOGE("Failed to change state of src element");
- goto ERROR;
- }
+ element = player->pipeline->mainbin[concatId].gst;
+ if (!element)
+ return TRUE;
- if (!MMPLAYER_IS_HTTP_STREAMING(player)) {
- if (gst_element_set_state(mainbin[MMPLAYER_M_AUTOPLUG].gst, target) == GST_STATE_CHANGE_FAILURE) {
- LOGE("Failed to change state of decodebin");
- goto ERROR;
- }
- } else {
- if (gst_element_set_state(mainbin[MMPLAYER_M_TYPEFIND].gst, target) == GST_STATE_CHANGE_FAILURE) {
- LOGE("Failed to change state of src element");
- goto ERROR;
+ if ((sinkbin) && (sinkbin[sinkId].gst)) {
+ GstPad *srcpad = gst_element_get_static_pad(element, "src");
+ GstPad *sinkpad = gst_element_get_static_pad(sinkbin[sinkId].gst, "sink");
+ if (srcpad && sinkpad) {
+ /* after getting drained signal there is no data flows, so no need to do pad_block */
+ LOGD("unlink %s:%s, %s:%s", GST_DEBUG_PAD_NAME(srcpad), GST_DEBUG_PAD_NAME(sinkpad));
+ gst_pad_unlink(srcpad, sinkpad);
+
+ /* send custom event to sink pad to handle it at video sink */
+ if (send_notice) {
+ LOGD("send custom event to sinkpad");
+ GstStructure *s = gst_structure_new_empty("tizen/flush-buffer");
+ GstEvent *event = gst_event_new_custom(GST_EVENT_CUSTOM_DOWNSTREAM, s);
+ gst_pad_send_event(sinkpad, event);
+ }
}
+ gst_object_unref(srcpad);
+ gst_object_unref(sinkpad);
}
- player->gapless.stream_changed = TRUE;
- player->gapless.running = TRUE;
- MMPLAYER_FLEAVE();
- return;
-
-ERROR:
- if (player) {
- MMPLAYER_PLAYBACK_UNLOCK(player);
+ LOGD("release concat request pad");
+ /* release and unref requests pad from the selector */
+ iter = gst_element_iterate_sink_pads(element);
+ while (gst_iterator_foreach(iter, __mmplayer_remove_sinkpad, element) == GST_ITERATOR_RESYNC)
+ gst_iterator_resync(iter);
+ gst_iterator_free(iter);
- if (!player->msg_posted) {
- MMPLAYER_POST_MSG(player, MM_MESSAGE_ERROR, &msg_param);
- player->msg_posted = TRUE;
- }
- }
- return;
+ return TRUE;
}
static gboolean
-__mmplayer_deactivate_selector(mm_player_t *player, MMPlayerTrackType type)
+__mmplayer_deactivate_selector(mmplayer_t *player, mmplayer_track_type_e type)
{
- mm_player_selector_t *selector = &player->selector[type];
- MMPlayerGstElement *sinkbin = NULL;
- enum MainElementID selectorId = MMPLAYER_M_NUM;
- enum MainElementID sinkId = MMPLAYER_M_NUM;
+ mmplayer_track_t *selector = &player->track[type];
+ mmplayer_gst_element_t *sinkbin = NULL;
+ main_element_id_e selectorId = MMPLAYER_M_NUM;
+ main_element_id_e sinkId = MMPLAYER_M_NUM;
GstPad *srcpad = NULL;
GstPad *sinkpad = NULL;
gboolean send_notice = FALSE;
LOGD("selector release");
/* release and unref requests pad from the selector */
- for (n = 0; n < selector->channels->len; n++) {
- GstPad *sinkpad = g_ptr_array_index(selector->channels, n);
+ for (n = 0; n < selector->streams->len; n++) {
+ GstPad *sinkpad = g_ptr_array_index(selector->streams, n);
gst_element_release_request_pad((player->pipeline->mainbin[selectorId].gst), sinkpad);
}
- g_ptr_array_set_size(selector->channels, 0);
+
+ g_ptr_array_set_size(selector->streams, 0);
gst_element_set_state(player->pipeline->mainbin[selectorId].gst, GST_STATE_NULL);
gst_bin_remove(GST_BIN_CAST(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst), player->pipeline->mainbin[selectorId].gst);
}
static void
-__mmplayer_deactivate_old_path(mm_player_t *player)
+__mmplayer_deactivate_old_path(mmplayer_t *player)
{
MMPLAYER_FENTER();
MMPLAYER_RETURN_IF_FAIL(player);
- if ((!__mmplayer_deactivate_selector(player, MM_PLAYER_TRACK_TYPE_AUDIO)) ||
- (!__mmplayer_deactivate_selector(player, MM_PLAYER_TRACK_TYPE_VIDEO)) ||
- (!__mmplayer_deactivate_selector(player, MM_PLAYER_TRACK_TYPE_TEXT))) {
- LOGE("deactivate selector error");
- goto ERROR;
+ if (MMPLAYER_USE_DECODEBIN(player)) {
+ if ((!__mmplayer_deactivate_selector(player, MM_PLAYER_TRACK_TYPE_AUDIO)) ||
+ (!__mmplayer_deactivate_selector(player, MM_PLAYER_TRACK_TYPE_VIDEO)) ||
+ (!__mmplayer_deactivate_selector(player, MM_PLAYER_TRACK_TYPE_TEXT))) {
+ LOGE("deactivate selector error");
+ goto ERROR;
+ }
+ } else {
+ if ((!__mmplayer_deactivate_combiner(player, MM_PLAYER_TRACK_TYPE_AUDIO)) ||
+ (!__mmplayer_deactivate_combiner(player, MM_PLAYER_TRACK_TYPE_VIDEO)) ||
+ (!__mmplayer_deactivate_combiner(player, MM_PLAYER_TRACK_TYPE_TEXT))) {
+ LOGE("deactivate concat error");
+ goto ERROR;
+ }
}
- __mmplayer_track_destroy(player);
+ _mmplayer_track_destroy(player);
__mmplayer_release_signal_connection(player, MM_PLAYER_SIGNAL_TYPE_AUTOPLUG);
if (player->streamer) {
- __mm_player_streaming_deinitialize(player->streamer);
- __mm_player_streaming_destroy(player->streamer);
+ _mm_player_streaming_initialize(player->streamer, FALSE);
+ _mm_player_streaming_destroy(player->streamer);
player->streamer = NULL;
}
- MMPLAYER_PLAYBACK_LOCK(player);
MMPLAYER_GAPLESS_PLAY_THREAD_SIGNAL(player);
-
MMPLAYER_FLEAVE();
return;
return;
}
-int _mmplayer_set_file_buffering_path(MMHandleType hplayer, const char* file_path)
-{
- int result = MM_ERROR_NONE;
- mm_player_t* player = (mm_player_t*) hplayer;
- MMPLAYER_FENTER();
-
- MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
-
- if (file_path) {
- player->http_file_buffering_path = (gchar*)file_path;
- LOGD("temp file path: %s\n", player->http_file_buffering_path);
- }
- MMPLAYER_FLEAVE();
- return result;
-}
-
-int _mmplayer_set_uri(MMHandleType hplayer, const char* uri)
+int
+_mmplayer_set_uri(MMHandleType hplayer, const char *uri)
{
int result = MM_ERROR_NONE;
- mm_player_t* player = (mm_player_t*) hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
+ MMPLAYER_RETURN_VAL_IF_FAIL(uri, MM_ERROR_INVALID_ARGUMENT);
- mm_attrs_set_string_by_name(player->attrs, "profile_uri", uri);
- if (mm_attrs_commit_all(player->attrs)) {
- LOGE("failed to commit the original uri.\n");
+ if (mm_player_set_attribute(hplayer, NULL,
+ "profile_uri", uri, strlen(uri), NULL) != MM_ERROR_NONE) {
+ LOGE("failed to set attribute");
result = MM_ERROR_PLAYER_INTERNAL;
} else {
if (_mmplayer_set_next_uri(hplayer, uri, TRUE) != MM_ERROR_NONE)
- LOGE("failed to add the original uri in the uri list.\n");
+ LOGE("failed to add the original uri in the uri list.");
}
MMPLAYER_FLEAVE();
return result;
}
-int _mmplayer_set_next_uri(MMHandleType hplayer, const char* uri, bool is_first_path)
+int
+_mmplayer_set_next_uri(MMHandleType hplayer, const char *uri, bool is_first_path)
{
- mm_player_t* player = (mm_player_t*) hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
guint num_of_list = 0;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(uri, MM_ERROR_INVALID_ARGUMENT);
if (player->pipeline && player->pipeline->textbin) {
- LOGE("subtitle path is enabled.\n");
+ LOGE("subtitle path is enabled.");
return MM_ERROR_PLAYER_INVALID_STATE;
}
num_of_list = g_list_length(player->uri_info.uri_list);
- if (is_first_path == TRUE) {
+ if (is_first_path) {
if (num_of_list == 0) {
player->uri_info.uri_list = g_list_append(player->uri_info.uri_list, g_strdup(uri));
- LOGD("add original path : %s", uri);
+ SECURE_LOGD("add original path : %s", uri);
} else {
player->uri_info.uri_list = g_list_delete_link(player->uri_info.uri_list, g_list_nth(player->uri_info.uri_list, 0));
player->uri_info.uri_list = g_list_insert(player->uri_info.uri_list, g_strdup(uri), 0);
- LOGD("change original path : %s", uri);
+ SECURE_LOGD("change original path : %s", uri);
}
} else {
MMHandleType attrs = 0;
player->uri_info.uri_list = g_list_append(player->uri_info.uri_list, g_strdup(original_uri));
player->uri_info.uri_idx = 0;
- LOGD("add original path at first : %s(%d)", original_uri);
+ SECURE_LOGD("add original path at first : %s", original_uri);
}
}
player->uri_info.uri_list = g_list_append(player->uri_info.uri_list, g_strdup(uri));
- LOGD("add new path : %s(total num of list = %d)", uri, g_list_length(player->uri_info.uri_list));
+ SECURE_LOGD("add new path : %s(total num of list = %d)", uri, g_list_length(player->uri_info.uri_list));
}
MMPLAYER_FLEAVE();
return MM_ERROR_NONE;
}
-int _mmplayer_get_next_uri(MMHandleType hplayer, char** uri)
+int
+_mmplayer_get_next_uri(MMHandleType hplayer, char **uri)
{
- mm_player_t* player = (mm_player_t*) hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
char *next_uri = NULL;
guint num_of_list = 0;
if (num_of_list > 0) {
gint uri_idx = player->uri_info.uri_idx;
- if (uri_idx < num_of_list-1)
+ if (uri_idx < num_of_list - 1)
uri_idx++;
else
uri_idx = 0;
next_uri = g_list_nth_data(player->uri_info.uri_list, uri_idx);
- LOGE("next uri idx : %d, uri = %s\n", uri_idx, next_uri);
+ LOGE("next uri idx : %d, uri = %s", uri_idx, next_uri);
*uri = g_strdup(next_uri);
}
return MM_ERROR_NONE;
}
-static void
-__mmplayer_gst_decode_unknown_type(GstElement *elem, GstPad* pad,
-GstCaps *caps, gpointer data)
+void
+_mmplayer_gst_decode_unknown_type(GstElement *elem, GstPad *pad,
+ GstCaps *caps, gpointer data)
{
- mm_player_t* player = (mm_player_t*)data;
- const gchar* klass = NULL;
- const gchar* mime = NULL;
- gchar* caps_str = NULL;
+ mmplayer_t *player = (mmplayer_t *)data;
+ const gchar *klass = NULL;
+ const gchar *mime = NULL;
+ gchar *caps_str = NULL;
klass = gst_element_factory_get_metadata(gst_element_get_factory(elem), GST_ELEMENT_METADATA_KLASS);
mime = gst_structure_get_name(gst_caps_get_structure(caps, 0));
__mmplayer_check_not_supported_codec(player, klass, mime);
}
-static gboolean
-__mmplayer_gst_decode_autoplug_continue(GstElement *bin, GstPad* pad,
-GstCaps * caps, gpointer data)
+gboolean
+_mmplayer_gst_decode_autoplug_continue(GstElement *bin, GstPad *pad,
+ GstCaps *caps, gpointer data)
{
- mm_player_t* player = (mm_player_t*)data;
- const char* mime = NULL;
+ mmplayer_t *player = (mmplayer_t *)data;
+ const char *mime = NULL;
gboolean ret = TRUE;
MMPLAYER_LOG_GST_CAPS_TYPE(caps);
mime = gst_structure_get_name(gst_caps_get_structure(caps, 0));
if (g_str_has_prefix(mime, "audio")) {
- GstStructure* caps_structure = NULL;
+ GstStructure *caps_structure = NULL;
gint samplerate = 0;
gint channels = 0;
gchar *caps_str = NULL;
caps_str = gst_caps_to_string(caps);
/* set it directly because not sent by TAG */
if (g_strrstr(caps_str, "mobile-xmf"))
- mm_attrs_set_string_by_name(player->attrs, "content_audio_codec", "mobile-xmf");
+ mm_player_set_attribute((MMHandleType)player, NULL,
+ "content_audio_codec", "mobile-xmf", strlen("mobile-xmf"), NULL);
+
MMPLAYER_FREEIF(caps_str);
- } else if (g_str_has_prefix(mime, "video") && !player->ini.video_playback_supported) {
- MMMessageParamType msg_param;
- memset(&msg_param, 0, sizeof(MMMessageParamType));
- msg_param.code = MM_ERROR_NOT_SUPPORT_API;
- MMPLAYER_POST_MSG(player, MM_MESSAGE_ERROR, &msg_param);
- LOGD("video file is not supported on this device");
- ret = FALSE;
} else if (g_str_has_prefix(mime, "video") && player->videodec_linked) {
LOGD("already video linked");
ret = FALSE;
return ret;
}
-static int
-__mmplayer_check_codec_info(mm_player_t* player, const char* klass, GstCaps* caps, char* factory_name)
+static gboolean
+__mmplayer_is_audio_offload_device_type(mmplayer_t *player)
{
- int ret = MM_ERROR_NONE;
- int idx = 0;
- int codec_type = MM_PLAYER_CODEC_TYPE_DEFAULT;
+ gboolean ret = FALSE;
+ GDBusConnection *conn = NULL;
+ GError *err = NULL;
+ GVariant *result = NULL;
+ const gchar *dbus_device_type = NULL;
+ const gchar *dbus_ret = NULL;
+ gint idx = 0;
+
+ conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &err);
+ if (!conn || err) {
+ LOGE("failed g_bus_get_sync() (%s)", (err ? err->message : "null"));
+ g_error_free(err);
+ goto DONE;
+ }
+
+ result = g_dbus_connection_call_sync(conn,
+ "org.pulseaudio.Server",
+ "/org/pulseaudio/StreamManager",
+ "org.pulseaudio.StreamManager",
+ "GetCurrentMediaRoutingPath",
+ g_variant_new("(s)", "out"),
+ G_VARIANT_TYPE("(ss)"),
+ G_DBUS_CALL_FLAGS_NONE,
+ 2000,
+ NULL,
+ &err);
+ if (!result || err) {
+ LOGE("failed g_dbus_connection_call_sync() (%s)", (err ? err->message : "null"));
+ g_error_free(err);
+ goto DONE;
+ }
+
+ /* device type is listed in stream-map.json at mmfw-sysconf */
+ g_variant_get(result, "(&s&s)", &dbus_device_type, &dbus_ret);
+
+ LOGI("g_dbus_connection_call_sync() success (%s, %s)", dbus_device_type, dbus_ret);
+ if (strncmp("STREAM_MANAGER_RETURN_OK", dbus_ret, strlen(dbus_ret)))
+ goto DONE;
+
+ /* the device type is listed in ini file among audio-jack, bt-a2dp, usb-audio, builtin-speaker */
+ for (idx = 0; player->ini.audio_offload_device_type[idx][0] != '\0'; idx++) {
+ if (strstr(dbus_device_type, player->ini.audio_offload_device_type[idx])) {
+ LOGD("audio offload is supportable");
+ ret = TRUE;
+ goto DONE;
+ }
+ }
+
+ LOGD("audio offload is not supportable");
+
+DONE:
+ g_variant_unref(result);
+ if (conn)
+ g_object_unref(conn);
+
+ return ret;
+}
+
+static void __mmplayer_rebuild_audio_pipeline(mmplayer_t *player)
+{
+ mmplayer_state_e current_state = MM_PLAYER_STATE_NONE;
+ gint64 position = 0;
+
+ MMPLAYER_RETURN_IF_FAIL(player && player->attrs &&
+ player->pipeline && player->pipeline->mainbin);
+
+ MMPLAYER_CMD_LOCK(player);
+ current_state = MMPLAYER_CURRENT_STATE(player);
+
+ if (!gst_element_query_position(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, GST_FORMAT_TIME, &position))
+ LOGW("getting current position failed in paused");
+
+ _mmplayer_unrealize((MMHandleType)player);
+ _mmplayer_realize((MMHandleType)player);
+
+ _mmplayer_set_position((MMHandleType)player, position);
+
+ /* async not to be blocked in streaming case */
+ mm_player_set_attribute((MMHandleType)player, NULL, "profile_prepare_async", TRUE, NULL);
+
+ _mmplayer_pause((MMHandleType)player);
+
+ if (current_state == MM_PLAYER_STATE_PLAYING)
+ _mmplayer_start((MMHandleType)player);
+ MMPLAYER_CMD_UNLOCK(player);
+
+ LOGD("rebuilding audio pipeline is completed.");
+}
+
+void __mmplayer_audio_device_connected_cb(MMSoundDevice_t device_h, bool is_connected, void *user_data)
+{
+ mmplayer_t *player = (mmplayer_t *)user_data;
+ mm_sound_device_type_e dev_type = MM_SOUND_DEVICE_TYPE_BUILTIN_SPEAKER;
+ gboolean is_supportable = FALSE;
+
+ if (mm_sound_get_device_type(device_h, &dev_type) != MM_ERROR_NONE)
+ LOGW("failed to get device type");
+ else
+ LOGD("dev type (%d), connected (%d)", dev_type, is_connected);
+
+ if ((dev_type != MM_SOUND_DEVICE_TYPE_BLUETOOTH_A2DP) &&
+ (dev_type != MM_SOUND_DEVICE_TYPE_AUDIOJACK) &&
+ (dev_type != MM_SOUND_DEVICE_TYPE_USB_AUDIO)) {
+ LOGD("ignore this dev connected info");
+ return;
+ }
+
+ is_supportable = __mmplayer_is_audio_offload_device_type(player);
+ if (player->build_audio_offload == is_supportable) {
+ LOGD("keep current pipeline without re-building");
+ return;
+ }
+
+ /* rebuild pipeline */
+ LOGD("re-build pipeline - offload: %d", is_supportable);
+ player->build_audio_offload = FALSE;
+ __mmplayer_rebuild_audio_pipeline(player);
+
+ return;
+}
+
+static gboolean
+__mmplayer_add_audio_device_connected_cb(mmplayer_t *player)
+{
+ unsigned int id = 0;
+
+ if (player->audio_device_cb_id != 0) {
+ LOGW("audio device connected cb was already added (%u)", player->audio_device_cb_id);
+ return TRUE;
+ }
+
+ if (mm_sound_add_device_connected_callback(MM_SOUND_DEVICE_IO_DIRECTION_OUT_FLAG,
+ __mmplayer_audio_device_connected_cb, player, &id) == MM_ERROR_NONE) {
+ LOGD("added device connected cb (%u)", id);
+ player->audio_device_cb_id = id;
+ } else {
+ LOGW("failed to add device connected cb");
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+int _mmplayer_audio_offload_is_activated(MMHandleType hplayer, bool *activated)
+{
+ mmplayer_t *player = (mmplayer_t *)hplayer;
+
+ MMPLAYER_FENTER();
+ MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
+ MMPLAYER_RETURN_VAL_IF_FAIL(activated, MM_ERROR_INVALID_ARGUMENT);
+
+ *activated = player->build_audio_offload;
+
+ LOGD("offload activated : %d", (int)*activated);
+
+ MMPLAYER_FLEAVE();
+ return MM_ERROR_NONE;
+}
+
+static gboolean
+__mmplayer_is_offload_supported_type(mmplayer_t *player)
+{
+ /* NOTE :
+ this function need to be updated according to the supported media format
+ @see player->ini.audio_offload_media_format */
+
+ if (__mmplayer_is_only_mp3_type(player->type)) {
+ LOGD("offload supportable media format type");
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+static gboolean
+__mmplayer_can_build_audio_offload_path(mmplayer_t *player)
+{
+ gboolean ret = FALSE;
+ GstElementFactory *factory = NULL;
+
+ MMPLAYER_FENTER();
+ MMPLAYER_RETURN_VAL_IF_FAIL(player && player->attrs, FALSE);
+
+ LOGD("current stream : %s, sink: %s", player->type, player->ini.audio_offload_sink_element);
+ if (!__mmplayer_is_offload_supported_type(player))
+ goto DONE;
+
+ if (!strcmp(player->ini.audio_offload_sink_element, "")) {
+ LOGD("there is no audio offload sink");
+ goto DONE;
+ }
+
+ if (player->ini.audio_offload_device_type[0][0] == '\0') {
+ LOGW("there is no audio device type to support offload");
+ goto DONE;
+ }
+
+ factory = gst_element_factory_find(player->ini.audio_offload_sink_element);
+ if (!factory) {
+ LOGW("there is no installed audio offload sink element");
+ goto DONE;
+ }
+ gst_object_unref(factory);
+
+ if (_mmplayer_acquire_hw_resource(player,
+ MMPLAYER_RESOURCE_TYPE_AUDIO_OFFLOAD) != MM_ERROR_NONE) {
+ LOGE("failed to acquire audio offload decoder resource");
+ goto DONE;
+ }
+
+ if (!__mmplayer_add_audio_device_connected_cb(player))
+ goto DONE;
+
+ if (!__mmplayer_is_audio_offload_device_type(player))
+ goto DONE;
+
+ LOGD("audio offload can be built");
+ ret = TRUE;
+
+DONE:
+ if (!ret)
+ __mmplayer_release_hw_resource(player, MMPLAYER_RESOURCE_TYPE_AUDIO_OFFLOAD);
+
+ MMPLAYER_FLEAVE();
+ return ret;
+}
+
+static GstAutoplugSelectResult
+__mmplayer_check_codec_info(mmplayer_t *player, const char *klass, GstCaps *caps, char *factory_name)
+{
+ GstAutoplugSelectResult ret = GST_AUTOPLUG_SELECT_TRY;
+ int audio_offload = 0;
if ((g_strrstr(klass, "Codec/Decoder/Audio"))) {
- mm_attrs_get_int_by_name(player->attrs, "audio_codec_type", &codec_type);
-
- LOGD("audio codec type: %d", codec_type);
- if (codec_type == MM_PLAYER_CODEC_TYPE_HW) {
- /* sw codec will be skipped */
- for (idx = 0; player->ini.audiocodec_element_sw[idx][0] != '\0'; idx++) {
- if (strstr(factory_name, player->ini.audiocodec_element_sw[idx])) {
- LOGW("skipping sw acodec:[%s] by codec type", factory_name);
- ret = MM_ERROR_PLAYER_INTERNAL;
- goto DONE;
- }
- }
- } else if (codec_type == MM_PLAYER_CODEC_TYPE_SW) {
- /* hw codec will be skipped */
- if (strcmp(player->ini.audiocodec_element_hw, "") &&
- g_strrstr(factory_name, player->ini.audiocodec_element_hw)) {
- LOGW("skipping hw acodec:[%s] by codec type", factory_name);
- ret = MM_ERROR_PLAYER_INTERNAL;
- goto DONE;
- }
+ mm_attrs_get_int_by_name(player->attrs, MM_PLAYER_AUDIO_OFFLOAD, &audio_offload); /* user requirement */
+
+ if (audio_offload && __mmplayer_can_build_audio_offload_path(player)) {
+ LOGD("expose audio path to build offload output path");
+ player->build_audio_offload = TRUE;
+ /* update codec info */
+ player->not_supported_codec &= MISSING_PLUGIN_VIDEO;
+ player->can_support_codec |= FOUND_PLUGIN_AUDIO;
+ player->audiodec_linked = 1;
+
+ ret = GST_AUTOPLUG_SELECT_EXPOSE;
+ goto DONE;
}
+ /* FIXME: If HW audio decoder is selected, related resource have to be acquired here.
+ And need to consider the multi-track audio content.
+ There is no HW audio decoder in public. */
+
/* set stream information */
if (!player->audiodec_linked)
- __mmplayer_set_audio_attrs(player, caps);
+ _mmplayer_set_audio_attrs(player, caps);
/* update codec info */
player->not_supported_codec &= MISSING_PLUGIN_VIDEO;
} else if (g_strrstr(klass, "Codec/Decoder/Video")) {
- mm_attrs_get_int_by_name(player->attrs, "video_codec_type", &codec_type);
-
- LOGD("video codec type: %d", codec_type);
- if (codec_type == MM_PLAYER_CODEC_TYPE_HW) {
- /* sw codec is skipped */
- for (idx = 0; player->ini.videocodec_element_sw[idx][0] != '\0'; idx++) {
- if (strstr(factory_name, player->ini.videocodec_element_sw[idx])) {
- LOGW("skipping sw vcodec:[%s] by codec type", factory_name);
- ret = MM_ERROR_PLAYER_INTERNAL;
- goto DONE;
- }
- }
- } else if (codec_type == MM_PLAYER_CODEC_TYPE_SW) {
- /* hw codec is skipped */
- if (g_strrstr(factory_name, player->ini.videocodec_element_hw)) {
- LOGW("skipping hw vcodec:[%s] by codec type", factory_name);
- ret = MM_ERROR_PLAYER_INTERNAL;
- goto DONE;
- }
- }
-
if ((strlen(player->ini.videocodec_element_hw) > 0) &&
(g_strrstr(factory_name, player->ini.videocodec_element_hw))) {
/* mark video decoder for acquire */
- if (player->video_decoder_resource == NULL) {
- if (mm_resource_manager_mark_for_acquire(player->resource_manager,
- MM_RESOURCE_MANAGER_RES_TYPE_VIDEO_DECODER,
- MM_RESOURCE_MANAGER_RES_VOLUME_FULL,
- &player->video_decoder_resource)
- != MM_RESOURCE_MANAGER_ERROR_NONE) {
- LOGE("could not mark video_decoder resource for acquire");
- ret = MM_ERROR_PLAYER_INTERNAL;
- goto DONE;
- }
- } else {
+ if (player->hw_resource[MMPLAYER_RESOURCE_TYPE_VIDEO_DECODER] != NULL) {
LOGW("video decoder resource is already acquired, skip it.");
- ret = MM_ERROR_PLAYER_INTERNAL;
+ ret = GST_AUTOPLUG_SELECT_SKIP;
goto DONE;
}
- player->interrupted_by_resource = FALSE;
- /* acquire resources for video playing */
- if (mm_resource_manager_commit(player->resource_manager)
- != MM_RESOURCE_MANAGER_ERROR_NONE) {
- LOGE("could not acquire resources for video decoding\n");
- ret = MM_ERROR_PLAYER_INTERNAL;
+ if (_mmplayer_acquire_hw_resource(player, MMPLAYER_RESOURCE_TYPE_VIDEO_DECODER) != MM_ERROR_NONE) {
+ LOGE("failed to acquire video decoder resource");
+ ret = GST_AUTOPLUG_SELECT_SKIP;
goto DONE;
}
+ player->interrupted_by_resource = FALSE;
}
/* update codec info */
return ret;
}
-gint
-__mmplayer_gst_decode_autoplug_select(GstElement *bin, GstPad* pad,
-GstCaps* caps, GstElementFactory* factory, gpointer data)
+GValueArray *
+_mmplayer_gst_decode_autoplug_sort(GstElement *bin,
+ GstPad *pad, GstCaps *caps, GValueArray *factories, gpointer data)
{
- /* NOTE : GstAutoplugSelectResult is defined in gstplay-enum.h but not exposed
- We are defining our own and will be removed when it actually exposed */
- typedef enum {
- GST_AUTOPLUG_SELECT_TRY,
- GST_AUTOPLUG_SELECT_EXPOSE,
- GST_AUTOPLUG_SELECT_SKIP
- } GstAutoplugSelectResult;
+#define DEFAULT_IDX 0xFFFF
+#define MIN_FACTORY_NUM 2
+ mmplayer_t *player = (mmplayer_t *)data;
+ GValueArray *new_factories = NULL;
+ GValue val = { 0, };
+ GstElementFactory *factory = NULL;
+ const gchar *klass = NULL;
+ gchar *factory_name = NULL;
+ guint hw_dec_idx = DEFAULT_IDX;
+ guint first_sw_dec_idx = DEFAULT_IDX;
+ guint last_sw_dec_idx = DEFAULT_IDX;
+ guint new_pos = DEFAULT_IDX;
+ guint rm_pos = DEFAULT_IDX;
+ int audio_codec_type;
+ int video_codec_type;
+ mmplayer_codec_type_e codec_type = MM_PLAYER_CODEC_TYPE_DEFAULT;
+
+ if (factories->n_values < MIN_FACTORY_NUM)
+ return NULL;
+
+ mm_attrs_get_int_by_name(player->attrs, MM_PLAYER_VIDEO_CODEC_TYPE, &video_codec_type);
+ mm_attrs_get_int_by_name(player->attrs, MM_PLAYER_AUDIO_CODEC_TYPE, &audio_codec_type);
+
+#ifdef __DEBUG__
+ LOGD("num of factory : %d, codec type %d, %d", factories->n_values, video_codec_type, audio_codec_type);
+#endif
+ for (int i = 0 ; i < factories->n_values ; i++) {
+ gchar *hw_dec_info = NULL;
+ gchar (*sw_dec_info)[PLAYER_INI_MAX_STRLEN] = {NULL, };
+
+ factory = g_value_get_object(g_value_array_get_nth(factories, i));
+ if (!factory) {
+ LOGW("failed to get factory object");
+ continue;
+ }
+ klass = gst_element_factory_get_klass(factory);
+ factory_name = GST_OBJECT_NAME(factory);
+
+#ifdef __DEBUG__
+ LOGD("Klass [%s] Factory [%s]", klass, factory_name);
+#endif
+ if (g_strrstr(klass, "Codec/Decoder/Audio")) {
+ if (!player->need_audio_dec_sorting) {
+ LOGD("sorting is not required");
+ return NULL;
+ }
+ codec_type = audio_codec_type;
+ hw_dec_info = player->ini.audiocodec_element_hw;
+ sw_dec_info = player->ini.audiocodec_element_sw;
+ } else if (g_strrstr(klass, "Codec/Decoder/Video")) {
+ if (!player->need_video_dec_sorting) {
+ LOGD("sorting is not required");
+ return NULL;
+ }
+ codec_type = video_codec_type;
+ hw_dec_info = player->ini.videocodec_element_hw;
+ sw_dec_info = player->ini.videocodec_element_sw;
+ } else {
+ continue;
+ }
+
+ if (g_strrstr(factory_name, hw_dec_info)) {
+ hw_dec_idx = i;
+ } else {
+ for (int j = 0; sw_dec_info[j][0] != '\0'; j++) {
+ if (strstr(factory_name, sw_dec_info[j])) {
+ last_sw_dec_idx = i;
+ if (first_sw_dec_idx == DEFAULT_IDX) {
+ first_sw_dec_idx = i;
+ }
+ }
+ }
+
+ if (first_sw_dec_idx == DEFAULT_IDX)
+ LOGW("unknown codec %s", factory_name);
+ }
+ }
+
+ if (hw_dec_idx == DEFAULT_IDX || first_sw_dec_idx == DEFAULT_IDX)
+ return NULL;
+
+ if (codec_type == MM_PLAYER_CODEC_TYPE_HW) {
+ if (hw_dec_idx < first_sw_dec_idx)
+ return NULL;
+ new_pos = first_sw_dec_idx;
+ rm_pos = hw_dec_idx + 1;
+ } else if (codec_type == MM_PLAYER_CODEC_TYPE_SW) {
+ if (last_sw_dec_idx < hw_dec_idx)
+ return NULL;
+ new_pos = last_sw_dec_idx + 1;
+ rm_pos = hw_dec_idx;
+ } else {
+ return NULL;
+ }
+
+ /* change position - insert H/W decoder according to the new position */
+ factory = g_value_get_object(g_value_array_get_nth(factories, hw_dec_idx));
+ if (!factory) {
+ LOGW("failed to get factory object");
+ return NULL;
+ }
+ new_factories = g_value_array_copy(factories);
+ g_value_init (&val, G_TYPE_OBJECT);
+ g_value_set_object (&val, factory);
+ g_value_array_insert(new_factories, new_pos, &val);
+ g_value_unset (&val);
+ g_value_array_remove(new_factories, rm_pos); /* remove previous H/W element */
+
+ for (int i = 0 ; i < new_factories->n_values ; i++) {
+ factory = g_value_get_object(g_value_array_get_nth(new_factories, i));
+ if (factory)
+ LOGD("[Re-arranged] Klass [%s] Factory [%s]",
+ gst_element_factory_get_klass(factory), GST_OBJECT_NAME (factory));
+ else
+ LOGE("[Re-arranged] failed to get factory object");
+ }
+
+ return new_factories;
+}
+gint
+_mmplayer_gst_decode_autoplug_select(GstElement *bin, GstPad *pad,
+ GstCaps *caps, GstElementFactory *factory, gpointer data)
+{
GstAutoplugSelectResult result = GST_AUTOPLUG_SELECT_TRY;
- mm_player_t* player = (mm_player_t*)data;
+ mmplayer_t *player = (mmplayer_t *)data;
- gchar* factory_name = NULL;
- gchar* caps_str = NULL;
- const gchar* klass = NULL;
+ gchar *factory_name = NULL;
+ gchar *caps_str = NULL;
+ const gchar *klass = NULL;
gint idx = 0;
factory_name = GST_OBJECT_NAME(factory);
* So, those plugins should be skipped for error handling.
*/
if (g_strrstr(klass, "Codec/Decoder/Image")) {
- LOGD("skipping [%s] by not required\n", factory_name);
+ LOGD("skipping [%s] by not required", factory_name);
result = GST_AUTOPLUG_SELECT_SKIP;
goto DONE;
}
if ((MMPLAYER_IS_MS_BUFF_SRC(player)) &&
(g_strrstr(klass, "Codec/Demuxer") || (g_strrstr(klass, "Codec/Parser")))) {
// TO CHECK : subtitle if needed, add subparse exception.
- LOGD("skipping parser/demuxer [%s] in es player by not required\n", factory_name);
+ LOGD("skipping parser/demuxer [%s] in es player by not required", factory_name);
result = GST_AUTOPLUG_SELECT_SKIP;
goto DONE;
}
if (g_strrstr(factory_name, "mpegpsdemux")) {
- LOGD("skipping PS container - not support\n");
+ LOGD("skipping PS container - not support");
result = GST_AUTOPLUG_SELECT_SKIP;
goto DONE;
}
/* don't make video because of not required */
if ((stype == MM_DISPLAY_SURFACE_NULL) &&
- (!player->set_mode.media_packet_video_stream)) {
+ (!player->set_mode.video_export)) {
LOGD("no need video decoding, expose pad");
result = GST_AUTOPLUG_SELECT_EXPOSE;
goto DONE;
}
if (g_strrstr(klass, "Codec/Decoder")) {
- if (__mmplayer_check_codec_info(player, klass, caps, factory_name) != MM_ERROR_NONE) {
- LOGD("skipping %s codec", factory_name);
- result = GST_AUTOPLUG_SELECT_SKIP;
+ result = __mmplayer_check_codec_info(player, klass, caps, factory_name);
+ if (result != GST_AUTOPLUG_SELECT_TRY) {
+ LOGW("skip add decoder");
goto DONE;
}
}
-DONE:
- MMPLAYER_FREEIF(caps_str);
+DONE:
+ MMPLAYER_FREEIF(caps_str);
+
+ return result;
+}
+
+void
+_mmplayer_gst_decode_pad_removed(GstElement *elem, GstPad *new_pad,
+ gpointer data)
+{
+ //mmplayer_t *player = (mmplayer_t *)data;
+ GstCaps *caps = NULL;
+
+ LOGD("[Decodebin2] pad-removed signal");
+
+ caps = gst_pad_query_caps(new_pad, NULL);
+ if (!caps) {
+ LOGW("query caps is NULL");
+ return;
+ }
+
+ gchar *caps_str = NULL;
+ caps_str = gst_caps_to_string(caps);
- return result;
+ LOGD("pad removed caps : %s from %s", caps_str, GST_ELEMENT_NAME(elem));
+
+ MMPLAYER_FREEIF(caps_str);
+ gst_caps_unref(caps);
}
-static void
-__mmplayer_gst_decode_pad_removed(GstElement *elem, GstPad* new_pad,
-gpointer data)
+void
+_mmplayer_gst_about_to_finish(GstElement *bin, gpointer data)
{
- //mm_player_t* player = (mm_player_t*)data;
- GstCaps* caps = NULL;
+ mmplayer_t *player = (mmplayer_t *)data;
- LOGD("[Decodebin2] pad-removed signal\n");
+ MMPLAYER_FENTER();
+ MMPLAYER_RETURN_IF_FAIL(player);
- caps = gst_pad_query_caps(new_pad, NULL);
- if (caps) {
- gchar* caps_str = NULL;
- caps_str = gst_caps_to_string(caps);
+ LOGD("got about to finish signal");
- LOGD("pad removed caps : %s from %s", caps_str, GST_ELEMENT_NAME(elem));
+ if (!MMPLAYER_CMD_TRYLOCK(player)) {
+ LOGW("Fail to get cmd lock");
+ return;
+ }
- MMPLAYER_FREEIF(caps_str);
- gst_caps_unref(caps);
+ if (!__mmplayer_verify_gapless_play_path(player)) {
+ LOGD("decoding is finished.");
+ MMPLAYER_CMD_UNLOCK(player);
+ return;
}
+
+ _mmplayer_set_reconfigure_state(player, TRUE);
+ MMPLAYER_CMD_UNLOCK(player);
+
+ MMPLAYER_POST_MSG(player, MM_MESSAGE_GAPLESS_CONSTRUCTION, NULL);
+ __mmplayer_deactivate_old_path(player);
+
+ MMPLAYER_FLEAVE();
}
-static void
-__mmplayer_gst_decode_drained(GstElement *bin, gpointer data)
+void
+_mmplayer_gst_decode_drained(GstElement *bin, gpointer data)
{
- mm_player_t* player = (mm_player_t*)data;
+ mmplayer_t *player = (mmplayer_t *)data;
GstIterator *iter = NULL;
GValue item = { 0, };
GstPad *pad = NULL;
MMPLAYER_FENTER();
MMPLAYER_RETURN_IF_FAIL(player);
- LOGD("__mmplayer_gst_decode_drained");
+ LOGD("got drained signal");
if (!MMPLAYER_CMD_TRYLOCK(player)) {
LOGW("Fail to get cmd lock");
return;
}
- if (!player->gapless.reconfigure && /* If it is already checked, skip verify. */
- !__mmplayer_verify_gapless_play_path(player)) {
+ if (!__mmplayer_verify_gapless_play_path(player)) {
LOGD("decoding is finished.");
- __mmplayer_reset_gapless_state(player);
MMPLAYER_CMD_UNLOCK(player);
return;
}
- player->gapless.reconfigure = TRUE;
+ _mmplayer_set_reconfigure_state(player, TRUE);
+ MMPLAYER_CMD_UNLOCK(player);
/* check decodebin src pads whether they received EOS or not */
iter = gst_element_iterate_src_pads(player->pipeline->mainbin[MMPLAYER_M_AUTOPLUG].gst);
if (!is_all_drained) {
LOGD("Wait util the all pads get EOS.");
- MMPLAYER_CMD_UNLOCK(player);
MMPLAYER_FLEAVE();
return;
}
/* deactivate pipeline except sinkbins to set up the new pipeline of next uri*/
MMPLAYER_POST_MSG(player, MM_MESSAGE_GAPLESS_CONSTRUCTION, NULL); /* post message for gapless */
__mmplayer_deactivate_old_path(player);
- MMPLAYER_CMD_UNLOCK(player);
MMPLAYER_FLEAVE();
}
void
-__mmplayer_gst_element_added(GstElement *bin, GstElement *element, gpointer data)
+_mmplayer_gst_element_added(GstElement *bin, GstElement *element, gpointer data)
{
- mm_player_t* player = (mm_player_t*)data;
- const gchar* klass = NULL;
- gchar* factory_name = NULL;
+ mmplayer_t *player = (mmplayer_t *)data;
+ const gchar *klass = NULL;
+ gchar *factory_name = NULL;
klass = gst_element_factory_get_metadata(gst_element_get_factory(element), GST_ELEMENT_METADATA_KLASS);
factory_name = GST_OBJECT_NAME(gst_element_get_factory(element));
- LOGD("new elem klass: %s, factory_name: %s, new elem name : %s\n", klass, factory_name, GST_ELEMENT_NAME(element));
+ LOGD("new elem klass: %s, factory_name: %s, new elem name : %s", klass, factory_name, GST_ELEMENT_NAME(element));
if (__mmplayer_add_dump_buffer_probe(player, element))
LOGD("add buffer probe");
- //<-
if (g_strrstr(klass, "Codec/Decoder/Audio")) {
- gchar* selected = NULL;
+ gchar *selected = NULL;
selected = g_strdup(GST_ELEMENT_NAME(element));
player->audio_decoders = g_list_append(player->audio_decoders, selected);
- }
- //-> temp code
- if (g_strrstr(klass, "Parser")) {
- gchar* selected = NULL;
-
- selected = g_strdup(factory_name);
- player->parsers = g_list_append(player->parsers, selected);
+ /* update codec info */
+ player->not_supported_codec &= MISSING_PLUGIN_VIDEO;
+ player->can_support_codec |= FOUND_PLUGIN_AUDIO;
+ player->audiodec_linked = 1;
+ } else if (g_strrstr(klass, "Codec/Decoder/Video")) {
+ /* update codec info */
+ player->not_supported_codec &= MISSING_PLUGIN_AUDIO;
+ player->can_support_codec |= FOUND_PLUGIN_VIDEO;
+ player->videodec_linked = 1;
}
if (g_strrstr(klass, "Demuxer/Adaptive")) {
"max-video-width", player->adaptive_info.limit.width,
"max-video-height", player->adaptive_info.limit.height, NULL);
- } else if (g_strrstr(klass, "Demux") || g_strrstr(klass, "Parse")) {
- /* FIXIT : first value will be overwritten if there's more
- * than 1 demuxer/parser
- */
-
- //LOGD("plugged element is demuxer. take it\n");
+ } else if (g_strrstr(klass, "Demuxer")) {
+#ifdef __DEBUG__
+ LOGD("plugged element is demuxer. take it");
+#endif
player->pipeline->mainbin[MMPLAYER_M_DEMUX].id = MMPLAYER_M_DEMUX;
player->pipeline->mainbin[MMPLAYER_M_DEMUX].gst = element;
-
- /*Added for multi audio support */ // Q. del?
- if (g_strrstr(klass, "Demux")) {
- player->pipeline->mainbin[MMPLAYER_M_DEMUX_EX].id = MMPLAYER_M_DEMUX_EX;
- player->pipeline->mainbin[MMPLAYER_M_DEMUX_EX].gst = element;
- }
}
if (g_strrstr(factory_name, "asfdemux") || g_strrstr(factory_name, "qtdemux") || g_strrstr(factory_name, "avidemux")) {
// to support trust-zone only
if (g_strrstr(factory_name, "asfdemux")) {
- LOGD("set file-location %s\n", player->profile.uri);
+ LOGD("set file-location %s", player->profile.uri);
g_object_set(G_OBJECT(element), "file-location", player->profile.uri, NULL);
} else if (g_strrstr(factory_name, "legacyh264parse")) {
- LOGD("[%s] output-format to legacyh264parse\n", "mssdemux");
+ LOGD("[%s] output-format to legacyh264parse", "mssdemux");
g_object_set(G_OBJECT(element), "output-format", 1, NULL); /* NALU/Byte Stream format */
} else if (g_strrstr(factory_name, "mpegaudioparse")) {
if ((MMPLAYER_IS_HTTP_STREAMING(player)) &&
player->pipeline->mainbin[MMPLAYER_M_DEMUXED_S_BUFFER].id = MMPLAYER_M_DEMUXED_S_BUFFER;
player->pipeline->mainbin[MMPLAYER_M_DEMUXED_S_BUFFER].gst = element;
- if (!MMPLAYER_IS_HTTP_PD(player) &&
- ((MMPLAYER_IS_HTTP_STREAMING(player)) ||
+ if ((MMPLAYER_IS_HTTP_STREAMING(player)) ||
(MMPLAYER_IS_HTTP_LIVE_STREAMING(player)) ||
- (MMPLAYER_IS_DASH_STREAMING(player)))) {
+ (MMPLAYER_IS_DASH_STREAMING(player))) {
/* in case of multiqueue, max bytes size is defined with fixed value in mm_player_streaming.h*/
- __mm_player_streaming_set_multiqueue(player->streamer, element, player->ini.http_buffering_time, 1.0, player->ini.http_buffering_limit);
- __mm_player_streaming_sync_property(player->streamer, player->pipeline->mainbin[MMPLAYER_M_AUTOPLUG].gst);
+ _mm_player_streaming_set_multiqueue(player->streamer, element);
+ _mm_player_streaming_sync_property(player->streamer, player->pipeline->mainbin[MMPLAYER_M_AUTOPLUG].gst);
}
}
}
static void
-__mmplayer_release_misc(mm_player_t* player)
+__mmplayer_release_misc(mmplayer_t *player)
{
int i;
bool cur_mode = player->set_mode.rich_audio;
MMPLAYER_RETURN_IF_FAIL(player);
- player->video_stream_cb = NULL;
- player->video_stream_cb_user_param = NULL;
- player->video_stream_prerolled = FALSE;
-
- player->audio_stream_render_cb = 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->http_content_size = 0;
player->not_supported_codec = MISSING_PLUGIN_NONE;
player->can_support_codec = FOUND_PLUGIN_NONE;
- player->pending_seek.is_pending = FALSE;
+ player->pending_seek.is_pending = false;
player->pending_seek.pos = 0;
player->msg_posted = FALSE;
player->has_many_types = FALSE;
player->is_subtitle_force_drop = FALSE;
player->play_subtitle = FALSE;
player->adjust_subtitle_pos = 0;
- player->last_multiwin_status = FALSE;
player->has_closed_caption = FALSE;
- player->set_mode.media_packet_video_stream = false;
+ player->set_mode.video_export = false;
player->profile.uri_type = MM_PLAYER_URI_TYPE_NONE;
- memset(&player->set_mode, 0, sizeof(MMPlayerSetMode));
+ memset(&player->set_mode, 0, sizeof(mmplayer_setting_mode_t));
/* recover mode */
player->set_mode.rich_audio = cur_mode;
+ if (player->audio_device_cb_id > 0 &&
+ mm_sound_remove_device_connected_callback(player->audio_device_cb_id) != MM_ERROR_NONE)
+ LOGW("failed to remove audio device_connected_callback");
+ player->audio_device_cb_id = 0;
+
for (i = 0; i < MM_PLAYER_STREAM_COUNT_MAX; i++) {
player->bitrate[i] = 0;
player->maximum_bitrate[i] = 0;
}
- MMPLAYER_MEDIA_STREAM_CALLBACK_LOCK(player);
-
- /* 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;
- player->buffer_cb_user_param[i] = NULL;
- player->seek_cb_user_param[i] = NULL;
- }
- MMPLAYER_MEDIA_STREAM_CALLBACK_UNLOCK(player);
-
/* free memory related to audio effect */
MMPLAYER_FREEIF(player->audio_effect_info.custom_ext_level_for_plugin);
}
static void
-__mmplayer_release_misc_post(mm_player_t* player)
+__mmplayer_release_misc_post(mmplayer_t *player)
{
char *original_uri = NULL;
MMPLAYER_FENTER();
/* player->pipeline is already released before. */
-
MMPLAYER_RETURN_IF_FAIL(player);
- mm_attrs_set_int_by_name(player->attrs, "content_video_found", 0);
+ player->video_decoded_cb = NULL;
+ player->video_decoded_cb_user_param = NULL;
+ player->video_stream_prerolled = false;
- /* clean found parsers */
- if (player->parsers) {
- GList *parsers = player->parsers;
- for (; parsers; parsers = g_list_next(parsers)) {
- gchar *name = parsers->data;
- MMPLAYER_FREEIF(name);
- }
- g_list_free(player->parsers);
- player->parsers = NULL;
- }
+ player->audio_decoded_cb = NULL;
+ player->audio_decoded_cb_user_param = NULL;
+ player->audio_extract_opt = MM_PLAYER_AUDIO_EXTRACT_DEFAULT;
+
+ player->audio_stream_changed_cb = NULL;
+ player->audio_stream_changed_cb_user_param = NULL;
+
+ mm_player_set_attribute((MMHandleType)player, NULL, "content_video_found", 0, NULL);
/* clean found audio decoders */
if (player->audio_decoders) {
- GList *a_dec = player->audio_decoders;
- for (; a_dec; a_dec = g_list_next(a_dec)) {
- gchar *name = a_dec->data;
- MMPLAYER_FREEIF(name);
- }
- g_list_free(player->audio_decoders);
+ g_list_free_full(player->audio_decoders, (GDestroyNotify)g_free);
player->audio_decoders = NULL;
}
/* clean the uri list except original uri */
- if (player->uri_info.uri_list) {
+ if (player->uri_info.uri_list && g_list_length(player->uri_info.uri_list) > 1) {
+ GList *tmp = NULL;
original_uri = g_list_nth_data(player->uri_info.uri_list, 0);
+ tmp = g_list_remove_link(player->uri_info.uri_list, player->uri_info.uri_list);
+ g_list_free_full(tmp, (GDestroyNotify)g_free);
- if (player->attrs) {
- mm_attrs_set_string_by_name(player->attrs, "profile_uri", original_uri);
- LOGD("restore original uri = %s\n", original_uri);
+ if (!original_uri)
+ LOGW("failed to get original uri info");
- if (mm_attrs_commit_all(player->attrs))
- LOGE("failed to commit the original uri.\n");
- }
+ mm_player_set_attribute((MMHandleType)player, NULL, "profile_uri",
+ original_uri, (original_uri) ? strlen(original_uri) : (0), NULL);
- GList *uri_list = player->uri_info.uri_list;
- for (; uri_list; uri_list = g_list_next(uri_list)) {
- gchar *uri = uri_list->data;
- MMPLAYER_FREEIF(uri);
- }
- g_list_free(player->uri_info.uri_list);
- player->uri_info.uri_list = NULL;
}
/* clear the audio stream buffer list */
- __mmplayer_audio_stream_clear_buffer(player, FALSE);
+ _mmplayer_audio_stream_clear_buffer(player, FALSE);
/* clear the video stream bo list */
__mmplayer_video_stream_destroy_bo_list(player);
}
gboolean
-__mmplayer_check_subtitle(mm_player_t* player)
+__mmplayer_check_subtitle(mmplayer_t *player)
{
MMHandleType attrs = 0;
char *subtitle_uri = NULL;
if (!subtitle_uri || !strlen(subtitle_uri))
return FALSE;
- SECURE_LOGD("subtitle uri is %s[%d]", subtitle_uri, strlen(subtitle_uri));
+ SECURE_LOGD("subtitle uri is %s[%zu]", subtitle_uri, strlen(subtitle_uri));
player->is_external_subtitle_present = TRUE;
MMPLAYER_FLEAVE();
}
void
-__mmplayer_cancel_eos_timer(mm_player_t* player)
+_mmplayer_cancel_eos_timer(mmplayer_t *player)
{
MMPLAYER_RETURN_IF_FAIL(player);
}
static void
-__mmplayer_add_sink(mm_player_t* player, GstElement* sink)
+__mmplayer_add_sink(mmplayer_t *player, GstElement *sink)
{
MMPLAYER_FENTER();
MMPLAYER_RETURN_IF_FAIL(player);
MMPLAYER_RETURN_IF_FAIL(sink);
- player->sink_elements =
- g_list_append(player->sink_elements, sink);
+ player->sink_elements = g_list_append(player->sink_elements, sink);
MMPLAYER_FLEAVE();
}
static void
-__mmplayer_del_sink(mm_player_t* player, GstElement* sink)
+__mmplayer_del_sink(mmplayer_t *player, GstElement *sink)
{
MMPLAYER_FENTER();
MMPLAYER_RETURN_IF_FAIL(player);
MMPLAYER_RETURN_IF_FAIL(sink);
- player->sink_elements =
- g_list_remove(player->sink_elements, sink);
+ player->sink_elements = g_list_remove(player->sink_elements, sink);
MMPLAYER_FLEAVE();
}
void
-__mmplayer_add_signal_connection(mm_player_t* player, GObject* object,
- MMPlayerSignalType type, const gchar* signal, GCallback cb_funct, gpointer u_data)
+_mmplayer_add_signal_connection(mmplayer_t *player, GObject *object,
+ mmplayer_signal_type_e type, const gchar *signal, GCallback cb_funct, gpointer u_data)
{
- MMPlayerSignalItem* item = NULL;
+ mmplayer_signal_item_t *item = NULL;
MMPLAYER_FENTER();
MMPLAYER_RETURN_IF_FAIL(player);
return;
}
- item = (MMPlayerSignalItem*)g_malloc(sizeof(MMPlayerSignalItem));
+ item = (mmplayer_signal_item_t *)g_try_malloc(sizeof(mmplayer_signal_item_t));
if (!item) {
LOGE("cannot connect signal [%s]", signal);
return;
* g_signal_handler_disconnect(instance, id);
*/
static void
-__mmplayer_release_signal_connection(mm_player_t* player, MMPlayerSignalType type)
+__mmplayer_release_signal_connection(mmplayer_t *player, mmplayer_signal_type_e type)
{
- GList* sig_list = NULL;
- MMPlayerSignalItem* item = NULL;
+ GList *sig_list = NULL;
+ mmplayer_signal_item_t *item = NULL;
MMPLAYER_FENTER();
return;
}
-int _mmplayer_change_videosink(MMHandleType handle, MMDisplaySurfaceType surface_type, void *display_overlay)
+int
+_mmplayer_change_videosink(MMHandleType handle, MMDisplaySurfaceType surface_type, int wl_surface_id)
{
- mm_player_t* player = 0;
+ mmplayer_t *player = 0;
int prev_display_surface_type = 0;
- void *prev_display_overlay = NULL;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(handle, MM_ERROR_COMMON_INVALID_ARGUMENT);
- MMPLAYER_RETURN_VAL_IF_FAIL(display_overlay, MM_ERROR_COMMON_INVALID_ARGUMENT);
player = MM_PLAYER_CAST(handle);
/* check video sinkbin is created */
- if (__mmplayer_video_param_check_video_sink_bin(player) == MM_ERROR_NONE) {
- LOGE("Videosink is already created");
+ if (_mmplayer_is_videosink_ready(player, MM_DISPLAY_SURFACE_NUM)) {
+ LOGW("Videosink is already created");
return MM_ERROR_NONE;
}
/* load previous attributes */
if (player->attrs) {
mm_attrs_get_int_by_name(player->attrs, "display_surface_type", &prev_display_surface_type);
- mm_attrs_get_data_by_name(player->attrs, "display_overlay", &prev_display_overlay);
LOGD("[0: Video surface, 4: EVAS surface] previous surface type(%d), new surface type(%d)", prev_display_surface_type, surface_type);
if (prev_display_surface_type == surface_type) {
LOGD("incoming display surface type is same as previous one, do nothing..");
/* videobin is not created yet, so we just set attributes related to display surface */
LOGD("store display attribute for given surface type(%d)", surface_type);
- mm_attrs_set_int_by_name(player->attrs, "display_surface_type", surface_type);
- mm_attrs_set_data_by_name(player->attrs, "display_overlay", display_overlay, sizeof(display_overlay));
- if (mm_attrs_commit_all(player->attrs)) {
- LOGE("failed to commit attribute");
- MMPLAYER_FLEAVE();
- return MM_ERROR_PLAYER_INTERNAL;
- }
+ mm_player_set_attribute(handle, NULL, "display_surface_type", surface_type,
+ "display_overlay", wl_surface_id, NULL);
MMPLAYER_FLEAVE();
return MM_ERROR_NONE;
}
/* Note : if silent is true, then subtitle would not be displayed. :*/
-int _mmplayer_set_subtitle_silent(MMHandleType hplayer, int silent)
+int
+_mmplayer_set_subtitle_silent(MMHandleType hplayer, int silent)
{
- mm_player_t* player = (mm_player_t*) hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
MMPLAYER_FENTER();
player->set_mode.subtitle_off = silent;
- LOGD("subtitle is %s.\n", player->set_mode.subtitle_off ? "ON" : "OFF");
+ LOGD("subtitle is %s.", player->set_mode.subtitle_off ? "ON" : "OFF");
MMPLAYER_FLEAVE();
return MM_ERROR_NONE;
}
-int _mmplayer_sync_subtitle_pipeline(mm_player_t* player)
+int
+_mmplayer_sync_subtitle_pipeline(mmplayer_t *player)
{
- MMPlayerGstElement* mainbin = NULL;
- MMPlayerGstElement* textbin = NULL;
+ mmplayer_gst_element_t *mainbin = NULL;
+ mmplayer_gst_element_t *textbin = NULL;
GstStateChangeReturn ret = GST_STATE_CHANGE_FAILURE;
GstState current_state = GST_STATE_VOID_PENDING;
GstState element_state = GST_STATE_VOID_PENDING;
ret = gst_element_get_state(mainbin[MMPLAYER_M_SUBSRC].gst, &element_state, &element_pending_state, 5 * GST_SECOND);
if (GST_STATE_CHANGE_FAILURE == ret) {
- LOGE("fail to state change.\n");
+ LOGE("fail to state change.");
result = MM_ERROR_PLAYER_INTERNAL;
goto ERROR;
}
}
-
gst_element_set_base_time(textbin[MMPLAYER_T_BIN].gst, base_time);
gst_element_set_start_time(textbin[MMPLAYER_T_BIN].gst, start_time);
// seek to current position
if (!gst_element_query_position(mainbin[MMPLAYER_M_PIPE].gst, GST_FORMAT_TIME, &time)) {
result = MM_ERROR_PLAYER_INVALID_STATE;
- LOGE("gst_element_query_position failed, invalid state\n");
+ LOGE("gst_element_query_position failed, invalid state");
goto ERROR;
}
LOGD("seek time = %"G_GINT64_FORMAT", rate = %f", time, player->playback_rate);
event = gst_event_new_seek(player->playback_rate, GST_FORMAT_TIME, (GstSeekFlags)(GST_SEEK_FLAG_FLUSH), GST_SEEK_TYPE_SET, time, GST_SEEK_TYPE_NONE, -1);
if (event) {
- __mmplayer_gst_send_event_to_sink(player, event);
+ _mmplayer_gst_send_event_to_sink(player, event);
} else {
result = MM_ERROR_PLAYER_INTERNAL;
LOGE("gst_event_new_seek failed"); /* pipeline will got error and can not be recovered */
}
static int
-__mmplayer_change_external_subtitle_language(mm_player_t* player, const char* filepath)
+__mmplayer_change_external_subtitle_language(mmplayer_t *player, const char *filepath)
{
GstStateChangeReturn ret = GST_STATE_CHANGE_FAILURE;
GstState current_state = GST_STATE_VOID_PENDING;
MMHandleType attrs = 0;
- MMPlayerGstElement* mainbin = NULL;
- MMPlayerGstElement* textbin = NULL;
+ mmplayer_gst_element_t *mainbin = NULL;
+ mmplayer_gst_element_t *textbin = NULL;
- gchar* subtitle_uri = NULL;
+ gchar *subtitle_uri = NULL;
int result = MM_ERROR_NONE;
const gchar *charset = NULL;
current_state = GST_STATE(mainbin[MMPLAYER_M_PIPE].gst);
if (current_state < GST_STATE_READY) {
result = MM_ERROR_PLAYER_INVALID_STATE;
- LOGE("Pipeline is not in proper state\n");
+ LOGE("Pipeline is not in proper state");
goto EXIT;
}
attrs = MMPLAYER_GET_ATTRS(player);
if (!attrs) {
- LOGE("cannot get content attribute\n");
+ LOGE("cannot get content attribute");
result = MM_ERROR_PLAYER_INTERNAL;
goto EXIT;
}
mm_attrs_get_string_by_name(attrs, "subtitle_uri", &subtitle_uri);
if (!subtitle_uri || strlen(subtitle_uri) < 1) {
- LOGE("subtitle uri is not proper filepath\n");
+ LOGE("subtitle uri is not proper filepath");
result = MM_ERROR_PLAYER_INVALID_URI;
goto EXIT;
}
- if (!util_get_storage_info(filepath, &player->storage_info[MMPLAYER_PATH_TEXT])) {
+ if (!_mmplayer_get_storage_info(filepath, &player->storage_info[MMPLAYER_PATH_TEXT])) {
LOGE("failed to get storage info of subtitle path");
result = MM_ERROR_PLAYER_INVALID_URI;
goto EXIT;
}
- LOGD("old subtitle file path is [%s]\n", subtitle_uri);
- LOGD("new subtitle file path is [%s]\n", filepath);
+ SECURE_LOGD("old subtitle file path is [%s]", subtitle_uri);
+ SECURE_LOGD("new subtitle file path is [%s]", filepath);
if (!strcmp(filepath, subtitle_uri)) {
- LOGD("No need to swtich subtitle, as input filepath is same as current filepath\n");
+ LOGD("subtitle path is not changed");
goto EXIT;
} else {
- mm_attrs_set_string_by_name(player->attrs, "subtitle_uri", filepath);
- if (mm_attrs_commit_all(player->attrs)) {
- LOGE("failed to commit.\n");
+ if (mm_player_set_attribute((MMHandleType)player, NULL,
+ "subtitle_uri", filepath, strlen(filepath), NULL) != MM_ERROR_NONE) {
+ LOGE("failed to set attribute");
goto EXIT;
}
}
g_object_set(G_OBJECT(mainbin[MMPLAYER_M_SUBSRC].gst), "location", filepath, NULL);
- charset = util_get_charset(filepath);
+ charset = _mmplayer_get_charset(filepath);
if (charset) {
- LOGD("detected charset is %s\n", charset);
+ LOGD("detected charset is %s", charset);
g_object_set(G_OBJECT(mainbin[MMPLAYER_M_SUBPARSE].gst), "subtitle-encoding", charset, NULL);
}
}
/* API to switch between external subtitles */
-int _mmplayer_set_external_subtitle_path(MMHandleType hplayer, const char* filepath)
+int
+_mmplayer_set_external_subtitle_path(MMHandleType hplayer, const char *filepath)
{
int result = MM_ERROR_NONE;
- mm_player_t* player = (mm_player_t*)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
char *path = NULL;
MMPLAYER_FENTER();
if (filepath) {
/* check file path */
if ((path = strstr(filepath, "file://")))
- result = util_exist_file_path(path + 7);
+ result = _mmplayer_exist_file_path(path + 7);
else
- result = util_exist_file_path(filepath);
+ result = _mmplayer_exist_file_path(filepath);
if (result != MM_ERROR_NONE) {
LOGE("invalid subtitle path 0x%X", result);
if (!player->pipeline) {
/* IDLE state */
- mm_attrs_set_string_by_name(player->attrs, "subtitle_uri", filepath);
- if (mm_attrs_commit_all(player->attrs)) {
- LOGE("failed to commit"); /* subtitle path will not be created */
+ if (mm_player_set_attribute(hplayer, NULL, "subtitle_uri", filepath,
+ (filepath)?(strlen(filepath)):(0), NULL) != MM_ERROR_NONE) {
+ LOGE("failed to set attribute");
return MM_ERROR_PLAYER_INTERNAL;
}
} else {
MMPLAYER_RETURN_VAL_IF_FAIL(filepath, MM_ERROR_COMMON_INVALID_ARGUMENT);
if (!__mmplayer_check_subtitle(player)) {
- mm_attrs_set_string_by_name(player->attrs, "subtitle_uri", filepath);
- if (mm_attrs_commit_all(player->attrs)) {
- LOGE("failed to commit");
+ if (mm_player_set_attribute(hplayer, NULL, "subtitle_uri",
+ filepath, strlen(filepath), NULL) != MM_ERROR_NONE) {
+ LOGE("failed to set attribute");
return MM_ERROR_PLAYER_INTERNAL;
}
- if (MM_ERROR_NONE != __mmplayer_gst_create_text_pipeline(player)) {
+ if (__mmplayer_gst_create_text_pipeline(player) != MM_ERROR_NONE) {
LOGE("fail to create text pipeline");
return MM_ERROR_PLAYER_INTERNAL;
}
}
static int
-__mmplayer_change_selector_pad(mm_player_t* player, MMPlayerTrackType type, int index)
+__mmplayer_switch_stream(mmplayer_t *player, mmplayer_track_type_e type, int index)
+{
+ guint active_idx = 0;
+ GstStream *stream = NULL;
+ GList *streams = NULL;
+ GstEvent *ev = NULL;
+ GstCaps *caps = NULL;
+
+ LOGD("Switching Streams... type: %d, index: %d", type, index);
+
+ player->track[type].active_track_index = index;
+
+ for (int i = 0; i < MM_PLAYER_TRACK_TYPE_MAX; i++) {
+ /* FIXME: need to consider the non display type or audio only in case of MM_PLAYER_TRACK_TYPE_VIDEO */
+ if (player->track[i].total_track_num > 0) {
+ active_idx = player->track[i].active_track_index;
+ stream = g_ptr_array_index(player->track[i].streams, active_idx);
+ streams = g_list_append (streams, (gchar *)gst_stream_get_stream_id(stream));
+ LOGD("Selecting %d type stream : %s\n", i, gst_stream_get_stream_id(stream));
+
+ if (i == MM_PLAYER_TRACK_TYPE_AUDIO) {
+ caps = gst_stream_get_caps(stream);
+ if (caps) {
+ _mmplayer_set_audio_attrs(player, caps);
+ gst_caps_unref(caps);
+ }
+ }
+ }
+ }
+
+ ev = gst_event_new_select_streams(streams);
+ gst_element_send_event(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, ev);
+ g_list_free(streams);
+
+ return MM_ERROR_NONE;
+}
+
+static int
+__mmplayer_change_selector_pad(mmplayer_t *player, mmplayer_track_type_e type, int index)
{
int result = MM_ERROR_NONE;
- gchar* change_pad_name = NULL;
- GstPad* sinkpad = NULL;
- MMPlayerGstElement* mainbin = NULL;
- enum MainElementID elem_idx = MMPLAYER_M_NUM;
- GstCaps* caps = NULL;
+ gchar *change_pad_name = NULL;
+ GstPad *sinkpad = NULL;
+ mmplayer_gst_element_t *mainbin = NULL;
+ main_element_id_e elem_idx = MMPLAYER_M_NUM;
+ GstCaps *caps = NULL;
gint total_track_num = 0;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player && player->pipeline && player->pipeline->mainbin,
MM_ERROR_PLAYER_NOT_INITIALIZED);
- LOGD("Change Track(%d) to %d\n", type, index);
+ LOGD("Change Track(%d) to %d", type, index);
mainbin = player->pipeline->mainbin;
elem_idx = MMPLAYER_M_T_INPUT_SELECTOR;
} else {
/* Changing Video Track is not supported. */
- LOGE("Track Type Error\n");
+ LOGE("Track Type Error");
goto EXIT;
}
if (mainbin[elem_idx].gst == NULL) {
result = MM_ERROR_PLAYER_NO_OP;
- LOGD("Req track doesn't exist\n");
+ LOGD("Req track doesn't exist");
goto EXIT;
}
- total_track_num = player->selector[type].total_track_num;
+ total_track_num = player->track[type].total_track_num;
if (total_track_num <= 0) {
result = MM_ERROR_PLAYER_NO_OP;
- LOGD("Language list is not available \n");
+ LOGD("Language list is not available");
goto EXIT;
}
if ((index < 0) || (index >= total_track_num)) {
result = MM_ERROR_INVALID_ARGUMENT;
- LOGD("Not a proper index : %d \n", index);
+ LOGD("Not a proper index : %d", index);
goto EXIT;
}
change_pad_name = g_strdup_printf("sink_%u", index);
if (change_pad_name == NULL) {
result = MM_ERROR_PLAYER_INTERNAL;
- LOGD("Pad does not exists\n");
+ LOGD("Pad does not exists");
goto EXIT;
}
- LOGD("new active pad name: %s\n", change_pad_name);
+ LOGD("new active pad name: %s", change_pad_name);
sinkpad = gst_element_get_static_pad(mainbin[elem_idx].gst, change_pad_name);
if (sinkpad == NULL) {
goto EXIT;
}
- LOGD("Set Active Pad - %s:%s\n", GST_DEBUG_PAD_NAME(sinkpad));
+ LOGD("Set Active Pad - %s:%s", GST_DEBUG_PAD_NAME(sinkpad));
g_object_set(mainbin[elem_idx].gst, "active-pad", sinkpad, NULL);
caps = gst_pad_get_current_caps(sinkpad);
gst_object_unref(sinkpad);
if (type == MM_PLAYER_TRACK_TYPE_AUDIO)
- __mmplayer_set_audio_attrs(player, caps);
+ _mmplayer_set_audio_attrs(player, caps);
-EXIT:
+ if (caps)
+ gst_caps_unref(caps);
+EXIT:
MMPLAYER_FREEIF(change_pad_name);
return result;
}
-int _mmplayer_change_track_language(MMHandleType hplayer, MMPlayerTrackType type, int index)
+int
+_mmplayer_change_track_language(MMHandleType hplayer, mmplayer_track_type_e type, int index)
{
int result = MM_ERROR_NONE;
- mm_player_t* player = NULL;
- MMPlayerGstElement* mainbin = NULL;
+ mmplayer_t *player = NULL;
+ mmplayer_gst_element_t *mainbin = NULL;
gint current_active_index = 0;
GstState current_state = GST_STATE_VOID_PENDING;
- GstEvent* event = NULL;
gint64 time = 0;
MMPLAYER_FENTER();
- player = (mm_player_t*)hplayer;
+ player = (mmplayer_t *)hplayer;
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
if (!player->pipeline) {
- LOGE("Track %d pre setting -> %d\n", type, index);
+ LOGE("Track %d pre setting -> %d", type, index);
- player->selector[type].active_pad_index = index;
+ player->track[type].active_track_index = index;
goto EXIT;
}
mainbin = player->pipeline->mainbin;
- current_active_index = player->selector[type].active_pad_index;
+ current_active_index = player->track[type].active_track_index;
/*If index is same as running index no need to change the pad*/
if (current_active_index == index)
current_state = GST_STATE(mainbin[MMPLAYER_M_PIPE].gst);
if (current_state < GST_STATE_PAUSED) {
result = MM_ERROR_PLAYER_INVALID_STATE;
- LOGW("Pipeline not in porper state\n");
+ LOGW("Pipeline not in porper state");
goto EXIT;
}
- result = __mmplayer_change_selector_pad(player, type, index);
+ if (MMPLAYER_USE_DECODEBIN(player))
+ result = __mmplayer_change_selector_pad(player, type, index);
+ else
+ result = __mmplayer_switch_stream(player, type, index);
+
if (result != MM_ERROR_NONE) {
- LOGE("change selector pad error\n");
+ LOGE("failed to change track");
goto EXIT;
}
- player->selector[type].active_pad_index = index;
+ player->track[type].active_track_index = index;
- if (current_state == GST_STATE_PLAYING) {
- event = gst_event_new_seek(player->playback_rate, GST_FORMAT_TIME, (GstSeekFlags)(GST_SEEK_FLAG_SEGMENT | GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_SKIP), GST_SEEK_TYPE_SET, time, GST_SEEK_TYPE_NONE, -1);
- if (event) {
- __mmplayer_gst_send_event_to_sink(player, event);
- } else {
- result = MM_ERROR_PLAYER_INTERNAL;
- goto EXIT;
+ if (MMPLAYER_USE_DECODEBIN(player)) {
+ GstEvent *event = NULL;
+ if (current_state == GST_STATE_PLAYING) {
+ event = gst_event_new_seek(player->playback_rate, GST_FORMAT_TIME,
+ (GstSeekFlags)(GST_SEEK_FLAG_SEGMENT | GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_SKIP),
+ GST_SEEK_TYPE_SET, time, GST_SEEK_TYPE_NONE, -1);
+ if (event) {
+ _mmplayer_gst_send_event_to_sink(player, event);
+ } else {
+ result = MM_ERROR_PLAYER_INTERNAL;
+ goto EXIT;
+ }
}
}
return result;
}
-int _mmplayer_get_subtitle_silent(MMHandleType hplayer, int* silent)
+int
+_mmplayer_get_subtitle_silent(MMHandleType hplayer, int *silent)
{
- mm_player_t* player = (mm_player_t*) hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
MMPLAYER_FENTER();
*silent = player->set_mode.subtitle_off;
- LOGD("subtitle is %s.\n", silent ? "ON" : "OFF");
+ LOGD("subtitle is %s.", silent ? "ON" : "OFF");
MMPLAYER_FLEAVE();
}
static gboolean
-__mmplayer_add_dump_buffer_probe(mm_player_t *player, GstElement *element)
+__mmplayer_add_dump_buffer_probe(mmplayer_t *player, GstElement *element)
{
MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
MMPLAYER_RETURN_VAL_IF_FAIL(element, FALSE);
for (idx = 0; player->ini.dump_element_keyword[idx][0] != '\0'; idx++) {
if (g_strrstr(factory_name, player->ini.dump_element_keyword[idx])) {
LOGD("dump [%s] sink pad", player->ini.dump_element_keyword[idx]);
- mm_player_dump_t *dump_s;
- dump_s = g_malloc(sizeof(mm_player_dump_t));
-
+ mmplayer_dump_t *dump_s;
+ dump_s = g_try_malloc(sizeof(mmplayer_dump_t));
if (dump_s == NULL) {
LOGE("malloc fail");
return FALSE;
dump_s->dump_pad = gst_element_get_static_pad(element, "sink");
if (dump_s->dump_pad) {
- memset(dump_file_name, 0x00, PLAYER_INI_MAX_STRLEN*2);
- snprintf(dump_file_name, PLAYER_INI_MAX_STRLEN*2, "%s/%s_sink_pad.dump", player->ini.dump_element_path, player->ini.dump_element_keyword[idx]);
+ memset(dump_file_name, 0x00, PLAYER_INI_MAX_STRLEN * 2);
+ snprintf(dump_file_name, PLAYER_INI_MAX_STRLEN * 2, "%s/%s_sink_pad.dump", player->ini.dump_element_path, player->ini.dump_element_keyword[idx]);
dump_s->dump_element_file = fopen(dump_file_name, "w+");
dump_s->probe_handle_id = gst_pad_add_probe(dump_s->dump_pad, GST_PAD_PROBE_TYPE_BUFFER, __mmplayer_dump_buffer_probe_cb, dump_s->dump_element_file, NULL);
/* add list for removed buffer probe and close FILE */
LOGD("%s sink pad added buffer probe for dump", factory_name);
return TRUE;
} else {
- g_free(dump_s);
- dump_s = NULL;
+ MMPLAYER_FREEIF(dump_s);
LOGE("failed to get %s sink pad added", factory_name);
}
}
static GstPadProbeReturn
__mmplayer_dump_buffer_probe_cb(GstPad *pad, GstPadProbeInfo *info, gpointer u_data)
{
- FILE *dump_data = (FILE *) u_data;
+ FILE *dump_data = (FILE *)u_data;
// int written = 0;
GstBuffer *buffer = gst_pad_probe_info_get_buffer(info);
GstMapInfo probe_info = GST_MAP_INFO_INIT;
- MMPLAYER_RETURN_VAL_IF_FAIL(dump_data, FALSE);
+ MMPLAYER_RETURN_VAL_IF_FAIL(dump_data, GST_PAD_PROBE_PASS);
gst_buffer_map(buffer, &probe_info, GST_MAP_READ);
-
-// LOGD("buffer timestamp = %" GST_TIME_FORMAT, GST_TIME_ARGS(GST_BUFFER_TIMESTAMP(buffer)));
-
+#ifdef __DEBUG__
+ LOGD("buffer timestamp = %" GST_TIME_FORMAT, GST_TIME_ARGS(GST_BUFFER_TIMESTAMP(buffer)));
+#endif
fwrite(probe_info.data, 1, probe_info.size , dump_data);
+ gst_buffer_unmap(buffer, &probe_info);
+
return GST_PAD_PROBE_OK;
}
static void
__mmplayer_release_dump_list(GList *dump_list)
{
- if (dump_list) {
- GList *d_list = dump_list;
- for (; d_list; d_list = g_list_next(d_list)) {
- mm_player_dump_t *dump_s = d_list->data;
- if (dump_s->dump_pad) {
- if (dump_s->probe_handle_id)
- gst_pad_remove_probe(dump_s->dump_pad, dump_s->probe_handle_id);
- }
- if (dump_s->dump_element_file) {
- fclose(dump_s->dump_element_file);
- dump_s->dump_element_file = NULL;
- }
- MMPLAYER_FREEIF(dump_s);
+ GList *d_list = dump_list;
+
+ if (!d_list)
+ return;
+
+ for (; d_list; d_list = g_list_next(d_list)) {
+ mmplayer_dump_t *dump_s = d_list->data;
+ if (dump_s->dump_pad) {
+ if (dump_s->probe_handle_id)
+ gst_pad_remove_probe(dump_s->dump_pad, dump_s->probe_handle_id);
+ gst_object_unref(GST_OBJECT(dump_s->dump_pad));
+ }
+ if (dump_s->dump_element_file) {
+ fclose(dump_s->dump_element_file);
+ dump_s->dump_element_file = NULL;
}
- g_list_free(dump_list);
- dump_list = NULL;
+ MMPLAYER_FREEIF(dump_s);
}
+ g_list_free(dump_list);
+ dump_list = NULL;
}
int
-_mmplayer_has_closed_caption(MMHandleType hplayer, bool* exist)
+_mmplayer_has_closed_caption(MMHandleType hplayer, bool *exist)
{
- mm_player_t* player = (mm_player_t*) hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
MMPLAYER_RETURN_VAL_IF_FAIL(exist, MM_ERROR_INVALID_ARGUMENT);
- *exist = player->has_closed_caption;
+ *exist = (bool)player->has_closed_caption;
MMPLAYER_FLEAVE();
return MM_ERROR_NONE;
}
-void _mm_player_video_stream_internal_buffer_unref(void *buffer)
+void
+_mm_player_video_stream_internal_buffer_unref(void *buffer)
{
MMPLAYER_FENTER();
if (buffer) {
- // LOGD("unref internal gst buffer %p", buffer);
+#ifdef __DEBUG__
+ LOGD("unref internal gst buffer %p", buffer);
+#endif
gst_buffer_unref((GstBuffer *)buffer);
buffer = NULL;
}
MMPLAYER_FLEAVE();
}
-int _mmplayer_get_timeout(MMHandleType hplayer, int *timeout)
+int
+_mmplayer_get_timeout(MMHandleType hplayer, int *timeout)
{
- mm_player_t* player = (mm_player_t*) hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
MMPLAYER_RETURN_VAL_IF_FAIL(timeout, MM_ERROR_COMMON_INVALID_ARGUMENT);
- if (MMPLAYER_IS_HTTP_PD(player))
- /* consider the timeout both download pipeline and playback pipeline */
- *timeout = player->ini.live_state_change_timeout + PLAYER_PD_STATE_CHANGE_TIME;
- else if (MMPLAYER_IS_STREAMING(player))
- *timeout = player->ini.live_state_change_timeout;
+ if (MMPLAYER_IS_STREAMING(player))
+ *timeout = (int)player->ini.live_state_change_timeout;
else
- *timeout = player->ini.localplayback_state_change_timeout;
-
- LOGD("timeout = %d\n", *timeout);
-
- MMPLAYER_FLEAVE();
- return MM_ERROR_NONE;
-}
+ *timeout = (int)player->ini.localplayback_state_change_timeout;
-int _mmplayer_get_num_of_video_out_buffers(MMHandleType hplayer, int *num, int *extra_num)
-{
- mm_player_t* player = (mm_player_t*) hplayer;
-
- MMPLAYER_FENTER();
-
- MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
- MMPLAYER_RETURN_VAL_IF_FAIL(num && extra_num, MM_ERROR_COMMON_INVALID_ARGUMENT);
-
- *num = player->video_num_buffers;
- *extra_num = player->video_extra_num_buffers;
-
- LOGD("state %d, num %d(%d)\n", MMPLAYER_CURRENT_STATE(player), *num, *extra_num);
+ LOGD("timeout = %d", *timeout);
MMPLAYER_FLEAVE();
return MM_ERROR_NONE;
}
static void
-__mmplayer_initialize_storage_info(mm_player_t* player, MMPlayerPathType path_type)
+__mmplayer_initialize_storage_info(mmplayer_t *player, mmplayer_path_type_e path_type)
{
int i = 0;
MMPLAYER_FENTER();
MMPLAYER_FLEAVE();
}
-int _mmplayer_manage_external_storage_state(MMHandleType hplayer, int id, int state)
+int
+_mmplayer_manage_external_storage_state(MMHandleType hplayer, int id, int state)
{
int ret = MM_ERROR_NONE;
- mm_player_t* player = (mm_player_t*)hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
MMMessageParamType msg_param = {0, };
MMPLAYER_FENTER();
return MM_ERROR_NONE;
/* FIXME: text path should be handled seperately. */
- if (((player->storage_info[MMPLAYER_PATH_VOD].type == STORAGE_TYPE_EXTERNAL) && (player->storage_info[MMPLAYER_PATH_VOD].id == id)) ||
- ((player->storage_info[MMPLAYER_PATH_TEXT].type == STORAGE_TYPE_EXTERNAL) && (player->storage_info[MMPLAYER_PATH_TEXT].id == id))) {
+ if (((player->storage_info[MMPLAYER_PATH_VOD].type == STORAGE_TYPE_EXTERNAL)
+ && (player->storage_info[MMPLAYER_PATH_VOD].id == id)) ||
+ ((player->storage_info[MMPLAYER_PATH_TEXT].type == STORAGE_TYPE_EXTERNAL)
+ && (player->storage_info[MMPLAYER_PATH_TEXT].id == id))) {
LOGW("external storage is removed");
if (player->msg_posted == FALSE) {
return ret;
}
-int _mmplayer_get_adaptive_variant_info(MMHandleType hplayer, int *num, char **var_info)
+int
+_mmplayer_get_adaptive_variant_info(MMHandleType hplayer, int *num, char **var_info)
{
int ret = MM_ERROR_NONE;
- mm_player_t* player = (mm_player_t*) hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
int idx = 0, total = 0;
gchar *result = NULL, *tmp = NULL;
result = g_strdup("");
for (idx = 0 ; idx < total ; idx++) {
- VariantData *v_data = NULL;
+ stream_variant_t *v_data = NULL;
v_data = g_list_nth_data(player->adaptive_info.var_list, idx);
if (v_data) {
return ret;
}
-int _mmplayer_set_max_adaptive_variant_limit(MMHandleType hplayer, int bandwidth, int width, int height)
+int
+_mmplayer_set_max_adaptive_variant_limit(MMHandleType hplayer, int bandwidth, int width, int height)
{
int ret = MM_ERROR_NONE;
- mm_player_t* player = (mm_player_t*) hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
}
-int _mmplayer_get_max_adaptive_variant_limit(MMHandleType hplayer, int *bandwidth, int *width, int *height)
+int
+_mmplayer_get_max_adaptive_variant_limit(MMHandleType hplayer, int *bandwidth, int *width, int *height)
{
int ret = MM_ERROR_NONE;
- mm_player_t* player = (mm_player_t*) hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
return ret;
}
-int _mmplayer_set_streaming_buffering_time(MMHandleType hplayer, int buffer_ms, int rebuffer_ms)
-{
- int ret = MM_ERROR_NONE;
- mm_player_t* player = (mm_player_t*) hplayer;
-
- MMPLAYER_FENTER();
- MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
-
- if (MMPLAYER_CURRENT_STATE(player) != MM_PLAYER_STATE_NULL)
- LOGW("buffer_ms will not be applied.");
-
-
- LOGD("set buffering time %d ms / %d ms", buffer_ms, rebuffer_ms);
-
- if (player->streamer == NULL) {
- player->streamer = __mm_player_streaming_create();
- __mm_player_streaming_initialize(player->streamer);
- }
-
- if (buffer_ms >= 0)
- player->streamer->buffering_req.prebuffer_time = buffer_ms;
-
- if (rebuffer_ms >= 0)
- player->streamer->buffering_req.rebuffer_time = rebuffer_ms;
-
- MMPLAYER_FLEAVE();
- return ret;
-
-}
-
-int _mmplayer_get_streaming_buffering_time(MMHandleType hplayer, int *buffer_ms, int *rebuffer_ms)
+int
+_mmplayer_get_streaming_buffering_time(MMHandleType hplayer, int *prebuffer_ms, int *rebuffer_ms)
{
int ret = MM_ERROR_NONE;
- mm_player_t* player = (mm_player_t*) hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
MMPLAYER_FENTER();
- MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
- MMPLAYER_RETURN_VAL_IF_FAIL(buffer_ms && rebuffer_ms, MM_ERROR_COMMON_INVALID_ARGUMENT);
+ MMPLAYER_RETURN_VAL_IF_FAIL(player && player->streamer, MM_ERROR_PLAYER_NOT_INITIALIZED);
+ MMPLAYER_RETURN_VAL_IF_FAIL(prebuffer_ms && rebuffer_ms, MM_ERROR_COMMON_INVALID_ARGUMENT);
+ MMPLAYER_RETURN_VAL_IF_FAIL(MMPLAYER_IS_STREAMING(player), MM_ERROR_PLAYER_NO_OP);
- if (player->streamer == NULL) {
- player->streamer = __mm_player_streaming_create();
- __mm_player_streaming_initialize(player->streamer);
- }
+ *prebuffer_ms = player->streamer->buffering_req.prebuffer_time;
- *buffer_ms = player->streamer->buffering_req.prebuffer_time;
- *rebuffer_ms = player->streamer->buffering_req.rebuffer_time;
+ if (player->streamer->buffering_req.rebuffer_time > MIN_BUFFERING_TIME)
+ *rebuffer_ms = player->streamer->buffering_req.rebuffer_time;
+ else /* live case */
+ *rebuffer_ms = DEFAULT_LIVE_REBUFFER_TIME;
- LOGD("buffering time %d ms / %d ms", *buffer_ms, *rebuffer_ms);
+ LOGD("buffering time %d ms / %d ms", *prebuffer_ms, *rebuffer_ms);
MMPLAYER_FLEAVE();
return ret;
}
-int _mmplayer_set_codec_type(MMHandleType hplayer, MMPlayerStreamType stream_type, MMPlayerVideoCodecType codec_type)
+int
+_mmplayer_set_codec_type(MMHandleType hplayer, mmplayer_stream_type_e stream_type, mmplayer_codec_type_e codec_type)
{
#define IDX_FIRST_SW_CODEC 0
- mm_player_t* player = (mm_player_t*) hplayer;
- const char* attr_name = (stream_type == MM_PLAYER_STREAM_TYPE_AUDIO) ? (MM_PLAYER_AUDIO_CODEC_TYPE) : (MM_PLAYER_VIDEO_CODEC_TYPE);
- MMHandleType attrs = 0;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
+ int default_codec_type = MM_PLAYER_CODEC_TYPE_DEFAULT;
+ const char *attr_name = NULL;
+ const char *default_type = NULL;
+ const char *element_hw = NULL;
+ const char *element_sw = NULL;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
- LOGD("ini setting : [a][h:%s][s:%s] / [v][h:%s][s:%s]",
- player->ini.audiocodec_element_hw, player->ini.audiocodec_element_sw[IDX_FIRST_SW_CODEC],
- player->ini.videocodec_element_hw, player->ini.videocodec_element_sw[IDX_FIRST_SW_CODEC]);
+ LOGD("stream type: %d, codec_type: %d", stream_type, codec_type);
+ /* FIXME: player need to know whether the decoder exist or not about required codec type since 6.0*/
switch (stream_type) {
case MM_PLAYER_STREAM_TYPE_AUDIO:
- /* to support audio codec selection, codec info have to be added in ini file as below.
- audio codec element hw = xxxx
- audio codec element sw = avdec */
- if (((codec_type == MM_PLAYER_CODEC_TYPE_HW) &&
- (!strcmp(player->ini.audiocodec_element_hw, ""))) ||
- ((codec_type == MM_PLAYER_CODEC_TYPE_SW) &&
- (!strcmp(player->ini.audiocodec_element_sw[IDX_FIRST_SW_CODEC], "")))) {
- LOGE("There is no audio codec info for codec_type %d", codec_type);
- return MM_ERROR_PLAYER_NO_OP;
- }
- break;
+ attr_name = MM_PLAYER_AUDIO_CODEC_TYPE;
+ default_type = player->ini.audiocodec_default_type;
+ element_hw = player->ini.audiocodec_element_hw;
+ element_sw = player->ini.audiocodec_element_sw[IDX_FIRST_SW_CODEC];
+ break;
case MM_PLAYER_STREAM_TYPE_VIDEO:
- /* to support video codec selection, codec info have to be added in ini file as below.
- video codec element hw = omx
- video codec element sw = avdec */
- if (((codec_type == MM_PLAYER_CODEC_TYPE_HW) &&
- (!strcmp(player->ini.videocodec_element_hw, ""))) ||
- ((codec_type == MM_PLAYER_CODEC_TYPE_SW) &&
- (!strcmp(player->ini.videocodec_element_sw[IDX_FIRST_SW_CODEC], "")))) {
- LOGE("There is no video codec info for codec_type %d", codec_type);
- return MM_ERROR_PLAYER_NO_OP;
- }
- break;
+ attr_name = MM_PLAYER_VIDEO_CODEC_TYPE;
+ default_type = player->ini.videocodec_default_type;
+ element_hw = player->ini.videocodec_element_hw;
+ element_sw = player->ini.videocodec_element_sw[IDX_FIRST_SW_CODEC];
+ break;
default:
LOGE("Invalid stream type %s", MMPLAYER_STREAM_TYPE_GET_NAME(stream_type));
return MM_ERROR_COMMON_INVALID_ARGUMENT;
- break;
+ break;
}
- LOGD("update %s codec_type to %d", attr_name, codec_type);
+ LOGD("default setting: [%s][%s][h:%s][s:%s]", attr_name, default_type, element_hw, element_sw);
- attrs = MMPLAYER_GET_ATTRS(player);
- mm_attrs_set_int_by_name(attrs, attr_name, codec_type);
+ if (!strcmp(default_type, "sw"))
+ default_codec_type = MM_PLAYER_CODEC_TYPE_SW;
+ else
+ default_codec_type = MM_PLAYER_CODEC_TYPE_HW;
+
+ if (codec_type == MM_PLAYER_CODEC_TYPE_DEFAULT)
+ codec_type = default_codec_type;
+
+ /* to support codec selection, codec info have to be added in ini file.
+ in case of hw codec is selected, filter elements should be applied
+ depending on the hw capabilities. */
+ if (codec_type != default_codec_type) {
+ if (((codec_type == MM_PLAYER_CODEC_TYPE_HW) && (!strcmp(element_hw, ""))) ||
+ ((codec_type == MM_PLAYER_CODEC_TYPE_SW) && (!strcmp(element_sw, "")))) {
+ LOGE("There is no codec for type %d", codec_type);
+ return MM_ERROR_PLAYER_NO_OP;
+ }
- if (mm_attrs_commit_all(player->attrs)) {
- LOGE("failed to commit codec_type attributes");
- return MM_ERROR_PLAYER_INTERNAL;
+ LOGD("sorting is required");
+ if (stream_type == MM_PLAYER_STREAM_TYPE_AUDIO)
+ player->need_audio_dec_sorting = TRUE;
+ else
+ player->need_video_dec_sorting = TRUE;
}
+ LOGD("update %s codec_type to %d", attr_name, codec_type);
+ mm_player_set_attribute(hplayer, NULL, attr_name, codec_type, NULL);
+
MMPLAYER_FLEAVE();
return MM_ERROR_NONE;
}
int
_mmplayer_set_replaygain_enabled(MMHandleType hplayer, bool enabled)
{
- mm_player_t* player = (mm_player_t*) hplayer;
- GstElement* rg_vol_element = NULL;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
+ GstElement *rg_vol_element = NULL;
MMPLAYER_FENTER();
/* just hold rgvolume enable value if pipeline is not ready */
if (!player->pipeline || !player->pipeline->audiobin) {
- LOGD("pipeline is not ready. holding rgvolume enable value\n");
+ LOGD("pipeline is not ready. holding rgvolume enable value");
return MM_ERROR_NONE;
}
int
_mmplayer_is_replaygain_enabled(MMHandleType hplayer, bool *enabled)
{
- mm_player_t* player = (mm_player_t*) hplayer;
- GstElement* rg_vol_element = NULL;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
+ GstElement *rg_vol_element = NULL;
gboolean enable = FALSE;
MMPLAYER_FENTER();
/* just hold enable_rg value if pipeline is not ready */
if (!player->pipeline || !player->pipeline->audiobin) {
- LOGD("pipeline is not ready. holding rgvolume value (%d)\n", player->sound.rg_enable);
+ LOGD("pipeline is not ready. holding rgvolume value (%d)", player->sound.rg_enable);
*enabled = player->sound.rg_enable;
return MM_ERROR_NONE;
}
}
g_object_get(rg_vol_element, "enable-rgvolume", &enable, NULL);
- *enabled = enable;
+ *enabled = (bool)enable;
MMPLAYER_FLEAVE();
int
_mmplayer_set_video_roi_area(MMHandleType hplayer, double scale_x, double scale_y, double scale_width, double scale_height)
{
- mm_player_t* player = (mm_player_t*) hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
MMHandleType attrs = 0;
- void *handle = NULL;
+ int handle = 0;
int ret = MM_ERROR_NONE;
MMPLAYER_FENTER();
attrs = MMPLAYER_GET_ATTRS(player);
MMPLAYER_RETURN_VAL_IF_FAIL(attrs, MM_ERROR_PLAYER_INTERNAL);
- mm_attrs_get_data_by_name(attrs, "display_overlay", &handle);
+ mm_attrs_get_int_by_name(attrs, "display_overlay", &handle);
if (!handle) {
LOGE("Display handle is NULL, after setting window handle, set video roi area");
return MM_ERROR_PLAYER_INTERNAL;
player->video_roi.scale_height = scale_height;
/* check video sinkbin is created */
- if (__mmplayer_video_param_check_video_sink_bin(player) != MM_ERROR_NONE)
+ if (!_mmplayer_is_videosink_ready(player, MM_DISPLAY_SURFACE_NUM))
return MM_ERROR_NONE;
if (!gst_video_overlay_set_video_roi_area(
int
_mmplayer_get_video_roi_area(MMHandleType hplayer, double *scale_x, double *scale_y, double *scale_width, double *scale_height)
{
- mm_player_t* player = (mm_player_t*) hplayer;
+ mmplayer_t *player = (mmplayer_t *)hplayer;
int ret = MM_ERROR_NONE;
MMPLAYER_FENTER();
return ret;
}
+int
+_mmplayer_set_client_pid(MMHandleType hplayer, int pid)
+{
+ mmplayer_t *player = (mmplayer_t *)hplayer;
+
+ MMPLAYER_FENTER();
+
+ MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
+
+ player->client_pid = pid;
+
+ LOGD("client pid[%d] %p", pid, player);
+
+ MMPLAYER_FLEAVE();
+
+ return MM_ERROR_NONE;
+}
+
+int
+_mmplayer_is_audio_control_available(MMHandleType hplayer, mmplayer_audio_control_opt_e opt, bool *available)
+{
+ mmplayer_t *player = (mmplayer_t *)hplayer;
+ mmplayer_codec_type_e codec_type = MM_PLAYER_CODEC_TYPE_DEFAULT;
+ enum audio_element_id elem_id = MMPLAYER_A_NUM;
+
+ MMPLAYER_FENTER();
+
+ MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
+ MMPLAYER_RETURN_VAL_IF_FAIL(available, MM_ERROR_INVALID_ARGUMENT);
+
+ *available = true;
+ mm_attrs_get_int_by_name(player->attrs, MM_PLAYER_AUDIO_CODEC_TYPE, (int *)&codec_type);
+
+ LOGD("current state %d, codec_type %d", MMPLAYER_CURRENT_STATE(player), codec_type);
+
+ if (codec_type == MM_PLAYER_CODEC_TYPE_SW)
+ return MM_ERROR_NONE;
+
+ /* in case of audio codec default type is HW */
+ switch(opt) {
+ case MM_PLAYER_AUDIO_CONTROL_OPT_EFFECT:
+ if (player->ini.support_audio_effect)
+ return MM_ERROR_NONE;
+ elem_id = MMPLAYER_A_FILTER;
+ break;
+ case MM_PLAYER_AUDIO_CONTROL_OPT_REPLAYGAIN:
+ if (player->ini.support_replaygain_control)
+ return MM_ERROR_NONE;
+ elem_id = MMPLAYER_A_RGVOL;
+ break;
+ case MM_PLAYER_AUDIO_CONTROL_OPT_PITCH:
+ if (player->ini.support_pitch_control)
+ return MM_ERROR_NONE;
+ elem_id = MMPLAYER_A_PITCH;
+ break;
+ case MM_PLAYER_AUDIO_CONTROL_OPT_PCM_EXPORTING:
+ if (player->ini.support_audio_effect)
+ return MM_ERROR_NONE;
+ break;
+ /* default case handling is not required */
+ }
+
+ if (MMPLAYER_CURRENT_STATE(player) < MM_PLAYER_STATE_READY) {
+ LOGW("audio control option [%d] is not available", opt);
+ *available = false;
+ } else {
+ /* setting pcm exporting option is allowed before READY state */
+ if (opt == MM_PLAYER_AUDIO_CONTROL_OPT_PCM_EXPORTING)
+ return MM_ERROR_PLAYER_INVALID_STATE;
+
+ /* check whether the audio filter exist or not after READY state,
+ because the sw codec could be added during auto-plugging in some cases */
+ if (!player->pipeline ||
+ !player->pipeline->audiobin ||
+ !player->pipeline->audiobin[elem_id].gst) {
+ LOGW("there is no audio elem [%d]", elem_id);
+ *available = false;
+ }
+ }
+
+ LOGD("audio control opt %d, available %d", opt, *available);
+
+ MMPLAYER_FLEAVE();
+
+ return MM_ERROR_NONE;
+}
+
static gboolean
-__mmplayer_update_duration_attrs(mm_player_t *player, MMHandleType attrs)
+__mmplayer_update_duration_value(mmplayer_t *player)
{
gboolean ret = FALSE;
gint64 dur_nsec = 0;
}
/* update streaming service type */
- player->streaming_type = __mmplayer_get_stream_service_type(player);
+ player->streaming_type = _mmplayer_get_stream_service_type(player);
/* check duration is OK */
- if (dur_nsec == 0 && !MMPLAYER_IS_LIVE_STREAMING(player)) {
+ if (dur_nsec == 0 && !MMPLAYER_IS_LIVE_STREAMING(player))
/* FIXIT : find another way to get duration here. */
LOGW("finally it's failed to get duration from pipeline. progressbar will not work correctely!");
- }
return ret;
}
static gboolean
-__mmplayer_update_audio_attrs(mm_player_t *player, MMHandleType attrs)
+__mmplayer_update_audio_attrs(mmplayer_t *player, MMHandleType attrs)
{
/* update audio params
NOTE : We need original audio params and it can be only obtained from src pad of audio
decoder. Below code only valid when we are not using 'resampler' just before
'audioconverter'. */
GstCaps *caps_a = NULL;
- GstPad* pad = NULL;
+ GstPad *pad = NULL;
gint samplerate = 0, channels = 0;
- GstStructure* p = NULL;
+ GstStructure *p = NULL;
+ GstElement *aconv = NULL;
LOGD("try to update audio attrs");
MMPLAYER_RETURN_VAL_IF_FAIL(player->pipeline->audiobin, FALSE);
- MMPLAYER_RETURN_VAL_IF_FAIL(player->pipeline->audiobin[MMPLAYER_A_SINK].gst, FALSE);
- pad = gst_element_get_static_pad(
- player->pipeline->audiobin[MMPLAYER_A_CONV].gst, "sink");
+ if (player->pipeline->audiobin[MMPLAYER_A_CONV].gst) {
+ aconv = player->pipeline->audiobin[MMPLAYER_A_CONV].gst;
+ } else if (player->pipeline->audiobin[MMPLAYER_A_EXTRACT_CONV].gst) {
+ aconv = player->pipeline->audiobin[MMPLAYER_A_EXTRACT_CONV].gst;
+ } else {
+ LOGE("there is no audio converter");
+ return FALSE;
+ }
+
+ pad = gst_element_get_static_pad(aconv, "sink");
if (!pad) {
- LOGW("failed to get pad from audiosink");
+ LOGW("failed to get pad from audio converter");
return FALSE;
}
caps_a = gst_pad_get_current_caps(pad);
-
if (!caps_a) {
LOGW("not ready to get audio caps");
gst_object_unref(pad);
mm_attrs_get_int_by_name(attrs, "content_audio_samplerate", &samplerate);
gst_structure_get_int(p, "rate", &samplerate);
- mm_attrs_set_int_by_name(attrs, "content_audio_samplerate", samplerate);
-
gst_structure_get_int(p, "channels", &channels);
- mm_attrs_set_int_by_name(attrs, "content_audio_channels", channels);
+
+ mm_player_set_attribute((MMHandleType)player, NULL,
+ "content_audio_samplerate", samplerate,
+ "content_audio_channels", channels, NULL);
SECURE_LOGD("samplerate : %d channels : %d", samplerate, channels);
}
static gboolean
-__mmplayer_update_video_attrs(mm_player_t *player, MMHandleType attrs)
+__mmplayer_update_video_attrs(mmplayer_t *player, MMHandleType attrs)
{
LOGD("try to update video attrs");
GstCaps *caps_v = NULL;
- GstPad* pad = NULL;
+ GstPad *pad = NULL;
gint tmpNu, tmpDe;
gint width, height;
- GstStructure* p = NULL;
+ GstStructure *p = NULL;
MMPLAYER_RETURN_VAL_IF_FAIL(player->pipeline->videobin, FALSE);
MMPLAYER_RETURN_VAL_IF_FAIL(player->pipeline->videobin[MMPLAYER_V_SINK].gst, FALSE);
p = gst_caps_get_structure(caps_v, 0);
gst_structure_get_int(p, "width", &width);
- mm_attrs_set_int_by_name(attrs, "content_video_width", width);
-
gst_structure_get_int(p, "height", &height);
- mm_attrs_set_int_by_name(attrs, "content_video_height", height);
+
+ mm_player_set_attribute((MMHandleType)player, NULL,
+ MM_PLAYER_VIDEO_WIDTH, width, MM_PLAYER_VIDEO_HEIGHT, height, NULL);
gst_structure_get_fraction(p, "framerate", &tmpNu, &tmpDe);
gst_object_unref(pad);
if (tmpDe > 0) {
- mm_attrs_set_int_by_name(attrs, "content_video_fps", tmpNu / tmpDe);
+ mm_player_set_attribute((MMHandleType)player, NULL,
+ MM_PLAYER_VIDEO_FPS, (tmpNu/tmpDe), NULL);
SECURE_LOGD("fps : %d", tmpNu / tmpDe);
}
}
static gboolean
-__mmplayer_update_bitrate_attrs(mm_player_t *player, MMHandleType attrs)
+__mmplayer_update_bitrate_attrs(mmplayer_t *player, MMHandleType attrs)
{
gboolean ret = FALSE;
guint64 data_size = 0;
msec_dur = GST_TIME_AS_MSECONDS(player->duration);
if (msec_dur > 0) {
bitrate = data_size * 8 * 1000 / msec_dur;
- SECURE_LOGD("file size : %u, video bitrate = %llu", data_size, bitrate);
- mm_attrs_set_int_by_name(attrs, "content_video_bitrate", bitrate);
-
+ SECURE_LOGD("file size : %"G_GUINT64_FORMAT
+ ", video bitrate = %"G_GUINT64_FORMAT, data_size, bitrate);
+ mm_player_set_attribute((MMHandleType)player, NULL,
+ MM_PLAYER_VIDEO_BITRATE, (int)bitrate, NULL);
ret = TRUE;
} else {
LOGD("player duration is less than 0");
if (MMPLAYER_IS_RTSP_STREAMING(player)) {
if (player->total_bitrate) {
- mm_attrs_set_int_by_name(attrs, "content_video_bitrate", player->total_bitrate);
+ mm_player_set_attribute((MMHandleType)player, NULL,
+ MM_PLAYER_VIDEO_BITRATE, player->total_bitrate, NULL);
ret = TRUE;
}
}
return ret;
}
+
static void
-__mmplayer_copy_uri_and_set_type(MMPlayerParseProfile* data, const char *uri, int uri_type)
+__mmplayer_copy_uri_and_set_type(mmplayer_parse_profile_t *data, const char *uri, int uri_type)
{
strncpy(data->uri, uri, MM_MAX_URL_LEN - 1);
data->uri_type = uri_type;
}
+
static int
-__mmplayer_set_mem_uri(MMPlayerParseProfile* data, char *path, void *param)
+__mmplayer_set_mem_uri(mmplayer_parse_profile_t *data, char *path, void *param)
{
int ret = MM_ERROR_PLAYER_INVALID_URI;
int mem_size = 0;
}
}
- LOGD("ext: %s, mem_size: %d, mmap(param): %p\n", ext, mem_size, param);
+ LOGD("ext: %s, mem_size: %d, mmap(param): %p", ext, mem_size, param);
if (mem_size && param) {
if (data->input_mem.buf)
}
static int
-__mmplayer_set_file_uri(MMPlayerParseProfile* data, const char *uri)
+__mmplayer_set_file_uri(mmplayer_parse_profile_t *data, const char *uri)
{
gchar *location = NULL;
GError *err = NULL;
(err != NULL) ? err->message : "unknown error");
if (err)
g_error_free(err);
- if (location)
- g_free(location);
+
+ MMPLAYER_FREEIF(location);
data->uri_type = MM_PLAYER_URI_TYPE_NONE;
return MM_ERROR_PLAYER_INVALID_URI;
path = (location != NULL) ? (location) : ((char *)uri);
- ret = util_exist_file_path(path);
+ ret = _mmplayer_exist_file_path(path);
/* if no protocol prefix exist. check file existence and then give file:// as it's prefix */
if (ret == MM_ERROR_NONE) {
- g_snprintf(data->uri, MM_MAX_URL_LEN, "file://%s", path);
- if (util_is_sdp_file(path)) {
- LOGD("uri is actually a file but it's sdp file. giving it to rtspsrc\n");
+ if (_mmplayer_is_sdp_file(path)) {
+ LOGD("uri is actually a file but it's sdp file. giving it to rtspsrc");
+ g_snprintf(data->uri, MM_MAX_URL_LEN, "rtsp-sdp://%s", path);
data->uri_type = MM_PLAYER_URI_TYPE_URL_RTSP;
} else {
+ g_snprintf(data->uri, MM_MAX_URL_LEN, "file://%s", path);
data->uri_type = MM_PLAYER_URI_TYPE_FILE;
}
} else if (ret == MM_ERROR_PLAYER_PERMISSION_DENIED) {
data->uri_type = MM_PLAYER_URI_TYPE_NO_PERMISSION;
} else {
- LOGE("invalid uri, could not play..\n");
+ LOGE("invalid uri, could not play..");
data->uri_type = MM_PLAYER_URI_TYPE_NONE;
}
- if (location)
- g_free(location);
+ MMPLAYER_FREEIF(location);
return ret;
}
-static MMPlayerVideoStreamDataType*
+static mmplayer_video_decoded_data_info_t *
__mmplayer_create_stream_from_pad(GstPad *pad)
{
GstCaps *caps = NULL;
GstStructure *structure = NULL;
unsigned int fourcc = 0;
const gchar *string_format = NULL;
- MMPlayerVideoStreamDataType *stream = NULL;
+ mmplayer_video_decoded_data_info_t *stream = NULL;
gint width, height;
MMPixelFormatType format;
+ GstVideoInfo info;
caps = gst_pad_get_current_caps(pad);
if (!caps) {
return NULL;
}
- /* MMPLAYER_LOG_GST_CAPS_TYPE(caps); */
+#ifdef __DEBUG__
+ MMPLAYER_LOG_GST_CAPS_TYPE(caps);
+#endif
structure = gst_caps_get_structure(caps, 0);
gst_structure_get_int(structure, "width", &width);
gst_structure_get_int(structure, "height", &height);
string_format = gst_structure_get_string(structure, "format");
+
if (string_format)
fourcc = _mmplayer_convert_fourcc_string_to_value(string_format);
- format = util_get_pixtype(fourcc);
+ format = _mmplayer_get_pixtype(fourcc);
+ gst_video_info_from_caps(&info, caps);
gst_caps_unref(caps);
/* moved here */
return NULL;
}
- stream = (MMPlayerVideoStreamDataType *)g_malloc0(sizeof(MMPlayerVideoStreamDataType));
+ stream = (mmplayer_video_decoded_data_info_t *)g_try_malloc0(sizeof(mmplayer_video_decoded_data_info_t));
if (!stream) {
LOGE("failed to alloc mem for video data");
return NULL;
stream->width = width;
stream->height = height;
stream->format = format;
+ stream->plane_num = GST_VIDEO_INFO_N_PLANES(&info);
return stream;
}
static void
-__mmplayer_zerocopy_set_stride_elevation_bo(MMPlayerVideoStreamDataType *stream, GstMemory *mem)
+__mmplayer_zerocopy_set_stride_elevation_bo(mmplayer_video_decoded_data_info_t *stream, GstMemory *mem)
{
unsigned int pitch = 0;
+ unsigned int size = 0;
int index = 0;
tbm_surface_h surface = gst_tizen_memory_get_surface(mem);
+ tbm_bo bo = NULL;
for (index = 0; index < gst_tizen_memory_get_num_bos(mem); index++) {
- tbm_surface_internal_get_plane_data(surface, index, NULL, NULL, &pitch);
- stream->bo[index] = tbm_bo_ref(gst_tizen_memory_get_bos(mem, index));
+ bo = gst_tizen_memory_get_bos(mem, index);
+ if (bo)
+ stream->bo[index] = tbm_bo_ref(bo);
+ else
+ LOGE("failed to get bo for index %d", index);
+ }
+
+ for (index = 0; index < stream->plane_num; index++) {
+ tbm_surface_internal_get_plane_data(surface, index, &size, NULL, &pitch);
stream->stride[index] = pitch;
- stream->elevation[index] = stream->height;
+ if (pitch)
+ stream->elevation[index] = size / pitch;
+ else
+ stream->elevation[index] = stream->height;
}
}
static gboolean
-__mmplayer_swcodec_set_stride_elevation(MMPlayerVideoStreamDataType *stream)
+__mmplayer_swcodec_set_stride_elevation(mmplayer_video_decoded_data_info_t *stream)
{
if (stream->format == MM_PIXEL_FORMAT_I420) {
int ret = TBM_SURFACE_ERROR_NONE;
}
static gboolean
-__mmplayer_swcodec_set_bo(mm_player_t *player, MMPlayerVideoStreamDataType *stream, GstMemory *mem)
+__mmplayer_swcodec_set_bo(mmplayer_t *player, mmplayer_video_decoded_data_info_t *stream, GstMemory *mem)
{
tbm_bo_handle thandle;
gboolean is_mapped;
}
static void
-__mmplayer_set_pause_state(mm_player_t *player)
+__mmplayer_set_pause_state(mmplayer_t *player)
{
if (player->sent_bos)
return;
return;
/* it's first time to update all content attrs. */
- __mmplayer_update_content_attrs(player, ATTR_ALL);
+ _mmplayer_update_content_attrs(player, ATTR_ALL);
}
static void
-__mmplayer_set_playing_state(mm_player_t *player)
+__mmplayer_set_playing_state(mmplayer_t *player)
{
gchar *audio_codec = NULL;
* c-api since c-api doesn't use _start() anymore. It may not work propery with
* legacy mmfw-player api
*/
- __mmplayer_update_content_attrs(player, ATTR_MISSING_ONLY);
+ _mmplayer_update_content_attrs(player, ATTR_MISSING_ONLY);
if ((player->cmd == MMPLAYER_COMMAND_START)
|| (player->cmd == MMPLAYER_COMMAND_RESUME)) {
else if (g_strrstr(player->type, "audio/x-amr"))
audio_codec = "AMR";
else if (g_strrstr(player->type, "audio/mpeg")
- && !g_strrstr(player->type, "mpegversion= (int)1"))
+ && !g_strrstr(player->type, "mpegversion=(int)1"))
audio_codec = "AAC";
else
audio_codec = "unknown";
- mm_attrs_set_string_by_name(player->attrs, "content_audio_codec", audio_codec);
+ if (mm_player_set_attribute((MMHandleType)player, NULL,
+ "content_audio_codec", audio_codec, strlen(audio_codec), NULL) != MM_ERROR_NONE)
+ LOGE("failed to set attribute");
- if (mm_attrs_commit_all(player->attrs))
- LOGE("failed to update attributes\n");
-
- LOGD("set audio codec type with caps\n");
+ LOGD("set audio codec type with caps");
}
return;
-}
\ No newline at end of file
+}
projects / platform / core / multimedia / libmm-player.git / blobdiff