blob: d3dd2b3868dbaef85472f199ab43361606dd0fbb [file] [log] [blame]
/*
**
** Copyright 2008, The Android Open Source Project
** Copyright 2012, 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 MetadataConverter.cpp
* \brief source file for Metadata converter ( for camera hal2 implementation )
* \author Sungjoong Kang(sj3.kang@samsung.com)
* \date 2012/05/31
*
* <b>Revision History: </b>
* - 2012/05/31 : Sungjoong Kang(sj3.kang@samsung.com) \n
* Initial Release
*/
//#define LOG_NDEBUG 0
#define LOG_TAG "MetadataConverter"
#include <utils/Log.h>
#include "MetadataConverter.h"
#include "exynos_format.h"
namespace android {
MetadataConverter::MetadataConverter()
{
return;
}
MetadataConverter::~MetadataConverter()
{
ALOGV("DEBUG(%s)destroy!!:", __FUNCTION__);
return;
}
status_t MetadataConverter::CheckEntryTypeMismatch(camera_metadata_entry_t * entry,
uint8_t type)
{
if (!(entry->type==type))
{
ALOGV("DEBUG(%s):Metadata Missmatch tag(%s) type (%d) count(%d)",
__FUNCTION__, get_camera_metadata_tag_name(entry->tag), entry->type, entry->count);
return BAD_VALUE;
}
return NO_ERROR;
}
status_t MetadataConverter::CheckEntryTypeMismatch(camera_metadata_entry_t * entry,
uint8_t type, size_t count)
{
if (!((entry->type==type)&&(entry->count==count)))
{
ALOGV("DEBUG(%s):Metadata Missmatch tag(%s) type (%d) count(%d)",
__FUNCTION__, get_camera_metadata_tag_name(entry->tag), entry->type, entry->count);
return BAD_VALUE;
}
return NO_ERROR;
}
status_t MetadataConverter::ToInternalShot(camera_metadata_t * request, struct camera2_shot_ext * dst_ext)
{
uint32_t num_entry = 0;
uint32_t index = 0;
uint32_t i = 0;
uint32_t cnt = 0;
camera_metadata_entry_t curr_entry;
struct camera2_shot * dst = NULL;
if (request == NULL || dst_ext == NULL)
return BAD_VALUE;
memset((void*)dst_ext, 0, sizeof(struct camera2_shot_ext));
dst = &dst_ext->shot;
dst->magicNumber = 0x23456789;
dst->ctl.aa.aeTargetFpsRange[0] = 15;
dst->ctl.aa.aeTargetFpsRange[1] = 30;
dst->ctl.aa.aeExpCompensation = 5;
num_entry = (uint32_t)get_camera_metadata_entry_count(request);
for (index = 0 ; index < num_entry ; index++) {
if (get_camera_metadata_entry(request, index, &curr_entry)==0) {
switch (curr_entry.tag) {
case ANDROID_LENS_FOCUS_DISTANCE:
if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_FLOAT, 1))
break;
dst->ctl.lens.focusDistance = curr_entry.data.f[0];
break;
case ANDROID_LENS_APERTURE:
if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_FLOAT, 1))
break;
dst->ctl.lens.aperture = curr_entry.data.f[0];
break;
case ANDROID_LENS_FOCAL_LENGTH:
if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_FLOAT, 1))
break;
dst->ctl.lens.focalLength = curr_entry.data.f[0];
break;
case ANDROID_LENS_FILTER_DENSITY:
if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_FLOAT, 1))
break;
dst->ctl.lens.filterDensity = curr_entry.data.f[0];
break;
case ANDROID_LENS_OPTICAL_STABILIZATION_MODE:
if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_BYTE, 1))
break;
dst->ctl.lens.opticalStabilizationMode =
(enum optical_stabilization_mode)curr_entry.data.u8[0];
break;
case ANDROID_SENSOR_TIMESTAMP:
if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_INT64, 1))
break;
dst->dm.sensor.timeStamp = curr_entry.data.i64[0];
break;
case ANDROID_SENSOR_SENSITIVITY:
if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_INT32, 1))
break;
dst->dm.aa.isoValue = curr_entry.data.i32[0];
break;
case ANDROID_SENSOR_EXPOSURE_TIME:
if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_INT64, 1))
break;
dst->dm.sensor.exposureTime = curr_entry.data.i64[0];
break;
case ANDROID_FLASH_MODE:
if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_BYTE, 1))
break;
dst->ctl.flash.flashMode = (enum flash_mode)(curr_entry.data.u8[0] + 1);
break;
case ANDROID_FLASH_FIRING_POWER:
if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_BYTE, 1))
break;
dst->ctl.flash.firingPower = curr_entry.data.u8[0];
break;
case ANDROID_FLASH_FIRING_TIME:
if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_INT64, 1))
break;
dst->ctl.flash.firingTime = curr_entry.data.i64[0];
break;
case ANDROID_SCALER_CROP_REGION:
if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_INT32, 3))
break;
for (i=0 ; i<curr_entry.count ; i++)
dst->ctl.scaler.cropRegion[i] = ALIGN(curr_entry.data.i32[i], 2);
break;
case ANDROID_JPEG_QUALITY:
if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_INT32, 1))
break;
dst->ctl.jpeg.quality= curr_entry.data.i32[0];
break;
case ANDROID_JPEG_THUMBNAIL_SIZE:
if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_INT32, 2))
break;
for (i=0 ; i<curr_entry.count ; i++)
dst->ctl.jpeg.thumbnailSize[i] = curr_entry.data.i32[i];
break;
case ANDROID_JPEG_THUMBNAIL_QUALITY:
if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_INT32, 1))
break;
dst->ctl.jpeg.thumbnailQuality= curr_entry.data.i32[0];
break;
case ANDROID_JPEG_GPS_COORDINATES:
if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_DOUBLE, 3))
break;
for (i=0 ; i<curr_entry.count ; i++)
dst->ctl.jpeg.gpsCoordinates[i] = curr_entry.data.d[i];
break;
case ANDROID_JPEG_GPS_PROCESSING_METHOD:
if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_BYTE))
break;
if (curr_entry.count > 32)
cnt = 32;
else
cnt = curr_entry.count;
for (i = 0 ; i < cnt ; i++)
dst_ext->gpsProcessingMethod[i] = curr_entry.data.u8[i];
break;
case ANDROID_JPEG_GPS_TIMESTAMP:
if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_INT64, 1))
break;
dst->ctl.jpeg.gpsTimestamp = curr_entry.data.i64[0];
break;
case ANDROID_JPEG_ORIENTATION:
if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_INT32, 1))
break;
dst->ctl.jpeg.orientation = curr_entry.data.i32[0];
break;
case ANDROID_STATS_FACE_DETECT_MODE:
if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_BYTE, 1))
break;
dst->ctl.stats.faceDetectMode = (enum facedetect_mode)(curr_entry.data.u8[0] + 1);
break;
case ANDROID_CONTROL_CAPTURE_INTENT:
if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_BYTE, 1))
break;
dst->ctl.aa.captureIntent = (enum aa_capture_intent)curr_entry.data.u8[0];
break;
case ANDROID_CONTROL_MODE:
if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_BYTE, 1))
break;
dst->ctl.aa.mode = (enum aa_mode)(curr_entry.data.u8[0] + 1);
break;
case ANDROID_CONTROL_VIDEO_STABILIZATION_MODE:
if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_BYTE, 1))
break;
dst->ctl.aa.videoStabilizationMode = curr_entry.data.u8[0];
break;
case ANDROID_CONTROL_AE_MODE:
if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_BYTE, 1))
break;
dst->ctl.aa.aeMode = (enum aa_aemode)(curr_entry.data.u8[0] + 2);
// skip locked mode
if (dst->ctl.aa.aeMode == AA_AEMODE_LOCKED)
dst->ctl.aa.aeMode = AA_AEMODE_OFF;
ALOGV("DEBUG(%s): ANDROID_CONTROL_AE_MODE (%d)", __FUNCTION__, dst->ctl.aa.aeMode);
break;
case ANDROID_CONTROL_AE_LOCK:
if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_BYTE, 1))
break;
dst_ext->ae_lock = (enum ae_lockmode)(curr_entry.data.u8[0]);
break;
case ANDROID_CONTROL_AE_EXP_COMPENSATION:
if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_INT32, 1))
break;
dst->ctl.aa.aeExpCompensation = curr_entry.data.i32[0] + 5;
break;
case ANDROID_CONTROL_AWB_MODE:
if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_BYTE, 1))
break;
dst->ctl.aa.awbMode = (enum aa_awbmode)(curr_entry.data.u8[0] + 2);
// skip locked mode
if (dst->ctl.aa.awbMode == AA_AWBMODE_LOCKED)
dst->ctl.aa.awbMode = AA_AWBMODE_OFF;
dst_ext->awb_mode_dm = (enum aa_awbmode)(curr_entry.data.u8[0] + 2);
break;
case ANDROID_CONTROL_AWB_LOCK:
if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_BYTE, 1))
break;
dst_ext->awb_lock = (enum awb_lockmode)(curr_entry.data.u8[0]);
break;
case ANDROID_CONTROL_AF_MODE:
if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_BYTE, 1))
break;
dst->ctl.aa.afMode = (enum aa_afmode)(curr_entry.data.u8[0] + 1);
if (dst->ctl.aa.afMode == AA_AFMODE_OFF)
dst->ctl.aa.afMode = AA_AFMODE_MANUAL;
break;
case ANDROID_CONTROL_AF_REGIONS:
if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_INT32, 5))
break;
for (i=0 ; i<curr_entry.count ; i++)
dst->ctl.aa.afRegions[i] = curr_entry.data.i32[i];
break;
case ANDROID_CONTROL_AE_REGIONS:
if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_INT32, 5))
break;
for (i=0 ; i<curr_entry.count ; i++)
dst->ctl.aa.aeRegions[i] = curr_entry.data.i32[i];
break;
case ANDROID_REQUEST_ID:
if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_INT32, 1))
break;
dst->ctl.request.id = curr_entry.data.i32[0];
ALOGV("DEBUG(%s): ANDROID_REQUEST_ID (%d)", __FUNCTION__, dst->ctl.request.id);
break;
case ANDROID_REQUEST_METADATA_MODE:
if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_BYTE, 1))
break;
dst->ctl.request.metadataMode = (enum metadata_mode)curr_entry.data.u8[0];
ALOGV("DEBUG(%s): ANDROID_REQUEST_METADATA_MODE (%d)", __FUNCTION__, (int)( dst->ctl.request.metadataMode));
break;
case ANDROID_REQUEST_OUTPUT_STREAMS:
if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_BYTE))
break;
dst->ctl.request.outputStreams[0] = 0;
for (i=0 ; i<curr_entry.count ; i++) {
ALOGV("DEBUG(%s): OUTPUT_STREAM[%d] = %d ", __FUNCTION__, i, curr_entry.data.u8[i]);
dst->ctl.request.outputStreams[0] |= (1 << curr_entry.data.u8[i]);
}
break;
case ANDROID_REQUEST_INPUT_STREAMS:
if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_BYTE))
break;
for (i=0 ; i<curr_entry.count ; i++) {
dst_ext->reprocessInput = curr_entry.data.u8[0];
ALOGV("DEBUG(%s): ANDROID_REQUEST_INPUT_STREAMS[%d] = %d ", __FUNCTION__, i, dst_ext->reprocessInput);
}
break;
case ANDROID_REQUEST_TYPE:
if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_BYTE, 1))
break;
dst_ext->isReprocessing = curr_entry.data.u8[0];
ALOGV("DEBUG(%s): ANDROID_REQUEST_TYPE (%d)", __FUNCTION__, dst_ext->isReprocessing);
break;
case ANDROID_REQUEST_FRAME_COUNT:
if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_INT32, 1))
break;
dst->ctl.request.frameCount = curr_entry.data.i32[0];
ALOGV("DEBUG(%s): ANDROID_REQUEST_FRAME_COUNT (%d)", __FUNCTION__, dst->ctl.request.frameCount);
break;
case ANDROID_CONTROL_SCENE_MODE:
if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_BYTE, 1))
break;
dst->ctl.aa.sceneMode = (enum aa_scene_mode)(curr_entry.data.u8[0] + 1);
break;
case ANDROID_CONTROL_AE_TARGET_FPS_RANGE:
if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_INT32, 2))
break;
for (i=0 ; i<curr_entry.count ; i++)
dst->ctl.aa.aeTargetFpsRange[i] = curr_entry.data.i32[i];
break;
default:
ALOGV("DEBUG(%s):Bad Metadata tag (%d)", __FUNCTION__, curr_entry.tag);
break;
}
}
}
if (dst->ctl.aa.mode != AA_CONTROL_USE_SCENE_MODE)
dst->ctl.aa.sceneMode = AA_SCENE_MODE_UNSUPPORTED;
ApplySceneModeParameters(request, dst_ext);
return NO_ERROR;
}
status_t MetadataConverter::ApplySceneModeParameters(camera_metadata_t * request, struct camera2_shot_ext * dst_ext)
{
camera_metadata_entry_t curr_entry;
struct camera2_shot * dst = NULL;
ALOGV("DEBUG(%s):", __FUNCTION__);
dst = &(dst_ext->shot);
switch (dst->ctl.aa.sceneMode) {
case AA_SCENE_MODE_ACTION:
dst->ctl.aa.mode = AA_CONTROL_USE_SCENE_MODE;
if (dst->ctl.aa.aeMode != AA_AEMODE_LOCKED)
dst->ctl.aa.aeMode = AA_AEMODE_ON;
dst->ctl.aa.awbMode = AA_AWBMODE_WB_AUTO;
dst_ext->awb_mode_dm = AA_AWBMODE_WB_AUTO;
dst->ctl.aa.isoMode = AA_ISOMODE_AUTO;
dst->ctl.aa.isoValue = 0;
dst->ctl.aa.aeTargetFpsRange[0] = 30;
dst->ctl.aa.aeTargetFpsRange[1] = 30;
dst->ctl.noise.mode = PROCESSING_MODE_FAST;
dst->ctl.noise.strength = 0;
dst->ctl.edge.mode = PROCESSING_MODE_FAST;
dst->ctl.edge.strength = 0;
dst->ctl.color.saturation = 3; // means '0'
break;
case AA_SCENE_MODE_PARTY:
dst->ctl.aa.mode = AA_CONTROL_USE_SCENE_MODE;
if (dst->ctl.aa.aeMode != AA_AEMODE_LOCKED)
dst->ctl.aa.aeMode = AA_AEMODE_ON;
dst->ctl.aa.awbMode = AA_AWBMODE_WB_AUTO;
dst_ext->awb_mode_dm = AA_AWBMODE_WB_AUTO;
dst->ctl.aa.isoMode = AA_ISOMODE_MANUAL;
dst->ctl.aa.isoValue = 200;
dst->ctl.aa.aeTargetFpsRange[0] = 15;
dst->ctl.aa.aeTargetFpsRange[1] = 30;
dst->ctl.noise.mode = PROCESSING_MODE_FAST;
dst->ctl.noise.strength = 0;
dst->ctl.edge.mode = PROCESSING_MODE_FAST;
dst->ctl.edge.strength = 0;
dst->ctl.color.saturation = 4; // means '+1'
break;
case AA_SCENE_MODE_SUNSET:
dst->ctl.aa.mode = AA_CONTROL_USE_SCENE_MODE;
if (dst->ctl.aa.aeMode != AA_AEMODE_LOCKED)
dst->ctl.aa.aeMode = AA_AEMODE_ON;
dst->ctl.aa.awbMode = AA_AWBMODE_WB_DAYLIGHT;
dst_ext->awb_mode_dm = AA_AWBMODE_WB_DAYLIGHT;
dst->ctl.aa.isoMode = AA_ISOMODE_AUTO;
dst->ctl.aa.isoValue = 0;
dst->ctl.aa.aeTargetFpsRange[0] = 15;
dst->ctl.aa.aeTargetFpsRange[1] = 30;
dst->ctl.noise.mode = PROCESSING_MODE_FAST;
dst->ctl.noise.strength = 0;
dst->ctl.edge.mode = PROCESSING_MODE_FAST;
dst->ctl.edge.strength = 0;
dst->ctl.color.saturation = 3; // means '0'
break;
case AA_SCENE_MODE_NIGHT:
dst->ctl.aa.mode = AA_CONTROL_USE_SCENE_MODE;
dst->ctl.aa.aeMode = AA_AEMODE_ON; // AE_LOCK is prohibited
dst->ctl.aa.awbMode = AA_AWBMODE_WB_AUTO;
dst_ext->awb_mode_dm = AA_AWBMODE_WB_AUTO;
dst->ctl.aa.isoMode = AA_ISOMODE_AUTO;
dst->ctl.aa.isoValue = 0;
dst->ctl.aa.aeTargetFpsRange[0] = 8;
dst->ctl.aa.aeTargetFpsRange[1] = 30;
dst->ctl.noise.mode = PROCESSING_MODE_FAST;
dst->ctl.noise.strength = 0;
dst->ctl.edge.mode = PROCESSING_MODE_FAST;
dst->ctl.edge.strength = 0;
dst->ctl.color.saturation = 3; // means '0'
break;
case AA_SCENE_MODE_FACE_PRIORITY:
dst->ctl.aa.mode = AA_CONTROL_AUTO;
if ((dst->ctl.aa.aeMode != AA_AEMODE_LOCKED) && (dst->ctl.aa.aeMode < AA_AEMODE_ON_AUTO_FLASH))
dst->ctl.aa.aeMode = AA_AEMODE_ON;
dst->ctl.aa.sceneMode = AA_SCENE_MODE_FACE_PRIORITY;
dst->ctl.aa.isoMode = AA_ISOMODE_AUTO;
dst->ctl.aa.isoValue = 0;
dst->ctl.noise.mode = PROCESSING_MODE_OFF;
dst->ctl.noise.strength = 0;
dst->ctl.edge.mode = PROCESSING_MODE_OFF;
dst->ctl.edge.strength = 0;
dst->ctl.color.saturation = 3; // means '0'
break;
default:
dst->ctl.aa.mode = AA_CONTROL_AUTO;
if ((dst->ctl.aa.aeMode != AA_AEMODE_LOCKED) && (dst->ctl.aa.aeMode < AA_AEMODE_ON_AUTO_FLASH))
dst->ctl.aa.aeMode = AA_AEMODE_ON;
dst->ctl.aa.sceneMode = AA_SCENE_MODE_UNSUPPORTED;
dst->ctl.aa.isoMode = AA_ISOMODE_AUTO;
dst->ctl.aa.isoValue = 0;
dst->ctl.noise.mode = PROCESSING_MODE_OFF;
dst->ctl.noise.strength = 0;
dst->ctl.edge.mode = PROCESSING_MODE_OFF;
dst->ctl.edge.strength = 0;
dst->ctl.color.saturation = 3; // means '0'
break;
}
return NO_ERROR;
}
status_t MetadataConverter::ToDynamicMetadata(struct camera2_shot_ext * metadata_ext, camera_metadata_t * dst)
{
status_t res;
struct camera2_shot * metadata = &metadata_ext->shot;
uint8_t byteData;
uint32_t intData;
if (0 != add_camera_metadata_entry(dst, ANDROID_REQUEST_ID,
&(metadata->ctl.request.id), 1))
return NO_MEMORY;
if (0 != add_camera_metadata_entry(dst, ANDROID_REQUEST_METADATA_MODE,
&(metadata->ctl.request.metadataMode), 1))
return NO_MEMORY;
if (0 != add_camera_metadata_entry(dst, ANDROID_REQUEST_FRAME_COUNT,
&(metadata->ctl.request.frameCount), 1))
return NO_MEMORY;
if (0 != add_camera_metadata_entry(dst, ANDROID_SENSOR_TIMESTAMP,
&metadata->dm.sensor.timeStamp, 1))
return NO_MEMORY;
if (0 != add_camera_metadata_entry(dst, ANDROID_SENSOR_EXPOSURE_TIME,
&metadata->dm.sensor.exposureTime, 1))
return NO_MEMORY;
if (0 != add_camera_metadata_entry(dst, ANDROID_LENS_APERTURE,
&metadata->dm.lens.aperture, 1))
return NO_MEMORY;
if (0 != add_camera_metadata_entry(dst, ANDROID_CONTROL_AE_TARGET_FPS_RANGE,
&(metadata->ctl.aa.aeTargetFpsRange), 2))
return NO_MEMORY;
ALOGV("(%s): ID(%d) METAMODE(%d) FrameCnt(%d) Timestamp(%lld) exposure(%lld) aper(%f)", __FUNCTION__,
metadata->ctl.request.id, metadata->ctl.request.metadataMode, metadata->ctl.request.frameCount,
metadata->dm.sensor.timeStamp, metadata->dm.sensor.exposureTime, metadata->dm.lens.aperture);
byteData = metadata_ext->awb_mode_dm- 2;
if (0 != add_camera_metadata_entry(dst, ANDROID_CONTROL_AWB_MODE,
&byteData, 1))
return NO_MEMORY;
byteData = metadata->dm.aa.aeMode - 1;
if (0 != add_camera_metadata_entry(dst, ANDROID_CONTROL_AE_MODE,
&byteData, 1))
return NO_MEMORY;
byteData = metadata->ctl.aa.afMode - 1;
if (0 != add_camera_metadata_entry(dst, ANDROID_CONTROL_AF_MODE,
&byteData, 1))
return NO_MEMORY;
byteData = metadata->ctl.aa.sceneMode - 1;
if (0 != add_camera_metadata_entry(dst, ANDROID_CONTROL_SCENE_MODE,
&byteData, 1))
return NO_MEMORY;
intData = metadata->ctl.aa.aeExpCompensation - 5;
if (0 != add_camera_metadata_entry(dst, ANDROID_CONTROL_AE_EXP_COMPENSATION,
&intData, 1))
return NO_MEMORY;
byteData = metadata->dm.stats.faceDetectMode - 1;
if (0 != add_camera_metadata_entry(dst, ANDROID_STATS_FACE_DETECT_MODE,
&byteData, 1))
return NO_MEMORY;
int maxFacecount = CAMERA2_MAX_FACES;
if (0 != add_camera_metadata_entry(dst, ANDROID_STATS_MAX_FACE_COUNT,
&maxFacecount, 1))
return NO_MEMORY;
int tempFaceCount = 0;
for (int i = 0; i < CAMERA2_MAX_FACES; i++) {
if (metadata->dm.stats.faceIds[i] > 0) {
mataFaceIds[tempFaceCount] = metadata->dm.stats.faceIds[i];
// clipping fd score because the max face score of android is 100
if (metadata->dm.stats.faceScores[i] > 100)
metaFaceScores[tempFaceCount] = 100;
else
metaFaceScores[tempFaceCount] = metadata->dm.stats.faceScores[i];
memcpy(&mataFaceLandmarks[tempFaceCount][0], &metadata->dm.stats.faceLandmarks[i][0], 6*sizeof(uint32_t));
memcpy(&metaFaceRectangles[tempFaceCount][0], &metadata->dm.stats.faceRectangles[i][0], 4*sizeof(uint32_t));
tempFaceCount++;
}
}
if (tempFaceCount > 0) {
if (0 != add_camera_metadata_entry(dst, ANDROID_STATS_FACE_RECTANGLES,
&metaFaceRectangles, 4 * tempFaceCount))
return NO_MEMORY;
if (0 != add_camera_metadata_entry(dst, ANDROID_STATS_FACE_LANDMARKS,
&mataFaceLandmarks, 6 * tempFaceCount))
return NO_MEMORY;
if (0 != add_camera_metadata_entry(dst, ANDROID_STATS_FACE_IDS,
&mataFaceIds, tempFaceCount))
return NO_MEMORY;
if (0 != add_camera_metadata_entry(dst, ANDROID_STATS_FACE_SCORES,
&metaFaceScores, tempFaceCount))
return NO_MEMORY;
}
if (0 != add_camera_metadata_entry(dst, ANDROID_SENSOR_SENSITIVITY,
&metadata->dm.aa.isoValue, 1))
return NO_MEMORY;
if (0 != add_camera_metadata_entry(dst, ANDROID_SCALER_CROP_REGION,
&metadata->ctl.scaler.cropRegion, 3))
return NO_MEMORY;
byteData = metadata->dm.aa.aeState - 1;
if (0 != add_camera_metadata_entry(dst, ANDROID_CONTROL_AE_STATE,
&byteData, 1))
return NO_MEMORY;
if (0 != add_camera_metadata_entry(dst, ANDROID_CONTROL_AWB_STATE,
&(metadata->dm.aa.awbState), 1))
return NO_MEMORY;
if (0 != add_camera_metadata_entry(dst, ANDROID_JPEG_ORIENTATION,
&metadata->ctl.jpeg.orientation, 1))
return NO_MEMORY;
if (0 != add_camera_metadata_entry(dst, ANDROID_JPEG_QUALITY,
&metadata->ctl.jpeg.quality, 1))
return NO_MEMORY;
if (0 != add_camera_metadata_entry(dst, ANDROID_JPEG_THUMBNAIL_SIZE,
&metadata->ctl.jpeg.thumbnailSize, 2))
return NO_MEMORY;
if (0 != add_camera_metadata_entry(dst, ANDROID_JPEG_THUMBNAIL_QUALITY,
&metadata->ctl.jpeg.thumbnailQuality, 1))
return NO_MEMORY;
if (0 != add_camera_metadata_entry(dst, ANDROID_JPEG_GPS_COORDINATES,
&(metadata->ctl.jpeg.gpsCoordinates), 3))
return NO_MEMORY;
if (0 != add_camera_metadata_entry(dst, ANDROID_JPEG_GPS_PROCESSING_METHOD,
&(metadata_ext->gpsProcessingMethod), 32))
return NO_MEMORY;
if (0 != add_camera_metadata_entry(dst, ANDROID_JPEG_GPS_TIMESTAMP,
&(metadata->ctl.jpeg.gpsTimestamp), 1))
return NO_MEMORY;
ALOGV("(%s): AWB(%d) AE(%d) SCENE(%d) AEComp(%d) AF(%d)", __FUNCTION__,
metadata_ext->awb_mode_dm- 2, metadata->dm.aa.aeMode - 1, metadata->ctl.aa.sceneMode - 1,
metadata->ctl.aa.aeExpCompensation, metadata->ctl.aa.afMode - 1);
if (metadata->ctl.request.metadataMode == METADATA_MODE_NONE) {
ALOGV("DEBUG(%s): METADATA_MODE_NONE", __FUNCTION__);
return NO_ERROR;
}
return NO_ERROR;
}
}; // namespace android