X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fmm_camcorder_util.c;h=3614ffe649683e18aaf5a1b051b1e4e7f06bd433;hb=HEAD;hp=c8abf6b791bb50100ec0c6a4ae2c17d4d963555f;hpb=3271a32fa45d8228481612e024060c44981d7b4b;p=platform%2Fcore%2Fmultimedia%2Flibmm-camcorder.git diff --git a/src/mm_camcorder_util.c b/src/mm_camcorder_util.c index c8abf6b..3614ffe 100644 --- a/src/mm_camcorder_util.c +++ b/src/mm_camcorder_util.c @@ -25,47 +25,47 @@ #include #include #include +#include #include /* struct statfs */ #include /* gettimeofday */ #include #include #include -#include #include "mm_camcorder_internal.h" #include "mm_camcorder_util.h" #include "mm_camcorder_sound.h" +#include #include #include -#include - /*----------------------------------------------------------------------- | GLOBAL VARIABLE DEFINITIONS for internal | -----------------------------------------------------------------------*/ +static int mmcam_log_level = MM_CAMCORDER_LOG_LEVEL_INFO; /*----------------------------------------------------------------------- | LOCAL VARIABLE DEFINITIONS for internal | -----------------------------------------------------------------------*/ #define TIME_STRING_MAX_LEN 64 #define __MMCAMCORDER_CAPTURE_WAIT_TIMEOUT 5 - -#define FPUTC_CHECK(x_char, x_file)\ -{\ - if (fputc(x_char, x_file) == EOF) \ - {\ - _mmcam_dbg_err("[Critical] fputc() returns fail.\n"); \ - return FALSE;\ - }\ +#define __MMCAMCORDER_MAX_WIDTH 8192 +#define __MMCAMCORDER_MAX_HEIGHT 8192 + +#define FPUTC_CHECK(x_char, x_file) \ +{ \ + if (fputc(x_char, x_file) == EOF) { \ + MMCAM_LOG_ERROR("[Critical] fputc() returns fail.\n"); \ + return FALSE; \ + } \ } -#define FPUTS_CHECK(x_str, x_file)\ -{\ - if (fputs(x_str, x_file) == EOF) \ - {\ - _mmcam_dbg_err("[Critical] fputs() returns fail.\n");\ - SAFE_FREE(str); \ - return FALSE;\ - }\ +#define FPUTS_CHECK(x_str, x_file) \ +{ \ + if (fputs(x_str, x_file) == EOF) { \ + MMCAM_LOG_ERROR("[Critical] fputs() returns fail.\n"); \ + SAFE_G_FREE(str); \ + return FALSE; \ + } \ } /*--------------------------------------------------------------------------- @@ -73,16 +73,13 @@ ---------------------------------------------------------------------------*/ /* STATIC INTERNAL FUNCTION */ -//static gint skip_mdat(FILE *f); +//static gint skip_mdat(FILE *f); static guint16 get_language_code(const char *str); static gchar* str_to_utf8(const gchar *str); 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); @@ -91,57 +88,161 @@ static gboolean _mmcamcorder_convert_NV12_to_I420(unsigned char *src, guint widt /*=========================================================================================== | | | FUNCTION DEFINITIONS | -| | +| | ========================================================================================== */ /*--------------------------------------------------------------------------- | GLOBAL FUNCTION DEFINITIONS: | ---------------------------------------------------------------------------*/ -static int __gdbus_method_call_sync(const char* bus_name, const char* object, const char* iface, - const char* method, GVariant* args, GVariant** result, bool is_sync) +static int __gdbus_method_call_sync(GDBusConnection *conn, const char *bus_name, + const char *object, const char *iface, const char *method, + GVariant *args, GVariant **result, bool is_sync) { int ret = MM_ERROR_NONE; - GError *err = NULL; - GVariant* dbus_reply = NULL; - GDBusConnection *conn = NULL; - - if (!object || !iface || !method) { - _mmcam_dbg_err("Invalid Argument"); - if (!object) - _mmcam_dbg_err("object null"); - if (!iface) - _mmcam_dbg_err("iface null"); - if (!method) - _mmcam_dbg_err("method null"); - return MM_ERROR_INVALID_ARGUMENT; - } + GVariant *dbus_reply = NULL; - conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, NULL); - if (conn == NULL) { - _mmcam_dbg_err("get connection failed"); - return MM_ERROR_CAMCORDER_INTERNAL; + if (!conn || !object || !iface || !method) { + MMCAM_LOG_ERROR("Invalid Argument %p %p %p %p", + conn, object, iface, method); + return MM_ERROR_INVALID_ARGUMENT; } - _mmcam_dbg_log("Dbus call with obj : '%s' iface : '%s' method : '%s'", object, iface, method); + MMCAM_LOG_WARNING("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, &err); + 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_LOG_WARNING("Method Call '%s.%s' Success", iface, method); *result = dbus_reply; } else { - _mmcam_dbg_err("dbus method call sync reply failed"); + MMCAM_LOG_ERROR("dbus method call sync reply failed"); ret = MM_ERROR_CAMCORDER_INTERNAL; } } 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_connection_call(conn, bus_name, object, iface, method, args, NULL, + G_DBUS_CALL_FLAGS_NONE, G_DBUS_TIMEOUT, NULL, NULL, NULL); } - g_object_unref(conn); + + MMCAM_LOG_WARNING("done"); + + return ret; +} + +static int __gdbus_subscribe_signal(GDBusConnection *conn, + const char *object_name, const char *iface_name, const char *signal_name, + GDBusSignalCallback signal_cb, guint *subscribe_id, void *userdata) +{ + guint subs_id = 0; + + if (!conn || !object_name || !iface_name || !signal_name || !signal_cb || !subscribe_id) { + MMCAM_LOG_ERROR("Invalid Argument %p %p %p %p %p %p", + conn, object_name, iface_name, signal_name, signal_cb, subscribe_id); + return MM_ERROR_INVALID_ARGUMENT; + } + + MMCAM_LOG_INFO("subscirbe signal Obj %s, iface_name %s, sig_name %s", + object_name, iface_name, signal_name); + + subs_id = g_dbus_connection_signal_subscribe(conn, + NULL, iface_name, signal_name, object_name, NULL, + G_DBUS_SIGNAL_FLAGS_NONE, signal_cb, userdata, NULL); + if (!subs_id) { + MMCAM_LOG_ERROR("g_dbus_connection_signal_subscribe() failed"); + return MM_ERROR_CAMCORDER_INTERNAL; + } else { + *subscribe_id = subs_id; + MMCAM_LOG_INFO("subs_id %u", subs_id); + } + + return MM_ERROR_NONE; +} + + +static void __gdbus_stream_eos_cb(GDBusConnection *connection, + const gchar *sender_name, const gchar *object_path, const gchar *interface_name, + const gchar *signal_name, GVariant *param, gpointer user_data) +{ + int played_idx = 0; + gboolean stopped_by_user = FALSE; + gboolean do_free = FALSE; + _MMCamcorderGDbusCbInfo *info = NULL; + + if (!param || !user_data) { + MMCAM_LOG_ERROR("invalid parameter %p %p", param, user_data); + return; + } + + info = (_MMCamcorderGDbusCbInfo *)user_data; + + MMCAM_LOG_WARNING("entered[gdbus_info:%p]", info); + + g_variant_get(param, "(ib)", &played_idx, &stopped_by_user); + + g_mutex_lock(&info->sync_mutex); + + MMCAM_LOG_WARNING("gdbus_info->param %d, played_idx %d, stopped_by_user %d", + info->param, played_idx, stopped_by_user); + + if (info->param == played_idx) { + g_dbus_connection_signal_unsubscribe(connection, info->subscribe_id); + + info->is_playing = FALSE; + info->subscribe_id = 0; + info->param = 0; + + g_cond_signal(&info->sync_cond); + } + + if (info->free_in_cb) + do_free = TRUE; + + g_mutex_unlock(&info->sync_mutex); + + if (do_free) { + MMCAM_LOG_WARNING("free gdbus_info[%p]", info); + _mmcamcorder_gdbus_info_free(info); + } + + MMCAM_LOG_WARNING("done"); + + return; +} + +static int __gdbus_wait_for_cb_return(_MMCamcorderGDbusCbInfo *gdbus_info, int time_out) +{ + int ret = MM_ERROR_NONE; + gint64 end_time = 0; + + if (!gdbus_info) { + MMCAM_LOG_ERROR("invalid info"); + return MM_ERROR_CAMCORDER_INVALID_ARGUMENT; + } + + g_mutex_lock(&gdbus_info->sync_mutex); + + MMCAM_LOG_WARNING("entered"); + + if (gdbus_info->is_playing == FALSE) { + MMCAM_LOG_INFO("callback is already returned"); + g_mutex_unlock(&gdbus_info->sync_mutex); + return MM_ERROR_NONE; + } + + 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_LOG_WARNING("wait signal received"); + } else { + MMCAM_LOG_ERROR("wait time is expired"); + ret = MM_ERROR_CAMCORDER_RESPONSE_TIMEOUT; + } + + g_mutex_unlock(&gdbus_info->sync_mutex); + + MMCAM_LOG_WARNING("done"); + return ret; } @@ -157,35 +258,34 @@ gint _mmcamcorder_find_tag(FILE *f, guint32 tag_fourcc, gboolean do_rewind) size_t read_item = 0; guchar buf[8]; - if (do_rewind) { + if (do_rewind) rewind(f); - } while ((read_item = fread(&buf, sizeof(guchar), 8, f)) > 0) { uint64_t buf_size = 0; uint32_t buf_fourcc = 0; if (read_item < 8) { - _mmcam_dbg_err("fread failed : %d", read_item); + MMCAM_LOG_ERROR("fread failed : %zu", read_item); break; } buf_fourcc = MMCAM_FOURCC(buf[4], buf[5], buf[6], buf[7]); if (tag_fourcc == buf_fourcc) { - _mmcam_dbg_log("find tag : %c%c%c%c", MMCAM_FOURCC_ARGS(tag_fourcc)); + MMCAM_LOG_INFO("find tag : %c%c%c%c", MMCAM_FOURCC_ARGS(tag_fourcc)); return TRUE; } else { - _mmcam_dbg_log("skip [%c%c%c%c] tag", MMCAM_FOURCC_ARGS(buf_fourcc)); + MMCAM_LOG_INFO("skip [%c%c%c%c] tag", MMCAM_FOURCC_ARGS(buf_fourcc)); buf_size = _mmcamcorder_get_container_size(buf); /* if size of mdat is 1, it means largesize is used.(bigger than 4GB) */ - if (buf_fourcc == MMCAM_FOURCC('m','d','a','t') && + if (buf_fourcc == MMCAM_FOURCC('m', 'd', 'a', 't') && buf_size == 1) { read_item = fread(&buf, sizeof(guchar), 8, f); if (read_item < 8) { - _mmcam_dbg_err("fread failed"); + MMCAM_LOG_ERROR("fread failed"); return FALSE; } @@ -195,15 +295,15 @@ 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_LOG_INFO("seek %"PRIu64, buf_size); if (fseeko(f, (off_t)buf_size, SEEK_CUR) != 0) { - _mmcam_dbg_err("fseeko() fail"); + MMCAM_LOG_ERROR("fseeko() fail"); return FALSE; } } } - _mmcam_dbg_log("cannot find tag : %c%c%c%c", MMCAM_FOURCC_ARGS(tag_fourcc)); + MMCAM_LOG_INFO("cannot find tag : %c%c%c%c", MMCAM_FOURCC_ARGS(tag_fourcc)); return FALSE; } @@ -213,42 +313,40 @@ gboolean _mmcamcorder_find_fourcc(FILE *f, guint32 tag_fourcc, gboolean do_rewin size_t read_item = 0; guchar buf[8]; - if (do_rewind) { + if (do_rewind) rewind(f); - } while ((read_item = fread(&buf, sizeof(guchar), 8, f)) > 0) { uint64_t buf_size = 0; uint32_t buf_fourcc = 0; if (read_item < 8) { - _mmcam_dbg_err("fread failed : %d", read_item); + MMCAM_LOG_ERROR("fread failed : %zu", read_item); break; } buf_fourcc = MMCAM_FOURCC(buf[4], buf[5], buf[6], buf[7]); if (tag_fourcc == buf_fourcc) { - _mmcam_dbg_log("find tag : %c%c%c%c", MMCAM_FOURCC_ARGS(tag_fourcc)); + MMCAM_LOG_INFO("find tag : %c%c%c%c", MMCAM_FOURCC_ARGS(tag_fourcc)); return TRUE; - } else if (buf_fourcc == MMCAM_FOURCC('m','o','o','v') && - tag_fourcc != buf_fourcc) { - if (_mmcamcorder_find_fourcc(f, tag_fourcc, FALSE)) { + } else if (buf_fourcc == MMCAM_FOURCC('m', 'o', 'o', 'v') && + tag_fourcc != buf_fourcc) { + if (_mmcamcorder_find_fourcc(f, tag_fourcc, FALSE)) return TRUE; - } else { + else continue; - } } else { - _mmcam_dbg_log("skip [%c%c%c%c] tag", MMCAM_FOURCC_ARGS(buf_fourcc)); + MMCAM_LOG_INFO("skip [%c%c%c%c] tag", MMCAM_FOURCC_ARGS(buf_fourcc)); buf_size = _mmcamcorder_get_container_size(buf); /* if size of mdat is 1, it means largesize is used.(bigger than 4GB) */ - if (buf_fourcc == MMCAM_FOURCC('m','d','a','t') && + if (buf_fourcc == MMCAM_FOURCC('m', 'd', 'a', 't') && buf_size == 1) { read_item = fread(&buf, sizeof(guchar), 8, f); if (read_item < 8) { - _mmcam_dbg_err("fread failed"); + MMCAM_LOG_ERROR("fread failed"); return FALSE; } @@ -258,34 +356,32 @@ 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_LOG_INFO("seek %"PRIu64, buf_size); if (fseeko(f, (off_t)buf_size, SEEK_CUR) != 0) { - _mmcam_dbg_err("fseeko() fail"); + MMCAM_LOG_ERROR("fseeko() fail"); return FALSE; } } } - _mmcam_dbg_log("cannot find tag : %c%c%c%c", MMCAM_FOURCC_ARGS(tag_fourcc)); + MMCAM_LOG_INFO("cannot find tag : %c%c%c%c", MMCAM_FOURCC_ARGS(tag_fourcc)); return FALSE; } gboolean _mmcamcorder_update_size(FILE *f, gint64 prev_pos, gint64 curr_pos) { - _mmcam_dbg_log("size : %"G_GINT64_FORMAT"", curr_pos-prev_pos); - if(fseeko(f, prev_pos, SEEK_SET) != 0) - { - _mmcam_dbg_err("fseeko() fail"); + MMCAM_LOG_INFO("size : %"G_GINT64_FORMAT"", curr_pos-prev_pos); + if (fseeko(f, prev_pos, SEEK_SET) != 0) { + MMCAM_LOG_ERROR("fseeko() fail"); return FALSE; } if (!write_to_32(f, curr_pos -prev_pos)) return FALSE; - if(fseeko(f, curr_pos, SEEK_SET) != 0) - { - _mmcam_dbg_err("fseeko() fail"); + if (fseeko(f, curr_pos, SEEK_SET) != 0) { + MMCAM_LOG_ERROR("fseeko() fail"); return FALSE; } @@ -297,115 +393,113 @@ gboolean _mmcamcorder_write_loci(FILE *f, _MMCamcorderLocationInfo info) gint64 current_pos, pos; gchar *str = NULL; - _mmcam_dbg_log(""); + MMCAM_LOG_INFO(""); - if((pos = ftello(f))<0) - { - _mmcam_dbg_err("ftello() returns negative value"); + if ((pos = ftello(f)) < 0) { + MMCAM_LOG_ERROR("ftello() returns negative value"); return FALSE; } - if(!write_to_32(f, 0)) //size + if (!write_to_32(f, 0)) //size return FALSE; - if(!write_tag(f, "loci")) // type + if (!write_tag(f, "loci")) // type return FALSE; FPUTC_CHECK(0, f); // version - if(!write_to_24(f, 0)) // flags + if (!write_to_24(f, 0)) // flags return FALSE; - if(!write_to_16(f, get_language_code("eng"))) // language + if (!write_to_16(f, get_language_code("eng"))) // language return FALSE; str = str_to_utf8("location_name"); FPUTS_CHECK(str, f); // name - SAFE_FREE(str); + SAFE_G_FREE(str); FPUTC_CHECK('\0', f); FPUTC_CHECK(0, f); //role - if(!write_to_32(f, info.longitude)) // Longitude + if (!write_to_32(f, info.longitude)) // Longitude return FALSE; - if(!write_to_32(f, info.latitude)) // Latitude + if (!write_to_32(f, info.latitude)) // Latitude return FALSE; - if(! write_to_32(f, info.altitude)) // Altitude + if (!write_to_32(f, info.altitude)) // Altitude return FALSE; str = str_to_utf8("Astronomical_body"); FPUTS_CHECK(str, f);//Astronomical_body - SAFE_FREE(str); + SAFE_G_FREE(str); FPUTC_CHECK('\0', f); str = str_to_utf8("Additional_notes"); FPUTS_CHECK(str, f); // Additional_notes - SAFE_FREE(str); + SAFE_G_FREE(str); FPUTC_CHECK('\0', f); - if((current_pos = ftello(f))<0) - { - _mmcam_dbg_err("ftello() returns negative value"); + if ((current_pos = ftello(f)) < 0) { + MMCAM_LOG_ERROR("ftello() returns negative value"); return FALSE; } - if(! _mmcamcorder_update_size(f, pos, current_pos)) + if (!_mmcamcorder_update_size(f, pos, current_pos)) return FALSE; return TRUE; } -void _mmcamcorder_write_Latitude(FILE *f,int value) { - char s_latitude[9]; +void _mmcamcorder_write_Latitude(FILE *f, int value) +{ + 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); - } else { - snprintf(s_latitude, 5, "%.2d.", l_decimal); - } + if (l_decimal == 0) + snprintf(s_latitude, sizeof(s_latitude), "-%.2d.", l_decimal); + else + 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) { + 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]; +void _mmcamcorder_write_Longitude(FILE *f, int value) +{ + 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); - } else { - snprintf(s_longitude, 6, "%.3d.", l_decimal); - } + if (l_decimal == 0) + snprintf(s_longitude, sizeof(s_longitude), "-%.3d.", l_decimal); + else + 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) { + 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); } @@ -415,39 +509,37 @@ void _mmcamcorder_write_Longitude(FILE *f,int value) { // 0x15c7 -> encode in english #define D_INFO_GEOGRAPH 0x001215c7 -gboolean _mmcamcorder_write_geodata(FILE *f,_MMCamcorderLocationInfo info) { - +gboolean _mmcamcorder_write_geodata(FILE *f, _MMCamcorderLocationInfo info) +{ gint64 current_pos, pos; - _mmcam_dbg_log(""); + MMCAM_LOG_INFO(""); - if((pos = ftello(f))<0) - { - _mmcam_dbg_err("ftello() returns negative value"); + if ((pos = ftello(f)) < 0) { + MMCAM_LOG_ERROR("ftello() returns negative value"); return FALSE; } - if(!write_to_32(f, 0)) //size + if (!write_to_32(f, 0)) //size return FALSE; // tag -> .xyz - if(!write_tag(f, D_GEOGRAPH)) // type + if (!write_tag(f, D_GEOGRAPH)) // type return FALSE; - if(!write_to_32(f, D_INFO_GEOGRAPH)) + if (!write_to_32(f, D_INFO_GEOGRAPH)) return FALSE; - _mmcamcorder_write_Latitude(f,info.latitude); - _mmcamcorder_write_Longitude(f,info.longitude); + _mmcamcorder_write_Latitude(f, info.latitude); + _mmcamcorder_write_Longitude(f, info.longitude); FPUTC_CHECK(0x2F, f); - if((current_pos = ftello(f))<0) - { - _mmcam_dbg_err("ftello() returns negative value"); + if ((current_pos = ftello(f)) < 0) { + MMCAM_LOG_ERROR("ftello() returns negative value"); return FALSE; } - if(! _mmcamcorder_update_size(f, pos, current_pos)) + if (!_mmcamcorder_update_size(f, pos, current_pos)) return FALSE; return TRUE; @@ -458,52 +550,52 @@ gboolean _mmcamcorder_write_udta(FILE *f, int gps_enable, _MMCamcorderLocationIn { gint64 current_pos, pos; - _mmcam_dbg_log("gps enable : %d", gps_enable); + MMCAM_LOG_INFO("gps enable : %d", gps_enable); if (gps_enable == FALSE) { - _mmcam_dbg_log("no need to write udta"); + MMCAM_LOG_INFO("no need to write udta"); return TRUE; } - if ((pos = ftello(f))<0) { - _mmcam_dbg_err("ftello() returns negative value"); + if ((pos = ftello(f)) < 0) { + MMCAM_LOG_ERROR("ftello() returns negative value"); return FALSE; } /* size */ if (!write_to_32(f, 0)) { - _mmcam_dbg_err("failed to write size"); + MMCAM_LOG_ERROR("failed to write size"); return FALSE; } /* type */ if (!write_tag(f, "udta")) { - _mmcam_dbg_err("failed to write type udta"); + MMCAM_LOG_ERROR("failed to write type udta"); return FALSE; } if (gps_enable) { if (!_mmcamcorder_write_loci(f, info)) { - _mmcam_dbg_err("failed to write loci"); + MMCAM_LOG_ERROR("failed to write loci"); return FALSE; } - if (!_mmcamcorder_write_geodata(f,geotag)) { - _mmcam_dbg_err("failed to write geodata"); + if (!_mmcamcorder_write_geodata(f, geotag)) { + MMCAM_LOG_ERROR("failed to write geodata"); return FALSE; } } - if ((current_pos = ftello(f))<0) { - _mmcam_dbg_err("ftello() returns negative value"); + if ((current_pos = ftello(f)) < 0) { + MMCAM_LOG_ERROR("ftello() returns negative value"); return FALSE; } if (!_mmcamcorder_update_size(f, pos, current_pos)) { - _mmcam_dbg_err("failed to update size"); + MMCAM_LOG_ERROR("failed to update size"); return FALSE; } - _mmcam_dbg_log("done"); + MMCAM_LOG_INFO("done"); return TRUE; } @@ -522,7 +614,7 @@ guint64 _mmcamcorder_get_container_size(const guchar *size) result = result | (temp << 8); result = result | size[3]; - _mmcam_dbg_log("result : %llu", result); + MMCAM_LOG_INFO("result : %"G_GUINT64_FORMAT, result); return result; } @@ -549,7 +641,7 @@ guint64 _mmcamcorder_get_container_size64(const guchar *size) result = result | (temp << 8); result = result | size[7]; - _mmcam_dbg_log("result : %llu", result); + MMCAM_LOG_INFO("result : %"G_GUINT64_FORMAT, result); return result; } @@ -595,65 +687,177 @@ gboolean _mmcamcorder_update_composition_matrix(FILE *f, int orientation) write_to_32(f, 0); write_to_32(f, 0x40000000); - _mmcam_dbg_log("orientation : %d, write data 0x%x 0x%x 0x%x 0x%x", - orientation, a, b, c, d); + MMCAM_LOG_INFO("orientation : %d, write data 0x%x 0x%x 0x%x 0x%x", + orientation, a, b, c, d); return TRUE; } -int _mmcamcorder_get_freespace(const gchar *path, const gchar *root_directory, guint64 *free_space) +static int __mmcamcorder_storage_supported_cb(int storage_id, storage_type_e type, + storage_state_e state, const char *path, void *user_data) { - int ret = 0; - struct statvfs vfs; + _MMCamcorderStorageInfo *info = (_MMCamcorderStorageInfo *)user_data; + + if (!info) { + MMCAM_LOG_ERROR("NULL info"); + return FALSE; + } + + if (type == info->type) { + info->id = storage_id; + return FALSE; + } + + return TRUE; +} + + +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_LOG_WARNING("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_LOG_ERROR("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_LOG_ERROR("get free space failed"); + ret = MM_ERROR_CAMCORDER_INTERNAL; + goto _CHECK_DONE; + } + + MMCAM_LOG_WARNING("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_LOG_INFO("validity and free space of storage : OK"); + } else { + *storage_validity = FALSE; + MMCAM_LOG_ERROR("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_LOG_WARNING("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_LOG_WARNING("file system 0x%x, max size %"G_GUINT64_FORMAT, + file_system_type, *max_size); + } + } + + g_free(dir_name); +} - int is_internal = TRUE; + +int _mmcamcorder_get_storage_info(const gchar *path, const gchar *root_directory, _MMCamcorderStorageInfo *info) +{ + int ret = 0; struct stat stat_path; struct stat stat_root; - if (path == NULL || free_space == NULL) { - _mmcam_dbg_err("invalid parameter %p, %p", path, free_space); + if (!path || !root_directory || !info) { + MMCAM_LOG_ERROR("invalid parameter %p %p %p", path, root_directory, info); return -1; } - if (root_directory && strlen(root_directory) > 0) { + if (strlen(root_directory) > 0) { if (stat(path, &stat_path) != 0) { - *free_space = 0; - _mmcam_dbg_err("failed to stat for [%s][errno %d]", path, errno); + MMCAM_LOG_ERROR("failed to stat for [%s][errno %d]", path, errno); return -1; } if (stat(root_directory, &stat_root) != 0) { - *free_space = 0; - _mmcam_dbg_err("failed to stat for [%s][errno %d]", root_directory, errno); + MMCAM_LOG_ERROR("failed to stat for [%s][errno %d]", root_directory, errno); return -1; } - if (stat_path.st_dev != stat_root.st_dev) { - is_internal = FALSE; - } + if (stat_path.st_dev == stat_root.st_dev) + info->type = STORAGE_TYPE_INTERNAL; + else + info->type = STORAGE_TYPE_EXTERNAL; } else { - _mmcam_dbg_warn("root_directory is NULL, assume that it's internal storage."); + info->type = STORAGE_TYPE_INTERNAL; + MMCAM_LOG_WARNING("invalid length of root directory, assume that it's internal storage."); } - if (is_internal) { + ret = storage_foreach_device_supported((storage_device_supported_cb)__mmcamcorder_storage_supported_cb, info); + if (ret != STORAGE_ERROR_NONE) { + MMCAM_LOG_ERROR("storage_foreach_device_supported failed 0x%x", ret); + return -1; + } + + MMCAM_LOG_INFO("storage info - type %d, id %d", info->type, info->id); + + return 0; +} + + +int _mmcamcorder_get_freespace(storage_type_e type, guint64 *free_space) +{ + int ret = 0; + struct statvfs vfs; + + if (type == STORAGE_TYPE_INTERNAL) ret = storage_get_internal_memory_size(&vfs); - } else { + else ret = storage_get_external_memory_size(&vfs); - } - if (ret < 0) { + if (ret != STORAGE_ERROR_NONE) { *free_space = 0; - _mmcam_dbg_err("failed to get memory size [%s]", path); + MMCAM_LOG_ERROR("get memory size failed [type %d] 0x%x", type, ret); return -1; - } else { - *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); - */ - return 1; } + + *free_space = vfs.f_bsize * vfs.f_bavail; + /* + MMCAM_LOG_INFO("vfs.f_bsize [%lu], vfs.f_bavail [%lu]", vfs.f_bsize, vfs.f_bavail); + MMCAM_LOG_INFO("memory size %"G_GUINT64_FORMAT" [%s]", *free_space, path); + */ + return 0; } @@ -664,12 +868,12 @@ int _mmcamcorder_get_file_system_type(const gchar *path, int *file_system_type) g_assert(path); if (!g_file_test(path, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR)) { - _mmcam_dbg_log("File(%s) doesn't exist.", path); + MMCAM_LOG_INFO("File(%s) doesn't exist.", path); return -2; } if (-1 == statfs(path, &fs)) { - _mmcam_dbg_log("statfs failed.(%s)", path); + MMCAM_LOG_INFO("statfs failed.(%s)", path); return -1; } @@ -679,36 +883,225 @@ int _mmcamcorder_get_file_system_type(const gchar *path, int *file_system_type) } -int _mmcamcorder_get_device_flash_brightness(int *brightness) +int _mmcamcorder_get_camera_id(int device_type, int *camera_id) +{ + int ret = MM_ERROR_NONE; + MMCamPreset info = {.videodev_type = device_type}; + MMHandleType handle = NULL; + mmf_camcorder_t *hcamcorder = NULL; + type_int_array *input_index = NULL; + + mmf_return_val_if_fail(camera_id, MM_ERROR_CAMCORDER_INVALID_ARGUMENT); + + ret = _mmcamcorder_create(&handle, &info); + if (ret != MM_ERROR_NONE) { + MMCAM_LOG_ERROR("_mmcamcorder_create failed[0x%x]", ret); + return ret; + } + + hcamcorder = MMF_CAMCORDER(handle); + + _mmcamcorder_conf_get_value_int_array(hcamcorder->conf_ctrl, + CONFIGURE_CATEGORY_CTRL_CAMERA, + "InputIndex", &input_index); + if (!input_index) { + MMCAM_LOG_ERROR("Get input index failed"); + ret = MM_ERROR_CAMCORDER_INTERNAL; + goto _GET_CAMERA_ID_OUT; + } + + *camera_id = input_index->default_value; + + MMCAM_LOG_INFO("device type[%d] -> camera id[%d]", device_type, *camera_id); + +_GET_CAMERA_ID_OUT: + _mmcamcorder_destroy(handle); + + return ret; +} + + +int _mmcamcorder_get_device_led_brightness(GDBusConnection *conn, int *brightness) { int get_value = 0; int ret = MM_ERROR_NONE; - GVariant *params = NULL, *result = NULL; - const char *param_type = "(i)"; - - if ((ret = __gdbus_method_call_sync("org.tizen.system.deviced", - "/Org/Tizen/System/DeviceD/Led", - "org.tizen.system.deviced.Led", - "GetBrightnessForCamera", - params, - &result, - TRUE)) != MM_ERROR_NONE) { - _mmcam_dbg_err("Dbus Call on Client Error"); + GVariant *params = NULL; + GVariant *result = NULL; + + ret = __gdbus_method_call_sync(conn, "org.tizen.system.deviced", + "/Org/Tizen/System/DeviceD/Led", "org.tizen.system.deviced.Led", + "GetBrightnessForCamera", params, &result, TRUE); + if (ret != MM_ERROR_NONE) { + MMCAM_LOG_ERROR("Dbus Call on Client Error"); return ret; } if (result) { - g_variant_get(result, param_type, &get_value); + g_variant_get(result, "(i)", &get_value); *brightness = get_value; - _mmcam_dbg_log("flash brightness : %d", *brightness); + MMCAM_LOG_INFO("flash brightness : %d", *brightness); + g_variant_unref(result); } else { - _mmcam_dbg_err("replied result is null"); + MMCAM_LOG_ERROR("replied result is null"); ret = MM_ERROR_CAMCORDER_INTERNAL; } return ret; } + +_MMCamcorderGDbusCbInfo *_mmcamcorder_gdbus_info_new(void) +{ + _MMCamcorderGDbusCbInfo *new_info = g_new0(_MMCamcorderGDbusCbInfo, 1); + + g_mutex_init(&new_info->sync_mutex); + g_cond_init(&new_info->sync_cond); + + MMCAM_LOG_INFO("new gdbus_info[%p]", new_info); + + return new_info; +} + + +void _mmcamcorder_gdbus_info_free(_MMCamcorderGDbusCbInfo *info) +{ + if (!info) { + MMCAM_LOG_WARNING("NULL info"); + return; + } + + MMCAM_LOG_INFO("free gdbus_info[%p]", info); + + g_mutex_clear(&info->sync_mutex); + g_cond_clear(&info->sync_cond); + + g_free(info); +} + + +void _mmcamcorder_gdbus_info_check_free(_MMCamcorderGDbusCbInfo *info) +{ + gboolean do_free = FALSE; + + if (!info) { + MMCAM_LOG_WARNING("NULL info"); + return; + } + + g_mutex_lock(&info->sync_mutex); + + if (info->subscribe_id > 0) { + MMCAM_LOG_WARNING("gdbus_info[%p] will be freed in sound EOS cb", info); + info->free_in_cb = TRUE; + } else { + do_free = TRUE; + } + + g_mutex_unlock(&info->sync_mutex); + + if (do_free) + _mmcamcorder_gdbus_info_free(info); +} + + +int _mmcamcorder_send_sound_play_message(GDBusConnection *conn, _MMCamcorderGDbusCbInfo *gdbus_info, + const char *sample_name, const char *stream_role, const char *volume_gain, int sync_play) +{ + int get_value = 0; + int ret = MM_ERROR_NONE; + GVariant *params = NULL; + GVariant *result = NULL; + guint subs_id = 0; + + if (!conn || !gdbus_info) { + MMCAM_LOG_ERROR("Invalid parameter %p %p", conn, gdbus_info); + return MM_ERROR_CAMCORDER_INTERNAL; + } + + params = g_variant_new("(sss)", sample_name, stream_role, volume_gain); + + ret = __gdbus_method_call_sync(conn, "org.pulseaudio.Server", + "/org/pulseaudio/SoundPlayer", "org.pulseaudio.SoundPlayer", + "SamplePlay", params, &result, TRUE); + if (ret != MM_ERROR_NONE) { + MMCAM_LOG_ERROR("Dbus Call on Client Error"); + return ret; + } + + if (result) { + g_variant_get(result, "(i)", &get_value); + MMCAM_LOG_INFO("played index : %d", get_value); + g_variant_unref(result); + } else { + MMCAM_LOG_ERROR("replied result is null"); + return MM_ERROR_CAMCORDER_INTERNAL; + } + + g_mutex_lock(&gdbus_info->sync_mutex); + + if (gdbus_info->subscribe_id > 0) { + MMCAM_LOG_WARNING("subscribe_id[%u] is remained. remove it.", gdbus_info->subscribe_id); + + g_dbus_connection_signal_unsubscribe(conn, gdbus_info->subscribe_id); + + gdbus_info->subscribe_id = 0; + } + + gdbus_info->is_playing = TRUE; + gdbus_info->param = get_value; + + ret = __gdbus_subscribe_signal(conn, + "/org/pulseaudio/SoundPlayer", "org.pulseaudio.SoundPlayer", "EOS", + __gdbus_stream_eos_cb, &subs_id, gdbus_info); + + if (ret == MM_ERROR_NONE) + gdbus_info->subscribe_id = subs_id; + + g_mutex_unlock(&gdbus_info->sync_mutex); + + if (sync_play && ret == MM_ERROR_NONE) + 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_LOG_ERROR("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_LOG_ERROR("Dbus Call on Client Error 0x%x", ret); + return; + } + + if (result) { + g_variant_get(result, "(b)", &get_value); + MMCAM_LOG_INFO("request result : %d", get_value); + g_variant_unref(result); + } else { + MMCAM_LOG_ERROR("replied result is null"); + } + + return; +} + + int _mmcamcorder_get_file_size(const char *filename, guint64 *size) { struct stat buf; @@ -729,35 +1122,35 @@ void _mmcamcorder_remove_buffer_probe(MMHandleType handle, _MMCamcorderHandlerCa mmf_return_if_fail(hcamcorder); if (!hcamcorder->buffer_probes) { - _mmcam_dbg_warn("list for buffer probe is NULL"); + MMCAM_LOG_WARNING("list for buffer probe is NULL"); return; } - _mmcam_dbg_log("start - category : 0x%x", category); + MMCAM_LOG_INFO("start - category : 0x%x", category); list = hcamcorder->buffer_probes; while (list) { item = list->data; if (!item) { - _mmcam_dbg_err("Remove buffer probe faild, the item is NULL"); + MMCAM_LOG_ERROR("Remove buffer probe failed, the item is NULL"); list = g_list_next(list); continue; } if (item->category & category) { if (item->object && GST_IS_PAD(item->object)) { - _mmcam_dbg_log("Remove buffer probe on [%s:%s] - [ID : %lu], [Category : %x]", - GST_DEBUG_PAD_NAME(item->object), item->handler_id, item->category); + MMCAM_LOG_INFO("Remove buffer probe on [%s:%s] - [ID : %lu], [Category : %x]", + GST_DEBUG_PAD_NAME(item->object), item->handler_id, item->category); gst_pad_remove_probe(GST_PAD(item->object), item->handler_id); } else { - _mmcam_dbg_warn("Remove buffer probe faild, the pad is null or not pad, just remove item from list and free it"); + MMCAM_LOG_WARNING("Remove buffer probe failed, the pad is null or not pad, just remove item from list and free it"); } list = g_list_next(list); hcamcorder->buffer_probes = g_list_remove(hcamcorder->buffer_probes, item); - SAFE_FREE(item); + SAFE_G_FREE(item); } else { - _mmcam_dbg_log("Skip item : [ID : %lu], [Category : %x] ", item->handler_id, item->category); + MMCAM_LOG_INFO("Skip item : [ID : %lu], [Category : %x] ", item->handler_id, item->category); list = g_list_next(list); } } @@ -767,7 +1160,7 @@ void _mmcamcorder_remove_buffer_probe(MMHandleType handle, _MMCamcorderHandlerCa hcamcorder->buffer_probes = NULL; } - _mmcam_dbg_log("done"); + MMCAM_LOG_INFO("done"); return; } @@ -782,42 +1175,42 @@ void _mmcamcorder_remove_one_buffer_probe(MMHandleType handle, void *object) mmf_return_if_fail(hcamcorder); if (!hcamcorder->buffer_probes) { - _mmcam_dbg_warn("list for buffer probe is NULL"); + MMCAM_LOG_WARNING("list for buffer probe is NULL"); return; } - _mmcam_dbg_log("start - object : %p", object); + MMCAM_LOG_INFO("start - object : %p", object); list = hcamcorder->buffer_probes; while (list) { item = list->data; if (!item) { - _mmcam_dbg_err("Remove buffer probe faild, the item is NULL"); + MMCAM_LOG_ERROR("Remove buffer probe failed, the item is NULL"); list = g_list_next(list); continue; } if (item->object && item->object == object) { if (GST_IS_PAD(item->object)) { - _mmcam_dbg_log("Remove buffer probe on [%s:%s] - [ID : %lu], [Category : %x]", - GST_DEBUG_PAD_NAME(item->object), item->handler_id, item->category); + MMCAM_LOG_INFO("Remove buffer probe on [%s:%s] - [ID : %lu], [Category : %x]", + GST_DEBUG_PAD_NAME(item->object), item->handler_id, item->category); gst_pad_remove_probe(GST_PAD(item->object), item->handler_id); } else { - _mmcam_dbg_warn("Remove buffer probe faild, the pad is null or not pad, just remove item from list and free it"); + MMCAM_LOG_WARNING("Remove buffer probe failed, the pad is null or not pad, just remove item from list and free it"); } list = g_list_next(list); hcamcorder->buffer_probes = g_list_remove(hcamcorder->buffer_probes, item); - SAFE_FREE(item); + SAFE_G_FREE(item); break; } else { - _mmcam_dbg_log("Skip item : [ID : %lu], [Category : %x] ", item->handler_id, item->category); + MMCAM_LOG_INFO("Skip item : [ID : %lu], [Category : %x] ", item->handler_id, item->category); list = g_list_next(list); } } - _mmcam_dbg_log("done"); + MMCAM_LOG_INFO("done"); return; } @@ -832,35 +1225,35 @@ void _mmcamcorder_remove_event_probe(MMHandleType handle, _MMCamcorderHandlerCat mmf_return_if_fail(hcamcorder); if (!hcamcorder->event_probes) { - _mmcam_dbg_warn("list for event probe is NULL"); + MMCAM_LOG_WARNING("list for event probe is NULL"); return; } - _mmcam_dbg_log("start - category : 0x%x", category); + MMCAM_LOG_INFO("start - category : 0x%x", category); list = hcamcorder->event_probes; while (list) { item = list->data; if (!item) { - _mmcam_dbg_err("Remove event probe faild, the item is NULL"); + MMCAM_LOG_ERROR("Remove event probe failed, the item is NULL"); list = g_list_next(list); continue; } if (item->category & category) { if (item->object && GST_IS_PAD(item->object)) { - _mmcam_dbg_log("Remove event probe on [%s:%s] - [ID : %lu], [Category : %x]", - GST_DEBUG_PAD_NAME(item->object), item->handler_id, item->category); + MMCAM_LOG_INFO("Remove event probe on [%s:%s] - [ID : %lu], [Category : %x]", + GST_DEBUG_PAD_NAME(item->object), item->handler_id, item->category); gst_pad_remove_probe(GST_PAD(item->object), item->handler_id); } else { - _mmcam_dbg_warn("Remove event probe faild, the pad is null or not pad, just remove item from list and free it"); + MMCAM_LOG_WARNING("Remove event probe failed, the pad is null or not pad, just remove item from list and free it"); } list = g_list_next(list); hcamcorder->event_probes = g_list_remove(hcamcorder->event_probes, item); - SAFE_FREE(item); + SAFE_G_FREE(item); } else { - _mmcam_dbg_log("Skip item : [ID : %lu], [Category : %x] ", item->handler_id, item->category); + MMCAM_LOG_INFO("Skip item : [ID : %lu], [Category : %x] ", item->handler_id, item->category); list = g_list_next(list); } } @@ -870,7 +1263,7 @@ void _mmcamcorder_remove_event_probe(MMHandleType handle, _MMCamcorderHandlerCat hcamcorder->event_probes = NULL; } - _mmcam_dbg_log("done"); + MMCAM_LOG_INFO("done"); return; } @@ -885,17 +1278,17 @@ void _mmcamcorder_disconnect_signal(MMHandleType handle, _MMCamcorderHandlerCate mmf_return_if_fail(hcamcorder); if (!hcamcorder->signals) { - _mmcam_dbg_warn("list for signal is NULL"); + MMCAM_LOG_WARNING("list for signal is NULL"); return; } - _mmcam_dbg_log("start - category : 0x%x", category); + MMCAM_LOG_INFO("start - category : 0x%x", category); list = hcamcorder->signals; while (list) { item = list->data; if (!item) { - _mmcam_dbg_err("Fail to Disconnecting signal, the item is NULL"); + MMCAM_LOG_ERROR("Fail to Disconnecting signal, the item is NULL"); list = g_list_next(list); continue; } @@ -903,22 +1296,22 @@ void _mmcamcorder_disconnect_signal(MMHandleType handle, _MMCamcorderHandlerCate if (item->category & category) { if (item->object && GST_IS_ELEMENT(item->object)) { if (g_signal_handler_is_connected(item->object, item->handler_id)) { - _mmcam_dbg_log("Disconnect signal from [%s] : [ID : %lu], [Category : %x]", - GST_OBJECT_NAME(item->object), item->handler_id, item->category); + MMCAM_LOG_INFO("Disconnect signal from [%s] : [ID : %lu], [Category : %x]", + GST_OBJECT_NAME(item->object), item->handler_id, item->category); g_signal_handler_disconnect(item->object, item->handler_id); } else { - _mmcam_dbg_warn("Signal was not connected, cannot disconnect it : [%s] [ID : %lu], [Category : %x]", - GST_OBJECT_NAME(item->object), item->handler_id, item->category); + MMCAM_LOG_WARNING("Signal was not connected, cannot disconnect it : [%s] [ID : %lu], [Category : %x]", + GST_OBJECT_NAME(item->object), item->handler_id, item->category); } } else { - _mmcam_dbg_err("Fail to Disconnecting signal, the element is null or not element, just remove item from list and free it"); + MMCAM_LOG_ERROR("Fail to Disconnecting signal, the element is null or not element, just remove item from list and free it"); } list = g_list_next(list); hcamcorder->signals = g_list_remove(hcamcorder->signals, item); - SAFE_FREE(item); + SAFE_G_FREE(item); } else { - _mmcam_dbg_log("Skip item : [ID : %lu], [Category : %x] ", item->handler_id, item->category); + MMCAM_LOG_INFO("Skip item : [ID : %lu], [Category : %x] ", item->handler_id, item->category); list = g_list_next(list); } } @@ -928,7 +1321,7 @@ void _mmcamcorder_disconnect_signal(MMHandleType handle, _MMCamcorderHandlerCate hcamcorder->signals = NULL; } - _mmcam_dbg_log("done"); + MMCAM_LOG_INFO("done"); return; } @@ -938,22 +1331,22 @@ void _mmcamcorder_remove_all_handlers(MMHandleType handle, _MMCamcorderHandlerC { mmf_camcorder_t* hcamcorder = MMF_CAMCORDER(handle); - _mmcam_dbg_log("ENTER"); + MMCAM_LOG_INFO("ENTER"); - if(hcamcorder->signals) + if (hcamcorder->signals) _mmcamcorder_disconnect_signal((MMHandleType)hcamcorder, category); - if(hcamcorder->event_probes) + if (hcamcorder->event_probes) _mmcamcorder_remove_event_probe((MMHandleType)hcamcorder, category); - if(hcamcorder->buffer_probes) + if (hcamcorder->buffer_probes) _mmcamcorder_remove_buffer_probe((MMHandleType)hcamcorder, category); - _mmcam_dbg_log("LEAVE"); + MMCAM_LOG_INFO("LEAVE"); } void _mmcamcorder_element_release_noti(gpointer data, GObject *where_the_object_was) { - int i=0; + int i = 0; _MMCamcorderSubContext *sc = (_MMCamcorderSubContext *)data; mmf_return_if_fail(sc); @@ -961,8 +1354,7 @@ void _mmcamcorder_element_release_noti(gpointer data, GObject *where_the_object_ for (i = 0 ; i < _MMCAMCORDER_PIPELINE_ELEMENT_NUM ; i++) { if (sc->element[i].gst && (G_OBJECT(sc->element[i].gst) == where_the_object_was)) { - _mmcam_dbg_warn("The element[%d][%p] is finalized", - sc->element[i].id, sc->element[i].gst); + MMCAM_LOG_WARNING("The element[%d][%p] is finalized", sc->element[i].id, sc->element[i].gst); sc->element[i].gst = NULL; sc->element[i].id = _MMCAMCORDER_NONE; return; @@ -973,15 +1365,14 @@ void _mmcamcorder_element_release_noti(gpointer data, GObject *where_the_object_ for (i = 0 ; i < _MMCAMCORDER_ENCODE_PIPELINE_ELEMENT_NUM ; i++) { if (sc->encode_element[i].gst && (G_OBJECT(sc->encode_element[i].gst) == where_the_object_was)) { - _mmcam_dbg_warn("The encode element[%d][%p] is finalized", - sc->encode_element[i].id, sc->encode_element[i].gst); + MMCAM_LOG_WARNING("The encode element[%d][%p] is finalized", sc->encode_element[i].id, sc->encode_element[i].gst); sc->encode_element[i].gst = NULL; sc->encode_element[i].id = _MMCAMCORDER_ENCODE_NONE; return; } } - _mmcam_dbg_warn("there is no matching element %p", where_the_object_was); + MMCAM_LOG_WARNING("there is no matching element %p", where_the_object_was); return; } @@ -994,32 +1385,32 @@ gboolean _mmcamcorder_msg_callback(void *data) mmf_camcorder_t *hcamcorder = NULL; mmf_return_val_if_fail(item, FALSE); - pthread_mutex_lock(&(item->lock)); + g_mutex_lock(&item->lock); hcamcorder = MMF_CAMCORDER(item->handle); if (hcamcorder == NULL) { - _mmcam_dbg_warn("msg id:0x%x, item:%p, handle is NULL", item->id, item); + MMCAM_LOG_WARNING("msg id:0x%x, item:%p, handle is NULL", item->id, item); goto MSG_CALLBACK_DONE; } - /*_mmcam_dbg_log("msg id:%x, msg_cb:%p, msg_data:%p, item:%p", item->id, hcamcorder->msg_cb, hcamcorder->msg_data, item);*/ + /*MMCAM_LOG_INFO("msg id:%x, msg_cb:%p, msg_data:%p, item:%p", item->id, hcamcorder->msg_cb, hcamcorder->msg_data, item);*/ - _MMCAMCORDER_LOCK((MMHandleType)hcamcorder); + _MMCAMCORDER_LOCK(hcamcorder); /* remove item from msg data */ if (hcamcorder->msg_data) { + /*MMCAM_LOG_INFO("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); + MMCAM_LOG_WARNING("msg_data is NULL but item[%p] will be removed", item); } - _MMCAMCORDER_UNLOCK((MMHandleType)hcamcorder); + _MMCAMCORDER_UNLOCK(hcamcorder); _MMCAMCORDER_LOCK_MESSAGE_CALLBACK(hcamcorder); - if ((hcamcorder) && (hcamcorder->msg_cb)) { + if ((hcamcorder) && (hcamcorder->msg_cb)) hcamcorder->msg_cb(item->id, (MMMessageParamType*)(&(item->param)), hcamcorder->msg_cb_param); - } _MMCAMCORDER_UNLOCK_MESSAGE_CALLBACK(hcamcorder); @@ -1030,33 +1421,26 @@ MSG_CALLBACK_DONE: if (item->id == MM_MESSAGE_CAMCORDER_FACE_DETECT_INFO) { MMCamFaceDetectInfo *cam_fd_info = (MMCamFaceDetectInfo *)item->param.data; if (cam_fd_info) { - SAFE_FREE(cam_fd_info->face_info); - free(cam_fd_info); - cam_fd_info = NULL; + SAFE_G_FREE(cam_fd_info->face_info); + SAFE_G_FREE(cam_fd_info); item->param.data = NULL; item->param.size = 0; } - } else if (item->id == MM_MESSAGE_CAMCORDER_VIDEO_CAPTURED || - item->id == MM_MESSAGE_CAMCORDER_AUDIO_CAPTURED) { + } 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) { - free(report->recording_filename); - report->recording_filename = NULL; - } - free(report); + SAFE_G_FREE(report->recording_filename); + g_free(report); report = NULL; - item->param.data = NULL; } } - pthread_mutex_unlock(&(item->lock)); - pthread_mutex_destroy(&(item->lock)); + g_mutex_unlock(&item->lock); + g_mutex_clear(&item->lock); - free(item); - item = NULL; + SAFE_G_FREE(item); /* For not being called again */ return FALSE; @@ -1074,61 +1458,56 @@ gboolean _mmcamcorder_send_message(MMHandleType handle, _MMCamcorderMsgItem *dat mmf_return_val_if_fail(hcamcorder, FALSE); mmf_return_val_if_fail(data, FALSE); - switch (data->id) - { - case MM_MESSAGE_CAMCORDER_STATE_CHANGED: - case MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_ASM: - data->param.union_type = MM_MSG_UNION_STATE; - break; - case MM_MESSAGE_CAMCORDER_RECORDING_STATUS: - data->param.union_type = MM_MSG_UNION_RECORDING_STATUS; - break; - case MM_MESSAGE_CAMCORDER_FIRMWARE_UPDATE: - data->param.union_type = MM_MSG_UNION_FIRMWARE; - break; - case MM_MESSAGE_CAMCORDER_CURRENT_VOLUME: - data->param.union_type = MM_MSG_UNION_REC_VOLUME_DB; - break; - case MM_MESSAGE_CAMCORDER_TIME_LIMIT: - case MM_MESSAGE_CAMCORDER_MAX_SIZE: - case MM_MESSAGE_CAMCORDER_NO_FREE_SPACE: - case MM_MESSAGE_CAMCORDER_ERROR: - case MM_MESSAGE_CAMCORDER_FOCUS_CHANGED: - case MM_MESSAGE_CAMCORDER_CAPTURED: - case MM_MESSAGE_CAMCORDER_VIDEO_CAPTURED: - case MM_MESSAGE_CAMCORDER_AUDIO_CAPTURED: - case MM_MESSAGE_READY_TO_RESUME: - default: - data->param.union_type = MM_MSG_UNION_CODE; - break; + switch (data->id) { + case MM_MESSAGE_CAMCORDER_STATE_CHANGED: + case MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_RM: + data->param.union_type = MM_MSG_UNION_STATE; + break; + case MM_MESSAGE_CAMCORDER_RECORDING_STATUS: + data->param.union_type = MM_MSG_UNION_RECORDING_STATUS; + break; + case MM_MESSAGE_CAMCORDER_FIRMWARE_UPDATE: + data->param.union_type = MM_MSG_UNION_FIRMWARE; + break; + case MM_MESSAGE_CAMCORDER_CURRENT_VOLUME: + data->param.union_type = MM_MSG_UNION_REC_VOLUME_DB; + break; + case MM_MESSAGE_CAMCORDER_TIME_LIMIT: + case MM_MESSAGE_CAMCORDER_MAX_SIZE: + case MM_MESSAGE_CAMCORDER_NO_FREE_SPACE: + case MM_MESSAGE_CAMCORDER_ERROR: + case MM_MESSAGE_CAMCORDER_FOCUS_CHANGED: + case MM_MESSAGE_CAMCORDER_CAPTURED: + case MM_MESSAGE_CAMCORDER_VIDEO_CAPTURED: + case MM_MESSAGE_CAMCORDER_AUDIO_CAPTURED: + case MM_MESSAGE_READY_TO_RESUME: + default: + data->param.union_type = MM_MSG_UNION_CODE; + break; } #ifdef _MMCAMCORDER_ENABLE_IDLE_MESSAGE_CALLBACK item = g_malloc(sizeof(_MMCamcorderMsgItem)); - if (item) { - memcpy(item, data, sizeof(_MMCamcorderMsgItem)); - item->handle = handle; - pthread_mutex_init(&(item->lock), NULL); - _MMCAMCORDER_LOCK(handle); - hcamcorder->msg_data = g_list_append(hcamcorder->msg_data, item); - /*_mmcam_dbg_log("item[%p]", item);*/ + memcpy(item, data, sizeof(_MMCamcorderMsgItem)); + item->handle = handle; + g_mutex_init(&item->lock); - /* Use DEFAULT priority */ - g_idle_add_full(G_PRIORITY_DEFAULT, _mmcamcorder_msg_callback, item, NULL); + _MMCAMCORDER_LOCK(handle); + hcamcorder->msg_data = g_list_append(hcamcorder->msg_data, item); + /*MMCAM_LOG_INFO("item[%p]", item);*/ - _MMCAMCORDER_UNLOCK(handle); - } else { - _mmcam_dbg_err("item[id:0x%x] malloc failed : %d", data->id, sizeof(_MMCamcorderMsgItem)); - } + /* Use DEFAULT priority */ + g_idle_add_full(G_PRIORITY_DEFAULT, _mmcamcorder_msg_callback, item, NULL); + + _MMCAMCORDER_UNLOCK(handle); #else /* _MMCAMCORDER_ENABLE_IDLE_MESSAGE_CALLBACK */ _MMCAMCORDER_LOCK_MESSAGE_CALLBACK(hcamcorder); - if (hcamcorder->msg_cb) { + if (hcamcorder->msg_cb) hcamcorder->msg_cb(data->id, (MMMessageParamType*)(&(data->param)), hcamcorder->msg_cb_param); - } else { - _mmcam_dbg_log("message callback is NULL. message id %d", data->id); - } + else + MMCAM_LOG_INFO("message callback is NULL. message id %d", data->id); _MMCAMCORDER_UNLOCK_MESSAGE_CALLBACK(hcamcorder); @@ -1136,25 +1515,16 @@ gboolean _mmcamcorder_send_message(MMHandleType handle, _MMCamcorderMsgItem *dat if (data->id == MM_MESSAGE_CAMCORDER_FACE_DETECT_INFO) { MMCamFaceDetectInfo *cam_fd_info = (MMCamFaceDetectInfo *)data->param.data; if (cam_fd_info) { - SAFE_FREE(cam_fd_info->face_info); - free(cam_fd_info); - cam_fd_info = NULL; - + SAFE_G_FREE(cam_fd_info->face_info); data->param.data = NULL; - data->param.size = 0; + g_free(cam_fd_info); } - } else if (data->id == MM_MESSAGE_CAMCORDER_VIDEO_CAPTURED || - data->id == MM_MESSAGE_CAMCORDER_AUDIO_CAPTURED) { + } else if (data->id == MM_MESSAGE_CAMCORDER_VIDEO_CAPTURED || data->id == MM_MESSAGE_CAMCORDER_AUDIO_CAPTURED) { MMCamRecordingReport *report = (MMCamRecordingReport *)data->param.data; if (report) { - if (report->recording_filename) { - free(report->recording_filename); - report->recording_filename = NULL; - } - free(report); - report = NULL; - + SAFE_G_FREE(report->recording_filename); data->param.data = NULL; + g_free(report); } } #endif /* _MMCAMCORDER_ENABLE_IDLE_MESSAGE_CALLBACK */ @@ -1170,10 +1540,7 @@ void _mmcamcorder_remove_message_all(MMHandleType handle) #ifdef _MMCAMCORDER_ENABLE_IDLE_MESSAGE_CALLBACK _MMCamcorderMsgItem *item = NULL; GList *list = NULL; - struct timespec timeout; - struct timeval tv; - struct timeval tv_to_add; - struct timeval tv_result; + gint64 end_time = 0; #endif /* _MMCAMCORDER_ENABLE_IDLE_MESSAGE_CALLBACK */ mmf_return_if_fail(hcamcorder); @@ -1182,11 +1549,8 @@ void _mmcamcorder_remove_message_all(MMHandleType handle) #ifdef _MMCAMCORDER_ENABLE_IDLE_MESSAGE_CALLBACK if (!hcamcorder->msg_data) { - _mmcam_dbg_log("No message data is remained."); + MMCAM_LOG_INFO("No message data is remained."); } else { - tv_to_add.tv_sec = 0; - tv_to_add.tv_usec = 1000 * 100; /* 100 ms */ - list = hcamcorder->msg_data; while (list) { @@ -1194,69 +1558,54 @@ void _mmcamcorder_remove_message_all(MMHandleType handle) list = g_list_next(list); if (!item) { - _mmcam_dbg_err("Fail to remove message. The item is NULL"); + MMCAM_LOG_ERROR("Fail to remove message. The item is NULL"); } else { - if (pthread_mutex_trylock(&(item->lock))) { + if (g_mutex_trylock(&(item->lock))) { ret = g_idle_remove_by_data(item); - _mmcam_dbg_log("remove msg item[%p], ret[%d]", item, ret); + MMCAM_LOG_INFO("remove msg item[%p], ret[%d]", item, ret); if (ret == FALSE) { item->handle = 0; - _mmcam_dbg_warn("failed to remove msg cb for item %p, it will be called later with NULL handle", item); + MMCAM_LOG_WARNING("failed to remove msg cb for item %p, it will be called later with NULL handle", item); } /* release allocated memory */ if (item->id == MM_MESSAGE_CAMCORDER_FACE_DETECT_INFO) { MMCamFaceDetectInfo *cam_fd_info = (MMCamFaceDetectInfo *)item->param.data; if (cam_fd_info) { - SAFE_FREE(cam_fd_info->face_info); - free(cam_fd_info); - cam_fd_info = NULL; - - item->param.data = NULL; + SAFE_G_FREE(cam_fd_info->face_info); item->param.size = 0; } - } else if (item->id == MM_MESSAGE_CAMCORDER_VIDEO_CAPTURED || - item->id == MM_MESSAGE_CAMCORDER_AUDIO_CAPTURED) { + SAFE_G_FREE(cam_fd_info); + } 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) { - free(report->recording_filename); - report->recording_filename = NULL; - } - free(report); - report = NULL; - - item->param.data = NULL; - } + if (report) + SAFE_G_FREE(report->recording_filename); + + SAFE_G_FREE(report); } hcamcorder->msg_data = g_list_remove(hcamcorder->msg_data, item); - pthread_mutex_unlock(&(item->lock)); + g_mutex_unlock(&(item->lock)); if (ret == TRUE) { - pthread_mutex_destroy(&(item->lock)); + g_mutex_clear(&item->lock); - free(item); - item = NULL; + SAFE_G_FREE(item); - _mmcam_dbg_log("remove msg done"); + MMCAM_LOG_INFO("remove msg done"); } } else { - _mmcam_dbg_warn("item lock failed. it's being called..."); + MMCAM_LOG_WARNING("item lock failed. it's being called..."); - gettimeofday(&tv, NULL); - timeradd(&tv, &tv_to_add, &tv_result); - timeout.tv_sec = tv_result.tv_sec; - timeout.tv_nsec = tv_result.tv_usec * 1000; + end_time = g_get_monotonic_time() + (100 * G_TIME_SPAN_MILLISECOND); - if (_MMCAMCORDER_TIMED_WAIT(handle, timeout)) { - _mmcam_dbg_warn("signal received"); - } else { - _mmcam_dbg_warn("timeout"); - } + if (_MMCAMCORDER_WAIT_UNTIL(handle, end_time)) + MMCAM_LOG_WARNING("signal received"); + else + MMCAM_LOG_WARNING("timeout"); } } } @@ -1269,7 +1618,7 @@ void _mmcamcorder_remove_message_all(MMHandleType handle) /* remove idle function for playing capture sound */ do { ret = g_idle_remove_by_data(hcamcorder); - _mmcam_dbg_log("remove idle function for playing capture sound. ret[%d]", ret); + MMCAM_LOG_INFO("remove idle function for playing capture sound. ret[%d]", ret); } while (ret); _MMCAMCORDER_UNLOCK(handle); @@ -1278,133 +1627,203 @@ void _mmcamcorder_remove_message_all(MMHandleType handle) } -int _mmcamcorder_get_pixel_format(GstCaps *caps) +int _mmcamcorder_get_pixel_format(GstCaps *caps, gboolean is_preview) { - const GstStructure *structure; + gchar *caps_string = NULL; const char *media_type; - GstVideoInfo media_info; - MMPixelFormatType type = 0; - unsigned int fourcc = 0; + const char *format; + + mmf_return_val_if_fail(caps != NULL, MM_PIXEL_FORMAT_INVALID); - mmf_return_val_if_fail( caps != NULL, MM_PIXEL_FORMAT_INVALID ); + if (_mmcamcorder_get_log_level() >= MM_CAMCORDER_LOG_LEVEL_DEBUG) { + caps_string = gst_caps_to_string(caps); + MMCAM_LOG_DEBUG("caps[%s]", caps_string); + g_free(caps_string); + } - structure = gst_caps_get_structure (caps, 0); - media_type = gst_structure_get_name (structure); - if (media_type == NULL) { - _mmcam_dbg_err("failed to get media_type"); + media_type = gst_structure_get_name(gst_caps_get_structure(caps, 0)); + if (!media_type) { + MMCAM_LOG_ERROR("failed to get media_type"); return MM_PIXEL_FORMAT_INVALID; } - gst_video_info_init (&media_info); - - if (!strcmp (media_type, "image/jpeg") ) { - _mmcam_dbg_log("It is jpeg."); - type = MM_PIXEL_FORMAT_ENCODED; - } else if (!strcmp (media_type, "video/x-raw") && - gst_video_info_from_caps(&media_info, caps) && - GST_VIDEO_INFO_IS_YUV(&media_info)) { - _mmcam_dbg_log("It is yuv."); - fourcc = gst_video_format_to_fourcc(GST_VIDEO_INFO_FORMAT(&media_info)); - type = _mmcamcorder_get_pixtype(fourcc); - } else if (!strcmp (media_type, "video/x-raw") && - gst_video_info_from_caps(&media_info, caps) && - GST_VIDEO_INFO_IS_RGB(&media_info)) { - _mmcam_dbg_log("It is rgb."); - type = MM_PIXEL_FORMAT_RGB888; - } else if (!strcmp (media_type, "video/x-h264")) { - _mmcam_dbg_log("It is H264"); - type = MM_PIXEL_FORMAT_ENCODED_H264; - } else { - _mmcam_dbg_err("Not supported format [%s]",media_type); - type = MM_PIXEL_FORMAT_INVALID; + if (!strcmp(media_type, "image/jpeg")) + return (is_preview ? MM_PIXEL_FORMAT_ENCODED_MJPEG : MM_PIXEL_FORMAT_ENCODED); + else if (!strcmp(media_type, "video/x-h264")) + return MM_PIXEL_FORMAT_ENCODED_H264; + else if (!strcmp(media_type, "video/x-jpeg")) + return MM_PIXEL_FORMAT_ENCODED_MJPEG; + else if (!strcmp(media_type, "video/x-vp8")) + return MM_PIXEL_FORMAT_ENCODED_VP8; + else if (!strcmp(media_type, "video/x-vp9")) + return MM_PIXEL_FORMAT_ENCODED_VP9; + + format = gst_structure_get_string(gst_caps_get_structure(caps, 0), "format"); + if (!format) { + caps_string = gst_caps_to_string(caps); + MMCAM_LOG_ERROR("unsupported caps[%s]", caps_string); + g_free(caps_string); + + return MM_PIXEL_FORMAT_INVALID; } - /*_mmcam_dbg_log( "Type [%d]", type );*/ + return _mmcamcorder_get_pixtype(GST_STR_FOURCC(format)); +} + - return type; +MMPixelFormatType _mmcamcorder_get_pixel_format2(GstCameraControlImageFormat img_fmt) +{ + const MMPixelFormatType pixel_format_table[] = { + [GST_CAMERA_CONTROL_IMAGE_FORMAT_NV12] = MM_PIXEL_FORMAT_NV12, + [GST_CAMERA_CONTROL_IMAGE_FORMAT_NV21] = MM_PIXEL_FORMAT_NV21, + [GST_CAMERA_CONTROL_IMAGE_FORMAT_I420] = MM_PIXEL_FORMAT_I420, + [GST_CAMERA_CONTROL_IMAGE_FORMAT_YV12] = MM_PIXEL_FORMAT_YV12, + [GST_CAMERA_CONTROL_IMAGE_FORMAT_YUYV] = MM_PIXEL_FORMAT_YUYV, + [GST_CAMERA_CONTROL_IMAGE_FORMAT_UYVY] = MM_PIXEL_FORMAT_UYVY, + [GST_CAMERA_CONTROL_IMAGE_FORMAT_BGRA] = MM_PIXEL_FORMAT_RGBA, + [GST_CAMERA_CONTROL_IMAGE_FORMAT_ARGB] = MM_PIXEL_FORMAT_ARGB, + [GST_CAMERA_CONTROL_IMAGE_FORMAT_JPEG] = MM_PIXEL_FORMAT_ENCODED, + [GST_CAMERA_CONTROL_IMAGE_FORMAT_H264] = MM_PIXEL_FORMAT_ENCODED_H264, + [GST_CAMERA_CONTROL_IMAGE_FORMAT_MJPEG] = MM_PIXEL_FORMAT_ENCODED_MJPEG, + [GST_CAMERA_CONTROL_IMAGE_FORMAT_VP8] = MM_PIXEL_FORMAT_ENCODED_VP8, + [GST_CAMERA_CONTROL_IMAGE_FORMAT_VP9] = MM_PIXEL_FORMAT_ENCODED_VP9, + }; + + if (img_fmt < GST_CAMERA_CONTROL_IMAGE_FORMAT_NV12 || img_fmt > GST_CAMERA_CONTROL_IMAGE_FORMAT_VP9) { + MMCAM_LOG_ERROR("invalid format[%d], return default[NV12]", img_fmt); + return MM_PIXEL_FORMAT_NV12; + } + + return pixel_format_table[img_fmt]; } + +GstCameraControlImageFormat _mmcamcorder_get_camera_control_image_format(int pixel_format) +{ + const GstCameraControlImageFormat img_fmt_table[] = { + [MM_PIXEL_FORMAT_NV12] = GST_CAMERA_CONTROL_IMAGE_FORMAT_NV12, + [MM_PIXEL_FORMAT_NV21] = GST_CAMERA_CONTROL_IMAGE_FORMAT_NV21, + [MM_PIXEL_FORMAT_I420] = GST_CAMERA_CONTROL_IMAGE_FORMAT_I420, + [MM_PIXEL_FORMAT_YV12] = GST_CAMERA_CONTROL_IMAGE_FORMAT_YV12, + [MM_PIXEL_FORMAT_YUYV] = GST_CAMERA_CONTROL_IMAGE_FORMAT_YUYV, + [MM_PIXEL_FORMAT_UYVY] = GST_CAMERA_CONTROL_IMAGE_FORMAT_UYVY, + [MM_PIXEL_FORMAT_RGBA] = GST_CAMERA_CONTROL_IMAGE_FORMAT_BGRA, + [MM_PIXEL_FORMAT_ARGB] = GST_CAMERA_CONTROL_IMAGE_FORMAT_ARGB, + [MM_PIXEL_FORMAT_ENCODED] = GST_CAMERA_CONTROL_IMAGE_FORMAT_JPEG, + [MM_PIXEL_FORMAT_ENCODED_H264] = GST_CAMERA_CONTROL_IMAGE_FORMAT_H264, + [MM_PIXEL_FORMAT_ENCODED_MJPEG] = GST_CAMERA_CONTROL_IMAGE_FORMAT_MJPEG, + [MM_PIXEL_FORMAT_ENCODED_VP8] = GST_CAMERA_CONTROL_IMAGE_FORMAT_VP8, + [MM_PIXEL_FORMAT_ENCODED_VP9] = GST_CAMERA_CONTROL_IMAGE_FORMAT_VP9 + }; + + if (pixel_format < MM_PIXEL_FORMAT_NV12 || pixel_format > MM_PIXEL_FORMAT_ENCODED_VP9) { + MMCAM_LOG_ERROR("invalid format[%d], return default[NV12]", pixel_format); + return GST_CAMERA_CONTROL_IMAGE_FORMAT_NV12; + } + + return img_fmt_table[pixel_format]; +} + + unsigned int _mmcamcorder_get_fourcc(int pixtype, int codectype, int use_zero_copy_format) { unsigned int fourcc = 0; - /*_mmcam_dbg_log("pixtype(%d)", pixtype);*/ + /*MMCAM_LOG_INFO("pixtype(%d)", pixtype);*/ switch (pixtype) { case MM_PIXEL_FORMAT_NV12: - if (use_zero_copy_format) { - fourcc = GST_MAKE_FOURCC ('S', 'N', '1', '2'); - } else { - fourcc = GST_MAKE_FOURCC ('N', 'V', '1', '2'); - } + if (use_zero_copy_format) + fourcc = GST_MAKE_FOURCC('S', 'N', '1', '2'); + else + fourcc = GST_MAKE_FOURCC('N', 'V', '1', '2'); + break; case MM_PIXEL_FORMAT_NV21: - if (use_zero_copy_format) { - fourcc = GST_MAKE_FOURCC ('S', 'N', '2', '1'); - } else { - fourcc = GST_MAKE_FOURCC ('N', 'V', '2', '1'); - } + if (use_zero_copy_format) + fourcc = GST_MAKE_FOURCC('S', 'N', '2', '1'); + else + fourcc = GST_MAKE_FOURCC('N', 'V', '2', '1'); + break; case MM_PIXEL_FORMAT_YUYV: - if (use_zero_copy_format) { - fourcc = GST_MAKE_FOURCC ('S', 'U', 'Y', 'V'); - } else { - fourcc = GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'); - } + if (use_zero_copy_format) + fourcc = GST_MAKE_FOURCC('S', 'U', 'Y', 'V'); + else + fourcc = GST_MAKE_FOURCC('Y', 'U', 'Y', '2'); + break; case MM_PIXEL_FORMAT_UYVY: - if (use_zero_copy_format) { - fourcc = GST_MAKE_FOURCC ('S', 'Y', 'V', 'Y'); - } else { - fourcc = GST_MAKE_FOURCC ('U', 'Y', 'V', 'Y'); - } + if (use_zero_copy_format) + fourcc = GST_MAKE_FOURCC('S', 'Y', 'V', 'Y'); + else + fourcc = GST_MAKE_FOURCC('U', 'Y', 'V', 'Y'); + break; case MM_PIXEL_FORMAT_I420: - if (use_zero_copy_format) { - fourcc = GST_MAKE_FOURCC ('S', '4', '2', '0'); - } else { - fourcc = GST_MAKE_FOURCC ('I', '4', '2', '0'); - } + if (use_zero_copy_format) + fourcc = GST_MAKE_FOURCC('S', '4', '2', '0'); + else + fourcc = GST_MAKE_FOURCC('I', '4', '2', '0'); + break; case MM_PIXEL_FORMAT_YV12: - fourcc = GST_MAKE_FOURCC ('Y', 'V', '1', '2'); + fourcc = GST_MAKE_FOURCC('Y', 'V', '1', '2'); break; case MM_PIXEL_FORMAT_422P: - fourcc = GST_MAKE_FOURCC ('4', '2', '2', 'P'); + fourcc = GST_MAKE_FOURCC('4', '2', '2', 'P'); break; case MM_PIXEL_FORMAT_RGB565: - fourcc = GST_MAKE_FOURCC ('R', 'G', 'B', 'P'); + fourcc = GST_MAKE_FOURCC('R', 'G', 'B', 'P'); break; case MM_PIXEL_FORMAT_RGB888: - fourcc = GST_MAKE_FOURCC ('R', 'G', 'B', ' '); + 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'); + fourcc = GST_MAKE_FOURCC('J', 'P', 'E', 'G'); } else if (codectype == MM_IMAGE_CODEC_JPEG_SRW) { - fourcc = GST_MAKE_FOURCC ('J', 'P', 'E', 'G'); /*TODO: JPEG+SamsungRAW format */ + fourcc = GST_MAKE_FOURCC('J', 'P', 'E', 'G'); /*TODO: JPEG+SamsungRAW format */ } else if (codectype == MM_IMAGE_CODEC_SRW) { - fourcc = GST_MAKE_FOURCC ('J', 'P', 'E', 'G'); /*TODO: SamsungRAW format */ + fourcc = GST_MAKE_FOURCC('J', 'P', 'E', 'G'); /*TODO: SamsungRAW format */ } else if (codectype == MM_IMAGE_CODEC_PNG) { - fourcc = GST_MAKE_FOURCC ('P', 'N', 'G', ' '); + fourcc = GST_MAKE_FOURCC('P', 'N', 'G', ' '); } else { /* Please let us know what other fourcces are. ex) BMP, GIF?*/ - fourcc = GST_MAKE_FOURCC ('J', 'P', 'E', 'G'); + fourcc = GST_MAKE_FOURCC('J', 'P', 'E', 'G'); } break; case MM_PIXEL_FORMAT_ITLV_JPEG_UYVY: - fourcc = GST_MAKE_FOURCC('I','T','L','V'); + fourcc = GST_MAKE_FOURCC('I', 'T', 'L', 'V'); break; case MM_PIXEL_FORMAT_ENCODED_H264: - fourcc = GST_MAKE_FOURCC('H','2','6','4'); + fourcc = GST_MAKE_FOURCC('H', '2', '6', '4'); + break; + case MM_PIXEL_FORMAT_INVZ: + fourcc = GST_MAKE_FOURCC('I', 'N', 'V', 'Z'); + break; + case MM_PIXEL_FORMAT_ENCODED_MJPEG: + fourcc = GST_MAKE_FOURCC ('M', 'J', 'P', 'G'); + break; + case MM_PIXEL_FORMAT_ENCODED_VP8: + fourcc = GST_MAKE_FOURCC ('V', 'P', '8', '0'); + break; + case MM_PIXEL_FORMAT_ENCODED_VP9: + fourcc = GST_MAKE_FOURCC ('V', 'P', '9', '0'); break; default: - _mmcam_dbg_log("Not proper pixel type[%d]. Set default - I420", pixtype); - if (use_zero_copy_format) { - fourcc = GST_MAKE_FOURCC ('S', '4', '2', '0'); - } else { - fourcc = GST_MAKE_FOURCC ('I', '4', '2', '0'); - } + MMCAM_LOG_INFO("Not proper pixel type[%d]. Set default - I420", pixtype); + if (use_zero_copy_format) + fourcc = GST_MAKE_FOURCC('S', '4', '2', '0'); + else + fourcc = GST_MAKE_FOURCC('I', '4', '2', '0'); + break; } @@ -1418,67 +1837,90 @@ int _mmcamcorder_get_pixtype(unsigned int fourcc) /* char *pfourcc = (char*)&fourcc; - _mmcam_dbg_log("fourcc(%c%c%c%c)", - pfourcc[0], pfourcc[1], pfourcc[2], pfourcc[3]); + MMCAM_LOG_INFO("fourcc(%c%c%c%c)", + pfourcc[0], pfourcc[1], pfourcc[2], pfourcc[3]); */ switch (fourcc) { - case GST_MAKE_FOURCC ('S', 'N', '1', '2'): - case GST_MAKE_FOURCC ('N', 'V', '1', '2'): + case GST_MAKE_FOURCC('S', 'N', '1', '2'): + /* fall through */ + case GST_MAKE_FOURCC('N', 'V', '1', '2'): pixtype = MM_PIXEL_FORMAT_NV12; break; - case GST_MAKE_FOURCC ('S', 'N', '2', '1'): - case GST_MAKE_FOURCC ('N', 'V', '2', '1'): + case GST_MAKE_FOURCC('S', 'N', '2', '1'): + /* fall through */ + case GST_MAKE_FOURCC('N', 'V', '2', '1'): pixtype = MM_PIXEL_FORMAT_NV21; break; - case GST_MAKE_FOURCC ('S', 'U', 'Y', 'V'): - case GST_MAKE_FOURCC ('Y', 'U', 'Y', 'V'): - case GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'): + case GST_MAKE_FOURCC('S', 'U', 'Y', 'V'): + /* fall through */ + case GST_MAKE_FOURCC('Y', 'U', 'Y', 'V'): + /* fall through */ + case GST_MAKE_FOURCC('Y', 'U', 'Y', '2'): pixtype = MM_PIXEL_FORMAT_YUYV; break; - case GST_MAKE_FOURCC ('S', 'Y', 'V', 'Y'): - case GST_MAKE_FOURCC ('U', 'Y', 'V', 'Y'): + case GST_MAKE_FOURCC('S', 'Y', 'V', 'Y'): + /* fall through */ + case GST_MAKE_FOURCC('U', 'Y', 'V', 'Y'): pixtype = MM_PIXEL_FORMAT_UYVY; break; - case GST_MAKE_FOURCC ('S', '4', '2', '0'): - case GST_MAKE_FOURCC ('I', '4', '2', '0'): + case GST_MAKE_FOURCC('S', '4', '2', '0'): + /* fall through */ + case GST_MAKE_FOURCC('I', '4', '2', '0'): pixtype = MM_PIXEL_FORMAT_I420; break; - case GST_MAKE_FOURCC ('Y', 'V', '1', '2'): + case GST_MAKE_FOURCC('Y', 'V', '1', '2'): pixtype = MM_PIXEL_FORMAT_YV12; break; - case GST_MAKE_FOURCC ('4', '2', '2', 'P'): + case GST_MAKE_FOURCC('4', '2', '2', 'P'): pixtype = MM_PIXEL_FORMAT_422P; break; - case GST_MAKE_FOURCC ('R', 'G', 'B', 'P'): + case GST_MAKE_FOURCC('R', 'G', 'B', 'P'): pixtype = MM_PIXEL_FORMAT_RGB565; break; - case GST_MAKE_FOURCC ('R', 'G', 'B', '3'): + case GST_MAKE_FOURCC('R', 'G', 'B', '3'): pixtype = MM_PIXEL_FORMAT_RGB888; break; - case GST_MAKE_FOURCC ('A', 'R', 'G', 'B'): - case GST_MAKE_FOURCC ('x', 'R', 'G', 'B'): + case GST_MAKE_FOURCC('A', 'R', 'G', 'B'): + /* fall through */ + case GST_MAKE_FOURCC('x', 'R', 'G', 'B'): pixtype = MM_PIXEL_FORMAT_ARGB; break; - case GST_MAKE_FOURCC ('B', 'G', 'R', 'A'): - case GST_MAKE_FOURCC ('B', 'G', 'R', 'x'): - case GST_MAKE_FOURCC ('S', 'R', '3', '2'): + case GST_MAKE_FOURCC('B', 'G', 'R', 'A'): + /* fall through */ + case GST_MAKE_FOURCC('B', 'G', 'R', 'x'): + /* fall through */ + case GST_MAKE_FOURCC('S', 'R', '3', '2'): pixtype = MM_PIXEL_FORMAT_RGBA; break; - case GST_MAKE_FOURCC ('J', 'P', 'E', 'G'): - case GST_MAKE_FOURCC ('P', 'N', 'G', ' '): + case GST_MAKE_FOURCC('J', 'P', 'E', 'G'): pixtype = MM_PIXEL_FORMAT_ENCODED; break; /*FIXME*/ - case GST_MAKE_FOURCC ('I', 'T', 'L', 'V'): + case GST_MAKE_FOURCC('I', 'T', 'L', 'V'): pixtype = MM_PIXEL_FORMAT_ITLV_JPEG_UYVY; break; - case GST_MAKE_FOURCC ('H', '2', '6', '4'): + case GST_MAKE_FOURCC('H', '2', '6', '4'): pixtype = MM_PIXEL_FORMAT_ENCODED_H264; break; + case GST_MAKE_FOURCC ('M', 'J', 'P', 'G'): + pixtype = MM_PIXEL_FORMAT_ENCODED_MJPEG; + break; + case GST_MAKE_FOURCC ('V', 'P', '8', '0'): + /* fall through */ + case GST_MAKE_FOURCC ('v', 'p', '0', '8'): + pixtype = MM_PIXEL_FORMAT_ENCODED_VP8; + break; + case GST_MAKE_FOURCC ('V', 'P', '9', '0'): + /* fall through */ + case GST_MAKE_FOURCC ('v', 'p', '0', '9'): + pixtype = MM_PIXEL_FORMAT_ENCODED_VP9; + 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); + MMCAM_LOG_INFO("Not supported fourcc type(%c%c%c%c)", fourcc, fourcc>>8, fourcc>>16, fourcc>>24); pixtype = MM_PIXEL_FORMAT_INVALID; break; } @@ -1498,14 +1940,14 @@ gboolean _mmcamcorder_add_elements_to_bin(GstBin *bin, GList *element_list) element = (_MMCamcorderGstElement*)local_list->data; if (element && element->gst) { if (!gst_bin_add(bin, GST_ELEMENT(element->gst))) { - _mmcam_dbg_err( "Add element [%s] to bin [%s] FAILED", - GST_ELEMENT_NAME(GST_ELEMENT(element->gst)), - GST_ELEMENT_NAME(GST_ELEMENT(bin)) ); + MMCAM_LOG_ERROR("Add element [%s] to bin [%s] FAILED", + GST_ELEMENT_NAME(GST_ELEMENT(element->gst)), + GST_ELEMENT_NAME(GST_ELEMENT(bin))); return FALSE; } else { - _mmcam_dbg_log("Add element [%s] to bin [%s] OK", - GST_ELEMENT_NAME(GST_ELEMENT(element->gst)), - GST_ELEMENT_NAME(GST_ELEMENT(bin))); + MMCAM_LOG_INFO("Add element [%s] to bin [%s] OK", + GST_ELEMENT_NAME(GST_ELEMENT(element->gst)), + GST_ELEMENT_NAME(GST_ELEMENT(bin))); } } local_list = local_list->next; @@ -1527,15 +1969,15 @@ gboolean _mmcamcorder_link_elements(GList *element_list) while (local_list) { element = (_MMCamcorderGstElement*)local_list->data; - if (element && element->gst) { + if (pre_element && pre_element->gst && element && element->gst) { if (_MM_GST_ELEMENT_LINK(GST_ELEMENT(pre_element->gst), GST_ELEMENT(element->gst))) { - _mmcam_dbg_log("Link [%s] to [%s] OK", - GST_ELEMENT_NAME(GST_ELEMENT(pre_element->gst)), - GST_ELEMENT_NAME(GST_ELEMENT(element->gst))); + MMCAM_LOG_INFO("Link [%s] to [%s] OK", + GST_ELEMENT_NAME(GST_ELEMENT(pre_element->gst)), + GST_ELEMENT_NAME(GST_ELEMENT(element->gst))); } else { - _mmcam_dbg_err("Link [%s] to [%s] FAILED", - GST_ELEMENT_NAME(GST_ELEMENT(pre_element->gst)), - GST_ELEMENT_NAME(GST_ELEMENT(element->gst))); + MMCAM_LOG_ERROR("Link [%s] to [%s] FAILED", + GST_ELEMENT_NAME(GST_ELEMENT(pre_element->gst)), + GST_ELEMENT_NAME(GST_ELEMENT(element->gst))); return FALSE; } } @@ -1547,166 +1989,219 @@ gboolean _mmcamcorder_link_elements(GList *element_list) return TRUE; } -gboolean _mmcamcorder_filtered_link_elements(GList *element_list, GstCaps *caps) +GstCaps *_mmcamcorder_get_video_caps(MMHandleType handle, MMPixelFormatType format, int width, int height, int fps, int rotate) { - GList *local_list = element_list; - _MMCamcorderGstElement *element = NULL; - _MMCamcorderGstElement *pre_element = NULL; - - mmf_return_val_if_fail(local_list, FALSE); + int codec_type = MM_IMAGE_CODEC_JPEG; + guint32 fourcc = 0; + char fourcc_string[sizeof(guint32) + 1]; +#ifdef _MMCAMCORDER_PRODUCT_TV + int maxwidth = 0; + int maxheight = 0; + int display_surface_type = MM_DISPLAY_SURFACE_NULL; +#endif /* _MMCAMCORDER_PRODUCT_TV */ + gchar *caps_string = NULL; + GstCaps *caps = NULL;; + mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle); + + switch (format) { + case MM_PIXEL_FORMAT_ENCODED_H264: +#ifdef _MMCAMCORDER_PRODUCT_TV + mm_camcorder_get_attributes(handle, NULL, + MMCAM_DISPLAY_SURFACE, &display_surface_type, + NULL); + if (display_surface_type != MM_DISPLAY_SURFACE_NULL && + __mmcamcorder_find_max_resolution(handle, &maxwidth, &maxheight) == false) { + MMCAM_LOG_ERROR("can not find max resolution limitation"); + return false; + } else if (display_surface_type == MM_DISPLAY_SURFACE_NULL) { + maxwidth = width; + maxheight = height; + } +#endif /* _MMCAMCORDER_PRODUCT_TV */ + caps = gst_caps_new_simple("video/x-h264", + "stream-format", G_TYPE_STRING, "byte-stream", +#ifdef _MMCAMCORDER_PRODUCT_TV + "maxwidth", G_TYPE_INT, maxwidth, + "maxheight", G_TYPE_INT, maxheight, + "alignment", G_TYPE_STRING, "au", +#endif /* _MMCAMCORDER_PRODUCT_TV */ + NULL); + break; + case MM_PIXEL_FORMAT_ENCODED_MJPEG: +#ifdef _MMCAMCORDER_PRODUCT_TV + caps = gst_caps_new_empty_simple("video/x-jpeg"); +#else + caps = gst_caps_new_empty_simple("image/jpeg"); +#endif + break; + case MM_PIXEL_FORMAT_ENCODED_VP8: + caps = gst_caps_new_empty_simple("video/x-vp8"); + break; + case MM_PIXEL_FORMAT_ENCODED_VP9: + caps = gst_caps_new_empty_simple("video/x-vp9"); + break; + default: + mm_camcorder_get_attributes(handle, NULL, + MMCAM_IMAGE_ENCODER, &codec_type, + NULL); + + fourcc = (guint32)_mmcamcorder_get_fourcc(format, codec_type, hcamcorder->use_zero_copy_format); + snprintf(fourcc_string, sizeof(fourcc_string), "%"GST_FOURCC_FORMAT, GST_FOURCC_ARGS(fourcc)); + caps = gst_caps_new_simple("video/x-raw", + "format", G_TYPE_STRING, fourcc_string, + NULL); + break; + } - pre_element = (_MMCamcorderGstElement*)local_list->data; - local_list = local_list->next; + gst_caps_set_simple(caps, + "width", G_TYPE_INT, width, + "height", G_TYPE_INT, height, + NULL); - while (local_list) { - element = (_MMCamcorderGstElement*)local_list->data; - if (element && element->gst) { - if (_MM_GST_ELEMENT_LINK_FILTERED(GST_ELEMENT(pre_element->gst), GST_ELEMENT(element->gst), caps)) { - _mmcam_dbg_log("Link [%s] to [%s] OK", - GST_ELEMENT_NAME(GST_ELEMENT(pre_element->gst)), - GST_ELEMENT_NAME(GST_ELEMENT(element->gst))); - } else { - _mmcam_dbg_err("Link [%s] to [%s] FAILED", - GST_ELEMENT_NAME(GST_ELEMENT(pre_element->gst)), - GST_ELEMENT_NAME(GST_ELEMENT(element->gst))); - return FALSE; - } - } + if (fps > 0) { + gst_caps_set_simple(caps, + "framerate", GST_TYPE_FRACTION, fps, 1, + NULL); + } - pre_element = element; - local_list = local_list->next; + if (rotate >= 0) { + gst_caps_set_simple(caps, + "rotate", G_TYPE_INT, rotate, + NULL); } - return TRUE; + caps_string = gst_caps_to_string(caps); + MMCAM_LOG_INFO("caps[%s]", caps_string); + g_free(caps_string); + + return caps; } 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_LOG_ERROR("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_LOG_ERROR("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); + MMCAM_LOG_INFO("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_LOG_ERROR("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_LOG_ERROR("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_LOG_ERROR("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_LOG_INFO("resize done %dx%d -> %dx%d, %p, length %zu", + src_width, src_height, *dst_width, *dst_height, *dst_data, *dst_length); return TRUE; } gboolean _mmcamcorder_encode_jpeg(void *src_data, unsigned int src_width, unsigned int src_height, - int src_format, unsigned int src_length, unsigned int jpeg_quality, - void **result_data, unsigned int *result_length) + int src_format, unsigned int src_length, unsigned int jpeg_quality, + void **result_data, unsigned int *result_length) { - int ret = 0; + int ret = MM_UTIL_ERROR_NONE; gboolean ret_conv = TRUE; - int jpeg_format = 0; + mm_util_color_format_e jpeg_format = MM_UTIL_COLOR_NUM; unsigned char *converted_src = NULL; unsigned int converted_src_size = 0; + mm_util_image_h decoded = NULL; + void *encoded_data = NULL; + size_t encoded_data_size = 0; mmf_return_val_if_fail(src_data && result_data && result_length, FALSE); switch (src_format) { case MM_PIXEL_FORMAT_NV12: - //jpeg_format = MM_UTIL_JPEG_FMT_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_NV12; + ret_conv = _mmcamcorder_convert_NV12_to_I420(src_data, src_width, src_height, &converted_src, &converted_src_size); + 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; - 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_YUYV; + ret_conv = _mmcamcorder_convert_YUYV_to_I420(src_data, src_width, src_height, &converted_src, &converted_src_size); + jpeg_format = MM_UTIL_COLOR_YUV420; break; case MM_PIXEL_FORMAT_UYVY: - //jpeg_format = MM_UTIL_JPEG_FMT_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_UYVY; + ret_conv = _mmcamcorder_convert_UYVY_to_I420(src_data, src_width, src_height, &converted_src, &converted_src_size); + 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: @@ -1723,31 +2218,44 @@ gboolean _mmcamcorder_encode_jpeg(void *src_data, unsigned int src_width, unsign free(converted_src); converted_src = NULL; } - _mmcam_dbg_err("color convert error source format[%d], jpeg format[%d]", src_format, jpeg_format); + MMCAM_LOG_ERROR("color convert error source format[%d], jpeg format[%d]", src_format, jpeg_format); + return FALSE; + } + + converted_src_size = (converted_src && (converted_src != src_data)) ? converted_src_size : src_length; + ret = mm_image_create_image(src_width, src_height, jpeg_format, converted_src, (size_t)converted_src_size, &decoded); + if (ret != MM_UTIL_ERROR_NONE) { + MMCAM_LOG_ERROR("mm_image_create_image error [%d]", ret); + if (converted_src && (converted_src != src_data)) + free(converted_src); return FALSE; } - ret = mm_util_jpeg_encode_to_memory(result_data, (int *)result_length, - converted_src, src_width, src_height, - jpeg_format, jpeg_quality); + ret = mm_util_encode_to_jpeg_memory(decoded, jpeg_quality, &encoded_data, &encoded_data_size); + mm_image_destroy_image(decoded); if (converted_src && (converted_src != src_data)) { free(converted_src); converted_src = NULL; } - if (ret != MM_ERROR_NONE) { - _mmcam_dbg_err("No encoder supports %d format, error code %x", src_format, ret); + if (ret != MM_UTIL_ERROR_NONE) { + MMCAM_LOG_ERROR("No encoder supports %d format, error code %x", src_format, ret); + if (encoded_data) + free(encoded_data); return FALSE; } + *result_data = encoded_data; + *result_length = (unsigned int)encoded_data_size; + return TRUE; } /* make UYVY smaller as multiple size. ex: 640x480 -> 320x240 or 160x120 ... */ gboolean _mmcamcorder_downscale_UYVYorYUYV(unsigned char *src, unsigned int src_width, unsigned int src_height, - unsigned char **dst, unsigned int dst_width, unsigned int dst_height) + unsigned char **dst, unsigned int dst_width, unsigned int dst_height) { unsigned int i = 0; int j = 0; @@ -1761,13 +2269,13 @@ gboolean _mmcamcorder_downscale_UYVYorYUYV(unsigned char *src, unsigned int src_ unsigned char *result = NULL; if (src == NULL || dst == NULL) { - _mmcam_dbg_err("src[%p] or dst[%p] is NULL", src, dst); + MMCAM_LOG_ERROR("src[%p] or dst[%p] is NULL", src, dst); return FALSE; } result = (unsigned char *)malloc((dst_width * dst_height)<<1); if (!result) { - _mmcam_dbg_err("failed to alloc dst data"); + MMCAM_LOG_ERROR("failed to alloc dst data"); return FALSE; } @@ -1776,9 +2284,8 @@ gboolean _mmcamcorder_downscale_UYVYorYUYV(unsigned char *src, unsigned int src_ line_width = src_width << 1; jump_width = ratio_width << 1; - _mmcam_dbg_warn("[src %dx%d] [dst %dx%d] [line width %d] [ratio width %d, height %d]", - src_width, src_height, dst_width, dst_height, - line_width, ratio_width, ratio_height); + MMCAM_LOG_WARNING("[src %dx%d] [dst %dx%d] [line width %d] [ratio width %d, height %d]", + src_width, src_height, dst_width, dst_height, line_width, ratio_width, ratio_height); for (i = 0 ; i < src_height ; i += ratio_height) { line_base = i * line_width; @@ -1789,18 +2296,18 @@ gboolean _mmcamcorder_downscale_UYVYorYUYV(unsigned char *src, unsigned int src_ j += jump_width; src_index = line_base + j; - if (src_index % 4 == 0) { + if (src_index % 4 == 0) result[k++] = src[src_index+2]; - } else { + else result[k++] = src[src_index]; - } + result[k++] = src[src_index+1]; } } *dst = result; - _mmcam_dbg_warn("converting done - result %p", result); + MMCAM_LOG_WARNING("converting done - result %p", result); return TRUE; } @@ -1808,17 +2315,17 @@ gboolean _mmcamcorder_downscale_UYVYorYUYV(unsigned char *src, unsigned int src_ static guint16 get_language_code(const char *str) { - return (guint16) (((str[0]-0x60) & 0x1F) << 10) + (((str[1]-0x60) & 0x1F) << 5) + ((str[2]-0x60) & 0x1F); + return (guint16)(((str[0]-0x60) & 0x1F) << 10) + (((str[1]-0x60) & 0x1F) << 5) + ((str[2]-0x60) & 0x1F); } static gchar * str_to_utf8(const gchar *str) { - return g_convert (str, -1, "UTF-8", "ASCII", NULL, NULL, NULL); + return g_convert(str, -1, "UTF-8", "ASCII", NULL, NULL, NULL); } static inline gboolean write_tag(FILE *f, const gchar *tag) { - while(*tag) + while (*tag) FPUTC_CHECK(*tag++, f); return TRUE; @@ -1853,57 +2360,54 @@ void *_mmcamcorder_util_task_thread_func(void *data) mmf_camcorder_t *hcamcorder = (mmf_camcorder_t *)data; if (!hcamcorder) { - _mmcam_dbg_err("handle is NULL"); + MMCAM_LOG_ERROR("handle is NULL"); return NULL; } - _mmcam_dbg_warn("start thread"); + MMCAM_LOG_WARNING("start thread"); - pthread_mutex_lock(&(hcamcorder->task_thread_lock)); + g_mutex_lock(&hcamcorder->task_thread_lock); while (hcamcorder->task_thread_state != _MMCAMCORDER_TASK_THREAD_STATE_EXIT) { switch (hcamcorder->task_thread_state) { case _MMCAMCORDER_TASK_THREAD_STATE_NONE: - _mmcam_dbg_warn("wait for task signal"); - pthread_cond_wait(&(hcamcorder->task_thread_cond), &(hcamcorder->task_thread_lock)); - _mmcam_dbg_warn("task signal received : state %d", hcamcorder->task_thread_state); + MMCAM_LOG_WARNING("wait for task signal"); + g_cond_wait(&hcamcorder->task_thread_cond, &hcamcorder->task_thread_lock); + MMCAM_LOG_WARNING("task signal received : state %d", hcamcorder->task_thread_state); break; case _MMCAMCORDER_TASK_THREAD_STATE_SOUND_PLAY_START: - _mmcamcorder_sound_play((MMHandleType)hcamcorder, _MMCAMCORDER_SAMPLE_SOUND_NAME_CAPTURE, FALSE); + _mmcamcorder_sound_play((MMHandleType)hcamcorder, _MMCAMCORDER_SAMPLE_SOUND_NAME_CAPTURE02, FALSE); hcamcorder->task_thread_state = _MMCAMCORDER_TASK_THREAD_STATE_NONE; break; case _MMCAMCORDER_TASK_THREAD_STATE_SOUND_SOLO_PLAY_START: - _mmcamcorder_sound_solo_play((MMHandleType)hcamcorder, _MMCAMCORDER_FILEPATH_CAPTURE_SND, FALSE); + _mmcamcorder_sound_solo_play((MMHandleType)hcamcorder, _MMCAMCORDER_SAMPLE_SOUND_NAME_CAPTURE01, FALSE); hcamcorder->task_thread_state = _MMCAMCORDER_TASK_THREAD_STATE_NONE; break; case _MMCAMCORDER_TASK_THREAD_STATE_ENCODE_PIPE_CREATE: ret = _mmcamcorder_video_prepare_record((MMHandleType)hcamcorder); /* Play record start sound */ - _mmcamcorder_sound_solo_play((MMHandleType)hcamcorder, _MMCAMCORDER_FILEPATH_REC_START_SND, FALSE); + _mmcamcorder_sound_solo_play((MMHandleType)hcamcorder, _MMCAMCORDER_SAMPLE_SOUND_NAME_REC_START, FALSE); - _mmcam_dbg_log("_mmcamcorder_video_prepare_record return 0x%x", ret); + MMCAM_LOG_INFO("_mmcamcorder_video_prepare_record return 0x%x", ret); hcamcorder->task_thread_state = _MMCAMCORDER_TASK_THREAD_STATE_NONE; break; case _MMCAMCORDER_TASK_THREAD_STATE_CHECK_CAPTURE_IN_RECORDING: { - struct timespec timeout; - struct timeval tv; + gint64 end_time = 0; - gettimeofday(&tv, NULL); - timeout.tv_sec = tv.tv_sec + __MMCAMCORDER_CAPTURE_WAIT_TIMEOUT; - timeout.tv_nsec = tv.tv_usec * 1000; + MMCAM_LOG_WARNING("wait for capture data in recording. wait signal..."); - _mmcam_dbg_warn("wait for capture data in recording. wait signal..."); + end_time = g_get_monotonic_time() + (5 * G_TIME_SPAN_SECOND); - if (!pthread_cond_timedwait(&(hcamcorder->task_thread_cond), &(hcamcorder->task_thread_lock), &timeout)) { - _mmcam_dbg_warn("signal received"); + if (g_cond_wait_until(&hcamcorder->task_thread_cond, &hcamcorder->task_thread_lock, end_time)) { + MMCAM_LOG_WARNING("signal received"); } else { _MMCamcorderMsgItem message; memset(&message, 0x0, sizeof(_MMCamcorderMsgItem)); - _mmcam_dbg_err("capture data wait time out, send error message"); + MMCAM_LOG_ERROR("capture data wait time out, send error message"); message.id = MM_MESSAGE_CAMCORDER_ERROR; message.param.code = MM_ERROR_CAMCORDER_RESPONSE_TIMEOUT; @@ -1917,80 +2421,19 @@ void *_mmcamcorder_util_task_thread_func(void *data) } break; default: - _mmcam_dbg_warn("invalid task thread state %d", hcamcorder->task_thread_state); + MMCAM_LOG_WARNING("invalid task thread state %d", hcamcorder->task_thread_state); hcamcorder->task_thread_state = _MMCAMCORDER_TASK_THREAD_STATE_EXIT; break; } } - pthread_mutex_unlock(&(hcamcorder->task_thread_lock)); + g_mutex_unlock(&hcamcorder->task_thread_lock); - _mmcam_dbg_warn("exit thread"); + MMCAM_LOG_WARNING("exit thread"); 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) { @@ -2005,17 +2448,17 @@ static gboolean _mmcamcorder_convert_YUYV_to_I420(unsigned char *src, guint widt unsigned char *dst_data = NULL; if (!src || !dst || !dst_len) { - _mmcam_dbg_err("NULL pointer %p, %p, %p", src, dst, dst_len); + MMCAM_LOG_ERROR("NULL pointer %p, %p, %p", src, dst, dst_len); return FALSE; } dst_size = (width * height * 3) >> 1; - _mmcam_dbg_log("YUVY -> I420 : %dx%d, dst size %d", width, height, dst_size); + MMCAM_LOG_INFO("YUVY -> I420 : %dx%d, dst size %d", width, height, dst_size); dst_data = (unsigned char *)malloc(dst_size); if (!dst_data) { - _mmcam_dbg_err("failed to alloc dst_data. size %d", dst_size); + MMCAM_LOG_ERROR("failed to alloc dst_data. size %d", dst_size); return FALSE; } @@ -2023,18 +2466,17 @@ static gboolean _mmcamcorder_convert_YUYV_to_I420(unsigned char *src, guint widt dst_u_offset = width * height; dst_v_offset = dst_u_offset + (dst_u_offset >> 2); - _mmcam_dbg_log("offset y %d, u %d, v %d", dst_y_offset, dst_u_offset, dst_v_offset); + MMCAM_LOG_INFO("offset y %d, u %d, v %d", dst_y_offset, dst_u_offset, dst_v_offset); for (i = 0 ; i < height ; i++) { for (j = 0 ; j < loop_length ; j += 2) { dst_data[dst_y_offset++] = src[src_offset++]; /*Y*/ if (i % 2 == 0) { - if (j % 4 == 0) { + if (j % 4 == 0) dst_data[dst_u_offset++] = src[src_offset++]; /*U*/ - } else { + else dst_data[dst_v_offset++] = src[src_offset++]; /*V*/ - } } else { src_offset++; } @@ -2044,8 +2486,7 @@ static gboolean _mmcamcorder_convert_YUYV_to_I420(unsigned char *src, guint widt *dst = dst_data; *dst_len = dst_size; - _mmcam_dbg_log("DONE: YUVY -> I420 : %dx%d, dst data %p, size %d", - width, height, *dst, dst_size); + MMCAM_LOG_INFO("DONE: YUVY -> I420 : %dx%d, dst data %p, size %d", width, height, *dst, dst_size); return TRUE; } @@ -2064,17 +2505,17 @@ static gboolean _mmcamcorder_convert_UYVY_to_I420(unsigned char *src, guint widt unsigned char *dst_data = NULL; if (!src || !dst || !dst_len) { - _mmcam_dbg_err("NULL pointer %p, %p, %p", src, dst, dst_len); + MMCAM_LOG_ERROR("NULL pointer %p, %p, %p", src, dst, dst_len); return FALSE; } dst_size = (width * height * 3) >> 1; - _mmcam_dbg_log("UYVY -> I420 : %dx%d, dst size %d", width, height, dst_size); + MMCAM_LOG_INFO("UYVY -> I420 : %dx%d, dst size %d", width, height, dst_size); dst_data = (unsigned char *)malloc(dst_size); if (!dst_data) { - _mmcam_dbg_err("failed to alloc dst_data. size %d", dst_size); + MMCAM_LOG_ERROR("failed to alloc dst_data. size %d", dst_size); return FALSE; } @@ -2082,16 +2523,15 @@ static gboolean _mmcamcorder_convert_UYVY_to_I420(unsigned char *src, guint widt dst_u_offset = width * height; dst_v_offset = dst_u_offset + (dst_u_offset >> 2); - _mmcam_dbg_log("offset y %d, u %d, v %d", dst_y_offset, dst_u_offset, dst_v_offset); + MMCAM_LOG_INFO("offset y %d, u %d, v %d", dst_y_offset, dst_u_offset, dst_v_offset); for (i = 0 ; i < height ; i++) { for (j = 0 ; j < loop_length ; j += 2) { if (i % 2 == 0) { - if (j % 4 == 0) { + if (j % 4 == 0) dst_data[dst_u_offset++] = src[src_offset++]; /*U*/ - } else { + else dst_data[dst_v_offset++] = src[src_offset++]; /*V*/ - } } else { src_offset++; } @@ -2103,8 +2543,7 @@ static gboolean _mmcamcorder_convert_UYVY_to_I420(unsigned char *src, guint widt *dst = dst_data; *dst_len = dst_size; - _mmcam_dbg_log("DONE: UYVY -> I420 : %dx%d, dst data %p, size %d", - width, height, *dst, dst_size); + MMCAM_LOG_INFO("DONE: UYVY -> I420 : %dx%d, dst data %p, size %d", width, height, *dst, dst_size); return TRUE; } @@ -2122,17 +2561,23 @@ static gboolean _mmcamcorder_convert_NV12_to_I420(unsigned char *src, guint widt unsigned char *dst_data = NULL; if (!src || !dst || !dst_len) { - _mmcam_dbg_err("NULL pointer %p, %p, %p", src, dst, dst_len); + MMCAM_LOG_ERROR("NULL pointer %p, %p, %p", src, dst, dst_len); + return FALSE; + } + + /* buffer overflow prevention check */ + if (width > __MMCAMCORDER_MAX_WIDTH || height > __MMCAMCORDER_MAX_HEIGHT) { + MMCAM_LOG_ERROR("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); + MMCAM_LOG_INFO("NV12 -> I420 : %dx%d, dst size %d", width, height, dst_size); dst_data = (unsigned char *)malloc(dst_size); if (!dst_data) { - _mmcam_dbg_err("failed to alloc dst_data. size %d", dst_size); + MMCAM_LOG_ERROR("failed to alloc dst_data. size %d", dst_size); return FALSE; } @@ -2140,7 +2585,7 @@ static gboolean _mmcamcorder_convert_NV12_to_I420(unsigned char *src, guint widt dst_u_offset = width * height; dst_v_offset = dst_u_offset + (dst_u_offset >> 2); - _mmcam_dbg_log("offset y %d, u %d, v %d", dst_y_offset, dst_u_offset, dst_v_offset); + MMCAM_LOG_INFO("offset y %d, u %d, v %d", dst_y_offset, dst_u_offset, dst_v_offset); /* memcpy Y */ memcpy(dst_data, src, dst_u_offset); @@ -2150,18 +2595,146 @@ static gboolean _mmcamcorder_convert_NV12_to_I420(unsigned char *src, guint widt /* set U and V */ for (i = 0 ; i < loop_length ; i++) { - if (i % 2 == 0) { + if (i % 2 == 0) dst_data[dst_u_offset++] = src[src_offset++]; - } else { + else dst_data[dst_v_offset++] = src[src_offset++]; - } } *dst = dst_data; *dst_len = dst_size; - _mmcam_dbg_log("DONE: NV12 -> I420 : %dx%d, dst data %p, size %d", - width, height, *dst, dst_size); + MMCAM_LOG_INFO("DONE: NV12 -> I420 : %dx%d, dst data %p, size %d", width, height, *dst, 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_LOG_ERROR("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_LOG_WARNING("failed to emit signal"); + } else { + MMCAM_LOG_INFO("emit signal done - value 0x%.8x", value); + g_dbus_connection_flush(conn, NULL, NULL, NULL); + MMCAM_LOG_INFO("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_LOG_ERROR("NULL ptr"); + return FALSE; + } + + if (samplerate == 0 || channel == 0 || interval == 0) { + MMCAM_LOG_ERROR("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; +} + +gboolean _mmcamcorder_is_encoded_preview_pixel_format(int pixel_format) +{ + return (pixel_format == MM_PIXEL_FORMAT_ENCODED || + pixel_format == MM_PIXEL_FORMAT_ENCODED_H264 || + pixel_format == MM_PIXEL_FORMAT_ENCODED_MJPEG || + pixel_format == MM_PIXEL_FORMAT_ENCODED_VP8 || + pixel_format == MM_PIXEL_FORMAT_ENCODED_VP9); +} + +void _mmcamcorder_set_log_level(int level) +{ + MMCAM_LOG_WARNING("set log level[%d]", level); + mmcam_log_level = level; +} + +int _mmcamcorder_get_log_level(void) +{ + return mmcam_log_level; +} + +void _mmcamcorder_measure_fps(void *data) +{ + int diff_sec; + int frame_count = 0; + struct timeval current_video_time; + _MMCamcorderKPIMeasure *kpi = (_MMCamcorderKPIMeasure *)data; + + mmf_return_if_fail(kpi); + + if (!timerisset(&kpi->init_video_time) && !timerisset(&kpi->last_video_time)) { + MMCAM_LOG_INFO("START to measure FPS"); + gettimeofday(&(kpi->init_video_time), NULL); + } + + frame_count = ++(kpi->video_framecount); + + gettimeofday(¤t_video_time, NULL); + + diff_sec = current_video_time.tv_sec - kpi->last_video_time.tv_sec; + if (diff_sec == 0) + return; + + kpi->current_fps = (frame_count - kpi->last_framecount) / diff_sec; + + if ((current_video_time.tv_sec - kpi->init_video_time.tv_sec) != 0) + kpi->average_fps = kpi->video_framecount / (current_video_time.tv_sec - kpi->init_video_time.tv_sec); + + kpi->last_framecount = frame_count; + kpi->last_video_time.tv_sec = current_video_time.tv_sec; + kpi->last_video_time.tv_usec = current_video_time.tv_usec; + + MMCAM_LOG_INFO("current fps[%d], average[%d]", kpi->current_fps, kpi->average_fps); +} + +void _mmcamcorder_set_property_array_int(GstElement *element, const char *property_name, int *array, unsigned int array_length) +{ + unsigned int i = 0; + GValue value = G_VALUE_INIT; + GValue tmp = G_VALUE_INIT; + + mmf_return_if_fail(element); + mmf_return_if_fail(property_name); + mmf_return_if_fail(array); + + g_value_init(&value, GST_TYPE_ARRAY); + g_value_init(&tmp, G_TYPE_INT); + + MMCAM_LOG_INFO("set element[%s], property[%s], array_length[%d]", + GST_ELEMENT_NAME(element), property_name, array_length); + + gst_value_array_init(&value, array_length); + + for (i = 0 ; i < array_length ; i++) { + MMCAM_LOG_INFO("array[%u] %d", i, array[i]); + g_value_set_int(&tmp, array[i]); + gst_value_array_append_value(&value, &tmp); + } + + g_object_set_property(G_OBJECT(element), property_name, &value); + + g_value_unset(&tmp); + g_value_unset(&value); +}