#define _MMCAMCORDER_CONVERT_OUTPUT_BUFFER_NUM 6
#define _MMCAMCORDER_NANOSEC_PER_1SEC 1000000000
#define _MMCAMCORDER_NANOSEC_PER_1MILISEC 1000
+#define _MMCAMCORDER_SIGNAL_REQUEST_CODEC_CONFIG "request-codec-config"
/*-----------------------------------------------------------------------
static GstPadProbeReturn __mmcamcorder_video_dataprobe_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);
-#ifdef _MMCAMCORDER_PRODUCT_TV
-static bool __mmcamcorder_find_max_resolution(MMHandleType handle, gint *max_width, gint *max_height);
-#endif /* _MMCAMCORDER_PRODUCT_TV */
+static guint32 _mmcamcorder_get_structure_fourcc(const GstStructure *structure);
-static gboolean __mmcamcorder_set_stream_data(MMCamcorderVideoStreamDataType *stream, GstBuffer *buffer, GstMemory *memory);
+static gboolean __mmcamcorder_set_stream_data(MMCamcorderVideoStreamDataType *stream, GstBuffer *buffer, GstMapInfo *map_info);
static gboolean __mmcamcorder_set_stream_data_zero_copy(MMCamcorderVideoStreamDataType *stream, GstBuffer *buffer, GstMemory *memory);
+static const char *__mmcamcorder_get_parser_name(MMPixelFormatType format);
+static void __mmcamcorder_request_codec_config(GstElement *videosrc_element);
/*=======================================================================================
| FUNCTION DEFINITIONS |
=======================================================================================*/
-static gboolean __mmcamcorder_set_stream_data(MMCamcorderVideoStreamDataType *stream, GstBuffer *buffer, GstMemory *memory)
+static gboolean __mmcamcorder_set_stream_data(MMCamcorderVideoStreamDataType *stream, GstBuffer *buffer, GstMapInfo *map_info)
{
gboolean ret = TRUE;
- GstMapInfo map_info;
mmf_return_val_if_fail(buffer, FALSE);
mmf_return_val_if_fail(stream, FALSE);
+ mmf_return_val_if_fail(map_info, FALSE);
- memset(&map_info, 0x0, sizeof(GstMapInfo));
-
- if (!gst_memory_map(memory, &map_info, GST_MAP_READWRITE)) {
- MMCAM_LOG_ERROR("map failed for memory[%p]", memory);
- return FALSE;
- }
-
- stream->length_total = gst_memory_get_sizes(memory, NULL, NULL);
+ stream->length_total = map_info->size;
switch (stream->format) {
case MM_PIXEL_FORMAT_NV12: /* fall through */
case MM_PIXEL_FORMAT_NV21:
stream->data_type = MM_CAM_STREAM_DATA_YUV420SP;
- stream->data.yuv420sp.y = map_info.data;
+ stream->data.yuv420sp.y = map_info->data;
stream->data.yuv420sp.length_y = stream->width * stream->height;
stream->data.yuv420sp.uv = stream->data.yuv420sp.y + stream->data.yuv420sp.length_y;
stream->data.yuv420sp.length_uv = stream->data.yuv420sp.length_y >> 1;
case MM_PIXEL_FORMAT_I420:
stream->data_type = MM_CAM_STREAM_DATA_YUV420P;
- stream->data.yuv420p.y = map_info.data;
+ stream->data.yuv420p.y = map_info->data;
stream->data.yuv420p.length_y = stream->width * stream->height;
stream->data.yuv420p.u = stream->data.yuv420p.y + stream->data.yuv420p.length_y;
stream->data.yuv420p.length_u = stream->data.yuv420p.length_y >> 2;
case MM_PIXEL_FORMAT_422P:
stream->data_type = MM_CAM_STREAM_DATA_YUV422P;
- stream->data.yuv422p.y = map_info.data;
+ stream->data.yuv422p.y = map_info->data;
stream->data.yuv422p.length_y = stream->width * stream->height;
stream->data.yuv422p.u = stream->data.yuv422p.y + stream->data.yuv422p.length_y;
stream->data.yuv422p.length_u = stream->data.yuv422p.length_y >> 1;
case MM_PIXEL_FORMAT_UYVY: /* fall through */
case MM_PIXEL_FORMAT_ITLV_JPEG_UYVY:
stream->data_type = MM_CAM_STREAM_DATA_YUV422;
- stream->data.yuv422.yuv = map_info.data;
+ stream->data.yuv422.yuv = map_info->data;
stream->data.yuv422.length_yuv = stream->length_total;
stream->stride[0] = stream->width << 1;
stream->elevation[0] = stream->height;
case MM_PIXEL_FORMAT_ENCODED_VP8: /* fall through */
case MM_PIXEL_FORMAT_ENCODED_VP9: /* fall through */
stream->data_type = MM_CAM_STREAM_DATA_ENCODED;
- stream->data.encoded.data = map_info.data;
+ stream->data.encoded.data = map_info->data;
stream->data.encoded.length_data = stream->length_total;
stream->data.encoded.is_delta_frame = GST_BUFFER_FLAG_IS_SET(buffer, GST_BUFFER_FLAG_DELTA_UNIT);
stream->num_planes = 1;
case MM_PIXEL_FORMAT_INVZ:
stream->data_type = MM_CAM_STREAM_DATA_DEPTH;
- stream->data.depth.data = map_info.data;
+ stream->data.depth.data = map_info->data;
stream->data.depth.length_data = stream->length_total;
stream->stride[0] = stream->width << 1;
stream->elevation[0] = stream->height;
case MM_PIXEL_FORMAT_RGBA: /* fall through */
case MM_PIXEL_FORMAT_ARGB:
stream->data_type = MM_CAM_STREAM_DATA_RGB;
- stream->data.rgb.data = map_info.data;
+ stream->data.rgb.data = map_info->data;
stream->data.rgb.length_data = stream->length_total;
stream->stride[0] = stream->width << 2;
stream->elevation[0] = stream->height;
break;
}
- gst_memory_unmap(memory, &map_info);
-
return ret;
}
}
+static const char *__mmcamcorder_get_parser_name(MMPixelFormatType format)
+{
+ switch (format) {
+ case MM_PIXEL_FORMAT_ENCODED_H264:
+ return "h264parse";
+ case MM_PIXEL_FORMAT_ENCODED_VP9:
+ return "vp9parse";
+ default:
+ MMCAM_LOG_WARNING("unsupported format[%d]", format);
+ return NULL;
+ }
+}
+
+
+static void __mmcamcorder_request_codec_config(GstElement *videosrc_element)
+{
+ if (!videosrc_element || !G_TYPE_CHECK_INSTANCE(videosrc_element)) {
+ MMCAM_LOG_WARNING("invalid videosrc element[%p]", videosrc_element);
+ return;
+ }
+
+ if (!g_signal_parse_name(_MMCAMCORDER_SIGNAL_REQUEST_CODEC_CONFIG,
+ G_TYPE_FROM_INSTANCE(videosrc_element), NULL, NULL, FALSE)) {
+ MMCAM_LOG_WARNING("no signal[%s]", _MMCAMCORDER_SIGNAL_REQUEST_CODEC_CONFIG);
+ return;
+ }
+
+ MMCAM_LOG_INFO("emit signal[%s]", _MMCAMCORDER_SIGNAL_REQUEST_CODEC_CONFIG);
+
+ g_signal_emit_by_name(videosrc_element, _MMCAMCORDER_SIGNAL_REQUEST_CODEC_CONFIG);
+}
+
+
gboolean _mmcamcorder_invoke_video_stream_cb(MMHandleType handle, GstSample *sample, gboolean is_preview, int stream_id)
{
int i = 0;
GstBuffer *buffer = NULL;
GstMemory *memory = NULL;
+ GstMapInfo map_info;
GstCaps *caps = NULL;
GstStructure *structure = NULL;
}
structure = gst_mini_object_get_qdata(GST_MINI_OBJECT_CAST(buffer), hcamcorder->buffer_quark);
- if (structure) {
+ if (structure && gst_structure_has_field(structure, "focus-state")) {
gst_structure_get(structure,
"focus-state", G_TYPE_INT, &stream.focus_state,
"facing-direction", G_TYPE_INT, &stream.facing_direction,
if (!__mmcamcorder_set_stream_data_zero_copy(&stream, buffer, memory))
goto _INVOKE_VIDEO_STREAM_CB_DONE;
} else {
- if (!__mmcamcorder_set_stream_data(&stream, buffer, memory))
+ memset(&map_info, 0x0, sizeof(GstMapInfo));
+
+ if (!gst_memory_map(memory, &map_info, GST_MAP_READWRITE)) {
+ MMCAM_LOG_ERROR("map failed for memory[%p]", memory);
+ return FALSE;
+ }
+
+ if (!__mmcamcorder_set_stream_data(&stream, buffer, &map_info))
goto _INVOKE_VIDEO_STREAM_CB_DONE;
}
}
_INVOKE_VIDEO_STREAM_CB_DONE:
+ if (!gst_is_tizen_memory(memory))
+ gst_memory_unmap(memory, &map_info);
+
for (i = 0 ; i < TBM_SURF_PLANE_MAX && stream.bo[i] ; i++) {
tbm_bo_map(stream.bo[i], TBM_DEVICE_CPU, TBM_OPTION_READ|TBM_OPTION_WRITE);
tbm_bo_unmap(stream.bo[i]);
int codectype = 0;
int capture_width = 0;
int capture_height = 0;
- int capture_jpg_quality = 100;
+ int capture_quality = 0;
int video_stabilization = 0;
int anti_shake = 0;
int display_surface_type = MM_DISPLAY_SURFACE_NULL;
const char *videosink_name = NULL;
const char *videoconvert_name = NULL;
const char *videodecoder_name = NULL;
+ const char *videoparse_name = NULL;
const char *decoder_conf_name = NULL;
char videodecoder_name_final[32] = {'\0',};
char *err_name = NULL;
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
_MMCamcorderSubContext *sc = NULL;
- type_element *VideosrcElement = NULL;
+ type_element *videosrc_element = NULL;
type_int_array *input_index = NULL;
mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
MMCAM_CAPTURE_HEIGHT, &capture_height,
MMCAM_CAMERA_HDR_CAPTURE, &sc->info_image->hdr_capture_mode,
MMCAM_IMAGE_ENCODER, &codectype,
- MMCAM_IMAGE_ENCODER_QUALITY, &capture_jpg_quality,
+ MMCAM_IMAGE_ENCODER_QUALITY, &capture_quality,
MMCAM_DISPLAY_SURFACE, &display_surface_type,
MMCAM_EXTRA_PREVIEW_ENABLE, &extra_preview_enable,
NULL);
/* Get fourcc from picture format */
sc->fourcc = _mmcamcorder_get_fourcc(sc->info_image->preview_format, codectype, hcamcorder->use_zero_copy_format);
- /* Get videosrc element and its name from configure */
- _mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
- CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
- "VideosrcElement",
- &VideosrcElement);
- _mmcamcorder_conf_get_value_element_name(VideosrcElement, &videosrc_name);
+ _mmcamcorder_conf_get_element_and_name((MMHandleType)hcamcorder,
+ CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT, "VideosrcElement",
+ &videosrc_element, &videosrc_name);
/**
* Create child element
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "high-speed-fps", 0);
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "capture-width", capture_width);
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "capture-height", capture_height);
- MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "capture-jpg-quality", capture_jpg_quality);
+ MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "capture-quality", capture_quality);
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "hdr-capture", sc->info_image->hdr_capture_mode);
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "extra-preview", extra_preview_enable);
MMCAMCORDER_G_OBJECT_GET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "buffer-quark", &hcamcorder->buffer_quark);
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "high-speed-fps", fps);
/* Set basic information of videosrc element */
- _mmcamcorder_conf_set_value_element_property(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, VideosrcElement);
+ _mmcamcorder_conf_set_value_element_property(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, videosrc_element);
/* Set video device index */
if (hcamcorder->is_network) {
}
#endif /* _MMCAMCORDER_RM_SUPPORT */
+ videoparse_name = __mmcamcorder_get_parser_name(sc->info_image->preview_format);
+ if (videoparse_name)
+ _MMCAMCORDER_ELEMENT_MAKE(sc, sc->element, _MMCAMCORDER_VIDEOSRC_PARSE, videoparse_name, "videosrc_parse", element_list, err);
+
_MMCAMCORDER_ELEMENT_MAKE(sc, sc->element, _MMCAMCORDER_VIDEOSRC_DECODE, videodecoder_name_final, "videosrc_decode", element_list, err);
_mmcamcorder_conf_set_value_element_property(sc->element[_MMCAMCORDER_VIDEOSRC_DECODE].gst, sc->VideodecoderElement);
pipeline_creation_error:
_MMCAMCORDER_ELEMENT_REMOVE(sc->element, _MMCAMCORDER_VIDEOSRC_SRC);
_MMCAMCORDER_ELEMENT_REMOVE(sc->element, _MMCAMCORDER_VIDEOSRC_FILT);
- _MMCAMCORDER_ELEMENT_REMOVE(sc->element, _MMCAMCORDER_VIDEOSRC_CLS_QUE);
- _MMCAMCORDER_ELEMENT_REMOVE(sc->element, _MMCAMCORDER_VIDEOSRC_CLS);
- _MMCAMCORDER_ELEMENT_REMOVE(sc->element, _MMCAMCORDER_VIDEOSRC_CLS_FILT);
_MMCAMCORDER_ELEMENT_REMOVE(sc->element, _MMCAMCORDER_VIDEOSRC_QUE);
+ _MMCAMCORDER_ELEMENT_REMOVE(sc->element, _MMCAMCORDER_VIDEOSRC_CAP_FILT);
+ _MMCAMCORDER_ELEMENT_REMOVE(sc->element, _MMCAMCORDER_VIDEOSRC_CAP_SINK);
_MMCAMCORDER_ELEMENT_REMOVE(sc->element, _MMCAMCORDER_VIDEOSRC_DECODE);
_MMCAMCORDER_ELEMENT_REMOVE(sc->element, _MMCAMCORDER_VIDEOSINK_QUE);
_MMCAMCORDER_ELEMENT_REMOVE(sc->element, _MMCAMCORDER_VIDEOSINK_SINK);
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
_MMCamcorderSubContext *sc = NULL;
_MMCamcorderGstElement *last_element = NULL;
- type_element *AudiosrcElement = NULL;
+ type_element *audiosrc_element = NULL;
mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
goto pipeline_creation_error;
}
- _mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
- CONFIGURE_CATEGORY_MAIN_AUDIO_INPUT,
- cat_name,
- &AudiosrcElement);
- _mmcamcorder_conf_get_value_element_name(AudiosrcElement, &audiosrc_name);
+ _mmcamcorder_conf_get_element_and_name((MMHandleType)hcamcorder,
+ CONFIGURE_CATEGORY_MAIN_AUDIO_INPUT, cat_name,
+ &audiosrc_element, &audiosrc_name);
free(cat_name);
cat_name = NULL;
_mmcamcorder_set_sound_stream_info(sc->encode_element[_MMCAMCORDER_AUDIOSRC_SRC].gst, stream_type, stream_index);
/* set audiosrc properties in ini configuration */
- _mmcamcorder_conf_set_value_element_property(sc->encode_element[_MMCAMCORDER_AUDIOSRC_SRC].gst, AudiosrcElement);
+ _mmcamcorder_conf_set_value_element_property(sc->encode_element[_MMCAMCORDER_AUDIOSRC_SRC].gst, audiosrc_element);
/* set block size */
_mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main,
}
if (_mmcamcorder_is_encoded_preview_pixel_format(sc->info_image->preview_format)) {
- /* set dummy element */
- gst_element_venc_name = "identity";
+ /* set parse element */
+ gst_element_venc_name = __mmcamcorder_get_parser_name(sc->info_image->preview_format);
+ if (!gst_element_venc_name)
+ gst_element_venc_name = "identity";
} else {
_mmcamcorder_conf_get_value_element_name(VideoencElement, &gst_element_venc_name);
}
gst_object_unref(bus);
bus = NULL;
+ /* capture mode */
+ err = _mmcamcorder_initialize_capture_mode(handle);
+ if (err != MM_ERROR_NONE) {
+ MMCAM_LOG_ERROR("initialize capture mode[%d] failed", hcamcorder->capture_mode);
+ goto pipeline_creation_error;
+ }
+
+ /* extra preview mode */
+ err = _mmcamcorder_initialize_extra_preview_mode(handle);
+ if (err != MM_ERROR_NONE) {
+ MMCAM_LOG_ERROR("initialize extra preview mode[%d] failed", hcamcorder->extra_preview.mode);
+ goto pipeline_creation_error;
+ }
+
return MM_ERROR_NONE;
pipeline_creation_error:
/* set flag */
if (sc->info_video->push_encoding_buffer == PUSH_ENCODING_BUFFER_INIT) {
sc->info_video->push_encoding_buffer = PUSH_ENCODING_BUFFER_RUN;
- MMCAM_LOG_WARNING("set push_encoding_buffer RUN");
+ __mmcamcorder_request_codec_config(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
+ MMCAM_LOG_WARNING("start to push buffer to encoding pipeline");
}
}
return TRUE;
}
-static guint32 _mmcamcorder_convert_fourcc_string_to_value(const gchar* format_name)
+static guint32 _mmcamcorder_get_structure_fourcc(const GstStructure *structure)
{
- return format_name[0] | (format_name[1] << 8) | (format_name[2] << 16) | (format_name[3] << 24);
+ const gchar *format_string = NULL;
+
+ if (!structure) {
+ MMCAM_LOG_WARNING("NULL structure");
+ return GST_MAKE_FOURCC('N', 'U', 'L', 'L');
+ }
+
+ if (gst_structure_has_name(structure, "video/x-h264"))
+ return GST_MAKE_FOURCC('H', '2', '6', '4');
+
+ if (gst_structure_has_name(structure, "video/x-h265"))
+ return GST_MAKE_FOURCC('H', '2', '6', '5');
+
+ if (gst_structure_has_name(structure, "video/x-vp8"))
+ return GST_MAKE_FOURCC('V', 'P', '8', '0');
+
+ if (gst_structure_has_name(structure, "video/x-vp9"))
+ return GST_MAKE_FOURCC('V', 'P', '9', '0');
+
+ if (gst_structure_has_name(structure, "video/x-jpeg") ||
+ gst_structure_has_name(structure, "image/jpeg"))
+ return GST_MAKE_FOURCC('M', 'J', 'P', 'G');
+
+ format_string = gst_structure_get_string(structure, "format");
+
+ if (format_string)
+ return GST_STR_FOURCC(format_string);
+
+ return GST_MAKE_FOURCC('N', 'O', 'N', 'E');
}
static GstPadProbeReturn __mmcamcorder_video_dataprobe_preview(GstPad *pad, GstPadProbeInfo *info, gpointer u_data)
int fps_auto = 0;
unsigned int caps_fourcc = 0;
gboolean do_set_caps = FALSE;
- char fourcc_string[sizeof(fourcc) + 1];
- gchar *caps_str = NULL;
-#ifdef _MMCAMCORDER_PRODUCT_TV
- gint maxwidth = 0;
- gint maxheight = 0;
- int display_surface_type = MM_DISPLAY_SURFACE_NULL;
-#endif /* _MMCAMCORDER_PRODUCT_TV */
-
GstCaps *caps = NULL;
mmf_camcorder_t *hcamcorder = NULL;
structure = gst_caps_get_structure(caps, 0);
if (structure) {
- const gchar *format_string = NULL;
int caps_width = 0;
int caps_height = 0;
- int caps_fps = 0;
+ int caps_fps_n = 0;
+ int caps_fps_d = 0;
int caps_rotate = 0;
- format_string = gst_structure_get_string(structure, "format");
- if (format_string)
- caps_fourcc = _mmcamcorder_convert_fourcc_string_to_value(format_string);
+ caps_fourcc = _mmcamcorder_get_structure_fourcc(structure);
gst_structure_get(structure,
"width", G_TYPE_INT, &caps_width,
"height", G_TYPE_INT, &caps_height,
- "fps", G_TYPE_INT, &caps_fps,
+ "framerate", GST_TYPE_FRACTION, &caps_fps_n, &caps_fps_d,
"rotate", G_TYPE_INT, &caps_rotate,
NULL);
#ifdef _MMCAMCORDER_PRODUCT_TV
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) {
+ set_rotate == caps_rotate && fps == caps_fps_n) {
MMCAM_LOG_INFO("No need to replace caps.");
} else {
- MMCAM_LOG_INFO("current [%c%c%c%c %dx%d, fps %d, rot %d], new [%c%c%c%c %dx%d, fps %d, rot %d]",
+ MMCAM_LOG_INFO("current [%c%c%c%c %dx%d, fps %d/%d, rot %d], new [%c%c%c%c %dx%d, fps %d, rot %d]",
caps_fourcc, caps_fourcc>>8, caps_fourcc>>16, caps_fourcc>>24,
- caps_width, caps_height, caps_fps, caps_rotate,
+ caps_width, caps_height, caps_fps_n, caps_fps_d, caps_rotate,
fourcc, fourcc>>8, fourcc>>16, fourcc>>24,
set_width, set_height, fps, set_rotate);
do_set_caps = TRUE;
}
} else {
if (set_width == caps_width && set_height == caps_height &&
- fourcc == caps_fourcc && set_rotate == caps_rotate && fps == caps_fps) {
+ fourcc == caps_fourcc && set_rotate == caps_rotate && fps == caps_fps_n) {
MMCAM_LOG_INFO("No need to replace caps.");
} else {
- MMCAM_LOG_INFO("current [%c%c%c%c %dx%d, fps %d, rot %d], new [%c%c%c%c %dx%d, fps %d, rot %d]",
+ MMCAM_LOG_INFO("current [%c%c%c%c %dx%d, fps %d/%d, rot %d], new [%c%c%c%c %dx%d, fps %d, rot %d]",
caps_fourcc, caps_fourcc>>8, caps_fourcc>>16, caps_fourcc>>24,
- caps_width, caps_height, caps_fps, caps_rotate,
+ caps_width, caps_height, caps_fps_n, caps_fps_d, caps_rotate,
fourcc, fourcc>>8, fourcc>>16, fourcc>>24,
set_width, set_height, fps, set_rotate);
do_set_caps = TRUE;
}
#else /*_MMCAMCORDER_PRODUCT_TV */
if (set_width == caps_width && set_height == caps_height &&
- fourcc == caps_fourcc && set_rotate == caps_rotate && fps == caps_fps) {
+ fourcc == caps_fourcc && set_rotate == caps_rotate && fps == caps_fps_n) {
MMCAM_LOG_INFO("No need to replace caps.");
} else {
- MMCAM_LOG_INFO("current [%c%c%c%c %dx%d, fps %d, rot %d], new [%c%c%c%c %dx%d, fps %d, rot %d]",
+ MMCAM_LOG_INFO("current [%c%c%c%c %dx%d, fps %d/%d, rot %d], new [%c%c%c%c %dx%d, fps %d, rot %d]",
caps_fourcc, caps_fourcc>>8, caps_fourcc>>16, caps_fourcc>>24,
- caps_width, caps_height, caps_fps, caps_rotate,
+ caps_width, caps_height, caps_fps_n, caps_fps_d, caps_rotate,
fourcc, fourcc>>8, fourcc>>16, fourcc>>24,
set_width, set_height, fps, set_rotate);
do_set_caps = TRUE;
if (!do_set_caps)
return TRUE;
- switch (sc->info_image->preview_format) {
- case MM_PIXEL_FORMAT_ENCODED_H264:
-#ifdef _MMCAMCORDER_PRODUCT_TV
- mm_camcorder_get_attributes(handle, NULL,
- MMCAM_DISPLAY_SURFACE, &display_surface_type,
- NULL);
- if (display_surface_type != MM_DISPLAY_SURFACE_NULL &&
- __mmcamcorder_find_max_resolution(handle, &maxwidth, &maxheight) == false) {
- MMCAM_LOG_ERROR("can not find max resolution limitation");
- return false;
- } else if (display_surface_type == MM_DISPLAY_SURFACE_NULL) {
- maxwidth = set_width;
- maxheight = set_height;
- }
-#endif /* _MMCAMCORDER_PRODUCT_TV */
- caps = gst_caps_new_simple("video/x-h264",
- "width", G_TYPE_INT, set_width,
- "height", G_TYPE_INT, set_height,
- "framerate", GST_TYPE_FRACTION, fps, 1,
- "stream-format", G_TYPE_STRING, "byte-stream",
-#ifdef _MMCAMCORDER_PRODUCT_TV
- "maxwidth", G_TYPE_INT, maxwidth,
- "maxheight", G_TYPE_INT, maxheight,
- "alignment", G_TYPE_STRING, "au",
-#endif /* _MMCAMCORDER_PRODUCT_TV */
- NULL);
- break;
- case 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);
- break;
- case MM_PIXEL_FORMAT_ENCODED_VP8:
- caps = gst_caps_new_simple("video/x-vp8",
- "width", G_TYPE_INT, set_width,
- "height", G_TYPE_INT, set_height,
- "framerate", GST_TYPE_FRACTION, fps, 1,
- NULL);
- break;
- case MM_PIXEL_FORMAT_ENCODED_VP9:
- caps = gst_caps_new_simple("video/x-vp9",
- "width", G_TYPE_INT, set_width,
- "height", G_TYPE_INT, set_height,
- "framerate", GST_TYPE_FRACTION, fps, 1,
- NULL);
- break;
- break;
- default:
- memcpy(fourcc_string, (char*)&fourcc, sizeof(fourcc));
- fourcc_string[sizeof(fourcc)] = '\0';
- caps = gst_caps_new_simple("video/x-raw",
- "format", G_TYPE_STRING, fourcc_string,
- "width", G_TYPE_INT, set_width,
- "height", G_TYPE_INT, set_height,
- "framerate", GST_TYPE_FRACTION, fps, 1,
- "rotate", G_TYPE_INT, set_rotate,
- NULL);
- break;
- }
-
+ caps = _mmcamcorder_get_video_caps(handle,
+ sc->info_image->preview_format, set_width, set_height, fps, set_rotate);
if (!caps) {
MMCAM_LOG_ERROR("There are no caps");
return FALSE;
}
- caps_str = gst_caps_to_string(caps);
- MMCAM_LOG_INFO("vidoesrc new caps set [%s]", caps_str);
- g_free(caps_str);
-
MMCAMCORDER_G_OBJECT_SET_POINTER(sc->element[_MMCAMCORDER_VIDEOSRC_FILT].gst, "caps", caps);
gst_caps_unref(caps);
}
#ifdef _MMCAMCORDER_PRODUCT_TV
-static bool __mmcamcorder_find_max_resolution(MMHandleType handle, gint *max_width, gint *max_height)
+bool __mmcamcorder_find_max_resolution(MMHandleType handle, gint *max_width, gint *max_height)
{
_MMCamcorderSubContext *sc = NULL;
mmf_camcorder_t *hcamcorder = NULL;