Replace deprecated API for GStreamer upgrade

[platform/core/multimedia/libmm-camcorder.git] / src / mm_camcorder_exifinfo.c

diff --git a/src/mm_camcorder_exifinfo.c b/src/mm_camcorder_exifinfo.c
index 8019984..a594460 100644 (file)
--- a/src/mm_camcorder_exifinfo.c
+++ b/src/mm_camcorder_exifinfo.c
@@ -48,7 +48,7 @@
  */
 #include <string.h>
 #define _EXIF_BIN_SIZE_                ((unsigned int)174)
-unsigned char g_exif_bin[_EXIF_BIN_SIZE_] = {
+static unsigned char g_exif_bin[_EXIF_BIN_SIZE_] = {
        0x45 , 0x78 , 0x69 , 0x66 , 0x00 , 0x00 , 0x49 , 0x49 , 0x2a , 0x00 , 0x08 , 0x00 , 0x00 , 0x00 , 0x05 , 0x00 ,
        0x1a , 0x01 , 0x05 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00 , 0x4a , 0x00 , 0x00 , 0x00 , 0x1b , 0x01 , 0x05 , 0x00 ,
        0x01 , 0x00 , 0x00 , 0x00 , 0x52 , 0x00 , 0x00 , 0x00 , 0x28 , 0x01 , 0x03 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00 ,
@@ -105,12 +105,12 @@ _exif_get_jpeg_marker_offset(void *jpeg, int jpeg_size, unsigned short marker)
        m[0] = marker >> 8;
        m[1] = marker & 0x00FF;
 
-       _mmcam_dbg_log("marker: 0x%02X 0x%02X", m[0], m[1]);
+       MMCAM_LOG_INFO("marker: 0x%02X 0x%02X", m[0], m[1]);
 
        if (*src == 0xff && *(src + 1) == 0xd8) {
                p = src + 2; /* SOI(start of image) */
        } else {
-               _mmcam_dbg_log("invalid JPEG file.");
+               MMCAM_LOG_INFO("invalid JPEG file.");
                return 0UL;
        }
 
@@ -119,12 +119,12 @@ _exif_get_jpeg_marker_offset(void *jpeg, int jpeg_size, unsigned short marker)
                        /*marker is 0xFFxx*/
                        if (*(p + 1) == m[1]) {
                                ret = p - src;
-                               _mmcam_dbg_log("marker offset: %lu %p %p.", ret, (p+1), src);
+                               MMCAM_LOG_INFO("marker offset: %lu %p %p.", ret, (p+1), src);
                                return ret;
                        }
                }
        }
-       _mmcam_dbg_log("Marker not found.");
+       MMCAM_LOG_INFO("Marker not found.");
        return 0UL;
 }
 #endif /* _MMCAMCORDER_EXIF_GET_JPEG_MARKER_OFFSET */
@@ -137,7 +137,7 @@ mm_exif_get_exif_data_from_data(mm_exif_info_t *info)
 
        ed = exif_data_new_from_data(info->data, info->size);
        if (ed == NULL)
-               _mmcam_dbg_log("Null exif data. (ed:%p)", ed);
+               MMCAM_LOG_INFO("Null exif data. (ed:%p)", ed);
 
        return ed;
 }
@@ -153,7 +153,7 @@ mm_exif_get_exif_from_info(mm_exif_info_t *info)
        unsigned int i;
 
        if (!info) {
-               _mmcam_dbg_err("NULL exif info");
+               MMCAM_LOG_ERROR("NULL exif info");
                return NULL;
        }
 
@@ -164,7 +164,7 @@ mm_exif_get_exif_from_info(mm_exif_info_t *info)
        size[1] = (unsigned char) (info->size >> 8);
        exif_loader_write(loader, size, 2);
 
-       for (i = 0; i < info->size && exif_loader_write(loader, info->data + i, 1); i++);
+       for (i = 0; i < info->size && exif_loader_write(loader, (unsigned char *)(info->data) + i, 1); i++);
 
        ed = exif_loader_get_data(loader);
        exif_loader_unref(loader);
@@ -179,11 +179,11 @@ mm_exif_set_exif_to_info(mm_exif_info_t *info, ExifData *exif)
        unsigned int ebs;
 
        if (!exif) {
-               _mmcam_dbg_log("exif Null");
+               MMCAM_LOG_INFO("exif Null");
                return MM_ERROR_CAMCORDER_NOT_INITIALIZED;
        }
 
-       _mmcam_dbg_log("exif(ifd :%p)", exif->ifd);
+       MMCAM_LOG_INFO("exif(ifd :%p)", exif->ifd);
 
        if (info->data) {
                free(info->data);
@@ -193,7 +193,7 @@ mm_exif_set_exif_to_info(mm_exif_info_t *info, ExifData *exif)
 
        exif_data_save_data(exif, &eb, &ebs);
        if (eb == NULL) {
-               _mmcam_dbg_log("MM_ERROR_CAMCORDER_LOW_MEMORY");
+               MMCAM_LOG_INFO("MM_ERROR_CAMCORDER_LOW_MEMORY");
                return MM_ERROR_CAMCORDER_LOW_MEMORY;
        }
        info->data = eb;
@@ -209,7 +209,7 @@ mm_exif_set_add_entry(ExifData *exif, ExifIfd ifd, ExifTag tag, ExifFormat forma
        ExifEntry *e = NULL;
 
        if (exif == NULL || format <= 0 || components <= 0 || data == NULL) {
-               _mmcam_dbg_err("invalid argument exif=%p format=%d, components=%lu data=%p!",
+               MMCAM_LOG_ERROR("invalid argument exif=%p format=%d, components=%lu data=%p!",
                                           exif, format, components, data);
                return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
        }
@@ -220,7 +220,7 @@ mm_exif_set_add_entry(ExifData *exif, ExifIfd ifd, ExifTag tag, ExifFormat forma
        /*create new tag*/
        e = exif_entry_new();
        if (e == NULL) {
-               _mmcam_dbg_err("entry create error!");
+               MMCAM_LOG_ERROR("entry create error!");
                return MM_ERROR_CAMCORDER_LOW_MEMORY;
        }
 
@@ -267,23 +267,23 @@ mm_exif_create_exif_info(mm_exif_info_t **info)
        unsigned char *eb = NULL;
        unsigned int ebs;
 #endif
-       _mmcam_dbg_log("");
+       MMCAM_LOG_INFO("");
 
        if (!info) {
-               _mmcam_dbg_err("NULL pointer");
+               MMCAM_LOG_ERROR("NULL pointer");
                return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
        }
 
        x = malloc(sizeof(mm_exif_info_t));
        if (!x) {
-               _mmcam_dbg_err("malloc error");
+               MMCAM_LOG_ERROR("malloc error");
                return MM_ERROR_CAMCORDER_LOW_MEMORY;
        }
 #if MM_EXIFINFO_USE_BINARY_EXIFDATA
        x->data = NULL;
        x->data = malloc(_EXIF_BIN_SIZE_);
        if (!x->data) {
-               _mmcam_dbg_err("malloc error");
+               MMCAM_LOG_ERROR("malloc error");
                free(x);
                return MM_ERROR_CAMCORDER_LOW_MEMORY;
        }
@@ -292,7 +292,8 @@ mm_exif_create_exif_info(mm_exif_info_t **info)
 #else
        ed = exif_data_new();
        if (!ed) {
-               _mmcam_dbg_err("exif data new error");
+               MMCAM_LOG_ERROR("exif data new error");
+               free(x);
                return MM_ERROR_CAMCORDER_LOW_MEMORY;
        }
 
@@ -304,8 +305,7 @@ mm_exif_create_exif_info(mm_exif_info_t **info)
 
        exif_data_save_data(ed, &eb, &ebs);
        if (eb == NULL) {
-               _mmcam_dbg_err("exif_data_save_data error");
-               free(x->data);
+               MMCAM_LOG_ERROR("exif_data_save_data error");
                free(x);
                exif_data_unref(ed);
                return MM_ERROR_CAMCORDER_INTERNAL;
@@ -317,7 +317,7 @@ mm_exif_create_exif_info(mm_exif_info_t **info)
 #endif
        *info = x;
 
-       _mmcam_dbg_log("Data:%p Size:%d", x->data, x->size);
+       MMCAM_LOG_INFO("Data:%p Size:%d", x->data, x->size);
 
        return MM_ERROR_NONE;
 }
@@ -325,21 +325,12 @@ mm_exif_create_exif_info(mm_exif_info_t **info)
 void
 mm_exif_destory_exif_info(mm_exif_info_t *info)
 {
-       /* _mmcam_dbg_log( ""); */
-
-#if MM_EXIFINFO_USE_BINARY_EXIFDATA
+       /* MMCAM_LOG_INFO( ""); */
        if (info) {
                if (info->data)
                        free(info->data);
                free(info);
        }
-#else
-       if (info) {
-               if (info->data)
-                       exif_mem_free(info->data);
-               free(info);
-       }
-#endif
 }
 
 
@@ -353,17 +344,17 @@ mm_exif_add_thumbnail_info(mm_exif_info_t *info, void *thumbnail, int width, int
        int ret = MM_ERROR_NONE;
        int cntl = 0;
 
-       _mmcam_dbg_log("Thumbnail size:%d, width:%d, height:%d", len, width, height);
+       MMCAM_LOG_INFO("Thumbnail size:%d, width:%d, height:%d", len, width, height);
 
        if (len > JPEG_THUMBNAIL_MAX_SIZE) {
-               _mmcam_dbg_err("Thumbnail size[%d] over!!! Skip inserting thumbnail...", len);
+               MMCAM_LOG_ERROR("Thumbnail size[%d] over!!! Skip inserting thumbnail...", len);
                return MM_ERROR_NONE;
        }
 
        /* get ExifData from info*/
        ed = mm_exif_get_exif_from_info(info);
        if (ed == NULL) {
-               _mmcam_dbg_err("mm_exif_get_exif_from_info failed");
+               MMCAM_LOG_ERROR("mm_exif_get_exif_from_info failed");
                return MM_ERROR_CAMCORDER_INTERNAL;
        }
 
@@ -423,15 +414,15 @@ mm_exif_write_exif_jpeg_to_memory(void **mem, unsigned int *length, mm_exif_info
        unsigned char *m = NULL;
        int m_len = 0;
 
-       _mmcam_dbg_log("");
+       MMCAM_LOG_INFO("");
 
        if (info == NULL || jpeg == NULL) {
-               _mmcam_dbg_err("MM_ERROR_CAMCORDER_INVALID_ARGUMENT info=%p, jpeg=%p", info, jpeg);
+               MMCAM_LOG_ERROR("MM_ERROR_CAMCORDER_INVALID_ARGUMENT info=%p, jpeg=%p", info, jpeg);
                return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
        }
 
        if (jpeg_len > JPEG_MAX_SIZE) {
-               _mmcam_dbg_err("jpeg_len is worng jpeg_len=%d", jpeg_len);
+               MMCAM_LOG_ERROR("jpeg_len is wrong jpeg_len=%d", jpeg_len);
                return MM_ERROR_CAMCORDER_DEVICE_WRONG_JPEG;
        }
 
@@ -449,10 +440,10 @@ mm_exif_write_exif_jpeg_to_memory(void **mem, unsigned int *length, mm_exif_info
                        free(test_exif_info);
                        test_exif_info = NULL;
                } else {
-                       _mmcam_dbg_err("test_exif_info is NULL");
+                       MMCAM_LOG_ERROR("test_exif_info is NULL");
                }
        } else {
-               _mmcam_dbg_warn("no EXIF in JPEG");
+               MMCAM_LOG_WARNING("no EXIF in JPEG");
        }
 
        /*length of output image*/
@@ -461,7 +452,7 @@ mm_exif_write_exif_jpeg_to_memory(void **mem, unsigned int *length, mm_exif_info
        /*alloc output image*/
        m = malloc(m_len);
        if (!m) {
-               _mmcam_dbg_err("malloc() failed.");
+               MMCAM_LOG_ERROR("malloc() failed.");
                return MM_ERROR_CAMCORDER_LOW_MEMORY;
        }
 
@@ -471,7 +462,7 @@ mm_exif_write_exif_jpeg_to_memory(void **mem, unsigned int *length, mm_exif_info
        /*set header length*/
        _exif_set_uint16(0, &head_len, (unsigned short)(ebs + 2));
        if (head[0] == 0 || head[1] == 0 || head_len == 0) {
-               _mmcam_dbg_err("setting error");
+               MMCAM_LOG_ERROR("setting error");
                free(m);
                return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
        }
@@ -493,7 +484,7 @@ mm_exif_write_exif_jpeg_to_memory(void **mem, unsigned int *length, mm_exif_info
        memcpy(m + EXIF_MARKER_SOI_LENGTH + EXIF_MARKER_APP1_LENGTH + EXIF_APP1_LENGTH + ebs,
                jpeg + jpeg_offset, jpeg_len - jpeg_offset);
 
-       _mmcam_dbg_log("JPEG+EXIF Copy DONE(original:%d, offset:%d, copied:%d)",
+       MMCAM_LOG_INFO("JPEG+EXIF Copy DONE(original:%d, offset:%d, copied:%d)",
                jpeg_len, jpeg_offset, jpeg_len - jpeg_offset);
 
        /*set ouput param*/
@@ -525,26 +516,26 @@ int mm_exif_load_exif_info(mm_exif_info_t **info, void *jpeg_data, int jpeg_leng
                                        memcpy((char*)x->data, b, s);
                                        x->size = s;
                                        *info = x;
-                                       _mmcam_dbg_warn("load EXIF : data %p, size %d", x->data, x->size);
+                                       MMCAM_LOG_WARNING("load EXIF : data %p, size %d", x->data, x->size);
                                } else {
-                                       _mmcam_dbg_err("mm_exif_info_t malloc failed");
+                                       MMCAM_LOG_ERROR("mm_exif_info_t malloc failed");
                                        free(x);
                                        exif_loader_unref(loader);
 
                                        return MM_ERROR_CAMCORDER_LOW_MEMORY;
                                }
                        } else {
-                               _mmcam_dbg_err("mm_exif_info_t malloc failed");
+                               MMCAM_LOG_ERROR("mm_exif_info_t malloc failed");
                        }
                } else {
-                       _mmcam_dbg_err("exif_loader_get_buf failed");
+                       MMCAM_LOG_ERROR("exif_loader_get_buf failed");
                }
 
                /* The loader is no longer needed--free it */
                exif_loader_unref(loader);
                loader = NULL;
        } else {
-               _mmcam_dbg_err("exif_loader_new failed");
+               MMCAM_LOG_ERROR("exif_loader_new failed");
        }
 
        if (x)