X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fmm_camcorder_util.c;h=c7c7093a76415295ded192ed9c676905dcf0da6a;hb=f0e15b6c1cbf6b315d5d0de97a7996f9c74733dd;hp=6f342c6fff74836d2eda0ef107cd046a64b587c4;hpb=bbe7eed533e7deb4961d494bead66b90c39dda39;p=platform%2Fcore%2Fmultimedia%2Flibmm-camcorder.git diff --git a/src/mm_camcorder_util.c b/src/mm_camcorder_util.c index 6f342c6..c7c7093 100644 --- a/src/mm_camcorder_util.c +++ b/src/mm_camcorder_util.c @@ -25,6 +25,7 @@ #include #include #include +#include #include /* struct statfs */ #include /* gettimeofday */ #include @@ -34,6 +35,7 @@ #include "mm_camcorder_internal.h" #include "mm_camcorder_util.h" #include "mm_camcorder_sound.h" +#include #include #include @@ -46,6 +48,8 @@ -----------------------------------------------------------------------*/ #define TIME_STRING_MAX_LEN 64 #define __MMCAMCORDER_CAPTURE_WAIT_TIMEOUT 5 +#define __MMCAMCORDER_MAX_WIDTH 8192 +#define __MMCAMCORDER_MAX_HEIGHT 8192 #define FPUTC_CHECK(x_char, x_file) \ { \ @@ -75,9 +79,6 @@ static inline gboolean write_tag(FILE *f, const gchar *tag); static inline gboolean write_to_32(FILE *f, guint val); static inline gboolean write_to_16(FILE *f, guint val); static inline gboolean write_to_24(FILE *f, guint val); -#ifdef _USE_YUV_TO_RGB888_ -static gboolean _mmcamcorder_convert_YUV_to_RGB888(unsigned char *src, int src_fmt, guint width, guint height, unsigned char **dst, unsigned int *dst_len); -#endif /* _USE_YUV_TO_RGB888_ */ static gboolean _mmcamcorder_convert_YUYV_to_I420(unsigned char *src, guint width, guint height, unsigned char **dst, unsigned int *dst_len); static gboolean _mmcamcorder_convert_UYVY_to_I420(unsigned char *src, guint width, guint height, unsigned char **dst, unsigned int *dst_len); static gboolean _mmcamcorder_convert_NV12_to_I420(unsigned char *src, guint width, guint height, unsigned char **dst, unsigned int *dst_len); @@ -105,14 +106,14 @@ static int __gdbus_method_call_sync(GDBusConnection *conn, const char *bus_name, return MM_ERROR_INVALID_ARGUMENT; } - _mmcam_dbg_log("Dbus call - obj [%s], iface [%s], method [%s]", object, iface, method); + _mmcam_dbg_warn("Dbus call - obj [%s], iface [%s], method [%s]", object, iface, method); if (is_sync) { dbus_reply = g_dbus_connection_call_sync(conn, bus_name, object, iface, method, args, NULL, G_DBUS_CALL_FLAGS_NONE, G_DBUS_TIMEOUT, NULL, NULL); if (dbus_reply) { - _mmcam_dbg_log("Method Call '%s.%s' Success", iface, method); + _mmcam_dbg_warn("Method Call '%s.%s' Success", iface, method); *result = dbus_reply; } else { _mmcam_dbg_err("dbus method call sync reply failed"); @@ -123,6 +124,8 @@ static int __gdbus_method_call_sync(GDBusConnection *conn, const char *bus_name, G_DBUS_CALL_FLAGS_NONE, G_DBUS_TIMEOUT, NULL, NULL, NULL); } + _mmcam_dbg_warn("done"); + return ret; } @@ -164,7 +167,7 @@ static void __gdbus_stream_eos_cb(GDBusConnection *connection, _MMCamcorderGDbusCbInfo *gdbus_info = NULL; mmf_camcorder_t *hcamcorder = NULL; - _mmcam_dbg_log("entered"); + _mmcam_dbg_warn("entered"); if (!param || !user_data) { _mmcam_dbg_err("invalid parameter %p %p", param, user_data); @@ -178,7 +181,7 @@ static void __gdbus_stream_eos_cb(GDBusConnection *connection, g_mutex_lock(&gdbus_info->sync_mutex); - _mmcam_dbg_log("gdbus_info->param %d, played_idx : %d, handle : %p", + _mmcam_dbg_warn("gdbus_info->param %d, played_idx : %d, handle : %p", gdbus_info->param, played_idx, hcamcorder); if (gdbus_info->param == played_idx) { @@ -193,6 +196,8 @@ static void __gdbus_stream_eos_cb(GDBusConnection *connection, g_mutex_unlock(&gdbus_info->sync_mutex); + _mmcam_dbg_warn("done"); + return; } @@ -208,7 +213,7 @@ static int __gdbus_wait_for_cb_return(_MMCamcorderGDbusCbInfo *gdbus_info, int t g_mutex_lock(&gdbus_info->sync_mutex); - _mmcam_dbg_log("entered"); + _mmcam_dbg_warn("entered"); if (gdbus_info->is_playing == FALSE) { _mmcam_dbg_log("callback is already returned"); @@ -219,7 +224,7 @@ static int __gdbus_wait_for_cb_return(_MMCamcorderGDbusCbInfo *gdbus_info, int t end_time = g_get_monotonic_time() + (time_out * G_TIME_SPAN_MILLISECOND); if (g_cond_wait_until(&gdbus_info->sync_cond, &gdbus_info->sync_mutex, end_time)) { - _mmcam_dbg_log("wait signal received"); + _mmcam_dbg_warn("wait signal received"); } else { _mmcam_dbg_err("wait time is expired"); ret = MM_ERROR_CAMCORDER_RESPONSE_TIMEOUT; @@ -227,6 +232,8 @@ static int __gdbus_wait_for_cb_return(_MMCamcorderGDbusCbInfo *gdbus_info, int t g_mutex_unlock(&gdbus_info->sync_mutex); + _mmcam_dbg_warn("done"); + return ret; } @@ -250,7 +257,7 @@ gint _mmcamcorder_find_tag(FILE *f, guint32 tag_fourcc, gboolean do_rewind) uint32_t buf_fourcc = 0; if (read_item < 8) { - _mmcam_dbg_err("fread failed : %d", read_item); + _mmcam_dbg_err("fread failed : %zu", read_item); break; } @@ -279,7 +286,7 @@ gint _mmcamcorder_find_tag(FILE *f, guint32 tag_fourcc, gboolean do_rewind) buf_size = buf_size - 8; /* include tag */ } - _mmcam_dbg_log("seek %llu", buf_size); + _mmcam_dbg_log("seek %"PRIu64, buf_size); if (fseeko(f, (off_t)buf_size, SEEK_CUR) != 0) { _mmcam_dbg_err("fseeko() fail"); return FALSE; @@ -305,7 +312,7 @@ gboolean _mmcamcorder_find_fourcc(FILE *f, guint32 tag_fourcc, gboolean do_rewin uint32_t buf_fourcc = 0; if (read_item < 8) { - _mmcam_dbg_err("fread failed : %d", read_item); + _mmcam_dbg_err("fread failed : %zu", read_item); break; } @@ -340,7 +347,7 @@ gboolean _mmcamcorder_find_fourcc(FILE *f, guint32 tag_fourcc, gboolean do_rewin buf_size = buf_size - 8; /* include tag */ } - _mmcam_dbg_log("seek %llu", buf_size); + _mmcam_dbg_log("seek %"PRIu64, buf_size); if (fseeko(f, (off_t)buf_size, SEEK_CUR) != 0) { _mmcam_dbg_err("fseeko() fail"); return FALSE; @@ -440,50 +447,50 @@ gboolean _mmcamcorder_write_loci(FILE *f, _MMCamcorderLocationInfo info) void _mmcamcorder_write_Latitude(FILE *f, int value) { - char s_latitude[9]; + char s_latitude[16]; int l_decimal = 0; int l_below_decimal = 0; l_decimal = value / 10000; if (value < 0) { if (l_decimal == 0) - snprintf(s_latitude, 5, "-%.2d.", l_decimal); + snprintf(s_latitude, sizeof(s_latitude), "-%.2d.", l_decimal); else - snprintf(s_latitude, 5, "%.2d.", l_decimal); + snprintf(s_latitude, sizeof(s_latitude), "%.2d.", l_decimal); } else { - snprintf(s_latitude, 5, "+%.2d.", l_decimal); + snprintf(s_latitude, sizeof(s_latitude), "+%.2d.", l_decimal); } l_below_decimal = value - (l_decimal * 10000); if (l_below_decimal < 0) l_below_decimal = -l_below_decimal; - snprintf(&s_latitude[4], 5, "%.4d", l_below_decimal); + snprintf(&s_latitude[4], sizeof(s_latitude) - 4, "%.4d", l_below_decimal); write_tag(f, s_latitude); } void _mmcamcorder_write_Longitude(FILE *f, int value) { - char s_longitude[10]; + char s_longitude[24]; int l_decimal = 0; int l_below_decimal = 0; l_decimal = value / 10000; if (value < 0) { if (l_decimal == 0) - snprintf(s_longitude, 6, "-%.3d.", l_decimal); + snprintf(s_longitude, sizeof(s_longitude), "-%.3d.", l_decimal); else - snprintf(s_longitude, 6, "%.3d.", l_decimal); + snprintf(s_longitude, sizeof(s_longitude), "%.3d.", l_decimal); } else { - snprintf(s_longitude, 6, "+%.3d.", l_decimal); + snprintf(s_longitude, sizeof(s_longitude), "+%.3d.", l_decimal); } l_below_decimal = value - (l_decimal * 10000); if (l_below_decimal < 0) l_below_decimal = -l_below_decimal; - snprintf(&s_longitude[5], 5, "%.4d", l_below_decimal); + snprintf(&s_longitude[5], sizeof(s_longitude) - 5, "%.4d", l_below_decimal); write_tag(f, s_longitude); } @@ -598,7 +605,7 @@ guint64 _mmcamcorder_get_container_size(const guchar *size) result = result | (temp << 8); result = result | size[3]; - _mmcam_dbg_log("result : %llu", result); + _mmcam_dbg_log("result : %"G_GUINT64_FORMAT, result); return result; } @@ -625,7 +632,7 @@ guint64 _mmcamcorder_get_container_size64(const guchar *size) result = result | (temp << 8); result = result | size[7]; - _mmcam_dbg_log("result : %llu", result); + _mmcam_dbg_log("result : %"G_GUINT64_FORMAT, result); return result; } @@ -697,6 +704,86 @@ static int __mmcamcorder_storage_supported_cb(int storage_id, storage_type_e typ } +int _mmcamcorder_get_storage_validity(MMHandleType handle, const char *filename, guint64 min_space, gboolean *storage_validity) +{ + int ret = MM_ERROR_NONE; + int err = 0; + char *dir_name = NULL; + guint64 free_space = 0; + mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); + + mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED); + mmf_return_val_if_fail(storage_validity, MM_ERROR_CAMCORDER_INVALID_ARGUMENT); + + if (!filename) { + _mmcam_dbg_warn("NULL filename, but keep going..."); + *storage_validity = TRUE; + return MM_ERROR_NONE; + } + + dir_name = g_path_get_dirname(filename); + mmf_return_val_if_fail(dir_name, MM_ERROR_OUT_OF_STORAGE); + + err = _mmcamcorder_get_storage_info(dir_name, hcamcorder->root_directory, &hcamcorder->storage_info); + if (err != 0) { + _mmcam_dbg_err("get storage info failed"); + ret = MM_ERROR_CAMCORDER_INTERNAL; + goto _CHECK_DONE; + } + + err = _mmcamcorder_get_freespace(hcamcorder->storage_info.type, &free_space); + if (err != 0) { + _mmcam_dbg_err("get free space failed"); + ret = MM_ERROR_CAMCORDER_INTERNAL; + goto _CHECK_DONE; + } + + _mmcam_dbg_warn("current free space - %s [%" G_GUINT64_FORMAT "]", dir_name, free_space); + +_CHECK_DONE: + g_free(dir_name); + + if (ret == MM_ERROR_NONE && free_space > min_space) { + *storage_validity = TRUE; + _mmcam_dbg_log("validity and free space of storage : OK"); + } else { + *storage_validity = FALSE; + _mmcam_dbg_err("OUT of STORAGE [err:%d or free space [%"G_GUINT64_FORMAT"] is smaller than [%"G_GUINT64_FORMAT"]", + err, free_space, min_space); + } + + return ret; +} + + +void _mmcamcorder_adjust_recording_max_size(const char *filename, guint64 *max_size) +{ + int file_system_type = 0; + char *dir_name = NULL; + + mmf_return_if_fail(max_size); + mmf_return_if_fail(filename); + + dir_name = g_path_get_dirname(filename); + mmf_return_if_fail(dir_name); + + if (_mmcamcorder_get_file_system_type(dir_name, &file_system_type) == 0) { + /* MSDOS_SUPER_MAGIC : 0x4d44 */ + if (file_system_type == MSDOS_SUPER_MAGIC && + (*max_size == 0 || *max_size > FAT32_FILE_SYSTEM_MAX_SIZE)) { + _mmcam_dbg_warn("FAT32 and too large max[%"G_GUINT64_FORMAT"], set max as %lu", + *max_size, FAT32_FILE_SYSTEM_MAX_SIZE); + *max_size = FAT32_FILE_SYSTEM_MAX_SIZE; + } else { + _mmcam_dbg_warn("file system 0x%x, max size %"G_GUINT64_FORMAT, + file_system_type, *max_size); + } + } + + g_free(dir_name); +} + + int _mmcamcorder_get_storage_info(const gchar *path, const gchar *root_directory, _MMCamcorderStorageInfo *info) { int ret = 0; @@ -759,7 +846,7 @@ int _mmcamcorder_get_freespace(storage_type_e type, guint64 *free_space) *free_space = vfs.f_bsize * vfs.f_bavail; /* _mmcam_dbg_log("vfs.f_bsize [%lu], vfs.f_bavail [%lu]", vfs.f_bsize, vfs.f_bavail); - _mmcam_dbg_log("memory size %llu [%s]", *free_space, path); + _mmcam_dbg_log("memory size %"G_GUINT64_FORMAT" [%s]", *free_space, path); */ return 0; } @@ -820,7 +907,8 @@ int _mmcamcorder_send_sound_play_message(GDBusConnection *conn, _MMCamcorderGDbu { int get_value = 0; int ret = MM_ERROR_NONE; - GVariant *params = NULL, *result = NULL; + GVariant *params = NULL; + GVariant *result = NULL; guint subs_id = 0; if (!conn || !gdbus_info) { @@ -829,7 +917,6 @@ int _mmcamcorder_send_sound_play_message(GDBusConnection *conn, _MMCamcorderGDbu } params = g_variant_new("(sss)", sample_name, stream_role, volume_gain); - result = g_variant_new("(i)", get_value); ret = __gdbus_method_call_sync(conn, "org.pulseaudio.Server", "/org/pulseaudio/SoundPlayer", "org.pulseaudio.SoundPlayer", @@ -876,6 +963,41 @@ int _mmcamcorder_send_sound_play_message(GDBusConnection *conn, _MMCamcorderGDbu } +void _mmcamcorder_request_dpm_popup(GDBusConnection *conn, const char *restricted_policy) +{ + int ret = MM_ERROR_NONE; + gboolean get_value = 0; + GVariant *params = NULL; + GVariant *result = NULL; + + if (!conn || !restricted_policy) { + _mmcam_dbg_err("Invalid parameter %p %p", conn, restricted_policy); + return; + } + + params = g_variant_new("(s)", restricted_policy); + + ret = __gdbus_method_call_sync(conn, + "org.tizen.DevicePolicyManager", + "/org/tizen/DevicePolicyManager/Syspopup", + "org.tizen.DevicePolicyManager.Syspopup", + "show", params, &result, TRUE); + if (ret != MM_ERROR_NONE) { + _mmcam_dbg_err("Dbus Call on Client Error 0x%x", ret); + return; + } + + if (result) { + g_variant_get(result, "(b)", &get_value); + _mmcam_dbg_log("request result : %d", get_value); + } else { + _mmcam_dbg_err("replied result is null"); + } + + return; +} + + int _mmcamcorder_get_file_size(const char *filename, guint64 *size) { struct stat buf; @@ -1173,6 +1295,7 @@ gboolean _mmcamcorder_msg_callback(void *data) /* remove item from msg data */ if (hcamcorder->msg_data) { + /*_mmcam_dbg_log("remove item %p", item);*/ hcamcorder->msg_data = g_list_remove(hcamcorder->msg_data, item); } else { _mmcam_dbg_warn("msg_data is NULL but item[%p] will be removed", item); @@ -1203,10 +1326,9 @@ MSG_CALLBACK_DONE: } else if (item->id == MM_MESSAGE_CAMCORDER_VIDEO_CAPTURED || item->id == MM_MESSAGE_CAMCORDER_AUDIO_CAPTURED) { MMCamRecordingReport *report = (MMCamRecordingReport *)item->param.data; if (report) { - if (report->recording_filename) - SAFE_G_FREE(report->recording_filename); - - SAFE_G_FREE(report); + SAFE_G_FREE(report->recording_filename); + g_free(report); + report = NULL; item->param.data = NULL; } } @@ -1234,7 +1356,6 @@ gboolean _mmcamcorder_send_message(MMHandleType handle, _MMCamcorderMsgItem *dat switch (data->id) { case MM_MESSAGE_CAMCORDER_STATE_CHANGED: - case MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_ASM: case MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_RM: data->param.union_type = MM_MSG_UNION_STATE; break; @@ -1294,16 +1415,16 @@ gboolean _mmcamcorder_send_message(MMHandleType handle, _MMCamcorderMsgItem *dat MMCamFaceDetectInfo *cam_fd_info = (MMCamFaceDetectInfo *)data->param.data; if (cam_fd_info) { SAFE_G_FREE(cam_fd_info->face_info); - SAFE_G_FREE(cam_fd_info); - data->param.size = 0; + data->param.data = NULL; + g_free(cam_fd_info); } } else if (data->id == MM_MESSAGE_CAMCORDER_VIDEO_CAPTURED || data->id == MM_MESSAGE_CAMCORDER_AUDIO_CAPTURED) { MMCamRecordingReport *report = (MMCamRecordingReport *)data->param.data; if (report) { SAFE_G_FREE(report->recording_filename); data->param.data = NULL; + g_free(report); } - SAFE_G_FREE(report); } #endif /* _MMCAMCORDER_ENABLE_IDLE_MESSAGE_CALLBACK */ @@ -1505,6 +1626,12 @@ unsigned int _mmcamcorder_get_fourcc(int pixtype, int codectype, int use_zero_co case MM_PIXEL_FORMAT_RGB888: fourcc = GST_MAKE_FOURCC('R', 'G', 'B', ' '); break; + case MM_PIXEL_FORMAT_RGBA: + fourcc = GST_MAKE_FOURCC('B', 'G', 'R', 'x'); + break; + case MM_PIXEL_FORMAT_ARGB: + fourcc = GST_MAKE_FOURCC('x', 'R', 'G', 'B'); + break; case MM_PIXEL_FORMAT_ENCODED: if (codectype == MM_IMAGE_CODEC_JPEG) { fourcc = GST_MAKE_FOURCC('J', 'P', 'E', 'G'); @@ -1525,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_INVZ: + fourcc = GST_MAKE_FOURCC('I', 'N', 'V', 'Z'); + break; default: _mmcam_dbg_log("Not proper pixel type[%d]. Set default - I420", pixtype); if (use_zero_copy_format) @@ -1603,6 +1733,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('I', 'N', 'V', 'Z'): + pixtype = MM_PIXEL_FORMAT_INVZ; + break; default: _mmcam_dbg_log("Not supported fourcc type(%c%c%c%c)", fourcc, fourcc>>8, fourcc>>16, fourcc>>24); pixtype = MM_PIXEL_FORMAT_INVALID; @@ -1674,71 +1807,68 @@ gboolean _mmcamcorder_link_elements(GList *element_list) } gboolean _mmcamcorder_resize_frame(unsigned char *src_data, unsigned int src_width, unsigned int src_height, unsigned int src_length, int src_format, - unsigned char **dst_data, unsigned int *dst_width, unsigned int *dst_height, unsigned int *dst_length) + unsigned char **dst_data, unsigned int *dst_width, unsigned int *dst_height, size_t *dst_length) { - int ret = TRUE; int mm_ret = MM_ERROR_NONE; - int input_format = MM_UTIL_IMG_FMT_YUV420; - unsigned char *dst_tmp_data = NULL; + int input_format = MM_UTIL_COLOR_YUV420; + mm_util_image_h src_image = NULL; + mm_util_image_h dst_image = NULL; if (!src_data || !dst_data || !dst_width || !dst_height || !dst_length) { - _mmcam_dbg_err("something is NULL %p,%p,%p,%p,%p", src_data, dst_data, dst_width, dst_height, dst_length); + _mmcam_dbg_err("something is NULL %p,%p,%p,%p,%p", + src_data, dst_data, dst_width, dst_height, dst_length); return FALSE; } /* set input format for mm-util */ switch (src_format) { case MM_PIXEL_FORMAT_I420: - input_format = MM_UTIL_IMG_FMT_I420; + input_format = MM_UTIL_COLOR_I420; break; case MM_PIXEL_FORMAT_YV12: - input_format = MM_UTIL_IMG_FMT_YUV420; + input_format = MM_UTIL_COLOR_YUV420; break; case MM_PIXEL_FORMAT_NV12: - input_format = MM_UTIL_IMG_FMT_NV12; + input_format = MM_UTIL_COLOR_NV12; break; case MM_PIXEL_FORMAT_YUYV: - input_format = MM_UTIL_IMG_FMT_YUYV; + input_format = MM_UTIL_COLOR_YUYV; break; case MM_PIXEL_FORMAT_UYVY: - input_format = MM_UTIL_IMG_FMT_UYVY; + input_format = MM_UTIL_COLOR_UYVY; break; case MM_PIXEL_FORMAT_RGB888: - input_format = MM_UTIL_IMG_FMT_RGB888; + input_format = MM_UTIL_COLOR_RGB24; break; default: - _mmcam_dbg_err("NOT supported format", src_format); + _mmcam_dbg_err("NOT supported format [%d]", src_format); return FALSE; } _mmcam_dbg_log("src size %dx%d -> dst size %dx%d", src_width, src_height, *dst_width, *dst_height); - /* get length of resized image */ - mm_ret = mm_util_get_image_size(input_format, *dst_width, *dst_height, dst_length); + mm_ret = mm_image_create_image(src_width, src_height, input_format, src_data, (size_t)src_length, &src_image); if (mm_ret != MM_ERROR_NONE) { - GST_ERROR("mm_util_get_image_size failed 0x%x", ret); + _mmcam_dbg_err("mm_image_create_image failed 0x%x", mm_ret); return FALSE; } - _mmcam_dbg_log("dst_length : %d", *dst_length); - - dst_tmp_data = (unsigned char *)malloc(*dst_length); - if (dst_tmp_data == NULL) { - _mmcam_dbg_err("failed to alloc dst_thumb_size(size %d)", *dst_length); + mm_ret = mm_util_resize_image(src_image, *dst_width, *dst_height, &dst_image); + mm_image_destroy_image(src_image); + if (mm_ret != MM_ERROR_NONE) { + _mmcam_dbg_err("mm_util_resize_image failed 0x%x", mm_ret); return FALSE; } - mm_ret = mm_util_resize_image(src_data, src_width, src_height, input_format, dst_tmp_data, dst_width, dst_height); - + mm_ret = mm_image_get_image(dst_image, dst_width, dst_height, NULL, dst_data, dst_length); + mm_image_destroy_image(dst_image); if (mm_ret != MM_ERROR_NONE) { - GST_ERROR("mm_util_resize_image failed 0x%x", ret); - free(dst_tmp_data); + _mmcam_dbg_err("mm_image_get_image failed 0x%x", mm_ret); return FALSE; } - *dst_data = dst_tmp_data; - - _mmcam_dbg_log("resize done %p, %dx%d", *dst_data, *dst_width, *dst_height); + _mmcam_dbg_log("resize done %dx%d -> %dx%d, %p, length %zu", + src_width, src_height, *dst_width, *dst_height, *dst_data, *dst_length); return TRUE; } @@ -1758,46 +1888,46 @@ gboolean _mmcamcorder_encode_jpeg(void *src_data, unsigned int src_width, unsign switch (src_format) { case MM_PIXEL_FORMAT_NV12: - //jpeg_format = MM_UTIL_JPEG_FMT_NV12; + //jpeg_format = MM_UTIL_COLOR_NV12; ret_conv = _mmcamcorder_convert_NV12_to_I420(src_data, src_width, src_height, &converted_src, &converted_src_size); - jpeg_format = MM_UTIL_JPEG_FMT_YUV420; + jpeg_format = MM_UTIL_COLOR_YUV420; break; case MM_PIXEL_FORMAT_NV16: - jpeg_format = MM_UTIL_JPEG_FMT_NV16; + jpeg_format = MM_UTIL_COLOR_NV16; converted_src = src_data; break; case MM_PIXEL_FORMAT_NV21: - jpeg_format = MM_UTIL_JPEG_FMT_NV21; + jpeg_format = MM_UTIL_COLOR_NV21; converted_src = src_data; break; case MM_PIXEL_FORMAT_YUYV: - //jpeg_format = MM_UTIL_JPEG_FMT_YUYV; + //jpeg_format = MM_UTIL_COLOR_YUYV; ret_conv = _mmcamcorder_convert_YUYV_to_I420(src_data, src_width, src_height, &converted_src, &converted_src_size); - jpeg_format = MM_UTIL_JPEG_FMT_YUV420; + jpeg_format = MM_UTIL_COLOR_YUV420; break; case MM_PIXEL_FORMAT_UYVY: - //jpeg_format = MM_UTIL_JPEG_FMT_UYVY; + //jpeg_format = MM_UTIL_COLOR_UYVY; ret_conv = _mmcamcorder_convert_UYVY_to_I420(src_data, src_width, src_height, &converted_src, &converted_src_size); - jpeg_format = MM_UTIL_JPEG_FMT_YUV420; + jpeg_format = MM_UTIL_COLOR_YUV420; break; case MM_PIXEL_FORMAT_I420: - jpeg_format = MM_UTIL_JPEG_FMT_YUV420; + jpeg_format = MM_UTIL_COLOR_YUV420; converted_src = src_data; break; case MM_PIXEL_FORMAT_RGB888: - jpeg_format = MM_UTIL_JPEG_FMT_RGB888; + jpeg_format = MM_UTIL_COLOR_RGB24; converted_src = src_data; break; case MM_PIXEL_FORMAT_RGBA: - jpeg_format = MM_UTIL_JPEG_FMT_RGBA8888; + jpeg_format = MM_UTIL_COLOR_RGBA; converted_src = src_data; break; case MM_PIXEL_FORMAT_ARGB: - jpeg_format = MM_UTIL_JPEG_FMT_ARGB8888; + jpeg_format = MM_UTIL_COLOR_ARGB; converted_src = src_data; break; case MM_PIXEL_FORMAT_422P: - jpeg_format = MM_UTIL_JPEG_FMT_YUV422; // not supported + jpeg_format = MM_UTIL_COLOR_YUV422; // not supported return FALSE; case MM_PIXEL_FORMAT_NV12T: case MM_PIXEL_FORMAT_YV12: @@ -1818,7 +1948,7 @@ gboolean _mmcamcorder_encode_jpeg(void *src_data, unsigned int src_width, unsign return FALSE; } - ret = mm_util_jpeg_encode_to_memory(result_data, (int *)result_length, + ret = mm_util_jpeg_encode_to_memory(result_data, result_length, converted_src, src_width, src_height, jpeg_format, jpeg_quality); if (converted_src && (converted_src != src_data)) { @@ -2016,56 +2146,6 @@ void *_mmcamcorder_util_task_thread_func(void *data) return NULL; } -#ifdef _USE_YUV_TO_RGB888_ -static gboolean -_mmcamcorder_convert_YUV_to_RGB888(unsigned char *src, int src_fmt, guint width, guint height, unsigned char **dst, unsigned int *dst_len) -{ - int ret = 0; - int src_cs = MM_UTIL_IMG_FMT_UYVY; - int dst_cs = MM_UTIL_IMG_FMT_RGB888; - unsigned int dst_size = 0; - - if (src_fmt == COLOR_FORMAT_YUYV) { - _mmcam_dbg_log("Convert YUYV to RGB888\n"); - src_cs = MM_UTIL_IMG_FMT_YUYV; - } else if (src_fmt == COLOR_FORMAT_UYVY) { - _mmcam_dbg_log("Convert UYVY to RGB888\n"); - src_cs = MM_UTIL_IMG_FMT_UYVY; - } else if (src_fmt == COLOR_FORMAT_NV12) { - _mmcam_dbg_log("Convert NV12 to RGB888\n"); - src_cs = MM_UTIL_IMG_FMT_NV12; - } else { - _mmcam_dbg_err("NOT supported format [%d]\n", src_fmt); - return FALSE; - } - - ret = mm_util_get_image_size(dst_cs, width, height, &dst_size); - if (ret != 0) { - _mmcam_dbg_err("mm_util_get_image_size failed [%x]\n", ret); - return FALSE; - } - - *dst = malloc(dst_size); - if (*dst == NULL) { - _mmcam_dbg_err("malloc failed\n"); - return FALSE; - } - - *dst_len = dst_size; - ret = mm_util_convert_colorspace(src, width, height, src_cs, *dst, dst_cs); - if (ret == 0) { - _mmcam_dbg_log("Convert [dst_size:%d] OK.\n", dst_size); - return TRUE; - } else { - free(*dst); - *dst = NULL; - - _mmcam_dbg_err("Convert [size:%d] FAILED.\n", dst_size); - return FALSE; - } -} -#endif /* _USE_YUV_TO_RGB888_ */ - static gboolean _mmcamcorder_convert_YUYV_to_I420(unsigned char *src, guint width, guint height, unsigned char **dst, unsigned int *dst_len) { @@ -2197,6 +2277,12 @@ static gboolean _mmcamcorder_convert_NV12_to_I420(unsigned char *src, guint widt return FALSE; } + /* buffer overflow prevention check */ + if (width > __MMCAMCORDER_MAX_WIDTH || height > __MMCAMCORDER_MAX_HEIGHT) { + _mmcam_dbg_err("too large size %d x %d", width, height); + return FALSE; + } + dst_size = (width * height * 3) >> 1; _mmcam_dbg_log("NV12 -> I420 : %dx%d, dst size %d", width, height, dst_size);