Add audioresample for supporting various samplerates

Change-Id: Ic41c21a21cf5ea621b047917ac5b2045712d1a4c

diff --git a/include/media_codec_port.h b/include/media_codec_port.h
index f1c3fca..f2a732c 100644 (file)
--- a/include/media_codec_port.h
+++ b/include/media_codec_port.h
@@ -163,41 +163,21 @@ typedef enum _mc_codec_port_type_e {
        CODEC_PORT_TYPE_MAX,
 } mc_codec_port_type_e;
 
-typedef enum _mc_vendor_e {
-       MC_VENDOR_DEFAULT,
-       MC_VENDOR_SLSI_SEC,
-       MC_VENDOR_SLSI_EXYNOS,
-       MC_VENDOR_QCT,
-       MC_VENDOR_SPRD
-} mc_vendor_e;
-
-struct _mc_decoder_info_t {
-       int width;
-       int height;
-       int actwidth;
-       int actheight;
-
-       int samplerate;
-       int channel;
-       int bit;
-};
-
-struct _mc_encoder_info_t {
-       int width;
-       int height;
-       int bitrate;
-       int format;
-       int fps;
-       int qp_min;
-       int qp_max;
-       int vbvbuffer_size;
-       int level;
-       int profile;
-
-       int samplerate;
-       int channel;
-       int bit;
-};
+typedef struct mc_audio_port_definition_t {
+       gint samplerate;
+       gint channel;
+       gint bit_depth;
+       gint bitrate;
+} mc_audio_port_definition_t;
+
+typedef struct mc_video_port_definition_t {
+       gchar *format;
+       gint width;
+       gint height;
+       gint stride;
+       gint bitrate;
+       gint framerate;
+} mc_video_port_definition_t;
 
 /* Codec Private data */
 struct _mc_handle_t {
@@ -209,14 +189,13 @@ struct _mc_handle_t {
 
        mediacodec_port_type_e port_type;
        mediacodec_codec_type_e codec_id;
-       mc_vendor_e vendor;
 
        void *ports[2];
        void *core;
 
        union {
-               mc_decoder_info_t decoder;
-               mc_encoder_info_t encoder;
+               mc_audio_port_definition_t audio;
+               mc_video_port_definition_t video;
        } info;
 
        /* for process done cb */

diff --git a/include/media_codec_port_gst.h b/include/media_codec_port_gst.h
old mode 100644 (file)
new mode 100755 (executable)
index 4373b7b..4d9198f
--- a/include/media_codec_port_gst.h
+++ b/include/media_codec_port_gst.h
@@ -59,17 +59,26 @@ extern "C" {
 #define THRESHOLD_QNUM 5
 
 /* gst port layer */
+typedef struct _mc_gst_port_def_t mc_gst_port_def_t;
 typedef struct _mc_gst_port_t mc_gst_port_t;
 typedef struct _mc_gst_core_t mc_gst_core_t;
 typedef struct _GstMCBuffer GstMCBuffer;
-typedef struct _ion_mmu_data_t ion_mmu_data_t;
+
 
 typedef enum {
-       BUF_SHARE_METHOD_PADDR = 0,
-       BUF_SHARE_METHOD_FD,
-       BUF_SHARE_METHOD_TIZEN_BUFFER,
-       BUF_SHARE_METHOD_FLUSH_BUFFER
-} buf_share_method_t;
+       in_port_index = 0,
+       out_port_index
+} port_index_e;
+
+
+struct _mc_gst_port_def_t {
+       gchar *mime_type;
+       media_format_mimetype_e coding_type;
+       union {
+               mc_audio_port_definition_t audio;
+               mc_video_port_definition_t video;
+       } info;
+};
 
 struct _mc_gst_port_t {
        mc_gst_core_t *core;
@@ -77,19 +86,21 @@ struct _mc_gst_port_t {
        guint buffer_size;
        guint index;
        gboolean is_allocated;
-       media_packet_h *buffers;
        GQueue *queue;
        GMutex mutex;
        GCond buffer_cond;
+       mc_gst_port_def_t port_def;
 };
 
 struct _mc_gst_core_t {
        gint(**vtable)();
        const gchar *mime;
-       gchar *format;
        GstElement *pipeline;
        GstElement *appsrc;
        GstElement *audioconvert;
+       GstElement *audioresample;
+       GstElement *videoscale;
+       GstElement *videoconvert;
        GstElement *capsfilter;
        GstElement *parser;
        GstElement *fakesink;
@@ -137,8 +148,8 @@ struct _mc_gst_core_t {
        mc_aqueue_t *available_queue;
        GQueue *output_queue;
 
-       void *codec_info;
        GstBuffer *codec_data;
+       GstCaps* (*mc_caps_new)(mc_gst_core_t *, mediacodec_codec_type_e, gint);
 
        void* user_cb[_MEDIACODEC_EVENT_TYPE_NUM];
        void* user_data[_MEDIACODEC_EVENT_TYPE_NUM];

diff --git a/src/media_codec_port.c b/src/media_codec_port.c
index 3584dd5..cf6843a 100644 (file)
--- a/src/media_codec_port.c
+++ b/src/media_codec_port.c
@@ -174,8 +174,8 @@ int mc_set_vdec_info(MMHandleType mediacodec, int width, int height)
        MEDIACODEC_CHECK_CONDITION(mc_handle->codec_id && mc_handle->is_video && !mc_handle->is_encoder,
                        MC_INVALID_ARG, "MEDIACODEC_ERROR_INVALID_PARAMETER");
 
-       mc_handle->info.decoder.width = width;
-       mc_handle->info.decoder.height = height;
+       mc_handle->info.video.width = width;
+       mc_handle->info.video.height = height;
 
        mc_handle->is_prepared = true;
 
@@ -198,10 +198,10 @@ int mc_set_venc_info(MMHandleType mediacodec, int width, int height, int fps, in
        MEDIACODEC_CHECK_CONDITION(mc_handle->codec_id && mc_handle->is_video && mc_handle->is_encoder,
                        MC_INVALID_ARG, "MEDIACODEC_ERROR_INVALID_PARAMETER");
 
-       mc_handle->info.encoder.width = width;
-       mc_handle->info.encoder.height = height;
-       mc_handle->info.encoder.fps = fps;
-       mc_handle->info.encoder.bitrate = target_bits * 1000;
+       mc_handle->info.video.width = width;
+       mc_handle->info.video.height = height;
+       mc_handle->info.video.framerate = fps;
+       mc_handle->info.video.bitrate = target_bits * 1000;
        mc_handle->is_prepared = true;
 
        return ret;
@@ -223,9 +223,9 @@ int mc_set_adec_info(MMHandleType mediacodec, int samplerate, int channel, int b
        MEDIACODEC_CHECK_CONDITION(mc_handle->codec_id && !mc_handle->is_video && !mc_handle->is_encoder,
                        MC_INVALID_ARG, "MEDIACODEC_ERROR_INVALID_PARAMETER");
 
-       mc_handle->info.decoder.samplerate = samplerate;
-       mc_handle->info.decoder.channel = channel;
-       mc_handle->info.decoder.bit = bit;
+       mc_handle->info.audio.samplerate = samplerate;
+       mc_handle->info.audio.channel = channel;
+       mc_handle->info.audio.bit_depth = bit;
        mc_handle->is_prepared = true;
 
        return ret;
@@ -247,10 +247,10 @@ int mc_set_aenc_info(MMHandleType mediacodec, int samplerate, int channel, int b
        MEDIACODEC_CHECK_CONDITION(mc_handle->codec_id && !mc_handle->is_video && mc_handle->is_encoder,
                        MC_INVALID_ARG, "MEDIACODEC_ERROR_INVALID_PARAMETER");
 
-       mc_handle->info.encoder.samplerate = samplerate;
-       mc_handle->info.encoder.channel = channel;
-       mc_handle->info.encoder.bit = bit;
-       mc_handle->info.encoder.bitrate = bitrate * 1000;
+       mc_handle->info.audio.samplerate = samplerate;
+       mc_handle->info.audio.channel = channel;
+       mc_handle->info.audio.bit_depth = bit;
+       mc_handle->info.audio.bitrate = bitrate * 1000;
 
        mc_handle->is_prepared = true;
 
@@ -294,19 +294,19 @@ int mc_configure(MMHandleType mediacodec, media_format_h format, int flags)
                                return MC_PARAM_ERROR;
                        }
 
-                       mc_handle->info.encoder.samplerate = samplerate;
-                       mc_handle->info.encoder.channel = channel;
-                       mc_handle->info.encoder.bit = bit;
-                       mc_handle->info.encoder.bitrate = bitrate * 1000;
+                       mc_handle->info.audio.samplerate = samplerate;
+                       mc_handle->info.audio.channel = channel;
+                       mc_handle->info.audio.bit_depth = bit;
+                       mc_handle->info.audio.bitrate = bitrate * 1000;
                } else if (GET_IS_DECODER(flags)) {
                        if ((samplerate <= 0) || (channel <= 0) || (bit <= 0)) {
                                LOGE("invalid pram is set : samplerate : %d, channel : %d, bit : %d",
                                        samplerate, channel, bit);
                                return MC_PARAM_ERROR;
                        }
-                       mc_handle->info.decoder.samplerate = samplerate;
-                       mc_handle->info.decoder.channel = channel;
-                       mc_handle->info.decoder.bit = bit;
+                       mc_handle->info.audio.samplerate = samplerate;
+                       mc_handle->info.audio.channel = channel;
+                       mc_handle->info.audio.bit_depth = bit;
                } else {
                        LOGE("either an encoder or a decoder must be set");
                        return MC_PARAM_ERROR;
@@ -322,10 +322,10 @@ int mc_configure(MMHandleType mediacodec, media_format_h format, int flags)
                                return MC_PARAM_ERROR;
                        }
 
-                       mc_handle->info.encoder.width = width;
-                       mc_handle->info.encoder.height = height;
-                       mc_handle->info.encoder.fps = fps;
-                       mc_handle->info.encoder.bitrate = bitrate * 1000;
+                       mc_handle->info.video.width = width;
+                       mc_handle->info.video.height = height;
+                       mc_handle->info.video.framerate = fps;
+                       mc_handle->info.video.bitrate = bitrate * 1000;
                } else if (GET_IS_DECODER(flags)) {
                        if ((width <= 0) || (height <= 0)) {
                                LOGE("invalid pram is set : width : %d, height : %d",
@@ -333,8 +333,8 @@ int mc_configure(MMHandleType mediacodec, media_format_h format, int flags)
                                return MC_PARAM_ERROR;
                        }
 
-                       mc_handle->info.decoder.width = width;
-                       mc_handle->info.decoder.height = height;
+                       mc_handle->info.video.width = width;
+                       mc_handle->info.video.height = height;
                } else {
                        LOGE("either an encoder or a decoder must be set");
                        return MC_PARAM_ERROR;

diff --git a/src/media_codec_port_gst.c b/src/media_codec_port_gst.c
index 771e632..6d32a7b 100644 (file)
--- a/src/media_codec_port_gst.c
+++ b/src/media_codec_port_gst.c
@@ -41,11 +41,10 @@ static mc_ret_e _mc_gst_create_pipeline(mc_gst_core_t *core, gchar *factory_name
 static mc_ret_e _mc_gst_destroy_pipeline(mc_gst_core_t *core);
 static void __mc_gst_buffer_add(GstElement *element, GstBuffer *buffer, GstPad *pad, gpointer data);
 static int __mc_output_buffer_finalize_cb(media_packet_h packet, int error_code, void *user_data);
-static int _mc_gst_update_caps(mc_gst_core_t *core, GstMCBuffer *mcbuffer, bool codec_config);
-static gboolean _mc_update_packet_info(mc_gst_core_t *core, media_format_h fmt);
+static gboolean _mc_update_packet_info(mc_gst_core_t *core, media_format_h format);
 static GstMCBuffer *_mc_gst_media_packet_to_gstbuffer(mc_gst_core_t *core, media_packet_h packet, bool codec_config);
 static int _mc_gst_gstbuffer_to_appsrc(mc_gst_core_t *core, GstMCBuffer *mcbuffer);
-static gchar *__mc_get_gst_input_format(media_packet_h packet, bool is_hw);
+static gchar *__mc_get_gst_input_format(media_format_mimetype_e mimetype, bool is_hw);
 static GstMCBuffer *__mc_gst_make_media_packet(mc_gst_core_t *core, GstBuffer *buffer);
 static gboolean __mc_gst_bus_callback(GstBus *bus, GstMessage *msg, gpointer data);
 static GstBusSyncReply __mc_gst_bus_sync_callback(GstBus *bus, GstMessage *msg, gpointer data);
@@ -82,6 +81,9 @@ static void __csc_tiled_to_linear_crop(unsigned char *yuv420_dest,
 static void _mc_send_eos_signal(mc_gst_core_t *core);
 static void _mc_wait_for_eos(mc_gst_core_t *core);
 static int _mc_get_mime(mc_gst_core_t *core);
+static int _mc_set_codec_data(mc_gst_core_t *core, GstMCBuffer *mcbuffer);
+GstCaps *_mc_gst_vid_caps_new(mc_gst_core_t *core, mediacodec_codec_type_e codec_id, gint index);
+GstCaps *_mc_gst_aud_caps_new(mc_gst_core_t *core, mediacodec_codec_type_e codec_id, gint index);
 
 /* video vtable */
 int(*vdec_vtable[])() = {&__mc_fill_input_buffer_with_packet, &__mc_fill_packet_with_output_buffer};
@@ -287,10 +289,10 @@ int __mc_fill_input_buffer_with_venc_packet(mc_gst_core_t *core, media_packet_h
        uint32_t plane_num;
        guint8 *planes[2];
 
-       mc_encoder_info_t *enc_info = (mc_encoder_info_t *)core->codec_info;
+       mc_gst_port_def_t *port_def = &core->ports[in_port_index]->port_def;
 
-       width = enc_info->width;
-       height = enc_info->height;
+       width = port_def->info.video.width;
+       height = port_def->info.video.height;
 
        ret = media_packet_get_number_of_video_planes(packet, &plane_num);
        if (ret != MEDIA_PACKET_ERROR_NONE) {
@@ -402,11 +404,11 @@ int __mc_fill_vdec_packet_with_output_buffer(mc_gst_core_t *core, void *data, in
 
        g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
 
-       mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info;
+       mc_gst_port_def_t *port_def = &core->ports[out_port_index]->port_def;
 
        if (!core->is_hw) {
-               width = dec_info->width;
-               height = dec_info->height;
+               width = port_def->info.video.width;
+               height = port_def->info.video.height;
                stride_width = GST_ROUND_UP_4(width);
                stride_height = height;
                buf_size = stride_width * stride_height * 3 / 2;
@@ -419,8 +421,8 @@ int __mc_fill_vdec_packet_with_output_buffer(mc_gst_core_t *core, void *data, in
                        return MC_ERROR;
                }
 
-               tsurf_info.width = dec_info->width;
-               tsurf_info.height = dec_info->height;
+               tsurf_info.width = port_def->info.video.width;
+               tsurf_info.height = port_def->info.video.height;
                tsurf_info.format = TBM_FORMAT_YVU420;
                tsurf_info.bpp = tbm_surface_internal_get_bpp(TBM_FORMAT_YVU420);
                tsurf_info.num_planes = tbm_surface_internal_get_num_planes(TBM_FORMAT_YVU420);
@@ -463,8 +465,8 @@ int __mc_fill_vdec_packet_with_output_buffer(mc_gst_core_t *core, void *data, in
                        }
 
                        if (bo_num > 0) {
-                               tsurf_info.width = dec_info->width;
-                               tsurf_info.height = dec_info->height;
+                               tsurf_info.width = port_def->info.video.width;
+                               tsurf_info.height = port_def->info.video.height;
                                tsurf_info.format = TBM_FORMAT_NV12;        /* bo_format */
                                tsurf_info.bpp = tbm_surface_internal_get_bpp(TBM_FORMAT_NV12);
                                tsurf_info.num_planes = tbm_surface_internal_get_num_planes(TBM_FORMAT_NV12);
@@ -542,13 +544,13 @@ int __mc_fill_venc_packet_with_output_buffer(mc_gst_core_t *core, void *data, in
 
        g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
 
-       switch (core->out_mime) {
+       switch (core->ports[out_port_index]->port_def.coding_type) {
        case MEDIA_FORMAT_H264_SP:
        case MEDIA_FORMAT_H264_MP:
        case MEDIA_FORMAT_H264_HP:
                data_size = _mc_check_h264_bytestream((unsigned char *)data, size, 1, &codec_config, &sync_flag, &slice);
 
-               if (data_size <= 0) {
+               if (data_size < 0) {
                        LOGE("No valid SPS/PPS ...");
                        return MC_INVALID_IN_BUF;
                }
@@ -904,41 +906,36 @@ int _mc_output_media_packet_new(mc_gst_core_t *core, bool video, bool encoder, m
                LOGE("media format create failed");
                return MC_ERROR;
        }
+       mc_gst_port_def_t *port_def = &core->ports[out_port_index]->port_def;
 
        if (encoder) {
-               mc_encoder_info_t *info;
-
-               info = (mc_encoder_info_t *)core->codec_info;
 
                if (video) {
                        media_format_set_video_mime(core->output_fmt, out_mime);
-                       media_format_set_video_width(core->output_fmt, info->width);
-                       media_format_set_video_height(core->output_fmt, info->height);
-                       media_format_set_video_avg_bps(core->output_fmt, info->bitrate);
+                       media_format_set_video_width(core->output_fmt, port_def->info.video.width);
+                       media_format_set_video_height(core->output_fmt, port_def->info.video.height);
+                       media_format_set_video_avg_bps(core->output_fmt, port_def->info.video.bitrate);
                } else {
                        int support_bit = 0;
                        support_bit = _mc_get_support_bit_from_format(out_mime);
 
                        media_format_set_audio_mime(core->output_fmt, out_mime);
-                       media_format_set_audio_channel(core->output_fmt, info->channel);
-                       media_format_set_audio_samplerate(core->output_fmt, info->samplerate);
+                       media_format_set_audio_channel(core->output_fmt, port_def->info.audio.channel);
+                       media_format_set_audio_samplerate(core->output_fmt, port_def->info.audio.samplerate);
                        media_format_set_audio_bit(core->output_fmt, support_bit);
-                       media_format_set_audio_avg_bps(core->output_fmt, info->bitrate);
+                       media_format_set_audio_avg_bps(core->output_fmt, port_def->info.audio.bitrate);
                }
        } else {
-               mc_decoder_info_t *info;
-
-               info = (mc_decoder_info_t *)core->codec_info;
 
                if (video) {
                        media_format_set_video_mime(core->output_fmt, out_mime);
-                       media_format_set_video_width(core->output_fmt, info->width);
-                       media_format_set_video_height(core->output_fmt, info->height);
+                       media_format_set_video_width(core->output_fmt, port_def->info.video.width);
+                       media_format_set_video_height(core->output_fmt, port_def->info.video.height);
                } else {
                        media_format_set_audio_mime(core->output_fmt, out_mime);
-                       media_format_set_audio_channel(core->output_fmt, info->channel);
-                       media_format_set_audio_samplerate(core->output_fmt, info->samplerate);
-                       media_format_set_audio_bit(core->output_fmt, info->bit);
+                       media_format_set_audio_channel(core->output_fmt, port_def->info.audio.channel);
+                       media_format_set_audio_samplerate(core->output_fmt, port_def->info.audio.samplerate);
+                       media_format_set_audio_bit(core->output_fmt, port_def->info.audio.bit_depth);
                }
        }
        return MC_ERROR_NONE;
@@ -956,7 +953,8 @@ mc_gst_core_t *mc_gst_core_new()
        core = g_new0(mc_gst_core_t, 1);
 
        /* 0 : input, 1 : output */
-       core->ports[0] = NULL;
+       core->ports[0] = mc_gst_port_new(core);
+       core->ports[0]->index = 0;
        core->ports[1] = mc_gst_port_new(core);
        core->ports[1]->index = 1;
 
@@ -1018,6 +1016,11 @@ void mc_gst_core_free(mc_gst_core_t *core)
        if (core->codec_data)
                gst_buffer_unref(core->codec_data);
 
+       if (core->ports[0] != NULL) {
+               mc_gst_port_free(core->ports[0]);
+               core->ports[0] = NULL;
+       }
+
        if (core->ports[1] != NULL) {
                mc_gst_port_free(core->ports[1]);
                core->ports[1] = NULL;
@@ -1043,7 +1046,6 @@ mc_gst_port_t *mc_gst_port_new(mc_gst_core_t *core)
        port->num_buffers = -1;
        port->buffer_size = 0;
        port->is_allocated = 0;
-       port->buffers = NULL;
 
        g_mutex_init(&port->mutex);
        port->queue = g_queue_new();
@@ -1069,33 +1071,43 @@ void mc_gst_port_free(mc_gst_port_t *port)
        return;
 }
 
-gboolean _mc_update_packet_info(mc_gst_core_t *core, media_format_h fmt)
+gboolean _mc_update_packet_info(mc_gst_core_t *core, media_format_h format)
 {
-       gboolean is_updated = FALSE;
+       gboolean is_format_change = FALSE;
 
-       mc_decoder_info_t *codec_info = (mc_decoder_info_t *)core->codec_info;
+       mc_gst_port_def_t *input_port_def = &core->ports[in_port_index]->port_def;
 
        if (core->video) {
                gint width = 0;
                gint height = 0;
                gint bitrate = 0;
+               gint framerate = 0;
+               gchar *sformat = NULL;
+               media_format_mimetype_e mimetype = 0;
 
-               media_format_get_video_info(fmt, NULL, &width, &height, &bitrate, NULL);
+               media_format_get_video_info(format, &mimetype, &width, &height, &bitrate, NULL);
+               media_format_get_video_frame_rate(format, &framerate);
 
-               if ((codec_info->width != width) || (codec_info->height != height)) {
-                       LOGD("Resolution changed : %dx%d -> %dx%d", codec_info->width, codec_info->height, width, height);
-                       codec_info->width = width;
-                       codec_info->height = height;
-                       is_updated = TRUE;
+               is_format_change |= input_port_def->info.video.width != width;
+               is_format_change |= input_port_def->info.video.height != height;
+               is_format_change |= (input_port_def->info.video.framerate != framerate) && (framerate != 0);
+               if (is_format_change) {
+                       LOGD("Format changed : resolution %dx%d -> %dx%d, framerate %d -> %d",
+                               input_port_def->info.video.width, input_port_def->info.video.height, width, height,
+                               input_port_def->info.video.framerate, framerate);
+                       input_port_def->info.video.width = width;
+                       input_port_def->info.video.height = height;
                }
 
                if (core->encoder) {
-                       mc_encoder_info_t *enc_info = (mc_encoder_info_t *)core->codec_info;
-
-                       if (bitrate != 0 && enc_info->bitrate != bitrate * 1000) {
-                               LOGD("Bitrate changed : %d -> %d", enc_info->bitrate, bitrate);
-                               enc_info->bitrate = bitrate * 1000;
-                               is_updated = TRUE;
+                       sformat = __mc_get_gst_input_format(mimetype, core->is_hw);
+                       is_format_change |= input_port_def->info.video.bitrate != bitrate * 1000;
+                       is_format_change |= g_strcmp0(input_port_def->info.video.format, sformat);
+                       if (is_format_change) {
+                               LOGD("Bitrate changed : %d -> %d", input_port_def->info.video.bitrate, bitrate);
+                               LOGD("Format changed : %s -> %s", input_port_def->info.video.format, sformat);
+                               input_port_def->info.video.bitrate = bitrate * 1000;
+                               input_port_def->info.video.format = g_strdup(sformat);
                        }
                }
        } else {
@@ -1104,31 +1116,34 @@ gboolean _mc_update_packet_info(mc_gst_core_t *core, media_format_h fmt)
                gint bit;
                gint bitrate;
 
-               media_format_get_audio_info(fmt, NULL, &channel, &samplerate, &bit, &bitrate);
+               media_format_get_audio_info(format, NULL, &channel, &samplerate, &bit, &bitrate);
 
-               if ((codec_info->channel != channel) || (codec_info->samplerate != samplerate) || (codec_info->bit != bit)) {
-                       LOGD("Audio info. changed : %d -> %d, %d -> %d, %d -> %d", codec_info->channel, channel, codec_info->samplerate, samplerate, codec_info->bit, bit);
-                       codec_info->channel = channel;
-                       codec_info->samplerate = samplerate;
-                       codec_info->bit = bit;
-                       is_updated = TRUE;
+               is_format_change |= input_port_def->info.audio.channel != channel;
+               is_format_change |= input_port_def->info.audio.samplerate != samplerate;
+               is_format_change |= input_port_def->info.audio.bit_depth != bit;
+               if (is_format_change) {
+                       LOGD("Audio info. changed : %d -> %d, %d -> %d, %d -> %d",
+                               input_port_def->info.audio.channel, channel,
+                               input_port_def->info.audio.samplerate, samplerate,
+                               input_port_def->info.audio.bit_depth, bit);
+                       input_port_def->info.audio.channel = channel;
+                       input_port_def->info.audio.samplerate = samplerate;
+                       input_port_def->info.audio.bit_depth = bit;
                }
 
                if (core->encoder) {
-                       mc_encoder_info_t *enc_info = (mc_encoder_info_t *)core->codec_info;
-
-                       if (bitrate != 0 && enc_info->bitrate != bitrate * 1000) {
-                               LOGD("Bitrate changed : %d -> %d", enc_info->bitrate, bitrate);
-                               enc_info->bitrate = bitrate * 1000;
-                               is_updated = TRUE;
+                       is_format_change |= input_port_def->info.audio.bitrate != bitrate * 1000;
+                       if (is_format_change) {
+                               LOGD("Bitrate changed : %d -> %d", input_port_def->info.audio.bitrate, bitrate);
+                               input_port_def->info.audio.bitrate = bitrate * 1000;
                        }
                }
        }
 
-       return is_updated;
+       return is_format_change;
 }
 
-static int _mc_gst_update_caps(mc_gst_core_t *core, GstMCBuffer *mcbuffer, bool codec_config)
+static int _mc_set_codec_data(mc_gst_core_t *core, GstMCBuffer *mcbuffer)
 {
        MEDIACODEC_FENTER();
 
@@ -1137,88 +1152,43 @@ static int _mc_gst_update_caps(mc_gst_core_t *core, GstMCBuffer *mcbuffer, bool
 
        int ret = MC_ERROR_NONE;
 
-       if (core->video) {
-               if (core->encoder) {
-                       mc_encoder_info_t *enc_info = (mc_encoder_info_t *)core->codec_info;
-
-                       core->format = __mc_get_gst_input_format(mcbuffer->packet, core->is_hw);
-                       gst_caps_set_simple(core->caps,
-                                       "format", G_TYPE_STRING, core->format,
-                                       "width", G_TYPE_INT, enc_info->width,
-                                       "height", G_TYPE_INT, enc_info->height,
-                                       "framerate", GST_TYPE_FRACTION, enc_info->fps, 1,
-                                       NULL);
-
-                       if (g_object_class_find_property(G_OBJECT_GET_CLASS(core->codec), "bitrate"))
-                               g_object_set(GST_OBJECT(core->codec), "bitrate", enc_info->bitrate, NULL);
-                       else
-                               g_object_set(GST_OBJECT(core->codec), "target-bitrate", enc_info->bitrate, NULL);
-                       LOGD("set bitrate = %d.", enc_info->bitrate);
-               } else {
-                       mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info;
-
-                       gst_caps_set_simple(core->caps,
-                                       "width", G_TYPE_INT, dec_info->width,
-                                       "height", G_TYPE_INT, dec_info->height,
-                                       NULL);
-
-                       ret = __mc_set_caps_codecdata(core, mcbuffer, CODECDATA_NOT_USE);
-                       if (ret != MC_ERROR_NONE)
-                               LOGW("__mc_set_caps_codecdata failed");
-               }
-       } else {
-               if (core->encoder) {
-                       mc_encoder_info_t *enc_info = (mc_encoder_info_t *)core->codec_info;
-
-                       gst_caps_set_simple(core->caps,
-                                       "format", G_TYPE_STRING, _mc_bit_to_string(enc_info->bit),
-                                       "rate", G_TYPE_INT, enc_info->samplerate,
-                                       "channels", G_TYPE_INT, enc_info->channel,
-                                       NULL);
-                       g_object_set(GST_OBJECT(core->codec), "bitrate", enc_info->bitrate, NULL);
-               } else {
-                       mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info;
-
-                       gst_caps_set_simple(core->caps,
-                                       "rate", G_TYPE_INT, dec_info->samplerate,
-                                       "channels", G_TYPE_INT, dec_info->channel,
-                                       NULL);
-
-                       if (codec_config) {
-                               switch (core->codec_id) {
-                               case MEDIACODEC_AAC:
-                               case MEDIACODEC_AAC_HE:
-                               case MEDIACODEC_AAC_HE_PS:
-                                       ret = __mc_set_caps_codecdata(core, mcbuffer, AAC_CODECDATA_SIZE);
-                                       if (ret != MC_ERROR_NONE)
-                                               LOGW("__mc_set_caps_codecdata failed");
-                                       break;
-                               case MEDIACODEC_WMAV1:
-                               case MEDIACODEC_WMAV2:
-                               case MEDIACODEC_WMAPRO:
-                               case MEDIACODEC_WMALSL:
-                                       ret = __mc_set_caps_codecdata(core, mcbuffer, WMA_CODECDATA_SIZE);
-                                       if (ret != MC_ERROR_NONE)
-                                               LOGW("__mc_set_caps_codecdata failed");
-                                       break;
-                               case MEDIACODEC_VORBIS:
-                               case MEDIACODEC_FLAC:
-                                       ret = __mc_set_caps_streamheader(core, mcbuffer, VORBIS_CODECDATA_SIZE);
-                                       if (ret != MC_ERROR_NONE)
-                                               LOGW("__mc_set_caps_streamheader failed");
-                                       break;
-                               default:
-                                       LOGD("doesn't need to set codecdata");
-                                       break;
-
-                               }
-                       }
-               }
+       switch (core->codec_id) {
+       case MEDIACODEC_AAC:
+       case MEDIACODEC_AAC_HE:
+       case MEDIACODEC_AAC_HE_PS:
+               ret = __mc_set_caps_codecdata(core, mcbuffer, AAC_CODECDATA_SIZE);
+               if (ret != MC_ERROR_NONE)
+                       LOGW("__mc_set_caps_codecdata failed");
+               break;
+       case MEDIACODEC_WMAV1:
+       case MEDIACODEC_WMAV2:
+       case MEDIACODEC_WMAPRO:
+       case MEDIACODEC_WMALSL:
+               ret = __mc_set_caps_codecdata(core, mcbuffer, WMA_CODECDATA_SIZE);
+               if (ret != MC_ERROR_NONE)
+                       LOGW("__mc_set_caps_codecdata failed");
+               break;
+       case MEDIACODEC_VORBIS:
+       case MEDIACODEC_FLAC:
+               ret = __mc_set_caps_streamheader(core, mcbuffer, VORBIS_CODECDATA_SIZE);
+               if (ret != MC_ERROR_NONE)
+                       LOGW("__mc_set_caps_streamheader failed");
+               break;
+       case MEDIACODEC_H264:
+       case MEDIACODEC_MPEG4:
+               ret = __mc_set_caps_codecdata(core, mcbuffer, CODECDATA_NOT_USE);
+               if (ret != MC_ERROR_NONE)
+                       LOGW("__mc_set_caps_codecdata failed");
+               break;
+       default:
+               LOGD("doesn't need to set codecdata");
+               break;
        }
-       g_object_set(core->appsrc, "caps", core->caps, NULL);
 
        MEDIACODEC_FLEAVE();
        return ret;
+
+
 }
 
 static gpointer feed_task(gpointer data)
@@ -1227,8 +1197,9 @@ static gpointer feed_task(gpointer data)
        bool codec_config = FALSE;
        bool eos = FALSE;
        bool initiative = TRUE;
-       media_format_h fmt = NULL;
-       media_packet_h in_buf = NULL;
+       bool is_format_change = FALSE;
+       media_format_h format = NULL;
+       media_packet_h input_buffer = NULL;
        GstMCBuffer *mcbuffer = NULL;
 
        MEDIACODEC_FENTER();
@@ -1237,23 +1208,23 @@ static gpointer feed_task(gpointer data)
 
        while (g_atomic_int_get(&core->available_queue->running)) {
                LOGD("waiting for next input....");
-               in_buf = _mc_get_input_buffer(core);
-               if (!in_buf)
+               input_buffer = _mc_get_input_buffer(core);
+               if (!input_buffer)
                        goto LEAVE;
 
-               media_packet_get_format(in_buf,  &fmt);
-               if (fmt) {
-                       if (_mc_update_packet_info(core, fmt))
-                               initiative = TRUE;
-                       media_format_unref(fmt);
+               media_packet_get_format(input_buffer,  &format);
+               if (format) {
+                       if (_mc_update_packet_info(core, format))
+                               is_format_change = TRUE;
+                       media_format_unref(format);
                }
 
-               if (media_packet_is_codec_config(in_buf, &codec_config) != MEDIA_PACKET_ERROR_NONE) {
+               if (media_packet_is_codec_config(input_buffer, &codec_config) != MEDIA_PACKET_ERROR_NONE) {
                        LOGE("media_packet_is_codec_config failed");
                        goto ERROR;
                }
 
-               if (media_packet_is_end_of_stream(in_buf, &eos) != MEDIA_PACKET_ERROR_NONE) {
+               if (media_packet_is_end_of_stream(input_buffer, &eos) != MEDIA_PACKET_ERROR_NONE) {
                        LOGE("media_packet_is_end_of_stream failed");
                        goto ERROR;
                }
@@ -1265,41 +1236,43 @@ static gpointer feed_task(gpointer data)
                        LOGD("end of stream");
                        gst_app_src_end_of_stream(GST_APP_SRC(core->appsrc));
                        _mc_wait_for_eos(core);
-                       initiative = true;
+                       initiative = TRUE;
 
-                       _mc_gst_handle_input_buffer_used(core, in_buf);
+                       _mc_gst_handle_input_buffer_used(core, input_buffer);
                        goto LEAVE;
                }
 
-               mcbuffer = _mc_gst_media_packet_to_gstbuffer(core, in_buf, codec_config);
+               mcbuffer = _mc_gst_media_packet_to_gstbuffer(core, input_buffer, codec_config);
                if (!mcbuffer) {
                        LOGW("gstbuffer can't make");
                        goto ERROR;
                }
-               /* mcbuffer took the ownership of the in_buf, so set in_buf to NULL to aviod double unref */
-               in_buf = NULL;
+               /* mcbuffer took the ownership of the input_buffer, so set input_buffer to NULL to aviod double unref */
+               input_buffer = NULL;
 
-               if (codec_config)
-                       initiative = TRUE;
-
-               if (initiative) {
+               if (codec_config || initiative) {
                        GstPad *pad;
-
-                       ret = _mc_gst_update_caps(core, mcbuffer, codec_config);
+                       ret = _mc_set_codec_data(core, mcbuffer);
                        if (ret != MC_ERROR_NONE) {
-                               LOGE("failed to update caps");
-                               /* unref mcbuff->buffer will invoke the finalize() of GstMcBuffer */
+                               LOGE("failed to set codec data");
                                gst_buffer_unref(mcbuffer->buffer);
                                goto ERROR;
                        }
-
                        pad = gst_element_get_static_pad(core->appsrc, "src");
                        gst_pad_push_event(pad, gst_event_new_stream_start("start"));
                        gst_object_unref(pad);
+                       initiative = FALSE;
+               }
 
+               if (is_format_change) {
+                       GstCaps *caps;
+                       caps = core->mc_caps_new(core, core->codec_id, in_port_index);
+                       g_object_set(core->appsrc, "caps", caps, NULL);
+                       gst_caps_unref(caps);
                        LOGD("caps updated");
                }
 
+
                /* inject buffer */
                ret = _mc_gst_gstbuffer_to_appsrc(core, mcbuffer);
                if (ret != GST_FLOW_OK) {
@@ -1307,12 +1280,10 @@ static gpointer feed_task(gpointer data)
                        goto ERROR;
                }
 
-               initiative = false;
-
                continue;
 ERROR:
-               if (in_buf)
-                       _mc_gst_handle_input_buffer_used(core, in_buf);
+               if (input_buffer)
+                       _mc_gst_handle_input_buffer_used(core, input_buffer);
 
                _mc_gst_set_flush_input(core);
 
@@ -1323,13 +1294,13 @@ ERROR:
 
                continue;
 LEAVE:
-               /*LOGE("status : in_buf : %p, codec_config : %d, eos : %d, encoder : %d in feed_task", in_buf, codec_config, eos, core->encoder);*/
+               /*LOGE("status : input_buffer : %p, codec_config : %d, eos : %d, encoder : %d in feed_task", input_buffer, codec_config, eos, core->encoder);*/
                continue;
 
        }
 
-       LOGI("status : in_buf : %p, codec_config : %d, eos : %d, video : %d, encoder : %d in feed_task",
-                       in_buf, codec_config, eos, core->video, core->encoder);
+       LOGI("status : input_buffer : %p, codec_config : %d, eos : %d, video : %d, encoder : %d in feed_task",
+                       input_buffer, codec_config, eos, core->video, core->encoder);
        LOGD("feed task finished %p v(%d)e(%d)", core, core->video, core->encoder);
 
        MEDIACODEC_FLEAVE();
@@ -1360,6 +1331,210 @@ static void __mc_gst_start_feed(GstElement *pipeline, guint size, gpointer data)
        }
 }
 
+GstCaps *_mc_gst_aud_caps_new(mc_gst_core_t *core, mediacodec_codec_type_e codec_id, gint index)
+{
+       GstCaps *caps = NULL;
+       mc_gst_port_def_t *port_def = &core->ports[index]->port_def;
+
+       caps = gst_caps_new_simple(core->mime,
+               "rate", G_TYPE_INT, port_def->info.audio.samplerate,
+               "channels", G_TYPE_INT, port_def->info.audio.channel, NULL);
+
+       switch (codec_id) {
+       case MEDIACODEC_AAC:
+               if (core->encoder) {
+                       gst_caps_set_simple(caps,
+                               "layout", G_TYPE_STRING, "interleaved", NULL);
+                       g_object_set(GST_OBJECT(core->codec), "compliance", -2, NULL);
+               } else {
+                       gst_caps_set_simple(caps,
+                               "framed", G_TYPE_BOOLEAN, TRUE,
+                               "mpegversion", G_TYPE_INT, 4,
+                               "stream-format", G_TYPE_STRING, "adts",
+                               NULL);
+                       LOGD("CAPS for codec_id (MEDIACODEC_AAC_LC - normal ADTS)");
+               }
+               break;
+       case MEDIACODEC_AAC_HE:
+       case MEDIACODEC_AAC_HE_PS:
+               if (core->encoder) {
+                       LOGD("[MC_NOT_SUPPORTED] he-aac-v12 encoder is not supported yet!!!");
+                       return NULL;
+               } else {
+                       gst_caps_set_simple(caps,
+                               "mpegversion", G_TYPE_INT, 4,
+                               "framed", G_TYPE_BOOLEAN, TRUE,
+                               "stream-format", G_TYPE_STRING, "raw",
+                               NULL);
+                       LOGD("CAPS for codec_id (MEDIACODEC_AAC_HE)");
+               }
+               break;
+       case MEDIACODEC_MP3:
+               if (core->encoder) {
+                       LOGD("[MC_NOT_SUPPORTED] mp3 encoder is not supported yet!!!");
+                       return NULL;
+               } else {
+                       gst_caps_set_simple(caps,
+                               "framed", G_TYPE_BOOLEAN, TRUE,
+                               "mpegversion", G_TYPE_INT, 1,       /* To-Do : plz check */
+                               "mpegaudioversion", G_TYPE_INT, 1,  /* To-Do : plz check */
+                               "layer", G_TYPE_INT, 3,             /* To-Do : plz check */
+                               NULL);
+                       LOGD("CAPS for codec_id (MEDIACODEC_MP3)");
+               }
+               break;
+       case MEDIACODEC_AMR_NB:
+               if (core->encoder) {
+                       gst_caps_set_simple(caps,
+                               "format", G_TYPE_STRING, _mc_bit_to_string(port_def->info.audio.bit_depth),
+                               "layout", G_TYPE_STRING, "interleaved",
+                               NULL);
+                       LOGD("CAPS for codec_id (MEDIACODEC_AMR_NB)");
+               } else {
+                       gst_caps_set_simple(caps,
+                               "rate", G_TYPE_INT, 8000,
+                               NULL);
+               }
+               break;
+       case MEDIACODEC_AMR_WB:
+               if (core->encoder) {
+                       LOGD("[MC_NOT_SUPPORTED] amr-wb encoder is not supported yet!!!");
+                       return NULL;
+               } else {
+                       gst_caps_set_simple(caps,
+                               "rate", G_TYPE_INT, 16000,
+                               NULL);
+               }
+               break;
+       case MEDIACODEC_VORBIS:
+               if (core->encoder) {
+                       LOGD("[MC_NOT_SUPPORTED] vorbis encoder is not supported yet!!!");
+                       return NULL;
+               } else {
+               }
+               break;
+       case MEDIACODEC_FLAC:
+               if (core->encoder) {
+                       LOGD("[MC_NOT_SUPPORTED] flac encoder is not supported yet!!!");
+                       return NULL;
+               } else {
+                       gst_caps_set_simple(caps,
+                               "framed", G_TYPE_BOOLEAN, TRUE,
+                               /* FIXME - Insert More Info */
+                               NULL);
+               }
+               break;
+       case MEDIACODEC_WMAV1:
+       case MEDIACODEC_WMAV2:
+       case MEDIACODEC_WMAPRO:
+       case MEDIACODEC_WMALSL:
+               if (core->encoder) {
+                       LOGD("[MC_NOT_SUPPORTED] wma encoder is not supported yet!!!");
+                       return NULL;
+               } else {
+                       /*
+                        * Need to extract from Stream Type Specific ... or
+                        * Need to get Demuxer's Caps from Stream Type Specific
+                        */
+                       guint16 format_tag = 0;
+                       gint wma_version = 0;
+                       gint block_align = 1024;      /*FIXME : Need checking */
+                       gint bitrate = 128000;        /*FIXME : Need checking */
+
+                       LOGD(" ----- WMA Need Additional Caps -----------");
+                       if (core->codec_id == MEDIACODEC_WMAV1) {
+                               format_tag = 352;       /* 0x160 */
+                               wma_version = 1;
+                       } else if (core->codec_id == MEDIACODEC_WMAV2) {
+                               format_tag = 353;       /* 0x161 */
+                               wma_version = 2;
+                       } else if (core->codec_id == MEDIACODEC_WMAPRO) {
+                               format_tag = 354;       /* 0x162 */
+                               wma_version = 3;
+                       } else if (core->codec_id == MEDIACODEC_WMALSL) {
+                               format_tag = 355;       /* 0x163 */
+                               wma_version = 3;
+                       } else {
+                               LOGE("Not support WMA format");
+                       }
+
+                       gst_caps_set_simple(caps,
+                               "bitrate", G_TYPE_INT, bitrate,
+                               "depth", G_TYPE_INT, port_def->info.audio.bit_depth,
+                               /* FIXME - Need More Info */
+                               "wmaversion", G_TYPE_INT, wma_version,
+                               "format_tag", G_TYPE_INT, format_tag,
+                               "block_align", G_TYPE_INT, block_align,
+                               NULL);
+               }
+               break;
+       default:
+               break;
+       }
+       return caps;
+}
+
+GstCaps *_mc_gst_vid_caps_new(mc_gst_core_t *core, mediacodec_codec_type_e codec_id, gint index)
+{
+       GstCaps *caps = NULL;
+       mc_gst_port_def_t *port_def = &core->ports[index]->port_def;
+
+       caps = gst_caps_new_simple(core->mime,
+               "width", G_TYPE_INT, port_def->info.video.width,
+               "height", G_TYPE_INT, port_def->info.video.height,
+               "framerate", GST_TYPE_FRACTION, port_def->info.video.framerate, 1,
+               NULL);
+
+       switch (codec_id) {
+       case MEDIACODEC_H263:
+               if (core->encoder) {
+                       gst_caps_set_simple(caps,
+                               "format", G_TYPE_STRING, port_def->info.video.format,
+                               NULL);
+               } else {
+                       gst_caps_set_simple(caps,
+                               "mpegversion", G_TYPE_INT, 4,
+                               "framerate", GST_TYPE_FRACTION, 30, 1,
+                               NULL);
+               }
+               break;
+       case MEDIACODEC_MPEG4:
+               if (core->encoder) {
+                       gst_caps_set_simple(caps,
+                               "format", G_TYPE_STRING, port_def->info.video.format,
+                               NULL);
+               } else {
+                       gst_caps_set_simple(caps,
+                               "mpegversion", G_TYPE_INT, 4,
+                               "systemstream", G_TYPE_BOOLEAN, false,
+                               "parsed", G_TYPE_BOOLEAN, TRUE,
+                               "framerate", GST_TYPE_FRACTION, 30, 1,
+                               NULL);
+               }
+               break;
+       case MEDIACODEC_H264:
+               if (core->encoder) {
+                       gst_caps_set_simple(caps,
+                               "format", G_TYPE_STRING, port_def->info.video.format,
+                               NULL);
+                       g_object_set(GST_OBJECT(core->codec), "byte-stream", TRUE, NULL);
+                       LOGE("format : %s", port_def->info.video.format);
+               } else {
+                       gst_caps_set_simple(caps,
+                               "parsed", G_TYPE_BOOLEAN, TRUE,                                         /* FIXME different from sw */
+                               "alignment", G_TYPE_STRING, "au",
+                               "stream-format", G_TYPE_STRING, "byte-stream",
+                               "framerate", GST_TYPE_FRACTION, 30, 1,
+                               NULL);
+               }
+               break;
+       default:
+               break;
+       }
+
+       return caps;
+}
+
 static int _mc_link_vtable(mc_gst_core_t *core, mediacodec_codec_type_e id, gboolean encoder, gboolean is_hw)
 {
        MEDIACODEC_FENTER();
@@ -1368,69 +1543,35 @@ static int _mc_link_vtable(mc_gst_core_t *core, mediacodec_codec_type_e id, gboo
 
        switch (id) {
        case MEDIACODEC_AAC:
-               /* if set to 'CODEC_CONFIG', then It is also available case of  MEDIA_FORMAT_AAC_LC (RAW) */
-               LOGD("aac lc (adts) vtable");
                if (encoder) {
                        core->vtable = aenc_aac_vtable;
-                       core->caps = gst_caps_new_simple(core->mime,
-                                       "layout", G_TYPE_STRING, "interleaved", NULL);
-                       g_object_set(GST_OBJECT(core->codec), "compliance", -2, NULL);
                } else {
-                       LOGD("CAPS for codec_id (MEDIACODEC_AAC_LC - normal ADTS)");
-
                        core->vtable = adec_aac_vtable;
-                       core->caps = gst_caps_new_simple(core->mime,
-                                       "framed", G_TYPE_BOOLEAN, TRUE,
-                                       "mpegversion", G_TYPE_INT, 4,
-                                       "stream-format", G_TYPE_STRING, "adts",
-                                       NULL);
                }
                break;
        case MEDIACODEC_AAC_HE:
        case MEDIACODEC_AAC_HE_PS:
-               LOGD("aac he v12 vtable");
                if (encoder) {
                        LOGD("[MC_NOT_SUPPORTED] he-aac-v12 encoder is not supported yet!!!");
                        return MC_NOT_SUPPORTED;
                } else {
-                       LOGD("CAPS for codec_id (MEDIACODEC_AAC_HE and _PS - MP4/M4A case)");
                        core->vtable = adec_aacv12_vtable;
-                       core->caps = gst_caps_new_simple(core->mime,
-                                       "mpegversion", G_TYPE_INT, 4,     /*TODO : need adding version /profile*/
-                                       "framed", G_TYPE_BOOLEAN, TRUE,
-                                       "stream-format", G_TYPE_STRING, "raw",
-                                       NULL);
                }
                break;
        case MEDIACODEC_MP3:
-               LOGD("mp3 vtable - Only support decoder");
                if (encoder) {
                        LOGD("[MC_NOT_SUPPORTED] mp3 encoder is not supported yet!!!");
                        return MC_NOT_SUPPORTED;
                } else {
                        core->vtable = adec_mp3_vtable;
-                       core->caps = gst_caps_new_simple(core->mime,
-                                       "framed", G_TYPE_BOOLEAN, TRUE,
-                                       "mpegversion", G_TYPE_INT, 1,       /* To-Do : plz check */
-                                       "mpegaudioversion", G_TYPE_INT, 1,  /* To-Do : plz check */
-                                       "layer", G_TYPE_INT, 3,             /* To-Do : plz check */
-                                       NULL);
                }
                break;
        case MEDIACODEC_AMR_NB:
                LOGD("amrnb vtable");
                if (encoder) {
                        core->vtable = aenc_amrnb_vtable;
-                       core->caps = gst_caps_new_simple(core->mime,
-                                       "format", G_TYPE_STRING, "S16LE",
-                                       "layout", G_TYPE_STRING, "interleaved",
-                                       NULL);
-
                } else {
                        core->vtable = adec_amrnb_vtable;
-                       core->caps = gst_caps_new_simple(core->mime,
-                                       "rate", G_TYPE_INT, 8000,
-                                       NULL);
                }
                break;
        case MEDIACODEC_AMR_WB:
@@ -1440,9 +1581,6 @@ static int _mc_link_vtable(mc_gst_core_t *core, mediacodec_codec_type_e id, gboo
                        return MC_NOT_SUPPORTED;
                } else {
                        core->vtable = adec_amrwb_vtable;
-                       core->caps = gst_caps_new_simple(core->mime,
-                                       "rate", G_TYPE_INT, 16000,
-                                       NULL);
                }
                break;
        case MEDIACODEC_VORBIS:
@@ -1452,7 +1590,6 @@ static int _mc_link_vtable(mc_gst_core_t *core, mediacodec_codec_type_e id, gboo
                        return MC_NOT_SUPPORTED;
                } else {
                        core->vtable = adec_vorbis_vtable;
-                       core->caps = gst_caps_new_empty_simple("audio/x-vorbis");
                }
                break;
        case MEDIACODEC_FLAC:
@@ -1462,10 +1599,6 @@ static int _mc_link_vtable(mc_gst_core_t *core, mediacodec_codec_type_e id, gboo
                        return MC_NOT_SUPPORTED;
                } else {
                        core->vtable = adec_flac_vtable;
-                       core->caps = gst_caps_new_simple(core->mime,
-                                       "framed", G_TYPE_BOOLEAN, TRUE,
-                                       /* FIXME - Insert More Info */
-                                       NULL);
                }
                break;
        case MEDIACODEC_WMAV1:
@@ -1477,64 +1610,18 @@ static int _mc_link_vtable(mc_gst_core_t *core, mediacodec_codec_type_e id, gboo
                        LOGD("[MC_NOT_SUPPORTED] wma encoder is not supported yet!!!");
                        return MC_NOT_SUPPORTED;
                } else {
-                       mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info;
-
                        core->vtable = adec_wma_vtable;
-
-                       /*
-                        * Need to extract from Stream Type Specific ... or
-                        * Need to get Demuxer's Caps from Stream Type Specific
-                        */
-                       guint16 format_tag = 0;
-                       gint wma_version = 0;
-                       gint block_align = 1024;      /*FIXME : Need checking */
-                       gint bitrate = 128000;        /*FIXME : Need checking */
-
-                       LOGD(" ----- WMA Need Additional Caps -----------");
-                       if (core->codec_id == MEDIACODEC_WMAV1) {
-                               format_tag = 352;       /* 0x160 */
-                               wma_version = 1;
-                       } else if (core->codec_id == MEDIACODEC_WMAV2) {
-                               format_tag = 353;       /* 0x161 */
-                               wma_version = 2;
-                       } else if (core->codec_id == MEDIACODEC_WMAPRO) {
-                               format_tag = 354;       /* 0x162 */
-                               wma_version = 3;
-                       } else if (core->codec_id == MEDIACODEC_WMALSL) {
-                               format_tag = 355;       /* 0x163 */
-                               wma_version = 3;
-                       } else {
-                               LOGE("Not support WMA format");
-                       }
-
-                       core->caps = gst_caps_new_simple(core->mime,
-                                       "bitrate", G_TYPE_INT, bitrate,
-                                       "depth", G_TYPE_INT, dec_info->bit,
-                                       /* FIXME - Need More Info */
-                                       "wmaversion", G_TYPE_INT, wma_version,
-                                       "format_tag", G_TYPE_INT, format_tag,
-                                       "block_align", G_TYPE_INT, block_align,
-                                       NULL);
                }
                break;
        case MEDIACODEC_H263:
                LOGD("h263 vtable");
                if (encoder) {
                        core->vtable = is_hw ? venc_h263_hw_vtable : venc_h263_sw_vtable;
-                       core->caps = gst_caps_new_empty_simple("video/x-raw");
                } else {
                        if (is_hw) {
                                core->vtable = vdec_h263_hw_vtable;
-                               core->caps = gst_caps_new_simple(core->mime,
-                                               "mpegversion", G_TYPE_INT, 4,
-                                               "framerate", GST_TYPE_FRACTION, 30, 1,
-                                               NULL);
                        } else {
                                core->vtable = vdec_h263_sw_vtable;
-                               core->caps = gst_caps_new_simple(core->mime,
-                                               "variant", G_TYPE_STRING, "itu",
-                                               "framerate", GST_TYPE_FRACTION, 30, 1,
-                                               NULL);
                        }
                }
                break;
@@ -1542,47 +1629,25 @@ static int _mc_link_vtable(mc_gst_core_t *core, mediacodec_codec_type_e id, gboo
                LOGD("mpeg4 vtable");
                if (encoder) {
                        core->vtable = is_hw ? venc_mpeg4_hw_vtable : venc_mpeg4_sw_vtable;
-                       core->caps = gst_caps_new_empty_simple("video/x-raw");
                } else {
                        core->vtable = is_hw ? vdec_mpeg4_hw_vtable : vdec_mpeg4_sw_vtable;
-                       core->caps = gst_caps_new_simple(core->mime,
-                                       "mpegversion", G_TYPE_INT, 4,
-                                       "systemstream", G_TYPE_BOOLEAN, false,
-                                       "parsed", G_TYPE_BOOLEAN, TRUE,
-                                       "framerate", GST_TYPE_FRACTION, 30, 1,
-                                       NULL);
                }
                break;
        case MEDIACODEC_H264:
                LOGD("h264 vtable");
                if (encoder) {
                        core->vtable = is_hw ? venc_h264_hw_vtable : venc_vtable;
-                       core->caps = gst_caps_new_empty_simple("video/x-raw");
-                       g_object_set(GST_OBJECT(core->codec), "byte-stream", TRUE, NULL);
                } else {
                        if (is_hw) {
                                core->vtable = vdec_h264_hw_vtable;
-                               core->caps = gst_caps_new_simple(core->mime,
-                                               "parsed", G_TYPE_BOOLEAN, TRUE,
-                                               "alignment", G_TYPE_STRING, "au",
-                                               "stream-format", G_TYPE_STRING, "byte-stream",
-                                               "framerate", GST_TYPE_FRACTION, 30, 1,
-                                               NULL);
                        } else {
                                core->vtable = vdec_h264_sw_vtable;
-                               core->caps = gst_caps_new_simple(core->mime,
-                                               "alignment", G_TYPE_STRING, "au",
-                                               "stream-format", G_TYPE_STRING, "byte-stream",
-                                               "framerate", GST_TYPE_FRACTION, 30, 1,
-                                               NULL);
                        }
                }
                break;
        default:
                break;
        }
-               /* set caps */
-               g_object_set(core->appsrc, "caps", core->caps, NULL);
 
        MEDIACODEC_FLEAVE();
 
@@ -1618,6 +1683,7 @@ mc_ret_e mc_gst_prepare(mc_handle_t *mc_handle)
        media_format_mimetype_e out_mime;
        int num_supported_codec = 0;
        int i = 0;
+       GstCaps *caps = NULL;
 
        if (!mc_handle)
                return MC_PARAM_ERROR;
@@ -1655,9 +1721,11 @@ mc_ret_e mc_gst_prepare(mc_handle_t *mc_handle)
        new_core->eos = false;
        new_core->encoder = encoder;
        new_core->video = video;
-       new_core->codec_info = encoder ? (void *)&mc_handle->info.encoder : (void *)&mc_handle->info.decoder;
-       new_core->out_mime = codec_map[i].type.out_format;
+       memcpy(&new_core->ports[in_port_index]->port_def.info, &mc_handle->info, sizeof(mc_handle->info));
+       memcpy(&new_core->ports[out_port_index]->port_def.info, &mc_handle->info, sizeof(mc_handle->info));
+       new_core->ports[out_port_index]->port_def.coding_type = out_mime;
        new_core->codec_id = id;
+       new_core->mc_caps_new = video ? &_mc_gst_vid_caps_new : &_mc_gst_aud_caps_new;
 
        new_core->bufmgr = tbm_bufmgr_init(new_core->drm_fd);
        if (new_core->bufmgr == NULL) {
@@ -1684,8 +1752,6 @@ mc_ret_e mc_gst_prepare(mc_handle_t *mc_handle)
                }
        }
 
-       mc_handle->core = new_core;
-
        /* create basic core elements */
        ret = _mc_gst_create_pipeline(mc_handle->core, factory_name);
        if (ret != MC_ERROR_NONE) {
@@ -1700,6 +1766,22 @@ mc_ret_e mc_gst_prepare(mc_handle_t *mc_handle)
                return ret;
        }
 
+       /* set caps in capsfilter as default*/
+       caps = new_core->mc_caps_new(new_core, id, out_port_index);
+
+       /* FIXME will parse input format from ini. format is needed when linking elements*/
+       if (new_core->video && new_core->encoder) {
+               gchar *format = NULL;
+
+               format = new_core->is_hw ? "SN12" : "I420";
+               gst_caps_set_simple(caps,
+                       "format", G_TYPE_STRING, format,
+                       NULL);
+       }
+       g_object_set(new_core->capsfilter, "caps", caps, NULL);
+       gst_caps_unref(caps);
+
+       mc_handle->core = new_core;
        LOGD("initialized... %d", ret);
        MEDIACODEC_FLEAVE();
 
@@ -2009,6 +2091,28 @@ mc_ret_e _mc_gst_create_pipeline(mc_gst_core_t *core, gchar *factory_name)
                                LOGE("capsfilter can't create");
                                goto ERROR;
                        }
+
+                       core->audioresample = gst_element_factory_make("audioresample", NULL);
+
+                       if (!core->audioresample) {
+                               LOGE("capsfilter can't create");
+                               goto ERROR;
+                       }
+               }
+
+               if (core->video && core->encoder) {
+                       core->videoconvert = gst_element_factory_make("videoconvert", NULL);
+
+                       if (!core->videoconvert) {
+                               LOGE("videoconvert can't create");
+                               goto ERROR;
+                       }
+
+                       core->videoscale = gst_element_factory_make("videoscale", NULL);
+                       if (!core->videoscale) {
+                               LOGE("videoscale can't create");
+                               goto ERROR;
+                       }
                }
 
                core->capsfilter = gst_element_factory_make("capsfilter", NULL);
@@ -2028,10 +2132,18 @@ mc_ret_e _mc_gst_create_pipeline(mc_gst_core_t *core, gchar *factory_name)
 
                /*__mc_link_elements(core);*/
                if (!core->video && core->encoder) {
-                       gst_bin_add_many(GST_BIN(core->pipeline), core->appsrc, core->capsfilter, core->audioconvert, core->codec, core->fakesink, NULL);
+                       gst_bin_add_many(GST_BIN(core->pipeline), core->appsrc, core->audioresample, core->audioconvert, core->capsfilter, core->codec, core->fakesink, NULL);
 
                        /* link elements */
-                       if (!(gst_element_link_many(core->appsrc, core->capsfilter, core->audioconvert, core->codec, core->fakesink, NULL))) {
+                       if (!(gst_element_link_many(core->appsrc, core->audioresample, core->audioconvert, core->capsfilter, core->codec, core->fakesink, NULL))) {
+                               LOGE("gst_element_link_many is failed");
+                               goto ERROR;
+                       }
+               } else if (core->video && core->encoder) {
+                       gst_bin_add_many(GST_BIN(core->pipeline), core->appsrc, core->capsfilter, core->codec, core->fakesink, NULL);
+
+                       /* link elements */
+                       if (!(gst_element_link_many(core->appsrc, core->codec, core->fakesink, NULL))) {
                                LOGE("gst_element_link_many is failed");
                                goto ERROR;
                        }
@@ -2089,6 +2201,15 @@ ERROR:
        if (core->capsfilter)
                gst_object_unref(GST_OBJECT(core->capsfilter));
 
+       if (core->audioresample)
+               gst_object_unref(GST_OBJECT(core->audioresample));
+
+       if (core->videoscale)
+               gst_object_unref(GST_OBJECT(core->videoscale));
+
+       if (core->videoconvert)
+               gst_object_unref(GST_OBJECT(core->videoconvert));
+
        if (core->audioconvert)
                gst_object_unref(GST_OBJECT(core->audioconvert));
 
@@ -2263,16 +2384,9 @@ int __mc_output_buffer_finalize_cb(media_packet_h packet, int error_code, void *
        return MEDIA_PACKET_FINALIZE;
 }
 
-gchar *__mc_get_gst_input_format(media_packet_h packet, bool is_hw)
+gchar *__mc_get_gst_input_format(media_format_mimetype_e mimetype, bool is_hw)
 {
        gchar *format = NULL;
-       media_format_h fmt = NULL;
-       media_format_mimetype_e mimetype = 0;
-
-       media_packet_get_format(packet, &fmt);
-       media_format_get_video_info(fmt, &mimetype, NULL, NULL, NULL, NULL);
-       media_format_unref(fmt);
-       LOGD("input packet mimetype : %x", mimetype);
 
        switch (mimetype) {
        case MEDIA_FORMAT_I420:
@@ -3409,29 +3523,19 @@ mc_ret_e mc_gst_get_packet_pool(mc_handle_t *mc_handle, media_packet_pool_h *pac
        mime_format = _mc_get_mime(core);
 
        if (core->video) {
-               if (core->encoder) {
-                       media_format_set_video_mime(fmt_handle, mime_format);
-                       media_format_set_video_width(fmt_handle, mc_handle->info.encoder.width);
-                       media_format_set_video_height(fmt_handle, mc_handle->info.encoder.height);
-                       media_format_set_video_avg_bps(fmt_handle, mc_handle->info.encoder.bitrate);
-               } else {
-                       media_format_set_video_mime(fmt_handle, mime_format);
-                       media_format_set_video_width(fmt_handle, mc_handle->info.decoder.width);
-                       media_format_set_video_height(fmt_handle, mc_handle->info.decoder.height);
-               }
+               media_format_set_video_mime(fmt_handle, mime_format);
+               media_format_set_video_width(fmt_handle, mc_handle->info.video.width);
+               media_format_set_video_height(fmt_handle, mc_handle->info.video.height);
 
+               if (core->encoder)
+                       media_format_set_video_avg_bps(fmt_handle, mc_handle->info.video.bitrate);
        } else {
-               if (core->encoder) {
                        media_format_set_audio_mime(fmt_handle, mime_format);
-                       media_format_set_audio_channel(fmt_handle, mc_handle->info.encoder.channel);
-                       media_format_set_audio_samplerate(fmt_handle, mc_handle->info.encoder.samplerate);
-                       media_format_set_audio_bit(fmt_handle, mc_handle->info.encoder.bit);
-               } else {
-                       media_format_set_audio_mime(fmt_handle, mime_format);
-                       media_format_set_audio_channel(fmt_handle, mc_handle->info.decoder.channel);
-                       media_format_set_audio_samplerate(fmt_handle, mc_handle->info.decoder.samplerate);
-                       media_format_set_audio_bit(fmt_handle, mc_handle->info.decoder.bit);
-               }
+                       media_format_set_audio_channel(fmt_handle, mc_handle->info.audio.channel);
+                       media_format_set_audio_samplerate(fmt_handle, mc_handle->info.audio.samplerate);
+                       media_format_set_audio_bit(fmt_handle, mc_handle->info.audio.bit_depth);
+               if (core->encoder)
+                       media_format_set_audio_avg_bps(fmt_handle, mc_handle->info.audio.bitrate);
        }
 
        ret = media_packet_pool_set_media_format(pool, fmt_handle);

diff --git a/test/media_codec_test.c b/test/media_codec_test.c
index 5b592f5..dc46195 100644 (file)
--- a/test/media_codec_test.c
+++ b/test/media_codec_test.c
@@ -799,6 +799,7 @@ int  _configure(App *app, int codecid, int flag, gboolean *hardware, media_forma
                if (encoder) {
                        extractor = amrenc_extractor;
                        mime = MEDIA_FORMAT_PCM_F32LE;  /* FIXME need to check according to verdor */
+                       *codec_mime = MEDIA_FORMAT_AMR_NB;
                        app->is_amr_nb = TRUE;
                } else {
                        extractor = amrdec_extractor;
@@ -1408,6 +1409,7 @@ void _mediacodec_prepare(App *app, gboolean frame_all)
                media_format_set_video_width(fmt, app->width);
                media_format_set_video_height(fmt, app->height);
                media_format_set_video_avg_bps(fmt, app->target_bits);
+               media_format_set_video_frame_rate(fmt, app->fps);
 
                media_format_create(&codec_format);
                media_format_set_video_mime(codec_format, codec_mime);
@@ -1985,30 +1987,33 @@ void displaymenu(void)
                g_print("*** input mediapath.\n");
        } else if (g_menu_state == CURRENT_STATUS_SET_CODEC) {
                g_print("*** Codec id : Select Codec ID Numbe  (e.g. AAC_LC = 96)\n");
-               g_print("               L16    =  16 (0x10)\n");
-               g_print("               ALAW   =  32 (0x20)\n");
-               g_print("               ULAW   =  48 (0x30)\n");
-               g_print("               AMR_NB =  64 (0x40)\n");
-               g_print("               AMR_WB =  65 (0x41)\n");
-               g_print("               G729   =  80 (0x50)\n");
-               g_print("               AAC_LC =  96 (0x60)\n");
-               g_print("               AAC_HE =  97 (0x61)\n");
-               g_print("               AAC_PS =  98 (0x62)\n");
-               g_print("               MP3    = 112 (0x70)\n");
-               g_print("               VORBIS = 128 (0x80)\n");
-               g_print("               FLAC   = 144 (0x90)\n");
-               g_print("               WMAV1  = 160 (0xA0)\n");
-               g_print("               WMAV2  = 161 (0xA1)\n");
-               g_print("               WMAPRO = 162 (0xA2)\n");
-               g_print("               WMALSL = 163 (0xA3)\n");
+               g_print("               L16    =  0\n");
+               g_print("               ALAW   =  1\n");
+               g_print("               ULAW   =  2\n");
+               g_print("               AMR_NB =  3\n");
+               g_print("               AMR_WB =  4\n");
+               g_print("               G729   =  5\n");
+               g_print("               AAC_LC =  6\n");
+               g_print("               AAC_HE =  7\n");
+               g_print("               AAC_PS =  8\n");
+               g_print("               MP3    =  9\n");
+               g_print("               VORBIS =  10\n");
+               g_print("               FLAC   =  11\n");
+               g_print("               WMAV1  =  12\n");
+               g_print("               WMAV2  =  13\n");
+               g_print("               WMAPRO =  14\n");
+               g_print("               WMALSL =  15\n");
                g_print("               -------------------\n");
-               g_print("               H261   = 101\n");
-               g_print("               H263   = 102\n");
-               g_print("               H264   = 103\n");
-               g_print("               MJPEG  = 104\n");
-               g_print("               MPEG1  = 105\n");
-               g_print("               MPEG2  = 106\n");
-               g_print("               MPEG4  = 107\n");
+               g_print("               H261   =  16\n");
+               g_print("               H263   =  17\n");
+               g_print("               H264   =  18\n");
+               g_print("               MJPEG  =  19\n");
+               g_print("               MPEG1  =  20\n");
+               g_print("               MPEG2  =  21\n");
+               g_print("               MPEG4  =  22\n");
+               g_print("               HEVC   =  23\n");
+               g_print("               VP8    =  24\n");
+               g_print("               VP9    =  25\n");
                g_print("               -------------------\n");
                g_print("*** Flags : Select Combination Number (e.g. DEOCDER + TYPE_SW = 10)\n");
                g_print("               CODEC : ENCODER =  1       DECODER =  2\n");
@@ -2046,6 +2051,7 @@ void interpret(char *cmd)
 {
        App *app = &s_app;
        gint tmp = 0;
+       static gint cnt = 0;
 
        switch (g_menu_state) {
        case CURRENT_STATUS_MAINMENU:
@@ -2057,111 +2063,83 @@ void interpret(char *cmd)
                break;
        case CURRENT_STATUS_SET_CODEC:
        {
-               static gint cnt = 0;
-               gchar **ptr = NULL;
-               switch (cnt) {
-               case 0:
-                       tmp = atoi(cmd);
+               gint ids[] = { 0x1010, 0x1020, 0x1030, 0x1040, 0x1041, 0x1050, 0x1060, 0x1061, 0x1062,
+                                               0x1070, 0x1080, 0x1090, 0x10A0, 0x10A1, 0x10A2, 0x10A3, 0x2010, 0x2020,
+                                               0x2030, 0x2040, 0x2050, 0x2060, 0x2070, 0x2080, 0x2090, 0x20A0, 0x20B0 };
 
-                       if (tmp > 100 &&
-                               (tmp != 112) &&
-                               (tmp != 128) &&
-                               (tmp != 144) &&
-                               (tmp != 160) && (tmp != 161) && (tmp != 162) && (tmp != 163)) {
-                                       tmp = strtol(cmd, ptr, 16);
-                                       app->codecid = 0x2000 + ((tmp & 0xFF) << 4);
-                       } else
-                               app->codecid = 0x1000 + tmp;
+               if (cnt == 0) {
+                       gint n_sizes = G_N_ELEMENTS(ids);
 
+                       tmp = atoi(cmd);
+                       if (tmp < 0 || tmp >= n_sizes - 1) {
+                               cnt = 0;
+                               g_print("Invalid value\n");
+                               reset_menu_state();
+                               break;
+                       }
+                       app->codecid = ids[tmp];
                        cnt++;
-                       break;
-               case 1:
+               } else if (cnt == 1) {
                        app->flag = atoi(cmd);
                        cnt = 0;
                        reset_menu_state();
-                       break;
-               default:
-                       break;
                }
        }
        break;
        case CURRENT_STATUS_SET_VDEC_INFO:
        {
-               static gint cnt = 0;
-               switch (cnt) {
-               case 0:
+               if (cnt == 0) {
                        app->width = atoi(cmd);
                        cnt++;
-                       break;
-               case 1:
+               } else if (cnt == 1) {
                        app->height = atoi(cmd);
                        app->type = VIDEO_DEC;
 
                        reset_menu_state();
                        cnt = 0;
-                       break;
-               default:
-                       break;
                }
        }
        break;
        case CURRENT_STATUS_SET_VENC_INFO:
        {
-               static gint cnt = 0;
-               switch (cnt) {
-               case 0:
-                       app->width = atoi(cmd);
+               if (cnt == 0) {
+                       app->width = atol(cmd);
                        cnt++;
-                       break;
-               case 1:
-                       app->height = atoi(cmd);
+               } else if (cnt == 1) {
+                       app->height = atol(cmd);
                        cnt++;
-                       break;
-               case 2:
+               } else if (cnt == 2) {
                        app->fps = atol(cmd);
                        cnt++;
-                       break;
-               case 3:
-                       app->target_bits = atoi(cmd);
+               } else if (cnt == 3) {
+                       app->target_bits = atol(cmd);
                        app->type = VIDEO_ENC;
 
                        reset_menu_state();
                        cnt = 0;
-                       break;
-               default:
-                       break;
                }
        }
        break;
        case CURRENT_STATUS_SET_ADEC_INFO:
        {
-               static gint cnt = 0;
-               switch (cnt) {
-               case 0:
+               if (cnt == 0) {
                        app->samplerate = atoi(cmd);
                        cnt++;
-                       break;
-               case 1:
+               } else if (cnt == 1) {
                        app->channel = atoi(cmd);
                        cnt++;
-                       break;
-               case 2:
+               } else if (cnt == 2) {
                        app->bit = atoi(cmd);
                        app->type = AUDIO_DEC;
 
                        reset_menu_state();
                        cnt = 0;
-                       break;
-               default:
-                       break;
                }
        }
        break;
        case CURRENT_STATUS_SET_AENC_INFO:
        {
-               static int cnt = 0;
-               switch (cnt) {
-               case 0:
+               if (cnt == 0) {
                        tmp = atoi(cmd);
 
                        if (tmp <= 0 || tmp > 96000) {
@@ -2171,8 +2149,7 @@ void interpret(char *cmd)
                        }
                        app->samplerate = tmp;
                        cnt++;
-                       break;
-               case 1:
+               } else if (cnt == 1) {
                        tmp = atoi(cmd);
 
                        if (tmp <= 0 || tmp > 6) {
@@ -2182,8 +2159,7 @@ void interpret(char *cmd)
                        }
                        app->channel = tmp;
                        cnt++;
-                       break;
-               case 2:
+               } else if (cnt == 2) {
                        tmp = atoi(cmd);
 
                        if (tmp <= 0 || tmp > 32) {
@@ -2193,8 +2169,7 @@ void interpret(char *cmd)
                        }
                        app->bit = tmp;
                        cnt++;
-                       break;
-               case 3:
+               } else if (cnt == 3) {
                        tmp = atoi(cmd);
 
                        if (tmp <= 0 || tmp >= INT_MAX) {
@@ -2207,9 +2182,6 @@ void interpret(char *cmd)
 
                        reset_menu_state();
                        cnt = 0;
-                       break;
-               default:
-                       break;
                }
        }
        break;
@@ -2237,22 +2209,16 @@ void interpret(char *cmd)
        case CURRENT_STATUS_AUTO_TEST:
        {
                int len;
-               static int cnt = 0;
-               switch (cnt) {
-               case 0:
+               if (cnt == 0) {
                        len = strlen(cmd);
                        strncpy(app->filepath, cmd, len + 1);
                        g_print("%s, %d\n", app->filepath, len);
                        cnt++;
-                       break;
-               case 1:
+               } else if (cnt == 1) {
                        app->is_video =  atoi(cmd) ? 1 : 0;
                        _mediacodec_auto_test(app, app->filepath);
                        reset_menu_state();
                        cnt = 0;
-                       break;
-               default:
-                       break;
                }
        }
        break;