| /* |
| * Copyright Samsung Electronics Co.,LTD. |
| * Copyright (C) 2010 The Android Open Source Project |
| * |
| * 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. |
| * |
| * JPEG DRIVER MODULE (JpegEncoder.cpp) |
| * Author : ge.lee -- initial version |
| * Date : 03 June 2010 |
| * Purpose : This file implements the JPEG encoder APIs as needed by Camera HAL |
| */ |
| #define LOG_TAG "JpegEncoder" |
| #define MAIN_DUMP 0 |
| #define THUMB_DUMP 0 |
| |
| #include <utils/Log.h> |
| #include <sys/mman.h> |
| #include <fcntl.h> |
| |
| #include "JpegEncoder.h" |
| |
| static const char ExifAsciiPrefix[] = { 0x41, 0x53, 0x43, 0x49, 0x49, 0x0, 0x0, 0x0 }; |
| |
| namespace android { |
| JpegEncoder::JpegEncoder() : available(false) |
| { |
| mArgs.mmapped_addr = (char *)MAP_FAILED; |
| mArgs.enc_param = NULL; |
| mArgs.thumb_enc_param = NULL; |
| |
| mDevFd = open(JPG_DRIVER_NAME, O_RDWR); |
| if (mDevFd < 0) { |
| ALOGE("Failed to open the device"); |
| return; |
| } |
| |
| mArgs.mmapped_addr = (char *)mmap(0, |
| JPG_TOTAL_BUF_SIZE, |
| PROT_READ | PROT_WRITE, |
| MAP_SHARED, |
| mDevFd, |
| 0); |
| |
| if (mArgs.mmapped_addr == MAP_FAILED) { |
| ALOGE("Failed to mmap"); |
| return; |
| } |
| |
| mArgs.enc_param = new jpg_enc_proc_param; |
| if (mArgs.enc_param == NULL) { |
| ALOGE("Failed to allocate the memory for enc_param"); |
| return; |
| } |
| memset(mArgs.enc_param, 0, sizeof(jpg_enc_proc_param)); |
| |
| mArgs.thumb_enc_param = new jpg_enc_proc_param; |
| if (mArgs.thumb_enc_param == NULL) { |
| ALOGE("Failed to allocate the memory for thumb_enc_param"); |
| delete mArgs.enc_param; |
| return; |
| } |
| memset(mArgs.thumb_enc_param, 0, sizeof(jpg_enc_proc_param)); |
| |
| mArgs.enc_param->sample_mode = JPG_420; |
| mArgs.enc_param->enc_type = JPG_MAIN; |
| mArgs.thumb_enc_param->sample_mode = JPG_420; |
| mArgs.thumb_enc_param->enc_type = JPG_THUMBNAIL; |
| |
| available = true; |
| } |
| |
| JpegEncoder::~JpegEncoder() |
| { |
| if (mArgs.mmapped_addr != (char*)MAP_FAILED) |
| munmap(mArgs.mmapped_addr, JPG_TOTAL_BUF_SIZE); |
| |
| delete mArgs.enc_param; |
| |
| delete mArgs.thumb_enc_param; |
| |
| if (mDevFd > 0) |
| close(mDevFd); |
| } |
| |
| jpg_return_status JpegEncoder::setConfig(jpeg_conf type, int32_t value) |
| { |
| if (!available) |
| return JPG_FAIL; |
| |
| jpg_return_status ret = JPG_SUCCESS; |
| |
| switch (type) { |
| case JPEG_SET_ENCODE_WIDTH: |
| if (value < 0 || value > MAX_JPG_WIDTH) |
| ret = JPG_FAIL; |
| else |
| mArgs.enc_param->width = value; |
| break; |
| |
| case JPEG_SET_ENCODE_HEIGHT: |
| if (value < 0 || value > MAX_JPG_HEIGHT) |
| ret = JPG_FAIL; |
| else |
| mArgs.enc_param->height = value; |
| break; |
| |
| case JPEG_SET_ENCODE_QUALITY: |
| if (value < JPG_QUALITY_LEVEL_1 || value > JPG_QUALITY_LEVEL_4) |
| ret = JPG_FAIL; |
| else |
| mArgs.enc_param->quality = (image_quality_type_t)value; |
| break; |
| |
| case JPEG_SET_ENCODE_IN_FORMAT: |
| if (value != JPG_MODESEL_YCBCR && value != JPG_MODESEL_RGB) { |
| ret = JPG_FAIL; |
| } else { |
| mArgs.enc_param->in_format = (in_mode_t)value; |
| mArgs.thumb_enc_param->in_format = (in_mode_t)value; |
| } |
| break; |
| |
| case JPEG_SET_SAMPING_MODE: |
| if (value != JPG_420 && value != JPG_422) { |
| ret = JPG_FAIL; |
| } else { |
| mArgs.enc_param->sample_mode = (sample_mode_t)value; |
| mArgs.thumb_enc_param->sample_mode = (sample_mode_t)value; |
| } |
| break; |
| |
| case JPEG_SET_THUMBNAIL_WIDTH: |
| if (value < 0 || value > MAX_JPG_THUMBNAIL_WIDTH) |
| ret = JPG_FAIL; |
| else |
| mArgs.thumb_enc_param->width = value; |
| break; |
| |
| case JPEG_SET_THUMBNAIL_HEIGHT: |
| if (value < 0 || value > MAX_JPG_THUMBNAIL_HEIGHT) |
| ret = JPG_FAIL; |
| else |
| mArgs.thumb_enc_param->height = value; |
| break; |
| |
| default: |
| ALOGE("Invalid Config type"); |
| ret = ERR_UNKNOWN; |
| } |
| |
| if (ret == JPG_FAIL) |
| ALOGE("Invalid value(%d) for %d type", value, type); |
| |
| return ret; |
| } |
| |
| void* JpegEncoder::getInBuf(uint64_t size) |
| { |
| if (!available) |
| return NULL; |
| |
| if (size > JPG_FRAME_BUF_SIZE) { |
| ALOGE("The buffer size requested is too large"); |
| return NULL; |
| } |
| mArgs.in_buf = (char *)ioctl(mDevFd, IOCTL_JPG_GET_FRMBUF, mArgs.mmapped_addr); |
| return (void *)(mArgs.in_buf); |
| } |
| |
| void* JpegEncoder::getOutBuf(uint64_t *size) |
| { |
| if (!available) |
| return NULL; |
| |
| if (mArgs.enc_param->file_size <= 0) { |
| ALOGE("The buffer requested doesn't have data"); |
| return NULL; |
| } |
| mArgs.out_buf = (char *)ioctl(mDevFd, IOCTL_JPG_GET_STRBUF, mArgs.mmapped_addr); |
| *size = mArgs.enc_param->file_size; |
| return (void *)(mArgs.out_buf); |
| } |
| |
| void* JpegEncoder::getThumbInBuf(uint64_t size) |
| { |
| if (!available) |
| return NULL; |
| |
| if (size > JPG_FRAME_THUMB_BUF_SIZE) { |
| ALOGE("The buffer size requested is too large"); |
| return NULL; |
| } |
| mArgs.in_thumb_buf = (char *)ioctl(mDevFd, IOCTL_JPG_GET_THUMB_FRMBUF, mArgs.mmapped_addr); |
| return (void *)(mArgs.in_thumb_buf); |
| } |
| |
| void* JpegEncoder::getThumbOutBuf(uint64_t *size) |
| { |
| if (!available) |
| return NULL; |
| |
| if (mArgs.thumb_enc_param->file_size <= 0) { |
| ALOGE("The buffer requested doesn't have data"); |
| return NULL; |
| } |
| mArgs.out_thumb_buf = (char *)ioctl(mDevFd, IOCTL_JPG_GET_THUMB_STRBUF, mArgs.mmapped_addr); |
| *size = mArgs.thumb_enc_param->file_size; |
| return (void *)(mArgs.out_thumb_buf); |
| } |
| |
| jpg_return_status JpegEncoder::encode(unsigned int *size, exif_attribute_t *exifInfo) |
| { |
| if (!available) |
| return JPG_FAIL; |
| |
| ALOGD("encode E"); |
| |
| jpg_return_status ret = JPG_FAIL; |
| unsigned char *exifOut = NULL; |
| jpg_enc_proc_param *param = mArgs.enc_param; |
| |
| ret = checkMcu(param->sample_mode, param->width, param->height, false); |
| if (ret != JPG_SUCCESS) |
| return ret; |
| |
| param->enc_type = JPG_MAIN; |
| ret = (jpg_return_status)ioctl(mDevFd, IOCTL_JPG_ENCODE, &mArgs); |
| if (ret != JPG_SUCCESS) { |
| ALOGE("Failed to encode main image"); |
| return ret; |
| } |
| |
| mArgs.out_buf = (char *)ioctl(mDevFd, IOCTL_JPG_GET_STRBUF, mArgs.mmapped_addr); |
| |
| if (exifInfo) { |
| unsigned int thumbLen, exifLen; |
| |
| uint_t bufSize = 0; |
| if (exifInfo->enableThumb) { |
| ret = encodeThumbImg(&thumbLen); |
| if (ret != JPG_SUCCESS) { |
| ALOGE("Failed to encode for thumbnail image"); |
| bufSize = EXIF_FILE_SIZE; |
| exifInfo->enableThumb = false; |
| } else { |
| bufSize = EXIF_FILE_SIZE + thumbLen; |
| } |
| } else { |
| bufSize = EXIF_FILE_SIZE; |
| } |
| |
| if (mArgs.enc_param->file_size + bufSize > JPG_TOTAL_BUF_SIZE) |
| return ret; |
| |
| exifOut = new unsigned char[bufSize]; |
| if (exifOut == NULL) { |
| ALOGE("Failed to allocate for exifOut"); |
| return ret; |
| } |
| memset(exifOut, 0, bufSize); |
| |
| ret = makeExif (exifOut, exifInfo, &exifLen); |
| if (ret != JPG_SUCCESS) { |
| ALOGE("Failed to make EXIF"); |
| delete[] exifOut; |
| return ret; |
| } |
| |
| memmove(&mArgs.out_buf[exifLen + 2], &mArgs.out_buf[2], param->file_size - 2); |
| memcpy(&mArgs.out_buf[2], exifOut, exifLen); |
| param->file_size += exifLen; |
| } |
| |
| delete[] exifOut; |
| |
| *size = param->file_size; |
| |
| #if MAIN_DUMP |
| FILE *fout = NULL; |
| char file_name[50] = "/data/main.jpg"; |
| fout = fopen(file_name, "wb"); |
| if (!fout) |
| perror(&file_name[0]); |
| size_t nwrite = fwrite(mArgs.out_buf, sizeof(char), param->file_size, fout); |
| fclose(fout); |
| #endif |
| |
| ALOGD("encode X"); |
| |
| return ret; |
| } |
| |
| jpg_return_status JpegEncoder::encodeThumbImg(unsigned int *size, bool useMain) |
| { |
| if (!available) |
| return JPG_FAIL; |
| |
| ALOGD("encodeThumbImg E"); |
| |
| jpg_return_status ret = JPG_FAIL; |
| jpg_enc_proc_param *param = mArgs.thumb_enc_param; |
| |
| if (useMain) { |
| mArgs.in_thumb_buf = (char *)getThumbInBuf(param->width*param->height*2); |
| if (mArgs.in_thumb_buf == NULL) { |
| ALOGE("Failed to get the buffer for thumbnail"); |
| return JPG_FAIL; |
| } |
| |
| ret = (jpg_return_status)scaleDownYuv422(mArgs.in_buf, |
| mArgs.enc_param->width, |
| mArgs.enc_param->height, |
| mArgs.in_thumb_buf, |
| param->width, |
| param->height); |
| if (ret != JPG_SUCCESS) |
| return JPG_FAIL; |
| } |
| |
| ret = checkMcu(param->sample_mode, param->width, param->height, true); |
| if (ret != JPG_SUCCESS) |
| return JPG_FAIL; |
| |
| mArgs.enc_param->enc_type = JPG_THUMBNAIL; |
| ret = (jpg_return_status)ioctl(mDevFd, IOCTL_JPG_ENCODE, &mArgs); |
| if (ret != JPG_SUCCESS) { |
| ALOGE("Failed to encode for thumbnail"); |
| return JPG_FAIL; |
| } |
| |
| mArgs.out_thumb_buf = (char *)ioctl(mDevFd, IOCTL_JPG_GET_THUMB_STRBUF, mArgs.mmapped_addr); |
| |
| #if THUMB_DUMP |
| FILE *fout = NULL; |
| char file_name[50] = "/data/thumb.jpg"; |
| fout = fopen(file_name, "wb"); |
| if (!fout) |
| perror(&file_name[0]); |
| size_t nwrite = fwrite(mArgs.out_thumb_buf, sizeof(char), param->file_size, fout); |
| fclose(fout); |
| #endif |
| |
| ALOGD("encodeThumbImg X"); |
| |
| return JPG_SUCCESS; |
| } |
| |
| jpg_return_status JpegEncoder::makeExif (unsigned char *exifOut, |
| exif_attribute_t *exifInfo, |
| unsigned int *size, |
| bool useMainbufForThumb) |
| { |
| if (!available) |
| return JPG_FAIL; |
| |
| ALOGD("makeExif E"); |
| |
| unsigned char *pCur, *pApp1Start, *pIfdStart, *pGpsIfdPtr, *pNextIfdOffset; |
| unsigned int tmp, LongerTagOffest = 0; |
| pApp1Start = pCur = exifOut; |
| |
| //2 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; |
| |
| //2 0th IFD TIFF Tags |
| if (exifInfo->enableGps) |
| tmp = NUM_0TH_IFD_TIFF; |
| else |
| tmp = NUM_0TH_IFD_TIFF - 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); |
| writeExifIfd(&pCur, EXIF_TAG_SOFTWARE, EXIF_TYPE_ASCII, |
| strlen((char *)exifInfo->software) + 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; |
| pCur += IFD_SIZE; // Skip a ifd size for gps IFD pointer |
| } |
| |
| pNextIfdOffset = pCur; // Skip a offset size for next IFD offset |
| pCur += OFFSET_SIZE; |
| |
| //2 0th IFD Exif Private Tags |
| pCur = pIfdStart + LongerTagOffest; |
| |
| tmp = NUM_0TH_IFD_EXIF; |
| memcpy(pCur, &tmp , NUM_SIZE); |
| pCur += NUM_SIZE; |
| |
| LongerTagOffest += NUM_SIZE + NUM_0TH_IFD_EXIF*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); |
| 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_METERING_MODE, EXIF_TYPE_SHORT, |
| 1, exifInfo->metering_mode); |
| writeExifIfd(&pCur, EXIF_TAG_FLASH, EXIF_TYPE_SHORT, |
| 1, exifInfo->flash); |
| writeExifIfd(&pCur, EXIF_TAG_FOCAL_LENGTH, EXIF_TYPE_RATIONAL, |
| 1, &exifInfo->focal_length, &LongerTagOffest, pIfdStart); |
| char code[8] = { 0x00, 0x00, 0x00, 0x49, 0x49, 0x43, 0x53, 0x41 }; |
| int commentsLen = strlen((char *)exifInfo->user_comment) + 1; |
| memmove(exifInfo->user_comment + sizeof(code), exifInfo->user_comment, commentsLen); |
| memcpy(exifInfo->user_comment, code, sizeof(code)); |
| writeExifIfd(&pCur, EXIF_TAG_USER_COMMENT, EXIF_TYPE_UNDEFINED, |
| commentsLen + sizeof(code), exifInfo->user_comment, &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); |
| writeExifIfd(&pCur, EXIF_TAG_SCENCE_CAPTURE_TYPE, EXIF_TYPE_LONG, |
| 1, exifInfo->scene_capture_type); |
| tmp = 0; |
| memcpy(pCur, &tmp, OFFSET_SIZE); // next IFD offset |
| pCur += OFFSET_SIZE; |
| |
| //2 0th IFD GPS Info Tags |
| if (exifInfo->enableGps) { |
| writeExifIfd(&pGpsIfdPtr, EXIF_TAG_GPS_IFD_POINTER, EXIF_TYPE_LONG, |
| 1, LongerTagOffest); // GPS IFD pointer skipped on 0th IFD |
| |
| pCur = pIfdStart + LongerTagOffest; |
| |
| if (exifInfo->gps_processing_method[0] == 0) { |
| // don't create GPS_PROCESSING_METHOD tag if there isn't any |
| tmp = NUM_0TH_IFD_GPS - 1; |
| } else { |
| tmp = NUM_0TH_IFD_GPS; |
| } |
| memcpy(pCur, &tmp, NUM_SIZE); |
| pCur += NUM_SIZE; |
| |
| LongerTagOffest += NUM_SIZE + tmp*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); |
| tmp = strlen((char*)exifInfo->gps_processing_method); |
| if (tmp > 0) { |
| if (tmp > 100) { |
| tmp = 100; |
| } |
| unsigned char tmp_buf[100+sizeof(ExifAsciiPrefix)]; |
| memcpy(tmp_buf, ExifAsciiPrefix, sizeof(ExifAsciiPrefix)); |
| memcpy(&tmp_buf[sizeof(ExifAsciiPrefix)], exifInfo->gps_processing_method, tmp); |
| writeExifIfd(&pCur, EXIF_TAG_GPS_PROCESSING_METHOD, EXIF_TYPE_UNDEFINED, |
| tmp+sizeof(ExifAsciiPrefix), tmp_buf, &LongerTagOffest, pIfdStart); |
| } |
| writeExifIfd(&pCur, EXIF_TAG_GPS_DATESTAMP, EXIF_TYPE_ASCII, |
| 11, exifInfo->gps_datestamp, &LongerTagOffest, pIfdStart); |
| tmp = 0; |
| memcpy(pCur, &tmp, OFFSET_SIZE); // next IFD offset |
| pCur += OFFSET_SIZE; |
| } |
| |
| //2 1th IFD TIFF Tags |
| char *thumbBuf; |
| int thumbSize; |
| |
| if (useMainbufForThumb) { |
| thumbBuf = mArgs.out_buf; |
| thumbSize = mArgs.enc_param->file_size; |
| } else { |
| thumbBuf = mArgs.out_thumb_buf; |
| thumbSize = mArgs.thumb_enc_param->file_size; |
| } |
| |
| if (exifInfo->enableThumb && (thumbBuf != NULL) && (thumbSize > 0)) { |
| tmp = LongerTagOffest; |
| memcpy(pNextIfdOffset, &tmp, OFFSET_SIZE); // NEXT IFD offset skipped on 0th IFD |
| |
| pCur = pIfdStart + LongerTagOffest; |
| |
| tmp = NUM_1TH_IFD_TIFF; |
| memcpy(pCur, &tmp, NUM_SIZE); |
| pCur += NUM_SIZE; |
| |
| LongerTagOffest += NUM_SIZE + NUM_1TH_IFD_TIFF*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; |
| memcpy(pCur, &tmp, OFFSET_SIZE); // next IFD offset |
| pCur += OFFSET_SIZE; |
| |
| memcpy(pIfdStart + LongerTagOffest, |
| thumbBuf, thumbSize); |
| LongerTagOffest += thumbSize; |
| } else { |
| tmp = 0; |
| memcpy(pNextIfdOffset, &tmp, OFFSET_SIZE); // NEXT IFD offset skipped on 0th IFD |
| } |
| |
| unsigned char App1Marker[2] = { 0xff, 0xe1 }; |
| memcpy(pApp1Start, App1Marker, 2); |
| pApp1Start += 2; |
| |
| *size = 10 + LongerTagOffest; |
| tmp = *size - 2; // APP1 Maker isn't counted |
| unsigned char size_mm[2] = {(tmp >> 8) & 0xFF, tmp & 0xFF}; |
| memcpy(pApp1Start, size_mm, 2); |
| |
| ALOGD("makeExif X"); |
| |
| return JPG_SUCCESS; |
| } |
| |
| jpg_return_status JpegEncoder::checkMcu(sample_mode_t sampleMode, |
| uint32_t width, uint32_t height, bool isThumb) |
| { |
| if (!available) |
| return JPG_FAIL; |
| |
| uint32_t expectedWidth = width; |
| uint32_t expectedHeight = height; |
| |
| switch (sampleMode){ |
| case JPG_422: |
| if (width % 16 != 0) |
| expectedWidth = width + 16 - (width % 16); |
| if (height % 8 != 0) |
| expectedHeight = height + 8 - (height % 8); |
| break; |
| |
| case JPG_420: |
| if (width % 16 != 0) |
| expectedWidth = width + 16 - (width % 16); |
| if (height % 16 != 0) |
| expectedHeight = height + 16 - (height % 16); |
| break; |
| |
| default: |
| ALOGE("Invaild sample mode"); |
| return JPG_FAIL; |
| } |
| |
| if (expectedWidth == width && expectedHeight == height) |
| return JPG_SUCCESS; |
| |
| ALOGW("The image is not matched for MCU"); |
| |
| uint32_t size = width*height * 2; |
| char *srcBuf, *dstBuf; |
| |
| if ((srcBuf = new char[size]) == NULL) { |
| ALOGE("Failed to allocate for srcBuf"); |
| return JPG_FAIL; |
| } |
| |
| if (!isThumb) |
| dstBuf = mArgs.in_buf; |
| else |
| dstBuf = mArgs.in_thumb_buf; |
| |
| memcpy(srcBuf, dstBuf, size); |
| bool ret = pad(srcBuf, width, height, dstBuf, expectedWidth, expectedHeight); |
| |
| delete[] srcBuf; |
| |
| return JPG_SUCCESS; |
| } |
| |
| bool JpegEncoder::pad(char *srcBuf, uint32_t srcWidth, uint32_t srcHight, |
| char *dstBuf, uint32_t dstWidth, uint32_t dstHight) |
| { |
| if (!available) |
| return false; |
| |
| if (srcBuf == NULL || dstBuf == NULL) { |
| ALOGE("srcBuf or dstBuf is NULL"); |
| return false; |
| } |
| |
| int padW = dstWidth - srcWidth; |
| int padH = dstHight - srcHight; |
| |
| if ((int)(dstWidth - srcWidth) < 0 || |
| (int)(dstHight - srcHight) < 0) { |
| ALOGE("dstSize is smaller than srcSize"); |
| return false; |
| } |
| memset(dstBuf, 0, dstWidth*dstHight * 2); |
| |
| for (uint32_t i = 0; i < srcHight; i++) |
| memcpy(dstBuf + i * dstWidth * 2, srcBuf + i * srcWidth * 2, srcWidth * 2); |
| |
| return true; |
| } |
| |
| bool JpegEncoder::scaleDownYuv422(char *srcBuf, uint32_t srcWidth, uint32_t srcHight, |
| char *dstBuf, uint32_t dstWidth, uint32_t dstHight) |
| { |
| if (!available) |
| return false; |
| |
| int32_t step_x, step_y; |
| int32_t iXsrc, iXdst; |
| int32_t x, y, src_y_start_pos, dst_pos, src_pos; |
| |
| if (dstWidth % 2 != 0 || dstHight % 2 != 0){ |
| ALOGE("scale_down_yuv422: invalid width, height for scaling"); |
| return false; |
| } |
| |
| step_x = srcWidth / dstWidth; |
| step_y = srcHight / dstHight; |
| |
| dst_pos = 0; |
| for (uint32_t y = 0; y < dstHight; y++) { |
| src_y_start_pos = (y * step_y * (srcWidth * 2)); |
| |
| for (uint32_t x = 0; x < dstWidth; x += 2) { |
| src_pos = src_y_start_pos + (x * (step_x * 2)); |
| |
| dstBuf[dst_pos++] = srcBuf[src_pos ]; |
| dstBuf[dst_pos++] = srcBuf[src_pos + 1]; |
| dstBuf[dst_pos++] = srcBuf[src_pos + 2]; |
| dstBuf[dst_pos++] = srcBuf[src_pos + 3]; |
| } |
| } |
| |
| return true; |
| } |
| |
| inline void JpegEncoder::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 JpegEncoder::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 JpegEncoder::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 JpegEncoder::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; |
| } |
| |
| }; |
