Camera3: Convert the callback metadata into fwk struct
Convert the metadata in the result callback into a struct
specified by the framework
Change-Id: I83fd74dbd6c65c5a56e0035353387748e73d5e57
diff --git a/camera/QCamera2/HAL3/QCamera3HALHeader.h b/camera/QCamera2/HAL3/QCamera3HALHeader.h
new file mode 100644
index 0000000..0e6cce4
--- /dev/null
+++ b/camera/QCamera2/HAL3/QCamera3HALHeader.h
@@ -0,0 +1,54 @@
+/* Copyright (c) 2013, The Linux Foundataion. All rights reserved.
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are
+* met:
+* * Redistributions of source code must retain the above copyright
+* notice, this list of conditions and the following disclaimer.
+* * Redistributions in binary form must reproduce the above
+* copyright notice, this list of conditions and the following
+* disclaimer in the documentation and/or other materials provided
+* with the distribution.
+* * Neither the name of The Linux Foundation nor the names of its
+* contributors may be used to endorse or promote products derived
+* from this software without specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*
+*/
+#ifndef __QCAMERA_HALHEADER_H__
+#define __QCAMERA_HALHEADER_H__
+
+extern "C" {
+#include <mm_camera_interface.h>
+#include <mm_jpeg_interface.h>
+}
+
+using namespace android;
+
+namespace qcamera {
+
+typedef struct {
+ int32_t jpeg_orientation;
+ uint8_t jpeg_quality;
+ cam_dimension_t thumbnail_size;
+ int64_t gps_timestamp;
+ double gps_coordinates[3];
+ uint8_t gps_processing_method;
+ int32_t sensor_sensitivity;
+ float lens_focal_length;
+} jpeg_settings_t;
+
+};//namespace qcamera
+
+#endif
diff --git a/camera/QCamera2/HAL3/QCamera3HWI.cpp b/camera/QCamera2/HAL3/QCamera3HWI.cpp
index cc0d7d9..d861c8f 100644
--- a/camera/QCamera2/HAL3/QCamera3HWI.cpp
+++ b/camera/QCamera2/HAL3/QCamera3HWI.cpp
@@ -43,7 +43,6 @@
using namespace android;
-//using namespace android;
namespace qcamera {
#define DATA_PTR(MEM_OBJ,INDEX) MEM_OBJ->getPtr( INDEX )
cam_capability_t *gCamCapability[MM_CAMERA_MAX_NUM_SENSORS];
@@ -63,6 +62,7 @@
};
const QCamera3HardwareInterface::QCameraMap QCamera3HardwareInterface::WHITE_BALANCE_MODES_MAP[] = {
+ { ANDROID_CONTROL_AWB_MODE_OFF, CAM_WB_MODE_OFF },
{ ANDROID_CONTROL_AWB_MODE_AUTO, CAM_WB_MODE_AUTO },
{ ANDROID_CONTROL_AWB_MODE_INCANDESCENT, CAM_WB_MODE_INCANDESCENT },
{ ANDROID_CONTROL_AWB_MODE_FLUORESCENT, CAM_WB_MODE_FLUORESCENT },
@@ -89,10 +89,11 @@
{ ANDROID_CONTROL_SCENE_MODE_SPORTS , CAM_SCENE_MODE_SPORTS },
{ ANDROID_CONTROL_SCENE_MODE_PARTY, CAM_SCENE_MODE_PARTY },
{ ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT, CAM_SCENE_MODE_CANDLELIGHT },
- { ANDROID_CONTROL_SCENE_MODE_BARCODE, CAM_SCENE_MODE_OFF}
+ { ANDROID_CONTROL_SCENE_MODE_BARCODE, CAM_SCENE_MODE_BARCODE}
};
const QCamera3HardwareInterface::QCameraMap QCamera3HardwareInterface::FOCUS_MODES_MAP[] = {
+ { ANDROID_CONTROL_AF_MODE_OFF, CAM_FOCUS_MODE_OFF },
{ ANDROID_CONTROL_AF_MODE_AUTO, CAM_FOCUS_MODE_AUTO },
{ ANDROID_CONTROL_AF_MODE_MACRO, CAM_FOCUS_MODE_MACRO },
{ ANDROID_CONTROL_AF_MODE_EDOF, CAM_FOCUS_MODE_EDOF },
@@ -108,7 +109,7 @@
};
const QCamera3HardwareInterface::QCameraMap QCamera3HardwareInterface::AUTO_EXPOSURE_MAP[] = {
- { ANDROID_CONTROL_AE_MODE_OFF, CAM_AEC_MODE_FRAME_AVERAGE },
+ { ANDROID_CONTROL_AE_MODE_OFF, CAM_AEC_MODE_OFF },
{ ANDROID_CONTROL_AE_MODE_ON, CAM_AEC_MODE_FRAME_AVERAGE },
};
@@ -144,7 +145,8 @@
: mCameraId(cameraId),
mCameraHandle(NULL),
mCameraOpened(false),
- mCallbackOps(NULL)
+ mCallbackOps(NULL),
+ mJpegSettings(NULL)
{
mCameraDevice.common.tag = HARDWARE_DEVICE_TAG;
mCameraDevice.common.version = CAMERA_DEVICE_API_VERSION_3_0;
@@ -171,6 +173,10 @@
*==========================================================================*/
QCamera3HardwareInterface::~QCamera3HardwareInterface()
{
+ if (mJpegSettings != NULL) {
+ free(mJpegSettings);
+ mJpegSettings = NULL;
+ }
closeCamera();
pthread_mutex_destroy(&mRequestLock);
@@ -771,14 +777,9 @@
pthread_cond_signal(&mRequestCond);
pthread_mutex_unlock(&mRequestLock);
- //TODO: Add translation from metadata_buffer_t to CameraMetadata
- // for now, hardcode timestamp only.
- CameraMetadata camMetadata;
uint32_t *frame_number = (uint32_t *)POINTER_OF(CAM_INTF_META_FRAME_NUMBER, metadata);
- nsecs_t captureTime = 1000000 * (*frame_number) * 33;
- camMetadata.update(ANDROID_SENSOR_TIMESTAMP, &captureTime, 1);
- result.result = camMetadata.release();
+ result.result = translateCbMetadataToResultMetadata(metadata);
if (!result.result) {
result.frame_number = *frame_number;
result.num_output_buffers = 0;
@@ -799,6 +800,268 @@
return;
}
+/*===========================================================================
+ * FUNCTION : translateCbMetadataToResultMetadata
+ *
+ * DESCRIPTION:
+ *
+ * PARAMETERS :
+ * @metadata : metadata information from callback
+ *
+ * RETURN : camera_metadata_t*
+ * metadata in a format specified by fwk
+ *==========================================================================*/
+camera_metadata_t*
+QCamera3HardwareInterface::translateCbMetadataToResultMetadata
+ (metadata_buffer_t *metadata)
+{
+ CameraMetadata camMetadata;
+ camera_metadata_t* resultMetadata;
+
+ uint32_t *frame_number =
+ (uint32_t *)POINTER_OF(CAM_INTF_META_FRAME_NUMBER, metadata);
+ nsecs_t captureTime = 1000000 * (*frame_number) * 33;
+ camMetadata.update(ANDROID_SENSOR_TIMESTAMP, &captureTime, 1);
+
+ /*CAM_INTF_META_HISTOGRAM - TODO*/
+ /*cam_hist_stats_t *histogram =
+ (cam_hist_stats_t *)POINTER_OF(CAM_INTF_META_HISTOGRAM,
+ metadata);*/
+
+ /*face detection*/
+ cam_face_detection_data_t *faceDetectionInfo =(cam_face_detection_data_t *)
+ POINTER_OF(CAM_INTF_META_FACE_DETECTION, metadata);
+ uint8_t numFaces = faceDetectionInfo->num_faces_detected;
+ int32_t faceIds[numFaces];
+ uint8_t faceScores[numFaces];
+ int32_t faceRectangles[numFaces * 4];
+ int32_t faceLandmarks[numFaces * 6];
+ int j = 0, k = 0;
+ for (int i = 0; i < numFaces; i++) {
+ faceIds[i] = faceDetectionInfo->faces[i].face_id;
+ faceScores[i] = faceDetectionInfo->faces[i].score;
+ convertRegions(faceDetectionInfo->faces[i].face_boundary,
+ faceRectangles+j, -1);
+ convertLandmarks(faceDetectionInfo->faces[i], faceLandmarks+k);
+ j+= 4;
+ k+= 6;
+ }
+ camMetadata.update(ANDROID_STATISTICS_FACE_IDS, faceIds, numFaces);
+ camMetadata.update(ANDROID_STATISTICS_FACE_SCORES, faceScores, numFaces);
+ camMetadata.update(ANDROID_STATISTICS_FACE_RECTANGLES,
+ faceRectangles, numFaces*4);
+ camMetadata.update(ANDROID_STATISTICS_FACE_LANDMARKS,
+ faceLandmarks, numFaces*6);
+
+
+ /*autofocus - TODO*/
+ /*cam_auto_focus_data_t *afData =(cam_auto_focus_data_t *)
+ POINTER_OF(CAM_INTF_META_AUTOFOCUS_DATA,metadata);*/
+
+ int32_t *color_correct_mode =
+ (int32_t *)POINTER_OF(CAM_INTF_META_COLOR_CORRECT_MODE, metadata);
+ camMetadata.update(ANDROID_COLOR_CORRECTION_MODE, color_correct_mode, 1);
+
+ int32_t *ae_precapture_id =
+ (int32_t *)POINTER_OF(CAM_INTF_META_AEC_PRECAPTURE_ID, metadata);
+ camMetadata.update(ANDROID_CONTROL_AE_PRECAPTURE_ID, ae_precapture_id, 1);
+
+ /*aec regions*/
+ cam_area_t *hAeRegions =
+ (cam_area_t *)POINTER_OF(CAM_INTF_META_AEC_ROI, metadata);
+ int32_t aeRegions[5];
+ convertRegions(hAeRegions->rect, aeRegions, hAeRegions->weight);
+ camMetadata.update(ANDROID_CONTROL_AE_REGIONS, aeRegions, 5);
+
+ int32_t *ae_state =
+ (int32_t *)POINTER_OF(CAM_INTF_META_AEC_STATE, metadata);
+ camMetadata.update(ANDROID_CONTROL_AE_STATE, ae_state, 1);
+
+ int32_t *focusMode =
+ (int32_t *)POINTER_OF(CAM_INTF_PARM_FOCUS_MODE, metadata);
+ camMetadata.update(ANDROID_CONTROL_AF_MODE, focusMode, 1);
+
+ /*af regions*/
+ cam_area_t *hAfRegions =
+ (cam_area_t *)POINTER_OF(CAM_INTF_META_AF_ROI, metadata);
+ int32_t afRegions[5];
+ convertRegions(hAfRegions->rect, afRegions, hAfRegions->weight);
+ camMetadata.update(ANDROID_CONTROL_AF_REGIONS, afRegions, 5);
+
+ int32_t *afState = (int32_t *)POINTER_OF(CAM_INTF_META_AF_STATE, metadata);
+ camMetadata.update(ANDROID_CONTROL_AF_STATE, afState, 1);
+
+ int32_t *afTriggerId =
+ (int32_t *)POINTER_OF(CAM_INTF_META_AF_TRIGGER_ID, metadata);
+ camMetadata.update(ANDROID_CONTROL_AF_TRIGGER_ID, afTriggerId, 1);
+
+ int32_t *whiteBalance =
+ (int32_t *)POINTER_OF(CAM_INTF_PARM_WHITE_BALANCE, metadata);
+ camMetadata.update(ANDROID_CONTROL_AWB_MODE, whiteBalance, 1);
+
+ /*awb regions*/
+ cam_area_t *hAwbRegions =
+ (cam_area_t *)POINTER_OF(CAM_INTF_META_AWB_REGIONS, metadata);
+ int32_t awbRegions[5];
+ convertRegions(hAwbRegions->rect, awbRegions, hAwbRegions->weight);
+ camMetadata.update(ANDROID_CONTROL_AWB_REGIONS, awbRegions, 5);
+
+ int32_t *whiteBalanceState =
+ (int32_t *)POINTER_OF(CAM_INTF_META_AWB_STATE, metadata);
+ camMetadata.update(ANDROID_CONTROL_AWB_STATE, whiteBalanceState, 1);
+
+ int32_t *mode = (int32_t *)POINTER_OF(CAM_INTF_META_MODE, metadata);
+ camMetadata.update(ANDROID_CONTROL_MODE, mode, 1);
+
+ int32_t *edgeMode = (int32_t *)POINTER_OF(CAM_INTF_META_EDGE, metadata);
+ camMetadata.update(ANDROID_EDGE_MODE, edgeMode, 1);
+
+ int32_t *flashPower =
+ (int32_t *)POINTER_OF(CAM_INTF_META_FLASH_POWER, metadata);
+ camMetadata.update(ANDROID_FLASH_FIRING_POWER, flashPower, 1);
+
+ int64_t *flashFiringTime =
+ (int64_t *)POINTER_OF(CAM_INTF_META_FLASH_FIRING_TIME, metadata);
+ camMetadata.update(ANDROID_FLASH_FIRING_TIME, flashFiringTime, 1);
+
+ /*int32_t *ledMode =
+ (int32_t *)POINTER_OF(CAM_INTF_PARM_LED_MODE, metadata);
+ camMetadata.update(ANDROID_FLASH_FIRING_TIME, ledMode, 1);*/
+
+ int32_t *flashState =
+ (int32_t *)POINTER_OF(CAM_INTF_META_FLASH_STATE, metadata);
+ camMetadata.update(ANDROID_FLASH_STATE, flashState, 1);
+
+ int32_t *hotPixelMode =
+ (int32_t *)POINTER_OF(CAM_INTF_META_HOTPIXEL_MODE, metadata);
+ camMetadata.update(ANDROID_HOT_PIXEL_MODE, hotPixelMode, 1);
+
+ float *lensAperture =
+ (float *)POINTER_OF(CAM_INTF_META_LENS_APERTURE, metadata);
+ camMetadata.update(ANDROID_LENS_APERTURE , lensAperture, 1);
+
+ float *filterDensity =
+ (float *)POINTER_OF(CAM_INTF_META_LENS_FILTERDENSITY, metadata);
+ camMetadata.update(ANDROID_LENS_FILTER_DENSITY , filterDensity, 1);
+
+ float *focalLength =
+ (float *)POINTER_OF(CAM_INTF_META_LENS_FOCAL_LENGTH, metadata);
+ camMetadata.update(ANDROID_LENS_FOCAL_LENGTH, focalLength, 1);
+
+ float *focusDistance =
+ (float *)POINTER_OF(CAM_INTF_META_LENS_FOCUS_DISTANCE, metadata);
+ camMetadata.update(ANDROID_LENS_FOCUS_DISTANCE , focusDistance, 1);
+
+ float *focusRange =
+ (float *)POINTER_OF(CAM_INTF_META_LENS_FOCUS_RANGE, metadata);
+ camMetadata.update(ANDROID_LENS_FOCUS_RANGE , focusRange, 1);
+
+ int32_t *opticalStab =
+ (int32_t *)POINTER_OF(CAM_INTF_META_LENS_OPT_STAB_MODE, metadata);
+ camMetadata.update(ANDROID_LENS_OPTICAL_STABILIZATION_MODE, opticalStab, 1);
+
+ /*int32_t *focusState =
+ (int32_t *)POINTER_OF(CAM_INTF_META_LENS_FOCUS_STATE, metadata);
+ camMetadata.update(ANDROID_LENS_STATE , focusState, 1); //check */
+
+ int32_t *noiseRedMode =
+ (int32_t *)POINTER_OF(CAM_INTF_META_NOISE_REDUCTION_MODE, metadata);
+ camMetadata.update(ANDROID_NOISE_REDUCTION_MODE , noiseRedMode, 1);
+
+ /*CAM_INTF_META_SCALER_CROP_REGION - check size*/
+
+ cam_crop_region_t *scalerCropRegion = (cam_crop_region_t *)
+ POINTER_OF(CAM_INTF_META_SCALER_CROP_REGION, metadata);
+ camMetadata.update(ANDROID_SCALER_CROP_REGION,
+ (int32_t*)scalerCropRegion,
+ sizeof(scalerCropRegion)/sizeof(cam_crop_region_t));
+
+ int64_t *sensorExpTime =
+ (int64_t *)POINTER_OF(CAM_INTF_META_SENSOR_EXPOSURE_TIME, metadata);
+ camMetadata.update(ANDROID_SENSOR_EXPOSURE_TIME , sensorExpTime, 1);
+
+ int64_t *sensorFameDuration =
+ (int64_t *)POINTER_OF(CAM_INTF_META_SENSOR_FRAME_DURATION, metadata);
+ camMetadata.update(ANDROID_SENSOR_FRAME_DURATION, sensorFameDuration, 1);
+
+ int32_t *sensorSensitivity =
+ (int32_t *)POINTER_OF(CAM_INTF_META_SENSOR_SENSITIVITY, metadata);
+ camMetadata.update(ANDROID_SENSOR_SENSITIVITY, sensorSensitivity, 1);
+
+ int64_t *sensorTimestamp =
+ (int64_t *)POINTER_OF(CAM_INTF_META_SENSOR_TIMESTAMP, metadata);
+ camMetadata.update(ANDROID_SENSOR_TIMESTAMP, sensorTimestamp, 1);
+
+ int32_t *shadingMode =
+ (int32_t *)POINTER_OF(CAM_INTF_META_SHADING_MODE, metadata);
+ camMetadata.update(ANDROID_SHADING_MODE, shadingMode, 1);
+
+ int32_t *faceDetectMode =
+ (int32_t *)POINTER_OF(CAM_INTF_META_STATS_FACEDETECT_MODE, metadata);
+ camMetadata.update(ANDROID_STATISTICS_FACE_DETECT_MODE, faceDetectMode, 1);
+
+ int32_t *histogramMode =
+ (int32_t *)POINTER_OF(CAM_INTF_META_STATS_HISTOGRAM_MODE, metadata);
+ camMetadata.update(ANDROID_STATISTICS_HISTOGRAM_MODE, histogramMode, 1);
+
+ int32_t *sharpnessMapMode =
+ (int32_t *)POINTER_OF(CAM_INTF_META_STATS_SHARPNESS_MAP_MODE, metadata);
+ camMetadata.update(ANDROID_STATISTICS_SHARPNESS_MAP_MODE,
+ sharpnessMapMode, 1);
+
+ /*CAM_INTF_META_STATS_SHARPNESS_MAP - check size*/
+ cam_sharpness_map_t *sharpnessMap = (cam_sharpness_map_t *)
+ POINTER_OF(CAM_INTF_META_STATS_SHARPNESS_MAP, metadata);
+ camMetadata.update(ANDROID_STATISTICS_SHARPNESS_MAP,
+ (int32_t*)sharpnessMap->sharpness,
+ CAM_MAX_MAP_WIDTH*CAM_MAX_MAP_HEIGHT);
+
+ resultMetadata = camMetadata.release();
+ return NULL;
+}
+
+/*===========================================================================
+ * FUNCTION : convertRegions
+ *
+ * DESCRIPTION: helper method to convert from cam_rect_t into int32_t array
+ *
+ * PARAMETERS :
+ * @rect : cam_rect_t struct to convert
+ * @region : int32_t destination array
+ * @weight : if we are converting from cam_area_t, weight is valid
+ * else weight = -1
+ *
+ *==========================================================================*/
+void QCamera3HardwareInterface::convertRegions(cam_rect_t rect, int32_t* region, int weight){
+ region[0] = rect.left;
+ region[1] = rect.top;
+ region[2] = rect.width;
+ region[3] = rect.height;
+ if (weight > -1) {
+ region[4] = weight;
+ }
+}
+/*===========================================================================
+ * FUNCTION : convertLandmarks
+ *
+ * DESCRIPTION: helper method to extract the landmarks from face detection info
+ *
+ * PARAMETERS :
+ * @face : cam_rect_t struct to convert
+ * @landmarks : int32_t destination array
+ *
+ *
+ *==========================================================================*/
+void QCamera3HardwareInterface::convertLandmarks(cam_face_detection_info_t face, int32_t* landmarks)
+{
+ landmarks[0] = face.left_eye_center.x;
+ landmarks[1] = face.left_eye_center.y;
+ landmarks[2] = face.right_eye_center.y;
+ landmarks[3] = face.right_eye_center.y;
+ landmarks[4] = face.mouth_center.x;
+ landmarks[5] = face.mouth_center.y;
+}
+
#define DATA_PTR(MEM_OBJ,INDEX) MEM_OBJ->getPtr( INDEX )
/*===========================================================================
* FUNCTION : initCapabilities
@@ -938,7 +1201,7 @@
int QCamera3HardwareInterface::initStaticMetadata(int cameraId)
{
int rc = 0;
- android::CameraMetadata staticInfo;
+ CameraMetadata staticInfo;
int facingBack = gCamCapability[cameraId]->position == CAM_POSITION_BACK;
/*HAL 3 only*/
#ifdef HAL_3_CAPABILITIES
@@ -1304,6 +1567,19 @@
available_jpeg_sizes,
sizeof(available_jpeg_sizes)/sizeof(int32_t));
+ static int32_t max_jpeg_size = 0;
+ int temp_width, temp_height;
+ for (int i = 0; i < gCamCapability[cameraId]->picture_sizes_tbl_cnt; i++) {
+ temp_width = gCamCapability[cameraId]->picture_sizes_tbl[i].width;
+ temp_height = gCamCapability[cameraId]->picture_sizes_tbl[i].height;
+ if (temp_width * temp_height > max_jpeg_size ) {
+ max_jpeg_size = temp_width * temp_height;
+ }
+ }
+ max_jpeg_size = max_jpeg_size * 3/2 + sizeof(camera3_jpeg_blob_t);
+ staticInfo.update(ANDROID_JPEG_MAX_SIZE,
+ &max_jpeg_size, 1);
+
static int32_t avail_effects[CAM_EFFECT_MODE_MAX];
for (int i = 0; i < gCamCapability[cameraId]->supported_effects_cnt; i++) {
avail_effects[i] = lookupFwkName(EFFECT_MODES_MAP,
@@ -1612,7 +1888,7 @@
* failure: NULL
*
*==========================================================================*/
-camera_metadata_t* QCamera3HardwareInterface::translateToMetadata(int type)
+camera_metadata_t* QCamera3HardwareInterface::translateCapabilityToMetadata(int type)
{
pthread_mutex_lock(&mMutex);
@@ -1622,7 +1898,7 @@
}
//first time we are handling this request
//fill up the metadata structure using the wrapper class
- android::CameraMetadata settings;
+ CameraMetadata settings;
//translate from cam_capability_t to camera_metadata_tag_t
static const uint8_t requestType = ANDROID_REQUEST_TYPE_CAPTURE;
settings.update(ANDROID_REQUEST_TYPE, &requestType, 1);
@@ -1748,40 +2024,220 @@
(const camera_metadata_t *settings)
{
int rc = 0;
- android::CameraMetadata frame_settings;
+ CameraMetadata frame_settings;
frame_settings = settings;
- //white balance
- int32_t fwk_whiteLevel = frame_settings.find(ANDROID_CONTROL_AWB_MODE).data.i32[0];
+ int32_t antibandingMode =
+ frame_settings.find(ANDROID_CONTROL_AE_ANTIBANDING_MODE).data.i32[0];
+ rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_PARM_ANTIBANDING,
+ sizeof(antibandingMode), &antibandingMode);
+
+ /*int32_t expCompensation = frame_settings.find().data.i32[0];
+ rc = AddSetParmEntryToBatch(mParameters,
+ CAM_INTF_PARM_EXPOSURE_COMPENSATION,
+ sizeof(expCompensation), &expCompensation);*/
+
+ int32_t aeLock = frame_settings.find(ANDROID_CONTROL_AE_LOCK).data.i32[0];
+ rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_PARM_AEC_LOCK,
+ sizeof(aeLock), &aeLock);
+
+ int32_t focusMode =
+ frame_settings.find(ANDROID_CONTROL_AF_MODE).data.i32[0];
+ rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_PARM_FOCUS_MODE,
+ sizeof(focusMode), &focusMode);
+
+ int32_t awbLock = frame_settings.find(ANDROID_CONTROL_AWB_LOCK).data.i32[0];
+ rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_PARM_AWB_LOCK,
+ sizeof(awbLock), &awbLock);
+
+ int32_t fwk_whiteLevel =
+ frame_settings.find(ANDROID_CONTROL_AWB_MODE).data.i32[0];
int whiteLevel = lookupHalName(WHITE_BALANCE_MODES_MAP,
- sizeof(WHITE_BALANCE_MODES_MAP)/ sizeof(int32_t),
- fwk_whiteLevel);
+ sizeof(WHITE_BALANCE_MODES_MAP)/ sizeof(int32_t),
+ fwk_whiteLevel);
rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_PARM_WHITE_BALANCE,
- sizeof(whiteLevel), &whiteLevel);
- //effect
- int32_t fwk_effectMode = frame_settings.find(ANDROID_CONTROL_EFFECT_MODE).data.i32[0];
+ sizeof(whiteLevel), &whiteLevel);
+
+ int32_t fwk_effectMode =
+ frame_settings.find(ANDROID_CONTROL_EFFECT_MODE).data.i32[0];
int effectMode = lookupHalName(EFFECT_MODES_MAP,
- sizeof(EFFECT_MODES_MAP)/ sizeof(int32_t),
- fwk_effectMode);
+ sizeof(EFFECT_MODES_MAP)/ sizeof(int32_t),
+ fwk_effectMode);
rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_PARM_EFFECT,
- sizeof(effectMode), &effectMode);
- //ae mode
- int32_t fwk_aeMode = frame_settings.find(ANDROID_CONTROL_AE_MODE).data.i32[0];
+ sizeof(effectMode), &effectMode);
+ int32_t fwk_aeMode =
+ frame_settings.find(ANDROID_CONTROL_AE_MODE).data.i32[0];
int aeMode = lookupHalName(AUTO_EXPOSURE_MAP,
- sizeof(AUTO_EXPOSURE_MAP)/ sizeof(int32_t),
- fwk_aeMode);
+ sizeof(AUTO_EXPOSURE_MAP)/ sizeof(int32_t),
+ fwk_aeMode);
rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_AEC_MODE,
- sizeof(aeMode), &aeMode);
+ sizeof(aeMode), &aeMode);
- //scaler crop region
- int32_t scalerCropRegion = frame_settings.find(ANDROID_SCALER_CROP_REGION).data.i32[0];
+ int32_t metaFrameNumber =
+ frame_settings.find(ANDROID_REQUEST_FRAME_COUNT).data.i32[0];
+ rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_FRAME_NUMBER,
+ sizeof(metaFrameNumber), &metaFrameNumber);
+
+ int32_t colorCorrectMode =
+ frame_settings.find(ANDROID_COLOR_CORRECTION_MODE).data.i32[0];
+ rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_COLOR_CORRECT_MODE,
+ sizeof(colorCorrectMode), &colorCorrectMode);
+
+ int32_t aecTrigger =
+ frame_settings.find(ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER).data.i32[0];
+ rc = AddSetParmEntryToBatch(mParameters,
+ CAM_INTF_META_AEC_PRECAPTURE_TRIGGER,
+ sizeof(aecTrigger), &aecTrigger);
+
+ int32_t afTrigger =
+ frame_settings.find(ANDROID_CONTROL_AF_TRIGGER).data.i32[0];
+ rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_AF_TRIGGER,
+ sizeof(afTrigger), &afTrigger);
+
+
+ int32_t metaMode = frame_settings.find(ANDROID_CONTROL_MODE).data.i32[0];
+ rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_MODE,
+ sizeof(metaMode), &metaMode);
+
+
+ int32_t demosaic = frame_settings.find(ANDROID_DEMOSAIC_MODE).data.u8[0];
+ rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_DEMOSAIC,
+ sizeof(demosaic), &demosaic);
+
+ int32_t edgeMode = frame_settings.find(ANDROID_EDGE_MODE).data.u8[0];
+ rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_EDGE,
+ sizeof(edgeMode), &edgeMode);
+
+
+ int32_t edgeStrength =
+ frame_settings.find(ANDROID_EDGE_STRENGTH).data.i32[0];
+ rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_SHARPNESS_STRENGTH,
+ sizeof(edgeStrength), &edgeStrength);
+
+ int32_t flashPower =
+ frame_settings.find(ANDROID_FLASH_FIRING_POWER).data.u8[0];
+ rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_FLASH_POWER,
+ sizeof(flashPower), &flashPower);
+
+ int64_t flashFiringTime =
+ frame_settings.find(ANDROID_FLASH_FIRING_TIME).data.i64[0];
+ rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_FLASH_FIRING_TIME,
+ sizeof(flashFiringTime), &flashFiringTime);
+
+ int32_t geometricMode =
+ frame_settings.find(ANDROID_GEOMETRIC_MODE).data.u8[0];
+ rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_GEOMETRIC_MODE,
+ sizeof(geometricMode), &geometricMode);
+
+ int32_t geometricStrength =
+ frame_settings.find(ANDROID_GEOMETRIC_STRENGTH).data.u8[0];
+ rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_GEOMETRIC_STRENGTH,
+ sizeof(geometricStrength), &geometricStrength);
+
+ int32_t hotPixelMode =
+ frame_settings.find(ANDROID_HOT_PIXEL_MODE).data.u8[0];
+ rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_HOTPIXEL_MODE,
+ sizeof(hotPixelMode), &hotPixelMode);
+
+
+ float lensAperture =
+ frame_settings.find( ANDROID_LENS_APERTURE).data.f[0];
+ rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_LENS_APERTURE,
+ sizeof(lensAperture), &lensAperture);
+
+
+ float filterDensity =
+ frame_settings.find(ANDROID_LENS_FILTER_DENSITY).data.f[0];
+ rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_LENS_FILTERDENSITY,
+ sizeof(filterDensity), &filterDensity);
+
+
+ float focalLength =
+ frame_settings.find(ANDROID_LENS_FOCAL_LENGTH).data.f[0];
+ rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_LENS_FOCAL_LENGTH,
+ sizeof(focalLength), &focalLength);
+
+ float focalDistance =
+ frame_settings.find(ANDROID_LENS_FOCUS_DISTANCE).data.f[0];
+ rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_LENS_FOCUS_DISTANCE,
+ sizeof(focalDistance), &focalDistance);
+
+ int32_t optStabMode =
+ frame_settings.find(ANDROID_LENS_OPTICAL_STABILIZATION_MODE).data.u8[0];
+ rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_LENS_OPT_STAB_MODE,
+ sizeof(optStabMode), &optStabMode);
+
+ int32_t noiseRedMode =
+ frame_settings.find(ANDROID_NOISE_REDUCTION_MODE).data.u8[0];
+ rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_NOISE_REDUCTION_MODE,
+ sizeof(noiseRedMode), &noiseRedMode);
+
+ int32_t noiseRedStrength =
+ frame_settings.find(ANDROID_NOISE_REDUCTION_STRENGTH).data.u8[0];
+ rc = AddSetParmEntryToBatch(mParameters,
+ CAM_INTF_META_NOISE_REDUCTION_STRENGTH,
+ sizeof(noiseRedStrength), &noiseRedStrength);
+
+ cam_crop_region_t scalerCropRegion;
+ scalerCropRegion.left =
+ frame_settings.find(ANDROID_SCALER_CROP_REGION).data.i32[0];
+ scalerCropRegion.top =
+ frame_settings.find(ANDROID_SCALER_CROP_REGION).data.i32[1];
+ scalerCropRegion.width =
+ frame_settings.find(ANDROID_SCALER_CROP_REGION).data.i32[2];
rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_SCALER_CROP_REGION,
- sizeof(scalerCropRegion), &scalerCropRegion);
+ sizeof(scalerCropRegion), &scalerCropRegion);
- //capture_intent
- int32_t captureIntent = frame_settings.find(ANDROID_CONTROL_CAPTURE_INTENT).data.i32[0];
+ int64_t sensorExpTime =
+ frame_settings.find(ANDROID_SENSOR_EXPOSURE_TIME).data.i64[0];
+ rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_SENSOR_EXPOSURE_TIME,
+ sizeof(sensorExpTime), &sensorExpTime);
+
+ int64_t sensorFrameDuration =
+ frame_settings.find(ANDROID_SENSOR_FRAME_DURATION).data.i64[0];
+ rc = AddSetParmEntryToBatch(mParameters,
+ CAM_INTF_META_SENSOR_FRAME_DURATION,
+ sizeof(sensorFrameDuration), &sensorFrameDuration);
+
+ int32_t sensorSensitivity =
+ frame_settings.find(ANDROID_SENSOR_SENSITIVITY).data.i32[0];
+ rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_SENSOR_SENSITIVITY,
+ sizeof(sensorSensitivity), &sensorSensitivity);
+
+ int32_t shadingMode = frame_settings.find(ANDROID_SHADING_MODE).data.u8[0];
+ rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_SHADING_MODE,
+ sizeof(shadingMode), &shadingMode);
+
+ int32_t shadingStrength =
+ frame_settings.find(ANDROID_SHADING_STRENGTH).data.u8[0];
+ rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_SHADING_STRENGTH,
+ sizeof(shadingStrength), &shadingStrength);
+
+ int32_t facedetectMode =
+ frame_settings.find(ANDROID_STATISTICS_FACE_DETECT_MODE).data.u8[0];
+ rc = AddSetParmEntryToBatch(mParameters,
+ CAM_INTF_META_STATS_FACEDETECT_MODE,
+ sizeof(facedetectMode), &facedetectMode);
+
+ int32_t histogramMode =
+ frame_settings.find(ANDROID_STATISTICS_HISTOGRAM_MODE).data.u8[0];
+ rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_STATS_HISTOGRAM_MODE,
+ sizeof(histogramMode), &histogramMode);
+
+ int32_t sharpnessMapMode =
+ frame_settings.find(ANDROID_STATISTICS_SHARPNESS_MAP_MODE).data.u8[0];
+ rc = AddSetParmEntryToBatch(mParameters,
+ CAM_INTF_META_STATS_SHARPNESS_MAP_MODE,
+ sizeof(sharpnessMapMode), &sharpnessMapMode);
+
+ int32_t tonemapMode = frame_settings.find(ANDROID_TONEMAP_MODE).data.u8[0];
+ rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_TONEMAP_MODE,
+ sizeof(tonemapMode), &tonemapMode);
+
+ int32_t captureIntent =
+ frame_settings.find(ANDROID_CONTROL_CAPTURE_INTENT).data.i32[0];
rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_CAPTURE_INTENT,
- sizeof(captureIntent), &captureIntent);
+ sizeof(captureIntent), &captureIntent);
return rc;
}
@@ -1807,7 +2263,7 @@
mJpegSettings = NULL;
}
mJpegSettings = (jpeg_settings_t*) malloc(sizeof(jpeg_settings_t));
- android::CameraMetadata jpeg_settings;
+ CameraMetadata jpeg_settings;
jpeg_settings = settings;
mJpegSettings->jpeg_orientation =
@@ -1956,7 +2412,7 @@
return NULL;
}
- fwk_metadata = hw->translateToMetadata(type);
+ fwk_metadata = hw->translateCapabilityToMetadata(type);
return fwk_metadata;
}
diff --git a/camera/QCamera2/HAL3/QCamera3HWI.h b/camera/QCamera2/HAL3/QCamera3HWI.h
index 02d9808..7b7f27e 100644
--- a/camera/QCamera2/HAL3/QCamera3HWI.h
+++ b/camera/QCamera2/HAL3/QCamera3HWI.h
@@ -27,13 +27,14 @@
*
*/
-#ifndef __QCAMERA2HARDWAREINTERFACE_H__
-#define __QCAMERA2HARDWAREINTERFACE_H__
+#ifndef __QCAMERA3HARDWAREINTERFACE_H__
+#define __QCAMERA3HARDWAREINTERFACE_H__
#include <pthread.h>
#include <utils/List.h>
#include <hardware/camera3.h>
#include <camera/CameraMetadata.h>
+#include "QCamera3HALHeader.h"
extern "C" {
#include <mm_camera_interface.h>
@@ -78,13 +79,14 @@
virtual ~QCamera3HardwareInterface();
int openCamera(struct hw_device_t **hw_device);
int getMetadata(int type);
- camera_metadata_t* translateToMetadata(int type);
- int metadataToParam(CameraMetadata &metadata);
+ camera_metadata_t* translateCapabilityToMetadata(int type);
static int getCamInfo(int cameraId, struct camera_info *info);
static int initCapabilities(int cameraId);
static int initStaticMetadata(int cameraId);
static void makeTable(cam_dimension_t* dimTable, uint8_t size, int32_t* sizeTable);
+ static void convertRegions(cam_rect_t rect, int32_t* region, int weight);
+ static void convertLandmarks(cam_face_detection_info_t face, int32_t* landmarks);
static int32_t getScalarFormat(int32_t format);
static void captureResultCb(metadata_buffer_t *metadata,
@@ -105,6 +107,7 @@
int setFrameParameters(int frame_id, const camera_metadata_t *settings);
int translateMetadataToParameters(const camera_metadata_t *settings);
+ camera_metadata_t* translateCbMetadataToResultMetadata(metadata_buffer_t *metadata);
int getJpegSettings(const camera_metadata_t *settings);
int initParameters();
@@ -158,18 +161,6 @@
//mutex to protect the critial section for processCaptureResult
pthread_mutex_t mCaptureResultLock;
-
- typedef struct {
- int32_t jpeg_orientation;
- uint8_t jpeg_quality;
- cam_dimension_t thumbnail_size;
- int64_t gps_timestamp;
- double gps_coordinates[3];
- uint8_t gps_processing_method;
- int32_t sensor_sensitivity;
- float lens_focal_length;
- } jpeg_settings_t;
-
jpeg_settings_t* mJpegSettings;
static const QCameraMap EFFECT_MODES_MAP[];
static const QCameraMap WHITE_BALANCE_MODES_MAP[];
