X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fmm_camcorder_gstcommon.c;h=a0da705c4b4f53ff194cda4ad7fbae0c78cfd904;hb=1044299a1d7b6c0b0ea979fe5d244af8dcca3741;hp=769278466ceb76179be64b6222483bd72b0706ba;hpb=e7407c6534d24e7aeb6a0aa1d8d677789d4f6f27;p=platform%2Fcore%2Fmultimedia%2Flibmm-camcorder.git diff --git a/src/mm_camcorder_gstcommon.c b/src/mm_camcorder_gstcommon.c index 7692784..a0da705 100644 --- a/src/mm_camcorder_gstcommon.c +++ b/src/mm_camcorder_gstcommon.c @@ -22,14 +22,16 @@ /*======================================================================================= | INCLUDE FILES | =======================================================================================*/ +#include #include #include #include -#include #include #include #include +#include +#include #include "mm_camcorder_internal.h" #include "mm_camcorder_gstcommon.h" @@ -153,6 +155,10 @@ static GstPadProbeReturn __mmcamcorder_video_dataprobe_push_buffer_to_record(Gst 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 */ + /*======================================================================================= | FUNCTION DEFINITIONS | =======================================================================================*/ @@ -186,7 +192,10 @@ int _mmcamcorder_create_preview_elements(MMHandleType handle) char decoder_name[20] = {'\0',}; #endif /* _MMCAMCORDER_RM_SUPPORT */ GstElement *sink_element = NULL; + GstCameraControl *control = NULL; int sink_element_size = 0; + int *fds = NULL; + int fd_number = 0; GList *element_list = NULL; @@ -246,6 +255,21 @@ int _mmcamcorder_create_preview_elements(MMHandleType handle) return err; } + if (hcamcorder->support_user_buffer) { + err = mm_camcorder_get_attributes(handle, NULL, + MMCAM_USER_BUFFER_FD, &fds, &fd_number, + NULL); + if (err != MM_ERROR_NONE || fd_number < 1) { + _mmcam_dbg_err("get user buffer fd failed 0x%x, number %d", err, fd_number); + return err; + } + + /* + for (i = 0 ; i < fd_number ; i++) + _mmcam_dbg_log("fds[%d] %d", i, fds[i]); + */ + } + /* Get fourcc from picture format */ sc->fourcc = _mmcamcorder_get_fourcc(sc->info_image->preview_format, codectype, hcamcorder->use_zero_copy_format); @@ -261,9 +285,6 @@ int _mmcamcorder_create_preview_elements(MMHandleType handle) */ _MMCAMCORDER_ELEMENT_MAKE(sc, sc->element, _MMCAMCORDER_VIDEOSRC_SRC, videosrc_name, "videosrc_src", element_list, err); - /* Set video device index */ - MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "camera-id", input_index->default_value); - _MMCAMCORDER_ELEMENT_MAKE(sc, sc->element, _MMCAMCORDER_VIDEOSRC_FILT, "capsfilter", "videosrc_filter", element_list, err); /* init high-speed-fps */ @@ -292,8 +313,20 @@ int _mmcamcorder_create_preview_elements(MMHandleType handle) /* Set basic infomation of videosrc element */ _mmcamcorder_conf_set_value_element_property(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, VideosrcElement); + /* Set video device index */ + MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "camera-id", input_index->default_value); + + /* set user buffer fd to videosrc element */ + if (hcamcorder->support_user_buffer) { + control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst); + if (!gst_camera_control_set_user_buffer_fd(control, fds, fd_number)) { + _mmcam_dbg_err("set user buffer fd failed"); + goto pipeline_creation_error; + } + } + /* make demux and decoder for H264 stream from videosrc */ - if (sc->info_image->preview_format == MM_PIXEL_FORMAT_ENCODED_H264) { + 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; @@ -351,6 +384,11 @@ int _mmcamcorder_create_preview_elements(MMHandleType handle) /* Get videosink name */ _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name); + if (!videosink_name) { + _mmcam_dbg_err("failed to get videosink name"); + goto pipeline_creation_error; + } + _MMCAMCORDER_ELEMENT_MAKE(sc, sc->element, _MMCAMCORDER_VIDEOSINK_QUE, "queue", "videosink_queue", element_list, err); _mmcam_dbg_log("videosink_name: %s", videosink_name); @@ -371,7 +409,7 @@ int _mmcamcorder_create_preview_elements(MMHandleType handle) g_object_set(G_OBJECT(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst), "socket-path", socket_path, NULL); } else { - if (hcamcorder->use_videoconvert && (!strcmp(videosink_name, "waylandsink") || !strcmp(videosink_name, "directvideosink"))) { + if (hcamcorder->use_videoconvert && (!strcmp(videosink_name, "tizenwlsink") || !strcmp(videosink_name, "directvideosink"))) { /* get video convert name */ _mmcamcorder_conf_get_value_element_name(sc->VideoconvertElement, &videoconvert_name); @@ -389,8 +427,7 @@ int _mmcamcorder_create_preview_elements(MMHandleType handle) if (sink_element) { int attr_index = 0; - mmf_attrs_t *attrs = MMF_CAMCORDER_ATTRS(handle); - mmf_attribute_t *attr_item = NULL; + MMHandleType attrs = MMF_CAMCORDER_ATTRS(handle); _mmcam_dbg_log("reuse sink element %p in attribute", sink_element); @@ -399,9 +436,8 @@ int _mmcamcorder_create_preview_elements(MMHandleType handle) /* reset attribute */ if (attrs) { mm_attrs_get_index((MMHandleType)attrs, MMCAM_DISPLAY_REUSE_ELEMENT, &attr_index); - attr_item = &attrs->items[attr_index]; - mmf_attribute_set_data(attr_item, NULL, 0); - mmf_attribute_commit(attr_item); + mm_attrs_set_data(attrs, attr_index, NULL, 0); + mm_attrs_commit(attrs, attr_index); } else { _mmcam_dbg_warn("attribute is NULL"); err = MM_ERROR_CAMCORDER_NOT_INITIALIZED; @@ -478,8 +514,12 @@ int _mmcamcorder_create_audiosrc_bin(MMHandleType handle) const char *audiosrc_name = NULL; char *cat_name = NULL; char *stream_type = NULL; - char stream_type_len = 0; + int stream_type_len = 0; int stream_index = 0; + int buffer_interval = 0; + int blocksize = 0; + int replay_gain_enable = FALSE; + double replay_gain_ref_level = 0.0; GstCaps *caps = NULL; GstPad *pad = NULL; @@ -510,6 +550,8 @@ int _mmcamcorder_create_audiosrc_bin(MMHandleType handle) MMCAM_AUDIO_FORMAT, &format, MMCAM_AUDIO_CHANNEL, &channel, MMCAM_AUDIO_VOLUME, &volume, + MMCAM_AUDIO_REPLAY_GAIN_ENABLE, &replay_gain_enable, + MMCAM_AUDIO_REPLAY_GAIN_REFERENCE_LEVEL, &replay_gain_ref_level, MMCAM_SOUND_STREAM_TYPE, &stream_type, &stream_type_len, MMCAM_SOUND_STREAM_INDEX, &stream_index, NULL); @@ -562,6 +604,17 @@ int _mmcamcorder_create_audiosrc_bin(MMHandleType handle) /* set audiosrc properties in ini configuration */ _mmcamcorder_conf_set_value_element_property(sc->encode_element[_MMCAMCORDER_AUDIOSRC_SRC].gst, AudiosrcElement); + /* set block size */ + _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main, + CONFIGURE_CATEGORY_MAIN_AUDIO_INPUT, + "AudioBufferInterval", + &buffer_interval); + + if (_mmcamcorder_get_audiosrc_blocksize(rate, format, channel, buffer_interval, &blocksize)) { + _mmcam_dbg_log("set audiosrc block size %d", blocksize); + MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_AUDIOSRC_SRC].gst, "blocksize", blocksize); + } + _MMCAMCORDER_ELEMENT_MAKE(sc, sc->encode_element, _MMCAMCORDER_AUDIOSRC_FILT, "capsfilter", "audiosrc_capsfilter", element_list, err); _MMCAMCORDER_ELEMENT_MAKE(sc, sc->encode_element, _MMCAMCORDER_AUDIOSRC_QUE, "queue", "audiosrc_queue", element_list, err); @@ -569,14 +622,13 @@ int _mmcamcorder_create_audiosrc_bin(MMHandleType handle) MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_AUDIOSRC_QUE].gst, "max-size-bytes", 0); MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_AUDIOSRC_QUE].gst, "max-size-time", 0); - if (a_enc != MM_AUDIO_CODEC_VORBIS) - _MMCAMCORDER_ELEMENT_MAKE(sc, sc->encode_element, _MMCAMCORDER_AUDIOSRC_VOL, "volume", "audiosrc_volume", element_list, err); - /* Set basic infomation */ if (a_enc != MM_AUDIO_CODEC_VORBIS) { int depth = 0; const gchar* format_name = NULL; + _MMCAMCORDER_ELEMENT_MAKE(sc, sc->encode_element, _MMCAMCORDER_AUDIOSRC_VOL, "volume", "audiosrc_volume", element_list, err); + if (volume == 0.0) { /* Because data probe of audio src do the same job, it doesn't need to set "mute" here. Already null raw data. */ MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_AUDIOSRC_VOL].gst, "volume", 1.0); @@ -611,6 +663,17 @@ int _mmcamcorder_create_audiosrc_bin(MMHandleType handle) rate, channel, BYTE_ORDER); } + /* Replay Gain */ + _mmcam_dbg_log("Replay gain - enable : %d, reference level : %lf", + replay_gain_enable, replay_gain_ref_level); + + if (replay_gain_enable) { + _MMCAMCORDER_ELEMENT_MAKE(sc, sc->encode_element, _MMCAMCORDER_AUDIOSRC_RGA, "rganalysis", "audiosrc_rga", element_list, err); + MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_AUDIOSRC_RGA].gst, "reference-level", replay_gain_ref_level); + /* If num-tracks is not set, album gain and peak event is not come. */ + MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_AUDIOSRC_RGA].gst, "num-tracks", 1); + } + if (caps) { MMCAMCORDER_G_OBJECT_SET_POINTER((sc->encode_element[_MMCAMCORDER_AUDIOSRC_FILT].gst), "caps", caps); gst_caps_unref(caps); @@ -726,6 +789,7 @@ int _mmcamcorder_create_encodesink_bin(MMHandleType handle, MMCamcorderEncodebin int auto_audio_convert = 0; int auto_audio_resample = 0; int auto_color_space = 0; + int cap_format = MM_PIXEL_FORMAT_INVALID; const char *gst_element_venc_name = NULL; const char *gst_element_aenc_name = NULL; const char *gst_element_ienc_name = NULL; @@ -810,6 +874,9 @@ int _mmcamcorder_create_encodesink_bin(MMHandleType handle, MMCamcorderEncodebin caps_from_pad = NULL; gst_object_unref(pad); pad = NULL; + + /* fixate caps */ + video_caps = gst_caps_fixate(video_caps); } else { /* Image */ MMCAMCORDER_G_OBJECT_GET(sc->element[_MMCAMCORDER_VIDEOSRC_FILT].gst, "caps", &video_caps); @@ -850,12 +917,18 @@ int _mmcamcorder_create_encodesink_bin(MMHandleType handle, MMCamcorderEncodebin _MMCAMCORDER_ELEMENT_MAKE(sc, sc->encode_element, _MMCAMCORDER_ENCSINK_ENCBIN, "encodebin", "encodesink_encbin", element_list, err); /* check element availability */ - err = mm_camcorder_get_attributes(handle, &err_name, - MMCAM_AUDIO_ENCODER, &audio_enc, - MMCAM_AUDIO_CHANNEL, &channel, - MMCAM_VIDEO_ENCODER_BITRATE, &v_bitrate, - MMCAM_AUDIO_ENCODER_BITRATE, &a_bitrate, - NULL); + if (profile == MM_CAMCORDER_ENCBIN_PROFILE_IMAGE) { + err = mm_camcorder_get_attributes(handle, &err_name, + MMCAM_CAPTURE_FORMAT, &cap_format, + NULL); + } else { + err = mm_camcorder_get_attributes(handle, &err_name, + MMCAM_AUDIO_ENCODER, &audio_enc, + MMCAM_AUDIO_CHANNEL, &channel, + MMCAM_VIDEO_ENCODER_BITRATE, &v_bitrate, + MMCAM_AUDIO_ENCODER_BITRATE, &a_bitrate, + NULL); + } if (err != MM_ERROR_NONE) { if (err_name) { @@ -865,7 +938,7 @@ int _mmcamcorder_create_encodesink_bin(MMHandleType handle, MMCamcorderEncodebin _mmcam_dbg_err("failed to get attributes [0x%x]", err); } - return err; + goto pipeline_creation_error; } _mmcam_dbg_log("Profile[%d]", profile); @@ -917,10 +990,12 @@ int _mmcamcorder_create_encodesink_bin(MMHandleType handle, MMCamcorderEncodebin goto pipeline_creation_error; } - if (sc->info_image->preview_format == MM_PIXEL_FORMAT_ENCODED_H264) - gst_element_venc_name = "capsfilter"; - else + if (sc->info_image->preview_format == MM_PIXEL_FORMAT_ENCODED_H264) { + /* set dummy element */ + gst_element_venc_name = "identity"; + } else { _mmcamcorder_conf_get_value_element_name(VideoencElement, &gst_element_venc_name); + } if (gst_element_venc_name) { _mmcam_dbg_log("video encoder name [%s]", gst_element_venc_name); @@ -1018,14 +1093,19 @@ int _mmcamcorder_create_encodesink_bin(MMHandleType handle, MMCamcorderEncodebin } if (profile == MM_CAMCORDER_ENCBIN_PROFILE_IMAGE) { - ImageencElement = _mmcamcorder_get_type_element(handle, MM_CAM_IMAGE_ENCODER); - if (!ImageencElement) { - _mmcam_dbg_err("Fail to get type element"); - err = MM_ERROR_CAMCORDER_RESOURCE_CREATION; - goto pipeline_creation_error; - } + if (cap_format == MM_PIXEL_FORMAT_ENCODED) { + ImageencElement = _mmcamcorder_get_type_element(handle, MM_CAM_IMAGE_ENCODER); + if (!ImageencElement) { + _mmcam_dbg_err("Fail to get type element"); + err = MM_ERROR_CAMCORDER_RESOURCE_CREATION; + goto pipeline_creation_error; + } - _mmcamcorder_conf_get_value_element_name(ImageencElement, &gst_element_ienc_name); + _mmcamcorder_conf_get_value_element_name(ImageencElement, &gst_element_ienc_name); + } else { + /* raw format - set dummy element */ + gst_element_ienc_name = "identity"; + } MMCAMCORDER_G_OBJECT_SET_POINTER(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "ienc-name", gst_element_ienc_name); _MMCAMCORDER_ENCODEBIN_ELMGET(sc, _MMCAMCORDER_ENCSINK_IENC, "image-encode", err); @@ -1285,10 +1365,10 @@ int _mmcamcorder_videosink_window_set(MMHandleType handle, type_element* Videosi { int err = MM_ERROR_NONE; int size = 0; - int retx = 0; - int rety = 0; - int retwidth = 0; - int retheight = 0; + int rect_x = 0; + int rect_y = 0; + int rect_width = 0; + int rect_height = 0; int visible = 0; int rotation = MM_DISPLAY_ROTATION_NONE; int flip = MM_FLIP_NONE; @@ -1301,7 +1381,8 @@ int _mmcamcorder_videosink_window_set(MMHandleType handle, type_element* Videosi #ifdef _MMCAMCORDER_RM_SUPPORT int display_scaler = 0; #endif /* _MMCAMCORDER_RM_SUPPORT */ - int *overlay = NULL; + int *dp_handle = NULL; + MMCamWindowInfo *window_info = NULL; gulong xid; char *err_name = NULL; const char *videosink_name = NULL; @@ -1324,14 +1405,14 @@ int _mmcamcorder_videosink_window_set(MMHandleType handle, type_element* Videosi /* Get video display information */ err = mm_camcorder_get_attributes(handle, &err_name, - MMCAM_DISPLAY_RECT_X, &retx, - MMCAM_DISPLAY_RECT_Y, &rety, - MMCAM_DISPLAY_RECT_WIDTH, &retwidth, - MMCAM_DISPLAY_RECT_HEIGHT, &retheight, + MMCAM_DISPLAY_RECT_X, &rect_x, + MMCAM_DISPLAY_RECT_Y, &rect_y, + MMCAM_DISPLAY_RECT_WIDTH, &rect_width, + MMCAM_DISPLAY_RECT_HEIGHT, &rect_height, MMCAM_DISPLAY_ROTATION, &rotation, MMCAM_DISPLAY_FLIP, &flip, MMCAM_DISPLAY_VISIBLE, &visible, - MMCAM_DISPLAY_HANDLE, (void**)&overlay, &size, + MMCAM_DISPLAY_HANDLE, (void **)&dp_handle, &size, MMCAM_DISPLAY_MODE, &display_mode, MMCAM_DISPLAY_GEOMETRY_METHOD, &display_geometry_method, MMCAM_DISPLAY_SCALE, &zoom_attr, @@ -1350,13 +1431,17 @@ int _mmcamcorder_videosink_window_set(MMHandleType handle, type_element* Videosi _mmcamcorder_conf_get_value_element_name(VideosinkElement, &videosink_name); - _mmcam_dbg_log("(overlay=%p, size=%d)", overlay, size); + if (!videosink_name) { + _mmcam_dbg_err("failed to get videosink name"); + return MM_ERROR_CAMCORDER_INTERNAL; + } + + _mmcam_dbg_log("(dp_handle=%p, size=%d)", dp_handle, size); /* Set display handle */ - if (!strcmp(videosink_name, "xvimagesink") || - !strcmp(videosink_name, "ximagesink")) { - if (overlay) { - xid = *overlay; + if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "ximagesink")) { + if (dp_handle) { + xid = *dp_handle; _mmcam_dbg_log("xid = %lu )", xid); gst_video_overlay_set_window_handle(GST_VIDEO_OVERLAY(vsink), xid); } else { @@ -1370,26 +1455,46 @@ int _mmcamcorder_videosink_window_set(MMHandleType handle, type_element* Videosi MMCAMCORDER_G_OBJECT_SET(vsink, "device-scaler", display_scaler); #endif /* _MMCAMCORDER_RM_SUPPORT */ } else if (!strcmp(videosink_name, "evasimagesink") || !strcmp(videosink_name, "evaspixmapsink")) { - _mmcam_dbg_log("videosink : %s, handle : %p", videosink_name, overlay); + _mmcam_dbg_log("videosink : %s, handle : %p", videosink_name, dp_handle); - if (overlay) { - MMCAMCORDER_G_OBJECT_SET_POINTER(vsink, "evas-object", overlay); + if (dp_handle) { + MMCAMCORDER_G_OBJECT_SET_POINTER(vsink, "evas-object", dp_handle); MMCAMCORDER_G_OBJECT_SET(vsink, "origin-size", !do_scaling); } else { _mmcam_dbg_err("display handle(eavs object) is NULL"); return MM_ERROR_CAMCORDER_INVALID_ARGUMENT; } - } else if (!strcmp(videosink_name, "waylandsink") || !strcmp(videosink_name, "directvideosink")) { - MMCamWaylandInfo *wl_info = (MMCamWaylandInfo *)overlay; - - if (wl_info) { - _mmcam_dbg_log("wayland global surface id : %d", wl_info->global_surface_id); - gst_video_overlay_set_wl_window_wl_surface_id(GST_VIDEO_OVERLAY(vsink), (guintptr)wl_info->global_surface_id); - gst_video_overlay_set_render_rectangle(GST_VIDEO_OVERLAY(vsink), - wl_info->window_x, wl_info->window_y, wl_info->window_width, wl_info->window_height); + } else if (!strcmp(videosink_name, "tizenwlsink")) { + if (dp_handle) { + window_info = (MMCamWindowInfo *)dp_handle; + _mmcam_dbg_log("wayland global surface id : %d", window_info->surface_id); + gst_video_overlay_set_wl_window_wl_surface_id(GST_VIDEO_OVERLAY(vsink), window_info->surface_id); } else { _mmcam_dbg_warn("Handle is NULL. skip setting."); } + } else if (!strcmp(videosink_name, "directvideosink")) { + if (dp_handle) { + window_info = (MMCamWindowInfo *)dp_handle; + _mmcam_dbg_log("wayland global surface id : %d, x,y,w,h (%d,%d,%d,%d)", + window_info->surface_id, + window_info->rect.x, + window_info->rect.y, + window_info->rect.width, + window_info->rect.height); + gst_video_overlay_set_window_handle(GST_VIDEO_OVERLAY(vsink), (guintptr)window_info->surface_id); + gst_video_overlay_set_render_rectangle(GST_VIDEO_OVERLAY(vsink), + window_info->rect.x, + window_info->rect.y, + window_info->rect.width, + window_info->rect.height); + } else { + _mmcam_dbg_warn("dp_handle is null"); + } +#ifdef _MMCAMCORDER_RM_SUPPORT + if (hcamcorder->request_resources.category_id[0] == RM_CATEGORY_VIDEO_DECODER_SUB) + display_scaler = 1; + MMCAMCORDER_G_OBJECT_SET(vsink, "device-scaler", display_scaler); +#endif /* _MMCAMCORDER_RM_SUPPORT */ } else { _mmcam_dbg_warn("Who are you?? (Videosink: %s)", videosink_name); } @@ -1398,7 +1503,7 @@ int _mmcamcorder_videosink_window_set(MMHandleType handle, type_element* Videosi videosink_name, display_geometry_method, origin_size, visible, rotation, flip); /* Set attribute */ - if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "waylandsink") || + if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "tizenwlsink") || !strcmp(videosink_name, "evaspixmapsink") || !strcmp(videosink_name, "directvideosink")) { /* set rotation */ MMCAMCORDER_G_OBJECT_SET(vsink, "rotate", rotation); @@ -1428,12 +1533,17 @@ int _mmcamcorder_videosink_window_set(MMHandleType handle, type_element* Videosi MMCAMCORDER_G_OBJECT_SET(vsink, "zoom", zoom_level); if (display_geometry_method == MM_DISPLAY_METHOD_CUSTOM_ROI) { - g_object_set(vsink, - "dst-roi-x", retx, - "dst-roi-y", rety, - "dst-roi-w", retwidth, - "dst-roi-h", retheight, - NULL); + if (!strcmp(videosink_name, "tizenwlsink")) { + gst_video_overlay_set_display_roi_area(GST_VIDEO_OVERLAY(vsink), + rect_x, rect_y, rect_width, rect_height); + } else { + g_object_set(vsink, + "dst-roi-x", rect_x, + "dst-roi-y", rect_y, + "dst-roi-w", rect_width, + "dst-roi-h", rect_height, + NULL); + } } } @@ -1441,21 +1551,35 @@ int _mmcamcorder_videosink_window_set(MMHandleType handle, type_element* Videosi } -int _mmcamcorder_vframe_stablize(MMHandleType handle) +int _mmcamcorder_video_frame_stabilize(MMHandleType handle, int cmd) { + int category = 0; mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); _MMCamcorderSubContext *sc = NULL; - _mmcam_dbg_log("%d", _MMCAMCORDER_CAMSTABLE_COUNT); - mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED); sc = MMF_CAMCORDER_SUBCONTEXT(handle); mmf_return_val_if_fail(sc, MM_ERROR_CAMCORDER_NOT_INITIALIZED); - if (sc->cam_stability_count != _MMCAMCORDER_CAMSTABLE_COUNT) - sc->cam_stability_count = _MMCAMCORDER_CAMSTABLE_COUNT; + switch (cmd) { + case _MMCamcorder_CMD_PREVIEW_START: + category = CONFIGURE_CATEGORY_CTRL_CAMERA; + break; + case _MMCamcorder_CMD_CAPTURE: + category = CONFIGURE_CATEGORY_CTRL_CAPTURE; + break; + default: + _mmcam_dbg_warn("unknown command : %d", cmd); + return MM_ERROR_CAMCORDER_INVALID_ARGUMENT; + } + + _mmcamcorder_conf_get_value_int(handle, hcamcorder->conf_ctrl, + category, "FrameStabilityCount", &sc->frame_stability_count); + + _mmcam_dbg_log("[cmd %d] frame stability count : %d", + cmd, sc->frame_stability_count); return MM_ERROR_NONE; } @@ -1523,19 +1647,14 @@ static GstPadProbeReturn __mmcamcorder_video_dataprobe_preview(GstPad *pad, GstP _MMCamcorderSubContext *sc = NULL; _MMCamcorderKPIMeasure *kpi = NULL; GstBuffer *buffer = GST_PAD_PROBE_INFO_BUFFER(info); - GstMemory *dataBlock = NULL; - GstMemory *metaBlock = NULL; - GstMapInfo mapinfo; mmf_return_val_if_fail(buffer, GST_PAD_PROBE_DROP); - mmf_return_val_if_fail(gst_buffer_n_memory(buffer) , GST_PAD_PROBE_DROP); + mmf_return_val_if_fail(gst_buffer_n_memory(buffer), GST_PAD_PROBE_DROP); mmf_return_val_if_fail(hcamcorder, GST_PAD_PROBE_DROP); sc = MMF_CAMCORDER_SUBCONTEXT(u_data); mmf_return_val_if_fail(sc, GST_PAD_PROBE_DROP); - memset(&mapinfo, 0x0, sizeof(GstMapInfo)); - current_state = hcamcorder->state; if (sc->drop_vframe > 0) { @@ -1547,9 +1666,9 @@ static GstPadProbeReturn __mmcamcorder_video_dataprobe_preview(GstPad *pad, GstP _mmcam_dbg_log("Drop video frame by drop_vframe"); return GST_PAD_PROBE_DROP; } - } else if (sc->cam_stability_count > 0) { - sc->cam_stability_count--; - _mmcam_dbg_log("Drop video frame by cam_stability_count"); + } else if (sc->frame_stability_count > 0) { + sc->frame_stability_count--; + _mmcam_dbg_log("Drop video frame by frame_stability_count"); return GST_PAD_PROBE_DROP; } @@ -1591,18 +1710,26 @@ static GstPadProbeReturn __mmcamcorder_video_dataprobe_preview(GstPad *pad, GstP /* video stream callback */ if (hcamcorder->vstream_cb && buffer) { - GstCaps *caps = NULL; - GstStructure *structure = NULL; int state = MM_CAMCORDER_STATE_NULL; + int num_bos = 0; unsigned int fourcc = 0; - MMCamcorderVideoStreamDataType stream; - MMVideoBuffer *mm_buf = NULL; const gchar *string_format = NULL; - state = _mmcamcorder_get_state((MMHandleType)hcamcorder); - if (state < MM_CAMCORDER_STATE_PREPARE) { - _mmcam_dbg_warn("Not ready for stream callback"); - return GST_PAD_PROBE_OK; + MMCamcorderVideoStreamDataType stream; + tbm_surface_h t_surface = NULL; + tbm_surface_info_s t_info; + + GstCaps *caps = NULL; + GstStructure *structure = NULL; + GstMemory *memory = NULL; + GstMapInfo mapinfo; + + if (sc->info_image->preview_format != MM_PIXEL_FORMAT_ENCODED_H264) { + state = _mmcamcorder_get_state((MMHandleType)hcamcorder); + if (state < MM_CAMCORDER_STATE_PREPARE) { + _mmcam_dbg_warn("Not ready for stream callback"); + return GST_PAD_PROBE_OK; + } } caps = gst_pad_get_current_caps(pad); @@ -1611,7 +1738,8 @@ static GstPadProbeReturn __mmcamcorder_video_dataprobe_preview(GstPad *pad, GstP return GST_PAD_PROBE_OK; } - /* clear stream data structure */ + /* clear data structure */ + memset(&mapinfo, 0x0, sizeof(GstMapInfo)); memset(&stream, 0x0, sizeof(MMCamcorderVideoStreamDataType)); structure = gst_caps_get_structure(caps, 0); @@ -1647,31 +1775,59 @@ static GstPadProbeReturn __mmcamcorder_video_dataprobe_preview(GstPad *pad, GstP } /* set size and timestamp */ - dataBlock = gst_buffer_peek_memory(buffer, 0); - stream.length_total = gst_memory_get_sizes(dataBlock, NULL, NULL); - stream.timestamp = (unsigned int)(GST_BUFFER_PTS(buffer)/1000000); /* nano sec -> mili sec */ + if (sc->info_image->preview_format == MM_PIXEL_FORMAT_ENCODED_H264) + memory = gst_buffer_get_all_memory(buffer); + else + memory = gst_buffer_peek_memory(buffer, 0); + if (!memory) { + _mmcam_dbg_err("GstMemory get failed from buffer %p", buffer); + return GST_PAD_PROBE_OK; + } + + if (hcamcorder->use_zero_copy_format) { + t_surface = (tbm_surface_h)gst_tizen_memory_get_surface(memory); + + if (tbm_surface_get_info(t_surface, &t_info) != TBM_SURFACE_ERROR_NONE) { + _mmcam_dbg_err("failed to get tbm surface[%p] info", t_surface); + return GST_PAD_PROBE_OK; + } + + stream.length_total = t_info.size; - if (hcamcorder->use_zero_copy_format && gst_buffer_n_memory(buffer) > 1) { - metaBlock = gst_buffer_peek_memory(buffer, 1); - gst_memory_map(metaBlock, &mapinfo, GST_MAP_READ); - mm_buf = (MMVideoBuffer *)mapinfo.data; + /* set bo, stride and elevation */ + num_bos = gst_tizen_memory_get_num_bos(memory); + for (i = 0 ; i < num_bos ; i++) + stream.bo[i] = gst_tizen_memory_get_bos(memory, i); + + for (i = 0 ; i < t_info.num_planes ; i++) { + stream.stride[i] = t_info.planes[i].stride; + stream.elevation[i] = t_info.planes[i].size / t_info.planes[i].stride; + /*_mmcam_dbg_log("[%d] %dx%d", i, stream.stride[i], stream.elevation[i]);*/ + } + + /* set gst buffer */ + stream.internal_buffer = buffer; + } else { + stream.length_total = gst_memory_get_sizes(memory, NULL, NULL); } + stream.timestamp = (unsigned int)(GST_BUFFER_PTS(buffer)/1000000); /* nano sec -> mili sec */ + /* set data pointers */ if (stream.format == MM_PIXEL_FORMAT_NV12 || - stream.format == MM_PIXEL_FORMAT_NV21 || - stream.format == MM_PIXEL_FORMAT_I420) { - if (mm_buf) { + stream.format == MM_PIXEL_FORMAT_NV21 || + stream.format == MM_PIXEL_FORMAT_I420) { + if (hcamcorder->use_zero_copy_format) { if (stream.format == MM_PIXEL_FORMAT_NV12 || stream.format == MM_PIXEL_FORMAT_NV21) { stream.data_type = MM_CAM_STREAM_DATA_YUV420SP; stream.num_planes = 2; - stream.data.yuv420sp.y = mm_buf->data[0]; - stream.data.yuv420sp.length_y = stream.width * stream.height; - stream.data.yuv420sp.uv = mm_buf->data[1]; - stream.data.yuv420sp.length_uv = stream.data.yuv420sp.length_y >> 1; + stream.data.yuv420sp.y = t_info.planes[0].ptr; + stream.data.yuv420sp.length_y = t_info.planes[0].size; + stream.data.yuv420sp.uv = t_info.planes[1].ptr; + stream.data.yuv420sp.length_uv = t_info.planes[1].size; /* - _mmcam_dbg_log("format[%d][num_planes:%d] [Y]p:0x%x,size:%d [UV]p:0x%x,size:%d", + _mmcam_dbg_log("format[%d][num_planes:%d] [Y]p:%p,size:%d [UV]p:%p,size:%d", stream.format, stream.num_planes, stream.data.yuv420sp.y, stream.data.yuv420sp.length_y, stream.data.yuv420sp.uv, stream.data.yuv420sp.length_uv); @@ -1679,14 +1835,14 @@ static GstPadProbeReturn __mmcamcorder_video_dataprobe_preview(GstPad *pad, GstP } else { stream.data_type = MM_CAM_STREAM_DATA_YUV420P; stream.num_planes = 3; - stream.data.yuv420p.y = mm_buf->data[0]; - stream.data.yuv420p.length_y = stream.width * stream.height; - stream.data.yuv420p.u = mm_buf->data[1]; - stream.data.yuv420p.length_u = stream.data.yuv420p.length_y >> 2; - stream.data.yuv420p.v = mm_buf->data[2]; - stream.data.yuv420p.length_v = stream.data.yuv420p.length_u; + stream.data.yuv420p.y = t_info.planes[0].ptr; + stream.data.yuv420p.length_y = t_info.planes[0].size; + stream.data.yuv420p.u = t_info.planes[1].ptr; + stream.data.yuv420p.length_u = t_info.planes[1].size; + stream.data.yuv420p.v = t_info.planes[2].ptr; + stream.data.yuv420p.length_v = t_info.planes[2].size; /* - _mmcam_dbg_log("S420[num_planes:%d] [Y]p:0x%x,size:%d [U]p:0x%x,size:%d [V]p:0x%x,size:%d", + _mmcam_dbg_log("S420[num_planes:%d] [Y]p:%p,size:%d [U]p:%p,size:%d [V]p:%p,size:%d", stream.num_planes, stream.data.yuv420p.y, stream.data.yuv420p.length_y, stream.data.yuv420p.u, stream.data.yuv420p.length_u, @@ -1694,9 +1850,9 @@ static GstPadProbeReturn __mmcamcorder_video_dataprobe_preview(GstPad *pad, GstP */ } } else { - gst_memory_map(dataBlock, &mapinfo, GST_MAP_READWRITE); + gst_memory_map(memory, &mapinfo, GST_MAP_READWRITE); if (stream.format == MM_PIXEL_FORMAT_NV12 || - stream.format == MM_PIXEL_FORMAT_NV21) { + stream.format == MM_PIXEL_FORMAT_NV21) { stream.data_type = MM_CAM_STREAM_DATA_YUV420SP; stream.num_planes = 2; stream.data.yuv420sp.y = mapinfo.data; @@ -1708,7 +1864,7 @@ static GstPadProbeReturn __mmcamcorder_video_dataprobe_preview(GstPad *pad, GstP stream.stride[1] = stream.width; stream.elevation[1] = stream.height >> 1; /* - _mmcam_dbg_log("format[%d][num_planes:%d] [Y]p:0x%x,size:%d [UV]p:0x%x,size:%d", + _mmcam_dbg_log("format[%d][num_planes:%d] [Y]p:%p,size:%d [UV]p:%p,size:%d", stream.format, stream.num_planes, stream.data.yuv420sp.y, stream.data.yuv420sp.length_y, stream.data.yuv420sp.uv, stream.data.yuv420sp.length_uv); @@ -1729,7 +1885,7 @@ static GstPadProbeReturn __mmcamcorder_video_dataprobe_preview(GstPad *pad, GstP stream.stride[2] = stream.width >> 1; stream.elevation[2] = stream.height >> 1; /* - _mmcam_dbg_log("I420[num_planes:%d] [Y]p:0x%x,size:%d [U]p:0x%x,size:%d [V]p:0x%x,size:%d", + _mmcam_dbg_log("I420[num_planes:%d] [Y]p:%p,size:%d [U]p:%p,size:%d [V]p:%p,size:%d", stream.num_planes, stream.data.yuv420p.y, stream.data.yuv420p.length_y, stream.data.yuv420p.u, stream.data.yuv420p.length_u, @@ -1738,73 +1894,78 @@ static GstPadProbeReturn __mmcamcorder_video_dataprobe_preview(GstPad *pad, GstP } } } else { - if (mm_buf) { - gst_memory_unmap(metaBlock, &mapinfo); - metaBlock = NULL; - } - gst_memory_map(dataBlock, &mapinfo, GST_MAP_READWRITE); - if (stream.format == MM_PIXEL_FORMAT_YUYV || - stream.format == MM_PIXEL_FORMAT_UYVY || - stream.format == MM_PIXEL_FORMAT_422P || - stream.format == MM_PIXEL_FORMAT_ITLV_JPEG_UYVY) { + gst_memory_map(memory, &mapinfo, GST_MAP_READWRITE); + + switch (stream.format) { + case MM_PIXEL_FORMAT_YUYV: + case MM_PIXEL_FORMAT_UYVY: + case MM_PIXEL_FORMAT_422P: + case MM_PIXEL_FORMAT_ITLV_JPEG_UYVY: stream.data_type = MM_CAM_STREAM_DATA_YUV422; stream.data.yuv422.yuv = mapinfo.data; stream.data.yuv422.length_yuv = stream.length_total; stream.stride[0] = stream.width << 1; stream.elevation[0] = stream.height; - } else if (stream.format == MM_PIXEL_FORMAT_ENCODED_H264) { - 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("H264[num_planes:%d] [0]p:0x%x,size:%d", - fourcc, fourcc>>8, fourcc>>16, fourcc>>24, stream.num_planes, - stream.data.encoded.data, stream.data.encoded.length_data); - } else { + break; + case MM_PIXEL_FORMAT_ENCODED_H264: + 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("H264[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: + stream.data_type = MM_CAM_STREAM_DATA_DEPTH; + stream.data.depth.data = mapinfo.data; + stream.data.depth.length_data = stream.length_total; + stream.stride[0] = stream.width << 1; + stream.elevation[0] = stream.height; + break; + case MM_PIXEL_FORMAT_RGBA: + case MM_PIXEL_FORMAT_ARGB: + stream.data_type = MM_CAM_STREAM_DATA_RGB; + stream.data.rgb.data = mapinfo.data; + stream.data.rgb.length_data = stream.length_total; + stream.stride[0] = stream.width << 2; + stream.elevation[0] = stream.height; + break; + default: stream.data_type = MM_CAM_STREAM_DATA_YUV420; stream.data.yuv420.yuv = mapinfo.data; stream.data.yuv420.length_yuv = stream.length_total; stream.stride[0] = (stream.width * 3) >> 1; stream.elevation[0] = stream.height; + break; } stream.num_planes = 1; /* - _mmcam_dbg_log("%c%c%c%c[num_planes:%d] [0]p:0x%x,size:%d", + _mmcam_dbg_log("%c%c%c%c[num_planes:%d] [0]p:%p,size:%d", fourcc, fourcc>>8, fourcc>>16, fourcc>>24, stream.num_planes, stream.data.yuv420.yuv, stream.data.yuv420.length_yuv); */ } - /* set tbm bo */ - if (mm_buf && mm_buf->type == MM_VIDEO_BUFFER_TYPE_TBM_BO) { - /* set bo, stride and elevation */ - for (i = 0 ; i < MM_VIDEO_BUFFER_PLANE_MAX ; i++) { - stream.bo[i] = (void *)mm_buf->handle.bo[i]; - stream.stride[i] = mm_buf->stride_width[i]; - stream.elevation[i] = mm_buf->stride_height[i]; - } - - /* set gst buffer */ - stream.internal_buffer = buffer; - } - /* call application callback */ _MMCAMCORDER_LOCK_VSTREAM_CALLBACK(hcamcorder); if (hcamcorder->vstream_cb) { hcamcorder->vstream_cb(&stream, hcamcorder->vstream_cb_param); - for (i = 0 ; i < MM_VIDEO_BUFFER_PLANE_MAX && stream.bo[i] ; i++) { + 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]); } } _MMCAMCORDER_UNLOCK_VSTREAM_CALLBACK(hcamcorder); - /* Either metaBlock was mapped, or dataBlock, but not both. */ - if (metaBlock) - gst_memory_unmap(metaBlock, &mapinfo); - else - gst_memory_unmap(dataBlock, &mapinfo); + + /* unmap memory */ + if (mapinfo.data) + gst_memory_unmap(memory, &mapinfo); + if (sc->info_image->preview_format == MM_PIXEL_FORMAT_ENCODED_H264) + gst_memory_unref(memory); } return GST_PAD_PROBE_OK; @@ -1827,7 +1988,7 @@ static GstPadProbeReturn __mmcamcorder_video_dataprobe_push_buffer_to_record(Gst /* push buffer in appsrc to encode */ if (!sc->info_video) { _mmcam_dbg_warn("sc->info_video is NULL!!"); - return FALSE; + return GST_PAD_PROBE_DROP; } if (sc->info_video->push_encoding_buffer == PUSH_ENCODING_BUFFER_RUN && @@ -1855,7 +2016,6 @@ static GstPadProbeReturn __mmcamcorder_video_dataprobe_push_buffer_to_record(Gst if (sc->encode_element[_MMCAMCORDER_AUDIOSRC_SRC].gst) { if (sc->info_video->is_firstframe) { - sc->info_video->is_firstframe = FALSE; clock = GST_ELEMENT_CLOCK(sc->encode_element[_MMCAMCORDER_AUDIOSRC_SRC].gst); if (clock) { gst_object_ref(clock); @@ -1873,7 +2033,6 @@ static GstPadProbeReturn __mmcamcorder_video_dataprobe_push_buffer_to_record(Gst g_cond_signal(&hcamcorder->task_thread_cond); g_mutex_unlock(&hcamcorder->task_thread_lock); } - sc->info_video->is_firstframe = FALSE; sc->info_video->base_video_ts = GST_BUFFER_PTS(buffer); } } @@ -1901,6 +2060,16 @@ static GstPadProbeReturn __mmcamcorder_video_dataprobe_push_buffer_to_record(Gst g_signal_emit_by_name(sc->encode_element[_MMCAMCORDER_ENCSINK_SRC].gst, "push-buffer", buffer, &ret); /*_mmcam_dbg_log("push buffer result : 0x%x", ret);*/ + + if (sc->info_video->is_firstframe) { + sc->info_video->is_firstframe = FALSE; + + /* drop buffer if it's from tizen allocator */ + if (gst_is_tizen_memory(gst_buffer_peek_memory(buffer, 0))) { + _mmcam_dbg_warn("drop first buffer from tizen allocator to avoid copy in basesrc"); + return GST_PAD_PROBE_DROP; + } + } } /* skip display if too fast FPS */ @@ -1922,27 +2091,188 @@ static GstPadProbeReturn __mmcamcorder_video_dataprobe_push_buffer_to_record(Gst } +GstPadProbeReturn __mmcamcorder_muxed_dataprobe(GstPad *pad, GstPadProbeInfo *info, gpointer u_data) +{ + MMCamcorderMuxedStreamDataType stream; + mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(u_data); + _MMCamcorderSubContext *sc = NULL; + GstBuffer *buffer = GST_PAD_PROBE_INFO_BUFFER(info); + GstMapInfo mapinfo; + + mmf_return_val_if_fail(buffer, GST_PAD_PROBE_OK); + mmf_return_val_if_fail(gst_buffer_n_memory(buffer), GST_PAD_PROBE_OK); + mmf_return_val_if_fail(hcamcorder, GST_PAD_PROBE_OK); + + sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder); + mmf_return_val_if_fail(sc, GST_PAD_PROBE_OK); + + if (!gst_buffer_map(buffer, &mapinfo, GST_MAP_READ)) { + _mmcam_dbg_warn("map failed : buffer %p", buffer); + return GST_PAD_PROBE_OK; + } + + /* call application callback */ + _MMCAMCORDER_LOCK_MSTREAM_CALLBACK(hcamcorder); + + if (hcamcorder->mstream_cb) { + stream.data = (void *)mapinfo.data; + stream.length = mapinfo.size; + stream.offset = sc->muxed_stream_offset; + hcamcorder->mstream_cb(&stream, hcamcorder->mstream_cb_param); + } + + _MMCAMCORDER_UNLOCK_MSTREAM_CALLBACK(hcamcorder); + + /* calculate current offset */ + sc->muxed_stream_offset += mapinfo.size; + + gst_buffer_unmap(buffer, &mapinfo); + + return GST_PAD_PROBE_OK; +} + + +GstPadProbeReturn __mmcamcorder_eventprobe_monitor(GstPad *pad, GstPadProbeInfo *info, gpointer u_data) +{ + GstEvent *event = GST_PAD_PROBE_INFO_EVENT(info); + mmf_camcorder_t *hcamcorder = NULL; + _MMCamcorderSubContext *sc = NULL; + GstObject *parent = NULL; + + switch (GST_EVENT_TYPE(event)) { + case GST_EVENT_UNKNOWN: + /* upstream events */ + case GST_EVENT_QOS: + case GST_EVENT_SEEK: + case GST_EVENT_NAVIGATION: + case GST_EVENT_LATENCY: + /* downstream serialized events */ + case GST_EVENT_BUFFERSIZE: + _mmcam_dbg_log("[%s:%s] gots %s", GST_DEBUG_PAD_NAME(pad), GST_EVENT_TYPE_NAME(event)); + break; + case GST_EVENT_TAG: + { + GstTagList *tag_list = NULL; + _MMCamcorderReplayGain *replay_gain = NULL; + + _mmcam_dbg_log("[%s:%s] gots %s", GST_DEBUG_PAD_NAME(pad), GST_EVENT_TYPE_NAME(event)); + + hcamcorder = MMF_CAMCORDER(u_data); + if (!hcamcorder || !hcamcorder->sub_context) { + _mmcam_dbg_warn("NULL handle"); + break; + } + + replay_gain = &hcamcorder->sub_context->replay_gain; + + gst_event_parse_tag(event, &tag_list); + if (!tag_list) { + _mmcam_dbg_warn("failed to get tag list"); + break; + } + + if (!gst_tag_list_get_double(tag_list, GST_TAG_TRACK_PEAK, &replay_gain->track_peak)) { + _mmcam_dbg_warn("failed to get GST_TAG_TRACK_PEAK"); + break; + } + + if (!gst_tag_list_get_double(tag_list, GST_TAG_TRACK_GAIN, &replay_gain->track_gain)) { + _mmcam_dbg_warn("failed to get GST_TAG_TRACK_GAIN"); + break; + } + + if (!gst_tag_list_get_double(tag_list, GST_TAG_ALBUM_PEAK, &replay_gain->album_peak)) { + _mmcam_dbg_warn("failed to get GST_TAG_ALBUM_PEAK"); + break; + } + + if (!gst_tag_list_get_double(tag_list, GST_TAG_ALBUM_GAIN, &replay_gain->album_gain)) { + _mmcam_dbg_warn("failed to get GST_TAG_ALBUM_PEAK"); + break; + } + + _mmcam_dbg_log("Track [peak %lf, gain %lf], Album [peak %lf, gain %lf]", + replay_gain->track_peak, replay_gain->track_gain, + replay_gain->album_peak, replay_gain->album_gain); + } + break; + case GST_EVENT_SEGMENT: + _mmcam_dbg_log("[%s:%s] gots %s", GST_DEBUG_PAD_NAME(pad), GST_EVENT_TYPE_NAME(event)); + + hcamcorder = MMF_CAMCORDER(u_data); + if (!hcamcorder) { + _mmcam_dbg_warn("NULL handle"); + break; + } + + sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder); + if (!sc) { + _mmcam_dbg_warn("NULL sub context"); + break; + } + + if (!sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst) { + _mmcam_dbg_warn("no encoder sink"); + break; + } + + parent = gst_pad_get_parent(pad); + if (!parent) { + _mmcam_dbg_warn("get parent failed"); + break; + } + + if (parent == (GstObject *)sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst) { + const GstSegment *segment; + gst_event_parse_segment(event, &segment); + if (segment->format == GST_FORMAT_BYTES) { + _mmcam_dbg_log("change current offset %llu -> %"G_GUINT64_FORMAT, + sc->muxed_stream_offset, segment->start); + + sc->muxed_stream_offset = (unsigned long long)segment->start; + } + } + + gst_object_unref(parent); + parent = NULL; + break; + case GST_EVENT_EOS: + _mmcam_dbg_warn("[%s:%s] gots %s", GST_DEBUG_PAD_NAME(pad), GST_EVENT_TYPE_NAME(event)); + break; + /* bidirectional events */ + case GST_EVENT_FLUSH_START: + case GST_EVENT_FLUSH_STOP: + _mmcam_dbg_err("[%s:%s] gots %s", GST_DEBUG_PAD_NAME(pad), GST_EVENT_TYPE_NAME(event)); + break; + default: + _mmcam_dbg_log("[%s:%s] gots %s", GST_DEBUG_PAD_NAME(pad), GST_EVENT_TYPE_NAME(event)); + break; + } + + return GST_PAD_PROBE_OK; +} + + int __mmcamcorder_get_amrnb_bitrate_mode(int bitrate) { int result = MM_CAMCORDER_MR475; - if (bitrate < 5150) { + if (bitrate < 5150) result = MM_CAMCORDER_MR475; /*AMR475*/ - } else if (bitrate < 5900) { + else if (bitrate < 5900) result = MM_CAMCORDER_MR515; /*AMR515*/ - } else if (bitrate < 6700) { + else if (bitrate < 6700) result = MM_CAMCORDER_MR59; /*AMR59*/ - } else if (bitrate < 7400) { + else if (bitrate < 7400) result = MM_CAMCORDER_MR67; /*AMR67*/ - } else if (bitrate < 7950) { + else if (bitrate < 7950) result = MM_CAMCORDER_MR74; /*AMR74*/ - } else if (bitrate < 10200) { + else if (bitrate < 10200) result = MM_CAMCORDER_MR795; /*AMR795*/ - } else if (bitrate < 12200) { + else if (bitrate < 12200) result = MM_CAMCORDER_MR102; /*AMR102*/ - } else { + else result = MM_CAMCORDER_MR122; /*AMR122*/ - } return result; } @@ -1970,6 +2300,9 @@ int _mmcamcorder_get_eos_message(MMHandleType handle) _mmcam_dbg_log("EOS signal received"); } else { _mmcam_dbg_err("EOS wait time out"); + + if (hcamcorder->error_code == MM_ERROR_NONE) + hcamcorder->error_code = MM_ERROR_CAMCORDER_RESPONSE_TIMEOUT; } } else { _mmcam_dbg_log("already got EOS"); @@ -2038,7 +2371,7 @@ int _mmcamcorder_check_codec_fileformat_compatibility(const char *codec_type, in } else if (!strcmp(codec_type, MMCAM_VIDEO_ENCODER)) { if (codec > MM_VIDEO_CODEC_INVALID && codec < MM_VIDEO_CODEC_NUM && file_format > MM_FILE_FORMAT_INVALID && file_format < MM_FILE_FORMAT_NUM) { - if (videocodec_fileformat_compatibility_table[ codec][file_format] == 0) { + if (videocodec_fileformat_compatibility_table[codec][file_format] == 0) { _mmcam_dbg_err("Video codec[%d] and file format[%d] compatibility FAILED.", codec, file_format); return MM_ERROR_CAMCORDER_ENCODER_WRONG_TYPE; } @@ -2126,16 +2459,16 @@ bool _mmcamcorder_set_display_rotation(MMHandleType handle, int display_rotate, return FALSE; } - if (!strcmp(videosink_name, "waylandsink") || !strcmp(videosink_name, "xvimagesink") || + if (!strcmp(videosink_name, "tizenwlsink") || !strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "evasimagesink") || !strcmp(videosink_name, "evaspixmapsink") || !strcmp(videosink_name, "directvideosink")) { MMCAMCORDER_G_OBJECT_SET(sc->element[videosink_index].gst, "rotate", display_rotate); _mmcam_dbg_log("Set display-rotate [%d] done.", display_rotate); - return TRUE; } else { - _mmcam_dbg_warn("videosink[%s] does not support DISPLAY_ROTATION.", videosink_name); - return FALSE; + _mmcam_dbg_warn("[%s] does not support DISPLAY_ROTATION, but no error", videosink_name); } + + return TRUE; } else { _mmcam_dbg_err("Videosink element is null"); return FALSE; @@ -2165,16 +2498,16 @@ bool _mmcamcorder_set_display_flip(MMHandleType handle, int display_flip, int vi return FALSE; } - if (!strcmp(videosink_name, "waylandsink") || !strcmp(videosink_name, "xvimagesink") || + if (!strcmp(videosink_name, "tizenwlsink") || !strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "evasimagesink") || !strcmp(videosink_name, "evaspixmapsink") || !strcmp(videosink_name, "directvideosink")) { MMCAMCORDER_G_OBJECT_SET(sc->element[videosink_index].gst, "flip", display_flip); _mmcam_dbg_log("Set display flip [%d] done.", display_flip); - return TRUE; } else { - _mmcam_dbg_warn("videosink[%s] does not support DISPLAY_FLIP", videosink_name); - return FALSE; + _mmcam_dbg_warn("[%s] does not support DISPLAY_FLIP, but no error", videosink_name); } + + return TRUE; } else { _mmcam_dbg_err("Videosink element is null"); return FALSE; @@ -2222,13 +2555,6 @@ bool _mmcamcorder_set_videosrc_caps(MMHandleType handle, unsigned int fourcc, in gboolean do_set_caps = FALSE; GstCaps *caps = NULL; -#ifdef _MMCAMCORDER_PRODUCT_TV - GstPad *sinkpad; - GstCaps *decsink_caps = NULL; - GstStructure *decsink_struct = NULL; - int maxwidth = 0; - int maxheight = 0; -#endif /*_MMCAMCORDER_PRODUCT_TV */ mmf_camcorder_t *hcamcorder = NULL; _MMCamcorderSubContext *sc = NULL; @@ -2270,11 +2596,8 @@ bool _mmcamcorder_set_videosrc_caps(MMHandleType handle, unsigned int fourcc, in motion_rate, capture_width, capture_height, fps_auto, sc->info_video->video_width, sc->info_video->video_height); - if (motion_rate != _MMCAMCORDER_DEFAULT_RECORDING_MOTION_RATE) { - MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "high-speed-fps", fps); - } else { - MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "high-speed-fps", 0); - } + MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, + "high-speed-fps", (motion_rate != _MMCAMCORDER_DEFAULT_RECORDING_MOTION_RATE ? 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); @@ -2394,34 +2717,21 @@ bool _mmcamcorder_set_videosrc_caps(MMHandleType handle, unsigned int fourcc, in if (do_set_caps) { if (sc->info_image->preview_format == MM_PIXEL_FORMAT_ENCODED_H264) { #ifdef _MMCAMCORDER_PRODUCT_TV - sinkpad = gst_element_get_static_pad(sc->element[_MMCAMCORDER_VIDEOSRC_DECODE].gst, "sink"); - if (!sinkpad) { - _mmcam_dbg_err("There are no decoder caps"); - return FALSE; - } - - decsink_caps = gst_pad_get_pad_template_caps(sinkpad); - if (!decsink_caps) { - gst_object_unref(sinkpad); - _mmcam_dbg_err("There is no decoder sink caps"); - return FALSE; - } + gint maxwidth = 0; + gint maxheight = 0; + int display_surface_type = MM_DISPLAY_SURFACE_NULL; + mm_camcorder_get_attributes(handle, NULL, + MMCAM_DISPLAY_SURFACE, &display_surface_type, + NULL); - decsink_struct = gst_caps_get_structure(decsink_caps, 0); - if (!decsink_struct) { - _mmcam_dbg_err("There are no structure from caps"); - gst_object_unref(decsink_caps); - gst_object_unref(sinkpad); - return 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) { + maxwidth = set_width; + maxheight = set_height; } - - if (gst_structure_has_field(decsink_struct, "maxwidth")) - gst_structure_get_int(decsink_struct, "maxwidth", &maxwidth); - - if (gst_structure_has_field(decsink_struct, "maxheight")) - gst_structure_get_int(decsink_struct, "maxheight", &maxheight); #endif /* _MMCAMCORDER_PRODUCT_TV */ - caps = gst_caps_new_simple("video/x-h264", "width", G_TYPE_INT, set_width, "height", G_TYPE_INT, set_height, @@ -2433,11 +2743,6 @@ bool _mmcamcorder_set_videosrc_caps(MMHandleType handle, unsigned int fourcc, in "alignment", G_TYPE_STRING, "au", #endif /* _MMCAMCORDER_PRODUCT_TV */ NULL); - -#ifdef _MMCAMCORDER_PRODUCT_TV - gst_object_unref(decsink_caps); - gst_object_unref(sinkpad); -#endif /* _MMCAMCORDER_PRODUCT_TV */ } else { char fourcc_string[sizeof(fourcc)+1]; strncpy(fourcc_string, (char*)&fourcc, sizeof(fourcc)); @@ -2452,7 +2757,16 @@ bool _mmcamcorder_set_videosrc_caps(MMHandleType handle, unsigned int fourcc, in } if (caps) { - _mmcam_dbg_log("vidoesrc new caps set. %"GST_PTR_FORMAT, caps); + gchar *caps_str = gst_caps_to_string(caps); + + if (caps_str) { + _mmcam_dbg_log("vidoesrc new caps set [%s]", caps_str); + g_free(caps_str); + caps_str = NULL; + } else { + _mmcam_dbg_warn("caps string failed"); + } + MMCAMCORDER_G_OBJECT_SET_POINTER(sc->element[_MMCAMCORDER_VIDEOSRC_FILT].gst, "caps", caps); gst_caps_unref(caps); caps = NULL; @@ -2583,7 +2897,7 @@ bool _mmcamcorder_set_videosrc_stabilization(MMHandleType handle, int stabilizat if (sc->info_image->preview_format == MM_PIXEL_FORMAT_NV12 && video_width >= 1080 && video_height >= 720) { _mmcam_dbg_log("NV12, video size %dx%d, ENABLE video stabilization", - video_width, video_height, stabilization); + video_width, video_height); /* set vdis mode */ g_object_set(G_OBJECT(v_src), "enable-vdis-mode", TRUE, @@ -2664,21 +2978,18 @@ bool _mmcamcorder_set_encoded_preview_bitrate(MMHandleType handle, int bitrate) CameraControl = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst); controls = gst_camera_control_list_channels(CameraControl); - _mmcam_dbg_log("controls : 0x%x", controls); + _mmcam_dbg_log("controls : %p", controls); if (controls != NULL) { - _mmcam_dbg_log("controls : 0x%x", controls); for (item = controls ; item && item->data ; item = item->next) { CameraControlChannel = item->data; - _mmcam_dbg_log("label : %d", CameraControlChannel->label); + _mmcam_dbg_log("label : %s", CameraControlChannel->label); if (!strcmp(CameraControlChannel->label, "bitrate")) { _mmcam_dbg_log("set encoded preview bitrate %d", bitrate); return gst_camera_control_set_value(CameraControl, CameraControlChannel, bitrate); } } - if (item == NULL) { - _mmcam_dbg_warn("failed to find \"bitrate\" control channel"); - } + _mmcam_dbg_warn("failed to find \"bitrate\" control channel"); } return FALSE; @@ -2727,7 +3038,7 @@ bool _mmcamcorder_set_sound_stream_info(GstElement *element, char *stream_type, "props,media.role=%s, media.parent_id=%d", stream_type, stream_index); - _mmcam_dbg_log("stream type %s, index %d -> [%s]", stream_type, stream_index, stream_props); + _mmcam_dbg_warn("stream type %s, index %d -> [%s]", stream_type, stream_index, stream_props); props = gst_structure_from_string(stream_props, NULL); if (!props) { @@ -2872,3 +3183,65 @@ bool _mmcamcorder_recreate_decoder_for_encoded_preview(MMHandleType handle) return TRUE; } + +#ifdef _MMCAMCORDER_PRODUCT_TV +static bool __mmcamcorder_find_max_resolution(MMHandleType handle, gint *max_width, gint *max_height) +{ + _MMCamcorderSubContext *sc = NULL; + mmf_camcorder_t *hcamcorder = NULL; + int index = 0; + const gchar *mime = NULL; + GstPad *sinkpad; + GstCaps *decsink_caps = NULL; + GstStructure *decsink_struct = NULL; + + mmf_return_val_if_fail(handle, false); + mmf_return_val_if_fail(max_width, false); + mmf_return_val_if_fail(max_height, false); + + hcamcorder = MMF_CAMCORDER(handle); + mmf_return_val_if_fail(hcamcorder, false); + + sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder); + + sinkpad = gst_element_get_static_pad(sc->element[_MMCAMCORDER_VIDEOSRC_DECODE].gst, "sink"); + if (!sinkpad) { + _mmcam_dbg_err("There are no decoder caps"); + return false; + } + + decsink_caps = gst_pad_get_pad_template_caps(sinkpad); + if (!decsink_caps) { + gst_object_unref(sinkpad); + _mmcam_dbg_err("There is no decoder sink caps"); + return false; + } + + for (index = 0; index < gst_caps_get_size(decsink_caps); index++) { + decsink_struct = gst_caps_get_structure(decsink_caps, index); + if (!decsink_struct) { + _mmcam_dbg_err("There are no structure from caps"); + gst_object_unref(decsink_caps); + gst_object_unref(sinkpad); + return false; + } + mime = gst_structure_get_name(decsink_struct); + if (!strcmp(mime, "video/x-h264")) { + _mmcam_dbg_log("h264 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); + gst_object_unref(decsink_caps); + gst_object_unref(sinkpad); + + if (*max_width <= 0 || *max_height <= 0) + return false; + + return true; +} +#endif /* _MMCAMCORDER_PRODUCT_TV */