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 LOG_TAG "EmulatedCameraDeviceInfo"
18 #define ATRACE_TAG ATRACE_TAG_CAMERA
19
20 #include "EmulatedCameraDeviceInfo.h"
21
22 #include <inttypes.h>
23 #include <log/log.h>
24
25 namespace android {
26
27 const std::set<uint8_t> EmulatedCameraDeviceInfo::kSupportedCapabilites = {
28 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE,
29 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_MANUAL_SENSOR,
30 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_MANUAL_POST_PROCESSING,
31 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_RAW,
32 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_READ_SENSOR_SETTINGS,
33 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BURST_CAPTURE,
34 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_DEPTH_OUTPUT,
35 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_PRIVATE_REPROCESSING,
36 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_YUV_REPROCESSING,
37 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_LOGICAL_MULTI_CAMERA,
38 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_REMOSAIC_REPROCESSING,
39 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_ULTRA_HIGH_RESOLUTION_SENSOR,
40 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT,
41 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_STREAM_USE_CASE,
42 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_COLOR_SPACE_PROFILES};
43
44 const std::set<uint8_t> EmulatedCameraDeviceInfo::kSupportedHWLevels = {
45 ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
46 ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_FULL,
47 ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_3,
48 };
49
50 const std::vector<int64_t> EmulatedCameraDeviceInfo::kSupportedUseCases = {
51 ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_DEFAULT,
52 ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_PREVIEW,
53 ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_STILL_CAPTURE,
54 ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_VIDEO_RECORD,
55 ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_PREVIEW_VIDEO_STILL,
56 ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_VIDEO_CALL};
57
Create(std::unique_ptr<HalCameraMetadata> static_metadata)58 std::unique_ptr<EmulatedCameraDeviceInfo> EmulatedCameraDeviceInfo::Create(
59 std::unique_ptr<HalCameraMetadata> static_metadata) {
60 auto deviceInfo = std::make_unique<EmulatedCameraDeviceInfo>();
61 if (deviceInfo == nullptr) {
62 ALOGE("%s: Creating EmulatedCameraDeviceInfo failed.", __FUNCTION__);
63 return nullptr;
64 }
65
66 status_t res = deviceInfo->Initialize(std::move(static_metadata));
67 if (res != OK) {
68 ALOGE("%s: Failed to initialize EmulatedCameraDeviceInfo: %s(%d)",
69 __FUNCTION__, strerror(-res), res);
70 return nullptr;
71 }
72
73 return deviceInfo;
74 }
75
Clone(const EmulatedCameraDeviceInfo & other)76 std::unique_ptr<EmulatedCameraDeviceInfo> EmulatedCameraDeviceInfo::Clone(
77 const EmulatedCameraDeviceInfo& other) {
78 std::unique_ptr<HalCameraMetadata> static_metadata =
79 HalCameraMetadata::Clone(other.static_metadata_.get());
80
81 return EmulatedCameraDeviceInfo::Create(std::move(static_metadata));
82 }
83
InitializeSensorDefaults()84 status_t EmulatedCameraDeviceInfo::InitializeSensorDefaults() {
85 camera_metadata_ro_entry_t entry;
86 auto ret =
87 static_metadata_->Get(ANDROID_SENSOR_INFO_SENSITIVITY_RANGE, &entry);
88 if ((ret == OK) && (entry.count == 2)) {
89 sensor_sensitivity_range_ =
90 std::make_pair(entry.data.i32[0], entry.data.i32[1]);
91 } else if (!supports_manual_sensor_) {
92 sensor_sensitivity_range_ =
93 std::make_pair(EmulatedSensor::kSupportedSensitivityRange[0],
94 EmulatedSensor::kSupportedSensitivityRange[1]);
95 } else {
96 ALOGE("%s: Manual sensor devices must advertise sensor sensitivity range!",
97 __FUNCTION__);
98 return BAD_VALUE;
99 }
100
101 ret = static_metadata_->Get(ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE, &entry);
102 if ((ret == OK) && (entry.count == 2)) {
103 sensor_exposure_time_range_ =
104 std::make_pair(entry.data.i64[0], entry.data.i64[1]);
105 } else if (!supports_manual_sensor_) {
106 sensor_exposure_time_range_ =
107 std::make_pair(EmulatedSensor::kSupportedExposureTimeRange[0],
108 EmulatedSensor::kSupportedExposureTimeRange[1]);
109 } else {
110 ALOGE(
111 "%s: Manual sensor devices must advertise sensor exposure time range!",
112 __FUNCTION__);
113 return BAD_VALUE;
114 }
115
116 ret = static_metadata_->Get(ANDROID_SENSOR_INFO_MAX_FRAME_DURATION, &entry);
117 if ((ret == OK) && (entry.count == 1)) {
118 sensor_max_frame_duration_ = entry.data.i64[0];
119 } else if (!supports_manual_sensor_) {
120 sensor_max_frame_duration_ = EmulatedSensor::kSupportedFrameDurationRange[1];
121 } else {
122 ALOGE("%s: Manual sensor devices must advertise sensor max frame duration!",
123 __FUNCTION__);
124 return BAD_VALUE;
125 }
126
127 if (supports_manual_sensor_) {
128 if (available_requests_.find(ANDROID_SENSOR_SENSITIVITY) ==
129 available_requests_.end()) {
130 ALOGE(
131 "%s: Sensor sensitivity must be configurable on manual sensor "
132 "devices!",
133 __FUNCTION__);
134 return BAD_VALUE;
135 }
136
137 if (available_requests_.find(ANDROID_SENSOR_EXPOSURE_TIME) ==
138 available_requests_.end()) {
139 ALOGE(
140 "%s: Sensor exposure time must be configurable on manual sensor "
141 "devices!",
142 __FUNCTION__);
143 return BAD_VALUE;
144 }
145
146 if (available_requests_.find(ANDROID_SENSOR_FRAME_DURATION) ==
147 available_requests_.end()) {
148 ALOGE(
149 "%s: Sensor frame duration must be configurable on manual sensor "
150 "devices!",
151 __FUNCTION__);
152 return BAD_VALUE;
153 }
154 }
155
156 report_rolling_shutter_skew_ =
157 available_results_.find(ANDROID_SENSOR_ROLLING_SHUTTER_SKEW) !=
158 available_results_.end();
159 report_sensitivity_ = available_results_.find(ANDROID_SENSOR_SENSITIVITY) !=
160 available_results_.end();
161 report_exposure_time_ =
162 available_results_.find(ANDROID_SENSOR_EXPOSURE_TIME) !=
163 available_results_.end();
164 report_frame_duration_ =
165 available_results_.find(ANDROID_SENSOR_FRAME_DURATION) !=
166 available_results_.end();
167 report_neutral_color_point_ =
168 available_results_.find(ANDROID_SENSOR_NEUTRAL_COLOR_POINT) !=
169 available_results_.end();
170 report_green_split_ = available_results_.find(ANDROID_SENSOR_GREEN_SPLIT) !=
171 available_results_.end();
172 report_noise_profile_ =
173 available_results_.find(ANDROID_SENSOR_NOISE_PROFILE) !=
174 available_results_.end();
175
176 if (is_raw_capable_ && !report_green_split_) {
177 ALOGE("%s: RAW capable devices must be able to report the noise profile!",
178 __FUNCTION__);
179 return BAD_VALUE;
180 }
181
182 if (is_raw_capable_ && !report_neutral_color_point_) {
183 ALOGE(
184 "%s: RAW capable devices must be able to report the neutral color "
185 "point!",
186 __FUNCTION__);
187 return BAD_VALUE;
188 }
189
190 if (is_raw_capable_ && !report_green_split_) {
191 ALOGE("%s: RAW capable devices must be able to report the green split!",
192 __FUNCTION__);
193 return BAD_VALUE;
194 }
195 if (available_results_.find(ANDROID_SENSOR_TIMESTAMP) ==
196 available_results_.end()) {
197 ALOGE("%s: Sensor timestamp must always be part of the results!",
198 __FUNCTION__);
199 return BAD_VALUE;
200 }
201
202 ret = static_metadata_->Get(ANDROID_SENSOR_AVAILABLE_TEST_PATTERN_MODES,
203 &entry);
204 if (ret == OK) {
205 available_test_pattern_modes_.insert(entry.data.i32,
206 entry.data.i32 + entry.count);
207 } else {
208 ALOGE("%s: No available test pattern modes!", __FUNCTION__);
209 return BAD_VALUE;
210 }
211
212 sensor_exposure_time_ = GetClosestValue(EmulatedSensor::kDefaultExposureTime,
213 sensor_exposure_time_range_.first,
214 sensor_exposure_time_range_.second);
215 sensor_frame_duration_ =
216 GetClosestValue(EmulatedSensor::kDefaultFrameDuration,
217 EmulatedSensor::kSupportedFrameDurationRange[0],
218 sensor_max_frame_duration_);
219 sensor_sensitivity_ = GetClosestValue(EmulatedSensor::kDefaultSensitivity,
220 sensor_sensitivity_range_.first,
221 sensor_sensitivity_range_.second);
222
223 bool off_test_pattern_mode_supported =
224 available_test_pattern_modes_.find(ANDROID_SENSOR_TEST_PATTERN_MODE_OFF) !=
225 available_test_pattern_modes_.end();
226 int32_t test_pattern_mode = (off_test_pattern_mode_supported)
227 ? ANDROID_SENSOR_TEST_PATTERN_MODE_OFF
228 : *available_test_pattern_modes_.begin();
229 int32_t test_pattern_data[4] = {0, 0, 0, 0};
230
231 for (size_t idx = 0; idx < kTemplateCount; idx++) {
232 if (default_requests_[idx].get() == nullptr) {
233 continue;
234 }
235
236 default_requests_[idx]->Set(ANDROID_SENSOR_EXPOSURE_TIME,
237 &sensor_exposure_time_, 1);
238 default_requests_[idx]->Set(ANDROID_SENSOR_FRAME_DURATION,
239 &sensor_frame_duration_, 1);
240 default_requests_[idx]->Set(ANDROID_SENSOR_SENSITIVITY,
241 &sensor_sensitivity_, 1);
242 default_requests_[idx]->Set(ANDROID_SENSOR_TEST_PATTERN_MODE,
243 &test_pattern_mode, 1);
244 default_requests_[idx]->Set(ANDROID_SENSOR_TEST_PATTERN_DATA,
245 test_pattern_data, 4);
246 }
247
248 return OK;
249 }
250
InitializeStatisticsDefaults()251 status_t EmulatedCameraDeviceInfo::InitializeStatisticsDefaults() {
252 camera_metadata_ro_entry_t entry;
253 auto ret = static_metadata_->Get(
254 ANDROID_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES, &entry);
255 if (ret == OK) {
256 available_face_detect_modes_.insert(entry.data.u8,
257 entry.data.u8 + entry.count);
258 } else {
259 ALOGE("%s: No available face detect modes!", __FUNCTION__);
260 return BAD_VALUE;
261 }
262
263 ret = static_metadata_->Get(
264 ANDROID_STATISTICS_INFO_AVAILABLE_LENS_SHADING_MAP_MODES, &entry);
265 if (ret == OK) {
266 available_lens_shading_map_modes_.insert(entry.data.u8,
267 entry.data.u8 + entry.count);
268 } else {
269 ALOGE("%s: No available lens shading modes!", __FUNCTION__);
270 return BAD_VALUE;
271 }
272
273 ret = static_metadata_->Get(
274 ANDROID_STATISTICS_INFO_AVAILABLE_HOT_PIXEL_MAP_MODES, &entry);
275 if (ret == OK) {
276 available_hot_pixel_map_modes_.insert(entry.data.u8,
277 entry.data.u8 + entry.count);
278 } else if (is_raw_capable_) {
279 ALOGE("%s: RAW capable device must support hot pixel map modes!",
280 __FUNCTION__);
281 return BAD_VALUE;
282 } else {
283 available_hot_pixel_map_modes_.emplace(
284 ANDROID_STATISTICS_HOT_PIXEL_MAP_MODE_OFF);
285 }
286
287 bool hot_pixel_mode_off_supported =
288 available_hot_pixel_map_modes_.find(
289 ANDROID_STATISTICS_HOT_PIXEL_MAP_MODE_OFF) !=
290 available_hot_pixel_map_modes_.end();
291 bool face_detect_mode_off_supported =
292 available_face_detect_modes_.find(
293 ANDROID_STATISTICS_FACE_DETECT_MODE_OFF) !=
294 available_face_detect_modes_.end();
295 bool lens_shading_map_mode_off_supported =
296 available_lens_shading_map_modes_.find(
297 ANDROID_STATISTICS_LENS_SHADING_MAP_MODE_ON) !=
298 available_lens_shading_map_modes_.end();
299 bool lens_shading_map_mode_on_supported =
300 available_lens_shading_map_modes_.find(
301 ANDROID_STATISTICS_LENS_SHADING_MAP_MODE_ON) !=
302 available_lens_shading_map_modes_.end();
303 if (is_raw_capable_ && !lens_shading_map_mode_on_supported) {
304 ALOGE("%s: RAW capable device must support lens shading map reporting!",
305 __FUNCTION__);
306 return BAD_VALUE;
307 }
308
309 if (lens_shading_map_mode_on_supported &&
310 (available_results_.find(ANDROID_STATISTICS_LENS_SHADING_MAP) ==
311 available_results_.end())) {
312 ALOGE(
313 "%s: Lens shading map reporting available but corresponding result key "
314 "is absent!",
315 __FUNCTION__);
316 return BAD_VALUE;
317 }
318
319 if (lens_shading_map_mode_on_supported &&
320 ((shading_map_size_[0] == 0) || (shading_map_size_[1] == 0))) {
321 ALOGE(
322 "%s: Lens shading map reporting available but without valid shading "
323 "map size!",
324 __FUNCTION__);
325 return BAD_VALUE;
326 }
327
328 report_lens_intrinsics_samples_ =
329 (available_results_.find(ANDROID_STATISTICS_LENS_INTRINSIC_SAMPLES) !=
330 available_results_.end()) &&
331 (available_results_.find(ANDROID_STATISTICS_LENS_INTRINSIC_TIMESTAMPS) !=
332 available_results_.end());
333
334 report_scene_flicker_ =
335 available_results_.find(ANDROID_STATISTICS_SCENE_FLICKER) !=
336 available_results_.end();
337
338 uint8_t face_detect_mode = face_detect_mode_off_supported
339 ? ANDROID_STATISTICS_FACE_DETECT_MODE_OFF
340 : *available_face_detect_modes_.begin();
341 uint8_t hot_pixel_map_mode = hot_pixel_mode_off_supported
342 ? ANDROID_STATISTICS_HOT_PIXEL_MAP_MODE_OFF
343 : *available_hot_pixel_map_modes_.begin();
344 uint8_t lens_shading_map_mode =
345 lens_shading_map_mode_off_supported
346 ? ANDROID_STATISTICS_LENS_SHADING_MAP_MODE_OFF
347 : *available_lens_shading_map_modes_.begin();
348 for (size_t idx = 0; idx < kTemplateCount; idx++) {
349 if (default_requests_[idx].get() == nullptr) {
350 continue;
351 }
352
353 if ((static_cast<RequestTemplate>(idx) == RequestTemplate::kStillCapture) &&
354 is_raw_capable_ && lens_shading_map_mode_on_supported) {
355 uint8_t lens_shading_map_on = ANDROID_STATISTICS_LENS_SHADING_MAP_MODE_ON;
356 default_requests_[idx]->Set(ANDROID_STATISTICS_LENS_SHADING_MAP_MODE,
357 &lens_shading_map_on, 1);
358 } else {
359 default_requests_[idx]->Set(ANDROID_STATISTICS_LENS_SHADING_MAP_MODE,
360 &lens_shading_map_mode, 1);
361 }
362
363 default_requests_[idx]->Set(ANDROID_STATISTICS_FACE_DETECT_MODE,
364 &face_detect_mode, 1);
365 default_requests_[idx]->Set(ANDROID_STATISTICS_HOT_PIXEL_MAP_MODE,
366 &hot_pixel_map_mode, 1);
367 }
368
369 return InitializeBlackLevelDefaults();
370 }
371
InitializeControlSceneDefaults()372 status_t EmulatedCameraDeviceInfo::InitializeControlSceneDefaults() {
373 camera_metadata_ro_entry_t entry;
374 auto ret =
375 static_metadata_->Get(ANDROID_CONTROL_AVAILABLE_SCENE_MODES, &entry);
376 if (ret == OK) {
377 available_scenes_.insert(entry.data.u8, entry.data.u8 + entry.count);
378 } else {
379 ALOGE("%s: No available scene modes!", __FUNCTION__);
380 return BAD_VALUE;
381 }
382
383 if ((entry.count == 1) &&
384 (entry.data.u8[0] == ANDROID_CONTROL_SCENE_MODE_DISABLED)) {
385 scenes_supported_ = false;
386 return OK;
387 } else {
388 scenes_supported_ = true;
389 }
390
391 if (available_requests_.find(ANDROID_CONTROL_SCENE_MODE) ==
392 available_requests_.end()) {
393 ALOGE("%s: Scene mode cannot be set!", __FUNCTION__);
394 return BAD_VALUE;
395 }
396
397 if (available_results_.find(ANDROID_CONTROL_SCENE_MODE) ==
398 available_results_.end()) {
399 ALOGE("%s: Scene mode cannot be reported!", __FUNCTION__);
400 return BAD_VALUE;
401 }
402
403 camera_metadata_ro_entry_t overrides_entry;
404 ret = static_metadata_->Get(ANDROID_CONTROL_SCENE_MODE_OVERRIDES,
405 &overrides_entry);
406 if ((ret == OK) && ((overrides_entry.count / 3) == available_scenes_.size()) &&
407 ((overrides_entry.count % 3) == 0)) {
408 for (size_t i = 0; i < entry.count; i++) {
409 SceneOverride scene(overrides_entry.data.u8[i * 3],
410 overrides_entry.data.u8[i * 3 + 1],
411 overrides_entry.data.u8[i * 3 + 2]);
412 if (available_ae_modes_.find(scene.ae_mode) == available_ae_modes_.end()) {
413 ALOGE("%s: AE scene mode override: %d not supported!", __FUNCTION__,
414 scene.ae_mode);
415 return BAD_VALUE;
416 }
417 if (available_awb_modes_.find(scene.awb_mode) ==
418 available_awb_modes_.end()) {
419 ALOGE("%s: AWB scene mode override: %d not supported!", __FUNCTION__,
420 scene.awb_mode);
421 return BAD_VALUE;
422 }
423 if (available_af_modes_.find(scene.af_mode) == available_af_modes_.end()) {
424 ALOGE("%s: AF scene mode override: %d not supported!", __FUNCTION__,
425 scene.af_mode);
426 return BAD_VALUE;
427 }
428 scene_overrides_.emplace(entry.data.u8[i], scene);
429 }
430 } else {
431 ALOGE("%s: No available scene overrides!", __FUNCTION__);
432 return BAD_VALUE;
433 }
434
435 return OK;
436 }
437
InitializeControlAFDefaults()438 status_t EmulatedCameraDeviceInfo::InitializeControlAFDefaults() {
439 camera_metadata_ro_entry_t entry;
440 auto ret = static_metadata_->Get(ANDROID_CONTROL_AF_AVAILABLE_MODES, &entry);
441 if (ret == OK) {
442 available_af_modes_.insert(entry.data.u8, entry.data.u8 + entry.count);
443 } else {
444 ALOGE("%s: No available AF modes!", __FUNCTION__);
445 return BAD_VALUE;
446 }
447 // Off mode must always be present
448 if (available_af_modes_.find(ANDROID_CONTROL_AF_MODE_OFF) ==
449 available_af_modes_.end()) {
450 ALOGE("%s: AF off control mode must always be present!", __FUNCTION__);
451 return BAD_VALUE;
452 }
453
454 if (available_requests_.find(ANDROID_CONTROL_AF_MODE) ==
455 available_requests_.end()) {
456 ALOGE("%s: Clients must be able to set AF mode!", __FUNCTION__);
457 return BAD_VALUE;
458 }
459
460 if (available_requests_.find(ANDROID_CONTROL_AF_TRIGGER) ==
461 available_requests_.end()) {
462 ALOGE("%s: Clients must be able to set AF trigger!", __FUNCTION__);
463 return BAD_VALUE;
464 }
465 if (available_results_.find(ANDROID_CONTROL_AF_TRIGGER) ==
466 available_results_.end()) {
467 ALOGE("%s: AF trigger must be reported!", __FUNCTION__);
468 return BAD_VALUE;
469 }
470
471 if (available_results_.find(ANDROID_CONTROL_AF_MODE) ==
472 available_results_.end()) {
473 ALOGE("%s: AF mode must be reported!", __FUNCTION__);
474 return BAD_VALUE;
475 }
476
477 if (available_results_.find(ANDROID_CONTROL_AF_STATE) ==
478 available_results_.end()) {
479 ALOGE("%s: AF state must be reported!", __FUNCTION__);
480 return BAD_VALUE;
481 }
482
483 bool auto_mode_present =
484 available_af_modes_.find(ANDROID_CONTROL_AF_MODE_AUTO) !=
485 available_af_modes_.end();
486 bool picture_caf_mode_present =
487 available_af_modes_.find(ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE) !=
488 available_af_modes_.end();
489 bool video_caf_mode_present =
490 available_af_modes_.find(ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO) !=
491 available_af_modes_.end();
492 af_supported_ = auto_mode_present && (minimum_focus_distance_ > .0f);
493 picture_caf_supported_ =
494 picture_caf_mode_present && (minimum_focus_distance_ > .0f);
495 video_caf_supported_ =
496 video_caf_mode_present && (minimum_focus_distance_ > .0f);
497
498 return OK;
499 }
500
InitializeControlAWBDefaults()501 status_t EmulatedCameraDeviceInfo::InitializeControlAWBDefaults() {
502 camera_metadata_ro_entry_t entry;
503 auto ret = static_metadata_->Get(ANDROID_CONTROL_AWB_AVAILABLE_MODES, &entry);
504 if (ret == OK) {
505 available_awb_modes_.insert(entry.data.u8, entry.data.u8 + entry.count);
506 } else {
507 ALOGE("%s: No available AWB modes!", __FUNCTION__);
508 return BAD_VALUE;
509 }
510 // Auto mode must always be present
511 if (available_awb_modes_.find(ANDROID_CONTROL_AWB_MODE_AUTO) ==
512 available_awb_modes_.end()) {
513 ALOGE("%s: AWB auto control mode must always be present!", __FUNCTION__);
514 return BAD_VALUE;
515 }
516
517 if (available_results_.find(ANDROID_CONTROL_AWB_MODE) ==
518 available_results_.end()) {
519 ALOGE("%s: AWB mode must be reported!", __FUNCTION__);
520 return BAD_VALUE;
521 }
522
523 if (available_results_.find(ANDROID_CONTROL_AWB_STATE) ==
524 available_results_.end()) {
525 ALOGE("%s: AWB state must be reported!", __FUNCTION__);
526 return BAD_VALUE;
527 }
528
529 ret = static_metadata_->Get(ANDROID_CONTROL_AWB_LOCK_AVAILABLE, &entry);
530 if ((ret == OK) && (entry.count == 1)) {
531 awb_lock_available_ =
532 entry.data.u8[0] == ANDROID_CONTROL_AWB_LOCK_AVAILABLE_TRUE;
533 } else {
534 ALOGV("%s: No available AWB lock!", __FUNCTION__);
535 awb_lock_available_ = false;
536 }
537 report_awb_lock_ = available_results_.find(ANDROID_CONTROL_AWB_LOCK) !=
538 available_results_.end();
539
540 return OK;
541 }
542
InitializeBlackLevelDefaults()543 status_t EmulatedCameraDeviceInfo::InitializeBlackLevelDefaults() {
544 if (is_level_full_or_higher_) {
545 if (available_requests_.find(ANDROID_BLACK_LEVEL_LOCK) ==
546 available_requests_.end()) {
547 ALOGE(
548 "%s: Full or above capable devices must be able to set the black "
549 "level lock!",
550 __FUNCTION__);
551 return BAD_VALUE;
552 }
553
554 if (available_results_.find(ANDROID_BLACK_LEVEL_LOCK) ==
555 available_results_.end()) {
556 ALOGE(
557 "%s: Full or above capable devices must be able to report the black "
558 "level lock!",
559 __FUNCTION__);
560 return BAD_VALUE;
561 }
562
563 report_black_level_lock_ = true;
564 uint8_t blackLevelLock = ANDROID_BLACK_LEVEL_LOCK_OFF;
565 for (size_t idx = 0; idx < kTemplateCount; idx++) {
566 if (default_requests_[idx].get() == nullptr) {
567 continue;
568 }
569
570 default_requests_[idx]->Set(ANDROID_BLACK_LEVEL_LOCK, &blackLevelLock, 1);
571 }
572 }
573
574 return InitializeEdgeDefaults();
575 }
576
InitializeControlAEDefaults()577 status_t EmulatedCameraDeviceInfo::InitializeControlAEDefaults() {
578 camera_metadata_ro_entry_t entry;
579 auto ret = static_metadata_->Get(ANDROID_CONTROL_AE_AVAILABLE_MODES, &entry);
580 if (ret == OK) {
581 available_ae_modes_.insert(entry.data.u8, entry.data.u8 + entry.count);
582 } else {
583 ALOGE("%s: No available AE modes!", __FUNCTION__);
584 return BAD_VALUE;
585 }
586
587 ret = static_metadata_->Get(ANDROID_CONTROL_AE_AVAILABLE_PRIORITY_MODES, &entry);
588 if (ret == OK) {
589 available_ae_priority_modes_.insert(entry.data.u8, entry.data.u8 + entry.count);
590 } else {
591 ALOGV("%s: No available AE priority modes!", __FUNCTION__);
592 }
593
594 // On mode must always be present
595 if (available_ae_modes_.find(ANDROID_CONTROL_AE_MODE_ON) ==
596 available_ae_modes_.end()) {
597 ALOGE("%s: AE on control mode must always be present!", __FUNCTION__);
598 return BAD_VALUE;
599 }
600
601 if (available_results_.find(ANDROID_CONTROL_AE_MODE) ==
602 available_results_.end()) {
603 ALOGE("%s: AE mode must be reported!", __FUNCTION__);
604 return BAD_VALUE;
605 }
606
607 if (available_results_.find(ANDROID_CONTROL_AE_STATE) ==
608 available_results_.end()) {
609 ALOGE("%s: AE state must be reported!", __FUNCTION__);
610 return BAD_VALUE;
611 }
612
613 ret = static_metadata_->Get(ANDROID_CONTROL_AE_LOCK_AVAILABLE, &entry);
614 if ((ret == OK) && (entry.count == 1)) {
615 ae_lock_available_ =
616 entry.data.u8[0] == ANDROID_CONTROL_AE_LOCK_AVAILABLE_TRUE;
617 } else {
618 ALOGV("%s: No available AE lock!", __FUNCTION__);
619 ae_lock_available_ = false;
620 }
621 report_ae_lock_ = available_results_.find(ANDROID_CONTROL_AE_LOCK) !=
622 available_results_.end();
623
624 if (supports_manual_sensor_) {
625 if (!ae_lock_available_) {
626 ALOGE("%s: AE lock must always be available for manual sensors!",
627 __FUNCTION__);
628 return BAD_VALUE;
629 }
630 auto off_mode = available_control_modes_.find(ANDROID_CONTROL_MODE_OFF);
631 if (off_mode == available_control_modes_.end()) {
632 ALOGE("%s: Off control mode must always be present for manual sensors!",
633 __FUNCTION__);
634 return BAD_VALUE;
635 }
636
637 off_mode = available_ae_modes_.find(ANDROID_CONTROL_AE_MODE_OFF);
638 if (off_mode == available_ae_modes_.end()) {
639 ALOGE(
640 "%s: AE off control mode must always be present for manual sensors!",
641 __FUNCTION__);
642 return BAD_VALUE;
643 }
644 }
645
646 if (available_requests_.find(ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER) ==
647 available_requests_.end()) {
648 ALOGE("%s: Clients must be able to set AE pre-capture trigger!",
649 __FUNCTION__);
650 return BAD_VALUE;
651 }
652
653 if (available_results_.find(ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER) ==
654 available_results_.end()) {
655 ALOGE("%s: AE pre-capture trigger must be reported!", __FUNCTION__);
656 return BAD_VALUE;
657 }
658
659 ret = static_metadata_->Get(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES,
660 &entry);
661 if (ret == OK) {
662 available_antibanding_modes_.insert(entry.data.u8,
663 entry.data.u8 + entry.count);
664 } else {
665 ALOGE("%s: No available antibanding modes!", __FUNCTION__);
666 return BAD_VALUE;
667 }
668
669 ret = static_metadata_->Get(ANDROID_CONTROL_AE_COMPENSATION_RANGE, &entry);
670 if ((ret == OK) && (entry.count == 2)) {
671 exposure_compensation_range_[0] = entry.data.i32[0];
672 exposure_compensation_range_[1] = entry.data.i32[1];
673 } else {
674 ALOGE("%s: No available exposure compensation range!", __FUNCTION__);
675 return BAD_VALUE;
676 }
677
678 ret = static_metadata_->Get(ANDROID_CONTROL_AE_COMPENSATION_STEP, &entry);
679 if ((ret == OK) && (entry.count == 1)) {
680 exposure_compensation_step_ = entry.data.r[0];
681 } else {
682 ALOGE("%s: No available exposure compensation step!", __FUNCTION__);
683 return BAD_VALUE;
684 }
685
686 bool ae_comp_requests =
687 available_requests_.find(ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION) !=
688 available_requests_.end();
689 bool ae_comp_results =
690 available_results_.find(ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION) !=
691 available_results_.end();
692 exposure_compensation_supported_ =
693 ((exposure_compensation_range_[0] < 0) &&
694 (exposure_compensation_range_[1] > 0) &&
695 (exposure_compensation_step_.denominator > 0) &&
696 (exposure_compensation_step_.numerator > 0)) &&
697 ae_comp_results && ae_comp_requests;
698
699 return OK;
700 }
701
InitializeMeteringRegionDefault(uint32_t tag,int32_t * region)702 status_t EmulatedCameraDeviceInfo::InitializeMeteringRegionDefault(
703 uint32_t tag, int32_t* region /*out*/) {
704 if (region == nullptr) {
705 return BAD_VALUE;
706 }
707 if (available_requests_.find(tag) == available_requests_.end()) {
708 ALOGE("%s: %d metering region configuration must be supported!",
709 __FUNCTION__, tag);
710 return BAD_VALUE;
711 }
712 if (available_results_.find(tag) == available_results_.end()) {
713 ALOGE("%s: %d metering region must be reported!", __FUNCTION__, tag);
714 return BAD_VALUE;
715 }
716
717 region[0] = scaler_crop_region_default_[0];
718 region[1] = scaler_crop_region_default_[1];
719 region[2] = scaler_crop_region_default_[2];
720 region[3] = scaler_crop_region_default_[3];
721 region[4] = 0;
722
723 return OK;
724 }
725
InitializeControlDefaults()726 status_t EmulatedCameraDeviceInfo::InitializeControlDefaults() {
727 camera_metadata_ro_entry_t entry;
728 int32_t metering_area[5] = {0}; // (top, left, width, height, wight)
729 auto ret = static_metadata_->Get(ANDROID_CONTROL_AVAILABLE_MODES, &entry);
730 if (ret == OK) {
731 available_control_modes_.insert(entry.data.u8, entry.data.u8 + entry.count);
732 } else {
733 ALOGE("%s: No available control modes!", __FUNCTION__);
734 return BAD_VALUE;
735 }
736
737 available_sensor_pixel_modes_.insert(ANDROID_SENSOR_PIXEL_MODE_DEFAULT);
738
739 if (SupportsCapability(
740 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_ULTRA_HIGH_RESOLUTION_SENSOR)) {
741 available_sensor_pixel_modes_.insert(
742 ANDROID_SENSOR_PIXEL_MODE_MAXIMUM_RESOLUTION);
743 }
744
745 // Auto mode must always be present
746 if (available_control_modes_.find(ANDROID_CONTROL_MODE_AUTO) ==
747 available_control_modes_.end()) {
748 ALOGE("%s: Auto control modes must always be present!", __FUNCTION__);
749 return BAD_VALUE;
750 }
751
752 // Capture intent must always be user configurable
753 if (available_requests_.find(ANDROID_CONTROL_CAPTURE_INTENT) ==
754 available_requests_.end()) {
755 ALOGE("%s: Clients must be able to set the capture intent!", __FUNCTION__);
756 return BAD_VALUE;
757 }
758
759 ret = static_metadata_->Get(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES,
760 &entry);
761 if ((ret == OK) && ((entry.count % 2) == 0)) {
762 available_fps_ranges_.reserve(entry.count / 2);
763 for (size_t i = 0; i < entry.count; i += 2) {
764 FPSRange range(entry.data.i32[i], entry.data.i32[i + 1]);
765 if (range.min_fps > range.max_fps) {
766 ALOGE("%s: Minimum framerate: %d bigger than maximum framerate: %d",
767 __FUNCTION__, range.min_fps, range.max_fps);
768 return BAD_VALUE;
769 }
770 if ((range.max_fps >= kMinimumStreamingFPS) &&
771 (range.max_fps == range.min_fps) && (ae_target_fps_.max_fps == 0)) {
772 ae_target_fps_ = range;
773 }
774 available_fps_ranges_.push_back(range);
775 }
776 } else {
777 ALOGE("%s: No available framerate ranges!", __FUNCTION__);
778 return BAD_VALUE;
779 }
780
781 if (ae_target_fps_.max_fps == 0) {
782 ALOGE("%s: No minimum streaming capable framerate range available!",
783 __FUNCTION__);
784 return BAD_VALUE;
785 }
786
787 if (available_requests_.find(ANDROID_CONTROL_AE_TARGET_FPS_RANGE) ==
788 available_requests_.end()) {
789 ALOGE("%s: Clients must be able to set the target framerate range!",
790 __FUNCTION__);
791 return BAD_VALUE;
792 }
793
794 if (available_results_.find(ANDROID_CONTROL_AE_TARGET_FPS_RANGE) ==
795 available_results_.end()) {
796 ALOGE("%s: Target framerate must be reported!", __FUNCTION__);
797 return BAD_VALUE;
798 }
799
800 report_extended_scene_mode_ =
801 available_results_.find(ANDROID_CONTROL_EXTENDED_SCENE_MODE) !=
802 available_results_.end();
803
804 if (is_backward_compatible_) {
805 ret = static_metadata_->Get(ANDROID_CONTROL_POST_RAW_SENSITIVITY_BOOST,
806 &entry);
807 if (ret == OK) {
808 post_raw_boost_ = entry.data.i32[0];
809 } else {
810 ALOGW("%s: No available post RAW boost! Setting default!", __FUNCTION__);
811 post_raw_boost_ = 100;
812 }
813 report_post_raw_boost_ =
814 available_results_.find(ANDROID_CONTROL_POST_RAW_SENSITIVITY_BOOST) !=
815 available_results_.end();
816
817 ret = static_metadata_->Get(ANDROID_CONTROL_AVAILABLE_EFFECTS, &entry);
818 if ((ret == OK) && (entry.count > 0)) {
819 available_effects_.insert(entry.data.u8, entry.data.u8 + entry.count);
820 if (available_effects_.find(ANDROID_CONTROL_EFFECT_MODE_OFF) ==
821 available_effects_.end()) {
822 ALOGE("%s: Off color effect mode not supported!", __FUNCTION__);
823 return BAD_VALUE;
824 }
825 } else {
826 ALOGE("%s: No available effects!", __FUNCTION__);
827 return BAD_VALUE;
828 }
829
830 ret = static_metadata_->Get(
831 ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES, &entry);
832 if ((ret == OK) && (entry.count > 0)) {
833 available_vstab_modes_.insert(entry.data.u8, entry.data.u8 + entry.count);
834 if (available_vstab_modes_.find(
835 ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF) ==
836 available_vstab_modes_.end()) {
837 ALOGE("%s: Off video stabilization mode not supported!", __FUNCTION__);
838 return BAD_VALUE;
839 }
840 if (available_vstab_modes_.find(
841 ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_ON) !=
842 available_vstab_modes_.end()) {
843 vstab_available_ = true;
844 }
845 } else {
846 ALOGE("%s: No available video stabilization modes!", __FUNCTION__);
847 return BAD_VALUE;
848 }
849
850 ret = static_metadata_->Get(ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM,
851 &entry);
852 if ((ret == OK) && (entry.count > 0)) {
853 if (entry.count != 1) {
854 ALOGE("%s: Invalid max digital zoom capability!", __FUNCTION__);
855 return BAD_VALUE;
856 }
857 max_zoom_ = entry.data.f[0];
858 } else {
859 ALOGE("%s: No available max digital zoom", __FUNCTION__);
860 return BAD_VALUE;
861 }
862
863 ret = static_metadata_->Get(ANDROID_CONTROL_ZOOM_RATIO_RANGE, &entry);
864 if ((ret == OK) && (entry.count > 0)) {
865 if (entry.count != 2) {
866 ALOGE("%s: Invalid zoom ratio range capability!", __FUNCTION__);
867 return BAD_VALUE;
868 }
869
870 if (entry.data.f[1] != max_zoom_) {
871 ALOGE("%s: Max zoom ratio must be equal to max digital zoom",
872 __FUNCTION__);
873 return BAD_VALUE;
874 }
875
876 if (entry.data.f[1] < entry.data.f[0]) {
877 ALOGE("%s: Max zoom ratio must be larger than min zoom ratio",
878 __FUNCTION__);
879 return BAD_VALUE;
880 }
881
882 // Validity check request and result keys
883 if (available_requests_.find(ANDROID_CONTROL_ZOOM_RATIO) ==
884 available_requests_.end()) {
885 ALOGE("%s: Zoom ratio tag must be available in available request keys",
886 __FUNCTION__);
887 return BAD_VALUE;
888 }
889 if (available_results_.find(ANDROID_CONTROL_ZOOM_RATIO) ==
890 available_results_.end()) {
891 ALOGE("%s: Zoom ratio tag must be available in available result keys",
892 __FUNCTION__);
893 return BAD_VALUE;
894 }
895
896 zoom_ratio_supported_ = true;
897 min_zoom_ = entry.data.f[0];
898 }
899
900 ret = static_metadata_->Get(
901 ANDROID_CONTROL_AVAILABLE_EXTENDED_SCENE_MODE_MAX_SIZES, &entry);
902 if ((ret == OK) && (entry.count > 0)) {
903 if (entry.count % 3 != 0) {
904 ALOGE("%s: Invalid bokeh capabilities!", __FUNCTION__);
905 return BAD_VALUE;
906 }
907
908 camera_metadata_ro_entry_t zoom_ratio_ranges_entry;
909 ret = static_metadata_->Get(
910 ANDROID_CONTROL_AVAILABLE_EXTENDED_SCENE_MODE_ZOOM_RATIO_RANGES,
911 &zoom_ratio_ranges_entry);
912 if (ret != OK ||
913 zoom_ratio_ranges_entry.count / 2 != entry.count / 3 - 1) {
914 ALOGE("%s: Invalid bokeh mode zoom ratio ranges.", __FUNCTION__);
915 return BAD_VALUE;
916 }
917
918 // Validity check request and characteristics keys
919 if (available_requests_.find(ANDROID_CONTROL_EXTENDED_SCENE_MODE) ==
920 available_requests_.end()) {
921 ALOGE("%s: Extended scene mode must be configurable for this device",
922 __FUNCTION__);
923 return BAD_VALUE;
924 }
925 if (available_characteristics_.find(
926 ANDROID_CONTROL_AVAILABLE_EXTENDED_SCENE_MODE_MAX_SIZES) ==
927 available_characteristics_.end() ||
928 available_characteristics_.find(
929 ANDROID_CONTROL_AVAILABLE_EXTENDED_SCENE_MODE_ZOOM_RATIO_RANGES) ==
930 available_characteristics_.end()) {
931 ALOGE(
932 "%s: ExtendedSceneMode maxSizes and zoomRatioRanges "
933 "characteristics keys must "
934 "be available",
935 __FUNCTION__);
936 return BAD_VALUE;
937 }
938
939 // Derive available bokeh caps.
940 StreamConfigurationMap stream_configuration_map(*static_metadata_);
941 std::set<StreamSize> yuv_sizes = stream_configuration_map.GetOutputSizes(
942 HAL_PIXEL_FORMAT_YCBCR_420_888);
943 bool has_extended_scene_mode_off = false;
944 for (size_t i = 0, j = 0; i < entry.count; i += 3) {
945 int32_t mode = entry.data.i32[i];
946 int32_t max_width = entry.data.i32[i + 1];
947 int32_t max_height = entry.data.i32[i + 2];
948 float min_zoom_ratio, max_zoom_ratio;
949
950 if (mode < ANDROID_CONTROL_EXTENDED_SCENE_MODE_DISABLED ||
951 (mode > ANDROID_CONTROL_EXTENDED_SCENE_MODE_BOKEH_CONTINUOUS &&
952 mode < ANDROID_CONTROL_EXTENDED_SCENE_MODE_VENDOR_START)) {
953 ALOGE("%s: Invalid extended scene mode %d", __FUNCTION__, mode);
954 return BAD_VALUE;
955 }
956
957 if (mode == ANDROID_CONTROL_EXTENDED_SCENE_MODE_DISABLED) {
958 has_extended_scene_mode_off = true;
959 if (max_width != 0 || max_height != 0) {
960 ALOGE(
961 "%s: Invalid max width or height for "
962 "EXTENDED_SCENE_MODE_DISABLED",
963 __FUNCTION__);
964 return BAD_VALUE;
965 }
966 min_zoom_ratio = min_zoom_;
967 max_zoom_ratio = max_zoom_;
968 } else if (yuv_sizes.find({max_width, max_height}) == yuv_sizes.end()) {
969 ALOGE("%s: Invalid max width or height for extended scene mode %d",
970 __FUNCTION__, mode);
971 return BAD_VALUE;
972 } else {
973 min_zoom_ratio = zoom_ratio_ranges_entry.data.f[j];
974 max_zoom_ratio = zoom_ratio_ranges_entry.data.f[j + 1];
975 j += 2;
976 }
977
978 ExtendedSceneModeCapability cap(mode, max_width, max_height,
979 min_zoom_ratio, max_zoom_ratio);
980 available_extended_scene_mode_caps_.push_back(cap);
981 }
982 if (!has_extended_scene_mode_off) {
983 ALOGE("%s: Off extended scene mode not supported!", __FUNCTION__);
984 return BAD_VALUE;
985 }
986 }
987
988 ret = static_metadata_->Get(ANDROID_CONTROL_MAX_REGIONS, &entry);
989 if ((ret == OK) && (entry.count == 3)) {
990 max_ae_regions_ = entry.data.i32[0];
991 max_awb_regions_ = entry.data.i32[1];
992 max_af_regions_ = entry.data.i32[2];
993 } else {
994 ALOGE(
995 "%s: Metering regions must be available for backward compatible "
996 "devices!",
997 __FUNCTION__);
998 return BAD_VALUE;
999 }
1000
1001 if ((is_level_full_or_higher_) &&
1002 ((max_ae_regions_ == 0) || (max_af_regions_ == 0))) {
1003 ALOGE(
1004 "%s: Full and higher level cameras must support at AF and AE "
1005 "metering regions",
1006 __FUNCTION__);
1007 return BAD_VALUE;
1008 }
1009
1010 if (max_ae_regions_ > 0) {
1011 ret = InitializeMeteringRegionDefault(ANDROID_CONTROL_AE_REGIONS,
1012 ae_metering_region_);
1013 if (ret != OK) {
1014 return ret;
1015 }
1016 }
1017
1018 if (max_awb_regions_ > 0) {
1019 ret = InitializeMeteringRegionDefault(ANDROID_CONTROL_AWB_REGIONS,
1020 awb_metering_region_);
1021 if (ret != OK) {
1022 return ret;
1023 }
1024 }
1025
1026 if (max_af_regions_ > 0) {
1027 ret = InitializeMeteringRegionDefault(ANDROID_CONTROL_AF_REGIONS,
1028 af_metering_region_);
1029 if (ret != OK) {
1030 return ret;
1031 }
1032 }
1033
1034 ret = InitializeControlAEDefaults();
1035 if (ret != OK) {
1036 return ret;
1037 }
1038
1039 ret = InitializeControlAWBDefaults();
1040 if (ret != OK) {
1041 return ret;
1042 }
1043
1044 ret = InitializeControlAFDefaults();
1045 if (ret != OK) {
1046 return ret;
1047 }
1048
1049 ret = InitializeControlSceneDefaults();
1050 if (ret != OK) {
1051 return ret;
1052 }
1053 }
1054
1055 for (size_t idx = 0; idx < kTemplateCount; idx++) {
1056 auto template_idx = static_cast<RequestTemplate>(idx);
1057 if (default_requests_[idx].get() == nullptr) {
1058 continue;
1059 }
1060
1061 uint8_t intent = ANDROID_CONTROL_CAPTURE_INTENT_CUSTOM;
1062 uint8_t control_mode, ae_mode, awb_mode, af_mode, scene_mode, vstab_mode;
1063 control_mode = ANDROID_CONTROL_MODE_AUTO;
1064 ae_mode = ANDROID_CONTROL_AE_MODE_ON;
1065 awb_mode = ANDROID_CONTROL_AWB_MODE_AUTO;
1066 af_mode = af_supported_ ? ANDROID_CONTROL_AF_MODE_AUTO
1067 : ANDROID_CONTROL_AF_MODE_OFF;
1068 scene_mode = ANDROID_CONTROL_SCENE_MODE_DISABLED;
1069 vstab_mode = ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF;
1070 uint8_t effect_mode = ANDROID_CONTROL_EFFECT_MODE_OFF;
1071 uint8_t ae_lock = ANDROID_CONTROL_AE_LOCK_OFF;
1072 uint8_t awb_lock = ANDROID_CONTROL_AWB_LOCK_OFF;
1073 int32_t ae_target_fps[] = {ae_target_fps_.min_fps, ae_target_fps_.max_fps};
1074 float zoom_ratio = 1.0f;
1075 switch (template_idx) {
1076 case RequestTemplate::kManual:
1077 intent = ANDROID_CONTROL_CAPTURE_INTENT_MANUAL;
1078 control_mode = ANDROID_CONTROL_MODE_OFF;
1079 ae_mode = ANDROID_CONTROL_AE_MODE_OFF;
1080 awb_mode = ANDROID_CONTROL_AWB_MODE_OFF;
1081 af_mode = ANDROID_CONTROL_AF_MODE_OFF;
1082 break;
1083 case RequestTemplate::kZeroShutterLag:
1084 intent = ANDROID_CONTROL_CAPTURE_INTENT_ZERO_SHUTTER_LAG;
1085 if (picture_caf_supported_) {
1086 af_mode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE;
1087 }
1088 break;
1089 case RequestTemplate::kPreview:
1090 intent = ANDROID_CONTROL_CAPTURE_INTENT_PREVIEW;
1091 if (picture_caf_supported_) {
1092 af_mode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE;
1093 }
1094 break;
1095 case RequestTemplate::kStillCapture:
1096 intent = ANDROID_CONTROL_CAPTURE_INTENT_STILL_CAPTURE;
1097 if (picture_caf_supported_) {
1098 af_mode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE;
1099 }
1100 break;
1101 case RequestTemplate::kVideoRecord:
1102 intent = ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_RECORD;
1103 if (video_caf_supported_) {
1104 af_mode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO;
1105 }
1106 if (vstab_available_) {
1107 vstab_mode = ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_ON;
1108 }
1109 break;
1110 case RequestTemplate::kVideoSnapshot:
1111 intent = ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_SNAPSHOT;
1112 if (video_caf_supported_) {
1113 af_mode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO;
1114 }
1115 if (vstab_available_) {
1116 vstab_mode = ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_ON;
1117 }
1118 break;
1119 default:
1120 // Noop
1121 break;
1122 }
1123
1124 if (intent != ANDROID_CONTROL_CAPTURE_INTENT_CUSTOM) {
1125 default_requests_[idx]->Set(ANDROID_CONTROL_CAPTURE_INTENT, &intent, 1);
1126 default_requests_[idx]->Set(ANDROID_CONTROL_MODE, &control_mode, 1);
1127 default_requests_[idx]->Set(ANDROID_CONTROL_AE_MODE, &ae_mode, 1);
1128 default_requests_[idx]->Set(ANDROID_CONTROL_AE_TARGET_FPS_RANGE,
1129 ae_target_fps, ARRAY_SIZE(ae_target_fps));
1130 default_requests_[idx]->Set(ANDROID_CONTROL_AWB_MODE, &awb_mode, 1);
1131 default_requests_[idx]->Set(ANDROID_CONTROL_AF_MODE, &af_mode, 1);
1132 if (is_backward_compatible_) {
1133 default_requests_[idx]->Set(ANDROID_CONTROL_POST_RAW_SENSITIVITY_BOOST,
1134 &post_raw_boost_, 1);
1135 if (vstab_available_) {
1136 default_requests_[idx]->Set(ANDROID_CONTROL_VIDEO_STABILIZATION_MODE,
1137 &vstab_mode, 1);
1138 }
1139 if (ae_lock_available_) {
1140 default_requests_[idx]->Set(ANDROID_CONTROL_AE_LOCK, &ae_lock, 1);
1141 }
1142 if (awb_lock_available_) {
1143 default_requests_[idx]->Set(ANDROID_CONTROL_AWB_LOCK, &awb_lock, 1);
1144 }
1145 if (scenes_supported_) {
1146 default_requests_[idx]->Set(ANDROID_CONTROL_SCENE_MODE, &scene_mode,
1147 1);
1148 }
1149 if (max_ae_regions_ > 0) {
1150 default_requests_[idx]->Set(ANDROID_CONTROL_AE_REGIONS, metering_area,
1151 ARRAY_SIZE(metering_area));
1152 }
1153 if (max_awb_regions_ > 0) {
1154 default_requests_[idx]->Set(ANDROID_CONTROL_AWB_REGIONS,
1155 metering_area, ARRAY_SIZE(metering_area));
1156 }
1157 if (max_af_regions_ > 0) {
1158 default_requests_[idx]->Set(ANDROID_CONTROL_AF_REGIONS, metering_area,
1159 ARRAY_SIZE(metering_area));
1160 }
1161 if (exposure_compensation_supported_) {
1162 default_requests_[idx]->Set(ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION,
1163 &exposure_compensation_, 1);
1164 }
1165 if (zoom_ratio_supported_) {
1166 default_requests_[idx]->Set(ANDROID_CONTROL_ZOOM_RATIO, &zoom_ratio,
1167 1);
1168 }
1169 bool is_auto_antbanding_supported =
1170 available_antibanding_modes_.find(
1171 ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO) !=
1172 available_antibanding_modes_.end();
1173 uint8_t antibanding_mode = is_auto_antbanding_supported
1174 ? ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO
1175 : *available_antibanding_modes_.begin();
1176 default_requests_[idx]->Set(ANDROID_CONTROL_AE_ANTIBANDING_MODE,
1177 &antibanding_mode, 1);
1178 default_requests_[idx]->Set(ANDROID_CONTROL_EFFECT_MODE, &effect_mode,
1179 1);
1180 uint8_t ae_trigger = ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_IDLE;
1181 default_requests_[idx]->Set(ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER,
1182 &ae_trigger, 1);
1183 uint8_t af_trigger = ANDROID_CONTROL_AF_TRIGGER_IDLE;
1184 default_requests_[idx]->Set(ANDROID_CONTROL_AF_TRIGGER, &af_trigger, 1);
1185 }
1186 }
1187
1188 int32_t settings_override = ANDROID_CONTROL_SETTINGS_OVERRIDE_OFF;
1189 default_requests_[idx]->Set(ANDROID_CONTROL_SETTINGS_OVERRIDE,
1190 &settings_override, 1);
1191 }
1192
1193 return InitializeHotPixelDefaults();
1194 }
1195
InitializeTonemapDefaults()1196 status_t EmulatedCameraDeviceInfo::InitializeTonemapDefaults() {
1197 if (is_backward_compatible_) {
1198 camera_metadata_ro_entry_t entry;
1199 auto ret =
1200 static_metadata_->Get(ANDROID_TONEMAP_AVAILABLE_TONE_MAP_MODES, &entry);
1201 if (ret == OK) {
1202 available_tonemap_modes_.insert(entry.data.u8,
1203 entry.data.u8 + entry.count);
1204 } else {
1205 ALOGE("%s: No available tonemap modes!", __FUNCTION__);
1206 return BAD_VALUE;
1207 }
1208
1209 if ((is_level_full_or_higher_) && (available_tonemap_modes_.size() < 3)) {
1210 ALOGE(
1211 "%s: Full and higher level cameras must support at least three or "
1212 "more tonemap modes",
1213 __FUNCTION__);
1214 return BAD_VALUE;
1215 }
1216
1217 bool fast_mode_supported =
1218 available_tonemap_modes_.find(ANDROID_TONEMAP_MODE_FAST) !=
1219 available_tonemap_modes_.end();
1220 bool hq_mode_supported =
1221 available_tonemap_modes_.find(ANDROID_TONEMAP_MODE_HIGH_QUALITY) !=
1222 available_tonemap_modes_.end();
1223 uint8_t tonemap_mode = *available_tonemap_modes_.begin();
1224 for (size_t idx = 0; idx < kTemplateCount; idx++) {
1225 if (default_requests_[idx].get() == nullptr) {
1226 continue;
1227 }
1228
1229 switch (static_cast<RequestTemplate>(idx)) {
1230 case RequestTemplate::kVideoRecord: // Pass-through
1231 case RequestTemplate::kPreview:
1232 if (fast_mode_supported) {
1233 tonemap_mode = ANDROID_TONEMAP_MODE_FAST;
1234 }
1235 break;
1236 case RequestTemplate::kVideoSnapshot: // Pass-through
1237 case RequestTemplate::kStillCapture:
1238 if (hq_mode_supported) {
1239 tonemap_mode = ANDROID_TONEMAP_MODE_HIGH_QUALITY;
1240 }
1241 break;
1242 default:
1243 // Noop
1244 break;
1245 }
1246
1247 default_requests_[idx]->Set(ANDROID_TONEMAP_MODE, &tonemap_mode, 1);
1248 default_requests_[idx]->Set(
1249 ANDROID_TONEMAP_CURVE_RED, EmulatedSensor::kDefaultToneMapCurveRed,
1250 ARRAY_SIZE(EmulatedSensor::kDefaultToneMapCurveRed));
1251 default_requests_[idx]->Set(
1252 ANDROID_TONEMAP_CURVE_GREEN, EmulatedSensor::kDefaultToneMapCurveGreen,
1253 ARRAY_SIZE(EmulatedSensor::kDefaultToneMapCurveGreen));
1254 default_requests_[idx]->Set(
1255 ANDROID_TONEMAP_CURVE_BLUE, EmulatedSensor::kDefaultToneMapCurveBlue,
1256 ARRAY_SIZE(EmulatedSensor::kDefaultToneMapCurveBlue));
1257 }
1258 }
1259
1260 return InitializeStatisticsDefaults();
1261 }
1262
InitializeEdgeDefaults()1263 status_t EmulatedCameraDeviceInfo::InitializeEdgeDefaults() {
1264 if (is_backward_compatible_) {
1265 camera_metadata_ro_entry_t entry;
1266 auto ret = static_metadata_->Get(ANDROID_EDGE_AVAILABLE_EDGE_MODES, &entry);
1267 if (ret == OK) {
1268 available_edge_modes_.insert(entry.data.u8, entry.data.u8 + entry.count);
1269 } else {
1270 ALOGE("%s: No available edge modes!", __FUNCTION__);
1271 return BAD_VALUE;
1272 }
1273
1274 report_edge_mode_ =
1275 available_results_.find(ANDROID_EDGE_MODE) != available_results_.end();
1276 bool is_fast_mode_supported =
1277 available_edge_modes_.find(ANDROID_EDGE_MODE_FAST) !=
1278 available_edge_modes_.end();
1279 bool is_hq_mode_supported =
1280 available_edge_modes_.find(ANDROID_EDGE_MODE_HIGH_QUALITY) !=
1281 available_edge_modes_.end();
1282 bool is_zsl_mode_supported =
1283 available_edge_modes_.find(ANDROID_EDGE_MODE_ZERO_SHUTTER_LAG) !=
1284 available_edge_modes_.end();
1285 uint8_t edge_mode = *available_ae_modes_.begin();
1286 for (size_t idx = 0; idx < kTemplateCount; idx++) {
1287 if (default_requests_[idx].get() == nullptr) {
1288 continue;
1289 }
1290
1291 switch (static_cast<RequestTemplate>(idx)) {
1292 case RequestTemplate::kVideoRecord: // Pass-through
1293 case RequestTemplate::kPreview:
1294 if (is_fast_mode_supported) {
1295 edge_mode = ANDROID_EDGE_MODE_FAST;
1296 }
1297 break;
1298 case RequestTemplate::kVideoSnapshot: // Pass-through
1299 case RequestTemplate::kStillCapture:
1300 if (is_hq_mode_supported) {
1301 edge_mode = ANDROID_EDGE_MODE_HIGH_QUALITY;
1302 }
1303 break;
1304 case RequestTemplate::kZeroShutterLag:
1305 if (is_zsl_mode_supported) {
1306 edge_mode = ANDROID_EDGE_MODE_ZERO_SHUTTER_LAG;
1307 }
1308 break;
1309 default:
1310 // Noop
1311 break;
1312 }
1313
1314 default_requests_[idx]->Set(ANDROID_EDGE_MODE, &edge_mode, 1);
1315 }
1316 }
1317
1318 return InitializeShadingDefaults();
1319 }
1320
InitializeColorCorrectionDefaults()1321 status_t EmulatedCameraDeviceInfo::InitializeColorCorrectionDefaults() {
1322 camera_metadata_ro_entry_t entry;
1323 auto ret = static_metadata_->Get(
1324 ANDROID_COLOR_CORRECTION_AVAILABLE_ABERRATION_MODES, &entry);
1325 if (ret == OK) {
1326 available_color_aberration_modes_.insert(entry.data.u8,
1327 entry.data.u8 + entry.count);
1328 } else if (supports_manual_post_processing_) {
1329 ALOGE(
1330 "%s: Devices capable of manual post-processing must support color "
1331 "abberation!",
1332 __FUNCTION__);
1333 return BAD_VALUE;
1334 }
1335
1336 if (!available_color_aberration_modes_.empty()) {
1337 bool is_fast_mode_supported =
1338 available_color_aberration_modes_.find(
1339 ANDROID_COLOR_CORRECTION_ABERRATION_MODE_FAST) !=
1340 available_color_aberration_modes_.end();
1341 bool is_hq_mode_supported =
1342 available_color_aberration_modes_.find(
1343 ANDROID_COLOR_CORRECTION_ABERRATION_MODE_HIGH_QUALITY) !=
1344 available_color_aberration_modes_.end();
1345 uint8_t color_aberration = *available_color_aberration_modes_.begin();
1346 uint8_t color_correction_mode = ANDROID_COLOR_CORRECTION_MODE_FAST;
1347 for (size_t idx = 0; idx < kTemplateCount; idx++) {
1348 if (default_requests_[idx].get() == nullptr) {
1349 continue;
1350 }
1351
1352 switch (static_cast<RequestTemplate>(idx)) {
1353 case RequestTemplate::kVideoRecord: // Pass-through
1354 case RequestTemplate::kPreview:
1355 if (is_fast_mode_supported) {
1356 color_aberration = ANDROID_COLOR_CORRECTION_ABERRATION_MODE_FAST;
1357 }
1358 break;
1359 case RequestTemplate::kVideoSnapshot: // Pass-through
1360 case RequestTemplate::kStillCapture:
1361 if (is_hq_mode_supported) {
1362 color_aberration =
1363 ANDROID_COLOR_CORRECTION_ABERRATION_MODE_HIGH_QUALITY;
1364 }
1365 break;
1366 default:
1367 // Noop
1368 break;
1369 }
1370
1371 default_requests_[idx]->Set(ANDROID_COLOR_CORRECTION_ABERRATION_MODE,
1372 &color_aberration, 1);
1373 if (is_backward_compatible_) {
1374 default_requests_[idx]->Set(ANDROID_COLOR_CORRECTION_MODE,
1375 &color_correction_mode, 1);
1376 default_requests_[idx]->Set(
1377 ANDROID_COLOR_CORRECTION_TRANSFORM,
1378 EmulatedSensor::kDefaultColorTransform,
1379 ARRAY_SIZE(EmulatedSensor::kDefaultColorTransform));
1380 default_requests_[idx]->Set(
1381 ANDROID_COLOR_CORRECTION_GAINS,
1382 EmulatedSensor::kDefaultColorCorrectionGains,
1383 ARRAY_SIZE(EmulatedSensor::kDefaultColorCorrectionGains));
1384 }
1385 }
1386 }
1387
1388 return InitializeSensorDefaults();
1389 }
1390
InitializeScalerDefaults()1391 status_t EmulatedCameraDeviceInfo::InitializeScalerDefaults() {
1392 if (is_backward_compatible_) {
1393 camera_metadata_ro_entry_t entry;
1394 auto ret =
1395 static_metadata_->Get(ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE, &entry);
1396 if ((ret == OK) && (entry.count == 4)) {
1397 scaler_crop_region_default_[0] = entry.data.i32[0];
1398 scaler_crop_region_default_[1] = entry.data.i32[1];
1399 scaler_crop_region_default_[2] = entry.data.i32[2];
1400 scaler_crop_region_default_[3] = entry.data.i32[3];
1401 } else {
1402 ALOGE("%s: Sensor pixel array size is not available!", __FUNCTION__);
1403 return BAD_VALUE;
1404 }
1405
1406 if (SupportsCapability(
1407 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_ULTRA_HIGH_RESOLUTION_SENSOR)) {
1408 ret = static_metadata_->Get(
1409 ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE_MAXIMUM_RESOLUTION, &entry);
1410 if ((ret == OK) && (entry.count == 4)) {
1411 scaler_crop_region_max_resolution_[0] = entry.data.i32[0];
1412 scaler_crop_region_max_resolution_[1] = entry.data.i32[1];
1413 scaler_crop_region_max_resolution_[2] = entry.data.i32[2];
1414 scaler_crop_region_max_resolution_[3] = entry.data.i32[3];
1415 } else {
1416 ALOGE(
1417 "%s: Sensor pixel array size maximum resolution is not available!",
1418 __FUNCTION__);
1419 return BAD_VALUE;
1420 }
1421 }
1422
1423 if (available_requests_.find(ANDROID_SCALER_CROP_REGION) ==
1424 available_requests_.end()) {
1425 ALOGE(
1426 "%s: Backward compatible devices must support scaler crop "
1427 "configuration!",
1428 __FUNCTION__);
1429 return BAD_VALUE;
1430 }
1431 if (available_results_.find(ANDROID_SCALER_CROP_REGION) ==
1432 available_results_.end()) {
1433 ALOGE("%s: Scaler crop must reported on backward compatible devices!",
1434 __FUNCTION__);
1435 return BAD_VALUE;
1436 }
1437 if (available_results_.find(
1438 ANDROID_LOGICAL_MULTI_CAMERA_ACTIVE_PHYSICAL_SENSOR_CROP_REGION) !=
1439 available_results_.end()) {
1440 report_active_sensor_crop_ = true;
1441 }
1442 ret = static_metadata_->Get(ANDROID_SCALER_AVAILABLE_ROTATE_AND_CROP_MODES,
1443 &entry);
1444 if ((ret == OK) && (entry.count > 0)) {
1445 // Listing rotate and crop, so need to make sure it's consistently reported
1446 if (available_requests_.find(ANDROID_SCALER_ROTATE_AND_CROP) ==
1447 available_requests_.end()) {
1448 ALOGE(
1449 "%s: Rotate and crop must be listed in request keys if supported!",
1450 __FUNCTION__);
1451 return BAD_VALUE;
1452 }
1453 if (available_results_.find(ANDROID_SCALER_ROTATE_AND_CROP) ==
1454 available_results_.end()) {
1455 ALOGE("%s: Rotate and crop must be listed in result keys if supported!",
1456 __FUNCTION__);
1457 return BAD_VALUE;
1458 }
1459 if (available_characteristics_.find(
1460 ANDROID_SCALER_AVAILABLE_ROTATE_AND_CROP_MODES) ==
1461 available_characteristics_.end()) {
1462 ALOGE(
1463 "%s: Rotate and crop must be listed in characteristics keys if "
1464 "supported!",
1465 __FUNCTION__);
1466 return BAD_VALUE;
1467 }
1468 report_rotate_and_crop_ = true;
1469 for (size_t i = 0; i < entry.count; i++) {
1470 if (entry.data.u8[i] == ANDROID_SCALER_ROTATE_AND_CROP_AUTO) {
1471 rotate_and_crop_ = ANDROID_SCALER_ROTATE_AND_CROP_AUTO;
1472 }
1473 available_rotate_crop_modes_.insert(entry.data.u8[i]);
1474 }
1475 }
1476
1477 for (size_t idx = 0; idx < kTemplateCount; idx++) {
1478 if (default_requests_[idx].get() == nullptr) {
1479 continue;
1480 }
1481
1482 default_requests_[idx]->Set(ANDROID_SCALER_CROP_REGION,
1483 scaler_crop_region_default_,
1484 ARRAY_SIZE(scaler_crop_region_default_));
1485 if (report_rotate_and_crop_) {
1486 default_requests_[idx]->Set(ANDROID_SCALER_ROTATE_AND_CROP,
1487 &rotate_and_crop_, 1);
1488 }
1489 }
1490 }
1491
1492 return InitializeControlDefaults();
1493 }
1494
InitializeShadingDefaults()1495 status_t EmulatedCameraDeviceInfo::InitializeShadingDefaults() {
1496 camera_metadata_ro_entry_t entry;
1497 auto ret = static_metadata_->Get(ANDROID_SHADING_AVAILABLE_MODES, &entry);
1498 if (ret == OK) {
1499 available_shading_modes_.insert(entry.data.u8, entry.data.u8 + entry.count);
1500 } else {
1501 ALOGE("%s: No available lens shading modes!", __FUNCTION__);
1502 return BAD_VALUE;
1503 }
1504
1505 if (supports_manual_post_processing_ &&
1506 (available_shading_modes_.size() < 2)) {
1507 ALOGE(
1508 "%s: Devices capable of manual post-processing need to support at "
1509 "least "
1510 "two"
1511 " lens shading modes!",
1512 __FUNCTION__);
1513 return BAD_VALUE;
1514 }
1515
1516 bool is_fast_mode_supported =
1517 available_shading_modes_.find(ANDROID_SHADING_MODE_FAST) !=
1518 available_shading_modes_.end();
1519 bool is_hq_mode_supported =
1520 available_shading_modes_.find(ANDROID_SHADING_MODE_HIGH_QUALITY) !=
1521 available_shading_modes_.end();
1522 uint8_t shading_mode = *available_shading_modes_.begin();
1523 for (size_t idx = 0; idx < kTemplateCount; idx++) {
1524 if (default_requests_[idx].get() == nullptr) {
1525 continue;
1526 }
1527
1528 switch (static_cast<RequestTemplate>(idx)) {
1529 case RequestTemplate::kVideoRecord: // Pass-through
1530 case RequestTemplate::kPreview:
1531 if (is_fast_mode_supported) {
1532 shading_mode = ANDROID_SHADING_MODE_FAST;
1533 }
1534 break;
1535 case RequestTemplate::kVideoSnapshot: // Pass-through
1536 case RequestTemplate::kStillCapture:
1537 if (is_hq_mode_supported) {
1538 shading_mode = ANDROID_SHADING_MODE_HIGH_QUALITY;
1539 }
1540 break;
1541 default:
1542 // Noop
1543 break;
1544 }
1545
1546 default_requests_[idx]->Set(ANDROID_SHADING_MODE, &shading_mode, 1);
1547 }
1548
1549 return InitializeNoiseReductionDefaults();
1550 }
1551
InitializeNoiseReductionDefaults()1552 status_t EmulatedCameraDeviceInfo::InitializeNoiseReductionDefaults() {
1553 camera_metadata_ro_entry_t entry;
1554 auto ret = static_metadata_->Get(
1555 ANDROID_NOISE_REDUCTION_AVAILABLE_NOISE_REDUCTION_MODES, &entry);
1556 if (ret == OK) {
1557 available_noise_reduction_modes_.insert(entry.data.u8,
1558 entry.data.u8 + entry.count);
1559 } else {
1560 ALOGE("%s: No available noise reduction modes!", __FUNCTION__);
1561 return BAD_VALUE;
1562 }
1563
1564 if ((is_level_full_or_higher_) &&
1565 (available_noise_reduction_modes_.size() < 2)) {
1566 ALOGE(
1567 "%s: Full and above device must support at least two noise reduction "
1568 "modes!",
1569 __FUNCTION__);
1570 return BAD_VALUE;
1571 }
1572
1573 bool is_fast_mode_supported =
1574 available_noise_reduction_modes_.find(ANDROID_NOISE_REDUCTION_MODE_FAST) !=
1575 available_noise_reduction_modes_.end();
1576 bool is_hq_mode_supported = available_noise_reduction_modes_.find(
1577 ANDROID_NOISE_REDUCTION_MODE_HIGH_QUALITY) !=
1578 available_noise_reduction_modes_.end();
1579 bool is_zsl_mode_supported =
1580 available_noise_reduction_modes_.find(
1581 ANDROID_NOISE_REDUCTION_MODE_ZERO_SHUTTER_LAG) !=
1582 available_noise_reduction_modes_.end();
1583 uint8_t noise_reduction_mode = *available_noise_reduction_modes_.begin();
1584 for (size_t idx = 0; idx < kTemplateCount; idx++) {
1585 if (default_requests_[idx].get() == nullptr) {
1586 continue;
1587 }
1588
1589 switch (static_cast<RequestTemplate>(idx)) {
1590 case RequestTemplate::kVideoRecord: // Pass-through
1591 case RequestTemplate::kVideoSnapshot: // Pass-through
1592 case RequestTemplate::kPreview:
1593 if (is_fast_mode_supported) {
1594 noise_reduction_mode = ANDROID_NOISE_REDUCTION_MODE_FAST;
1595 }
1596 break;
1597 case RequestTemplate::kStillCapture:
1598 if (is_hq_mode_supported) {
1599 noise_reduction_mode = ANDROID_NOISE_REDUCTION_MODE_HIGH_QUALITY;
1600 }
1601 break;
1602 case RequestTemplate::kZeroShutterLag:
1603 if (is_zsl_mode_supported) {
1604 noise_reduction_mode = ANDROID_NOISE_REDUCTION_MODE_ZERO_SHUTTER_LAG;
1605 }
1606 break;
1607 default:
1608 // Noop
1609 break;
1610 }
1611
1612 default_requests_[idx]->Set(ANDROID_NOISE_REDUCTION_MODE,
1613 &noise_reduction_mode, 1);
1614 }
1615
1616 return InitializeColorCorrectionDefaults();
1617 }
1618
InitializeHotPixelDefaults()1619 status_t EmulatedCameraDeviceInfo::InitializeHotPixelDefaults() {
1620 camera_metadata_ro_entry_t entry;
1621 auto ret = static_metadata_->Get(ANDROID_HOT_PIXEL_AVAILABLE_HOT_PIXEL_MODES,
1622 &entry);
1623 if (ret == OK) {
1624 available_hot_pixel_modes_.insert(entry.data.u8,
1625 entry.data.u8 + entry.count);
1626 } else {
1627 ALOGE("%s: No available hotpixel modes!", __FUNCTION__);
1628 return BAD_VALUE;
1629 }
1630
1631 if ((is_level_full_or_higher_) && (available_hot_pixel_modes_.size() < 2)) {
1632 ALOGE(
1633 "%s: Full and higher level cameras must support at least fast and hq "
1634 "hotpixel modes",
1635 __FUNCTION__);
1636 return BAD_VALUE;
1637 }
1638
1639 bool fast_mode_supported =
1640 available_hot_pixel_modes_.find(ANDROID_HOT_PIXEL_MODE_FAST) !=
1641 available_hot_pixel_modes_.end();
1642 bool hq_mode_supported =
1643 available_hot_pixel_modes_.find(ANDROID_HOT_PIXEL_MODE_HIGH_QUALITY) !=
1644 available_hot_pixel_modes_.end();
1645 uint8_t hotpixel_mode = *available_hot_pixel_modes_.begin();
1646 for (size_t idx = 0; idx < kTemplateCount; idx++) {
1647 if (default_requests_[idx].get() == nullptr) {
1648 continue;
1649 }
1650
1651 switch (static_cast<RequestTemplate>(idx)) {
1652 case RequestTemplate::kVideoRecord: // Pass-through
1653 case RequestTemplate::kPreview:
1654 if (fast_mode_supported) {
1655 hotpixel_mode = ANDROID_HOT_PIXEL_MODE_FAST;
1656 }
1657 break;
1658 case RequestTemplate::kVideoSnapshot: // Pass-through
1659 case RequestTemplate::kStillCapture:
1660 if (hq_mode_supported) {
1661 hotpixel_mode = ANDROID_HOT_PIXEL_MODE_HIGH_QUALITY;
1662 }
1663 break;
1664 default:
1665 // Noop
1666 break;
1667 }
1668
1669 default_requests_[idx]->Set(ANDROID_HOT_PIXEL_MODE, &hotpixel_mode, 1);
1670 }
1671
1672 return InitializeTonemapDefaults();
1673 }
1674
InitializeFlashDefaults()1675 status_t EmulatedCameraDeviceInfo::InitializeFlashDefaults() {
1676 camera_metadata_ro_entry_t entry;
1677 auto ret = static_metadata_->Get(ANDROID_FLASH_INFO_AVAILABLE, &entry);
1678 if ((ret == OK) && (entry.count == 1)) {
1679 is_flash_supported_ = entry.data.u8[0];
1680 } else {
1681 ALOGE("%s: No available flash info!", __FUNCTION__);
1682 return BAD_VALUE;
1683 }
1684
1685 if (is_flash_supported_) {
1686 flash_state_ = ANDROID_FLASH_STATE_READY;
1687 } else {
1688 flash_state_ = ANDROID_FLASH_STATE_UNAVAILABLE;
1689 }
1690
1691 uint8_t flash_mode = ANDROID_FLASH_MODE_OFF;
1692 for (size_t idx = 0; idx < kTemplateCount; idx++) {
1693 if (default_requests_[idx].get() == nullptr) {
1694 continue;
1695 }
1696
1697 default_requests_[idx]->Set(ANDROID_FLASH_MODE, &flash_mode, 1);
1698 }
1699
1700 return InitializeScalerDefaults();
1701 }
1702
InitializeLensDefaults()1703 status_t EmulatedCameraDeviceInfo::InitializeLensDefaults() {
1704 camera_metadata_ro_entry_t entry;
1705 auto ret =
1706 static_metadata_->Get(ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE, &entry);
1707 if ((ret == OK) && (entry.count == 1)) {
1708 minimum_focus_distance_ = entry.data.f[0];
1709 } else {
1710 ALOGW("%s: No available minimum focus distance assuming fixed focus!",
1711 __FUNCTION__);
1712 minimum_focus_distance_ = .0f;
1713 }
1714
1715 ret = static_metadata_->Get(ANDROID_LENS_INFO_AVAILABLE_APERTURES, &entry);
1716 if ((ret == OK) && (entry.count > 0)) {
1717 // TODO: add support for multiple apertures
1718 aperture_ = entry.data.f[0];
1719 } else {
1720 ALOGE("%s: No available aperture!", __FUNCTION__);
1721 return BAD_VALUE;
1722 }
1723
1724 ret = static_metadata_->Get(ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS, &entry);
1725 if ((ret == OK) && (entry.count > 0)) {
1726 focal_length_ = entry.data.f[0];
1727 } else {
1728 ALOGE("%s: No available focal length!", __FUNCTION__);
1729 return BAD_VALUE;
1730 }
1731
1732 ret = static_metadata_->Get(ANDROID_LENS_INFO_SHADING_MAP_SIZE, &entry);
1733 if ((ret == OK) && (entry.count == 2)) {
1734 shading_map_size_[0] = entry.data.i32[0];
1735 shading_map_size_[1] = entry.data.i32[1];
1736 } else if (is_raw_capable_) {
1737 ALOGE("%s: No available shading map size!", __FUNCTION__);
1738 return BAD_VALUE;
1739 }
1740
1741 ret = static_metadata_->Get(ANDROID_LENS_INFO_AVAILABLE_FILTER_DENSITIES,
1742 &entry);
1743 if ((ret == OK) && (entry.count > 0)) {
1744 // TODO: add support for multiple filter densities
1745 filter_density_ = entry.data.f[0];
1746 } else {
1747 ALOGE("%s: No available filter density!", __FUNCTION__);
1748 return BAD_VALUE;
1749 }
1750
1751 ret = static_metadata_->Get(ANDROID_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION,
1752 &entry);
1753 if ((ret == OK) && (entry.count > 0)) {
1754 // TODO: add support for multiple OIS modes
1755 available_ois_modes_.insert(entry.data.u8, entry.data.u8 + entry.count);
1756 if (available_ois_modes_.find(ANDROID_LENS_OPTICAL_STABILIZATION_MODE_OFF) ==
1757 available_ois_modes_.end()) {
1758 ALOGE("%s: OIS off mode not supported!", __FUNCTION__);
1759 return BAD_VALUE;
1760 }
1761 } else {
1762 ALOGE("%s: No available OIS modes!", __FUNCTION__);
1763 return BAD_VALUE;
1764 }
1765
1766 ret = static_metadata_->Get(ANDROID_LENS_POSE_ROTATION, &entry);
1767 if ((ret == OK) && (entry.count == ARRAY_SIZE(pose_rotation_))) {
1768 memcpy(pose_rotation_, entry.data.f, sizeof(pose_rotation_));
1769 }
1770 ret = static_metadata_->Get(ANDROID_LENS_POSE_TRANSLATION, &entry);
1771 if ((ret == OK) && (entry.count == ARRAY_SIZE(pose_translation_))) {
1772 memcpy(pose_translation_, entry.data.f, sizeof(pose_translation_));
1773 }
1774 ret = static_metadata_->Get(ANDROID_LENS_INTRINSIC_CALIBRATION, &entry);
1775 if ((ret == OK) && (entry.count == ARRAY_SIZE(intrinsic_calibration_))) {
1776 memcpy(intrinsic_calibration_, entry.data.f, sizeof(intrinsic_calibration_));
1777 }
1778
1779 ret = static_metadata_->Get(ANDROID_LENS_DISTORTION, &entry);
1780 if ((ret == OK) && (entry.count == ARRAY_SIZE(distortion_))) {
1781 memcpy(distortion_, entry.data.f, sizeof(distortion_));
1782 }
1783
1784 report_focus_distance_ =
1785 available_results_.find(ANDROID_LENS_FOCUS_DISTANCE) !=
1786 available_results_.end();
1787 report_focus_range_ = available_results_.find(ANDROID_LENS_FOCUS_RANGE) !=
1788 available_results_.end();
1789 report_filter_density_ =
1790 available_results_.find(ANDROID_LENS_FILTER_DENSITY) !=
1791 available_results_.end();
1792 report_ois_mode_ =
1793 available_results_.find(ANDROID_LENS_OPTICAL_STABILIZATION_MODE) !=
1794 available_results_.end();
1795 report_pose_rotation_ = available_results_.find(ANDROID_LENS_POSE_ROTATION) !=
1796 available_results_.end();
1797 report_pose_translation_ =
1798 available_results_.find(ANDROID_LENS_POSE_TRANSLATION) !=
1799 available_results_.end();
1800 report_intrinsic_calibration_ =
1801 available_results_.find(ANDROID_LENS_INTRINSIC_CALIBRATION) !=
1802 available_results_.end();
1803 report_distortion_ = available_results_.find(ANDROID_LENS_DISTORTION) !=
1804 available_results_.end();
1805
1806 focus_distance_ = minimum_focus_distance_;
1807 for (size_t idx = 0; idx < kTemplateCount; idx++) {
1808 if (default_requests_[idx].get() == nullptr) {
1809 continue;
1810 }
1811
1812 default_requests_[idx]->Set(ANDROID_LENS_APERTURE, &aperture_, 1);
1813 default_requests_[idx]->Set(ANDROID_LENS_FOCAL_LENGTH, &focal_length_, 1);
1814 default_requests_[idx]->Set(ANDROID_LENS_FOCUS_DISTANCE, &focus_distance_,
1815 1);
1816 default_requests_[idx]->Set(ANDROID_LENS_OPTICAL_STABILIZATION_MODE,
1817 &ois_mode_, 1);
1818 }
1819
1820 return InitializeFlashDefaults();
1821 }
1822
InitializeInfoDefaults()1823 status_t EmulatedCameraDeviceInfo::InitializeInfoDefaults() {
1824 camera_metadata_ro_entry_t entry;
1825 auto ret =
1826 static_metadata_->Get(ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL, &entry);
1827 if ((ret == OK) && (entry.count == 1)) {
1828 if (kSupportedHWLevels.find(entry.data.u8[0]) ==
1829 kSupportedCapabilites.end()) {
1830 ALOGE("%s: HW Level: %u not supported", __FUNCTION__, entry.data.u8[0]);
1831 return BAD_VALUE;
1832 }
1833 } else {
1834 ALOGE("%s: No available hardware level!", __FUNCTION__);
1835 return BAD_VALUE;
1836 }
1837
1838 supported_hw_level_ = entry.data.u8[0];
1839 is_level_full_or_higher_ =
1840 (supported_hw_level_ == ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_FULL) ||
1841 (supported_hw_level_ == ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_3);
1842
1843 return InitializeReprocessDefaults();
1844 }
1845
InitializeReprocessDefaults()1846 status_t EmulatedCameraDeviceInfo::InitializeReprocessDefaults() {
1847 if (supports_private_reprocessing_ || supports_yuv_reprocessing_ ||
1848 supports_remosaic_reprocessing_) {
1849 StreamConfigurationMap config_map(*static_metadata_);
1850 if (!config_map.SupportsReprocessing()) {
1851 ALOGE(
1852 "%s: Reprocess capability present but InputOutput format map is "
1853 "absent!",
1854 __FUNCTION__);
1855 return BAD_VALUE;
1856 }
1857
1858 auto input_formats = config_map.GetInputFormats();
1859 for (const auto& input_format : input_formats) {
1860 auto output_formats =
1861 config_map.GetValidOutputFormatsForInput(input_format);
1862 for (const auto& output_format : output_formats) {
1863 if (!EmulatedSensor::IsReprocessPathSupported(
1864 EmulatedSensor::OverrideFormat(
1865 input_format,
1866 ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD),
1867 EmulatedSensor::OverrideFormat(
1868 output_format,
1869 ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD))) {
1870 ALOGE(
1871 "%s: Input format: 0x%x to output format: 0x%x reprocess is"
1872 " currently not supported!",
1873 __FUNCTION__, input_format, output_format);
1874 return BAD_VALUE;
1875 }
1876 }
1877 }
1878 }
1879
1880 return InitializeLensDefaults();
1881 }
1882
InitializeRequestDefaults()1883 status_t EmulatedCameraDeviceInfo::InitializeRequestDefaults() {
1884 camera_metadata_ro_entry_t entry;
1885 auto ret =
1886 static_metadata_->Get(ANDROID_REQUEST_AVAILABLE_CAPABILITIES, &entry);
1887 if ((ret == OK) && (entry.count > 0)) {
1888 for (size_t i = 0; i < entry.count; i++) {
1889 if (kSupportedCapabilites.find(entry.data.u8[i]) ==
1890 kSupportedCapabilites.end()) {
1891 ALOGE("%s: Capability: %u not supported", __FUNCTION__,
1892 entry.data.u8[i]);
1893 return BAD_VALUE;
1894 }
1895 }
1896 } else {
1897 ALOGE("%s: No available capabilities!", __FUNCTION__);
1898 return BAD_VALUE;
1899 }
1900 available_capabilities_.insert(entry.data.u8, entry.data.u8 + entry.count);
1901
1902 ret = static_metadata_->Get(ANDROID_REQUEST_PIPELINE_MAX_DEPTH, &entry);
1903 if ((ret == OK) && (entry.count == 1)) {
1904 if (entry.data.u8[0] == 0) {
1905 ALOGE("%s: Maximum request pipeline depth must have a non zero value!",
1906 __FUNCTION__);
1907 return BAD_VALUE;
1908 }
1909 } else {
1910 ALOGE("%s: Maximum request pipeline depth absent!", __FUNCTION__);
1911 return BAD_VALUE;
1912 }
1913 max_pipeline_depth_ = entry.data.u8[0];
1914
1915 ret = static_metadata_->Get(ANDROID_REQUEST_PARTIAL_RESULT_COUNT, &entry);
1916 if ((ret == OK) && (entry.count == 1)) {
1917 if (entry.data.i32[0] > 2) {
1918 ALOGW("%s: Partial result count greater than 2 not supported!",
1919 __FUNCTION__);
1920 }
1921 partial_result_count_ = entry.data.i32[0];
1922 }
1923
1924 ret = static_metadata_->Get(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS,
1925 &entry);
1926 if ((ret != OK) || (entry.count == 0)) {
1927 ALOGE("%s: No available characteristic keys!", __FUNCTION__);
1928 return BAD_VALUE;
1929 }
1930 available_characteristics_.insert(entry.data.i32,
1931 entry.data.i32 + entry.count);
1932
1933 ret = static_metadata_->Get(ANDROID_REQUEST_AVAILABLE_RESULT_KEYS, &entry);
1934 if ((ret != OK) || (entry.count == 0)) {
1935 ALOGE("%s: No available result keys!", __FUNCTION__);
1936 return BAD_VALUE;
1937 }
1938 available_results_.insert(entry.data.i32, entry.data.i32 + entry.count);
1939
1940 ret = static_metadata_->Get(ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS, &entry);
1941 if ((ret != OK) || (entry.count == 0)) {
1942 ALOGE("%s: No available request keys!", __FUNCTION__);
1943 return BAD_VALUE;
1944 }
1945 available_requests_.insert(entry.data.i32, entry.data.i32 + entry.count);
1946
1947 supports_manual_sensor_ =
1948 SupportsCapability(ANDROID_REQUEST_AVAILABLE_CAPABILITIES_MANUAL_SENSOR);
1949 supports_manual_post_processing_ = SupportsCapability(
1950 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_MANUAL_POST_PROCESSING);
1951 supports_private_reprocessing_ = SupportsCapability(
1952 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_PRIVATE_REPROCESSING);
1953 supports_yuv_reprocessing_ = SupportsCapability(
1954 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_YUV_REPROCESSING);
1955 supports_remosaic_reprocessing_ = SupportsCapability(
1956 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_REMOSAIC_REPROCESSING);
1957 is_backward_compatible_ = SupportsCapability(
1958 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE);
1959 is_raw_capable_ =
1960 SupportsCapability(ANDROID_REQUEST_AVAILABLE_CAPABILITIES_RAW);
1961 supports_stream_use_case_ =
1962 SupportsCapability(ANDROID_REQUEST_AVAILABLE_CAPABILITIES_STREAM_USE_CASE);
1963
1964 if (supports_manual_sensor_) {
1965 auto templateIdx = static_cast<size_t>(RequestTemplate::kManual);
1966 default_requests_[templateIdx] = HalCameraMetadata::Create(1, 10);
1967 }
1968
1969 if (supports_stream_use_case_) {
1970 ret = static_metadata_->Get(ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES,
1971 &entry);
1972 if (ret != OK) {
1973 ALOGE("%s: No available stream use cases!", __FUNCTION__);
1974 return BAD_VALUE;
1975 }
1976 for (int64_t useCase : kSupportedUseCases) {
1977 if (std::find(entry.data.i64, entry.data.i64 + entry.count, useCase) ==
1978 entry.data.i64 + entry.count) {
1979 ALOGE("%s: Mandatory stream use case %" PRId64 " not found!",
1980 __FUNCTION__, useCase);
1981 return BAD_VALUE;
1982 }
1983 }
1984 }
1985
1986 for (size_t templateIdx = 0; templateIdx < kTemplateCount; templateIdx++) {
1987 switch (static_cast<RequestTemplate>(templateIdx)) {
1988 case RequestTemplate::kPreview:
1989 case RequestTemplate::kStillCapture:
1990 case RequestTemplate::kVideoRecord:
1991 case RequestTemplate::kVideoSnapshot:
1992 default_requests_[templateIdx] = HalCameraMetadata::Create(1, 10);
1993 break;
1994 default:
1995 // Noop
1996 break;
1997 }
1998 }
1999
2000 if (supports_yuv_reprocessing_ || supports_private_reprocessing_) {
2001 auto templateIdx = static_cast<size_t>(RequestTemplate::kZeroShutterLag);
2002 default_requests_[templateIdx] = HalCameraMetadata::Create(1, 10);
2003 }
2004
2005 return InitializeInfoDefaults();
2006 }
2007
SupportsCapability(uint8_t cap)2008 bool EmulatedCameraDeviceInfo::SupportsCapability(uint8_t cap) {
2009 return available_capabilities_.find(cap) != available_capabilities_.end();
2010 }
2011
2012 } // namespace android
2013