Mirror/libcamera
1
0
Fork 0
mirror of https://git.libcamera.org/libcamera/libcamera.git synced 2025-07-15 16:35:06 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions

android: camera_device: Use the new CameraMetadata functions

Browse source 
Now that CameraMetadata supports more convenient functions, use those
instead.

Signed-off-by: Paul Elder <paul.elder@ideasonboard.com>
Reviewed-by: Niklas Söderlund <niklas.soderlund@ragnatech.se>
Reviewed-by: Kieran Bingham <kieran.bingham@ideasonboard.com>
This commit is contained in:
Paul Elder 2021-05-12 18:31:19 +09:00
parent 1ff6887d6b
commit 0bc6ce8f67
1 changed files with 106 additions and 137 deletions
Download patch file Download diff file Expand all files Collapse all files

243
src/android/camera_device.cpp
View file

@ -803,7 +803,7 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
data.push_back(ANDROID_COLOR_CORRECTION_ABERRATION_MODE_OFF); data.push_back(ANDROID_COLOR_CORRECTION_ABERRATION_MODE_OFF);
} }
staticMetadata_->addEntry(ANDROID_COLOR_CORRECTION_AVAILABLE_ABERRATION_MODES, staticMetadata_->addEntry(ANDROID_COLOR_CORRECTION_AVAILABLE_ABERRATION_MODES,
data.data(), data.size()); data);
} }
/* Control static metadata. */ /* Control static metadata. */
@ -814,15 +814,13 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO, ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO,
}; };
staticMetadata_->addEntry(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES, staticMetadata_->addEntry(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES,
aeAvailableAntiBandingModes.data(), aeAvailableAntiBandingModes);
aeAvailableAntiBandingModes.size());
std::vector<uint8_t> aeAvailableModes = { std::vector<uint8_t> aeAvailableModes = {
ANDROID_CONTROL_AE_MODE_ON, ANDROID_CONTROL_AE_MODE_ON,
}; };
staticMetadata_->addEntry(ANDROID_CONTROL_AE_AVAILABLE_MODES, staticMetadata_->addEntry(ANDROID_CONTROL_AE_AVAILABLE_MODES,
aeAvailableModes.data(), aeAvailableModes);
aeAvailableModes.size());
int64_t minFrameDurationNsec = -1; int64_t minFrameDurationNsec = -1;
int64_t maxFrameDurationNsec = -1; int64_t maxFrameDurationNsec = -1;
@ -864,15 +862,14 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
minFps, maxFps, maxFps, maxFps minFps, maxFps, maxFps, maxFps
}; };
staticMetadata_->addEntry(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES, staticMetadata_->addEntry(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES,
availableAeFpsTarget, 4); availableAeFpsTarget);
} }
std::vector<int32_t> aeCompensationRange = { std::vector<int32_t> aeCompensationRange = {
0, 0, 0, 0,
}; };
staticMetadata_->addEntry(ANDROID_CONTROL_AE_COMPENSATION_RANGE, staticMetadata_->addEntry(ANDROID_CONTROL_AE_COMPENSATION_RANGE,
aeCompensationRange.data(), aeCompensationRange);
aeCompensationRange.size());
const camera_metadata_rational_t aeCompensationStep[] = { const camera_metadata_rational_t aeCompensationStep[] = {
{ 0, 1 } { 0, 1 }
@ -884,29 +881,25 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
ANDROID_CONTROL_AF_MODE_OFF, ANDROID_CONTROL_AF_MODE_OFF,
}; };
staticMetadata_->addEntry(ANDROID_CONTROL_AF_AVAILABLE_MODES, staticMetadata_->addEntry(ANDROID_CONTROL_AF_AVAILABLE_MODES,
availableAfModes.data(), availableAfModes);
availableAfModes.size());
std::vector<uint8_t> availableEffects = { std::vector<uint8_t> availableEffects = {
ANDROID_CONTROL_EFFECT_MODE_OFF, ANDROID_CONTROL_EFFECT_MODE_OFF,
}; };
staticMetadata_->addEntry(ANDROID_CONTROL_AVAILABLE_EFFECTS, staticMetadata_->addEntry(ANDROID_CONTROL_AVAILABLE_EFFECTS,
availableEffects.data(), availableEffects);
availableEffects.size());
std::vector<uint8_t> availableSceneModes = { std::vector<uint8_t> availableSceneModes = {
ANDROID_CONTROL_SCENE_MODE_DISABLED, ANDROID_CONTROL_SCENE_MODE_DISABLED,
}; };
staticMetadata_->addEntry(ANDROID_CONTROL_AVAILABLE_SCENE_MODES, staticMetadata_->addEntry(ANDROID_CONTROL_AVAILABLE_SCENE_MODES,
availableSceneModes.data(), availableSceneModes);
availableSceneModes.size());
std::vector<uint8_t> availableStabilizationModes = { std::vector<uint8_t> availableStabilizationModes = {
ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF, ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF,
}; };
staticMetadata_->addEntry(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES, staticMetadata_->addEntry(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES,
availableStabilizationModes.data(), availableStabilizationModes);
availableStabilizationModes.size());
/* /*
* \todo Inspect the Camera capabilities to report the available * \todo Inspect the Camera capabilities to report the available
@ -916,15 +909,13 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
ANDROID_CONTROL_AWB_MODE_AUTO, ANDROID_CONTROL_AWB_MODE_AUTO,
}; };
staticMetadata_->addEntry(ANDROID_CONTROL_AWB_AVAILABLE_MODES, staticMetadata_->addEntry(ANDROID_CONTROL_AWB_AVAILABLE_MODES,
availableAwbModes.data(), availableAwbModes);
availableAwbModes.size());
std::vector<int32_t> availableMaxRegions = { std::vector<int32_t> availableMaxRegions = {
0, 0, 0, 0, 0, 0,
}; };
staticMetadata_->addEntry(ANDROID_CONTROL_MAX_REGIONS, staticMetadata_->addEntry(ANDROID_CONTROL_MAX_REGIONS,
availableMaxRegions.data(), availableMaxRegions);
availableMaxRegions.size());
std::vector<uint8_t> sceneModesOverride = { std::vector<uint8_t> sceneModesOverride = {
ANDROID_CONTROL_AE_MODE_ON, ANDROID_CONTROL_AE_MODE_ON,
@ -932,20 +923,19 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
ANDROID_CONTROL_AF_MODE_OFF, ANDROID_CONTROL_AF_MODE_OFF,
}; };
staticMetadata_->addEntry(ANDROID_CONTROL_SCENE_MODE_OVERRIDES, staticMetadata_->addEntry(ANDROID_CONTROL_SCENE_MODE_OVERRIDES,
sceneModesOverride.data(), sceneModesOverride);
sceneModesOverride.size());
uint8_t aeLockAvailable = ANDROID_CONTROL_AE_LOCK_AVAILABLE_FALSE; uint8_t aeLockAvailable = ANDROID_CONTROL_AE_LOCK_AVAILABLE_FALSE;
staticMetadata_->addEntry(ANDROID_CONTROL_AE_LOCK_AVAILABLE, staticMetadata_->addEntry(ANDROID_CONTROL_AE_LOCK_AVAILABLE,
&aeLockAvailable, 1); aeLockAvailable);
uint8_t awbLockAvailable = ANDROID_CONTROL_AWB_LOCK_AVAILABLE_FALSE; uint8_t awbLockAvailable = ANDROID_CONTROL_AWB_LOCK_AVAILABLE_FALSE;
staticMetadata_->addEntry(ANDROID_CONTROL_AWB_LOCK_AVAILABLE, staticMetadata_->addEntry(ANDROID_CONTROL_AWB_LOCK_AVAILABLE,
&awbLockAvailable, 1); awbLockAvailable);
char availableControlModes = ANDROID_CONTROL_MODE_AUTO; char availableControlModes = ANDROID_CONTROL_MODE_AUTO;
staticMetadata_->addEntry(ANDROID_CONTROL_AVAILABLE_MODES, staticMetadata_->addEntry(ANDROID_CONTROL_AVAILABLE_MODES,
&availableControlModes, 1); availableControlModes);
/* JPEG static metadata. */ /* JPEG static metadata. */
@ -983,9 +973,9 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
thumbnailEntries.push_back(size.height); thumbnailEntries.push_back(size.height);
} }
staticMetadata_->addEntry(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES, staticMetadata_->addEntry(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES,
thumbnailEntries.data(), thumbnailEntries.size()); thumbnailEntries);
staticMetadata_->addEntry(ANDROID_JPEG_MAX_SIZE, &maxJpegBufferSize_, 1); staticMetadata_->addEntry(ANDROID_JPEG_MAX_SIZE, maxJpegBufferSize_);
/* Sensor static metadata. */ /* Sensor static metadata. */
std::array<int32_t, 2> pixelArraySize; std::array<int32_t, 2> pixelArraySize;
@ -994,7 +984,7 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
pixelArraySize[0] = size.width; pixelArraySize[0] = size.width;
pixelArraySize[1] = size.height; pixelArraySize[1] = size.height;
staticMetadata_->addEntry(ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE, staticMetadata_->addEntry(ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE,
pixelArraySize.data(), pixelArraySize.size()); pixelArraySize);
} }
if (properties.contains(properties::UnitCellSize)) { if (properties.contains(properties::UnitCellSize)) {
@ -1004,7 +994,7 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
cellSize.height * pixelArraySize[1] / 1e6f cellSize.height * pixelArraySize[1] / 1e6f
}; };
staticMetadata_->addEntry(ANDROID_SENSOR_INFO_PHYSICAL_SIZE, staticMetadata_->addEntry(ANDROID_SENSOR_INFO_PHYSICAL_SIZE,
physicalSize.data(), physicalSize.size()); physicalSize);
} }
{ {
@ -1017,20 +1007,20 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
static_cast<int32_t>(rects[0].height), static_cast<int32_t>(rects[0].height),
}; };
staticMetadata_->addEntry(ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE, staticMetadata_->addEntry(ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE,
data.data(), data.size()); data);
} }
int32_t sensitivityRange[] = { int32_t sensitivityRange[] = {
32, 2400, 32, 2400,
}; };
staticMetadata_->addEntry(ANDROID_SENSOR_INFO_SENSITIVITY_RANGE, staticMetadata_->addEntry(ANDROID_SENSOR_INFO_SENSITIVITY_RANGE,
&sensitivityRange, 2); sensitivityRange);
/* Report the color filter arrangement if the camera reports it. */ /* Report the color filter arrangement if the camera reports it. */
if (properties.contains(properties::draft::ColorFilterArrangement)) { if (properties.contains(properties::draft::ColorFilterArrangement)) {
uint8_t filterArr = properties.get(properties::draft::ColorFilterArrangement); uint8_t filterArr = properties.get(properties::draft::ColorFilterArrangement);
staticMetadata_->addEntry(ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT, staticMetadata_->addEntry(ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT,
&filterArr, 1); filterArr);
} }
const auto &exposureInfo = controlsInfo.find(&controls::ExposureTime); const auto &exposureInfo = controlsInfo.find(&controls::ExposureTime);
@ -1040,25 +1030,24 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
exposureInfo->second.max().get<int32_t>() * 1000LL, exposureInfo->second.max().get<int32_t>() * 1000LL,
}; };
staticMetadata_->addEntry(ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE, staticMetadata_->addEntry(ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE,
&exposureTimeRange, 2); exposureTimeRange, 2);
} }
staticMetadata_->addEntry(ANDROID_SENSOR_ORIENTATION, &orientation_, 1); staticMetadata_->addEntry(ANDROID_SENSOR_ORIENTATION, orientation_);
std::vector<int32_t> testPatterModes = { std::vector<int32_t> testPatterModes = {
ANDROID_SENSOR_TEST_PATTERN_MODE_OFF, ANDROID_SENSOR_TEST_PATTERN_MODE_OFF,
}; };
staticMetadata_->addEntry(ANDROID_SENSOR_AVAILABLE_TEST_PATTERN_MODES, staticMetadata_->addEntry(ANDROID_SENSOR_AVAILABLE_TEST_PATTERN_MODES,
testPatterModes.data(), testPatterModes);
testPatterModes.size());
uint8_t timestampSource = ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE_UNKNOWN; uint8_t timestampSource = ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE_UNKNOWN;
staticMetadata_->addEntry(ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE, staticMetadata_->addEntry(ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE,
&timestampSource, 1); timestampSource);
if (maxFrameDurationNsec > 0) if (maxFrameDurationNsec > 0)
staticMetadata_->addEntry(ANDROID_SENSOR_INFO_MAX_FRAME_DURATION, staticMetadata_->addEntry(ANDROID_SENSOR_INFO_MAX_FRAME_DURATION,
&maxFrameDurationNsec, 1); maxFrameDurationNsec);
/* Statistics static metadata. */ /* Statistics static metadata. */
uint8_t faceDetectMode = ANDROID_STATISTICS_FACE_DETECT_MODE_OFF; uint8_t faceDetectMode = ANDROID_STATISTICS_FACE_DETECT_MODE_OFF;
@ -1067,7 +1056,7 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
int32_t maxFaceCount = 0; int32_t maxFaceCount = 0;
staticMetadata_->addEntry(ANDROID_STATISTICS_INFO_MAX_FACE_COUNT, staticMetadata_->addEntry(ANDROID_STATISTICS_INFO_MAX_FACE_COUNT,
&maxFaceCount, 1); maxFaceCount);
{ {
std::vector<uint8_t> data; std::vector<uint8_t> data;
@ -1080,25 +1069,24 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
data.push_back(ANDROID_STATISTICS_LENS_SHADING_MAP_MODE_OFF); data.push_back(ANDROID_STATISTICS_LENS_SHADING_MAP_MODE_OFF);
} }
staticMetadata_->addEntry(ANDROID_STATISTICS_INFO_AVAILABLE_LENS_SHADING_MAP_MODES, staticMetadata_->addEntry(ANDROID_STATISTICS_INFO_AVAILABLE_LENS_SHADING_MAP_MODES,
data.data(), data.size()); data);
} }
/* Sync static metadata. */ /* Sync static metadata. */
int32_t maxLatency = ANDROID_SYNC_MAX_LATENCY_UNKNOWN; int32_t maxLatency = ANDROID_SYNC_MAX_LATENCY_UNKNOWN;
staticMetadata_->addEntry(ANDROID_SYNC_MAX_LATENCY, &maxLatency, 1); staticMetadata_->addEntry(ANDROID_SYNC_MAX_LATENCY, maxLatency);
/* Flash static metadata. */ /* Flash static metadata. */
char flashAvailable = ANDROID_FLASH_INFO_AVAILABLE_FALSE; char flashAvailable = ANDROID_FLASH_INFO_AVAILABLE_FALSE;
staticMetadata_->addEntry(ANDROID_FLASH_INFO_AVAILABLE, staticMetadata_->addEntry(ANDROID_FLASH_INFO_AVAILABLE,
&flashAvailable, 1); flashAvailable);
/* Lens static metadata. */ /* Lens static metadata. */
std::vector<float> lensApertures = { std::vector<float> lensApertures = {
2.53 / 100, 2.53 / 100,
}; };
staticMetadata_->addEntry(ANDROID_LENS_INFO_AVAILABLE_APERTURES, staticMetadata_->addEntry(ANDROID_LENS_INFO_AVAILABLE_APERTURES,
lensApertures.data(), lensApertures);
lensApertures.size());
uint8_t lensFacing; uint8_t lensFacing;
switch (facing_) { switch (facing_) {
@ -1113,29 +1101,27 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
lensFacing = ANDROID_LENS_FACING_EXTERNAL; lensFacing = ANDROID_LENS_FACING_EXTERNAL;
break; break;
} }
staticMetadata_->addEntry(ANDROID_LENS_FACING, &lensFacing, 1); staticMetadata_->addEntry(ANDROID_LENS_FACING, lensFacing);
std::vector<float> lensFocalLenghts = { std::vector<float> lensFocalLengths = {
1, 1,
}; };
staticMetadata_->addEntry(ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS, staticMetadata_->addEntry(ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS,
lensFocalLenghts.data(), lensFocalLengths);
lensFocalLenghts.size());
std::vector<uint8_t> opticalStabilizations = { std::vector<uint8_t> opticalStabilizations = {
ANDROID_LENS_OPTICAL_STABILIZATION_MODE_OFF, ANDROID_LENS_OPTICAL_STABILIZATION_MODE_OFF,
}; };
staticMetadata_->addEntry(ANDROID_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION, staticMetadata_->addEntry(ANDROID_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION,
opticalStabilizations.data(), opticalStabilizations);
opticalStabilizations.size());
float hypeFocalDistance = 0; float hypeFocalDistance = 0;
staticMetadata_->addEntry(ANDROID_LENS_INFO_HYPERFOCAL_DISTANCE, staticMetadata_->addEntry(ANDROID_LENS_INFO_HYPERFOCAL_DISTANCE,
&hypeFocalDistance, 1); hypeFocalDistance);
float minFocusDistance = 0; float minFocusDistance = 0;
staticMetadata_->addEntry(ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE, staticMetadata_->addEntry(ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE,
&minFocusDistance, 1); minFocusDistance);
/* Noise reduction modes. */ /* Noise reduction modes. */
{ {
@ -1149,7 +1135,7 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
data.push_back(ANDROID_NOISE_REDUCTION_MODE_OFF); data.push_back(ANDROID_NOISE_REDUCTION_MODE_OFF);
} }
staticMetadata_->addEntry(ANDROID_NOISE_REDUCTION_AVAILABLE_NOISE_REDUCTION_MODES, staticMetadata_->addEntry(ANDROID_NOISE_REDUCTION_AVAILABLE_NOISE_REDUCTION_MODES,
data.data(), data.size()); data);
} }
/* Scaler static metadata. */ /* Scaler static metadata. */
@ -1174,7 +1160,7 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
1.0f * max.height / min.height); 1.0f * max.height / min.height);
} }
staticMetadata_->addEntry(ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM, staticMetadata_->addEntry(ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM,
&maxZoom, 1); maxZoom);
std::vector<uint32_t> availableStreamConfigurations; std::vector<uint32_t> availableStreamConfigurations;
availableStreamConfigurations.reserve(streamConfigurations_.size() * 4); availableStreamConfigurations.reserve(streamConfigurations_.size() * 4);
@ -1193,8 +1179,7 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
ANDROID_SCALER_AVAILABLE_FORMATS_BLOB, 2560, 1920, 33333333, ANDROID_SCALER_AVAILABLE_FORMATS_BLOB, 2560, 1920, 33333333,
}; };
staticMetadata_->addEntry(ANDROID_SCALER_AVAILABLE_STALL_DURATIONS, staticMetadata_->addEntry(ANDROID_SCALER_AVAILABLE_STALL_DURATIONS,
availableStallDurations.data(), availableStallDurations);
availableStallDurations.size());
/* Use the minimum frame duration for all the YUV/RGB formats. */ /* Use the minimum frame duration for all the YUV/RGB formats. */
if (minFrameDurationNsec > 0) { if (minFrameDurationNsec > 0) {
@ -1207,22 +1192,21 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
minFrameDurations.push_back(minFrameDurationNsec); minFrameDurations.push_back(minFrameDurationNsec);
} }
staticMetadata_->addEntry(ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS, staticMetadata_->addEntry(ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS,
minFrameDurations.data(), minFrameDurations);
minFrameDurations.size());
} }
uint8_t croppingType = ANDROID_SCALER_CROPPING_TYPE_CENTER_ONLY; uint8_t croppingType = ANDROID_SCALER_CROPPING_TYPE_CENTER_ONLY;
staticMetadata_->addEntry(ANDROID_SCALER_CROPPING_TYPE, &croppingType, 1); staticMetadata_->addEntry(ANDROID_SCALER_CROPPING_TYPE, croppingType);
/* Info static metadata. */ /* Info static metadata. */
uint8_t supportedHWLevel = ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED; uint8_t supportedHWLevel = ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED;
staticMetadata_->addEntry(ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL, staticMetadata_->addEntry(ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL,
&supportedHWLevel, 1); supportedHWLevel);
/* Request static metadata. */ /* Request static metadata. */
int32_t partialResultCount = 1; int32_t partialResultCount = 1;
staticMetadata_->addEntry(ANDROID_REQUEST_PARTIAL_RESULT_COUNT, staticMetadata_->addEntry(ANDROID_REQUEST_PARTIAL_RESULT_COUNT,
&partialResultCount, 1); partialResultCount);
{ {
/* Default the value to 2 if not reported by the camera. */ /* Default the value to 2 if not reported by the camera. */
@ -1231,13 +1215,13 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
if (infoMap != controlsInfo.end()) if (infoMap != controlsInfo.end())
maxPipelineDepth = infoMap->second.max().get<int32_t>(); maxPipelineDepth = infoMap->second.max().get<int32_t>();
staticMetadata_->addEntry(ANDROID_REQUEST_PIPELINE_MAX_DEPTH, staticMetadata_->addEntry(ANDROID_REQUEST_PIPELINE_MAX_DEPTH,
&maxPipelineDepth, 1); maxPipelineDepth);
} }
/* LIMITED does not support reprocessing. */ /* LIMITED does not support reprocessing. */
uint32_t maxNumInputStreams = 0; uint32_t maxNumInputStreams = 0;
staticMetadata_->addEntry(ANDROID_REQUEST_MAX_NUM_INPUT_STREAMS, staticMetadata_->addEntry(ANDROID_REQUEST_MAX_NUM_INPUT_STREAMS,
&maxNumInputStreams, 1); maxNumInputStreams);
std::vector<uint8_t> availableCapabilities = { std::vector<uint8_t> availableCapabilities = {
ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE, ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE,
@ -1261,11 +1245,10 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
/* Number of { RAW, YUV, JPEG } supported output streams */ /* Number of { RAW, YUV, JPEG } supported output streams */
int32_t numOutStreams[] = { rawStreamAvailable, 2, 1 }; int32_t numOutStreams[] = { rawStreamAvailable, 2, 1 };
staticMetadata_->addEntry(ANDROID_REQUEST_MAX_NUM_OUTPUT_STREAMS, staticMetadata_->addEntry(ANDROID_REQUEST_MAX_NUM_OUTPUT_STREAMS,
&numOutStreams, 3); numOutStreams);
staticMetadata_->addEntry(ANDROID_REQUEST_AVAILABLE_CAPABILITIES, staticMetadata_->addEntry(ANDROID_REQUEST_AVAILABLE_CAPABILITIES,
availableCapabilities.data(), availableCapabilities);
availableCapabilities.size());
std::vector<int32_t> availableCharacteristicsKeys = { std::vector<int32_t> availableCharacteristicsKeys = {
ANDROID_COLOR_CORRECTION_AVAILABLE_ABERRATION_MODES, ANDROID_COLOR_CORRECTION_AVAILABLE_ABERRATION_MODES,
@ -1320,8 +1303,7 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
ANDROID_SYNC_MAX_LATENCY, ANDROID_SYNC_MAX_LATENCY,
}; };
staticMetadata_->addEntry(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS, staticMetadata_->addEntry(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS,
availableCharacteristicsKeys.data(), availableCharacteristicsKeys);
availableCharacteristicsKeys.size());
std::vector<int32_t> availableRequestKeys = { std::vector<int32_t> availableRequestKeys = {
ANDROID_COLOR_CORRECTION_ABERRATION_MODE, ANDROID_COLOR_CORRECTION_ABERRATION_MODE,
@ -1352,8 +1334,7 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
ANDROID_STATISTICS_FACE_DETECT_MODE ANDROID_STATISTICS_FACE_DETECT_MODE
}; };
staticMetadata_->addEntry(ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS, staticMetadata_->addEntry(ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS,
availableRequestKeys.data(), availableRequestKeys);
availableRequestKeys.size());
std::vector<int32_t> availableResultKeys = { std::vector<int32_t> availableResultKeys = {
ANDROID_COLOR_CORRECTION_ABERRATION_MODE, ANDROID_COLOR_CORRECTION_ABERRATION_MODE,
@ -1402,8 +1383,7 @@ const camera_metadata_t *CameraDevice::getStaticMetadata()
ANDROID_STATISTICS_SCENE_FLICKER, ANDROID_STATISTICS_SCENE_FLICKER,
}; };
staticMetadata_->addEntry(ANDROID_REQUEST_AVAILABLE_RESULT_KEYS, staticMetadata_->addEntry(ANDROID_REQUEST_AVAILABLE_RESULT_KEYS,
availableResultKeys.data(), availableResultKeys);
availableResultKeys.size());
if (!staticMetadata_->isValid()) { if (!staticMetadata_->isValid()) {
LOG(HAL, Error) << "Failed to construct static metadata"; LOG(HAL, Error) << "Failed to construct static metadata";
@ -1442,69 +1422,63 @@ std::unique_ptr<CameraMetadata> CameraDevice::requestTemplatePreview()
entry.data.i32, 2); entry.data.i32, 2);
uint8_t aeMode = ANDROID_CONTROL_AE_MODE_ON; uint8_t aeMode = ANDROID_CONTROL_AE_MODE_ON;
requestTemplate->addEntry(ANDROID_CONTROL_AE_MODE, requestTemplate->addEntry(ANDROID_CONTROL_AE_MODE, aeMode);
&aeMode, 1);
int32_t aeExposureCompensation = 0; int32_t aeExposureCompensation = 0;
requestTemplate->addEntry(ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION, requestTemplate->addEntry(ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION,
&aeExposureCompensation, 1); aeExposureCompensation);
uint8_t aePrecaptureTrigger = ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_IDLE; uint8_t aePrecaptureTrigger = ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_IDLE;
requestTemplate->addEntry(ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER, requestTemplate->addEntry(ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER,
&aePrecaptureTrigger, 1); aePrecaptureTrigger);
uint8_t aeLock = ANDROID_CONTROL_AE_LOCK_OFF; uint8_t aeLock = ANDROID_CONTROL_AE_LOCK_OFF;
requestTemplate->addEntry(ANDROID_CONTROL_AE_LOCK, requestTemplate->addEntry(ANDROID_CONTROL_AE_LOCK, aeLock);
&aeLock, 1);
uint8_t aeAntibandingMode = ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO; uint8_t aeAntibandingMode = ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO;
requestTemplate->addEntry(ANDROID_CONTROL_AE_ANTIBANDING_MODE, requestTemplate->addEntry(ANDROID_CONTROL_AE_ANTIBANDING_MODE,
&aeAntibandingMode, 1); aeAntibandingMode);
uint8_t afMode = ANDROID_CONTROL_AF_MODE_OFF; uint8_t afMode = ANDROID_CONTROL_AF_MODE_OFF;
requestTemplate->addEntry(ANDROID_CONTROL_AF_MODE, &afMode, 1); requestTemplate->addEntry(ANDROID_CONTROL_AF_MODE, afMode);
uint8_t afTrigger = ANDROID_CONTROL_AF_TRIGGER_IDLE; uint8_t afTrigger = ANDROID_CONTROL_AF_TRIGGER_IDLE;
requestTemplate->addEntry(ANDROID_CONTROL_AF_TRIGGER, requestTemplate->addEntry(ANDROID_CONTROL_AF_TRIGGER, afTrigger);
&afTrigger, 1);
uint8_t awbMode = ANDROID_CONTROL_AWB_MODE_AUTO; uint8_t awbMode = ANDROID_CONTROL_AWB_MODE_AUTO;
requestTemplate->addEntry(ANDROID_CONTROL_AWB_MODE, requestTemplate->addEntry(ANDROID_CONTROL_AWB_MODE, awbMode);
&awbMode, 1);
uint8_t awbLock = ANDROID_CONTROL_AWB_LOCK_OFF; uint8_t awbLock = ANDROID_CONTROL_AWB_LOCK_OFF;
requestTemplate->addEntry(ANDROID_CONTROL_AWB_LOCK, requestTemplate->addEntry(ANDROID_CONTROL_AWB_LOCK, awbLock);
&awbLock, 1);
uint8_t flashMode = ANDROID_FLASH_MODE_OFF; uint8_t flashMode = ANDROID_FLASH_MODE_OFF;
requestTemplate->addEntry(ANDROID_FLASH_MODE, requestTemplate->addEntry(ANDROID_FLASH_MODE, flashMode);
&flashMode, 1);
uint8_t faceDetectMode = ANDROID_STATISTICS_FACE_DETECT_MODE_OFF; uint8_t faceDetectMode = ANDROID_STATISTICS_FACE_DETECT_MODE_OFF;
requestTemplate->addEntry(ANDROID_STATISTICS_FACE_DETECT_MODE, requestTemplate->addEntry(ANDROID_STATISTICS_FACE_DETECT_MODE,
&faceDetectMode, 1); faceDetectMode);
uint8_t noiseReduction = ANDROID_NOISE_REDUCTION_MODE_OFF; uint8_t noiseReduction = ANDROID_NOISE_REDUCTION_MODE_OFF;
requestTemplate->addEntry(ANDROID_NOISE_REDUCTION_MODE, requestTemplate->addEntry(ANDROID_NOISE_REDUCTION_MODE,
&noiseReduction, 1); noiseReduction);
uint8_t aberrationMode = ANDROID_COLOR_CORRECTION_ABERRATION_MODE_OFF; uint8_t aberrationMode = ANDROID_COLOR_CORRECTION_ABERRATION_MODE_OFF;
requestTemplate->addEntry(ANDROID_COLOR_CORRECTION_ABERRATION_MODE, requestTemplate->addEntry(ANDROID_COLOR_CORRECTION_ABERRATION_MODE,
&aberrationMode, 1); aberrationMode);
uint8_t controlMode = ANDROID_CONTROL_MODE_AUTO; uint8_t controlMode = ANDROID_CONTROL_MODE_AUTO;
requestTemplate->addEntry(ANDROID_CONTROL_MODE, &controlMode, 1); requestTemplate->addEntry(ANDROID_CONTROL_MODE, controlMode);
float lensAperture = 2.53 / 100; float lensAperture = 2.53 / 100;
requestTemplate->addEntry(ANDROID_LENS_APERTURE, &lensAperture, 1); requestTemplate->addEntry(ANDROID_LENS_APERTURE, lensAperture);
uint8_t opticalStabilization = ANDROID_LENS_OPTICAL_STABILIZATION_MODE_OFF; uint8_t opticalStabilization = ANDROID_LENS_OPTICAL_STABILIZATION_MODE_OFF;
requestTemplate->addEntry(ANDROID_LENS_OPTICAL_STABILIZATION_MODE, requestTemplate->addEntry(ANDROID_LENS_OPTICAL_STABILIZATION_MODE,
&opticalStabilization, 1); opticalStabilization);
uint8_t captureIntent = ANDROID_CONTROL_CAPTURE_INTENT_PREVIEW; uint8_t captureIntent = ANDROID_CONTROL_CAPTURE_INTENT_PREVIEW;
requestTemplate->addEntry(ANDROID_CONTROL_CAPTURE_INTENT, requestTemplate->addEntry(ANDROID_CONTROL_CAPTURE_INTENT,
&captureIntent, 1); captureIntent);
return requestTemplate; return requestTemplate;
} }
@ -1580,7 +1554,7 @@ const camera_metadata_t *CameraDevice::constructDefaultRequestSettings(int type)
} }
requestTemplate->updateEntry(ANDROID_CONTROL_CAPTURE_INTENT, requestTemplate->updateEntry(ANDROID_CONTROL_CAPTURE_INTENT,
&captureIntent, 1); captureIntent);
requestTemplates_[type] = std::move(requestTemplate); requestTemplates_[type] = std::move(requestTemplate);
return requestTemplates_[type]->get(); return requestTemplates_[type]->get();
@ -2154,20 +2128,20 @@ CameraDevice::getResultMetadata(const Camera3RequestDescriptor &descriptor) cons
uint8_t value = ANDROID_COLOR_CORRECTION_ABERRATION_MODE_OFF; uint8_t value = ANDROID_COLOR_CORRECTION_ABERRATION_MODE_OFF;
resultMetadata->addEntry(ANDROID_COLOR_CORRECTION_ABERRATION_MODE, resultMetadata->addEntry(ANDROID_COLOR_CORRECTION_ABERRATION_MODE,
&value, 1); value);
value = ANDROID_CONTROL_AE_ANTIBANDING_MODE_OFF; value = ANDROID_CONTROL_AE_ANTIBANDING_MODE_OFF;
resultMetadata->addEntry(ANDROID_CONTROL_AE_ANTIBANDING_MODE, &value, 1); resultMetadata->addEntry(ANDROID_CONTROL_AE_ANTIBANDING_MODE, value);
int32_t value32 = 0; int32_t value32 = 0;
resultMetadata->addEntry(ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION, resultMetadata->addEntry(ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION,
&value32, 1); value32);
value = ANDROID_CONTROL_AE_LOCK_OFF; value = ANDROID_CONTROL_AE_LOCK_OFF;
resultMetadata->addEntry(ANDROID_CONTROL_AE_LOCK, &value, 1); resultMetadata->addEntry(ANDROID_CONTROL_AE_LOCK, value);
value = ANDROID_CONTROL_AE_MODE_ON; value = ANDROID_CONTROL_AE_MODE_ON;
resultMetadata->addEntry(ANDROID_CONTROL_AE_MODE, &value, 1); resultMetadata->addEntry(ANDROID_CONTROL_AE_MODE, value);
if (settings.getEntry(ANDROID_CONTROL_AE_TARGET_FPS_RANGE, &entry)) if (settings.getEntry(ANDROID_CONTROL_AE_TARGET_FPS_RANGE, &entry))
/* /*
@ -2178,109 +2152,104 @@ CameraDevice::getResultMetadata(const Camera3RequestDescriptor &descriptor) cons
resultMetadata->addEntry(ANDROID_CONTROL_AE_TARGET_FPS_RANGE, resultMetadata->addEntry(ANDROID_CONTROL_AE_TARGET_FPS_RANGE,
entry.data.i32, 2); entry.data.i32, 2);
value = ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_IDLE;
found = settings.getEntry(ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER, &entry); found = settings.getEntry(ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER, &entry);
resultMetadata->addEntry(ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER, value = found ? *entry.data.u8 :
found ? entry.data.u8 : &value, 1); (uint8_t)ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_IDLE;
resultMetadata->addEntry(ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER, value);
value = ANDROID_CONTROL_AE_STATE_CONVERGED; value = ANDROID_CONTROL_AE_STATE_CONVERGED;
resultMetadata->addEntry(ANDROID_CONTROL_AE_STATE, &value, 1); resultMetadata->addEntry(ANDROID_CONTROL_AE_STATE, value);
value = ANDROID_CONTROL_AF_MODE_OFF; value = ANDROID_CONTROL_AF_MODE_OFF;
resultMetadata->addEntry(ANDROID_CONTROL_AF_MODE, &value, 1); resultMetadata->addEntry(ANDROID_CONTROL_AF_MODE, value);
value = ANDROID_CONTROL_AF_STATE_INACTIVE; value = ANDROID_CONTROL_AF_STATE_INACTIVE;
resultMetadata->addEntry(ANDROID_CONTROL_AF_STATE, &value, 1); resultMetadata->addEntry(ANDROID_CONTROL_AF_STATE, value);
value = ANDROID_CONTROL_AF_TRIGGER_IDLE; value = ANDROID_CONTROL_AF_TRIGGER_IDLE;
resultMetadata->addEntry(ANDROID_CONTROL_AF_TRIGGER, &value, 1); resultMetadata->addEntry(ANDROID_CONTROL_AF_TRIGGER, value);
value = ANDROID_CONTROL_AWB_MODE_AUTO; value = ANDROID_CONTROL_AWB_MODE_AUTO;
resultMetadata->addEntry(ANDROID_CONTROL_AWB_MODE, &value, 1); resultMetadata->addEntry(ANDROID_CONTROL_AWB_MODE, value);
value = ANDROID_CONTROL_AWB_LOCK_OFF; value = ANDROID_CONTROL_AWB_LOCK_OFF;
resultMetadata->addEntry(ANDROID_CONTROL_AWB_LOCK, &value, 1); resultMetadata->addEntry(ANDROID_CONTROL_AWB_LOCK, value);
value = ANDROID_CONTROL_AWB_STATE_CONVERGED; value = ANDROID_CONTROL_AWB_STATE_CONVERGED;
resultMetadata->addEntry(ANDROID_CONTROL_AWB_STATE, &value, 1); resultMetadata->addEntry(ANDROID_CONTROL_AWB_STATE, value);
value = ANDROID_CONTROL_CAPTURE_INTENT_PREVIEW; value = ANDROID_CONTROL_CAPTURE_INTENT_PREVIEW;
resultMetadata->addEntry(ANDROID_CONTROL_CAPTURE_INTENT, &value, 1); resultMetadata->addEntry(ANDROID_CONTROL_CAPTURE_INTENT, value);
value = ANDROID_CONTROL_EFFECT_MODE_OFF; value = ANDROID_CONTROL_EFFECT_MODE_OFF;
resultMetadata->addEntry(ANDROID_CONTROL_EFFECT_MODE, &value, 1); resultMetadata->addEntry(ANDROID_CONTROL_EFFECT_MODE, value);
value = ANDROID_CONTROL_MODE_AUTO; value = ANDROID_CONTROL_MODE_AUTO;
resultMetadata->addEntry(ANDROID_CONTROL_MODE, &value, 1); resultMetadata->addEntry(ANDROID_CONTROL_MODE, value);
value = ANDROID_CONTROL_SCENE_MODE_DISABLED; value = ANDROID_CONTROL_SCENE_MODE_DISABLED;
resultMetadata->addEntry(ANDROID_CONTROL_SCENE_MODE, &value, 1); resultMetadata->addEntry(ANDROID_CONTROL_SCENE_MODE, value);
value = ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF; value = ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF;
resultMetadata->addEntry(ANDROID_CONTROL_VIDEO_STABILIZATION_MODE, &value, 1); resultMetadata->addEntry(ANDROID_CONTROL_VIDEO_STABILIZATION_MODE, value);
value = ANDROID_FLASH_MODE_OFF; value = ANDROID_FLASH_MODE_OFF;
resultMetadata->addEntry(ANDROID_FLASH_MODE, &value, 1); resultMetadata->addEntry(ANDROID_FLASH_MODE, value);
value = ANDROID_FLASH_STATE_UNAVAILABLE; value = ANDROID_FLASH_STATE_UNAVAILABLE;
resultMetadata->addEntry(ANDROID_FLASH_STATE, &value, 1); resultMetadata->addEntry(ANDROID_FLASH_STATE, value);
if (settings.getEntry(ANDROID_LENS_APERTURE, &entry)) if (settings.getEntry(ANDROID_LENS_APERTURE, &entry))
resultMetadata->addEntry(ANDROID_LENS_APERTURE, entry.data.f, 1); resultMetadata->addEntry(ANDROID_LENS_APERTURE, entry.data.f, 1);
float focal_length = 1.0; float focal_length = 1.0;
resultMetadata->addEntry(ANDROID_LENS_FOCAL_LENGTH, &focal_length, 1); resultMetadata->addEntry(ANDROID_LENS_FOCAL_LENGTH, focal_length);
value = ANDROID_LENS_STATE_STATIONARY; value = ANDROID_LENS_STATE_STATIONARY;
resultMetadata->addEntry(ANDROID_LENS_STATE, &value, 1); resultMetadata->addEntry(ANDROID_LENS_STATE, value);
value = ANDROID_LENS_OPTICAL_STABILIZATION_MODE_OFF; value = ANDROID_LENS_OPTICAL_STABILIZATION_MODE_OFF;
resultMetadata->addEntry(ANDROID_LENS_OPTICAL_STABILIZATION_MODE, resultMetadata->addEntry(ANDROID_LENS_OPTICAL_STABILIZATION_MODE,
&value, 1); value);
value32 = ANDROID_SENSOR_TEST_PATTERN_MODE_OFF; value32 = ANDROID_SENSOR_TEST_PATTERN_MODE_OFF;
resultMetadata->addEntry(ANDROID_SENSOR_TEST_PATTERN_MODE, resultMetadata->addEntry(ANDROID_SENSOR_TEST_PATTERN_MODE, value32);
&value32, 1);
value = ANDROID_STATISTICS_FACE_DETECT_MODE_OFF; value = ANDROID_STATISTICS_FACE_DETECT_MODE_OFF;
resultMetadata->addEntry(ANDROID_STATISTICS_FACE_DETECT_MODE, resultMetadata->addEntry(ANDROID_STATISTICS_FACE_DETECT_MODE, value);
&value, 1);
value = ANDROID_STATISTICS_LENS_SHADING_MAP_MODE_OFF; value = ANDROID_STATISTICS_LENS_SHADING_MAP_MODE_OFF;
resultMetadata->addEntry(ANDROID_STATISTICS_LENS_SHADING_MAP_MODE, resultMetadata->addEntry(ANDROID_STATISTICS_LENS_SHADING_MAP_MODE,
&value, 1); value);
value = ANDROID_STATISTICS_HOT_PIXEL_MAP_MODE_OFF; value = ANDROID_STATISTICS_HOT_PIXEL_MAP_MODE_OFF;
resultMetadata->addEntry(ANDROID_STATISTICS_HOT_PIXEL_MAP_MODE, resultMetadata->addEntry(ANDROID_STATISTICS_HOT_PIXEL_MAP_MODE, value);
&value, 1);
value = ANDROID_STATISTICS_SCENE_FLICKER_NONE; value = ANDROID_STATISTICS_SCENE_FLICKER_NONE;
resultMetadata->addEntry(ANDROID_STATISTICS_SCENE_FLICKER, resultMetadata->addEntry(ANDROID_STATISTICS_SCENE_FLICKER, value);
&value, 1);
value = ANDROID_NOISE_REDUCTION_MODE_OFF; value = ANDROID_NOISE_REDUCTION_MODE_OFF;
resultMetadata->addEntry(ANDROID_NOISE_REDUCTION_MODE, &value, 1); resultMetadata->addEntry(ANDROID_NOISE_REDUCTION_MODE, value);
/* 33.3 msec */ /* 33.3 msec */
const int64_t rolling_shutter_skew = 33300000; const int64_t rolling_shutter_skew = 33300000;
resultMetadata->addEntry(ANDROID_SENSOR_ROLLING_SHUTTER_SKEW, resultMetadata->addEntry(ANDROID_SENSOR_ROLLING_SHUTTER_SKEW,
&rolling_shutter_skew, 1); rolling_shutter_skew);
/* Add metadata tags reported by libcamera. */ /* Add metadata tags reported by libcamera. */
const int64_t timestamp = metadata.get(controls::SensorTimestamp); const int64_t timestamp = metadata.get(controls::SensorTimestamp);
resultMetadata->addEntry(ANDROID_SENSOR_TIMESTAMP, &timestamp, 1); resultMetadata->addEntry(ANDROID_SENSOR_TIMESTAMP, timestamp);
if (metadata.contains(controls::draft::PipelineDepth)) { if (metadata.contains(controls::draft::PipelineDepth)) {
uint8_t pipeline_depth = uint8_t pipeline_depth =
metadata.get<int32_t>(controls::draft::PipelineDepth); metadata.get<int32_t>(controls::draft::PipelineDepth);
resultMetadata->addEntry(ANDROID_REQUEST_PIPELINE_DEPTH, resultMetadata->addEntry(ANDROID_REQUEST_PIPELINE_DEPTH,
&pipeline_depth, 1); pipeline_depth);
} }
if (metadata.contains(controls::ExposureTime)) { if (metadata.contains(controls::ExposureTime)) {
int64_t exposure = metadata.get(controls::ExposureTime) * 1000ULL; int64_t exposure = metadata.get(controls::ExposureTime) * 1000ULL;
resultMetadata->addEntry(ANDROID_SENSOR_EXPOSURE_TIME, resultMetadata->addEntry(ANDROID_SENSOR_EXPOSURE_TIME, exposure);
&exposure, 1);
} }
if (metadata.contains(controls::ScalerCrop)) { if (metadata.contains(controls::ScalerCrop)) {
@ -2289,7 +2258,7 @@ CameraDevice::getResultMetadata(const Camera3RequestDescriptor &descriptor) cons
crop.x, crop.y, static_cast<int32_t>(crop.width), crop.x, crop.y, static_cast<int32_t>(crop.width),
static_cast<int32_t>(crop.height), static_cast<int32_t>(crop.height),
}; };
resultMetadata->addEntry(ANDROID_SCALER_CROP_REGION, cropRect, 4); resultMetadata->addEntry(ANDROID_SCALER_CROP_REGION, cropRect);
} }
/* /*