#include <stdlib.h>
#include <stdio.h>
#include <time.h>
-#include <mm_debug.h>
#include <mm_error.h>
#define MM_EXIFINFO_USE_BINARY_EXIFDATA 1
*/
#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 ,
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;
}
/*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 */
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;
}
unsigned char size[2];
unsigned int i;
+ if (!info) {
+ MMCAM_LOG_ERROR("NULL exif info");
+ return NULL;
+ }
+
/*get ExifData from info*/
loader = exif_loader_new();
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);
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);
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;
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;
}
/*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;
}
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;
}
#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;
}
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;
#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;
}
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
}
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;
}
int
-mm_exif_write_exif_jpeg_to_file(char *filename, mm_exif_info_t *info, void *jpeg, int jpeg_len)
-{
- FILE *fp = NULL;
- unsigned short head[2] = {0,};
- unsigned short head_len = 0;
- unsigned char *eb = NULL;
- unsigned int ebs;
-
- _mmcam_dbg_log("");
-
- eb = info->data;
- ebs = info->size;
-
- /*create file*/
- fp = fopen(filename, "wb");
- if (!fp) {
- _mmcam_dbg_err("fopen() failed [%s].", filename);
- return MM_ERROR_IMAGE_FILEOPEN;
- }
-
- /*set SOI, APP1*/
- _exif_set_uint16(0, &head[0], 0xffd8);
- _exif_set_uint16(0, &head[1], 0xffe1);
- /*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");
- fclose(fp);
- return -1;
- }
-
- fwrite(&head[0], 1, EXIF_MARKER_SOI_LENGTH, fp); /*SOI marker*/
- fwrite(&head[1], 1, EXIF_MARKER_APP1_LENGTH, fp); /*APP1 marker*/
- fwrite(&head_len, 1, EXIF_APP1_LENGTH, fp); /*length of APP1*/
- fwrite(eb, 1, ebs, fp); /*EXIF*/
- fwrite(jpeg + JPEG_DATA_OFFSET, 1, jpeg_len - JPEG_DATA_OFFSET, fp); /*IMAGE*/
-
- fclose(fp);
-
- return MM_ERROR_NONE;
-}
-
-int
-mm_exif_write_exif_jpeg_to_memory(void **mem, unsigned int *length, mm_exif_info_t *info, void *jpeg, unsigned int jpeg_len)
+mm_exif_write_exif_jpeg_to_memory(void **mem, unsigned int *length, mm_exif_info_t *info, unsigned char *jpeg, unsigned int jpeg_len)
{
unsigned short head[2] = {0,};
unsigned short head_len = 0;
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;
}
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*/
/*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;
}
/*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;
}
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*/
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)
projects / platform / core / multimedia / libmm-camcorder.git / blobdiff