libcamera_external/Exif.cpp - LeafOS-Devices/android_hardware_samsung_slsi-linaro_exynos - Gitiles

 /*
  * Copyright 2008, The Android Open Source Project
  * Copyright 2013, Samsung Electronics Co. LTD
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 /*!
  * \file      Exif.cpp
  * \brief     source file for Android Camera Ext HAL
  * \author    teahyung kim (tkon.kim@samsung.com)
  * \date      2013/04/30
  *
  */

 #define LOG_TAG "Exif"

 #include <cutils/compiler.h>
 #include <utils/Log.h>
 #include <fcntl.h>

 #include <camera/Camera.h>

 #include "Exif.h"

 namespace android {
 #define CLEAR(x)    memset(&(x), 0, sizeof(x))

 const char Exif::DEFAULT_MAKER[] = "SAMSUNG";
 const char Exif::DEFAULT_MODEL[] = "Exynos";
 const char Exif::DEFAULT_SOFTWARE[] = "Exif Software Version 1.0.2.0";
 const char Exif::DEFAULT_EXIF_VERSION[] = "0220";
 const char Exif::DEFAULT_USERCOMMENTS[] = "User comments";

 const int Exif::DEFAULT_YCBCR_POSITIONING = 1;

 const int Exif::DEFAULT_EXPOSURE_PROGRAM = 2;

 const int Exif::DEFAULT_FLASH = 0;
 const int Exif::DEFAULT_COLOR_SPACE = 1;
 const int Exif::DEFAULT_EXPOSURE_MODE = EXIF_EXPOSURE_AUTO;
 const int Exif::DEFAULT_APEX_DEN = 100;
 const int Exif::DEFAULT_SENSING_METHOD = 2;

 const int Exif::DEFAULT_COMPRESSION = 6;
 const int Exif::DEFAULT_RESOLUTION_NUM = 72;
 const int Exif::DEFAULT_RESOLUTION_DEN = 1;
 const int Exif::DEFAULT_RESOLUTION_UNIT = 2;

 const int Exif::DEFAULT_CONTINUOUS_SHOT_INFO = 0;
 Exif::Exif(int cameraId, int CameraType)
 {
     mCameraId = cameraId;
     mCameraType = CameraType;

     mNum0thIfdTiff = 10;

     if (cameraId == CAMERA_FACING_BACK) {
         if (mCameraType == CAMERA_TYPE_SOC)
             mNum0thIfdExif = 23;
         else
             mNum0thIfdExif = 27;
     } else {
         mNum0thIfdExif = 14;
     }

     mNum0thIfdGps = 10;
     mNum1thIfdTiff = 9;
 }

 Exif::~Exif()
 {
 }

 uint32_t Exif::make(void *exifOutBuf,
             exif_attribute_t *exifInfo,
             unsigned int exifOutBufSize,
             unsigned char *thumbBuf,
             unsigned int thumbSize)
 {
     ALOGV("makeExif E");

     unsigned char *pCur, *pApp1Start, *pIfdStart, *pGpsIfdPtr, *pNextIfdOffset;
     unsigned int tmp, LongerTagOffest = 0;
     pApp1Start = pCur = (unsigned char *)exifOutBuf;

     /* Exif Identifier Code & TIFF Header */
     pCur += 4;
     /* Skip 4 Byte for APP1 marker and length */
     unsigned char ExifIdentifierCode[6] = {0x45, 0x78, 0x69, 0x66, 0x00, 0x00};
     memcpy(pCur, ExifIdentifierCode, 6);
     pCur += 6;

     /* Byte Order - little endian, Offset of IFD - 0x00000008.H */
     unsigned char TiffHeader[8] = {0x49, 0x49, 0x2A, 0x00, 0x08, 0x00, 0x00, 0x00};
     memcpy(pCur, TiffHeader, 8);
     pIfdStart = pCur;
     pCur += 8;

     const char asciiPrefix[] = {0x41, 0x53, 0x43, 0x49, 0x49, 0x0, 0x0, 0x0};
     unsigned char tmpBuf[256] = {0, };
     size_t len;

     /* 0th IFD TIFF Tags */
     if (exifInfo->enableGps)
         tmp = mNum0thIfdTiff;
     else
         tmp = mNum0thIfdTiff - 1;

     memcpy(pCur, &tmp, NUM_SIZE);
     pCur += NUM_SIZE;

     LongerTagOffest += 8 + NUM_SIZE + tmp * IFD_SIZE + OFFSET_SIZE;

     writeExifIfd(&pCur, EXIF_TAG_IMAGE_WIDTH, EXIF_TYPE_LONG,
                  1, exifInfo->width);
     writeExifIfd(&pCur, EXIF_TAG_IMAGE_HEIGHT, EXIF_TYPE_LONG,
                  1, exifInfo->height);
     writeExifIfd(&pCur, EXIF_TAG_MAKE, EXIF_TYPE_ASCII,
                  strlen((char *)exifInfo->maker) + 1, exifInfo->maker, &LongerTagOffest, pIfdStart);
     writeExifIfd(&pCur, EXIF_TAG_MODEL, EXIF_TYPE_ASCII,
                  strlen((char *)exifInfo->model) + 1, exifInfo->model, &LongerTagOffest, pIfdStart);
     writeExifIfd(&pCur, EXIF_TAG_ORIENTATION, EXIF_TYPE_SHORT,
                  1, exifInfo->orientation);

     if (CAMERA_TYPE_ISP == mCameraType) {
         writeExifIfd(&pCur, EXIF_TAG_SOFTWARE, EXIF_TYPE_ASCII,
             strlen((char *)exifInfo->software) + 1, exifInfo->software, &LongerTagOffest, pIfdStart);
     } else {
         writeExifIfd(&pCur, EXIF_TAG_SOFTWARE, EXIF_TYPE_ASCII,
             1, exifInfo->software, &LongerTagOffest, pIfdStart);
     }

     writeExifIfd(&pCur, EXIF_TAG_DATE_TIME, EXIF_TYPE_ASCII,
                  20, exifInfo->date_time, &LongerTagOffest, pIfdStart);
     writeExifIfd(&pCur, EXIF_TAG_YCBCR_POSITIONING, EXIF_TYPE_SHORT,
                  1, exifInfo->ycbcr_positioning);
     writeExifIfd(&pCur, EXIF_TAG_EXIF_IFD_POINTER, EXIF_TYPE_LONG,
                  1, LongerTagOffest);
     if (exifInfo->enableGps) {
         pGpsIfdPtr = pCur;
         /* Skip a ifd size for gps IFD pointer */
         pCur += IFD_SIZE;
     }

     /* Skip a offset size for next IFD offset */
     pNextIfdOffset = pCur;
     pCur += OFFSET_SIZE;

     /* 0th IFD Exif Private Tags */
     pCur = pIfdStart + LongerTagOffest;

     tmp = mNum0thIfdExif;
     memcpy(pCur, &tmp , NUM_SIZE);
     pCur += NUM_SIZE;

     LongerTagOffest += NUM_SIZE + mNum0thIfdExif*IFD_SIZE + OFFSET_SIZE;

     writeExifIfd(&pCur, EXIF_TAG_EXPOSURE_TIME, EXIF_TYPE_RATIONAL,
                  1, &exifInfo->exposure_time, &LongerTagOffest, pIfdStart);
     writeExifIfd(&pCur, EXIF_TAG_FNUMBER, EXIF_TYPE_RATIONAL,
                  1, &exifInfo->fnumber, &LongerTagOffest, pIfdStart);
     writeExifIfd(&pCur, EXIF_TAG_EXPOSURE_PROGRAM, EXIF_TYPE_SHORT,
                  1, exifInfo->exposure_program);
     writeExifIfd(&pCur, EXIF_TAG_ISO_SPEED_RATING, EXIF_TYPE_SHORT,
                  1, exifInfo->iso_speed_rating);
     writeExifIfd(&pCur, EXIF_TAG_EXIF_VERSION, EXIF_TYPE_UNDEFINED,
                  4, exifInfo->exif_version);
     writeExifIfd(&pCur, EXIF_TAG_DATE_TIME_ORG, EXIF_TYPE_ASCII,
                  20, exifInfo->date_time, &LongerTagOffest, pIfdStart);
     writeExifIfd(&pCur, EXIF_TAG_DATE_TIME_DIGITIZE, EXIF_TYPE_ASCII,
                  20, exifInfo->date_time, &LongerTagOffest, pIfdStart);

     if (mCameraId == CAMERA_FACING_BACK) {
         if (CAMERA_TYPE_ISP == mCameraType) {
             writeExifIfd(&pCur, EXIF_TAG_SHUTTER_SPEED, EXIF_TYPE_SRATIONAL,
                          1, (rational_t *)&exifInfo->shutter_speed, &LongerTagOffest, pIfdStart);
             writeExifIfd(&pCur, EXIF_TAG_APERTURE, EXIF_TYPE_RATIONAL,
                          1, &exifInfo->aperture, &LongerTagOffest, pIfdStart);
             writeExifIfd(&pCur, EXIF_TAG_BRIGHTNESS, EXIF_TYPE_SRATIONAL,
                          1, (rational_t *)&exifInfo->brightness, &LongerTagOffest, pIfdStart);
             writeExifIfd(&pCur, EXIF_TAG_EXPOSURE_BIAS, EXIF_TYPE_SRATIONAL,
                          1, (rational_t *)&exifInfo->exposure_bias, &LongerTagOffest, pIfdStart);
         }

         writeExifIfd(&pCur, EXIF_TAG_MAX_APERTURE, EXIF_TYPE_RATIONAL,
                      1, &exifInfo->max_aperture, &LongerTagOffest, pIfdStart);
         writeExifIfd(&pCur, EXIF_TAG_DIGITAL_ZOOM_RATIO, EXIF_TYPE_RATIONAL,
                      1, &exifInfo->digital_zoom_ratio, &LongerTagOffest, pIfdStart);
         writeExifIfd(&pCur, EXIF_TAG_METERING_MODE, EXIF_TYPE_SHORT,
                      1, exifInfo->metering_mode);
         writeExifIfd(&pCur, EXIF_TAG_LIGHT_SOURCE, EXIF_TYPE_SHORT,
                      1, exifInfo->light_source);
         writeExifIfd(&pCur, EXIF_TAG_FLASH, EXIF_TYPE_SHORT,
                      1, exifInfo->flash);
 		writeExifIfd(&pCur, EXIF_TAG_FOCAL_35mm_LENGTH, EXIF_TYPE_SHORT,
 				1, exifInfo->focal_35mm_length);
     }

     writeExifIfd(&pCur, EXIF_TAG_FOCAL_LENGTH, EXIF_TYPE_RATIONAL,
                  1, &exifInfo->focal_length, &LongerTagOffest, pIfdStart);
     CLEAR(tmpBuf);
     len = strlen((char *)exifInfo->user_comment) + 1;
     memcpy(tmpBuf, asciiPrefix, sizeof(asciiPrefix));
     memcpy(tmpBuf + sizeof(asciiPrefix), exifInfo->user_comment, len);
     writeExifIfd(&pCur, EXIF_TAG_USER_COMMENT, EXIF_TYPE_UNDEFINED,
                  len + sizeof(asciiPrefix), tmpBuf, &LongerTagOffest, pIfdStart);
     writeExifIfd(&pCur, EXIF_TAG_COLOR_SPACE, EXIF_TYPE_SHORT,
                  1, exifInfo->color_space);
     writeExifIfd(&pCur, EXIF_TAG_PIXEL_X_DIMENSION, EXIF_TYPE_LONG,
                  1, exifInfo->width);
     writeExifIfd(&pCur, EXIF_TAG_PIXEL_Y_DIMENSION, EXIF_TYPE_LONG,
                  1, exifInfo->height);
     writeExifIfd(&pCur, EXIF_TAG_EXPOSURE_MODE, EXIF_TYPE_LONG,
                  1, exifInfo->exposure_mode);
     writeExifIfd(&pCur, EXIF_TAG_WHITE_BALANCE, EXIF_TYPE_LONG,
                  1, exifInfo->white_balance);
     if (mCameraId == CAMERA_FACING_BACK) {
         writeExifIfd(&pCur, EXIF_TAG_SCENCE_CAPTURE_TYPE, EXIF_TYPE_LONG,
                      1, exifInfo->scene_capture_type);
         writeExifIfd(&pCur, EXIF_TAG_IMAGE_UNIQUE_ID, EXIF_TYPE_ASCII,
                      12, exifInfo->unique_id, &LongerTagOffest, pIfdStart);
 		writeExifIfd(&pCur, EXIF_TAG_SENSING_METHOD, EXIF_TYPE_SHORT,
 				1, exifInfo->sensing_method);
     }

     tmp = 0;
     /* next IFD offset */
     memcpy(pCur, &tmp, OFFSET_SIZE);
     pCur += OFFSET_SIZE;

     /* 0th IFD GPS Info Tags */
     if (exifInfo->enableGps) {
         /* GPS IFD pointer skipped on 0th IFD */
         writeExifIfd(&pGpsIfdPtr, EXIF_TAG_GPS_IFD_POINTER, EXIF_TYPE_LONG,
                      1, LongerTagOffest);

         pCur = pIfdStart + LongerTagOffest;

         tmp = mNum0thIfdGps;
         memcpy(pCur, &tmp, NUM_SIZE);
         pCur += NUM_SIZE;

         LongerTagOffest += NUM_SIZE + mNum0thIfdGps * IFD_SIZE + OFFSET_SIZE;

         writeExifIfd(&pCur, EXIF_TAG_GPS_VERSION_ID, EXIF_TYPE_BYTE,
                      4, exifInfo->gps_version_id);
         writeExifIfd(&pCur, EXIF_TAG_GPS_LATITUDE_REF, EXIF_TYPE_ASCII,
                      2, exifInfo->gps_latitude_ref);
         writeExifIfd(&pCur, EXIF_TAG_GPS_LATITUDE, EXIF_TYPE_RATIONAL,
                      3, exifInfo->gps_latitude, &LongerTagOffest, pIfdStart);
         writeExifIfd(&pCur, EXIF_TAG_GPS_LONGITUDE_REF, EXIF_TYPE_ASCII,
                      2, exifInfo->gps_longitude_ref);
         writeExifIfd(&pCur, EXIF_TAG_GPS_LONGITUDE, EXIF_TYPE_RATIONAL,
                      3, exifInfo->gps_longitude, &LongerTagOffest, pIfdStart);
         writeExifIfd(&pCur, EXIF_TAG_GPS_ALTITUDE_REF, EXIF_TYPE_BYTE,
                      1, exifInfo->gps_altitude_ref);
         writeExifIfd(&pCur, EXIF_TAG_GPS_ALTITUDE, EXIF_TYPE_RATIONAL,
                      1, &exifInfo->gps_altitude, &LongerTagOffest, pIfdStart);
         writeExifIfd(&pCur, EXIF_TAG_GPS_TIMESTAMP, EXIF_TYPE_RATIONAL,
                      3, exifInfo->gps_timestamp, &LongerTagOffest, pIfdStart);
         CLEAR(tmpBuf);
         len = strlen((char *)exifInfo->gps_processing_method);
         memcpy(tmpBuf, asciiPrefix, sizeof(asciiPrefix));
         memcpy(tmpBuf + sizeof(asciiPrefix), exifInfo->gps_processing_method, len);
         writeExifIfd(&pCur, EXIF_TAG_GPS_PROCESSING_METHOD, EXIF_TYPE_UNDEFINED,
                      len + sizeof(asciiPrefix), tmpBuf, &LongerTagOffest, pIfdStart);
         writeExifIfd(&pCur, EXIF_TAG_GPS_DATESTAMP, EXIF_TYPE_ASCII,
                      11, exifInfo->gps_datestamp, &LongerTagOffest, pIfdStart);
         tmp = 0;
         /* next IFD offset */
         memcpy(pCur, &tmp, OFFSET_SIZE);
         pCur += OFFSET_SIZE;
     }

     /* 1th IFD TIFF Tags */
     if ((thumbBuf != NULL) && (thumbSize > 0)) {
         if (CC_UNLIKELY(!exifOutBufSize)) {
             ALOGE("makeExif: error, exifOutBufSize is zero");
             return 0;
         }

         tmp = LongerTagOffest;
         /* NEXT IFD offset skipped on 0th IFD */
         memcpy(pNextIfdOffset, &tmp, OFFSET_SIZE);

         pCur = pIfdStart + LongerTagOffest;

         tmp = mNum1thIfdTiff;
         memcpy(pCur, &tmp, NUM_SIZE);
         pCur += NUM_SIZE;

         LongerTagOffest += NUM_SIZE + mNum1thIfdTiff * IFD_SIZE + OFFSET_SIZE;

         writeExifIfd(&pCur, EXIF_TAG_IMAGE_WIDTH, EXIF_TYPE_LONG,
                      1, exifInfo->widthThumb);
         writeExifIfd(&pCur, EXIF_TAG_IMAGE_HEIGHT, EXIF_TYPE_LONG,
                      1, exifInfo->heightThumb);
         writeExifIfd(&pCur, EXIF_TAG_COMPRESSION_SCHEME, EXIF_TYPE_SHORT,
                      1, exifInfo->compression_scheme);
         writeExifIfd(&pCur, EXIF_TAG_ORIENTATION, EXIF_TYPE_SHORT,
                      1, exifInfo->orientation);
         writeExifIfd(&pCur, EXIF_TAG_X_RESOLUTION, EXIF_TYPE_RATIONAL,
                      1, &exifInfo->x_resolution, &LongerTagOffest, pIfdStart);
         writeExifIfd(&pCur, EXIF_TAG_Y_RESOLUTION, EXIF_TYPE_RATIONAL,
                      1, &exifInfo->y_resolution, &LongerTagOffest, pIfdStart);
         writeExifIfd(&pCur, EXIF_TAG_RESOLUTION_UNIT, EXIF_TYPE_SHORT,
                      1, exifInfo->resolution_unit);
         writeExifIfd(&pCur, EXIF_TAG_JPEG_INTERCHANGE_FORMAT, EXIF_TYPE_LONG,
                      1, LongerTagOffest);
         writeExifIfd(&pCur, EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LEN, EXIF_TYPE_LONG,
                      1, thumbSize);

         tmp = 0;
         /* next IFD offset */
         memcpy(pCur, &tmp, OFFSET_SIZE);
         pCur += OFFSET_SIZE;

         if (CC_UNLIKELY(pIfdStart + LongerTagOffest + thumbSize >= (void *)((uint32_t)exifOutBuf + exifOutBufSize))) {
             ALOGE("makeExif: error, thumbnail size(%d bytes) is too big ", thumbSize);
             return 0;
         }

         memcpy(pIfdStart + LongerTagOffest,
                thumbBuf, thumbSize);
         LongerTagOffest += thumbSize;
     } else {
         tmp = 0;
         /* NEXT IFD offset skipped on 0th IFD */
         memcpy(pNextIfdOffset, &tmp, OFFSET_SIZE);
     }

     unsigned char App1Marker[2] = {0xff, 0xe1};
     memcpy(pApp1Start, App1Marker, 2);
     pApp1Start += 2;

     uint32_t size = 10 + LongerTagOffest;
     /* APP1 Maker isn't counted */
     tmp = size - 2;
     unsigned char size_le[2] = {(unsigned char)((tmp >> 8) & 0xFF), (unsigned char)(tmp & 0xFF)};
     memcpy(pApp1Start, size_le, 2);

     ALOGV("makeExif X: size %d byte", size);
     return size;
 }

 inline void Exif::writeExifIfd(unsigned char **pCur,
                                  unsigned short tag,
                                  unsigned short type,
                                  unsigned int count,
                                  uint32_t value)
 {
     memcpy(*pCur, &tag, 2);
     *pCur += 2;
     memcpy(*pCur, &type, 2);
     *pCur += 2;
     memcpy(*pCur, &count, 4);
     *pCur += 4;
     memcpy(*pCur, &value, 4);
     *pCur += 4;
 }

 inline void Exif::writeExifIfd(unsigned char **pCur,
                                  unsigned short tag,
                                  unsigned short type,
                                  unsigned int count,
                                  unsigned char *pValue)
 {
     char buf[4] = {0,};
     memcpy(buf, pValue, count);
     memcpy(*pCur, &tag, 2);
     *pCur += 2;
     memcpy(*pCur, &type, 2);
     *pCur += 2;
     memcpy(*pCur, &count, 4);
     *pCur += 4;
     memcpy(*pCur, buf, 4);
     *pCur += 4;
 }


 inline void Exif::writeExifIfd(unsigned char **pCur,
                                  unsigned short tag,
                                  unsigned short type,
                                  unsigned int count,
                                  unsigned char *pValue,
                                  unsigned int *offset,
                                  unsigned char *start)
 {
     memcpy(*pCur, &tag, 2);
     *pCur += 2;
     memcpy(*pCur, &type, 2);
     *pCur += 2;
     memcpy(*pCur, &count, 4);
     *pCur += 4;
     memcpy(*pCur, offset, 4);
     *pCur += 4;
     memcpy(start + *offset, pValue, count);
     *offset += count;
 }

 inline void Exif::writeExifIfd(unsigned char **pCur,
                                  unsigned short tag,
                                  unsigned short type,
                                  unsigned int count,
                                  rational_t *pValue,
                                  unsigned int *offset,
                                  unsigned char *start)
 {
     memcpy(*pCur, &tag, 2);
     *pCur += 2;
     memcpy(*pCur, &type, 2);
     *pCur += 2;
     memcpy(*pCur, &count, 4);
     *pCur += 4;
     memcpy(*pCur, offset, 4);
     *pCur += 4;
     memcpy(start + *offset, pValue, 8 * count);
     *offset += 8 * count;
 }

 };
	/*
	* Copyright 2008, The Android Open Source Project
	* Copyright 2013, Samsung Electronics Co. LTD
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	/*!
	* \file Exif.cpp
	* \brief source file for Android Camera Ext HAL
	* \author teahyung kim (tkon.kim@samsung.com)
	* \date 2013/04/30
	*
	*/

	#define LOG_TAG "Exif"

	#include <cutils/compiler.h>
	#include <utils/Log.h>
	#include <fcntl.h>

	#include <camera/Camera.h>

	#include "Exif.h"

	namespace android {
	#define CLEAR(x) memset(&(x), 0, sizeof(x))

	const char Exif::DEFAULT_MAKER[] = "SAMSUNG";
	const char Exif::DEFAULT_MODEL[] = "Exynos";
	const char Exif::DEFAULT_SOFTWARE[] = "Exif Software Version 1.0.2.0";
	const char Exif::DEFAULT_EXIF_VERSION[] = "0220";
	const char Exif::DEFAULT_USERCOMMENTS[] = "User comments";

	const int Exif::DEFAULT_YCBCR_POSITIONING = 1;

	const int Exif::DEFAULT_EXPOSURE_PROGRAM = 2;

	const int Exif::DEFAULT_FLASH = 0;
	const int Exif::DEFAULT_COLOR_SPACE = 1;
	const int Exif::DEFAULT_EXPOSURE_MODE = EXIF_EXPOSURE_AUTO;
	const int Exif::DEFAULT_APEX_DEN = 100;
	const int Exif::DEFAULT_SENSING_METHOD = 2;

	const int Exif::DEFAULT_COMPRESSION = 6;
	const int Exif::DEFAULT_RESOLUTION_NUM = 72;
	const int Exif::DEFAULT_RESOLUTION_DEN = 1;
	const int Exif::DEFAULT_RESOLUTION_UNIT = 2;

	const int Exif::DEFAULT_CONTINUOUS_SHOT_INFO = 0;
	Exif::Exif(int cameraId, int CameraType)
	{
	mCameraId = cameraId;
	mCameraType = CameraType;

	mNum0thIfdTiff = 10;

	if (cameraId == CAMERA_FACING_BACK) {
	if (mCameraType == CAMERA_TYPE_SOC)
	mNum0thIfdExif = 23;
	else
	mNum0thIfdExif = 27;
	} else {
	mNum0thIfdExif = 14;
	}

	mNum0thIfdGps = 10;
	mNum1thIfdTiff = 9;
	}

	Exif::~Exif()
	{
	}

	uint32_t Exif::make(void *exifOutBuf,
	exif_attribute_t *exifInfo,
	unsigned int exifOutBufSize,
	unsigned char *thumbBuf,
	unsigned int thumbSize)
	{
	ALOGV("makeExif E");

	unsigned char pCur, pApp1Start, pIfdStart, pGpsIfdPtr, *pNextIfdOffset;
	unsigned int tmp, LongerTagOffest = 0;
	pApp1Start = pCur = (unsigned char *)exifOutBuf;

	/* Exif Identifier Code & TIFF Header */
	pCur += 4;
	/* Skip 4 Byte for APP1 marker and length */
	unsigned char ExifIdentifierCode[6] = {0x45, 0x78, 0x69, 0x66, 0x00, 0x00};
	memcpy(pCur, ExifIdentifierCode, 6);
	pCur += 6;

	/* Byte Order - little endian, Offset of IFD - 0x00000008.H */
	unsigned char TiffHeader[8] = {0x49, 0x49, 0x2A, 0x00, 0x08, 0x00, 0x00, 0x00};
	memcpy(pCur, TiffHeader, 8);
	pIfdStart = pCur;
	pCur += 8;

	const char asciiPrefix[] = {0x41, 0x53, 0x43, 0x49, 0x49, 0x0, 0x0, 0x0};
	unsigned char tmpBuf[256] = {0, };
	size_t len;

	/* 0th IFD TIFF Tags */
	if (exifInfo->enableGps)
	tmp = mNum0thIfdTiff;
	else
	tmp = mNum0thIfdTiff - 1;

	memcpy(pCur, &tmp, NUM_SIZE);
	pCur += NUM_SIZE;

	LongerTagOffest += 8 + NUM_SIZE + tmp * IFD_SIZE + OFFSET_SIZE;

	writeExifIfd(&pCur, EXIF_TAG_IMAGE_WIDTH, EXIF_TYPE_LONG,
	1, exifInfo->width);
	writeExifIfd(&pCur, EXIF_TAG_IMAGE_HEIGHT, EXIF_TYPE_LONG,
	1, exifInfo->height);
	writeExifIfd(&pCur, EXIF_TAG_MAKE, EXIF_TYPE_ASCII,
	strlen((char *)exifInfo->maker) + 1, exifInfo->maker, &LongerTagOffest, pIfdStart);
	writeExifIfd(&pCur, EXIF_TAG_MODEL, EXIF_TYPE_ASCII,
	strlen((char *)exifInfo->model) + 1, exifInfo->model, &LongerTagOffest, pIfdStart);
	writeExifIfd(&pCur, EXIF_TAG_ORIENTATION, EXIF_TYPE_SHORT,
	1, exifInfo->orientation);

	if (CAMERA_TYPE_ISP == mCameraType) {
	writeExifIfd(&pCur, EXIF_TAG_SOFTWARE, EXIF_TYPE_ASCII,
	strlen((char *)exifInfo->software) + 1, exifInfo->software, &LongerTagOffest, pIfdStart);
	} else {
	writeExifIfd(&pCur, EXIF_TAG_SOFTWARE, EXIF_TYPE_ASCII,
	1, exifInfo->software, &LongerTagOffest, pIfdStart);
	}

	writeExifIfd(&pCur, EXIF_TAG_DATE_TIME, EXIF_TYPE_ASCII,
	20, exifInfo->date_time, &LongerTagOffest, pIfdStart);
	writeExifIfd(&pCur, EXIF_TAG_YCBCR_POSITIONING, EXIF_TYPE_SHORT,
	1, exifInfo->ycbcr_positioning);
	writeExifIfd(&pCur, EXIF_TAG_EXIF_IFD_POINTER, EXIF_TYPE_LONG,
	1, LongerTagOffest);
	if (exifInfo->enableGps) {
	pGpsIfdPtr = pCur;
	/* Skip a ifd size for gps IFD pointer */
	pCur += IFD_SIZE;
	}

	/* Skip a offset size for next IFD offset */
	pNextIfdOffset = pCur;
	pCur += OFFSET_SIZE;

	/* 0th IFD Exif Private Tags */
	pCur = pIfdStart + LongerTagOffest;

	tmp = mNum0thIfdExif;
	memcpy(pCur, &tmp , NUM_SIZE);
	pCur += NUM_SIZE;

	LongerTagOffest += NUM_SIZE + mNum0thIfdExif*IFD_SIZE + OFFSET_SIZE;

	writeExifIfd(&pCur, EXIF_TAG_EXPOSURE_TIME, EXIF_TYPE_RATIONAL,
	1, &exifInfo->exposure_time, &LongerTagOffest, pIfdStart);
	writeExifIfd(&pCur, EXIF_TAG_FNUMBER, EXIF_TYPE_RATIONAL,
	1, &exifInfo->fnumber, &LongerTagOffest, pIfdStart);
	writeExifIfd(&pCur, EXIF_TAG_EXPOSURE_PROGRAM, EXIF_TYPE_SHORT,
	1, exifInfo->exposure_program);
	writeExifIfd(&pCur, EXIF_TAG_ISO_SPEED_RATING, EXIF_TYPE_SHORT,
	1, exifInfo->iso_speed_rating);
	writeExifIfd(&pCur, EXIF_TAG_EXIF_VERSION, EXIF_TYPE_UNDEFINED,
	4, exifInfo->exif_version);
	writeExifIfd(&pCur, EXIF_TAG_DATE_TIME_ORG, EXIF_TYPE_ASCII,
	20, exifInfo->date_time, &LongerTagOffest, pIfdStart);
	writeExifIfd(&pCur, EXIF_TAG_DATE_TIME_DIGITIZE, EXIF_TYPE_ASCII,
	20, exifInfo->date_time, &LongerTagOffest, pIfdStart);

	if (mCameraId == CAMERA_FACING_BACK) {
	if (CAMERA_TYPE_ISP == mCameraType) {
	writeExifIfd(&pCur, EXIF_TAG_SHUTTER_SPEED, EXIF_TYPE_SRATIONAL,
	1, (rational_t *)&exifInfo->shutter_speed, &LongerTagOffest, pIfdStart);
	writeExifIfd(&pCur, EXIF_TAG_APERTURE, EXIF_TYPE_RATIONAL,
	1, &exifInfo->aperture, &LongerTagOffest, pIfdStart);
	writeExifIfd(&pCur, EXIF_TAG_BRIGHTNESS, EXIF_TYPE_SRATIONAL,
	1, (rational_t *)&exifInfo->brightness, &LongerTagOffest, pIfdStart);
	writeExifIfd(&pCur, EXIF_TAG_EXPOSURE_BIAS, EXIF_TYPE_SRATIONAL,
	1, (rational_t *)&exifInfo->exposure_bias, &LongerTagOffest, pIfdStart);
	}

	writeExifIfd(&pCur, EXIF_TAG_MAX_APERTURE, EXIF_TYPE_RATIONAL,
	1, &exifInfo->max_aperture, &LongerTagOffest, pIfdStart);
	writeExifIfd(&pCur, EXIF_TAG_DIGITAL_ZOOM_RATIO, EXIF_TYPE_RATIONAL,
	1, &exifInfo->digital_zoom_ratio, &LongerTagOffest, pIfdStart);
	writeExifIfd(&pCur, EXIF_TAG_METERING_MODE, EXIF_TYPE_SHORT,
	1, exifInfo->metering_mode);
	writeExifIfd(&pCur, EXIF_TAG_LIGHT_SOURCE, EXIF_TYPE_SHORT,
	1, exifInfo->light_source);
	writeExifIfd(&pCur, EXIF_TAG_FLASH, EXIF_TYPE_SHORT,
	1, exifInfo->flash);
	writeExifIfd(&pCur, EXIF_TAG_FOCAL_35mm_LENGTH, EXIF_TYPE_SHORT,
	1, exifInfo->focal_35mm_length);
	}

	writeExifIfd(&pCur, EXIF_TAG_FOCAL_LENGTH, EXIF_TYPE_RATIONAL,
	1, &exifInfo->focal_length, &LongerTagOffest, pIfdStart);
	CLEAR(tmpBuf);
	len = strlen((char *)exifInfo->user_comment) + 1;
	memcpy(tmpBuf, asciiPrefix, sizeof(asciiPrefix));
	memcpy(tmpBuf + sizeof(asciiPrefix), exifInfo->user_comment, len);
	writeExifIfd(&pCur, EXIF_TAG_USER_COMMENT, EXIF_TYPE_UNDEFINED,
	len + sizeof(asciiPrefix), tmpBuf, &LongerTagOffest, pIfdStart);
	writeExifIfd(&pCur, EXIF_TAG_COLOR_SPACE, EXIF_TYPE_SHORT,
	1, exifInfo->color_space);
	writeExifIfd(&pCur, EXIF_TAG_PIXEL_X_DIMENSION, EXIF_TYPE_LONG,
	1, exifInfo->width);
	writeExifIfd(&pCur, EXIF_TAG_PIXEL_Y_DIMENSION, EXIF_TYPE_LONG,
	1, exifInfo->height);
	writeExifIfd(&pCur, EXIF_TAG_EXPOSURE_MODE, EXIF_TYPE_LONG,
	1, exifInfo->exposure_mode);
	writeExifIfd(&pCur, EXIF_TAG_WHITE_BALANCE, EXIF_TYPE_LONG,
	1, exifInfo->white_balance);
	if (mCameraId == CAMERA_FACING_BACK) {
	writeExifIfd(&pCur, EXIF_TAG_SCENCE_CAPTURE_TYPE, EXIF_TYPE_LONG,
	1, exifInfo->scene_capture_type);
	writeExifIfd(&pCur, EXIF_TAG_IMAGE_UNIQUE_ID, EXIF_TYPE_ASCII,
	12, exifInfo->unique_id, &LongerTagOffest, pIfdStart);
	writeExifIfd(&pCur, EXIF_TAG_SENSING_METHOD, EXIF_TYPE_SHORT,
	1, exifInfo->sensing_method);
	}

	tmp = 0;
	/* next IFD offset */
	memcpy(pCur, &tmp, OFFSET_SIZE);
	pCur += OFFSET_SIZE;

	/* 0th IFD GPS Info Tags */
	if (exifInfo->enableGps) {
	/* GPS IFD pointer skipped on 0th IFD */
	writeExifIfd(&pGpsIfdPtr, EXIF_TAG_GPS_IFD_POINTER, EXIF_TYPE_LONG,
	1, LongerTagOffest);

	pCur = pIfdStart + LongerTagOffest;

	tmp = mNum0thIfdGps;
	memcpy(pCur, &tmp, NUM_SIZE);
	pCur += NUM_SIZE;

	LongerTagOffest += NUM_SIZE + mNum0thIfdGps * IFD_SIZE + OFFSET_SIZE;

	writeExifIfd(&pCur, EXIF_TAG_GPS_VERSION_ID, EXIF_TYPE_BYTE,
	4, exifInfo->gps_version_id);
	writeExifIfd(&pCur, EXIF_TAG_GPS_LATITUDE_REF, EXIF_TYPE_ASCII,
	2, exifInfo->gps_latitude_ref);
	writeExifIfd(&pCur, EXIF_TAG_GPS_LATITUDE, EXIF_TYPE_RATIONAL,
	3, exifInfo->gps_latitude, &LongerTagOffest, pIfdStart);
	writeExifIfd(&pCur, EXIF_TAG_GPS_LONGITUDE_REF, EXIF_TYPE_ASCII,
	2, exifInfo->gps_longitude_ref);
	writeExifIfd(&pCur, EXIF_TAG_GPS_LONGITUDE, EXIF_TYPE_RATIONAL,
	3, exifInfo->gps_longitude, &LongerTagOffest, pIfdStart);
	writeExifIfd(&pCur, EXIF_TAG_GPS_ALTITUDE_REF, EXIF_TYPE_BYTE,
	1, exifInfo->gps_altitude_ref);
	writeExifIfd(&pCur, EXIF_TAG_GPS_ALTITUDE, EXIF_TYPE_RATIONAL,
	1, &exifInfo->gps_altitude, &LongerTagOffest, pIfdStart);
	writeExifIfd(&pCur, EXIF_TAG_GPS_TIMESTAMP, EXIF_TYPE_RATIONAL,
	3, exifInfo->gps_timestamp, &LongerTagOffest, pIfdStart);
	CLEAR(tmpBuf);
	len = strlen((char *)exifInfo->gps_processing_method);
	memcpy(tmpBuf, asciiPrefix, sizeof(asciiPrefix));
	memcpy(tmpBuf + sizeof(asciiPrefix), exifInfo->gps_processing_method, len);
	writeExifIfd(&pCur, EXIF_TAG_GPS_PROCESSING_METHOD, EXIF_TYPE_UNDEFINED,
	len + sizeof(asciiPrefix), tmpBuf, &LongerTagOffest, pIfdStart);
	writeExifIfd(&pCur, EXIF_TAG_GPS_DATESTAMP, EXIF_TYPE_ASCII,
	11, exifInfo->gps_datestamp, &LongerTagOffest, pIfdStart);
	tmp = 0;
	/* next IFD offset */
	memcpy(pCur, &tmp, OFFSET_SIZE);
	pCur += OFFSET_SIZE;
	}

	/* 1th IFD TIFF Tags */
	if ((thumbBuf != NULL) && (thumbSize > 0)) {
	if (CC_UNLIKELY(!exifOutBufSize)) {
	ALOGE("makeExif: error, exifOutBufSize is zero");
	return 0;
	}

	tmp = LongerTagOffest;
	/* NEXT IFD offset skipped on 0th IFD */
	memcpy(pNextIfdOffset, &tmp, OFFSET_SIZE);

	pCur = pIfdStart + LongerTagOffest;

	tmp = mNum1thIfdTiff;
	memcpy(pCur, &tmp, NUM_SIZE);
	pCur += NUM_SIZE;

	LongerTagOffest += NUM_SIZE + mNum1thIfdTiff * IFD_SIZE + OFFSET_SIZE;

	writeExifIfd(&pCur, EXIF_TAG_IMAGE_WIDTH, EXIF_TYPE_LONG,
	1, exifInfo->widthThumb);
	writeExifIfd(&pCur, EXIF_TAG_IMAGE_HEIGHT, EXIF_TYPE_LONG,
	1, exifInfo->heightThumb);
	writeExifIfd(&pCur, EXIF_TAG_COMPRESSION_SCHEME, EXIF_TYPE_SHORT,
	1, exifInfo->compression_scheme);
	writeExifIfd(&pCur, EXIF_TAG_ORIENTATION, EXIF_TYPE_SHORT,
	1, exifInfo->orientation);
	writeExifIfd(&pCur, EXIF_TAG_X_RESOLUTION, EXIF_TYPE_RATIONAL,
	1, &exifInfo->x_resolution, &LongerTagOffest, pIfdStart);
	writeExifIfd(&pCur, EXIF_TAG_Y_RESOLUTION, EXIF_TYPE_RATIONAL,
	1, &exifInfo->y_resolution, &LongerTagOffest, pIfdStart);
	writeExifIfd(&pCur, EXIF_TAG_RESOLUTION_UNIT, EXIF_TYPE_SHORT,
	1, exifInfo->resolution_unit);
	writeExifIfd(&pCur, EXIF_TAG_JPEG_INTERCHANGE_FORMAT, EXIF_TYPE_LONG,
	1, LongerTagOffest);
	writeExifIfd(&pCur, EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LEN, EXIF_TYPE_LONG,
	1, thumbSize);

	tmp = 0;
	/* next IFD offset */
	memcpy(pCur, &tmp, OFFSET_SIZE);
	pCur += OFFSET_SIZE;

	if (CC_UNLIKELY(pIfdStart + LongerTagOffest + thumbSize >= (void *)((uint32_t)exifOutBuf + exifOutBufSize))) {
	ALOGE("makeExif: error, thumbnail size(%d bytes) is too big ", thumbSize);
	return 0;
	}

	memcpy(pIfdStart + LongerTagOffest,
	thumbBuf, thumbSize);
	LongerTagOffest += thumbSize;
	} else {
	tmp = 0;
	/* NEXT IFD offset skipped on 0th IFD */
	memcpy(pNextIfdOffset, &tmp, OFFSET_SIZE);
	}

	unsigned char App1Marker[2] = {0xff, 0xe1};
	memcpy(pApp1Start, App1Marker, 2);
	pApp1Start += 2;

	uint32_t size = 10 + LongerTagOffest;
	/* APP1 Maker isn't counted */
	tmp = size - 2;
	unsigned char size_le[2] = {(unsigned char)((tmp >> 8) & 0xFF), (unsigned char)(tmp & 0xFF)};
	memcpy(pApp1Start, size_le, 2);

	ALOGV("makeExif X: size %d byte", size);
	return size;
	}

	inline void Exif::writeExifIfd(unsigned char **pCur,
	unsigned short tag,
	unsigned short type,
	unsigned int count,
	uint32_t value)
	{
	memcpy(*pCur, &tag, 2);
	*pCur += 2;
	memcpy(*pCur, &type, 2);
	*pCur += 2;
	memcpy(*pCur, &count, 4);
	*pCur += 4;
	memcpy(*pCur, &value, 4);
	*pCur += 4;
	}

	inline void Exif::writeExifIfd(unsigned char **pCur,
	unsigned short tag,
	unsigned short type,
	unsigned int count,
	unsigned char *pValue)
	{
	char buf[4] = {0,};
	memcpy(buf, pValue, count);
	memcpy(*pCur, &tag, 2);
	*pCur += 2;
	memcpy(*pCur, &type, 2);
	*pCur += 2;
	memcpy(*pCur, &count, 4);
	*pCur += 4;
	memcpy(*pCur, buf, 4);
	*pCur += 4;
	}


	inline void Exif::writeExifIfd(unsigned char **pCur,
	unsigned short tag,
	unsigned short type,
	unsigned int count,
	unsigned char *pValue,
	unsigned int *offset,
	unsigned char *start)
	{
	memcpy(*pCur, &tag, 2);
	*pCur += 2;
	memcpy(*pCur, &type, 2);
	*pCur += 2;
	memcpy(*pCur, &count, 4);
	*pCur += 4;
	memcpy(*pCur, offset, 4);
	*pCur += 4;
	memcpy(start + *offset, pValue, count);
	*offset += count;
	}

	inline void Exif::writeExifIfd(unsigned char **pCur,
	unsigned short tag,
	unsigned short type,
	unsigned int count,
	rational_t *pValue,
	unsigned int *offset,
	unsigned char *start)
	{
	memcpy(*pCur, &tag, 2);
	*pCur += 2;
	memcpy(*pCur, &type, 2);
	*pCur += 2;
	memcpy(*pCur, &count, 4);
	*pCur += 4;
	memcpy(*pCur, offset, 4);
	*pCur += 4;
	memcpy(start + offset, pValue, 8 count);
	offset += 8 count;
	}

	};