[0.6.182] apply pcm extraction option

- Apply pcm extraction option to expose pcm api to public
  : sync with clock, deinterleave
- extract pcm with original pcm format if there is no user requirement
- renaming

Change-Id: I29ba805d8c0cd12e47ff8aef7f5c4b5464e56f12

diff --git a/packaging/libmm-player.spec b/packaging/libmm-player.spec
index fc928cf..a2d48f3 100644 (file)
--- a/packaging/libmm-player.spec
+++ b/packaging/libmm-player.spec
@@ -1,6 +1,6 @@
 Name:       libmm-player
 Summary:    Multimedia Framework Player Library
-Version:    0.6.181
+Version:    0.6.182
 Release:    0
 Group:      Multimedia/Libraries
 License:    Apache-2.0

diff --git a/src/include/mm_player.h b/src/include/mm_player.h
index 50bef0e..3d0e34e 100644 (file)
--- a/src/include/mm_player.h
+++ b/src/include/mm_player.h
@@ -382,6 +382,13 @@ typedef enum {
        MM_PLAYER_CODEC_TYPE_SW,          /**< SW codec can only be selected */
 } mmplayer_video_codec_type_e;
 
+typedef enum {
+       MM_PLAYER_AUDIO_EXTRACT_DEFAULT                  = 0x00,   /**< Sync with the playback clock and multichannel audio stream */
+       MM_PLAYER_AUDIO_EXTRACT_NO_SYNC_WITH_CLOCK       = 0x01,   /**< No sync with the playback clock */
+       MM_PLAYER_AUDIO_EXTRACT_DEINTERLEAVE             = 0x02,   /**< Splits one interleaved multichannel audio stream into many mono audio streams */
+       MM_PLAYER_AUDIO_EXTRACT_NO_SYNC_AND_DEINTERLEAVE = MM_PLAYER_AUDIO_EXTRACT_NO_SYNC_WITH_CLOCK | MM_PLAYER_AUDIO_EXTRACT_DEINTERLEAVE,
+} mmplayer_audio_extract_opt_e;
+
 /**
  * Attribute validity structure
  */

diff --git a/src/include/mm_player_internal.h b/src/include/mm_player_internal.h
index 3497a18..8f68a98 100644 (file)
--- a/src/include/mm_player_internal.h
+++ b/src/include/mm_player_internal.h
@@ -61,7 +61,7 @@ typedef struct {
 } mmplayer_audio_decoded_data_info_t;
 
 /**
- * Video stream callback function type.
+ * Video decoded callback function type.
  *
  * @param      stream          [in]    Reference pointer to video frame data
  * @param      stream_size     [in]    Size of video frame data
@@ -72,7 +72,7 @@ typedef struct {
  *
  * @return     This callback function have to return MM_ERROR_NONE.
  */
-typedef bool (*mm_player_video_stream_callback)(void *stream, void *user_param);
+typedef bool (*mm_player_video_decoded_callback)(void *stream, void *user_param);
 
 /**
  * Audio stream callback function type.
@@ -106,7 +106,7 @@ typedef bool (*mm_player_video_frame_render_error_callback)(void *error_id, void
  *
  * @return     This callback function have to return MM_ERROR_NONE.
  */
-typedef bool (*mm_player_audio_stream_callback)(mmplayer_audio_decoded_data_info_t *stream, void *user_param);
+typedef bool (*mm_player_audio_decoded_callback)(mmplayer_audio_decoded_data_info_t *stream, void *user_param);
 /**
  * This function is to set play speed for playback.
  *
@@ -135,23 +135,23 @@ int mm_player_set_play_speed(MMHandleType player, float rate, bool streaming);
  * @remark
  * @since
  */
-int mm_player_set_video_stream_callback(MMHandleType player, mm_player_video_stream_callback callback, void *user_param);
+int mm_player_set_video_decoded_callback(MMHandleType player, mm_player_video_decoded_callback callback, void *user_param);
 
 /**
  * This function set callback function for receiving audio stream from player.
  *
  * @param      player          [in]    Handle of player.
- * @param      sync            [in]    sync Sync on the clock.
- * @param      callback                [in]    audio stream callback function.
+ * @param      opt             [in]    audio extract option.
+ * @param      callback        [in]    audio stream callback function.
  * @param      user_param      [in]    User parameter.
  *
  * @return     This function returns zero on success, or negative value with error
  *                     code.
  * @remark
- * @see                mm_player_audio_stream_callback
+ * @see                mm_player_audio_decoded_callback
  * @since
  */
-int mm_player_set_audio_stream_callback(MMHandleType player, bool sync, mm_player_audio_stream_callback callback, void *user_param);
+int mm_player_set_audio_decoded_callback(MMHandleType player, mmplayer_audio_extract_opt_e opt, mm_player_audio_decoded_callback callback, void *user_param);
 
 /**
  * This function is to capture video frame.

diff --git a/src/include/mm_player_priv.h b/src/include/mm_player_priv.h
index aa44c5d..2182cb3 100644 (file)
--- a/src/include/mm_player_priv.h
+++ b/src/include/mm_player_priv.h
@@ -414,7 +414,7 @@ typedef struct {
        bool rich_audio;
        bool video_zc; // video zero-copy
        bool subtitle_off;
-       bool media_packet_video_stream;
+       bool video_export;
 } mmplayer_setting_mode_t; /* FIXME: renaming */
 
 typedef struct {
@@ -463,6 +463,7 @@ typedef struct {
        void *pcm_data;
        int data_size;
        int buff_size;
+       media_format_mimetype_e pcm_format;
 } mmplayer_audio_stream_buff_t;
 
 /**
@@ -591,8 +592,8 @@ typedef struct {
        void *audio_stream_changed_cb_user_param;
 
        /* video stream callback */
-       mm_player_video_stream_callback video_stream_cb;
-       void *video_stream_cb_user_param;
+       mm_player_video_decoded_callback video_decoded_cb;
+       void *video_decoded_cb_user_param;
        GCond video_bo_cond;
        GMutex video_bo_mutex;
        GList *video_bo_list; /* mmplayer_video_bo_info_t, bo list for decoded video data by sw codec */
@@ -600,10 +601,10 @@ typedef struct {
        bool video_stream_prerolled;
 
        /* audio stream callback */
-       mm_player_audio_stream_callback audio_stream_render_cb;
-       void *audio_stream_cb_user_param;
-       bool audio_stream_sink_sync;
+       mm_player_audio_decoded_callback audio_decoded_cb;
+       void *audio_decoded_cb_user_param;
        GList *audio_stream_buff_list; /* mmplayer_audio_stream_buff_t, buff list of extract pcm data */
+       mmplayer_audio_extract_opt_e audio_extract_opt;
 
        /* video capture callback*/
        gulong video_capture_cb_probe_id;
@@ -841,7 +842,7 @@ int _mmplayer_set_playspeed(MMHandleType hplayer, float rate, bool streaming);
 int _mmplayer_set_message_callback(MMHandleType hplayer, MMMessageCallback callback, void *user_param);
 int _mmplayer_set_videostream_changed_cb(MMHandleType hplayer, mm_player_stream_changed_callback callback, void *user_param);
 int _mmplayer_set_audiostream_changed_cb(MMHandleType hplayer, mm_player_stream_changed_callback callback, void *user_param);
-int _mmplayer_set_videostream_cb(MMHandleType hplayer, mm_player_video_stream_callback callback, void *user_param);
+int _mmplayer_set_video_decoded_cb(MMHandleType hplayer, mm_player_video_decoded_callback callback, void *user_param);
 int _mmplayer_set_subtitle_silent(MMHandleType hplayer, int silent);
 int _mmplayer_get_subtitle_silent(MMHandleType hplayer, int *silent);
 int _mmplayer_set_external_subtitle_path(MMHandleType hplayer, const char *filepath);
@@ -849,7 +850,7 @@ int _mmplayer_get_buffer_position(MMHandleType hplayer, int *start_pos, int *end
 int _mmplayer_update_video_param(mmplayer_t *player, char *param_name);
 int _mmplayer_change_videosink(MMHandleType handle, MMDisplaySurfaceType surface_type, void *display_overlay);
 int _mmplayer_audio_effect_custom_apply(mmplayer_t *player);
-int _mmplayer_set_audiostream_cb(MMHandleType hplayer, bool sync, mm_player_audio_stream_callback callback, void *user_param);
+int _mmplayer_set_audio_decoded_cb(MMHandleType hplayer, mmplayer_audio_extract_opt_e opt, mm_player_audio_decoded_callback callback, void *user_param);
 int _mmplayer_change_track_language(MMHandleType hplayer, mmplayer_track_type_e type, int index);
 int _mmplayer_sync_subtitle_pipeline(mmplayer_t *player);
 int _mmplayer_use_system_clock(MMHandleType hplayer);

diff --git a/src/include/mm_player_utils.h b/src/include/mm_player_utils.h
index 88946f1..be16503 100644 (file)
--- a/src/include/mm_player_utils.h
+++ b/src/include/mm_player_utils.h
@@ -300,6 +300,8 @@ const char *util_get_charset(const char *file_path);
 int util_get_pixtype(unsigned int fourcc);
 bool util_get_storage_info(const char *path, mmplayer_storage_info_t *storage_info);
 
+media_format_mimetype_e util_convert_audio_pcm_str_to_media_format_mime(const gchar *audio_pcm_str);
+
 #ifdef __cplusplus
        }
 #endif

diff --git a/src/mm_player.c b/src/mm_player.c
index feeeae9..bc9ac85 100644 (file)
--- a/src/mm_player.c
+++ b/src/mm_player.c
@@ -183,7 +183,7 @@ int mm_player_set_message_callback(MMHandleType player, MMMessageCallback callba
        return result;
 }
 
-int mm_player_set_audio_stream_callback(MMHandleType player, bool sync, mm_player_audio_stream_callback callback, void *user_param)
+int mm_player_set_audio_decoded_callback(MMHandleType player, mmplayer_audio_extract_opt_e opt, mm_player_audio_decoded_callback callback, void *user_param)
 {
        int result = MM_ERROR_NONE;
 
@@ -191,14 +191,14 @@ int mm_player_set_audio_stream_callback(MMHandleType player, bool sync, mm_playe
 
        MMPLAYER_CMD_LOCK(player);
 
-       result = _mmplayer_set_audiostream_cb(player, sync, callback, user_param);
+       result = _mmplayer_set_audio_decoded_cb(player, opt, callback, user_param);
 
        MMPLAYER_CMD_UNLOCK(player);
 
        return result;
 }
 
-int mm_player_set_video_stream_callback(MMHandleType player, mm_player_video_stream_callback callback, void *user_param)
+int mm_player_set_video_decoded_callback(MMHandleType player, mm_player_video_decoded_callback callback, void *user_param)
 {
        int result = MM_ERROR_NONE;
 
@@ -206,7 +206,7 @@ int mm_player_set_video_stream_callback(MMHandleType player, mm_player_video_str
 
        MMPLAYER_CMD_LOCK(player);
 
-       result = _mmplayer_set_videostream_cb(player, callback, user_param);
+       result = _mmplayer_set_video_decoded_cb(player, callback, user_param);
 
        MMPLAYER_CMD_UNLOCK(player);
 

diff --git a/src/mm_player_attrs.c b/src/mm_player_attrs.c
index 6df24d2..7831a18 100644 (file)
--- a/src/mm_player_attrs.c
+++ b/src/mm_player_attrs.c
@@ -229,8 +229,8 @@ __mmplayer_apply_attribute(MMHandleType handle, const char *attribute_name)
        }
 
        if (g_strrstr(attribute_name, MM_PLAYER_ENABLE_VIDEO_DECODED_CB)) {
-               if (!player->set_mode.media_packet_video_stream) {
-                       LOGE("there is no callback for media_packet");
+               if (!player->set_mode.video_export) {
+                       LOGE("there is no callback to export video");
                        return MM_ERROR_PLAYER_INTERNAL;
                }
                int enable = 0;
@@ -425,6 +425,15 @@ _mmplayer_construct_attribute(MMHandleType handle)
                        MMPLAYER_MAX_INT
                },
                {
+                       "content_audio_format",
+                       MM_ATTRS_TYPE_STRING,
+                       MM_ATTRS_FLAG_RW,
+                       (void *)NULL,
+                       MM_ATTRS_VALID_TYPE_NONE,
+                       0,
+                       0
+               },
+               {
                        "content_text_track_num",
                        MM_ATTRS_TYPE_INT,
                        MM_ATTRS_FLAG_RW,

diff --git a/src/mm_player_gst.c b/src/mm_player_gst.c
index 9c4451e..e13f96a 100644 (file)
--- a/src/mm_player_gst.c
+++ b/src/mm_player_gst.c
@@ -1264,11 +1264,11 @@ __mmplayer_handle_eos_delay(mmplayer_t *player, int delay_in_ms)
        MMPLAYER_RETURN_IF_FAIL(player);
 
        /* post now if delay is zero */
-       if (delay_in_ms == 0 || player->audio_stream_render_cb) {
+       if (delay_in_ms == 0 || player->audio_decoded_cb) {
                LOGD("eos delay is zero. posting EOS now");
                MMPLAYER_POST_MSG(player, MM_MESSAGE_END_OF_STREAM, NULL);
 
-               if (player->audio_stream_render_cb)
+               if (player->audio_decoded_cb)
                        __mmplayer_cancel_eos_timer(player);
 
                return;
@@ -1409,7 +1409,7 @@ __mmplayer_gst_handle_eos_message(mmplayer_t *player, GstMessage *msg)
        if (player->pipeline && player->pipeline->textbin)
                __mmplayer_drop_subtitle(player, TRUE);
 
-       if ((player->audio_stream_render_cb) && (!player->audio_stream_sink_sync))
+       if ((player->audio_decoded_cb) && (player->audio_extract_opt & MM_PLAYER_AUDIO_EXTRACT_NO_SYNC_WITH_CLOCK))
                __mmplayer_audio_stream_clear_buffer(player, TRUE);
 
        /* rewind if repeat count is greater then zero */
@@ -2543,7 +2543,7 @@ __mmplayer_gst_rtp_dynamic_pad(GstElement *element, GstPad *pad, gpointer data)
                gint stype = 0;
                mm_attrs_get_int_by_name(player->attrs, "display_surface_type", &stype);
 
-               if ((stype == MM_DISPLAY_SURFACE_NULL) && (!player->set_mode.media_packet_video_stream)) {
+               if ((stype == MM_DISPLAY_SURFACE_NULL) && (!player->set_mode.video_export)) {
                        if (player->v_stream_caps) {
                                gst_caps_unref(player->v_stream_caps);
                                player->v_stream_caps = NULL;
@@ -3197,7 +3197,7 @@ __mmplayer_gst_pause(mmplayer_t *player, gboolean async)
                return ret;
        }
 
-       if ((!MMPLAYER_IS_RTSP_STREAMING(player)) && (!player->video_stream_cb) &&
+       if ((!MMPLAYER_IS_RTSP_STREAMING(player)) && (!player->video_decoded_cb) &&
                (!player->pipeline->videobin) && (!player->pipeline->audiobin))
                return MM_ERROR_PLAYER_CODEC_NOT_FOUND;
 

diff --git a/src/mm_player_priv.c b/src/mm_player_priv.c
index a6410f8..fb14678 100644 (file)
--- a/src/mm_player_priv.c
+++ b/src/mm_player_priv.c
@@ -105,6 +105,10 @@
 
 #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:                                                                                       |
 ---------------------------------------------------------------------------*/
@@ -1119,7 +1123,7 @@ __mmplayer_gst_decode_pad_added(GstElement *elem, GstPad *pad, gpointer data)
 
                /* 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;
                }
@@ -1525,6 +1529,12 @@ __mmplayer_gst_create_sinkbin(GstElement *elem, GstPad *pad, gpointer data)
        /* LOGD("detected mimetype : %s", name); */
        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_attrs_set_string_by_name(player->attrs, "content_audio_format", audio_format);
+                       }
+
                        if (__mmplayer_gst_create_audio_sink_bin(player) != MM_ERROR_NONE) {
                                LOGE("failed to create audiobin. continuing without audio");
                                goto ERROR;
@@ -2283,7 +2293,7 @@ __mmplayer_audio_stream_send_data(mmplayer_t *player, mmplayer_audio_stream_buff
        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;
@@ -2293,8 +2303,8 @@ __mmplayer_audio_stream_send_data(mmplayer_t *player, mmplayer_audio_stream_buff
        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);
+       /* LOGD("[%"G_GUINT64_FORMAT"] send data size:%d, %p", audio_stream.channel_mask, audio_stream.data_size, player->audio_decoded_cb_user_param); */
+       player->audio_decoded_cb(&audio_stream, player->audio_decoded_cb_user_param);
 
        MMPLAYER_FLEAVE();
 }
@@ -2303,6 +2313,7 @@ static void
 __mmplayer_audio_stream_decoded_render_cb(GstElement *object, GstBuffer *buffer, GstPad *pad, gpointer data)
 {
        mmplayer_t *player = (mmplayer_t *)data;
+       const gchar *pcm_format = NULL;
        gint channel = 0;
        gint rate = 0;
        gint depth = 0;
@@ -2315,7 +2326,7 @@ __mmplayer_audio_stream_decoded_render_cb(GstElement *object, GstBuffer *buffer,
        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;
@@ -2325,6 +2336,7 @@ __mmplayer_audio_stream_decoded_render_cb(GstElement *object, GstBuffer *buffer,
        GstStructure *structure = gst_caps_get_structure(caps, 0);
 
        /* MMPLAYER_LOG_GST_CAPS_TYPE(caps); */
+       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);
@@ -2381,8 +2393,9 @@ __mmplayer_audio_stream_decoded_render_cb(GstElement *object, GstBuffer *buffer,
        a_buffer->is_little_endian = (endianness == 1234 ? true : false);
        a_buffer->channel_mask = channel_mask;
        a_buffer->data_size = a_size;
+       a_buffer->pcm_format = util_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_try_malloc(a_buffer->buff_size);
@@ -2443,10 +2456,11 @@ __mmplayer_gst_audio_deinterleave_pad_added(GstElement *elem, GstPad *pad, gpoin
                goto ERROR;
        }
 
-       LOGE("player->audio_stream_sink_sync: %d", 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);
@@ -2631,7 +2645,7 @@ __mmplayer_gst_fill_audio_bucket(mmplayer_t *player, GList **bucket)
        /* 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 */
+       if (player->audio_decoded_cb) { /* pcm extraction only, no sound output */
                gchar *dst_format = NULL;
                int dst_len = 0;
                int dst_samplerate = 0;
@@ -2646,7 +2660,24 @@ __mmplayer_gst_fill_audio_bucket(mmplayer_t *player, GList **bucket)
                                        "pcm_extraction_channels", &dst_channels,
                                        NULL);
 
-               LOGD("pcm info - format: %s(%d), samplerate : %d, channel: %d", dst_format, dst_len, dst_samplerate, dst_channels);
+               LOGD("required 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("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 || util_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;
+               }
 
                /* capsfilter */
                MMPLAYER_CREATE_ELEMENT(audiobin, MMPLAYER_A_CAPS_DEFAULT, "capsfilter", "audio capsfilter", TRUE, player);
@@ -2665,16 +2696,28 @@ __mmplayer_gst_fill_audio_bucket(mmplayer_t *player, GList **bucket)
                gst_caps_unref(caps);
                MMPLAYER_FREEIF(caps_str);
 
-               MMPLAYER_CREATE_ELEMENT(audiobin, MMPLAYER_A_DEINTERLEAVE, "deinterleave", "deinterleave", TRUE, player);
-
-               g_object_set(G_OBJECT(audiobin[MMPLAYER_A_DEINTERLEAVE].gst), "keep-positions", TRUE, NULL);
+               if (player->audio_extract_opt & MM_PLAYER_AUDIO_EXTRACT_DEINTERLEAVE) {
+                       MMPLAYER_CREATE_ELEMENT(audiobin, MMPLAYER_A_DEINTERLEAVE, "deinterleave", "deinterleave", TRUE, player);
 
-               /* 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);
+                       g_object_set(G_OBJECT(audiobin[MMPLAYER_A_DEINTERLEAVE].gst), "keep-positions", TRUE, NULL);
 
+                       /* 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);
+               } else {
+                       MMPLAYER_CREATE_ELEMENT(audiobin, MMPLAYER_A_SINK, "fakesink", "audiosink", TRUE, player);
+                       if (!(player->audio_extract_opt & MM_PLAYER_AUDIO_EXTRACT_NO_SYNC_WITH_CLOCK))
+                               g_object_set(G_OBJECT(audiobin[MMPLAYER_A_SINK].gst), "sync", TRUE, NULL);
+                       g_object_set(G_OBJECT(audiobin[MMPLAYER_A_SINK].gst), "signal-handoffs", TRUE, NULL);
+
+                       __mmplayer_add_signal_connection(player,
+                               G_OBJECT(audiobin[MMPLAYER_A_SINK].gst),
+                               MM_PLAYER_SIGNAL_TYPE_AUDIOBIN,
+                               "handoff",
+                               G_CALLBACK(__mmplayer_audio_stream_decoded_render_cb),
+                               (gpointer)player);
+                       }
        } else {
-
                /* normal playback */
                gint channels = 0;
 
@@ -3049,7 +3092,7 @@ __mmplayer_video_stream_decoded_preroll_cb(GstElement *object, GstBuffer *buffer
 {
        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;
@@ -3069,7 +3112,7 @@ __mmplayer_video_stream_decoded_render_cb(GstElement *object, GstBuffer *buffer,
 
        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;
@@ -3093,7 +3136,7 @@ __mmplayer_video_stream_decoded_render_cb(GstElement *object, GstBuffer *buffer,
 
        /* 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);
@@ -3105,8 +3148,8 @@ __mmplayer_video_stream_decoded_render_cb(GstElement *object, GstBuffer *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;
        }
 
@@ -3300,7 +3343,7 @@ __mmplayer_gst_set_videosink_property(mmplayer_t *player, MMDisplaySurfaceType s
                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))
@@ -4278,7 +4321,7 @@ __mmplayer_can_do_interrupt(mmplayer_t *player)
                goto FAILED;
        }
 
-       if (player->audio_stream_render_cb) {
+       if (player->audio_decoded_cb) {
                LOGW("not support in pcm extraction mode");
                goto FAILED;
        }
@@ -5138,7 +5181,7 @@ _mmplayer_set_audiostream_changed_cb(MMHandleType hplayer, mm_player_stream_chan
 }
 
 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)
 {
        mmplayer_t *player = (mmplayer_t *)hplayer;
 
@@ -5146,10 +5189,10 @@ _mmplayer_set_audiostream_cb(MMHandleType hplayer, bool sync, mm_player_audio_st
 
        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();
 
@@ -5157,7 +5200,7 @@ _mmplayer_set_audiostream_cb(MMHandleType hplayer, bool sync, mm_player_audio_st
 }
 
 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)
 {
        mmplayer_t *player = (mmplayer_t *)hplayer;
 
@@ -5168,11 +5211,11 @@ _mmplayer_set_videostream_cb(MMHandleType hplayer, mm_player_video_stream_callba
        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", 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();
 
@@ -7203,7 +7246,7 @@ __mmplayer_gst_decode_autoplug_select(GstElement *bin,  GstPad *pad,
 
                /* 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;
@@ -7429,13 +7472,13 @@ __mmplayer_release_misc(mmplayer_t *player)
 
        MMPLAYER_RETURN_IF_FAIL(player);
 
-       player->video_stream_cb = NULL;
-       player->video_stream_cb_user_param = NULL;
+       player->video_decoded_cb = NULL;
+       player->video_decoded_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->audio_decoded_cb = NULL;
+       player->audio_decoded_cb_user_param = NULL;
+       player->audio_extract_opt = MM_PLAYER_AUDIO_EXTRACT_DEFAULT;
 
        player->video_stream_changed_cb = NULL;
        player->video_stream_changed_cb_user_param = NULL;
@@ -7466,7 +7509,7 @@ __mmplayer_release_misc(mmplayer_t *player)
        player->play_subtitle = FALSE;
        player->adjust_subtitle_pos = 0;
        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(mmplayer_setting_mode_t));
        /* recover mode */

diff --git a/src/mm_player_utils.c b/src/mm_player_utils.c
index 52b58f1..a9d4f90 100644 (file)
--- a/src/mm_player_utils.c
+++ b/src/mm_player_utils.c
@@ -33,6 +33,7 @@
 #include <storage.h>
 #include <tzplatform_config.h>
 #include "mm_player_utils.h"
+#include "media_format.h"
 
 #define MEDIA_PATH_EXTERNAL tzplatform_getenv(TZ_SYS_STORAGE) /* external storage, sd card, usb */
 
@@ -563,3 +564,44 @@ util_get_storage_info(const char *path, mmplayer_storage_info_t *storage_info)
        LOGD("storage info %d:%d:%d", storage_info->type, storage_info->id, storage_info->state);
        return true;
 }
+
+media_format_mimetype_e util_convert_audio_pcm_str_to_media_format_mime(const gchar *audio_pcm_str)
+{
+       if (!audio_pcm_str) {
+               LOGW("audio pcm str is NULL");
+               return MEDIA_FORMAT_MAX;
+       }
+
+       if (strstr(audio_pcm_str, "S16LE"))
+               return MEDIA_FORMAT_PCM_S16LE;
+       else if (strstr(audio_pcm_str, "S24LE"))
+               return MEDIA_FORMAT_PCM_S24LE;
+       else if (strstr(audio_pcm_str, "S32LE"))
+               return MEDIA_FORMAT_PCM_S32LE;
+       else if (strstr(audio_pcm_str, "S16BE"))
+               return MEDIA_FORMAT_PCM_S16BE;
+       else if (strstr(audio_pcm_str, "S24BE"))
+               return MEDIA_FORMAT_PCM_S24BE;
+       else if (strstr(audio_pcm_str, "S32BE"))
+               return MEDIA_FORMAT_PCM_S32BE;
+       else if (strstr(audio_pcm_str, "F32LE"))
+               return MEDIA_FORMAT_PCM_F32LE;
+       else if (strstr(audio_pcm_str, "F32BE"))
+               return MEDIA_FORMAT_PCM_F32BE;
+       else if (strstr(audio_pcm_str, "U16LE"))
+               return MEDIA_FORMAT_PCM_U16LE;
+       else if (strstr(audio_pcm_str, "U24LE"))
+               return MEDIA_FORMAT_PCM_U24LE;
+       else if (strstr(audio_pcm_str, "U32LE"))
+               return MEDIA_FORMAT_PCM_U32LE;
+       else if (strstr(audio_pcm_str, "U16BE"))
+               return MEDIA_FORMAT_PCM_U16BE;
+       else if (strstr(audio_pcm_str, "U24BE"))
+               return MEDIA_FORMAT_PCM_U24BE;
+       else if (strstr(audio_pcm_str, "U32BE"))
+               return MEDIA_FORMAT_PCM_U32BE;
+       else {
+               LOGW("Not supported audio pcm format str : %s", audio_pcm_str);
+               return MEDIA_FORMAT_MAX;
+       }
+}