mjpeg preview support for usb camera in tv platform

Change-Id: I4732c7f1f1746b0621f3e975b9a19bacb4a9b1e4

diff --git a/packaging/libmm-camcorder.spec b/packaging/libmm-camcorder.spec
index df0fb2d..0b6ddbe 100644 (file)
--- a/packaging/libmm-camcorder.spec
+++ b/packaging/libmm-camcorder.spec
@@ -1,6 +1,6 @@
 Name:       libmm-camcorder
 Summary:    Camera and recorder library
-Version:    0.10.194
+Version:    0.10.195
 Release:    0
 Group:      Multimedia/Libraries
 License:    Apache-2.0

diff --git a/src/mm_camcorder_gstcommon.c b/src/mm_camcorder_gstcommon.c
index cd7b0ac..048c2d7 100644 (file)
--- a/src/mm_camcorder_gstcommon.c
+++ b/src/mm_camcorder_gstcommon.c
@@ -104,7 +104,7 @@ gboolean    videocodec_fileformat_compatibility_table[MM_VIDEO_CODEC_NUM][MM_FILE_F
 /*H262*/         { 0,  0,  0,       0,  0,  0,  0, 0,   0,  0,  0,  0,   0, 0,  0,  0,  0,   0,  0,  0,      0,  0,  0,  0,   0,   0},
 /*H263V2*/       { 0,  0,  0,       0,  0,  0,  0, 0,   0,  0,  0,  0,   0, 0,  0,  0,  0,   0,  0,  0,      0,  0,  0,  0,   0,   0},
 /*H263V3*/       { 0,  0,  0,       0,  0,  0,  0, 0,   0,  0,  0,  0,   0, 0,  0,  0,  0,   0,  0,  0,      0,  0,  0,  0,   0,   0},
-/*MJPEG*/        { 0,  0,  0,       0,  0,  0,  0, 0,   0,  0,  0,  0,   0, 0,  0,  0,  0,   0,  0,  0,      0,  0,  0,  0,   0,   0},
+/*MJPEG*/        { 0,  0,  1,       1,  0,  0,  0, 0,   0,  0,  0,  0,   0, 0,  0,  0,  0,   0,  0,  0,      0,  0,  0,  0,   0,   0},
 /*MPEG2*/        { 0,  0,  0,       0,  0,  0,  0, 0,   0,  0,  0,  0,   0, 0,  0,  0,  0,   0,  0,  0,      0,  0,  0,  0,   0,   0},
 /*MPEG4_SIMPLE*/ { 0,  0,  0,       0,  0,  0,  0, 0,   0,  0,  0,  0,   0, 0,  0,  0,  0,   0,  0,  0,      0,  0,  0,  0,   0,   0},
 /*MPEG4_ADV*/    { 0,  0,  0,       0,  0,  0,  0, 0,   0,  0,  0,  0,   0, 0,  0,  0,  0,   0,  0,  0,      0,  0,  0,  0,   0,   0},
@@ -154,7 +154,7 @@ static GstPadProbeReturn __mmcamcorder_video_dataprobe_preview(GstPad *pad, GstP
 static GstPadProbeReturn __mmcamcorder_video_dataprobe_push_buffer_to_record(GstPad *pad, GstPadProbeInfo *info, gpointer u_data);
 static int __mmcamcorder_get_amrnb_bitrate_mode(int bitrate);
 static guint32 _mmcamcorder_convert_fourcc_string_to_value(const gchar* format_name);
-
+static inline bool __mmcamcorder_is_encoded_preview_pixel_format(int pixel_format);
 #ifdef _MMCAMCORDER_PRODUCT_TV
 static bool __mmcamcorder_find_max_resolution(MMHandleType handle, gint *max_width, gint *max_height);
 #endif /* _MMCAMCORDER_PRODUCT_TV */
@@ -325,60 +325,93 @@ int _mmcamcorder_create_preview_elements(MMHandleType handle)
                }
        }
 
-       /* make demux and decoder for H264 stream from videosrc */
-       if (sc->info_image->preview_format == MM_PIXEL_FORMAT_ENCODED_H264 && display_surface_type != MM_DISPLAY_SURFACE_NULL) {
-               int preview_bitrate = 0;
-               int gop_interval = 0;
-               const char *videodecoder_name = NULL;
-
+       if (__mmcamcorder_is_encoded_preview_pixel_format(sc->info_image->preview_format)) {
                /* get recreate_decoder flag */
                _mmcamcorder_conf_get_value_int(handle, hcamcorder->conf_main,
                        CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
                        "RecreateDecoder",
                        &hcamcorder->recreate_decoder);
+       }
 
-               /* get video decoder element and name for H.264 format */
-               _mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
-                       CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
-                       "VideodecoderElementH264",
-                       &sc->VideodecoderElementH264);
-
-               _mmcamcorder_conf_get_value_element_name(sc->VideodecoderElementH264, &videodecoder_name);
-
-               if (videodecoder_name) {
-                       _mmcam_dbg_log("video decoder element [%s], recreate decoder %d",
-                               videodecoder_name, hcamcorder->recreate_decoder);
-#ifdef _MMCAMCORDER_RM_SUPPORT
-                       if (hcamcorder->request_resources.category_id[0] == RM_CATEGORY_VIDEO_DECODER_SUB)
-                               decoder_index = 1;
-
-                       snprintf(decoder_name, sizeof(decoder_name)-1, "%s%d", videodecoder_name, decoder_index);
-                       _mmcam_dbg_log("encoded preview decoder_name %s", decoder_name);
-                       /* create decoder element */
-                       _MMCAMCORDER_ELEMENT_MAKE(sc, sc->element, _MMCAMCORDER_VIDEOSRC_DECODE, decoder_name, "videosrc_decode", element_list, err);
-#else /* _MMCAMCORDER_RM_SUPPORT */
-                       /* create decoder element */
-                       _MMCAMCORDER_ELEMENT_MAKE(sc, sc->element, _MMCAMCORDER_VIDEOSRC_DECODE, videodecoder_name, "videosrc_decode", element_list, err);
-#endif /* _MMCAMCORDER_RM_SUPPORT */
-                       _mmcamcorder_conf_set_value_element_property(sc->element[_MMCAMCORDER_VIDEOSRC_DECODE].gst, sc->VideodecoderElementH264);
-               } else {
-                       _mmcam_dbg_err("failed to get video decoder element name from %p", sc->VideodecoderElementH264);
-                       goto pipeline_creation_error;
-               }
-
-               /* set encoded preview bitrate and iframe interval */
+       if (sc->info_image->preview_format == MM_PIXEL_FORMAT_ENCODED_H264) {
+               int preview_bitrate = 0;
+               int gop_interval = 0;
                mm_camcorder_get_attributes(handle, NULL,
                        MMCAM_ENCODED_PREVIEW_BITRATE, &preview_bitrate,
                        MMCAM_ENCODED_PREVIEW_GOP_INTERVAL, &gop_interval,
                        NULL);
 
+               /* set encoded preview bitrate */
                if (!_mmcamcorder_set_encoded_preview_bitrate(handle, preview_bitrate))
                        _mmcam_dbg_warn("_mmcamcorder_set_encoded_preview_bitrate failed");
 
+               /* set encoded preview iframe interval */
                if (!_mmcamcorder_set_encoded_preview_gop_interval(handle, gop_interval))
                        _mmcam_dbg_warn("_mmcamcorder_set_encoded_preview_gop_interval failed");
        }
 
+       if (display_surface_type != MM_DISPLAY_SURFACE_NULL) {
+               const char *videodecoder_name = NULL;
+               /* case of decoder element */
+               if (sc->info_image->preview_format == MM_PIXEL_FORMAT_ENCODED_H264) {
+                       /* get video decoder element and name for H.264 format */
+                       _mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
+                               CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
+                               "VideodecoderElementH264",
+                               &sc->VideodecoderElementH264);
+                       _mmcamcorder_conf_get_value_element_name(sc->VideodecoderElementH264,
+                               &videodecoder_name);
+                       if (videodecoder_name) {
+#ifdef _MMCAMCORDER_RM_SUPPORT
+                               if (hcamcorder->request_resources.category_id[0] == RM_CATEGORY_VIDEO_DECODER_SUB)
+                                       decoder_index = 1;
+
+                               snprintf(decoder_name, sizeof(decoder_name)-1, "%s%d", videodecoder_name, decoder_index);
+                               _mmcam_dbg_log("encoded preview decoder_name [%s], video decoder element [%s]",
+                                       decoder_name, videodecoder_name);
+                               /* create decoder element */
+                               _MMCAMCORDER_ELEMENT_MAKE(sc, sc->element, _MMCAMCORDER_VIDEOSRC_DECODE, decoder_name, "videosrc_decode", element_list, err);
+#else /* _MMCAMCORDER_RM_SUPPORT */
+                               _mmcam_dbg_log("video decoder element [%s]", videodecoder_name);
+                               /* create decoder element */
+                               _MMCAMCORDER_ELEMENT_MAKE(sc, sc->element, _MMCAMCORDER_VIDEOSRC_DECODE, videodecoder_name, "videosrc_decode", element_list, err);
+#endif /* _MMCAMCORDER_RM_SUPPORT */
+                               _mmcamcorder_conf_set_value_element_property(sc->element[_MMCAMCORDER_VIDEOSRC_DECODE].gst, sc->VideodecoderElementH264);
+                       } else {
+                               _mmcam_dbg_err("failed to get video decoder element name from %p", sc->VideodecoderElementH264);
+                               goto pipeline_creation_error;
+                       }
+               } else if (sc->info_image->preview_format == MM_PIXEL_FORMAT_ENCODED_MJPEG) {
+#ifdef _MMCAMCORDER_RM_SUPPORT
+                       /* get video decoder element and name for MJPEG format */
+                       _mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
+                               CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
+                               "VideodecoderElementH264",
+                               &sc->VideodecoderElementH264);
+                       _mmcamcorder_conf_get_value_element_name(sc->VideodecoderElementH264,
+                               &videodecoder_name);
+                       if (videodecoder_name) {
+                               if (hcamcorder->request_resources.category_id[0] == RM_CATEGORY_VIDEO_DECODER)
+                                       snprintf(decoder_name, sizeof(decoder_name)-1, "%s", "omx_uhd_mjpegdec");
+                               else
+                                       snprintf(decoder_name, sizeof(decoder_name)-1, "%s", "omx_mjpegdec");
+                               _mmcam_dbg_log("encoded preview decoder_name [%s], video decoder element [%s]",
+                                       decoder_name, videodecoder_name);
+                               /* create decoder element */
+                               _MMCAMCORDER_ELEMENT_MAKE(sc, sc->element, _MMCAMCORDER_VIDEOSRC_DECODE, decoder_name, "videosrc_decode", element_list, err);
+                               _mmcamcorder_conf_set_value_element_property(sc->element[_MMCAMCORDER_VIDEOSRC_DECODE].gst, sc->VideodecoderElementH264);
+                       } else {
+                               _mmcam_dbg_err("failed to get video decoder element name from %p", sc->VideodecoderElementH264);
+                               goto pipeline_creation_error;
+                       }
+#else /* _MMCAMCORDER_RM_SUPPORT */
+                       _mmcam_dbg_log("video decoder element [jpegdec]");
+                       /* create decoder element */
+                       _MMCAMCORDER_ELEMENT_MAKE(sc, sc->element, _MMCAMCORDER_VIDEOSRC_DECODE, "jpegdec", "videosrc_decode", element_list, err);
+#endif /* _MMCAMCORDER_RM_SUPPORT */
+               }
+       }
+
        _mmcam_dbg_log("Current mode[%d]", hcamcorder->type);
 
        /* Get videosink name */
@@ -855,7 +888,7 @@ int _mmcamcorder_create_encodesink_bin(MMHandleType handle, MMCamcorderEncodebin
 
                /* set capsfilter */
                if (profile == MM_CAMCORDER_ENCBIN_PROFILE_VIDEO) {
-                       if (sc->info_image->preview_format == MM_PIXEL_FORMAT_ENCODED_H264) {
+                       if (__mmcamcorder_is_encoded_preview_pixel_format(sc->info_image->preview_format)) {
                                _mmcam_dbg_log("get pad from videosrc_filter");
                                pad = gst_element_get_static_pad(sc->element[_MMCAMCORDER_VIDEOSRC_FILT].gst, "src");
                        } else {
@@ -990,7 +1023,7 @@ int _mmcamcorder_create_encodesink_bin(MMHandleType handle, MMCamcorderEncodebin
                        goto pipeline_creation_error;
                }
 
-               if (sc->info_image->preview_format == MM_PIXEL_FORMAT_ENCODED_H264) {
+               if (__mmcamcorder_is_encoded_preview_pixel_format(sc->info_image->preview_format)) {
                        /* set dummy element */
                        gst_element_venc_name = "identity";
                } else {
@@ -1312,7 +1345,7 @@ int _mmcamcorder_create_preview_pipeline(MMHandleType handle)
        }
 
        /* set dataprobe for video recording */
-       if (sc->info_image->preview_format == MM_PIXEL_FORMAT_ENCODED_H264)
+       if (__mmcamcorder_is_encoded_preview_pixel_format(sc->info_image->preview_format))
                srcpad = gst_element_get_static_pad(sc->element[_MMCAMCORDER_VIDEOSRC_QUE].gst, "src");
        else
                srcpad = gst_element_get_static_pad(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "src");
@@ -1724,7 +1757,7 @@ static GstPadProbeReturn __mmcamcorder_video_dataprobe_preview(GstPad *pad, GstP
                GstMemory *memory = NULL;
                GstMapInfo mapinfo;
 
-               if (sc->info_image->preview_format != MM_PIXEL_FORMAT_ENCODED_H264) {
+               if (!__mmcamcorder_is_encoded_preview_pixel_format(sc->info_image->preview_format)) {
                        state = _mmcamcorder_get_state((MMHandleType)hcamcorder);
                        if (state < MM_CAMCORDER_STATE_PREPARE) {
                                _mmcam_dbg_warn("Not ready for stream callback");
@@ -1748,6 +1781,8 @@ static GstPadProbeReturn __mmcamcorder_video_dataprobe_preview(GstPad *pad, GstP
 
                if (sc->info_image->preview_format == MM_PIXEL_FORMAT_ENCODED_H264) {
                        stream.format = MM_PIXEL_FORMAT_ENCODED_H264;
+               } else if (sc->info_image->preview_format == MM_PIXEL_FORMAT_ENCODED_MJPEG) {
+                       stream.format = MM_PIXEL_FORMAT_ENCODED_MJPEG;
                } else {
                        string_format = gst_structure_get_string(structure, "format");
                        if (string_format == NULL) {
@@ -1775,7 +1810,7 @@ static GstPadProbeReturn __mmcamcorder_video_dataprobe_preview(GstPad *pad, GstP
                }
 
                /* set size and timestamp */
-               if (sc->info_image->preview_format == MM_PIXEL_FORMAT_ENCODED_H264)
+               if (__mmcamcorder_is_encoded_preview_pixel_format(sc->info_image->preview_format))
                        memory = gst_buffer_get_all_memory(buffer);
                else
                        memory = gst_buffer_peek_memory(buffer, 0);
@@ -1918,6 +1953,16 @@ static GstPadProbeReturn __mmcamcorder_video_dataprobe_preview(GstPad *pad, GstP
                                        stream.data.encoded.data,
                                        stream.data.encoded.length_data,
                                        stream.data.encoded.is_delta_frame);
+
+                               */
+                               break;
+                       case MM_PIXEL_FORMAT_ENCODED_MJPEG:
+                               stream.data_type = MM_CAM_STREAM_DATA_ENCODED;
+                               stream.data.encoded.data = mapinfo.data;
+                               stream.data.encoded.length_data = stream.length_total;
+                               /*
+                               _mmcam_dbg_log("MJPEG[num_planes:%d] [0]p:%p,size:%d",
+                                       stream.num_planes, stream.data.encoded.data, stream.data.encoded.length_data);
                                */
                                break;
                        case MM_PIXEL_FORMAT_INVZ:
@@ -1968,7 +2013,7 @@ static GstPadProbeReturn __mmcamcorder_video_dataprobe_preview(GstPad *pad, GstP
                /* unmap memory */
                if (mapinfo.data)
                        gst_memory_unmap(memory, &mapinfo);
-               if (sc->info_image->preview_format == MM_PIXEL_FORMAT_ENCODED_H264)
+               if (__mmcamcorder_is_encoded_preview_pixel_format(sc->info_image->preview_format))
                        gst_memory_unref(memory);
        }
 
@@ -2667,8 +2712,9 @@ bool _mmcamcorder_set_videosrc_caps(MMHandleType handle, unsigned int fourcc, in
                        gst_structure_get_int(structure, "rotate", &caps_rotate);
 
 #ifdef _MMCAMCORDER_PRODUCT_TV
-                       if (sc->info_image->preview_format == MM_PIXEL_FORMAT_ENCODED_H264) {
-                               if (set_width == caps_width && set_height == caps_height && set_rotate == caps_rotate && fps == caps_fps) {
+                       if (__mmcamcorder_is_encoded_preview_pixel_format(sc->info_image->preview_format)) {
+                               if (set_width == caps_width && set_height == caps_height &&
+                                       set_rotate == caps_rotate && fps == caps_fps) {
                                        _mmcam_dbg_log("No need to replace caps.");
                                } else {
                                        _mmcam_dbg_log("current [%c%c%c%c %dx%d, fps %d, rot %d], new [%c%c%c%c %dx%d, fps %d, rot %d]",
@@ -2728,7 +2774,8 @@ bool _mmcamcorder_set_videosrc_caps(MMHandleType handle, unsigned int fourcc, in
                                        MMCAM_DISPLAY_SURFACE, &display_surface_type,
                                        NULL);
 
-                       if (display_surface_type != MM_DISPLAY_SURFACE_NULL && __mmcamcorder_find_max_resolution(handle, &maxwidth, &maxheight) == false) {
+                       if (display_surface_type != MM_DISPLAY_SURFACE_NULL &&
+                               __mmcamcorder_find_max_resolution(handle, &maxwidth, &maxheight) == false) {
                                _mmcam_dbg_err("can not find max resolution limitation");
                                return false;
                        } else if (display_surface_type == MM_DISPLAY_SURFACE_NULL) {
@@ -2747,6 +2794,16 @@ bool _mmcamcorder_set_videosrc_caps(MMHandleType handle, unsigned int fourcc, in
                                "alignment", G_TYPE_STRING, "au",
 #endif /* _MMCAMCORDER_PRODUCT_TV */
                                NULL);
+               } else if (sc->info_image->preview_format == MM_PIXEL_FORMAT_ENCODED_MJPEG){
+#ifdef _MMCAMCORDER_PRODUCT_TV
+                       caps = gst_caps_new_simple("video/x-jpeg",
+#else
+                       caps = gst_caps_new_simple("image/jpeg",
+#endif
+                               "width", G_TYPE_INT, set_width,
+                               "height", G_TYPE_INT, set_height,
+                               "framerate", GST_TYPE_FRACTION, fps, 1,
+                               NULL);
                } else {
                        char fourcc_string[sizeof(fourcc)+1];
                        strncpy(fourcc_string, (char*)&fourcc, sizeof(fourcc));
@@ -3065,7 +3122,7 @@ bool _mmcamcorder_recreate_decoder_for_encoded_preview(MMHandleType handle)
                return FALSE;
        }
 
-       if (sc->info_image->preview_format != MM_PIXEL_FORMAT_ENCODED_H264 ||
+       if (__mmcamcorder_is_encoded_preview_pixel_format(sc->info_image->preview_format) == false ||
                hcamcorder->recreate_decoder == FALSE) {
                _mmcam_dbg_log("skip this fuction - format %d, recreate decoder %d",
                        sc->info_image->preview_format, hcamcorder->recreate_decoder);
@@ -3108,11 +3165,21 @@ bool _mmcamcorder_recreate_decoder_for_encoded_preview(MMHandleType handle)
        }
 
 #ifdef _MMCAMCORDER_RM_SUPPORT
-       if (hcamcorder->request_resources.category_id[0] == RM_CATEGORY_VIDEO_DECODER_SUB)
-               decoder_index = 1;
+       if (sc->info_image->preview_format == MM_PIXEL_FORMAT_ENCODED_H264) {
+               if (hcamcorder->request_resources.category_id[0] == RM_CATEGORY_VIDEO_DECODER_SUB)
+                       decoder_index = 1;
+
+               snprintf(decoder_name, sizeof(decoder_name)-1, "%s%d", videodecoder_name, decoder_index);
+               _mmcam_dbg_log("encoded preview decoder_name %s", decoder_name);
+       } else {
+               /* MJPEG */
+               if (hcamcorder->request_resources.category_id[0] == RM_CATEGORY_VIDEO_DECODER)
+                       snprintf(decoder_name, sizeof(decoder_name)-1, "%s", "omx_uhd_mjpegdec");
+               else
+                       snprintf(decoder_name, sizeof(decoder_name)-1, "%s", "omx_mjpegdec");
+               _mmcam_dbg_log("encoded preview decoder_name %s", decoder_name);
+       }
 
-       snprintf(decoder_name, sizeof(decoder_name)-1, "%s%d", videodecoder_name, decoder_index);
-       _mmcam_dbg_log("encoded preview decoder_name %s", decoder_name);
        /* create decoder */
        sc->element[_MMCAMCORDER_VIDEOSRC_DECODE].gst = gst_element_factory_make(decoder_name, "videosrc_decode");
        if (sc->element[_MMCAMCORDER_VIDEOSRC_DECODE].gst == NULL) {
@@ -3170,6 +3237,13 @@ bool _mmcamcorder_recreate_decoder_for_encoded_preview(MMHandleType handle)
        return TRUE;
 }
 
+static inline bool __mmcamcorder_is_encoded_preview_pixel_format(int pixel_format) {
+       if (pixel_format == MM_PIXEL_FORMAT_ENCODED_H264 || pixel_format == MM_PIXEL_FORMAT_ENCODED_MJPEG)
+               return true;
+
+       return false;
+}
+
 #ifdef _MMCAMCORDER_PRODUCT_TV
 static bool __mmcamcorder_find_max_resolution(MMHandleType handle, gint *max_width, gint *max_height)
 {
@@ -3219,6 +3293,13 @@ static bool __mmcamcorder_find_max_resolution(MMHandleType handle, gint *max_wid
                        if (gst_structure_has_field(decsink_struct, "maxheight"))
                                *max_height = gst_value_get_int_range_max(gst_structure_get_value(decsink_struct, "maxheight"));
                        break;
+               } else if (!strcmp(mime, "video/x-jpeg")) {
+                       _mmcam_dbg_log("mjpeg caps structure found");
+                       if (gst_structure_has_field(decsink_struct, "maxwidth"))
+                               *max_width = gst_value_get_int_range_max(gst_structure_get_value(decsink_struct, "maxwidth"));
+                       if (gst_structure_has_field(decsink_struct, "maxheight"))
+                               *max_height = gst_value_get_int_range_max(gst_structure_get_value(decsink_struct, "maxheight"));
+                       break;
                }
        }
        _mmcam_dbg_log("maxwidth = %d , maxheight = %d", (int)*max_width, (int)*max_height);

diff --git a/src/mm_camcorder_rm.c b/src/mm_camcorder_rm.c
index 7291d54..fecd42e 100644 (file)
--- a/src/mm_camcorder_rm.c
+++ b/src/mm_camcorder_rm.c
@@ -127,16 +127,23 @@ int _mmcamcorder_rm_allocate(MMHandleType handle)
                        _mmcam_dbg_log("request dec rsc - category 0x%x", RM_CATEGORY_VIDEO_DECODER);
 
                        resource_count++;
-               }
-
-               if (display_surface_type == MM_DISPLAY_SURFACE_OVERLAY) {
+               } else if (preview_format == MM_PIXEL_FORMAT_ENCODED_MJPEG) {
                        hcamcorder->request_resources.state[resource_count] = RM_STATE_EXCLUSIVE;
-                       hcamcorder->request_resources.category_id[resource_count] = RM_CATEGORY_SCALER;
+                       hcamcorder->request_resources.category_id[resource_count] = RM_CATEGORY_VIDEO_DECODER_SUB;
 
-                       _mmcam_dbg_log("request scaler rsc - category 0x%x", RM_CATEGORY_SCALER);
+                       _mmcam_dbg_log("request dec rsc - category 0x%x", RM_CATEGORY_VIDEO_DECODER_SUB);
 
                        resource_count++;
                }
+               if (display_surface_type == MM_DISPLAY_SURFACE_OVERLAY) {
+                       hcamcorder->request_resources.state[resource_count] = RM_STATE_EXCLUSIVE;
+                       if (preview_format == MM_PIXEL_FORMAT_ENCODED_H264)
+                               hcamcorder->request_resources.category_id[resource_count] = RM_CATEGORY_SCALER;
+                       else
+                               hcamcorder->request_resources.category_id[resource_count] = RM_CATEGORY_SCALER_SUB;
+                       _mmcam_dbg_log("request scaler rsc - category 0x%x", hcamcorder->request_resources.category_id[resource_count]);
+                       resource_count++;
+               }
 
                hcamcorder->request_resources.request_num = resource_count;
 
@@ -154,12 +161,19 @@ int _mmcamcorder_rm_allocate(MMHandleType handle)
                                        hcamcorder->request_resources.category_id[resource_count] = RM_CATEGORY_VIDEO_DECODER_SUB;
                                        _mmcam_dbg_log("request dec rsc - category 0x%x", RM_CATEGORY_VIDEO_DECODER_SUB);
                                        resource_count++;
+                               } else if (preview_format == MM_PIXEL_FORMAT_ENCODED_MJPEG) {
+                                       hcamcorder->request_resources.state[resource_count] = RM_STATE_EXCLUSIVE;
+                                       hcamcorder->request_resources.category_id[resource_count] = RM_CATEGORY_VIDEO_DECODER;
+                                       _mmcam_dbg_log("request dec rsc - category 0x%x", RM_CATEGORY_VIDEO_DECODER);
+                                       resource_count++;
                                }
-
                                if (display_surface_type == MM_DISPLAY_SURFACE_OVERLAY) {
                                        hcamcorder->request_resources.state[resource_count] = RM_STATE_EXCLUSIVE;
-                                       hcamcorder->request_resources.category_id[resource_count] = RM_CATEGORY_SCALER_SUB;
-                                       _mmcam_dbg_log("request scaler rsc - category 0x%x", RM_CATEGORY_SCALER_SUB);
+                                       if (preview_format == MM_PIXEL_FORMAT_ENCODED_H264)
+                                               hcamcorder->request_resources.category_id[resource_count] = RM_CATEGORY_SCALER_SUB;
+                                       else
+                                               hcamcorder->request_resources.category_id[resource_count] = RM_CATEGORY_SCALER;
+                                       _mmcam_dbg_log("request scaler rsc - category 0x%x", hcamcorder->request_resources.category_id[resource_count]);
                                        resource_count++;
                                }
                        }

diff --git a/src/mm_camcorder_util.c b/src/mm_camcorder_util.c
index c7c7093..063ac1f 100644 (file)
--- a/src/mm_camcorder_util.c
+++ b/src/mm_camcorder_util.c
@@ -1652,6 +1652,9 @@ unsigned int _mmcamcorder_get_fourcc(int pixtype, int codectype, int use_zero_co
        case MM_PIXEL_FORMAT_ENCODED_H264:
                fourcc = GST_MAKE_FOURCC('H', '2', '6', '4');
                break;
+       case MM_PIXEL_FORMAT_ENCODED_MJPEG:
+               fourcc = GST_MAKE_FOURCC ('M', 'J', 'P', 'G');
+               break;
        case MM_PIXEL_FORMAT_INVZ:
                fourcc = GST_MAKE_FOURCC('I', 'N', 'V', 'Z');
                break;
@@ -1733,6 +1736,9 @@ int _mmcamcorder_get_pixtype(unsigned int fourcc)
        case GST_MAKE_FOURCC('H', '2', '6', '4'):
                pixtype = MM_PIXEL_FORMAT_ENCODED_H264;
                break;
+       case GST_MAKE_FOURCC ('M', 'J', 'P', 'G'):
+               pixtype = MM_PIXEL_FORMAT_ENCODED_MJPEG;
+               break;
        case GST_MAKE_FOURCC('I', 'N', 'V', 'Z'):
                pixtype = MM_PIXEL_FORMAT_INVZ;
                break;