#include <stdlib.h>
#include <stdio.h>
#include <time.h>
-#include <mm_debug.h>
#include <mm_error.h>
-#include <glib.h>
#define MM_EXIFINFO_USE_BINARY_EXIFDATA 1
#define JPEG_MAX_SIZE 20000000
*/
#include <string.h>
#define _EXIF_BIN_SIZE_ ((unsigned int)174)
-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
- , 0x02 , 0x00 , 0x00 , 0x00 , 0x13 , 0x02 , 0x03 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00
- , 0x69 , 0x87 , 0x04 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00 , 0x5a , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00
- , 0x48 , 0x00 , 0x00 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00 , 0x48 , 0x00 , 0x00 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00
- , 0x06 , 0x00 , 0x00 , 0x90 , 0x07 , 0x00 , 0x04 , 0x00 , 0x00 , 0x00 , 0x30 , 0x32 , 0x31 , 0x30 , 0x01 , 0x91
- , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0xa0 , 0x07 , 0x00 , 0x04 , 0x00
- , 0x00 , 0x00 , 0x30 , 0x31 , 0x30 , 0x30 , 0x01 , 0xa0 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00
- , 0x00 , 0x00 , 0x02 , 0xa0 , 0x04 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x03 , 0xa0
- , 0x04 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00
+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 ,
+ 0x02 , 0x00 , 0x00 , 0x00 , 0x13 , 0x02 , 0x03 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00 ,
+ 0x69 , 0x87 , 0x04 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00 , 0x5a , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 ,
+ 0x48 , 0x00 , 0x00 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00 , 0x48 , 0x00 , 0x00 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00 ,
+ 0x06 , 0x00 , 0x00 , 0x90 , 0x07 , 0x00 , 0x04 , 0x00 , 0x00 , 0x00 , 0x30 , 0x32 , 0x31 , 0x30 , 0x01 , 0x91 ,
+ 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0xa0 , 0x07 , 0x00 , 0x04 , 0x00 ,
+ 0x00 , 0x00 , 0x30 , 0x31 , 0x30 , 0x30 , 0x01 , 0xa0 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 ,
+ 0x00 , 0x00 , 0x02 , 0xa0 , 0x04 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x03 , 0xa0 ,
+ 0x04 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00
};
#endif
/**
* Structure for exif entry.
*/
-typedef struct _mm_exif_entry_t
-{
+typedef struct _mm_exif_entry_t {
ExifTag tag; /**< exif tag*/
ExifFormat format; /**< exif format*/
unsigned long components; /**< number of components*/
* local functions.
*/
static void
-_exif_set_uint16 (int is_motorola, void * out, unsigned short in)
+_exif_set_uint16(int is_motorola, void * out, unsigned short in)
{
if (is_motorola) {
((unsigned char *)out)[0] = in & 0x00ff;
#ifdef _MMCAMCORDER_EXIF_GET_JPEG_MARKER_OFFSET
static unsigned long
-_exif_get_jpeg_marker_offset (void *jpeg, int jpeg_size, unsigned short marker)
+_exif_get_jpeg_marker_offset(void *jpeg, int jpeg_size, unsigned short marker)
{
- unsigned char *p = NULL;
- unsigned char *src = jpeg;
- int src_sz = jpeg_size;
- unsigned char m[2];
- unsigned long ret;
+ unsigned char *p = NULL;
+ unsigned char *src = jpeg;
+ int src_sz = jpeg_size;
+ unsigned char m[2];
+ unsigned long ret;
int i;
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)
- {
+ if (*src == 0xff && *(src + 1) == 0xd8) {
p = src + 2; /* SOI(start of image) */
- }
- else
- {
- _mmcam_dbg_log("invalid JPEG file.");
+ } else {
+ MMCAM_LOG_INFO("invalid JPEG file.");
return 0UL;
}
- for (i = 0; i < src_sz - (1 + 2); i++, p++)
- {
- if (*p == 0xff)
- {
+ for (i = 0; i < src_sz - (1 + 2); i++, p++) {
+ if (*p == 0xff) {
/*marker is 0xFFxx*/
- if (*(p + 1) == m[1])
- {
+ 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 */
ExifData*
-mm_exif_get_exif_data_from_data (mm_exif_info_t *info)
+mm_exif_get_exif_data_from_data(mm_exif_info_t *info)
{
- ExifData *ed = NULL;
+ ExifData *ed = NULL;
ed = exif_data_new_from_data(info->data, info->size);
- if( ed == NULL )
- {
- _mmcam_dbg_log("Null exif data. (ed:%p)", ed);
- }
+ if (ed == NULL)
+ MMCAM_LOG_INFO("Null exif data. (ed:%p)", ed);
return ed;
}
ExifData*
-mm_exif_get_exif_from_info (mm_exif_info_t *info)
+mm_exif_get_exif_from_info(mm_exif_info_t *info)
{
- ExifData *ed = NULL;
- ExifLoader *loader = NULL;
+ ExifData *ed = NULL;
+ ExifLoader *loader = NULL;
- unsigned char size[2];
- unsigned int i;
+ 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 ();
+ loader = exif_loader_new();
size[0] = (unsigned char) (info->size);
size[1] = (unsigned char) (info->size >> 8);
- exif_loader_write (loader, size, 2);
+ 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);
+ ed = exif_loader_get_data(loader);
+ exif_loader_unref(loader);
return ed;
}
int
-mm_exif_set_exif_to_info (mm_exif_info_t *info, ExifData *exif)
+mm_exif_set_exif_to_info(mm_exif_info_t *info, ExifData *exif)
{
- unsigned char *eb = NULL;
- unsigned int ebs;
+ unsigned char *eb = NULL;
+ unsigned int ebs;
- if (!exif)
- {
- _mmcam_dbg_log("exif Null");
+ if (!exif) {
+ 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);
+ if (info->data) {
+ free(info->data);
info->data = NULL;
info->size = 0;
}
- exif_data_save_data (exif, &eb, &ebs);
- if(eb==NULL)
- {
- _mmcam_dbg_log("MM_ERROR_CAMCORDER_LOW_MEMORY");
+ exif_data_save_data(exif, &eb, &ebs);
+ if (eb == NULL) {
+ MMCAM_LOG_INFO("MM_ERROR_CAMCORDER_LOW_MEMORY");
return MM_ERROR_CAMCORDER_LOW_MEMORY;
}
info->data = eb;
int
-mm_exif_set_add_entry (ExifData *exif, ExifIfd ifd, ExifTag tag,ExifFormat format,unsigned long components, const char* data)
+mm_exif_set_add_entry(ExifData *exif, ExifIfd ifd, ExifTag tag, ExifFormat format, unsigned long components, const char* data)
{
ExifData *ed = (ExifData *)exif;
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!",
- exif,format,components,data);
+ 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;
}
return MM_ERROR_CAMCORDER_LOW_MEMORY;
}
- if (format == EXIF_FORMAT_ASCII) {
+ if (format == EXIF_FORMAT_ASCII)
memset(e->data, '\0', exif_format_get_size(format) * e->components);
- }
}
e->size = exif_format_get_size(format) * e->components;
- memcpy(e->data,data,e->size);
+ memcpy(e->data, data, e->size);
exif_content_add_entry(ed->ifd[ifd], e);
exif_entry_unref(e);
int
-mm_exif_create_exif_info (mm_exif_info_t **info)
+mm_exif_create_exif_info(mm_exif_info_t **info)
{
mm_exif_info_t *x = NULL;
#if (MM_EXIFINFO_USE_BINARY_EXIFDATA == 0)
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)
+mm_exif_destory_exif_info(mm_exif_info_t *info)
{
- //_mmcam_dbg_log( "");
-
-#if MM_EXIFINFO_USE_BINARY_EXIFDATA
- if (info) {
- if (info->data)
- free (info->data);
- free (info);
- }
-#else
+ /* MMCAM_LOG_INFO( ""); */
if (info) {
if (info->data)
- exif_mem_free (info->data);
- free (info);
+ free(info->data);
+ free(info);
}
-#endif
}
int
-mm_exif_add_thumbnail_info (mm_exif_info_t *info, void *thumbnail, int width, int height, int len)
+mm_exif_add_thumbnail_info(mm_exif_info_t *info, void *thumbnail, int width, int height, int len)
{
ExifData *ed = NULL;
static ExifLong elong[10];
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);
+ if (len > JPEG_THUMBNAIL_MAX_SIZE) {
+ 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;
}
if (p_compressed != NULL) {
exif_set_short(p_compressed, exif_data_get_byte_order(ed), 6);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_1, EXIF_TAG_COMPRESSION, EXIF_FORMAT_SHORT, 1, (const char *)p_compressed);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
goto exit;
- }
} else {
ret = MM_ERROR_CAMCORDER_LOW_MEMORY;
goto exit;
}
/* set thumbnail size */
- exif_set_long ((unsigned char *)&elong[cntl], exif_data_get_byte_order(ed), width);
+ exif_set_long((unsigned char *)&elong[cntl], exif_data_get_byte_order(ed), width);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_1, EXIF_TAG_IMAGE_WIDTH, EXIF_FORMAT_LONG, 1, (const char *)&elong[cntl++]);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
goto exit;
- }
- exif_set_long ((unsigned char *)&elong[cntl], exif_data_get_byte_order(ed), height);
+
+ exif_set_long((unsigned char *)&elong[cntl], exif_data_get_byte_order(ed), height);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_1, EXIF_TAG_IMAGE_LENGTH, EXIF_FORMAT_LONG, 1, (const char *)&elong[cntl++]);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
goto exit;
- }
- ret = mm_exif_set_exif_to_info (info, ed);
- if (ret != MM_ERROR_NONE) {
+ ret = mm_exif_set_exif_to_info(info, ed);
+ if (ret != MM_ERROR_NONE)
goto exit;
- }
ed->data = NULL;
ed->size = 0;
- exif_data_unref (ed);
+ exif_data_unref(ed);
-exit :
- if(p_compressed != NULL)
+exit:
+ if (p_compressed != NULL)
free(p_compressed);
+
return ret;
}
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);
+ if (info == NULL || jpeg == NULL) {
+ 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);
+ if (jpeg_len > JPEG_MAX_SIZE) {
+ 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*/
/*SOI + APP1 + length of APP1 + length of EXIF + IMAGE*/
m_len = EXIF_MARKER_SOI_LENGTH + EXIF_MARKER_APP1_LENGTH + EXIF_APP1_LENGTH + ebs + (jpeg_len - jpeg_offset);
/*alloc output image*/
- m = malloc (m_len);
+ m = malloc(m_len);
if (!m) {
- _mmcam_dbg_err( "malloc() failed.");
+ MMCAM_LOG_ERROR("malloc() failed.");
return MM_ERROR_CAMCORDER_LOW_MEMORY;
}
/*set SOI, APP1*/
- _exif_set_uint16 (0, &head[0], 0xffd8);
- _exif_set_uint16 (0, &head[1], 0xffe1);
+ _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));
+ _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;
}
/* Complete JPEG+EXIF */
/*SOI marker*/
memcpy(m, &head[0], EXIF_MARKER_SOI_LENGTH);
+
/*APP1 marker*/
- memcpy(m + EXIF_MARKER_SOI_LENGTH,
- &head[1], EXIF_MARKER_APP1_LENGTH);
+ memcpy(m + EXIF_MARKER_SOI_LENGTH, &head[1], EXIF_MARKER_APP1_LENGTH);
+
/*length of APP1*/
- memcpy(m + EXIF_MARKER_SOI_LENGTH + EXIF_MARKER_APP1_LENGTH,
- &head_len, EXIF_APP1_LENGTH);
+ memcpy(m + EXIF_MARKER_SOI_LENGTH + EXIF_MARKER_APP1_LENGTH, &head_len, EXIF_APP1_LENGTH);
+
/*EXIF*/
- memcpy(m + EXIF_MARKER_SOI_LENGTH + EXIF_MARKER_APP1_LENGTH + EXIF_APP1_LENGTH,
- eb, ebs);
+ memcpy(m + EXIF_MARKER_SOI_LENGTH + EXIF_MARKER_APP1_LENGTH + EXIF_APP1_LENGTH, eb, ebs);
+
/*IMAGE*/
memcpy(m + EXIF_MARKER_SOI_LENGTH + EXIF_MARKER_APP1_LENGTH + EXIF_APP1_LENGTH + ebs,
- jpeg + jpeg_offset, jpeg_len - jpeg_offset);
+ jpeg + jpeg_offset, jpeg_len - jpeg_offset);
- _mmcam_dbg_log("JPEG+EXIF Copy DONE(original:%d, offset:%d, copied:%d)",
- jpeg_len, jpeg_offset, jpeg_len - jpeg_offset);
+ MMCAM_LOG_INFO("JPEG+EXIF Copy DONE(original:%d, offset:%d, copied:%d)",
+ jpeg_len, jpeg_offset, jpeg_len - jpeg_offset);
/*set ouput param*/
- *mem = m;
+ *mem = m;
*length = m_len;
return MM_ERROR_NONE;
const unsigned char *b = NULL;
unsigned int s = 0;
mm_exif_info_t *x = NULL;
- // TODO : get exif and re-set exif
+
+ /* TODO : get exif and re-set exif */
+
loader = exif_loader_new();
if (loader) {
- exif_loader_write (loader, jpeg_data, jpeg_length);
- exif_loader_get_buf (loader, &b, &s);
+ exif_loader_write(loader, jpeg_data, jpeg_length);
+ exif_loader_get_buf(loader, &b, &s);
if (s > 0) {
x = malloc(sizeof(mm_exif_info_t));
if (x) {
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) {
+ if (x)
return MM_ERROR_NONE;
- } else {
+ else
return MM_ERROR_CAMCORDER_INTERNAL;
- }
}
projects / platform / core / multimedia / libmm-camcorder.git / blobdiff