#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
+#include <inttypes.h>
#include <sys/vfs.h> /* struct statfs */
#include <sys/time.h> /* gettimeofday */
#include <sys/stat.h>
#include "mm_camcorder_internal.h"
#include "mm_camcorder_util.h"
#include "mm_camcorder_sound.h"
+#include <mm_util_image.h>
#include <mm_util_imgp.h>
#include <mm_util_jpeg.h>
-----------------------------------------------------------------------*/
#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) \
{ \
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);
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");
G_DBUS_CALL_FLAGS_NONE, G_DBUS_TIMEOUT, NULL, NULL, NULL);
}
+ _mmcam_dbg_warn("done");
+
return ret;
}
_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);
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) {
g_mutex_unlock(&gdbus_info->sync_mutex);
+ _mmcam_dbg_warn("done");
+
return;
}
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");
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;
g_mutex_unlock(&gdbus_info->sync_mutex);
+ _mmcam_dbg_warn("done");
+
return ret;
}
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;
}
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;
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;
}
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;
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);
}
result = result | (temp << 8);
result = result | size[3];
- _mmcam_dbg_log("result : %llu", result);
+ _mmcam_dbg_log("result : %"G_GUINT64_FORMAT, result);
return result;
}
result = result | (temp << 8);
result = result | size[7];
- _mmcam_dbg_log("result : %llu", result);
+ _mmcam_dbg_log("result : %"G_GUINT64_FORMAT, result);
return result;
}
}
+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;
*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;
}
}
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",
}
params = g_variant_new("(s)", restricted_policy);
- result = g_variant_new("(b)", get_value);
ret = __gdbus_method_call_sync(conn,
"org.tizen.DevicePolicyManager",
/* 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);
} 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;
}
}
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;
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 */
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');
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)
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;
}
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;
}
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:
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)) {
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)
{
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);