-----------------------------------------------------------------------*/
#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_REPLY_TIMEOUT, NULL, 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");
}
} else {
g_dbus_connection_call(conn, bus_name, object, iface, method, args, NULL,
- G_DBUS_CALL_FLAGS_NONE, G_DBUS_REPLY_TIMEOUT, NULL, NULL, NULL);
+ G_DBUS_CALL_FLAGS_NONE, G_DBUS_TIMEOUT, NULL, NULL, NULL);
}
+ _mmcam_dbg_warn("done");
+
return ret;
}
{
int played_idx = 0;
_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);
}
gdbus_info = (_MMCamcorderGDbusCbInfo *)user_data;
+ hcamcorder = (mmf_camcorder_t *)gdbus_info->mm_handle;
g_variant_get(param, "(i)", &played_idx);
g_mutex_lock(&gdbus_info->sync_mutex);
- _mmcam_dbg_log("gdbus_info->param %d, played_idx : %d",
- gdbus_info->param, played_idx);
+ _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_dbus_connection_signal_unsubscribe(connection, gdbus_info->subscribe_id);
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;
}
{
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) {
g_mutex_unlock(&gdbus_info->sync_mutex);
if (sync_play && ret == MM_ERROR_NONE)
- ret = __gdbus_wait_for_cb_return(gdbus_info, G_DBUS_CB_TIMEOUT_MSEC);
+ ret = __gdbus_wait_for_cb_return(gdbus_info, G_DBUS_TIMEOUT);
return ret;
}
+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);
+ result = g_variant_new("(b)", get_value);
+
+ 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;
/* 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;
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);
- if (mm_ret != MM_ERROR_NONE) {
- GST_ERROR("mm_util_get_image_size failed 0x%x", 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);
- 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_util_resize_image(src_data, src_width, src_height, input_format,
+ *dst_width, *dst_height, dst_data, dst_width, dst_height, dst_length);
if (mm_ret != MM_ERROR_NONE) {
GST_ERROR("mm_util_resize_image failed 0x%x", ret);
- free(dst_tmp_data);
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);
return TRUE;
}
+
+
+void _mmcamcorder_emit_dbus_signal(GDBusConnection *conn, const char *object_name,
+ const char *interface_name, const char *signal_name, int value)
+{
+ if (!conn || !object_name || !interface_name || !signal_name) {
+ _mmcam_dbg_err("NULL pointer %p %p %p %p",
+ conn, object_name, interface_name, signal_name);
+ return;
+ }
+
+ if (!g_dbus_connection_emit_signal(conn, NULL,
+ object_name, interface_name, signal_name,
+ g_variant_new("(i)", value), NULL)) {
+ _mmcam_dbg_warn("failed to emit signal");
+ } else {
+ _mmcam_dbg_log("emit signal done - value 0x%.8x", value);
+ g_dbus_connection_flush(conn, NULL, NULL, NULL);
+ _mmcam_dbg_log("signal flush done");
+ }
+
+ return;
+}
+
+
+int _mmcamcorder_get_audiosrc_blocksize(int samplerate, int format, int channel, int interval, int *blocksize)
+{
+ int depth = 8;
+
+ if (!blocksize) {
+ _mmcam_dbg_err("NULL ptr");
+ return FALSE;
+ }
+
+ if (samplerate == 0 || channel == 0 || interval == 0) {
+ _mmcam_dbg_err("invalid param %d %d %d", samplerate, channel, interval);
+ return FALSE;
+ }
+
+ if (format == MM_CAMCORDER_AUDIO_FORMAT_PCM_S16_LE)
+ depth = 16;
+
+ *blocksize = samplerate * depth * channel * interval / 8000;
+
+ return TRUE;
+}