1 /*
2 * Copyright (C) 2023 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #define FAILURE_DEBUG_PREFIX "CameraDevice"
18
19 #include <string_view>
20
21 #include <system/camera_metadata.h>
22 #include <system/graphics.h>
23
24 #include "CameraDevice.h"
25 #include "CameraDeviceSession.h"
26 #include "debug.h"
27
28 namespace android {
29 namespace hardware {
30 namespace camera {
31 namespace provider {
32 namespace implementation {
33 namespace {
34 const uint32_t kExtraResultKeys[] = {
35 ANDROID_CONTROL_AE_STATE,
36 ANDROID_CONTROL_AF_STATE,
37 ANDROID_CONTROL_AWB_STATE,
38 ANDROID_FLASH_STATE,
39 ANDROID_LENS_FOCUS_DISTANCE,
40 ANDROID_LENS_STATE,
41 ANDROID_REQUEST_PIPELINE_DEPTH,
42 ANDROID_SENSOR_TIMESTAMP, // populate with zero, CameraDeviceSession will put an actual value
43 ANDROID_SENSOR_ROLLING_SHUTTER_SKEW,
44 ANDROID_STATISTICS_SCENE_FLICKER,
45 };
46
getSortedKeys(const CameraMetadataMap & m)47 std::vector<uint32_t> getSortedKeys(const CameraMetadataMap& m) {
48 std::vector<uint32_t> keys;
49 keys.reserve(m.size());
50 for (const auto& [tag, unused] : m) {
51 keys.push_back(tag);
52 }
53 std::sort(keys.begin(), keys.end());
54 return keys;
55 }
56
57 camera_metadata_enum_android_control_capture_intent_t
MapRequestTemplateToIntent(const RequestTemplate tpl)58 MapRequestTemplateToIntent(const RequestTemplate tpl) {
59 switch (tpl) {
60 case RequestTemplate::PREVIEW:
61 return ANDROID_CONTROL_CAPTURE_INTENT_PREVIEW;
62 case RequestTemplate::STILL_CAPTURE:
63 return ANDROID_CONTROL_CAPTURE_INTENT_STILL_CAPTURE;
64 case RequestTemplate::VIDEO_RECORD:
65 return ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_RECORD;
66 case RequestTemplate::VIDEO_SNAPSHOT:
67 return ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_SNAPSHOT;
68 case RequestTemplate::ZERO_SHUTTER_LAG:
69 return ANDROID_CONTROL_CAPTURE_INTENT_ZERO_SHUTTER_LAG;
70 case RequestTemplate::MANUAL:
71 return ANDROID_CONTROL_CAPTURE_INTENT_MANUAL;
72 default:
73 return ANDROID_CONTROL_CAPTURE_INTENT_CUSTOM;
74 }
75 }
76
77 } // namespace
78
79 using aidl::android::hardware::camera::common::Status;
80 using hw::HwCameraFactoryProduct;
81
CameraDevice(HwCameraFactoryProduct hwCamera)82 CameraDevice::CameraDevice(HwCameraFactoryProduct hwCamera)
83 : mHwCamera(std::move(hwCamera)) {}
84
~CameraDevice()85 CameraDevice::~CameraDevice() {}
86
getCameraCharacteristics(CameraMetadata * metadata)87 ScopedAStatus CameraDevice::getCameraCharacteristics(CameraMetadata* metadata) {
88 CameraMetadataMap m;
89
90 {
91 m[ANDROID_COLOR_CORRECTION_AVAILABLE_ABERRATION_MODES]
92 .add<uint8_t>(ANDROID_COLOR_CORRECTION_ABERRATION_MODE_OFF);
93 }
94 { // ANDROID_CONTROL_...
95 m[ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES]
96 .add<uint8_t>(ANDROID_CONTROL_AE_ANTIBANDING_MODE_OFF)
97 .add<uint8_t>(ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO);
98 m[ANDROID_CONTROL_AE_AVAILABLE_MODES]
99 .add<uint8_t>(ANDROID_CONTROL_AE_MODE_OFF)
100 .add<uint8_t>(ANDROID_CONTROL_AE_MODE_ON);
101 {
102 auto& ranges = m[ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES];
103 for (const auto& r : mHwCamera->getTargetFpsRanges()) {
104 ranges.add<int32_t>(r.first).add<int32_t>(r.second);
105 }
106 }
107 {
108 const auto aeCompensationRange = mHwCamera->getAeCompensationRange();
109 m[ANDROID_CONTROL_AE_COMPENSATION_RANGE]
110 .add<int32_t>(std::get<0>(aeCompensationRange))
111 .add<int32_t>(std::get<1>(aeCompensationRange));
112
113 const camera_metadata_rational_t aeCompensationStep = {
114 .numerator = std::get<2>(aeCompensationRange),
115 .denominator = std::get<3>(aeCompensationRange),
116 };
117 m[ANDROID_CONTROL_AE_COMPENSATION_STEP] = aeCompensationStep;
118 }
119 m[ANDROID_CONTROL_AF_AVAILABLE_MODES]
120 .add<uint8_t>(ANDROID_CONTROL_AF_MODE_OFF)
121 .add<uint8_t>(ANDROID_CONTROL_AF_MODE_AUTO);
122 m[ANDROID_CONTROL_AVAILABLE_EFFECTS]
123 .add<uint8_t>(ANDROID_CONTROL_EFFECT_MODE_OFF);
124 m[ANDROID_CONTROL_AVAILABLE_SCENE_MODES]
125 .add<uint8_t>(ANDROID_CONTROL_SCENE_MODE_DISABLED);
126 m[ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES]
127 .add<uint8_t>(ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF);
128 m[ANDROID_CONTROL_AWB_AVAILABLE_MODES]
129 .add<uint8_t>(ANDROID_CONTROL_AWB_MODE_OFF)
130 .add<uint8_t>(ANDROID_CONTROL_AWB_MODE_AUTO);
131 m[ANDROID_CONTROL_MAX_REGIONS]
132 .add<int32_t>(0) // AE
133 .add<int32_t>(0) // AWB
134 .add<int32_t>(0); // AF
135 m[ANDROID_CONTROL_AE_LOCK_AVAILABLE] =
136 uint8_t(ANDROID_CONTROL_AE_LOCK_AVAILABLE_FALSE);
137 m[ANDROID_CONTROL_AWB_LOCK_AVAILABLE] =
138 uint8_t(ANDROID_CONTROL_AWB_LOCK_AVAILABLE_FALSE);
139 m[ANDROID_CONTROL_AVAILABLE_MODES]
140 .add<uint8_t>(ANDROID_CONTROL_MODE_OFF)
141 .add<uint8_t>(ANDROID_CONTROL_MODE_AUTO);
142 {
143 const auto zoomRatioRange = mHwCamera->getZoomRatioRange();
144 m[ANDROID_CONTROL_ZOOM_RATIO_RANGE]
145 .add<float>(zoomRatioRange.first)
146 .add<float>(zoomRatioRange.second);
147 }
148 }
149 { // ANDROID_EDGE_...
150 m[ANDROID_EDGE_AVAILABLE_EDGE_MODES]
151 .add<uint8_t>(ANDROID_EDGE_MODE_OFF);
152 }
153 { // ANDROID_FLASH_INFO_...
154 const auto supportedFlashStrength = mHwCamera->getSupportedFlashStrength();
155 if (supportedFlashStrength.first > 0) {
156 m[ANDROID_FLASH_INFO_AVAILABLE] = uint8_t(ANDROID_FLASH_INFO_AVAILABLE_TRUE);
157 m[ANDROID_FLASH_INFO_STRENGTH_MAXIMUM_LEVEL] =
158 int32_t(supportedFlashStrength.first);
159 m[ANDROID_FLASH_INFO_STRENGTH_DEFAULT_LEVEL] =
160 int32_t(supportedFlashStrength.second);
161 } else {
162 m[ANDROID_FLASH_INFO_AVAILABLE] = uint8_t(ANDROID_FLASH_INFO_AVAILABLE_FALSE);
163 }
164 }
165 { // ANDROID_HOT_PIXEL_...
166 m[ANDROID_HOT_PIXEL_AVAILABLE_HOT_PIXEL_MODES]
167 .add<uint8_t>(ANDROID_HOT_PIXEL_MODE_OFF);
168 }
169 { // ANDROID_JPEG_...
170 {
171 auto& v = m[ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES];
172 for (const auto sz : mHwCamera->getAvailableThumbnailSizes()) {
173 v.add<int32_t>(sz.width).add<int32_t>(sz.height);
174 }
175 }
176 m[ANDROID_JPEG_MAX_SIZE] = int32_t(mHwCamera->getJpegMaxSize());
177 }
178 { // ANDROID_LENS_...
179 m[ANDROID_LENS_FACING] = uint8_t(mHwCamera->isBackFacing() ?
180 ANDROID_LENS_FACING_BACK : ANDROID_LENS_FACING_FRONT);
181
182 {
183 auto& v = m[ANDROID_LENS_INFO_AVAILABLE_APERTURES];
184 for (const float ap : mHwCamera->getAvailableApertures()) {
185 v.add<float>(ap);
186 }
187 }
188 {
189 auto& v = m[ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS];
190 for (const float ap : mHwCamera->getAvailableFocalLength()) {
191 v.add<float>(ap);
192 }
193 }
194
195 m[ANDROID_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION]
196 .add<uint8_t>(ANDROID_LENS_OPTICAL_STABILIZATION_MODE_OFF);
197 m[ANDROID_LENS_INFO_HYPERFOCAL_DISTANCE] =
198 float(mHwCamera->getHyperfocalDistance());
199 m[ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE] =
200 float(mHwCamera->getMinimumFocusDistance());
201 m[ANDROID_LENS_INFO_FOCUS_DISTANCE_CALIBRATION] =
202 uint8_t(ANDROID_LENS_INFO_FOCUS_DISTANCE_CALIBRATION_APPROXIMATE);
203 }
204 { // ANDROID_NOISE_REDUCTION_...
205 m[ANDROID_NOISE_REDUCTION_AVAILABLE_NOISE_REDUCTION_MODES]
206 .add<uint8_t>(ANDROID_NOISE_REDUCTION_MODE_OFF);
207 }
208 { // ANDROID_REQUEST_...
209 {
210 const auto maxNumOutputStreams = mHwCamera->getMaxNumOutputStreams();
211 m[ANDROID_REQUEST_MAX_NUM_OUTPUT_STREAMS]
212 .add<int32_t>(std::get<0>(maxNumOutputStreams))
213 .add<int32_t>(std::get<1>(maxNumOutputStreams))
214 .add<int32_t>(std::get<2>(maxNumOutputStreams));
215 }
216
217 m[ANDROID_REQUEST_MAX_NUM_INPUT_STREAMS] = int32_t(0);
218 m[ANDROID_REQUEST_PIPELINE_MAX_DEPTH] = uint8_t(mHwCamera->getPipelineMaxDepth());
219 m[ANDROID_REQUEST_PARTIAL_RESULT_COUNT] = int32_t(1);
220 {
221 auto& availableCaps = m[ANDROID_REQUEST_AVAILABLE_CAPABILITIES];
222 uint32_t availableCapsBitmap =
223 mHwCamera->getAvailableCapabilitiesBitmap();
224
225 for (int i = 0; availableCapsBitmap; ++i, availableCapsBitmap >>= 1) {
226 if (availableCapsBitmap & 1) {
227 availableCaps.add<uint8_t>(i);
228 }
229 }
230 }
231 }
232 { // ANDROID_SCALER_...
233 m[ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM] =
234 float(mHwCamera->getMaxDigitalZoom());
235
236 {
237 auto& streamConfigurations = m[ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS];
238 auto& minFrameDurations = m[ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS];
239 auto& stallDurations = m[ANDROID_SCALER_AVAILABLE_STALL_DURATIONS];
240
241 const int64_t minFrameDurationNs = mHwCamera->getMinFrameDurationNs();
242 const int64_t stallFrameDurationNs = mHwCamera->getStallFrameDurationNs();
243 const auto supportedFormats = mHwCamera->getSupportedPixelFormats();
244
245 for (const auto& res : mHwCamera->getSupportedResolutions()) {
246 for (const auto fmt : supportedFormats) {
247 const int32_t fmti = static_cast<int32_t>(fmt);
248
249 streamConfigurations
250 .add<int32_t>(fmti)
251 .add<int32_t>(res.width).add<int32_t>(res.height)
252 .add<int32_t>(ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT);
253 minFrameDurations
254 .add<int64_t>(fmti)
255 .add<int64_t>(res.width).add<int64_t>(res.height)
256 .add<int64_t>(minFrameDurationNs);
257 stallDurations
258 .add<int64_t>(fmti)
259 .add<int64_t>(res.width).add<int64_t>(res.height)
260 .add<int64_t>((fmt == PixelFormat::BLOB) ? stallFrameDurationNs : 0);
261 }
262 }
263 }
264
265 m[ANDROID_SCALER_CROPPING_TYPE] =
266 uint8_t(ANDROID_SCALER_CROPPING_TYPE_CENTER_ONLY);
267 }
268 { // ANDROID_SENSOR_...
269 m[ANDROID_SENSOR_ORIENTATION] =
270 int32_t(mHwCamera->getSensorOrientation());
271 m[ANDROID_SENSOR_AVAILABLE_TEST_PATTERN_MODES]
272 .add<int32_t>(ANDROID_SENSOR_TEST_PATTERN_MODE_OFF);
273
274 {
275 const auto sensorSize = mHwCamera->getSensorSize();
276 const auto sensorDPI = mHwCamera->getSensorDPI();
277
278 m[ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE]
279 .add<int32_t>(0).add<int32_t>(0)
280 .add<int32_t>(sensorSize.width)
281 .add<int32_t>(sensorSize.height);
282 m[ANDROID_SENSOR_INFO_PHYSICAL_SIZE]
283 .add<float>(sensorSize.width / sensorDPI)
284 .add<float>(sensorSize.height / sensorDPI);
285 m[ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE]
286 .add<int32_t>(sensorSize.width)
287 .add<int32_t>(sensorSize.height);
288 m[ANDROID_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE]
289 .add<int32_t>(0).add<int32_t>(0)
290 .add<int32_t>(sensorSize.width)
291 .add<int32_t>(sensorSize.height);
292 }
293 {
294 const auto senitivityRange = mHwCamera->getSensorSensitivityRange();
295
296 m[ANDROID_SENSOR_INFO_SENSITIVITY_RANGE]
297 .add<int32_t>(senitivityRange.first)
298 .add<int32_t>(senitivityRange.second);
299 }
300
301 m[ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT] =
302 uint8_t(ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_RGB);
303
304 {
305 const auto exposureTimeRange = mHwCamera->getSensorExposureTimeRange();
306
307 m[ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE]
308 .add<int64_t>(exposureTimeRange.first)
309 .add<int64_t>(exposureTimeRange.second);
310 }
311
312 m[ANDROID_SENSOR_INFO_MAX_FRAME_DURATION] =
313 int64_t(mHwCamera->getSensorMaxFrameDuration());
314 m[ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE] =
315 uint8_t(ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE_UNKNOWN); // SYSTEM_TIME_MONOTONIC
316 }
317 { // ANDROID_SHADING_...
318 m[ANDROID_SHADING_AVAILABLE_MODES]
319 .add<uint8_t>(ANDROID_SHADING_MODE_OFF);
320 }
321 { // ANDROID_STATISTICS_...
322 m[ANDROID_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES]
323 .add<uint8_t>(ANDROID_STATISTICS_FACE_DETECT_MODE_OFF);
324 m[ANDROID_STATISTICS_INFO_MAX_FACE_COUNT] = int32_t(0);
325 m[ANDROID_STATISTICS_INFO_AVAILABLE_HOT_PIXEL_MAP_MODES]
326 .add<uint8_t>(ANDROID_STATISTICS_HOT_PIXEL_MAP_MODE_OFF);
327 m[ANDROID_STATISTICS_INFO_AVAILABLE_LENS_SHADING_MAP_MODES]
328 .add<uint8_t>(ANDROID_STATISTICS_LENS_SHADING_MAP_MODE_OFF);
329 }
330 { // ANDROID_INFO_...
331 m[ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL] =
332 uint8_t(ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED);
333 }
334 { // ANDROID_SYNC_
335 m[ANDROID_SYNC_MAX_LATENCY] = ANDROID_SYNC_MAX_LATENCY_UNKNOWN;
336 }
337 { // ANDROID_DISTORTION_CORRECTION_...
338 m[ANDROID_DISTORTION_CORRECTION_AVAILABLE_MODES]
339 .add<uint8_t>(ANDROID_DISTORTION_CORRECTION_MODE_OFF);
340 }
341
342 ////////////////////////////////////////////////////////////////////////////
343 {
344 const std::vector<uint32_t> keys = getSortedKeys(m);
345 CameraMetadataValue& val = m[ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS];
346 for (const uint32_t key : keys) {
347 val.add<int32_t>(key);
348 }
349 }
350 {
351 CameraMetadataMap r = constructDefaultRequestSettings(RequestTemplate::PREVIEW);
352
353 {
354 const std::vector<uint32_t> keys = getSortedKeys(r);
355 CameraMetadataValue& val = m[ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS];
356 for (const uint32_t key : keys) {
357 val.add<int32_t>(key);
358 }
359 }
360
361 for (const uint32_t key : kExtraResultKeys) {
362 r[key];
363 }
364
365 {
366 const std::vector<uint32_t> keys = getSortedKeys(r);
367 CameraMetadataValue& val = m[ANDROID_REQUEST_AVAILABLE_RESULT_KEYS];
368 for (const uint32_t key : keys) {
369 val.add<int32_t>(key);
370 }
371 }
372 }
373
374 auto maybeMetadata = serializeCameraMetadataMap(m);
375 if (maybeMetadata) {
376 *metadata = std::move(maybeMetadata.value());
377 return ScopedAStatus::ok();
378 } else {
379 return toScopedAStatus(Status::INTERNAL_ERROR);
380 }
381 }
382
getPhysicalCameraCharacteristics(const std::string &,CameraMetadata *)383 ScopedAStatus CameraDevice::getPhysicalCameraCharacteristics(
384 const std::string& /*physicalCameraId*/, CameraMetadata* /*metadata*/) {
385 return toScopedAStatus(FAILURE(Status::OPERATION_NOT_SUPPORTED));
386 }
387
getResourceCost(CameraResourceCost * cost)388 ScopedAStatus CameraDevice::getResourceCost(CameraResourceCost* cost) {
389 cost->resourceCost = 100;
390 return ScopedAStatus::ok();
391 }
392
isStreamCombinationSupported(const StreamConfiguration & cfg,bool * support)393 ScopedAStatus CameraDevice::isStreamCombinationSupported(
394 const StreamConfiguration& cfg, bool* support) {
395 *support = CameraDeviceSession::isStreamCombinationSupported(cfg, *mHwCamera);
396 return ScopedAStatus::ok();
397 }
398
open(const std::shared_ptr<ICameraDeviceCallback> & callback,std::shared_ptr<ICameraDeviceSession> * session)399 ScopedAStatus CameraDevice::open(const std::shared_ptr<ICameraDeviceCallback>& callback,
400 std::shared_ptr<ICameraDeviceSession>* session) {
401 *session = ndk::SharedRefBase::make<CameraDeviceSession>(
402 mSelf.lock(), callback, *mHwCamera);
403 return ScopedAStatus::ok();
404 }
405
openInjectionSession(const std::shared_ptr<ICameraDeviceCallback> &,std::shared_ptr<ICameraInjectionSession> *)406 ScopedAStatus CameraDevice::openInjectionSession(
407 const std::shared_ptr<ICameraDeviceCallback>& /*callback*/,
408 std::shared_ptr<ICameraInjectionSession>* /*session*/) {
409 return toScopedAStatus(FAILURE(Status::OPERATION_NOT_SUPPORTED));
410 }
411
setTorchMode(const bool)412 ScopedAStatus CameraDevice::setTorchMode(const bool /*on*/) {
413 return toScopedAStatus(FAILURE(Status::OPERATION_NOT_SUPPORTED));
414 }
415
turnOnTorchWithStrengthLevel(const int32_t)416 ScopedAStatus CameraDevice::turnOnTorchWithStrengthLevel(const int32_t /*strength*/) {
417 return toScopedAStatus(FAILURE(Status::OPERATION_NOT_SUPPORTED));
418 }
419
getTorchStrengthLevel(int32_t *)420 ScopedAStatus CameraDevice::getTorchStrengthLevel(int32_t* /*strength*/) {
421 return toScopedAStatus(FAILURE(Status::OPERATION_NOT_SUPPORTED));
422 }
423
constructDefaultRequestSettings(const RequestTemplate tpl) const424 CameraMetadataMap CameraDevice::constructDefaultRequestSettings(const RequestTemplate tpl) const {
425 using namespace std::literals;
426 const auto sensorSize = mHwCamera->getSensorSize();
427 const std::pair<int32_t, int32_t> fpsRange = mHwCamera->getDefaultTargetFpsRange(tpl);
428
429 CameraMetadataMap m;
430
431 m[ANDROID_COLOR_CORRECTION_ABERRATION_MODE] =
432 uint8_t(ANDROID_COLOR_CORRECTION_ABERRATION_MODE_OFF);
433 m[ANDROID_CONTROL_AE_ANTIBANDING_MODE] =
434 uint8_t(ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO);
435 m[ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION] = int32_t(0);
436 m[ANDROID_CONTROL_AE_LOCK] = uint8_t(ANDROID_CONTROL_AE_LOCK_OFF);
437 m[ANDROID_CONTROL_AE_MODE] = uint8_t((tpl == RequestTemplate::MANUAL) ?
438 ANDROID_CONTROL_AE_MODE_OFF : ANDROID_CONTROL_AE_MODE_ON);
439 m[ANDROID_CONTROL_AE_TARGET_FPS_RANGE]
440 .add<int32_t>(fpsRange.first).add<int32_t>(fpsRange.second);
441 m[ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER] =
442 uint8_t(ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_IDLE);
443 m[ANDROID_CONTROL_AF_MODE] = uint8_t((tpl == RequestTemplate::MANUAL) ?
444 ANDROID_CONTROL_AF_MODE_OFF : ANDROID_CONTROL_AF_MODE_AUTO);
445 m[ANDROID_CONTROL_AF_TRIGGER] = uint8_t(ANDROID_CONTROL_AF_TRIGGER_IDLE);
446 m[ANDROID_CONTROL_AWB_LOCK] = uint8_t(ANDROID_CONTROL_AWB_LOCK_OFF);
447 m[ANDROID_CONTROL_AWB_MODE] = uint8_t((tpl == RequestTemplate::MANUAL) ?
448 ANDROID_CONTROL_AWB_MODE_OFF : ANDROID_CONTROL_AWB_MODE_AUTO);
449 m[ANDROID_CONTROL_CAPTURE_INTENT] = uint8_t(MapRequestTemplateToIntent(tpl));
450 m[ANDROID_CONTROL_EFFECT_MODE] = uint8_t(ANDROID_CONTROL_EFFECT_MODE_OFF);
451 m[ANDROID_CONTROL_MODE] = uint8_t((tpl == RequestTemplate::MANUAL) ?
452 ANDROID_CONTROL_MODE_OFF : ANDROID_CONTROL_MODE_AUTO);
453 m[ANDROID_CONTROL_SCENE_MODE] = uint8_t(ANDROID_CONTROL_SCENE_MODE_DISABLED);
454 m[ANDROID_CONTROL_VIDEO_STABILIZATION_MODE] =
455 uint8_t(ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF);
456 m[ANDROID_CONTROL_ZOOM_RATIO] = float(mHwCamera->getZoomRatioRange().first);
457
458 m[ANDROID_EDGE_MODE] = uint8_t(ANDROID_EDGE_MODE_OFF);
459
460 m[ANDROID_FLASH_MODE] = uint8_t(ANDROID_FLASH_MODE_OFF);
461
462 m[ANDROID_HOT_PIXEL_MODE] = uint8_t(ANDROID_HOT_PIXEL_MODE_OFF);
463
464 m[ANDROID_JPEG_ORIENTATION] = int32_t(0);
465 m[ANDROID_JPEG_QUALITY] = uint8_t(85);
466 m[ANDROID_JPEG_THUMBNAIL_QUALITY] = uint8_t(85);
467 m[ANDROID_JPEG_THUMBNAIL_SIZE].add<int32_t>(0).add<int32_t>(0);
468
469 m[ANDROID_LENS_APERTURE] = float(mHwCamera->getDefaultAperture());
470 m[ANDROID_LENS_FOCAL_LENGTH] = float(mHwCamera->getDefaultFocalLength());
471 m[ANDROID_LENS_FOCUS_DISTANCE] = float(mHwCamera->getMinimumFocusDistance());
472 m[ANDROID_LENS_OPTICAL_STABILIZATION_MODE] =
473 uint8_t(ANDROID_LENS_OPTICAL_STABILIZATION_MODE_OFF);
474
475 m[ANDROID_NOISE_REDUCTION_MODE] = uint8_t(ANDROID_NOISE_REDUCTION_MODE_OFF);
476
477 m[ANDROID_SENSOR_TEST_PATTERN_MODE] = int32_t(ANDROID_SENSOR_TEST_PATTERN_MODE_OFF);
478
479 m[ANDROID_REQUEST_ID] = int32_t(0);
480 m[ANDROID_REQUEST_METADATA_MODE] = uint8_t(ANDROID_REQUEST_METADATA_MODE_FULL);
481
482 m[ANDROID_SCALER_CROP_REGION]
483 .add<int32_t>(0).add<int32_t>(0)
484 .add<int32_t>(sensorSize.width - 1)
485 .add<int32_t>(sensorSize.height - 1);
486
487 m[ANDROID_SENSOR_EXPOSURE_TIME] = int64_t(mHwCamera->getDefaultSensorExpTime());
488 m[ANDROID_SENSOR_FRAME_DURATION] = int64_t(mHwCamera->getDefaultSensorFrameDuration());
489 m[ANDROID_SENSOR_SENSITIVITY] = int32_t(mHwCamera->getDefaultSensorSensitivity());
490
491 m[ANDROID_STATISTICS_FACE_DETECT_MODE] =
492 uint8_t(ANDROID_STATISTICS_FACE_DETECT_MODE_OFF);
493 m[ANDROID_STATISTICS_SHARPNESS_MAP_MODE] =
494 uint8_t(ANDROID_STATISTICS_SHARPNESS_MAP_MODE_OFF);
495 m[ANDROID_STATISTICS_HOT_PIXEL_MAP_MODE] =
496 uint8_t(ANDROID_STATISTICS_HOT_PIXEL_MAP_MODE_OFF);
497 m[ANDROID_STATISTICS_LENS_SHADING_MAP_MODE] =
498 uint8_t(ANDROID_STATISTICS_LENS_SHADING_MAP_MODE_OFF);
499
500 m[ANDROID_BLACK_LEVEL_LOCK] = uint8_t(ANDROID_BLACK_LEVEL_LOCK_OFF);
501 m[ANDROID_DISTORTION_CORRECTION_MODE] =
502 uint8_t(ANDROID_DISTORTION_CORRECTION_MODE_OFF);
503
504 return m;
505 }
506
507 } // namespace implementation
508 } // namespace provider
509 } // namespace camera
510 } // namespace hardware
511 } // namespace android
512