1 /*
2 * Copyright (C) 2019 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 "EmulatedRequestState"
18 #define ATRACE_TAG ATRACE_TAG_CAMERA
19
20 #include "EmulatedRequestState.h"
21
22 #include <inttypes.h>
23 #include <log/log.h>
24 #include <utils/HWLUtils.h>
25
26 #include "EmulatedRequestProcessor.h"
27
28 namespace android {
29
30 using google_camera_hal::HwlPipelineResult;
31
32 const std::set<uint8_t> EmulatedRequestState::kSupportedCapabilites = {
33 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE,
34 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_MANUAL_SENSOR,
35 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_MANUAL_POST_PROCESSING,
36 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_RAW,
37 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_READ_SENSOR_SETTINGS,
38 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BURST_CAPTURE,
39 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_DEPTH_OUTPUT,
40 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_PRIVATE_REPROCESSING,
41 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_YUV_REPROCESSING,
42 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_LOGICAL_MULTI_CAMERA,
43 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_REMOSAIC_REPROCESSING,
44 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_ULTRA_HIGH_RESOLUTION_SENSOR,
45 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT,
46 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_STREAM_USE_CASE};
47
48 const std::set<uint8_t> EmulatedRequestState::kSupportedHWLevels = {
49 ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
50 ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_FULL,
51 ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_3,
52 };
53
54 const std::vector<int64_t> EmulatedRequestState::kSupportedUseCases = {
55 ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_DEFAULT,
56 ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_PREVIEW,
57 ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_STILL_CAPTURE,
58 ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_VIDEO_RECORD,
59 ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_PREVIEW_VIDEO_STILL,
60 ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_VIDEO_CALL};
61
62 template <typename T>
GetClosestValue(T val,T min,T max)63 T GetClosestValue(T val, T min, T max) {
64 if ((min > max) || ((val >= min) && (val <= max))) {
65 return val;
66 } else if (val > max) {
67 return max;
68 } else {
69 return min;
70 }
71 }
72
Update3AMeteringRegion(uint32_t tag,const HalCameraMetadata & settings,int32_t * region)73 status_t EmulatedRequestState::Update3AMeteringRegion(
74 uint32_t tag, const HalCameraMetadata& settings, int32_t* region /*out*/) {
75 if ((region == nullptr) || ((tag != ANDROID_CONTROL_AE_REGIONS) &&
76 (tag != ANDROID_CONTROL_AF_REGIONS) &&
77 (tag != ANDROID_CONTROL_AWB_REGIONS))) {
78 return BAD_VALUE;
79 }
80
81 camera_metadata_ro_entry_t entry;
82 auto ret = settings.Get(ANDROID_SCALER_CROP_REGION, &entry);
83 if ((ret == OK) && (entry.count > 0)) {
84 int32_t crop_region[4];
85 crop_region[0] = entry.data.i32[0];
86 crop_region[1] = entry.data.i32[1];
87 crop_region[2] = entry.data.i32[2] + crop_region[0];
88 crop_region[3] = entry.data.i32[3] + crop_region[1];
89 ret = settings.Get(tag, &entry);
90 if ((ret == OK) && (entry.count > 0)) {
91 const int32_t* a_region = entry.data.i32;
92 // calculate the intersection of 3A and CROP regions
93 if (a_region[0] < crop_region[2] && crop_region[0] < a_region[2] &&
94 a_region[1] < crop_region[3] && crop_region[1] < a_region[3]) {
95 region[0] = std::max(a_region[0], crop_region[0]);
96 region[1] = std::max(a_region[1], crop_region[1]);
97 region[2] = std::min(a_region[2], crop_region[2]);
98 region[3] = std::min(a_region[3], crop_region[3]);
99 region[4] = entry.data.i32[4];
100 }
101 }
102 }
103
104 return OK;
105 }
106
CompensateAE()107 status_t EmulatedRequestState::CompensateAE() {
108 if (!exposure_compensation_supported_) {
109 sensor_exposure_time_ = current_exposure_time_;
110 return OK;
111 }
112
113 camera_metadata_ro_entry_t entry;
114 auto ret =
115 request_settings_->Get(ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION, &entry);
116 if ((ret == OK) && (entry.count == 1)) {
117 exposure_compensation_ = entry.data.i32[0];
118 } else {
119 ALOGW("%s: AE compensation absent from request, re-using previous value!",
120 __FUNCTION__);
121 }
122
123 float ae_compensation = ::powf(
124 2, exposure_compensation_ *
125 ((static_cast<float>(exposure_compensation_step_.numerator) /
126 exposure_compensation_step_.denominator)));
127
128 sensor_exposure_time_ = GetClosestValue(
129 static_cast<nsecs_t>(ae_compensation * current_exposure_time_),
130 sensor_exposure_time_range_.first, sensor_exposure_time_range_.second);
131
132 return OK;
133 }
134
DoFakeAE()135 status_t EmulatedRequestState::DoFakeAE() {
136 camera_metadata_ro_entry_t entry;
137 auto ret = request_settings_->Get(ANDROID_CONTROL_AE_LOCK, &entry);
138 if ((ret == OK) && (entry.count == 1)) {
139 ae_lock_ = entry.data.u8[0];
140 } else {
141 ae_lock_ = ANDROID_CONTROL_AE_LOCK_OFF;
142 }
143
144 if (ae_lock_ == ANDROID_CONTROL_AE_LOCK_ON) {
145 ae_state_ = ANDROID_CONTROL_AE_STATE_LOCKED;
146 return OK;
147 }
148
149 FPSRange fps_range;
150 ret = request_settings_->Get(ANDROID_CONTROL_AE_TARGET_FPS_RANGE, &entry);
151 if ((ret == OK) && (entry.count == 2)) {
152 for (const auto& it : available_fps_ranges_) {
153 if ((it.min_fps == entry.data.i32[0]) &&
154 (it.max_fps == entry.data.i32[1])) {
155 fps_range = {entry.data.i32[0], entry.data.i32[1]};
156 break;
157 }
158 }
159 if (fps_range.max_fps == 0) {
160 ALOGE("%s: Unsupported framerate range [%d, %d]", __FUNCTION__,
161 entry.data.i32[0], entry.data.i32[1]);
162 return BAD_VALUE;
163 }
164 } else {
165 fps_range = *available_fps_ranges_.begin();
166 }
167
168 ret = request_settings_->Get(ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER, &entry);
169 if ((ret == OK) && (entry.count == 1)) {
170 ae_trigger_ = entry.data.u8[0];
171 } else {
172 ae_trigger_ = ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_IDLE;
173 }
174
175 nsecs_t min_frame_duration =
176 GetClosestValue(ms2ns(1000 / fps_range.max_fps),
177 EmulatedSensor::kSupportedFrameDurationRange[0],
178 sensor_max_frame_duration_);
179 nsecs_t max_frame_duration =
180 GetClosestValue(ms2ns(1000 / fps_range.min_fps),
181 EmulatedSensor::kSupportedFrameDurationRange[0],
182 sensor_max_frame_duration_);
183 sensor_frame_duration_ = (max_frame_duration + min_frame_duration) / 2;
184
185 // Face priority mode usually changes the AE algorithm behavior by
186 // using the regions of interest associated with detected faces.
187 // Try to emulate this behavior by slightly increasing the target exposure
188 // time compared to normal operation.
189 if (exposure_compensation_supported_) {
190 float max_ae_compensation = ::powf(
191 2, exposure_compensation_range_[1] *
192 ((static_cast<float>(exposure_compensation_step_.numerator) /
193 exposure_compensation_step_.denominator)));
194 ae_target_exposure_time_ = GetClosestValue(
195 static_cast<nsecs_t>(sensor_frame_duration_ / max_ae_compensation),
196 sensor_exposure_time_range_.first, sensor_exposure_time_range_.second);
197 } else if (scene_mode_ == ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY) {
198 ae_target_exposure_time_ = GetClosestValue(
199 sensor_frame_duration_ / 4, sensor_exposure_time_range_.first,
200 sensor_exposure_time_range_.second);
201 } else {
202 ae_target_exposure_time_ = GetClosestValue(
203 sensor_frame_duration_ / 5, sensor_exposure_time_range_.first,
204 sensor_exposure_time_range_.second);
205 }
206
207 if ((ae_trigger_ == ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_START) ||
208 (ae_state_ == ANDROID_CONTROL_AE_STATE_PRECAPTURE)) {
209 if (ae_state_ != ANDROID_CONTROL_AE_STATE_PRECAPTURE) {
210 ae_frame_counter_ = 0;
211 }
212
213 if (ae_trigger_ == ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_CANCEL) {
214 // Done with precapture
215 ae_frame_counter_ = 0;
216 ae_state_ = ANDROID_CONTROL_AE_STATE_CONVERGED;
217 ae_trigger_ = ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_CANCEL;
218 } else if ((ae_frame_counter_ > kAEPrecaptureMinFrames) &&
219 (abs(ae_target_exposure_time_ - current_exposure_time_) <
220 ae_target_exposure_time_ / kAETargetThreshold)) {
221 // Done with precapture
222 ae_frame_counter_ = 0;
223 ae_state_ = ANDROID_CONTROL_AE_STATE_CONVERGED;
224 ae_trigger_ = ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_IDLE;
225 } else {
226 // Converge some more
227 current_exposure_time_ +=
228 (ae_target_exposure_time_ - current_exposure_time_) *
229 kExposureTrackRate;
230 ae_frame_counter_++;
231 ae_state_ = ANDROID_CONTROL_AE_STATE_PRECAPTURE;
232 }
233 } else {
234 switch (ae_state_) {
235 case ANDROID_CONTROL_AE_STATE_INACTIVE:
236 ae_state_ = ANDROID_CONTROL_AE_STATE_SEARCHING;
237 break;
238 case ANDROID_CONTROL_AE_STATE_CONVERGED:
239 ae_frame_counter_++;
240 if (ae_frame_counter_ > kStableAeMaxFrames) {
241 float exposure_step = ((double)rand_r(&rand_seed_) / RAND_MAX) *
242 (kExposureWanderMax - kExposureWanderMin) +
243 kExposureWanderMin;
244 ae_target_exposure_time_ =
245 GetClosestValue(static_cast<nsecs_t>(ae_target_exposure_time_ *
246 std::pow(2, exposure_step)),
247 sensor_exposure_time_range_.first,
248 sensor_exposure_time_range_.second);
249 ae_state_ = ANDROID_CONTROL_AE_STATE_SEARCHING;
250 }
251 break;
252 case ANDROID_CONTROL_AE_STATE_SEARCHING:
253 current_exposure_time_ +=
254 (ae_target_exposure_time_ - current_exposure_time_) *
255 kExposureTrackRate;
256 if (abs(ae_target_exposure_time_ - current_exposure_time_) <
257 ae_target_exposure_time_ / kAETargetThreshold) {
258 // Close enough
259 ae_state_ = ANDROID_CONTROL_AE_STATE_CONVERGED;
260 ae_frame_counter_ = 0;
261 }
262 break;
263 case ANDROID_CONTROL_AE_STATE_LOCKED:
264 ae_state_ = ANDROID_CONTROL_AE_STATE_CONVERGED;
265 ae_frame_counter_ = 0;
266 break;
267 default:
268 ALOGE("%s: Unexpected AE state %d!", __FUNCTION__, ae_state_);
269 return INVALID_OPERATION;
270 }
271 }
272
273 return OK;
274 }
275
ProcessAWB()276 status_t EmulatedRequestState::ProcessAWB() {
277 if (max_awb_regions_ > 0) {
278 auto ret = Update3AMeteringRegion(ANDROID_CONTROL_AWB_REGIONS,
279 *request_settings_, awb_metering_region_);
280 if (ret != OK) {
281 return ret;
282 }
283 }
284 if (((awb_mode_ == ANDROID_CONTROL_AWB_MODE_OFF) ||
285 (control_mode_ == ANDROID_CONTROL_MODE_OFF)) &&
286 supports_manual_post_processing_) {
287 // TODO: Add actual manual support
288 } else if (is_backward_compatible_) {
289 camera_metadata_ro_entry_t entry;
290 auto ret = request_settings_->Get(ANDROID_CONTROL_AWB_LOCK, &entry);
291 if ((ret == OK) && (entry.count == 1)) {
292 awb_lock_ = entry.data.u8[0];
293 } else {
294 awb_lock_ = ANDROID_CONTROL_AWB_LOCK_OFF;
295 }
296
297 if (awb_lock_ == ANDROID_CONTROL_AWB_LOCK_ON) {
298 awb_state_ = ANDROID_CONTROL_AWB_STATE_LOCKED;
299 } else {
300 awb_state_ = ANDROID_CONTROL_AWB_STATE_CONVERGED;
301 }
302 } else {
303 // No color output support no need for AWB
304 }
305
306 return OK;
307 }
308
ProcessAF()309 status_t EmulatedRequestState::ProcessAF() {
310 camera_metadata_ro_entry entry;
311
312 if (max_af_regions_ > 0) {
313 auto ret = Update3AMeteringRegion(ANDROID_CONTROL_AF_REGIONS,
314 *request_settings_, af_metering_region_);
315 if (ret != OK) {
316 return ret;
317 }
318 }
319 if (af_mode_ == ANDROID_CONTROL_AF_MODE_OFF) {
320 camera_metadata_ro_entry_t entry;
321 auto ret = request_settings_->Get(ANDROID_LENS_FOCUS_DISTANCE, &entry);
322 if ((ret == OK) && (entry.count == 1)) {
323 if ((entry.data.f[0] >= 0.f) &&
324 (entry.data.f[0] <= minimum_focus_distance_)) {
325 focus_distance_ = entry.data.f[0];
326 } else {
327 ALOGE(
328 "%s: Unsupported focus distance, It should be within "
329 "[%5.2f, %5.2f]",
330 __FUNCTION__, 0.f, minimum_focus_distance_);
331 }
332 }
333
334 af_state_ = ANDROID_CONTROL_AF_STATE_INACTIVE;
335 return OK;
336 }
337
338 auto ret = request_settings_->Get(ANDROID_CONTROL_AF_TRIGGER, &entry);
339 if ((ret == OK) && (entry.count == 1)) {
340 af_trigger_ = entry.data.u8[0];
341 } else {
342 af_trigger_ = ANDROID_CONTROL_AF_TRIGGER_IDLE;
343 }
344
345 /**
346 * Simulate AF triggers. Transition at most 1 state per frame.
347 * - Focusing always succeeds (goes into locked, or PASSIVE_SCAN).
348 */
349
350 bool af_trigger_start = false;
351 switch (af_trigger_) {
352 case ANDROID_CONTROL_AF_TRIGGER_IDLE:
353 break;
354 case ANDROID_CONTROL_AF_TRIGGER_START:
355 af_trigger_start = true;
356 break;
357 case ANDROID_CONTROL_AF_TRIGGER_CANCEL:
358 // Cancel trigger always transitions into INACTIVE
359 af_state_ = ANDROID_CONTROL_AF_STATE_INACTIVE;
360
361 // Stay in 'inactive' until at least next frame
362 return OK;
363 default:
364 ALOGE("%s: Unknown AF trigger value", __FUNCTION__);
365 return BAD_VALUE;
366 }
367
368 // If we get down here, we're either in ANDROID_CONTROL_AF_MODE_AUTO,
369 // ANDROID_CONTROL_AF_MODE_MACRO, ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO,
370 // ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE and no other modes like
371 // ANDROID_CONTROL_AF_MODE_OFF or ANDROID_CONTROL_AF_MODE_EDOF
372 switch (af_state_) {
373 case ANDROID_CONTROL_AF_STATE_INACTIVE:
374 if (af_trigger_start) {
375 switch (af_mode_) {
376 case ANDROID_CONTROL_AF_MODE_AUTO:
377 // fall-through
378 case ANDROID_CONTROL_AF_MODE_MACRO:
379 af_state_ = ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN;
380 break;
381 case ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO:
382 // fall-through
383 case ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE:
384 af_state_ = ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED;
385 break;
386 }
387 } else {
388 // At least one frame stays in INACTIVE
389 if (!af_mode_changed_) {
390 switch (af_mode_) {
391 case ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO:
392 // fall-through
393 case ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE:
394 af_state_ = ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN;
395 break;
396 }
397 }
398 }
399 break;
400 case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN:
401 /**
402 * When the AF trigger is activated, the algorithm should finish
403 * its PASSIVE_SCAN if active, and then transition into AF_FOCUSED
404 * or AF_NOT_FOCUSED as appropriate
405 */
406 if (af_trigger_start) {
407 // Randomly transition to focused or not focused
408 if (rand_r(&rand_seed_) % 3) {
409 af_state_ = ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED;
410 } else {
411 af_state_ = ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED;
412 }
413 }
414 /**
415 * When the AF trigger is not involved, the AF algorithm should
416 * start in INACTIVE state, and then transition into PASSIVE_SCAN
417 * and PASSIVE_FOCUSED states
418 */
419 else {
420 // Randomly transition to passive focus
421 if (rand_r(&rand_seed_) % 3 == 0) {
422 af_state_ = ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED;
423 }
424 }
425
426 break;
427 case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED:
428 if (af_trigger_start) {
429 // Randomly transition to focused or not focused
430 if (rand_r(&rand_seed_) % 3) {
431 af_state_ = ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED;
432 } else {
433 af_state_ = ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED;
434 }
435 }
436 // TODO: initiate passive scan (PASSIVE_SCAN)
437 break;
438 case ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN:
439 // Simulate AF sweep completing instantaneously
440
441 // Randomly transition to focused or not focused
442 if (rand_r(&rand_seed_) % 3) {
443 af_state_ = ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED;
444 } else {
445 af_state_ = ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED;
446 }
447 break;
448 case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED:
449 if (af_trigger_start) {
450 switch (af_mode_) {
451 case ANDROID_CONTROL_AF_MODE_AUTO:
452 // fall-through
453 case ANDROID_CONTROL_AF_MODE_MACRO:
454 af_state_ = ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN;
455 break;
456 case ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO:
457 // fall-through
458 case ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE:
459 // continuous autofocus => trigger start has no effect
460 break;
461 }
462 }
463 break;
464 case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED:
465 if (af_trigger_start) {
466 switch (af_mode_) {
467 case ANDROID_CONTROL_AF_MODE_AUTO:
468 // fall-through
469 case ANDROID_CONTROL_AF_MODE_MACRO:
470 af_state_ = ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN;
471 break;
472 case ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO:
473 // fall-through
474 case ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE:
475 // continuous autofocus => trigger start has no effect
476 break;
477 }
478 }
479 break;
480 default:
481 ALOGE("%s: Bad af state %d", __FUNCTION__, af_state_);
482 }
483
484 return OK;
485 }
486
ProcessAE()487 status_t EmulatedRequestState::ProcessAE() {
488 if (max_ae_regions_ > 0) {
489 auto ret = Update3AMeteringRegion(ANDROID_CONTROL_AE_REGIONS,
490 *request_settings_, ae_metering_region_);
491 if (ret != OK) {
492 ALOGE("%s: Failed updating the 3A metering regions: %d, (%s)",
493 __FUNCTION__, ret, strerror(-ret));
494 }
495 }
496
497 camera_metadata_ro_entry_t entry;
498 bool auto_ae_mode = false;
499 bool auto_ae_flash_mode = false;
500 switch (ae_mode_) {
501 case ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH:
502 case ANDROID_CONTROL_AE_MODE_ON_ALWAYS_FLASH:
503 case ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH_REDEYE:
504 auto_ae_flash_mode = true;
505 [[fallthrough]];
506 case ANDROID_CONTROL_AE_MODE_ON:
507 auto_ae_mode = true;
508 };
509 if (((ae_mode_ == ANDROID_CONTROL_AE_MODE_OFF) ||
510 (control_mode_ == ANDROID_CONTROL_MODE_OFF)) &&
511 supports_manual_sensor_) {
512 auto ret = request_settings_->Get(ANDROID_SENSOR_EXPOSURE_TIME, &entry);
513 if ((ret == OK) && (entry.count == 1)) {
514 if ((entry.data.i64[0] >= sensor_exposure_time_range_.first) &&
515 (entry.data.i64[0] <= sensor_exposure_time_range_.second)) {
516 sensor_exposure_time_ = entry.data.i64[0];
517 } else {
518 ALOGE(
519 "%s: Sensor exposure time %" PRId64
520 " not within supported range[%" PRId64 ", %" PRId64 "]",
521 __FUNCTION__,
522 entry.data.i64[0],
523 sensor_exposure_time_range_.first,
524 sensor_exposure_time_range_.second);
525 // Use last valid value
526 }
527 }
528
529 ret = request_settings_->Get(ANDROID_SENSOR_FRAME_DURATION, &entry);
530 if ((ret == OK) && (entry.count == 1)) {
531 if ((entry.data.i64[0] >=
532 EmulatedSensor::kSupportedFrameDurationRange[0]) &&
533 (entry.data.i64[0] <= sensor_max_frame_duration_)) {
534 sensor_frame_duration_ = entry.data.i64[0];
535 } else {
536 ALOGE(
537 "%s: Sensor frame duration %" PRId64
538 " not within supported range[%" PRId64 ", %" PRId64 "]",
539 __FUNCTION__, entry.data.i64[0],
540 EmulatedSensor::kSupportedFrameDurationRange[0],
541 sensor_max_frame_duration_);
542 // Use last valid value
543 }
544 }
545
546 if (sensor_frame_duration_ < sensor_exposure_time_) {
547 sensor_frame_duration_ = sensor_exposure_time_;
548 }
549
550 ret = request_settings_->Get(ANDROID_SENSOR_SENSITIVITY, &entry);
551 if ((ret == OK) && (entry.count == 1)) {
552 if ((entry.data.i32[0] >= sensor_sensitivity_range_.first) &&
553 (entry.data.i32[0] <= sensor_sensitivity_range_.second)) {
554 sensor_sensitivity_ = entry.data.i32[0];
555 } else {
556 ALOGE("%s: Sensor sensitivity %d not within supported range[%d, %d]",
557 __FUNCTION__, entry.data.i32[0],
558 sensor_sensitivity_range_.first,
559 sensor_sensitivity_range_.second);
560 // Use last valid value
561 }
562 }
563 ae_state_ = ANDROID_CONTROL_AE_STATE_INACTIVE;
564 } else if (is_backward_compatible_ && auto_ae_mode) {
565 auto ret = DoFakeAE();
566 if (ret != OK) {
567 ALOGE("%s: Failed fake AE: %d, (%s)", __FUNCTION__, ret, strerror(-ret));
568 }
569
570 // Do AE compensation on the results of the AE
571 ret = CompensateAE();
572 if (ret != OK) {
573 ALOGE("%s: Failed during AE compensation: %d, (%s)", __FUNCTION__, ret,
574 strerror(-ret));
575 }
576 } else {
577 ALOGI(
578 "%s: No emulation for current AE mode using previous sensor settings!",
579 __FUNCTION__);
580 }
581
582 if (is_flash_supported_) {
583 flash_state_ = ANDROID_FLASH_STATE_READY;
584 // Flash fires only if the request manually enables it (SINGLE/TORCH)
585 // and the appropriate AE mode is set or during still capture with auto
586 // flash AE modes.
587 bool manual_flash_mode = false;
588 auto ret = request_settings_->Get(ANDROID_FLASH_MODE, &entry);
589 if ((ret == OK) && (entry.count == 1)) {
590 if ((entry.data.u8[0] == ANDROID_FLASH_MODE_SINGLE) ||
591 (entry.data.u8[0] == ANDROID_FLASH_MODE_TORCH)) {
592 manual_flash_mode = true;
593 }
594 }
595 if (manual_flash_mode && !auto_ae_flash_mode) {
596 flash_state_ = ANDROID_FLASH_STATE_FIRED;
597 } else {
598 bool is_still_capture = false;
599 ret = request_settings_->Get(ANDROID_CONTROL_CAPTURE_INTENT, &entry);
600 if ((ret == OK) && (entry.count == 1)) {
601 if (entry.data.u8[0] == ANDROID_CONTROL_CAPTURE_INTENT_STILL_CAPTURE) {
602 is_still_capture = true;
603 }
604 }
605 if (is_still_capture && auto_ae_flash_mode) {
606 flash_state_ = ANDROID_FLASH_STATE_FIRED;
607 }
608 }
609 } else {
610 flash_state_ = ANDROID_FLASH_STATE_UNAVAILABLE;
611 }
612
613 return OK;
614 }
615
InitializeSensorSettings(std::unique_ptr<HalCameraMetadata> request_settings,EmulatedSensor::SensorSettings * sensor_settings)616 status_t EmulatedRequestState::InitializeSensorSettings(
617 std::unique_ptr<HalCameraMetadata> request_settings,
618 EmulatedSensor::SensorSettings* sensor_settings /*out*/) {
619 if ((sensor_settings == nullptr) || (request_settings.get() == nullptr)) {
620 return BAD_VALUE;
621 }
622
623 std::lock_guard<std::mutex> lock(request_state_mutex_);
624 request_settings_ = std::move(request_settings);
625 camera_metadata_ro_entry_t entry;
626 auto ret = request_settings_->Get(ANDROID_CONTROL_MODE, &entry);
627 if ((ret == OK) && (entry.count == 1)) {
628 if (available_control_modes_.find(entry.data.u8[0]) !=
629 available_control_modes_.end()) {
630 control_mode_ = entry.data.u8[0];
631 } else {
632 ALOGE("%s: Unsupported control mode!", __FUNCTION__);
633 return BAD_VALUE;
634 }
635 }
636
637 ret = request_settings_->Get(ANDROID_SENSOR_PIXEL_MODE, &entry);
638 if ((ret == OK) && (entry.count == 1)) {
639 if (available_sensor_pixel_modes_.find(entry.data.u8[0]) !=
640 available_sensor_pixel_modes_.end()) {
641 sensor_pixel_mode_ = entry.data.u8[0];
642 } else {
643 ALOGE("%s: Unsupported control sensor pixel mode!", __FUNCTION__);
644 return BAD_VALUE;
645 }
646 }
647
648 ret = request_settings_->Get(ANDROID_CONTROL_SCENE_MODE, &entry);
649 if ((ret == OK) && (entry.count == 1)) {
650 // Disabled scene is not expected to be among the available scene list
651 if ((entry.data.u8[0] == ANDROID_CONTROL_SCENE_MODE_DISABLED) ||
652 (available_scenes_.find(entry.data.u8[0]) != available_scenes_.end())) {
653 scene_mode_ = entry.data.u8[0];
654 } else {
655 ALOGE("%s: Unsupported scene mode!", __FUNCTION__);
656 return BAD_VALUE;
657 }
658 }
659
660 float min_zoom = min_zoom_, max_zoom = max_zoom_;
661 ret = request_settings_->Get(ANDROID_CONTROL_EXTENDED_SCENE_MODE, &entry);
662 if ((ret == OK) && (entry.count == 1)) {
663 bool extended_scene_mode_valid = false;
664 for (const auto& cap : available_extended_scene_mode_caps_) {
665 if (cap.mode == entry.data.u8[0]) {
666 extended_scene_mode_ = entry.data.u8[0];
667 min_zoom = cap.min_zoom;
668 max_zoom = cap.max_zoom;
669 extended_scene_mode_valid = true;
670 break;
671 }
672 }
673 if (!extended_scene_mode_valid) {
674 ALOGE("%s: Unsupported extended scene mode %d!", __FUNCTION__,
675 entry.data.u8[0]);
676 return BAD_VALUE;
677 }
678 if (extended_scene_mode_ != ANDROID_CONTROL_EXTENDED_SCENE_MODE_DISABLED) {
679 scene_mode_ = ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY;
680 }
681 }
682
683 // Check zoom ratio range and override to supported range
684 ret = request_settings_->Get(ANDROID_CONTROL_ZOOM_RATIO, &entry);
685 if ((ret == OK) && (entry.count == 1)) {
686 zoom_ratio_ = std::min(std::max(entry.data.f[0], min_zoom), max_zoom);
687 }
688
689 // Check rotate_and_crop setting
690 ret = request_settings_->Get(ANDROID_SCALER_ROTATE_AND_CROP, &entry);
691 if ((ret == OK) && (entry.count == 1)) {
692 if (available_rotate_crop_modes_.find(entry.data.u8[0]) !=
693 available_rotate_crop_modes_.end()) {
694 rotate_and_crop_ = entry.data.u8[0];
695 } else {
696 ALOGE("%s: Unsupported rotate and crop mode: %u", __FUNCTION__, entry.data.u8[0]);
697 return BAD_VALUE;
698 }
699 }
700
701 // Check video stabilization parameter
702 uint8_t vstab_mode = ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF;
703 ret = request_settings_->Get(ANDROID_CONTROL_VIDEO_STABILIZATION_MODE, &entry);
704 if ((ret == OK) && (entry.count == 1)) {
705 if (available_vstab_modes_.find(entry.data.u8[0]) !=
706 available_vstab_modes_.end()) {
707 vstab_mode = entry.data.u8[0];
708 } else {
709 ALOGE("%s: Unsupported video stabilization mode: %u! Video stabilization will be disabled!",
710 __FUNCTION__, entry.data.u8[0]);
711 }
712 }
713
714 // Check video stabilization parameter
715 uint8_t edge_mode = ANDROID_EDGE_MODE_OFF;
716 ret = request_settings_->Get(ANDROID_EDGE_MODE, &entry);
717 if ((ret == OK) && (entry.count == 1)) {
718 if (available_edge_modes_.find(entry.data.u8[0]) !=
719 available_edge_modes_.end()) {
720 edge_mode = entry.data.u8[0];
721 } else {
722 ALOGE("%s: Unsupported edge mode: %u", __FUNCTION__, entry.data.u8[0]);
723 return BAD_VALUE;
724 }
725 }
726
727 // Check test pattern parameter
728 uint8_t test_pattern_mode = ANDROID_SENSOR_TEST_PATTERN_MODE_OFF;
729 ret = request_settings_->Get(ANDROID_SENSOR_TEST_PATTERN_MODE, &entry);
730 if ((ret == OK) && (entry.count == 1)) {
731 if (available_test_pattern_modes_.find(entry.data.u8[0]) !=
732 available_test_pattern_modes_.end()) {
733 test_pattern_mode = entry.data.u8[0];
734 } else {
735 ALOGE("%s: Unsupported test pattern mode: %u", __FUNCTION__,
736 entry.data.u8[0]);
737 return BAD_VALUE;
738 }
739 }
740 uint32_t test_pattern_data[4] = {0, 0, 0, 0};
741 if (test_pattern_mode == ANDROID_SENSOR_TEST_PATTERN_MODE_SOLID_COLOR) {
742 ret = request_settings_->Get(ANDROID_SENSOR_TEST_PATTERN_DATA, &entry);
743 if ((ret == OK) && (entry.count == 4)) {
744 // 'Convert' from i32 to u32 here
745 memcpy(test_pattern_data, entry.data.i32, sizeof(test_pattern_data));
746 }
747 }
748 // BLACK is just SOLID_COLOR with all-zero data
749 if (test_pattern_mode == ANDROID_SENSOR_TEST_PATTERN_MODE_BLACK) {
750 test_pattern_mode = ANDROID_SENSOR_TEST_PATTERN_MODE_SOLID_COLOR;
751 }
752
753 // 3A modes are active in case the scene is disabled or set to face priority
754 // or the control mode is not using scenes
755 if ((scene_mode_ == ANDROID_CONTROL_SCENE_MODE_DISABLED) ||
756 (scene_mode_ == ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY) ||
757 (control_mode_ != ANDROID_CONTROL_MODE_USE_SCENE_MODE)) {
758 ret = request_settings_->Get(ANDROID_CONTROL_AE_MODE, &entry);
759 if ((ret == OK) && (entry.count == 1)) {
760 if (available_ae_modes_.find(entry.data.u8[0]) !=
761 available_ae_modes_.end()) {
762 ae_mode_ = entry.data.u8[0];
763 } else {
764 ALOGE("%s: Unsupported AE mode! Using last valid mode!", __FUNCTION__);
765 }
766 }
767
768 ret = request_settings_->Get(ANDROID_CONTROL_AWB_MODE, &entry);
769 if ((ret == OK) && (entry.count == 1)) {
770 if (available_awb_modes_.find(entry.data.u8[0]) !=
771 available_awb_modes_.end()) {
772 awb_mode_ = entry.data.u8[0];
773 } else {
774 ALOGE("%s: Unsupported AWB mode! Using last valid mode!", __FUNCTION__);
775 }
776 }
777
778 ret = request_settings_->Get(ANDROID_CONTROL_AF_MODE, &entry);
779 if ((ret == OK) && (entry.count == 1)) {
780 if (available_af_modes_.find(entry.data.u8[0]) !=
781 available_af_modes_.end()) {
782 af_mode_changed_ = af_mode_ != entry.data.u8[0];
783 af_mode_ = entry.data.u8[0];
784 } else {
785 ALOGE("%s: Unsupported AF mode! Using last valid mode!", __FUNCTION__);
786 }
787 }
788 } else {
789 auto it = scene_overrides_.find(scene_mode_);
790 if (it != scene_overrides_.end()) {
791 ae_mode_ = it->second.ae_mode;
792 awb_mode_ = it->second.awb_mode;
793 af_mode_changed_ = af_mode_ != entry.data.u8[0];
794 af_mode_ = it->second.af_mode;
795 } else {
796 ALOGW(
797 "%s: Current scene has no overrides! Using the currently active 3A "
798 "modes!",
799 __FUNCTION__);
800 }
801 }
802
803 ret = ProcessAE();
804 if (ret != OK) {
805 return ret;
806 }
807
808 ret = ProcessAWB();
809 if (ret != OK) {
810 return ret;
811 }
812
813 ret = ProcessAF();
814 if (ret != OK) {
815 return ret;
816 }
817
818 ret = request_settings_->Get(ANDROID_STATISTICS_LENS_SHADING_MAP_MODE, &entry);
819 if ((ret == OK) && (entry.count == 1)) {
820 if (available_lens_shading_map_modes_.find(entry.data.u8[0]) !=
821 available_lens_shading_map_modes_.end()) {
822 sensor_settings->lens_shading_map_mode = entry.data.u8[0];
823 } else {
824 ALOGE("%s: Unsupported lens shading map mode!", __FUNCTION__);
825 }
826 }
827
828 sensor_settings->exposure_time = sensor_exposure_time_;
829 sensor_settings->frame_duration = sensor_frame_duration_;
830 sensor_settings->gain = sensor_sensitivity_;
831 sensor_settings->report_neutral_color_point = report_neutral_color_point_;
832 sensor_settings->report_green_split = report_green_split_;
833 sensor_settings->report_noise_profile = report_noise_profile_;
834 sensor_settings->zoom_ratio = zoom_ratio_;
835 sensor_settings->report_rotate_and_crop = report_rotate_and_crop_;
836 sensor_settings->rotate_and_crop = rotate_and_crop_;
837 sensor_settings->report_video_stab = !available_vstab_modes_.empty();
838 sensor_settings->video_stab = vstab_mode;
839 sensor_settings->report_edge_mode = report_edge_mode_;
840 sensor_settings->edge_mode = edge_mode;
841 sensor_settings->sensor_pixel_mode = sensor_pixel_mode_;
842 sensor_settings->test_pattern_mode = test_pattern_mode;
843 memcpy(sensor_settings->test_pattern_data, test_pattern_data,
844 sizeof(sensor_settings->test_pattern_data));
845
846 return OK;
847 }
848
InitializeResult(uint32_t pipeline_id,uint32_t frame_number)849 std::unique_ptr<HwlPipelineResult> EmulatedRequestState::InitializeResult(
850 uint32_t pipeline_id, uint32_t frame_number) {
851 std::lock_guard<std::mutex> lock(request_state_mutex_);
852 auto result = std::make_unique<HwlPipelineResult>();
853 result->camera_id = camera_id_;
854 result->pipeline_id = pipeline_id;
855 result->frame_number = frame_number;
856 result->result_metadata = HalCameraMetadata::Clone(request_settings_.get());
857 result->partial_result = partial_result_count_;
858
859 // Results supported on all emulated devices
860 result->result_metadata->Set(ANDROID_REQUEST_PIPELINE_DEPTH,
861 &max_pipeline_depth_, 1);
862 result->result_metadata->Set(ANDROID_CONTROL_MODE, &control_mode_, 1);
863 result->result_metadata->Set(ANDROID_SENSOR_PIXEL_MODE, &sensor_pixel_mode_,
864 1);
865
866 result->result_metadata->Set(ANDROID_CONTROL_AF_MODE, &af_mode_, 1);
867 result->result_metadata->Set(ANDROID_CONTROL_AF_STATE, &af_state_, 1);
868 result->result_metadata->Set(ANDROID_CONTROL_AWB_MODE, &awb_mode_, 1);
869 result->result_metadata->Set(ANDROID_CONTROL_AWB_STATE, &awb_state_, 1);
870 result->result_metadata->Set(ANDROID_CONTROL_AE_MODE, &ae_mode_, 1);
871 result->result_metadata->Set(ANDROID_CONTROL_AE_STATE, &ae_state_, 1);
872 int32_t fps_range[] = {ae_target_fps_.min_fps, ae_target_fps_.max_fps};
873 result->result_metadata->Set(ANDROID_CONTROL_AE_TARGET_FPS_RANGE, fps_range,
874 ARRAY_SIZE(fps_range));
875 result->result_metadata->Set(ANDROID_FLASH_STATE, &flash_state_, 1);
876 result->result_metadata->Set(ANDROID_LENS_STATE, &lens_state_, 1);
877
878 // Results depending on device capability and features
879 if (is_backward_compatible_) {
880 result->result_metadata->Set(ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER,
881 &ae_trigger_, 1);
882 result->result_metadata->Set(ANDROID_CONTROL_AF_TRIGGER, &af_trigger_, 1);
883 uint8_t vstab_mode = ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF;
884 result->result_metadata->Set(ANDROID_CONTROL_VIDEO_STABILIZATION_MODE,
885 &vstab_mode, 1);
886 if (exposure_compensation_supported_) {
887 result->result_metadata->Set(ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION,
888 &exposure_compensation_, 1);
889 }
890 }
891 if (ae_lock_available_ && report_ae_lock_) {
892 result->result_metadata->Set(ANDROID_CONTROL_AE_LOCK, &ae_lock_, 1);
893 }
894 if (awb_lock_available_ && report_awb_lock_) {
895 result->result_metadata->Set(ANDROID_CONTROL_AWB_LOCK, &awb_lock_, 1);
896 }
897 if (scenes_supported_) {
898 result->result_metadata->Set(ANDROID_CONTROL_SCENE_MODE, &scene_mode_, 1);
899 }
900 if (max_ae_regions_ > 0) {
901 result->result_metadata->Set(ANDROID_CONTROL_AE_REGIONS, ae_metering_region_,
902 ARRAY_SIZE(ae_metering_region_));
903 }
904 if (max_awb_regions_ > 0) {
905 result->result_metadata->Set(ANDROID_CONTROL_AWB_REGIONS,
906 awb_metering_region_,
907 ARRAY_SIZE(awb_metering_region_));
908 }
909 if (max_af_regions_ > 0) {
910 result->result_metadata->Set(ANDROID_CONTROL_AF_REGIONS, af_metering_region_,
911 ARRAY_SIZE(af_metering_region_));
912 }
913 if (report_exposure_time_) {
914 result->result_metadata->Set(ANDROID_SENSOR_EXPOSURE_TIME,
915 &sensor_exposure_time_, 1);
916 }
917 if (report_frame_duration_) {
918 result->result_metadata->Set(ANDROID_SENSOR_FRAME_DURATION,
919 &sensor_frame_duration_, 1);
920 }
921 if (report_sensitivity_) {
922 result->result_metadata->Set(ANDROID_SENSOR_SENSITIVITY,
923 &sensor_sensitivity_, 1);
924 }
925 if (report_rolling_shutter_skew_) {
926 result->result_metadata->Set(
927 ANDROID_SENSOR_ROLLING_SHUTTER_SKEW,
928 &EmulatedSensor::kSupportedFrameDurationRange[0], 1);
929 }
930 if (report_post_raw_boost_) {
931 result->result_metadata->Set(ANDROID_CONTROL_POST_RAW_SENSITIVITY_BOOST,
932 &post_raw_boost_, 1);
933 }
934 if (report_focus_distance_) {
935 result->result_metadata->Set(ANDROID_LENS_FOCUS_DISTANCE, &focus_distance_,
936 1);
937 }
938 if (report_focus_range_) {
939 float focus_range[2] = {0.f};
940 if (minimum_focus_distance_ > .0f) {
941 focus_range[0] = 1 / minimum_focus_distance_;
942 }
943 result->result_metadata->Set(ANDROID_LENS_FOCUS_RANGE, focus_range,
944 ARRAY_SIZE(focus_range));
945 }
946 if (report_filter_density_) {
947 result->result_metadata->Set(ANDROID_LENS_FILTER_DENSITY, &filter_density_,
948 1);
949 }
950 if (report_ois_mode_) {
951 result->result_metadata->Set(ANDROID_LENS_OPTICAL_STABILIZATION_MODE,
952 &ois_mode_, 1);
953 }
954 if (report_pose_rotation_) {
955 result->result_metadata->Set(ANDROID_LENS_POSE_ROTATION, pose_rotation_,
956 ARRAY_SIZE(pose_rotation_));
957 }
958 if (report_pose_translation_) {
959 result->result_metadata->Set(ANDROID_LENS_POSE_TRANSLATION,
960 pose_translation_,
961 ARRAY_SIZE(pose_translation_));
962 }
963 if (report_intrinsic_calibration_) {
964 result->result_metadata->Set(ANDROID_LENS_INTRINSIC_CALIBRATION,
965 intrinsic_calibration_,
966 ARRAY_SIZE(intrinsic_calibration_));
967 }
968 if (report_distortion_) {
969 result->result_metadata->Set(ANDROID_LENS_DISTORTION, distortion_,
970 ARRAY_SIZE(distortion_));
971 }
972 if (report_black_level_lock_) {
973 result->result_metadata->Set(ANDROID_BLACK_LEVEL_LOCK, &black_level_lock_,
974 1);
975 }
976 if (report_scene_flicker_) {
977 result->result_metadata->Set(ANDROID_STATISTICS_SCENE_FLICKER,
978 ¤t_scene_flicker_, 1);
979 }
980 if (zoom_ratio_supported_) {
981 result->result_metadata->Set(ANDROID_CONTROL_ZOOM_RATIO, &zoom_ratio_, 1);
982 int32_t* chosen_crop_region = scaler_crop_region_default_;
983 if (sensor_pixel_mode_ == ANDROID_SENSOR_PIXEL_MODE_MAXIMUM_RESOLUTION) {
984 chosen_crop_region = scaler_crop_region_max_resolution_;
985 }
986 result->result_metadata->Set(ANDROID_SCALER_CROP_REGION, chosen_crop_region,
987 ARRAY_SIZE(scaler_crop_region_default_));
988 }
989 if (report_extended_scene_mode_) {
990 result->result_metadata->Set(ANDROID_CONTROL_EXTENDED_SCENE_MODE,
991 &extended_scene_mode_, 1);
992 }
993 return result;
994 }
995
SupportsCapability(uint8_t cap)996 bool EmulatedRequestState::SupportsCapability(uint8_t cap) {
997 return available_capabilities_.find(cap) != available_capabilities_.end();
998 }
999
InitializeSensorDefaults()1000 status_t EmulatedRequestState::InitializeSensorDefaults() {
1001 camera_metadata_ro_entry_t entry;
1002 auto ret =
1003 static_metadata_->Get(ANDROID_SENSOR_INFO_SENSITIVITY_RANGE, &entry);
1004 if ((ret == OK) && (entry.count == 2)) {
1005 sensor_sensitivity_range_ =
1006 std::make_pair(entry.data.i32[0], entry.data.i32[1]);
1007 } else if (!supports_manual_sensor_) {
1008 sensor_sensitivity_range_ =
1009 std::make_pair(EmulatedSensor::kSupportedSensitivityRange[0],
1010 EmulatedSensor::kSupportedSensitivityRange[1]);
1011 } else {
1012 ALOGE("%s: Manual sensor devices must advertise sensor sensitivity range!",
1013 __FUNCTION__);
1014 return BAD_VALUE;
1015 }
1016
1017 ret = static_metadata_->Get(ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE, &entry);
1018 if ((ret == OK) && (entry.count == 2)) {
1019 sensor_exposure_time_range_ =
1020 std::make_pair(entry.data.i64[0], entry.data.i64[1]);
1021 } else if (!supports_manual_sensor_) {
1022 sensor_exposure_time_range_ =
1023 std::make_pair(EmulatedSensor::kSupportedExposureTimeRange[0],
1024 EmulatedSensor::kSupportedExposureTimeRange[1]);
1025 } else {
1026 ALOGE(
1027 "%s: Manual sensor devices must advertise sensor exposure time range!",
1028 __FUNCTION__);
1029 return BAD_VALUE;
1030 }
1031
1032 ret = static_metadata_->Get(ANDROID_SENSOR_INFO_MAX_FRAME_DURATION, &entry);
1033 if ((ret == OK) && (entry.count == 1)) {
1034 sensor_max_frame_duration_ = entry.data.i64[0];
1035 } else if (!supports_manual_sensor_) {
1036 sensor_max_frame_duration_ = EmulatedSensor::kSupportedFrameDurationRange[1];
1037 } else {
1038 ALOGE("%s: Manual sensor devices must advertise sensor max frame duration!",
1039 __FUNCTION__);
1040 return BAD_VALUE;
1041 }
1042
1043 if (supports_manual_sensor_) {
1044 if (available_requests_.find(ANDROID_SENSOR_SENSITIVITY) ==
1045 available_requests_.end()) {
1046 ALOGE(
1047 "%s: Sensor sensitivity must be configurable on manual sensor "
1048 "devices!",
1049 __FUNCTION__);
1050 return BAD_VALUE;
1051 }
1052
1053 if (available_requests_.find(ANDROID_SENSOR_EXPOSURE_TIME) ==
1054 available_requests_.end()) {
1055 ALOGE(
1056 "%s: Sensor exposure time must be configurable on manual sensor "
1057 "devices!",
1058 __FUNCTION__);
1059 return BAD_VALUE;
1060 }
1061
1062 if (available_requests_.find(ANDROID_SENSOR_FRAME_DURATION) ==
1063 available_requests_.end()) {
1064 ALOGE(
1065 "%s: Sensor frame duration must be configurable on manual sensor "
1066 "devices!",
1067 __FUNCTION__);
1068 return BAD_VALUE;
1069 }
1070 }
1071
1072 report_rolling_shutter_skew_ =
1073 available_results_.find(ANDROID_SENSOR_ROLLING_SHUTTER_SKEW) !=
1074 available_results_.end();
1075 report_sensitivity_ = available_results_.find(ANDROID_SENSOR_SENSITIVITY) !=
1076 available_results_.end();
1077 report_exposure_time_ =
1078 available_results_.find(ANDROID_SENSOR_EXPOSURE_TIME) !=
1079 available_results_.end();
1080 report_frame_duration_ =
1081 available_results_.find(ANDROID_SENSOR_FRAME_DURATION) !=
1082 available_results_.end();
1083 report_neutral_color_point_ =
1084 available_results_.find(ANDROID_SENSOR_NEUTRAL_COLOR_POINT) !=
1085 available_results_.end();
1086 report_green_split_ = available_results_.find(ANDROID_SENSOR_GREEN_SPLIT) !=
1087 available_results_.end();
1088 report_noise_profile_ =
1089 available_results_.find(ANDROID_SENSOR_NOISE_PROFILE) !=
1090 available_results_.end();
1091
1092 if (is_raw_capable_ && !report_green_split_) {
1093 ALOGE("%s: RAW capable devices must be able to report the noise profile!",
1094 __FUNCTION__);
1095 return BAD_VALUE;
1096 }
1097
1098 if (is_raw_capable_ && !report_neutral_color_point_) {
1099 ALOGE(
1100 "%s: RAW capable devices must be able to report the neutral color "
1101 "point!",
1102 __FUNCTION__);
1103 return BAD_VALUE;
1104 }
1105
1106 if (is_raw_capable_ && !report_green_split_) {
1107 ALOGE("%s: RAW capable devices must be able to report the green split!",
1108 __FUNCTION__);
1109 return BAD_VALUE;
1110 }
1111 if (available_results_.find(ANDROID_SENSOR_TIMESTAMP) ==
1112 available_results_.end()) {
1113 ALOGE("%s: Sensor timestamp must always be part of the results!",
1114 __FUNCTION__);
1115 return BAD_VALUE;
1116 }
1117
1118 ret = static_metadata_->Get(ANDROID_SENSOR_AVAILABLE_TEST_PATTERN_MODES,
1119 &entry);
1120 if (ret == OK) {
1121 available_test_pattern_modes_.insert(entry.data.i32,
1122 entry.data.i32 + entry.count);
1123 } else {
1124 ALOGE("%s: No available test pattern modes!", __FUNCTION__);
1125 return BAD_VALUE;
1126 }
1127
1128 sensor_exposure_time_ = GetClosestValue(EmulatedSensor::kDefaultExposureTime,
1129 sensor_exposure_time_range_.first,
1130 sensor_exposure_time_range_.second);
1131 sensor_frame_duration_ =
1132 GetClosestValue(EmulatedSensor::kDefaultFrameDuration,
1133 EmulatedSensor::kSupportedFrameDurationRange[0],
1134 sensor_max_frame_duration_);
1135 sensor_sensitivity_ = GetClosestValue(EmulatedSensor::kDefaultSensitivity,
1136 sensor_sensitivity_range_.first,
1137 sensor_sensitivity_range_.second);
1138
1139 bool off_test_pattern_mode_supported =
1140 available_test_pattern_modes_.find(ANDROID_SENSOR_TEST_PATTERN_MODE_OFF) !=
1141 available_test_pattern_modes_.end();
1142 int32_t test_pattern_mode = (off_test_pattern_mode_supported)
1143 ? ANDROID_SENSOR_TEST_PATTERN_MODE_OFF
1144 : *available_test_pattern_modes_.begin();
1145 int32_t test_pattern_data[4] = {0, 0, 0, 0};
1146
1147 for (size_t idx = 0; idx < kTemplateCount; idx++) {
1148 if (default_requests_[idx].get() == nullptr) {
1149 continue;
1150 }
1151
1152 default_requests_[idx]->Set(ANDROID_SENSOR_EXPOSURE_TIME,
1153 &sensor_exposure_time_, 1);
1154 default_requests_[idx]->Set(ANDROID_SENSOR_FRAME_DURATION,
1155 &sensor_frame_duration_, 1);
1156 default_requests_[idx]->Set(ANDROID_SENSOR_SENSITIVITY,
1157 &sensor_sensitivity_, 1);
1158 default_requests_[idx]->Set(ANDROID_SENSOR_TEST_PATTERN_MODE,
1159 &test_pattern_mode, 1);
1160 default_requests_[idx]->Set(ANDROID_SENSOR_TEST_PATTERN_DATA,
1161 test_pattern_data, 4);
1162 }
1163
1164 return OK;
1165 }
1166
InitializeStatisticsDefaults()1167 status_t EmulatedRequestState::InitializeStatisticsDefaults() {
1168 camera_metadata_ro_entry_t entry;
1169 auto ret = static_metadata_->Get(
1170 ANDROID_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES, &entry);
1171 if (ret == OK) {
1172 available_face_detect_modes_.insert(entry.data.u8,
1173 entry.data.u8 + entry.count);
1174 } else {
1175 ALOGE("%s: No available face detect modes!", __FUNCTION__);
1176 return BAD_VALUE;
1177 }
1178
1179 ret = static_metadata_->Get(
1180 ANDROID_STATISTICS_INFO_AVAILABLE_LENS_SHADING_MAP_MODES, &entry);
1181 if (ret == OK) {
1182 available_lens_shading_map_modes_.insert(entry.data.u8,
1183 entry.data.u8 + entry.count);
1184 } else {
1185 ALOGE("%s: No available lens shading modes!", __FUNCTION__);
1186 return BAD_VALUE;
1187 }
1188
1189 ret = static_metadata_->Get(
1190 ANDROID_STATISTICS_INFO_AVAILABLE_HOT_PIXEL_MAP_MODES, &entry);
1191 if (ret == OK) {
1192 available_hot_pixel_map_modes_.insert(entry.data.u8,
1193 entry.data.u8 + entry.count);
1194 } else if (is_raw_capable_) {
1195 ALOGE("%s: RAW capable device must support hot pixel map modes!",
1196 __FUNCTION__);
1197 return BAD_VALUE;
1198 } else {
1199 available_hot_pixel_map_modes_.emplace(
1200 ANDROID_STATISTICS_HOT_PIXEL_MAP_MODE_OFF);
1201 }
1202
1203 bool hot_pixel_mode_off_supported =
1204 available_hot_pixel_map_modes_.find(
1205 ANDROID_STATISTICS_HOT_PIXEL_MAP_MODE_OFF) !=
1206 available_hot_pixel_map_modes_.end();
1207 bool face_detect_mode_off_supported =
1208 available_face_detect_modes_.find(
1209 ANDROID_STATISTICS_FACE_DETECT_MODE_OFF) !=
1210 available_face_detect_modes_.end();
1211 bool lens_shading_map_mode_off_supported =
1212 available_lens_shading_map_modes_.find(
1213 ANDROID_STATISTICS_LENS_SHADING_MAP_MODE_ON) !=
1214 available_lens_shading_map_modes_.end();
1215 bool lens_shading_map_mode_on_supported =
1216 available_lens_shading_map_modes_.find(
1217 ANDROID_STATISTICS_LENS_SHADING_MAP_MODE_ON) !=
1218 available_lens_shading_map_modes_.end();
1219 if (is_raw_capable_ && !lens_shading_map_mode_on_supported) {
1220 ALOGE("%s: RAW capable device must support lens shading map reporting!",
1221 __FUNCTION__);
1222 return BAD_VALUE;
1223 }
1224
1225 if (lens_shading_map_mode_on_supported &&
1226 (available_results_.find(ANDROID_STATISTICS_LENS_SHADING_MAP) ==
1227 available_results_.end())) {
1228 ALOGE(
1229 "%s: Lens shading map reporting available but corresponding result key "
1230 "is absent!",
1231 __FUNCTION__);
1232 return BAD_VALUE;
1233 }
1234
1235 if (lens_shading_map_mode_on_supported &&
1236 ((shading_map_size_[0] == 0) || (shading_map_size_[1] == 0))) {
1237 ALOGE(
1238 "%s: Lens shading map reporting available but without valid shading "
1239 "map size!",
1240 __FUNCTION__);
1241 return BAD_VALUE;
1242 }
1243
1244 report_scene_flicker_ =
1245 available_results_.find(ANDROID_STATISTICS_SCENE_FLICKER) !=
1246 available_results_.end();
1247
1248 uint8_t face_detect_mode = face_detect_mode_off_supported
1249 ? ANDROID_STATISTICS_FACE_DETECT_MODE_OFF
1250 : *available_face_detect_modes_.begin();
1251 uint8_t hot_pixel_map_mode = hot_pixel_mode_off_supported
1252 ? ANDROID_STATISTICS_HOT_PIXEL_MAP_MODE_OFF
1253 : *available_hot_pixel_map_modes_.begin();
1254 uint8_t lens_shading_map_mode =
1255 lens_shading_map_mode_off_supported
1256 ? ANDROID_STATISTICS_LENS_SHADING_MAP_MODE_OFF
1257 : *available_lens_shading_map_modes_.begin();
1258 for (size_t idx = 0; idx < kTemplateCount; idx++) {
1259 if (default_requests_[idx].get() == nullptr) {
1260 continue;
1261 }
1262
1263 if ((static_cast<RequestTemplate>(idx) == RequestTemplate::kStillCapture) &&
1264 is_raw_capable_ && lens_shading_map_mode_on_supported) {
1265 uint8_t lens_shading_map_on = ANDROID_STATISTICS_LENS_SHADING_MAP_MODE_ON;
1266 default_requests_[idx]->Set(ANDROID_STATISTICS_LENS_SHADING_MAP_MODE,
1267 &lens_shading_map_on, 1);
1268 } else {
1269 default_requests_[idx]->Set(ANDROID_STATISTICS_LENS_SHADING_MAP_MODE,
1270 &lens_shading_map_mode, 1);
1271 }
1272
1273 default_requests_[idx]->Set(ANDROID_STATISTICS_FACE_DETECT_MODE,
1274 &face_detect_mode, 1);
1275 default_requests_[idx]->Set(ANDROID_STATISTICS_HOT_PIXEL_MAP_MODE,
1276 &hot_pixel_map_mode, 1);
1277 }
1278
1279 return InitializeBlackLevelDefaults();
1280 }
1281
InitializeControlSceneDefaults()1282 status_t EmulatedRequestState::InitializeControlSceneDefaults() {
1283 camera_metadata_ro_entry_t entry;
1284 auto ret =
1285 static_metadata_->Get(ANDROID_CONTROL_AVAILABLE_SCENE_MODES, &entry);
1286 if (ret == OK) {
1287 available_scenes_.insert(entry.data.u8, entry.data.u8 + entry.count);
1288 } else {
1289 ALOGE("%s: No available scene modes!", __FUNCTION__);
1290 return BAD_VALUE;
1291 }
1292
1293 if ((entry.count == 1) &&
1294 (entry.data.u8[0] == ANDROID_CONTROL_SCENE_MODE_DISABLED)) {
1295 scenes_supported_ = false;
1296 return OK;
1297 } else {
1298 scenes_supported_ = true;
1299 }
1300
1301 if (available_requests_.find(ANDROID_CONTROL_SCENE_MODE) ==
1302 available_requests_.end()) {
1303 ALOGE("%s: Scene mode cannot be set!", __FUNCTION__);
1304 return BAD_VALUE;
1305 }
1306
1307 if (available_results_.find(ANDROID_CONTROL_SCENE_MODE) ==
1308 available_results_.end()) {
1309 ALOGE("%s: Scene mode cannot be reported!", __FUNCTION__);
1310 return BAD_VALUE;
1311 }
1312
1313 camera_metadata_ro_entry_t overrides_entry;
1314 ret = static_metadata_->Get(ANDROID_CONTROL_SCENE_MODE_OVERRIDES,
1315 &overrides_entry);
1316 if ((ret == OK) && ((overrides_entry.count / 3) == available_scenes_.size()) &&
1317 ((overrides_entry.count % 3) == 0)) {
1318 for (size_t i = 0; i < entry.count; i++) {
1319 SceneOverride scene(overrides_entry.data.u8[i*3],
1320 overrides_entry.data.u8[i*3 + 1],
1321 overrides_entry.data.u8[i*3 + 2]);
1322 if (available_ae_modes_.find(scene.ae_mode) == available_ae_modes_.end()) {
1323 ALOGE("%s: AE scene mode override: %d not supported!", __FUNCTION__,
1324 scene.ae_mode);
1325 return BAD_VALUE;
1326 }
1327 if (available_awb_modes_.find(scene.awb_mode) ==
1328 available_awb_modes_.end()) {
1329 ALOGE("%s: AWB scene mode override: %d not supported!", __FUNCTION__,
1330 scene.awb_mode);
1331 return BAD_VALUE;
1332 }
1333 if (available_af_modes_.find(scene.af_mode) == available_af_modes_.end()) {
1334 ALOGE("%s: AF scene mode override: %d not supported!", __FUNCTION__,
1335 scene.af_mode);
1336 return BAD_VALUE;
1337 }
1338 scene_overrides_.emplace(entry.data.u8[i], scene);
1339 }
1340 } else {
1341 ALOGE("%s: No available scene overrides!", __FUNCTION__);
1342 return BAD_VALUE;
1343 }
1344
1345 return OK;
1346 }
1347
InitializeControlAFDefaults()1348 status_t EmulatedRequestState::InitializeControlAFDefaults() {
1349 camera_metadata_ro_entry_t entry;
1350 auto ret = static_metadata_->Get(ANDROID_CONTROL_AF_AVAILABLE_MODES, &entry);
1351 if (ret == OK) {
1352 available_af_modes_.insert(entry.data.u8, entry.data.u8 + entry.count);
1353 } else {
1354 ALOGE("%s: No available AF modes!", __FUNCTION__);
1355 return BAD_VALUE;
1356 }
1357 // Off mode must always be present
1358 if (available_af_modes_.find(ANDROID_CONTROL_AF_MODE_OFF) ==
1359 available_af_modes_.end()) {
1360 ALOGE("%s: AF off control mode must always be present!", __FUNCTION__);
1361 return BAD_VALUE;
1362 }
1363
1364 if (available_requests_.find(ANDROID_CONTROL_AF_MODE) ==
1365 available_requests_.end()) {
1366 ALOGE("%s: Clients must be able to set AF mode!", __FUNCTION__);
1367 return BAD_VALUE;
1368 }
1369
1370 if (available_requests_.find(ANDROID_CONTROL_AF_TRIGGER) ==
1371 available_requests_.end()) {
1372 ALOGE("%s: Clients must be able to set AF trigger!", __FUNCTION__);
1373 return BAD_VALUE;
1374 }
1375 if (available_results_.find(ANDROID_CONTROL_AF_TRIGGER) ==
1376 available_results_.end()) {
1377 ALOGE("%s: AF trigger must be reported!", __FUNCTION__);
1378 return BAD_VALUE;
1379 }
1380
1381 if (available_results_.find(ANDROID_CONTROL_AF_MODE) ==
1382 available_results_.end()) {
1383 ALOGE("%s: AF mode must be reported!", __FUNCTION__);
1384 return BAD_VALUE;
1385 }
1386
1387 if (available_results_.find(ANDROID_CONTROL_AF_STATE) ==
1388 available_results_.end()) {
1389 ALOGE("%s: AF state must be reported!", __FUNCTION__);
1390 return BAD_VALUE;
1391 }
1392
1393 bool auto_mode_present =
1394 available_af_modes_.find(ANDROID_CONTROL_AF_MODE_AUTO) !=
1395 available_af_modes_.end();
1396 bool picture_caf_mode_present =
1397 available_af_modes_.find(ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE) !=
1398 available_af_modes_.end();
1399 bool video_caf_mode_present =
1400 available_af_modes_.find(ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO) !=
1401 available_af_modes_.end();
1402 af_supported_ = auto_mode_present && (minimum_focus_distance_ > .0f);
1403 picture_caf_supported_ =
1404 picture_caf_mode_present && (minimum_focus_distance_ > .0f);
1405 video_caf_supported_ =
1406 video_caf_mode_present && (minimum_focus_distance_ > .0f);
1407
1408 return OK;
1409 }
1410
InitializeControlAWBDefaults()1411 status_t EmulatedRequestState::InitializeControlAWBDefaults() {
1412 camera_metadata_ro_entry_t entry;
1413 auto ret = static_metadata_->Get(ANDROID_CONTROL_AWB_AVAILABLE_MODES, &entry);
1414 if (ret == OK) {
1415 available_awb_modes_.insert(entry.data.u8, entry.data.u8 + entry.count);
1416 } else {
1417 ALOGE("%s: No available AWB modes!", __FUNCTION__);
1418 return BAD_VALUE;
1419 }
1420 // Auto mode must always be present
1421 if (available_awb_modes_.find(ANDROID_CONTROL_AWB_MODE_AUTO) ==
1422 available_awb_modes_.end()) {
1423 ALOGE("%s: AWB auto control mode must always be present!", __FUNCTION__);
1424 return BAD_VALUE;
1425 }
1426
1427 if (available_results_.find(ANDROID_CONTROL_AWB_MODE) ==
1428 available_results_.end()) {
1429 ALOGE("%s: AWB mode must be reported!", __FUNCTION__);
1430 return BAD_VALUE;
1431 }
1432
1433 if (available_results_.find(ANDROID_CONTROL_AWB_STATE) ==
1434 available_results_.end()) {
1435 ALOGE("%s: AWB state must be reported!", __FUNCTION__);
1436 return BAD_VALUE;
1437 }
1438
1439 ret = static_metadata_->Get(ANDROID_CONTROL_AWB_LOCK_AVAILABLE, &entry);
1440 if ((ret == OK) && (entry.count == 1)) {
1441 awb_lock_available_ =
1442 entry.data.u8[0] == ANDROID_CONTROL_AWB_LOCK_AVAILABLE_TRUE;
1443 } else {
1444 ALOGV("%s: No available AWB lock!", __FUNCTION__);
1445 awb_lock_available_ = false;
1446 }
1447 report_awb_lock_ = available_results_.find(ANDROID_CONTROL_AWB_LOCK) !=
1448 available_results_.end();
1449
1450 return OK;
1451 }
1452
InitializeBlackLevelDefaults()1453 status_t EmulatedRequestState::InitializeBlackLevelDefaults() {
1454 if (is_level_full_or_higher_) {
1455 if (available_requests_.find(ANDROID_BLACK_LEVEL_LOCK) ==
1456 available_requests_.end()) {
1457 ALOGE(
1458 "%s: Full or above capable devices must be able to set the black "
1459 "level lock!",
1460 __FUNCTION__);
1461 return BAD_VALUE;
1462 }
1463
1464 if (available_results_.find(ANDROID_BLACK_LEVEL_LOCK) ==
1465 available_results_.end()) {
1466 ALOGE(
1467 "%s: Full or above capable devices must be able to report the black "
1468 "level lock!",
1469 __FUNCTION__);
1470 return BAD_VALUE;
1471 }
1472
1473 report_black_level_lock_ = true;
1474 uint8_t blackLevelLock = ANDROID_BLACK_LEVEL_LOCK_OFF;
1475 for (size_t idx = 0; idx < kTemplateCount; idx++) {
1476 if (default_requests_[idx].get() == nullptr) {
1477 continue;
1478 }
1479
1480 default_requests_[idx]->Set(ANDROID_BLACK_LEVEL_LOCK, &blackLevelLock, 1);
1481 }
1482 }
1483
1484 return InitializeEdgeDefaults();
1485 }
1486
InitializeControlAEDefaults()1487 status_t EmulatedRequestState::InitializeControlAEDefaults() {
1488 camera_metadata_ro_entry_t entry;
1489 auto ret = static_metadata_->Get(ANDROID_CONTROL_AE_AVAILABLE_MODES, &entry);
1490 if (ret == OK) {
1491 available_ae_modes_.insert(entry.data.u8, entry.data.u8 + entry.count);
1492 } else {
1493 ALOGE("%s: No available AE modes!", __FUNCTION__);
1494 return BAD_VALUE;
1495 }
1496 // On mode must always be present
1497 if (available_ae_modes_.find(ANDROID_CONTROL_AE_MODE_ON) ==
1498 available_ae_modes_.end()) {
1499 ALOGE("%s: AE on control mode must always be present!", __FUNCTION__);
1500 return BAD_VALUE;
1501 }
1502
1503 if (available_results_.find(ANDROID_CONTROL_AE_MODE) ==
1504 available_results_.end()) {
1505 ALOGE("%s: AE mode must be reported!", __FUNCTION__);
1506 return BAD_VALUE;
1507 }
1508
1509 if (available_results_.find(ANDROID_CONTROL_AE_STATE) ==
1510 available_results_.end()) {
1511 ALOGE("%s: AE state must be reported!", __FUNCTION__);
1512 return BAD_VALUE;
1513 }
1514
1515 ret = static_metadata_->Get(ANDROID_CONTROL_AE_LOCK_AVAILABLE, &entry);
1516 if ((ret == OK) && (entry.count == 1)) {
1517 ae_lock_available_ =
1518 entry.data.u8[0] == ANDROID_CONTROL_AE_LOCK_AVAILABLE_TRUE;
1519 } else {
1520 ALOGV("%s: No available AE lock!", __FUNCTION__);
1521 ae_lock_available_ = false;
1522 }
1523 report_ae_lock_ = available_results_.find(ANDROID_CONTROL_AE_LOCK) !=
1524 available_results_.end();
1525
1526 if (supports_manual_sensor_) {
1527 if (!ae_lock_available_) {
1528 ALOGE("%s: AE lock must always be available for manual sensors!",
1529 __FUNCTION__);
1530 return BAD_VALUE;
1531 }
1532 auto off_mode = available_control_modes_.find(ANDROID_CONTROL_MODE_OFF);
1533 if (off_mode == available_control_modes_.end()) {
1534 ALOGE("%s: Off control mode must always be present for manual sensors!",
1535 __FUNCTION__);
1536 return BAD_VALUE;
1537 }
1538
1539 off_mode = available_ae_modes_.find(ANDROID_CONTROL_AE_MODE_OFF);
1540 if (off_mode == available_ae_modes_.end()) {
1541 ALOGE(
1542 "%s: AE off control mode must always be present for manual sensors!",
1543 __FUNCTION__);
1544 return BAD_VALUE;
1545 }
1546 }
1547
1548 if (available_requests_.find(ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER) ==
1549 available_requests_.end()) {
1550 ALOGE("%s: Clients must be able to set AE pre-capture trigger!",
1551 __FUNCTION__);
1552 return BAD_VALUE;
1553 }
1554
1555 if (available_results_.find(ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER) ==
1556 available_results_.end()) {
1557 ALOGE("%s: AE pre-capture trigger must be reported!", __FUNCTION__);
1558 return BAD_VALUE;
1559 }
1560
1561 ret = static_metadata_->Get(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES,
1562 &entry);
1563 if (ret == OK) {
1564 available_antibanding_modes_.insert(entry.data.u8,
1565 entry.data.u8 + entry.count);
1566 } else {
1567 ALOGE("%s: No available antibanding modes!", __FUNCTION__);
1568 return BAD_VALUE;
1569 }
1570
1571 ret = static_metadata_->Get(ANDROID_CONTROL_AE_COMPENSATION_RANGE, &entry);
1572 if ((ret == OK) && (entry.count == 2)) {
1573 exposure_compensation_range_[0] = entry.data.i32[0];
1574 exposure_compensation_range_[1] = entry.data.i32[1];
1575 } else {
1576 ALOGE("%s: No available exposure compensation range!", __FUNCTION__);
1577 return BAD_VALUE;
1578 }
1579
1580 ret = static_metadata_->Get(ANDROID_CONTROL_AE_COMPENSATION_STEP, &entry);
1581 if ((ret == OK) && (entry.count == 1)) {
1582 exposure_compensation_step_ = entry.data.r[0];
1583 } else {
1584 ALOGE("%s: No available exposure compensation step!", __FUNCTION__);
1585 return BAD_VALUE;
1586 }
1587
1588 bool ae_comp_requests =
1589 available_requests_.find(ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION) !=
1590 available_requests_.end();
1591 bool ae_comp_results =
1592 available_results_.find(ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION) !=
1593 available_results_.end();
1594 exposure_compensation_supported_ =
1595 ((exposure_compensation_range_[0] < 0) &&
1596 (exposure_compensation_range_[1] > 0) &&
1597 (exposure_compensation_step_.denominator > 0) &&
1598 (exposure_compensation_step_.numerator > 0)) &&
1599 ae_comp_results && ae_comp_requests;
1600
1601 return OK;
1602 }
1603
InitializeMeteringRegionDefault(uint32_t tag,int32_t * region)1604 status_t EmulatedRequestState::InitializeMeteringRegionDefault(
1605 uint32_t tag, int32_t* region /*out*/) {
1606 if (region == nullptr) {
1607 return BAD_VALUE;
1608 }
1609 if (available_requests_.find(tag) == available_requests_.end()) {
1610 ALOGE("%s: %d metering region configuration must be supported!",
1611 __FUNCTION__, tag);
1612 return BAD_VALUE;
1613 }
1614 if (available_results_.find(tag) == available_results_.end()) {
1615 ALOGE("%s: %d metering region must be reported!", __FUNCTION__, tag);
1616 return BAD_VALUE;
1617 }
1618
1619 region[0] = scaler_crop_region_default_[0];
1620 region[1] = scaler_crop_region_default_[1];
1621 region[2] = scaler_crop_region_default_[2];
1622 region[3] = scaler_crop_region_default_[3];
1623 region[4] = 0;
1624
1625 return OK;
1626 }
1627
InitializeControlDefaults()1628 status_t EmulatedRequestState::InitializeControlDefaults() {
1629 camera_metadata_ro_entry_t entry;
1630 int32_t metering_area[5] = {0}; // (top, left, width, height, wight)
1631 auto ret = static_metadata_->Get(ANDROID_CONTROL_AVAILABLE_MODES, &entry);
1632 if (ret == OK) {
1633 available_control_modes_.insert(entry.data.u8, entry.data.u8 + entry.count);
1634 } else {
1635 ALOGE("%s: No available control modes!", __FUNCTION__);
1636 return BAD_VALUE;
1637 }
1638
1639 available_sensor_pixel_modes_.insert(ANDROID_SENSOR_PIXEL_MODE_DEFAULT);
1640
1641 if (SupportsCapability(
1642 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_ULTRA_HIGH_RESOLUTION_SENSOR)) {
1643 available_sensor_pixel_modes_.insert(
1644 ANDROID_SENSOR_PIXEL_MODE_MAXIMUM_RESOLUTION);
1645 }
1646
1647 // Auto mode must always be present
1648 if (available_control_modes_.find(ANDROID_CONTROL_MODE_AUTO) ==
1649 available_control_modes_.end()) {
1650 ALOGE("%s: Auto control modes must always be present!", __FUNCTION__);
1651 return BAD_VALUE;
1652 }
1653
1654 // Capture intent must always be user configurable
1655 if (available_requests_.find(ANDROID_CONTROL_CAPTURE_INTENT) ==
1656 available_requests_.end()) {
1657 ALOGE("%s: Clients must be able to set the capture intent!", __FUNCTION__);
1658 return BAD_VALUE;
1659 }
1660
1661 ret = static_metadata_->Get(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES,
1662 &entry);
1663 if ((ret == OK) && ((entry.count % 2) == 0)) {
1664 available_fps_ranges_.reserve(entry.count / 2);
1665 for (size_t i = 0; i < entry.count; i += 2) {
1666 FPSRange range(entry.data.i32[i], entry.data.i32[i + 1]);
1667 if (range.min_fps > range.max_fps) {
1668 ALOGE("%s: Mininum framerate: %d bigger than maximum framerate: %d",
1669 __FUNCTION__, range.min_fps, range.max_fps);
1670 return BAD_VALUE;
1671 }
1672 if ((range.max_fps >= kMinimumStreamingFPS) &&
1673 (range.max_fps == range.min_fps) && (ae_target_fps_.max_fps == 0)) {
1674 ae_target_fps_ = range;
1675 }
1676 available_fps_ranges_.push_back(range);
1677 }
1678 } else {
1679 ALOGE("%s: No available framerate ranges!", __FUNCTION__);
1680 return BAD_VALUE;
1681 }
1682
1683 if (ae_target_fps_.max_fps == 0) {
1684 ALOGE("%s: No minimum streaming capable framerate range available!",
1685 __FUNCTION__);
1686 return BAD_VALUE;
1687 }
1688
1689 if (available_requests_.find(ANDROID_CONTROL_AE_TARGET_FPS_RANGE) ==
1690 available_requests_.end()) {
1691 ALOGE("%s: Clients must be able to set the target framerate range!",
1692 __FUNCTION__);
1693 return BAD_VALUE;
1694 }
1695
1696 if (available_results_.find(ANDROID_CONTROL_AE_TARGET_FPS_RANGE) ==
1697 available_results_.end()) {
1698 ALOGE("%s: Target framerate must be reported!", __FUNCTION__);
1699 return BAD_VALUE;
1700 }
1701
1702 report_extended_scene_mode_ =
1703 available_results_.find(ANDROID_CONTROL_EXTENDED_SCENE_MODE) !=
1704 available_results_.end();
1705
1706 if (is_backward_compatible_) {
1707 ret = static_metadata_->Get(ANDROID_CONTROL_POST_RAW_SENSITIVITY_BOOST,
1708 &entry);
1709 if (ret == OK) {
1710 post_raw_boost_ = entry.data.i32[0];
1711 } else {
1712 ALOGW("%s: No available post RAW boost! Setting default!", __FUNCTION__);
1713 post_raw_boost_ = 100;
1714 }
1715 report_post_raw_boost_ =
1716 available_results_.find(ANDROID_CONTROL_POST_RAW_SENSITIVITY_BOOST) !=
1717 available_results_.end();
1718
1719 ret = static_metadata_->Get(ANDROID_CONTROL_AVAILABLE_EFFECTS, &entry);
1720 if ((ret == OK) && (entry.count > 0)) {
1721 available_effects_.insert(entry.data.u8, entry.data.u8 + entry.count);
1722 if (available_effects_.find(ANDROID_CONTROL_EFFECT_MODE_OFF) ==
1723 available_effects_.end()) {
1724 ALOGE("%s: Off color effect mode not supported!", __FUNCTION__);
1725 return BAD_VALUE;
1726 }
1727 } else {
1728 ALOGE("%s: No available effects!", __FUNCTION__);
1729 return BAD_VALUE;
1730 }
1731
1732 ret = static_metadata_->Get(
1733 ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES, &entry);
1734 if ((ret == OK) && (entry.count > 0)) {
1735 available_vstab_modes_.insert(entry.data.u8, entry.data.u8 + entry.count);
1736 if (available_vstab_modes_.find(ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF) ==
1737 available_vstab_modes_.end()) {
1738 ALOGE("%s: Off video stabilization mode not supported!", __FUNCTION__);
1739 return BAD_VALUE;
1740 }
1741 if (available_vstab_modes_.find(ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_ON) !=
1742 available_vstab_modes_.end()) {
1743 vstab_available_ = true;
1744 }
1745 } else {
1746 ALOGE("%s: No available video stabilization modes!", __FUNCTION__);
1747 return BAD_VALUE;
1748 }
1749
1750 ret = static_metadata_->Get(ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM,
1751 &entry);
1752 if ((ret == OK) && (entry.count > 0)) {
1753 if (entry.count != 1) {
1754 ALOGE("%s: Invalid max digital zoom capability!", __FUNCTION__);
1755 return BAD_VALUE;
1756 }
1757 max_zoom_ = entry.data.f[0];
1758 } else {
1759 ALOGE("%s: No available max digital zoom", __FUNCTION__);
1760 return BAD_VALUE;
1761 }
1762
1763 ret = static_metadata_->Get(ANDROID_CONTROL_ZOOM_RATIO_RANGE, &entry);
1764 if ((ret == OK) && (entry.count > 0)) {
1765 if (entry.count != 2) {
1766 ALOGE("%s: Invalid zoom ratio range capability!", __FUNCTION__);
1767 return BAD_VALUE;
1768 }
1769
1770 if (entry.data.f[1] != max_zoom_) {
1771 ALOGE("%s: Max zoom ratio must be equal to max digital zoom",
1772 __FUNCTION__);
1773 return BAD_VALUE;
1774 }
1775
1776 if (entry.data.f[1] < entry.data.f[0]) {
1777 ALOGE("%s: Max zoom ratio must be larger than min zoom ratio",
1778 __FUNCTION__);
1779 return BAD_VALUE;
1780 }
1781
1782 // Sanity check request and result keys
1783 if (available_requests_.find(ANDROID_CONTROL_ZOOM_RATIO) ==
1784 available_requests_.end()) {
1785 ALOGE("%s: Zoom ratio tag must be available in available request keys",
1786 __FUNCTION__);
1787 return BAD_VALUE;
1788 }
1789 if (available_results_.find(ANDROID_CONTROL_ZOOM_RATIO) ==
1790 available_results_.end()) {
1791 ALOGE("%s: Zoom ratio tag must be available in available result keys",
1792 __FUNCTION__);
1793 return BAD_VALUE;
1794 }
1795
1796 zoom_ratio_supported_ = true;
1797 min_zoom_ = entry.data.f[0];
1798 }
1799
1800 ret = static_metadata_->Get(
1801 ANDROID_CONTROL_AVAILABLE_EXTENDED_SCENE_MODE_MAX_SIZES, &entry);
1802 if ((ret == OK) && (entry.count > 0)) {
1803 if (entry.count % 3 != 0) {
1804 ALOGE("%s: Invalid bokeh capabilities!", __FUNCTION__);
1805 return BAD_VALUE;
1806 }
1807
1808 camera_metadata_ro_entry_t zoom_ratio_ranges_entry;
1809 ret = static_metadata_->Get(
1810 ANDROID_CONTROL_AVAILABLE_EXTENDED_SCENE_MODE_ZOOM_RATIO_RANGES,
1811 &zoom_ratio_ranges_entry);
1812 if (ret != OK ||
1813 zoom_ratio_ranges_entry.count / 2 != entry.count / 3 - 1) {
1814 ALOGE("%s: Invalid bokeh mode zoom ratio ranges.", __FUNCTION__);
1815 return BAD_VALUE;
1816 }
1817
1818 // Sanity check request and characteristics keys
1819 if (available_requests_.find(ANDROID_CONTROL_EXTENDED_SCENE_MODE) ==
1820 available_requests_.end()) {
1821 ALOGE("%s: Extended scene mode must be configurable for this device",
1822 __FUNCTION__);
1823 return BAD_VALUE;
1824 }
1825 if (available_characteristics_.find(
1826 ANDROID_CONTROL_AVAILABLE_EXTENDED_SCENE_MODE_MAX_SIZES) ==
1827 available_characteristics_.end() ||
1828 available_characteristics_.find(
1829 ANDROID_CONTROL_AVAILABLE_EXTENDED_SCENE_MODE_ZOOM_RATIO_RANGES) ==
1830 available_characteristics_.end()) {
1831 ALOGE(
1832 "%s: ExtendedSceneMode maxSizes and zoomRatioRanges "
1833 "characteristics keys must "
1834 "be available",
1835 __FUNCTION__);
1836 return BAD_VALUE;
1837 }
1838
1839 // Derive available bokeh caps.
1840 StreamConfigurationMap stream_configuration_map(*static_metadata_);
1841 std::set<StreamSize> yuv_sizes = stream_configuration_map.GetOutputSizes(
1842 HAL_PIXEL_FORMAT_YCBCR_420_888);
1843 bool has_extended_scene_mode_off = false;
1844 for (size_t i = 0, j = 0; i < entry.count; i += 3) {
1845 int32_t mode = entry.data.i32[i];
1846 int32_t max_width = entry.data.i32[i + 1];
1847 int32_t max_height = entry.data.i32[i + 2];
1848 float min_zoom_ratio, max_zoom_ratio;
1849
1850 if (mode < ANDROID_CONTROL_EXTENDED_SCENE_MODE_DISABLED ||
1851 (mode > ANDROID_CONTROL_EXTENDED_SCENE_MODE_BOKEH_CONTINUOUS &&
1852 mode < ANDROID_CONTROL_EXTENDED_SCENE_MODE_VENDOR_START)) {
1853 ALOGE("%s: Invalid extended scene mode %d", __FUNCTION__, mode);
1854 return BAD_VALUE;
1855 }
1856
1857 if (mode == ANDROID_CONTROL_EXTENDED_SCENE_MODE_DISABLED) {
1858 has_extended_scene_mode_off = true;
1859 if (max_width != 0 || max_height != 0) {
1860 ALOGE(
1861 "%s: Invalid max width or height for "
1862 "EXTENDED_SCENE_MODE_DISABLED",
1863 __FUNCTION__);
1864 return BAD_VALUE;
1865 }
1866 min_zoom_ratio = min_zoom_;
1867 max_zoom_ratio = max_zoom_;
1868 } else if (yuv_sizes.find({max_width, max_height}) == yuv_sizes.end()) {
1869 ALOGE("%s: Invalid max width or height for extended scene mode %d",
1870 __FUNCTION__, mode);
1871 return BAD_VALUE;
1872 } else {
1873 min_zoom_ratio = zoom_ratio_ranges_entry.data.f[j];
1874 max_zoom_ratio = zoom_ratio_ranges_entry.data.f[j + 1];
1875 j += 2;
1876 }
1877
1878 ExtendedSceneModeCapability cap(mode, max_width, max_height,
1879 min_zoom_ratio, max_zoom_ratio);
1880 available_extended_scene_mode_caps_.push_back(cap);
1881 }
1882 if (!has_extended_scene_mode_off) {
1883 ALOGE("%s: Off extended scene mode not supported!", __FUNCTION__);
1884 return BAD_VALUE;
1885 }
1886 }
1887
1888 ret = static_metadata_->Get(ANDROID_CONTROL_MAX_REGIONS, &entry);
1889 if ((ret == OK) && (entry.count == 3)) {
1890 max_ae_regions_ = entry.data.i32[0];
1891 max_awb_regions_ = entry.data.i32[1];
1892 max_af_regions_ = entry.data.i32[2];
1893 } else {
1894 ALOGE(
1895 "%s: Metering regions must be available for backward compatible "
1896 "devices!",
1897 __FUNCTION__);
1898 return BAD_VALUE;
1899 }
1900
1901 if ((is_level_full_or_higher_) &&
1902 ((max_ae_regions_ == 0) || (max_af_regions_ == 0))) {
1903 ALOGE(
1904 "%s: Full and higher level cameras must support at AF and AE "
1905 "metering regions",
1906 __FUNCTION__);
1907 return BAD_VALUE;
1908 }
1909
1910 if (max_ae_regions_ > 0) {
1911 ret = InitializeMeteringRegionDefault(ANDROID_CONTROL_AE_REGIONS,
1912 ae_metering_region_);
1913 if (ret != OK) {
1914 return ret;
1915 }
1916 }
1917
1918 if (max_awb_regions_ > 0) {
1919 ret = InitializeMeteringRegionDefault(ANDROID_CONTROL_AWB_REGIONS,
1920 awb_metering_region_);
1921 if (ret != OK) {
1922 return ret;
1923 }
1924 }
1925
1926 if (max_af_regions_ > 0) {
1927 ret = InitializeMeteringRegionDefault(ANDROID_CONTROL_AF_REGIONS,
1928 af_metering_region_);
1929 if (ret != OK) {
1930 return ret;
1931 }
1932 }
1933
1934 ret = InitializeControlAEDefaults();
1935 if (ret != OK) {
1936 return ret;
1937 }
1938
1939 ret = InitializeControlAWBDefaults();
1940 if (ret != OK) {
1941 return ret;
1942 }
1943
1944 ret = InitializeControlAFDefaults();
1945 if (ret != OK) {
1946 return ret;
1947 }
1948
1949 ret = InitializeControlSceneDefaults();
1950 if (ret != OK) {
1951 return ret;
1952 }
1953 }
1954
1955 for (size_t idx = 0; idx < kTemplateCount; idx++) {
1956 auto template_idx = static_cast<RequestTemplate>(idx);
1957 if (default_requests_[idx].get() == nullptr) {
1958 continue;
1959 }
1960
1961 uint8_t intent = ANDROID_CONTROL_CAPTURE_INTENT_CUSTOM;
1962 uint8_t control_mode, ae_mode, awb_mode, af_mode, scene_mode, vstab_mode;
1963 control_mode = ANDROID_CONTROL_MODE_AUTO;
1964 ae_mode = ANDROID_CONTROL_AE_MODE_ON;
1965 awb_mode = ANDROID_CONTROL_AWB_MODE_AUTO;
1966 af_mode = af_supported_ ? ANDROID_CONTROL_AF_MODE_AUTO
1967 : ANDROID_CONTROL_AF_MODE_OFF;
1968 scene_mode = ANDROID_CONTROL_SCENE_MODE_DISABLED;
1969 vstab_mode = ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF;
1970 uint8_t effect_mode = ANDROID_CONTROL_EFFECT_MODE_OFF;
1971 uint8_t ae_lock = ANDROID_CONTROL_AE_LOCK_OFF;
1972 uint8_t awb_lock = ANDROID_CONTROL_AWB_LOCK_OFF;
1973 int32_t ae_target_fps[] = {ae_target_fps_.min_fps, ae_target_fps_.max_fps};
1974 float zoom_ratio = 1.0f;
1975 switch (template_idx) {
1976 case RequestTemplate::kManual:
1977 intent = ANDROID_CONTROL_CAPTURE_INTENT_MANUAL;
1978 control_mode = ANDROID_CONTROL_MODE_OFF;
1979 ae_mode = ANDROID_CONTROL_AE_MODE_OFF;
1980 awb_mode = ANDROID_CONTROL_AWB_MODE_OFF;
1981 af_mode = ANDROID_CONTROL_AF_MODE_OFF;
1982 break;
1983 case RequestTemplate::kZeroShutterLag:
1984 intent = ANDROID_CONTROL_CAPTURE_INTENT_ZERO_SHUTTER_LAG;
1985 if (picture_caf_supported_) {
1986 af_mode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE;
1987 }
1988 break;
1989 case RequestTemplate::kPreview:
1990 intent = ANDROID_CONTROL_CAPTURE_INTENT_PREVIEW;
1991 if (picture_caf_supported_) {
1992 af_mode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE;
1993 }
1994 break;
1995 case RequestTemplate::kStillCapture:
1996 intent = ANDROID_CONTROL_CAPTURE_INTENT_STILL_CAPTURE;
1997 if (picture_caf_supported_) {
1998 af_mode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE;
1999 }
2000 break;
2001 case RequestTemplate::kVideoRecord:
2002 intent = ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_RECORD;
2003 if (video_caf_supported_) {
2004 af_mode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO;
2005 }
2006 if (vstab_available_) {
2007 vstab_mode = ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_ON;
2008 }
2009 break;
2010 case RequestTemplate::kVideoSnapshot:
2011 intent = ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_SNAPSHOT;
2012 if (video_caf_supported_) {
2013 af_mode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO;
2014 }
2015 if (vstab_available_) {
2016 vstab_mode = ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_ON;
2017 }
2018 break;
2019 default:
2020 // Noop
2021 break;
2022 }
2023
2024 if (intent != ANDROID_CONTROL_CAPTURE_INTENT_CUSTOM) {
2025 default_requests_[idx]->Set(ANDROID_CONTROL_CAPTURE_INTENT, &intent, 1);
2026 default_requests_[idx]->Set(ANDROID_CONTROL_MODE, &control_mode, 1);
2027 default_requests_[idx]->Set(ANDROID_CONTROL_AE_MODE, &ae_mode, 1);
2028 default_requests_[idx]->Set(ANDROID_CONTROL_AE_TARGET_FPS_RANGE,
2029 ae_target_fps, ARRAY_SIZE(ae_target_fps));
2030 default_requests_[idx]->Set(ANDROID_CONTROL_AWB_MODE, &awb_mode, 1);
2031 default_requests_[idx]->Set(ANDROID_CONTROL_AF_MODE, &af_mode, 1);
2032 if (is_backward_compatible_) {
2033 default_requests_[idx]->Set(ANDROID_CONTROL_POST_RAW_SENSITIVITY_BOOST,
2034 &post_raw_boost_, 1);
2035 if (vstab_available_) {
2036 default_requests_[idx]->Set(ANDROID_CONTROL_VIDEO_STABILIZATION_MODE,
2037 &vstab_mode, 1);
2038 }
2039 if (ae_lock_available_) {
2040 default_requests_[idx]->Set(ANDROID_CONTROL_AE_LOCK, &ae_lock, 1);
2041 }
2042 if (awb_lock_available_) {
2043 default_requests_[idx]->Set(ANDROID_CONTROL_AWB_LOCK, &awb_lock, 1);
2044 }
2045 if (scenes_supported_) {
2046 default_requests_[idx]->Set(ANDROID_CONTROL_SCENE_MODE, &scene_mode,
2047 1);
2048 }
2049 if (max_ae_regions_ > 0) {
2050 default_requests_[idx]->Set(ANDROID_CONTROL_AE_REGIONS, metering_area,
2051 ARRAY_SIZE(metering_area));
2052 }
2053 if (max_awb_regions_ > 0) {
2054 default_requests_[idx]->Set(ANDROID_CONTROL_AWB_REGIONS,
2055 metering_area, ARRAY_SIZE(metering_area));
2056 }
2057 if (max_af_regions_ > 0) {
2058 default_requests_[idx]->Set(ANDROID_CONTROL_AF_REGIONS, metering_area,
2059 ARRAY_SIZE(metering_area));
2060 }
2061 if (exposure_compensation_supported_) {
2062 default_requests_[idx]->Set(ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION,
2063 &exposure_compensation_, 1);
2064 }
2065 if (zoom_ratio_supported_) {
2066 default_requests_[idx]->Set(ANDROID_CONTROL_ZOOM_RATIO, &zoom_ratio,
2067 1);
2068 }
2069 bool is_auto_antbanding_supported =
2070 available_antibanding_modes_.find(
2071 ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO) !=
2072 available_antibanding_modes_.end();
2073 uint8_t antibanding_mode = is_auto_antbanding_supported
2074 ? ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO
2075 : *available_antibanding_modes_.begin();
2076 default_requests_[idx]->Set(ANDROID_CONTROL_AE_ANTIBANDING_MODE,
2077 &antibanding_mode, 1);
2078 default_requests_[idx]->Set(ANDROID_CONTROL_EFFECT_MODE, &effect_mode,
2079 1);
2080 uint8_t ae_trigger = ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_IDLE;
2081 default_requests_[idx]->Set(ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER,
2082 &ae_trigger, 1);
2083 uint8_t af_trigger = ANDROID_CONTROL_AF_TRIGGER_IDLE;
2084 default_requests_[idx]->Set(ANDROID_CONTROL_AF_TRIGGER, &af_trigger, 1);
2085 }
2086 }
2087 }
2088
2089 return InitializeHotPixelDefaults();
2090 }
2091
InitializeTonemapDefaults()2092 status_t EmulatedRequestState::InitializeTonemapDefaults() {
2093 if (is_backward_compatible_) {
2094 camera_metadata_ro_entry_t entry;
2095 auto ret =
2096 static_metadata_->Get(ANDROID_TONEMAP_AVAILABLE_TONE_MAP_MODES, &entry);
2097 if (ret == OK) {
2098 available_tonemap_modes_.insert(entry.data.u8,
2099 entry.data.u8 + entry.count);
2100 } else {
2101 ALOGE("%s: No available tonemap modes!", __FUNCTION__);
2102 return BAD_VALUE;
2103 }
2104
2105 if ((is_level_full_or_higher_) && (available_tonemap_modes_.size() < 3)) {
2106 ALOGE(
2107 "%s: Full and higher level cameras must support at least three or "
2108 "more tonemap modes",
2109 __FUNCTION__);
2110 return BAD_VALUE;
2111 }
2112
2113 bool fast_mode_supported =
2114 available_tonemap_modes_.find(ANDROID_TONEMAP_MODE_FAST) !=
2115 available_tonemap_modes_.end();
2116 bool hq_mode_supported =
2117 available_tonemap_modes_.find(ANDROID_TONEMAP_MODE_HIGH_QUALITY) !=
2118 available_tonemap_modes_.end();
2119 uint8_t tonemap_mode = *available_tonemap_modes_.begin();
2120 for (size_t idx = 0; idx < kTemplateCount; idx++) {
2121 if (default_requests_[idx].get() == nullptr) {
2122 continue;
2123 }
2124
2125 switch (static_cast<RequestTemplate>(idx)) {
2126 case RequestTemplate::kVideoRecord: // Pass-through
2127 case RequestTemplate::kPreview:
2128 if (fast_mode_supported) {
2129 tonemap_mode = ANDROID_TONEMAP_MODE_FAST;
2130 }
2131 break;
2132 case RequestTemplate::kVideoSnapshot: // Pass-through
2133 case RequestTemplate::kStillCapture:
2134 if (hq_mode_supported) {
2135 tonemap_mode = ANDROID_TONEMAP_MODE_HIGH_QUALITY;
2136 }
2137 break;
2138 default:
2139 // Noop
2140 break;
2141 }
2142
2143 default_requests_[idx]->Set(ANDROID_TONEMAP_MODE, &tonemap_mode, 1);
2144 default_requests_[idx]->Set(
2145 ANDROID_TONEMAP_CURVE_RED, EmulatedSensor::kDefaultToneMapCurveRed,
2146 ARRAY_SIZE(EmulatedSensor::kDefaultToneMapCurveRed));
2147 default_requests_[idx]->Set(
2148 ANDROID_TONEMAP_CURVE_GREEN, EmulatedSensor::kDefaultToneMapCurveGreen,
2149 ARRAY_SIZE(EmulatedSensor::kDefaultToneMapCurveGreen));
2150 default_requests_[idx]->Set(
2151 ANDROID_TONEMAP_CURVE_BLUE, EmulatedSensor::kDefaultToneMapCurveBlue,
2152 ARRAY_SIZE(EmulatedSensor::kDefaultToneMapCurveBlue));
2153 }
2154 }
2155
2156 return InitializeStatisticsDefaults();
2157 }
2158
InitializeEdgeDefaults()2159 status_t EmulatedRequestState::InitializeEdgeDefaults() {
2160 if (is_backward_compatible_) {
2161 camera_metadata_ro_entry_t entry;
2162 auto ret = static_metadata_->Get(ANDROID_EDGE_AVAILABLE_EDGE_MODES, &entry);
2163 if (ret == OK) {
2164 available_edge_modes_.insert(entry.data.u8, entry.data.u8 + entry.count);
2165 } else {
2166 ALOGE("%s: No available edge modes!", __FUNCTION__);
2167 return BAD_VALUE;
2168 }
2169
2170 report_edge_mode_ = available_results_.find(ANDROID_EDGE_MODE) != available_results_.end();
2171 bool is_fast_mode_supported =
2172 available_edge_modes_.find(ANDROID_EDGE_MODE_FAST) !=
2173 available_edge_modes_.end();
2174 bool is_hq_mode_supported =
2175 available_edge_modes_.find(ANDROID_EDGE_MODE_HIGH_QUALITY) !=
2176 available_edge_modes_.end();
2177 bool is_zsl_mode_supported =
2178 available_edge_modes_.find(ANDROID_EDGE_MODE_ZERO_SHUTTER_LAG) !=
2179 available_edge_modes_.end();
2180 uint8_t edge_mode = *available_ae_modes_.begin();
2181 for (size_t idx = 0; idx < kTemplateCount; idx++) {
2182 if (default_requests_[idx].get() == nullptr) {
2183 continue;
2184 }
2185
2186 switch (static_cast<RequestTemplate>(idx)) {
2187 case RequestTemplate::kVideoRecord: // Pass-through
2188 case RequestTemplate::kPreview:
2189 if (is_fast_mode_supported) {
2190 edge_mode = ANDROID_EDGE_MODE_FAST;
2191 }
2192 break;
2193 case RequestTemplate::kVideoSnapshot: // Pass-through
2194 case RequestTemplate::kStillCapture:
2195 if (is_hq_mode_supported) {
2196 edge_mode = ANDROID_EDGE_MODE_HIGH_QUALITY;
2197 }
2198 break;
2199 case RequestTemplate::kZeroShutterLag:
2200 if (is_zsl_mode_supported) {
2201 edge_mode = ANDROID_EDGE_MODE_ZERO_SHUTTER_LAG;
2202 }
2203 break;
2204 default:
2205 // Noop
2206 break;
2207 }
2208
2209 default_requests_[idx]->Set(ANDROID_EDGE_MODE, &edge_mode, 1);
2210 }
2211 }
2212
2213 return InitializeShadingDefaults();
2214 }
2215
InitializeColorCorrectionDefaults()2216 status_t EmulatedRequestState::InitializeColorCorrectionDefaults() {
2217 camera_metadata_ro_entry_t entry;
2218 auto ret = static_metadata_->Get(
2219 ANDROID_COLOR_CORRECTION_AVAILABLE_ABERRATION_MODES, &entry);
2220 if (ret == OK) {
2221 available_color_aberration_modes_.insert(entry.data.u8,
2222 entry.data.u8 + entry.count);
2223 } else if (supports_manual_post_processing_) {
2224 ALOGE(
2225 "%s: Devices capable of manual post-processing must support color "
2226 "abberation!",
2227 __FUNCTION__);
2228 return BAD_VALUE;
2229 }
2230
2231 if (!available_color_aberration_modes_.empty()) {
2232 bool is_fast_mode_supported =
2233 available_color_aberration_modes_.find(
2234 ANDROID_COLOR_CORRECTION_ABERRATION_MODE_FAST) !=
2235 available_color_aberration_modes_.end();
2236 bool is_hq_mode_supported =
2237 available_color_aberration_modes_.find(
2238 ANDROID_COLOR_CORRECTION_ABERRATION_MODE_HIGH_QUALITY) !=
2239 available_color_aberration_modes_.end();
2240 uint8_t color_aberration = *available_color_aberration_modes_.begin();
2241 uint8_t color_correction_mode = ANDROID_COLOR_CORRECTION_MODE_FAST;
2242 for (size_t idx = 0; idx < kTemplateCount; idx++) {
2243 if (default_requests_[idx].get() == nullptr) {
2244 continue;
2245 }
2246
2247 switch (static_cast<RequestTemplate>(idx)) {
2248 case RequestTemplate::kVideoRecord: // Pass-through
2249 case RequestTemplate::kPreview:
2250 if (is_fast_mode_supported) {
2251 color_aberration = ANDROID_COLOR_CORRECTION_ABERRATION_MODE_FAST;
2252 }
2253 break;
2254 case RequestTemplate::kVideoSnapshot: // Pass-through
2255 case RequestTemplate::kStillCapture:
2256 if (is_hq_mode_supported) {
2257 color_aberration =
2258 ANDROID_COLOR_CORRECTION_ABERRATION_MODE_HIGH_QUALITY;
2259 }
2260 break;
2261 default:
2262 // Noop
2263 break;
2264 }
2265
2266 default_requests_[idx]->Set(ANDROID_COLOR_CORRECTION_ABERRATION_MODE,
2267 &color_aberration, 1);
2268 if (is_backward_compatible_) {
2269 default_requests_[idx]->Set(ANDROID_COLOR_CORRECTION_MODE,
2270 &color_correction_mode, 1);
2271 default_requests_[idx]->Set(
2272 ANDROID_COLOR_CORRECTION_TRANSFORM,
2273 EmulatedSensor::kDefaultColorTransform,
2274 ARRAY_SIZE(EmulatedSensor::kDefaultColorTransform));
2275 default_requests_[idx]->Set(
2276 ANDROID_COLOR_CORRECTION_GAINS,
2277 EmulatedSensor::kDefaultColorCorrectionGains,
2278 ARRAY_SIZE(EmulatedSensor::kDefaultColorCorrectionGains));
2279 }
2280 }
2281 }
2282
2283 return InitializeSensorDefaults();
2284 }
2285
InitializeScalerDefaults()2286 status_t EmulatedRequestState::InitializeScalerDefaults() {
2287 if (is_backward_compatible_) {
2288 camera_metadata_ro_entry_t entry;
2289 auto ret =
2290 static_metadata_->Get(ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE, &entry);
2291 if ((ret == OK) && (entry.count == 4)) {
2292 scaler_crop_region_default_[0] = entry.data.i32[0];
2293 scaler_crop_region_default_[1] = entry.data.i32[1];
2294 scaler_crop_region_default_[2] = entry.data.i32[2];
2295 scaler_crop_region_default_[3] = entry.data.i32[3];
2296 } else {
2297 ALOGE("%s: Sensor pixel array size is not available!", __FUNCTION__);
2298 return BAD_VALUE;
2299 }
2300
2301 if (SupportsCapability(
2302 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_ULTRA_HIGH_RESOLUTION_SENSOR)) {
2303 ret = static_metadata_->Get(
2304 ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE_MAXIMUM_RESOLUTION, &entry);
2305 if ((ret == OK) && (entry.count == 4)) {
2306 scaler_crop_region_max_resolution_[0] = entry.data.i32[0];
2307 scaler_crop_region_max_resolution_[1] = entry.data.i32[1];
2308 scaler_crop_region_max_resolution_[2] = entry.data.i32[2];
2309 scaler_crop_region_max_resolution_[3] = entry.data.i32[3];
2310 } else {
2311 ALOGE(
2312 "%s: Sensor pixel array size maximum resolution is not available!",
2313 __FUNCTION__);
2314 return BAD_VALUE;
2315 }
2316 }
2317
2318 if (available_requests_.find(ANDROID_SCALER_CROP_REGION) ==
2319 available_requests_.end()) {
2320 ALOGE(
2321 "%s: Backward compatible devices must support scaler crop "
2322 "configuration!",
2323 __FUNCTION__);
2324 return BAD_VALUE;
2325 }
2326 if (available_results_.find(ANDROID_SCALER_CROP_REGION) ==
2327 available_results_.end()) {
2328 ALOGE("%s: Scaler crop must reported on backward compatible devices!",
2329 __FUNCTION__);
2330 return BAD_VALUE;
2331 }
2332 ret = static_metadata_->Get(ANDROID_SCALER_AVAILABLE_ROTATE_AND_CROP_MODES,
2333 &entry);
2334 if ((ret == OK) && (entry.count > 0)) {
2335 // Listing rotate and crop, so need to make sure it's consistently reported
2336 if (available_requests_.find(ANDROID_SCALER_ROTATE_AND_CROP) ==
2337 available_requests_.end()) {
2338 ALOGE(
2339 "%s: Rotate and crop must be listed in request keys if supported!",
2340 __FUNCTION__);
2341 return BAD_VALUE;
2342 }
2343 if (available_results_.find(ANDROID_SCALER_ROTATE_AND_CROP) ==
2344 available_results_.end()) {
2345 ALOGE("%s: Rotate and crop must be listed in result keys if supported!",
2346 __FUNCTION__);
2347 return BAD_VALUE;
2348 }
2349 if (available_characteristics_.find(
2350 ANDROID_SCALER_AVAILABLE_ROTATE_AND_CROP_MODES) ==
2351 available_characteristics_.end()) {
2352 ALOGE(
2353 "%s: Rotate and crop must be listed in characteristics keys if "
2354 "supported!",
2355 __FUNCTION__);
2356 return BAD_VALUE;
2357 }
2358 report_rotate_and_crop_ = true;
2359 for (size_t i = 0; i < entry.count; i++) {
2360 if (entry.data.u8[i] == ANDROID_SCALER_ROTATE_AND_CROP_AUTO) {
2361 rotate_and_crop_ = ANDROID_SCALER_ROTATE_AND_CROP_AUTO;
2362 }
2363 available_rotate_crop_modes_.insert(entry.data.u8[i]);
2364 }
2365 }
2366
2367 for (size_t idx = 0; idx < kTemplateCount; idx++) {
2368 if (default_requests_[idx].get() == nullptr) {
2369 continue;
2370 }
2371
2372 default_requests_[idx]->Set(ANDROID_SCALER_CROP_REGION,
2373 scaler_crop_region_default_,
2374 ARRAY_SIZE(scaler_crop_region_default_));
2375 if (report_rotate_and_crop_) {
2376 default_requests_[idx]->Set(ANDROID_SCALER_ROTATE_AND_CROP,
2377 &rotate_and_crop_, 1);
2378 }
2379 }
2380 }
2381
2382 return InitializeControlDefaults();
2383 }
2384
InitializeShadingDefaults()2385 status_t EmulatedRequestState::InitializeShadingDefaults() {
2386 camera_metadata_ro_entry_t entry;
2387 auto ret = static_metadata_->Get(ANDROID_SHADING_AVAILABLE_MODES, &entry);
2388 if (ret == OK) {
2389 available_shading_modes_.insert(entry.data.u8, entry.data.u8 + entry.count);
2390 } else {
2391 ALOGE("%s: No available lens shading modes!", __FUNCTION__);
2392 return BAD_VALUE;
2393 }
2394
2395 if (supports_manual_post_processing_ &&
2396 (available_shading_modes_.size() < 2)) {
2397 ALOGE(
2398 "%s: Devices capable of manual post-processing need to support at "
2399 "least "
2400 "two"
2401 " lens shading modes!",
2402 __FUNCTION__);
2403 return BAD_VALUE;
2404 }
2405
2406 bool is_fast_mode_supported =
2407 available_shading_modes_.find(ANDROID_SHADING_MODE_FAST) !=
2408 available_shading_modes_.end();
2409 bool is_hq_mode_supported =
2410 available_shading_modes_.find(ANDROID_SHADING_MODE_HIGH_QUALITY) !=
2411 available_shading_modes_.end();
2412 uint8_t shading_mode = *available_shading_modes_.begin();
2413 for (size_t idx = 0; idx < kTemplateCount; idx++) {
2414 if (default_requests_[idx].get() == nullptr) {
2415 continue;
2416 }
2417
2418 switch (static_cast<RequestTemplate>(idx)) {
2419 case RequestTemplate::kVideoRecord: // Pass-through
2420 case RequestTemplate::kPreview:
2421 if (is_fast_mode_supported) {
2422 shading_mode = ANDROID_SHADING_MODE_FAST;
2423 }
2424 break;
2425 case RequestTemplate::kVideoSnapshot: // Pass-through
2426 case RequestTemplate::kStillCapture:
2427 if (is_hq_mode_supported) {
2428 shading_mode = ANDROID_SHADING_MODE_HIGH_QUALITY;
2429 }
2430 break;
2431 default:
2432 // Noop
2433 break;
2434 }
2435
2436 default_requests_[idx]->Set(ANDROID_SHADING_MODE, &shading_mode, 1);
2437 }
2438
2439 return InitializeNoiseReductionDefaults();
2440 }
2441
InitializeNoiseReductionDefaults()2442 status_t EmulatedRequestState::InitializeNoiseReductionDefaults() {
2443 camera_metadata_ro_entry_t entry;
2444 auto ret = static_metadata_->Get(
2445 ANDROID_NOISE_REDUCTION_AVAILABLE_NOISE_REDUCTION_MODES, &entry);
2446 if (ret == OK) {
2447 available_noise_reduction_modes_.insert(entry.data.u8,
2448 entry.data.u8 + entry.count);
2449 } else {
2450 ALOGE("%s: No available noise reduction modes!", __FUNCTION__);
2451 return BAD_VALUE;
2452 }
2453
2454 if ((is_level_full_or_higher_) &&
2455 (available_noise_reduction_modes_.size() < 2)) {
2456 ALOGE(
2457 "%s: Full and above device must support at least two noise reduction "
2458 "modes!",
2459 __FUNCTION__);
2460 return BAD_VALUE;
2461 }
2462
2463 bool is_fast_mode_supported =
2464 available_noise_reduction_modes_.find(ANDROID_NOISE_REDUCTION_MODE_FAST) !=
2465 available_noise_reduction_modes_.end();
2466 bool is_hq_mode_supported = available_noise_reduction_modes_.find(
2467 ANDROID_NOISE_REDUCTION_MODE_HIGH_QUALITY) !=
2468 available_noise_reduction_modes_.end();
2469 bool is_zsl_mode_supported =
2470 available_noise_reduction_modes_.find(
2471 ANDROID_NOISE_REDUCTION_MODE_ZERO_SHUTTER_LAG) !=
2472 available_noise_reduction_modes_.end();
2473 uint8_t noise_reduction_mode = *available_noise_reduction_modes_.begin();
2474 for (size_t idx = 0; idx < kTemplateCount; idx++) {
2475 if (default_requests_[idx].get() == nullptr) {
2476 continue;
2477 }
2478
2479 switch (static_cast<RequestTemplate>(idx)) {
2480 case RequestTemplate::kVideoRecord: // Pass-through
2481 case RequestTemplate::kVideoSnapshot: // Pass-through
2482 case RequestTemplate::kPreview:
2483 if (is_fast_mode_supported) {
2484 noise_reduction_mode = ANDROID_NOISE_REDUCTION_MODE_FAST;
2485 }
2486 break;
2487 case RequestTemplate::kStillCapture:
2488 if (is_hq_mode_supported) {
2489 noise_reduction_mode = ANDROID_NOISE_REDUCTION_MODE_HIGH_QUALITY;
2490 }
2491 break;
2492 case RequestTemplate::kZeroShutterLag:
2493 if (is_zsl_mode_supported) {
2494 noise_reduction_mode = ANDROID_NOISE_REDUCTION_MODE_ZERO_SHUTTER_LAG;
2495 }
2496 break;
2497 default:
2498 // Noop
2499 break;
2500 }
2501
2502 default_requests_[idx]->Set(ANDROID_NOISE_REDUCTION_MODE,
2503 &noise_reduction_mode, 1);
2504 }
2505
2506 return InitializeColorCorrectionDefaults();
2507 }
2508
InitializeHotPixelDefaults()2509 status_t EmulatedRequestState::InitializeHotPixelDefaults() {
2510 camera_metadata_ro_entry_t entry;
2511 auto ret = static_metadata_->Get(ANDROID_HOT_PIXEL_AVAILABLE_HOT_PIXEL_MODES,
2512 &entry);
2513 if (ret == OK) {
2514 available_hot_pixel_modes_.insert(entry.data.u8,
2515 entry.data.u8 + entry.count);
2516 } else {
2517 ALOGE("%s: No available hotpixel modes!", __FUNCTION__);
2518 return BAD_VALUE;
2519 }
2520
2521 if ((is_level_full_or_higher_) && (available_hot_pixel_modes_.size() < 2)) {
2522 ALOGE(
2523 "%s: Full and higher level cameras must support at least fast and hq "
2524 "hotpixel modes",
2525 __FUNCTION__);
2526 return BAD_VALUE;
2527 }
2528
2529 bool fast_mode_supported =
2530 available_hot_pixel_modes_.find(ANDROID_HOT_PIXEL_MODE_FAST) !=
2531 available_hot_pixel_modes_.end();
2532 bool hq_mode_supported =
2533 available_hot_pixel_modes_.find(ANDROID_HOT_PIXEL_MODE_HIGH_QUALITY) !=
2534 available_hot_pixel_modes_.end();
2535 uint8_t hotpixel_mode = *available_hot_pixel_modes_.begin();
2536 for (size_t idx = 0; idx < kTemplateCount; idx++) {
2537 if (default_requests_[idx].get() == nullptr) {
2538 continue;
2539 }
2540
2541 switch (static_cast<RequestTemplate>(idx)) {
2542 case RequestTemplate::kVideoRecord: // Pass-through
2543 case RequestTemplate::kPreview:
2544 if (fast_mode_supported) {
2545 hotpixel_mode = ANDROID_HOT_PIXEL_MODE_FAST;
2546 }
2547 break;
2548 case RequestTemplate::kVideoSnapshot: // Pass-through
2549 case RequestTemplate::kStillCapture:
2550 if (hq_mode_supported) {
2551 hotpixel_mode = ANDROID_HOT_PIXEL_MODE_HIGH_QUALITY;
2552 }
2553 break;
2554 default:
2555 // Noop
2556 break;
2557 }
2558
2559 default_requests_[idx]->Set(ANDROID_HOT_PIXEL_MODE, &hotpixel_mode, 1);
2560 }
2561
2562 return InitializeTonemapDefaults();
2563 }
2564
InitializeFlashDefaults()2565 status_t EmulatedRequestState::InitializeFlashDefaults() {
2566 camera_metadata_ro_entry_t entry;
2567 auto ret = static_metadata_->Get(ANDROID_FLASH_INFO_AVAILABLE, &entry);
2568 if ((ret == OK) && (entry.count == 1)) {
2569 is_flash_supported_ = entry.data.u8[0];
2570 } else {
2571 ALOGE("%s: No available flash info!", __FUNCTION__);
2572 return BAD_VALUE;
2573 }
2574
2575 if (is_flash_supported_) {
2576 flash_state_ = ANDROID_FLASH_STATE_READY;
2577 } else {
2578 flash_state_ = ANDROID_FLASH_STATE_UNAVAILABLE;
2579 }
2580
2581 uint8_t flash_mode = ANDROID_FLASH_MODE_OFF;
2582 for (size_t idx = 0; idx < kTemplateCount; idx++) {
2583 if (default_requests_[idx].get() == nullptr) {
2584 continue;
2585 }
2586
2587 default_requests_[idx]->Set(ANDROID_FLASH_MODE, &flash_mode, 1);
2588 }
2589
2590 return InitializeScalerDefaults();
2591 }
2592
InitializeLensDefaults()2593 status_t EmulatedRequestState::InitializeLensDefaults() {
2594 camera_metadata_ro_entry_t entry;
2595 auto ret =
2596 static_metadata_->Get(ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE, &entry);
2597 if ((ret == OK) && (entry.count == 1)) {
2598 minimum_focus_distance_ = entry.data.f[0];
2599 } else {
2600 ALOGW("%s: No available minimum focus distance assuming fixed focus!",
2601 __FUNCTION__);
2602 minimum_focus_distance_ = .0f;
2603 }
2604
2605 ret = static_metadata_->Get(ANDROID_LENS_INFO_AVAILABLE_APERTURES, &entry);
2606 if ((ret == OK) && (entry.count > 0)) {
2607 // TODO: add support for multiple apertures
2608 aperture_ = entry.data.f[0];
2609 } else {
2610 ALOGE("%s: No available aperture!", __FUNCTION__);
2611 return BAD_VALUE;
2612 }
2613
2614 ret = static_metadata_->Get(ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS, &entry);
2615 if ((ret == OK) && (entry.count > 0)) {
2616 focal_length_ = entry.data.f[0];
2617 } else {
2618 ALOGE("%s: No available focal length!", __FUNCTION__);
2619 return BAD_VALUE;
2620 }
2621
2622 ret = static_metadata_->Get(ANDROID_LENS_INFO_SHADING_MAP_SIZE, &entry);
2623 if ((ret == OK) && (entry.count == 2)) {
2624 shading_map_size_[0] = entry.data.i32[0];
2625 shading_map_size_[1] = entry.data.i32[1];
2626 } else if (is_raw_capable_) {
2627 ALOGE("%s: No available shading map size!", __FUNCTION__);
2628 return BAD_VALUE;
2629 }
2630
2631 ret = static_metadata_->Get(ANDROID_LENS_INFO_AVAILABLE_FILTER_DENSITIES,
2632 &entry);
2633 if ((ret == OK) && (entry.count > 0)) {
2634 // TODO: add support for multiple filter densities
2635 filter_density_ = entry.data.f[0];
2636 } else {
2637 ALOGE("%s: No available filter density!", __FUNCTION__);
2638 return BAD_VALUE;
2639 }
2640
2641 ret = static_metadata_->Get(ANDROID_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION,
2642 &entry);
2643 if ((ret == OK) && (entry.count > 0)) {
2644 // TODO: add support for multiple OIS modes
2645 available_ois_modes_.insert(entry.data.u8, entry.data.u8 + entry.count);
2646 if (available_ois_modes_.find(ANDROID_LENS_OPTICAL_STABILIZATION_MODE_OFF) ==
2647 available_ois_modes_.end()) {
2648 ALOGE("%s: OIS off mode not supported!", __FUNCTION__);
2649 return BAD_VALUE;
2650 }
2651 } else {
2652 ALOGE("%s: No available OIS modes!", __FUNCTION__);
2653 return BAD_VALUE;
2654 }
2655
2656 ret = static_metadata_->Get(ANDROID_LENS_POSE_ROTATION, &entry);
2657 if ((ret == OK) && (entry.count == ARRAY_SIZE(pose_rotation_))) {
2658 memcpy(pose_rotation_, entry.data.f, sizeof(pose_rotation_));
2659 }
2660 ret = static_metadata_->Get(ANDROID_LENS_POSE_TRANSLATION, &entry);
2661 if ((ret == OK) && (entry.count == ARRAY_SIZE(pose_translation_))) {
2662 memcpy(pose_translation_, entry.data.f, sizeof(pose_translation_));
2663 }
2664 ret = static_metadata_->Get(ANDROID_LENS_INTRINSIC_CALIBRATION, &entry);
2665 if ((ret == OK) && (entry.count == ARRAY_SIZE(intrinsic_calibration_))) {
2666 memcpy(intrinsic_calibration_, entry.data.f, sizeof(intrinsic_calibration_));
2667 }
2668
2669 ret = static_metadata_->Get(ANDROID_LENS_DISTORTION, &entry);
2670 if ((ret == OK) && (entry.count == ARRAY_SIZE(distortion_))) {
2671 memcpy(distortion_, entry.data.f, sizeof(distortion_));
2672 }
2673
2674 report_focus_distance_ =
2675 available_results_.find(ANDROID_LENS_FOCUS_DISTANCE) !=
2676 available_results_.end();
2677 report_focus_range_ = available_results_.find(ANDROID_LENS_FOCUS_RANGE) !=
2678 available_results_.end();
2679 report_filter_density_ =
2680 available_results_.find(ANDROID_LENS_FILTER_DENSITY) !=
2681 available_results_.end();
2682 report_ois_mode_ =
2683 available_results_.find(ANDROID_LENS_OPTICAL_STABILIZATION_MODE) !=
2684 available_results_.end();
2685 report_pose_rotation_ = available_results_.find(ANDROID_LENS_POSE_ROTATION) !=
2686 available_results_.end();
2687 report_pose_translation_ =
2688 available_results_.find(ANDROID_LENS_POSE_TRANSLATION) !=
2689 available_results_.end();
2690 report_intrinsic_calibration_ =
2691 available_results_.find(ANDROID_LENS_INTRINSIC_CALIBRATION) !=
2692 available_results_.end();
2693 report_distortion_ = available_results_.find(ANDROID_LENS_DISTORTION) !=
2694 available_results_.end();
2695
2696 focus_distance_ = minimum_focus_distance_;
2697 for (size_t idx = 0; idx < kTemplateCount; idx++) {
2698 if (default_requests_[idx].get() == nullptr) {
2699 continue;
2700 }
2701
2702 default_requests_[idx]->Set(ANDROID_LENS_APERTURE, &aperture_, 1);
2703 default_requests_[idx]->Set(ANDROID_LENS_FOCAL_LENGTH, &focal_length_, 1);
2704 default_requests_[idx]->Set(ANDROID_LENS_FOCUS_DISTANCE, &focus_distance_,
2705 1);
2706 default_requests_[idx]->Set(ANDROID_LENS_OPTICAL_STABILIZATION_MODE,
2707 &ois_mode_, 1);
2708 }
2709
2710 return InitializeFlashDefaults();
2711 }
2712
InitializeInfoDefaults()2713 status_t EmulatedRequestState::InitializeInfoDefaults() {
2714 camera_metadata_ro_entry_t entry;
2715 auto ret =
2716 static_metadata_->Get(ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL, &entry);
2717 if ((ret == OK) && (entry.count == 1)) {
2718 if (kSupportedHWLevels.find(entry.data.u8[0]) ==
2719 kSupportedCapabilites.end()) {
2720 ALOGE("%s: HW Level: %u not supported", __FUNCTION__, entry.data.u8[0]);
2721 return BAD_VALUE;
2722 }
2723 } else {
2724 ALOGE("%s: No available hardware level!", __FUNCTION__);
2725 return BAD_VALUE;
2726 }
2727
2728 supported_hw_level_ = entry.data.u8[0];
2729 is_level_full_or_higher_ =
2730 (supported_hw_level_ == ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_FULL) ||
2731 (supported_hw_level_ == ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_3);
2732
2733 return InitializeReprocessDefaults();
2734 }
2735
InitializeReprocessDefaults()2736 status_t EmulatedRequestState::InitializeReprocessDefaults() {
2737 if (supports_private_reprocessing_ || supports_yuv_reprocessing_ ||
2738 supports_remosaic_reprocessing_) {
2739 StreamConfigurationMap config_map(*static_metadata_);
2740 if (!config_map.SupportsReprocessing()) {
2741 ALOGE(
2742 "%s: Reprocess capability present but InputOutput format map is "
2743 "absent!",
2744 __FUNCTION__);
2745 return BAD_VALUE;
2746 }
2747
2748 auto input_formats = config_map.GetInputFormats();
2749 for (const auto& input_format : input_formats) {
2750 auto output_formats =
2751 config_map.GetValidOutputFormatsForInput(input_format);
2752 for (const auto& output_format : output_formats) {
2753 if (!EmulatedSensor::IsReprocessPathSupported(
2754 EmulatedSensor::OverrideFormat(
2755 input_format,
2756 ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD),
2757 EmulatedSensor::OverrideFormat(
2758 output_format,
2759 ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD))) {
2760 ALOGE(
2761 "%s: Input format: 0x%x to output format: 0x%x reprocess is"
2762 " currently not supported!",
2763 __FUNCTION__, input_format, output_format);
2764 return BAD_VALUE;
2765 }
2766 }
2767 }
2768 }
2769
2770 return InitializeLensDefaults();
2771 }
2772
InitializeRequestDefaults()2773 status_t EmulatedRequestState::InitializeRequestDefaults() {
2774 camera_metadata_ro_entry_t entry;
2775 auto ret =
2776 static_metadata_->Get(ANDROID_REQUEST_AVAILABLE_CAPABILITIES, &entry);
2777 if ((ret == OK) && (entry.count > 0)) {
2778 for (size_t i = 0; i < entry.count; i++) {
2779 if (kSupportedCapabilites.find(entry.data.u8[i]) ==
2780 kSupportedCapabilites.end()) {
2781 ALOGE("%s: Capability: %u not supported", __FUNCTION__,
2782 entry.data.u8[i]);
2783 return BAD_VALUE;
2784 }
2785 }
2786 } else {
2787 ALOGE("%s: No available capabilities!", __FUNCTION__);
2788 return BAD_VALUE;
2789 }
2790 available_capabilities_.insert(entry.data.u8, entry.data.u8 + entry.count);
2791
2792 ret = static_metadata_->Get(ANDROID_REQUEST_PIPELINE_MAX_DEPTH, &entry);
2793 if ((ret == OK) && (entry.count == 1)) {
2794 if (entry.data.u8[0] == 0) {
2795 ALOGE("%s: Maximum request pipeline depth must have a non zero value!",
2796 __FUNCTION__);
2797 return BAD_VALUE;
2798 }
2799 } else {
2800 ALOGE("%s: Maximum request pipeline depth absent!", __FUNCTION__);
2801 return BAD_VALUE;
2802 }
2803 max_pipeline_depth_ = entry.data.u8[0];
2804
2805 ret = static_metadata_->Get(ANDROID_REQUEST_PARTIAL_RESULT_COUNT, &entry);
2806 if ((ret == OK) && (entry.count == 1)) {
2807 if (entry.data.i32[0] != 1) {
2808 ALOGW("%s: Partial results not supported!", __FUNCTION__);
2809 }
2810 }
2811
2812 ret = static_metadata_->Get(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS,
2813 &entry);
2814 if ((ret != OK) || (entry.count == 0)) {
2815 ALOGE("%s: No available characteristic keys!", __FUNCTION__);
2816 return BAD_VALUE;
2817 }
2818 available_characteristics_.insert(entry.data.i32,
2819 entry.data.i32 + entry.count);
2820
2821 ret = static_metadata_->Get(ANDROID_REQUEST_AVAILABLE_RESULT_KEYS, &entry);
2822 if ((ret != OK) || (entry.count == 0)) {
2823 ALOGE("%s: No available result keys!", __FUNCTION__);
2824 return BAD_VALUE;
2825 }
2826 available_results_.insert(entry.data.i32, entry.data.i32 + entry.count);
2827
2828 ret = static_metadata_->Get(ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS, &entry);
2829 if ((ret != OK) || (entry.count == 0)) {
2830 ALOGE("%s: No available request keys!", __FUNCTION__);
2831 return BAD_VALUE;
2832 }
2833 available_requests_.insert(entry.data.i32, entry.data.i32 + entry.count);
2834
2835 supports_manual_sensor_ =
2836 SupportsCapability(ANDROID_REQUEST_AVAILABLE_CAPABILITIES_MANUAL_SENSOR);
2837 supports_manual_post_processing_ = SupportsCapability(
2838 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_MANUAL_POST_PROCESSING);
2839 supports_private_reprocessing_ = SupportsCapability(
2840 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_PRIVATE_REPROCESSING);
2841 supports_yuv_reprocessing_ = SupportsCapability(
2842 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_YUV_REPROCESSING);
2843 supports_remosaic_reprocessing_ = SupportsCapability(
2844 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_REMOSAIC_REPROCESSING);
2845 is_backward_compatible_ = SupportsCapability(
2846 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE);
2847 is_raw_capable_ =
2848 SupportsCapability(ANDROID_REQUEST_AVAILABLE_CAPABILITIES_RAW);
2849 supports_stream_use_case_ =
2850 SupportsCapability(ANDROID_REQUEST_AVAILABLE_CAPABILITIES_STREAM_USE_CASE);
2851
2852 if (supports_manual_sensor_) {
2853 auto templateIdx = static_cast<size_t>(RequestTemplate::kManual);
2854 default_requests_[templateIdx] = HalCameraMetadata::Create(1, 10);
2855 }
2856
2857 if (supports_stream_use_case_) {
2858 ret = static_metadata_->Get(ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES,
2859 &entry);
2860 if (ret != OK) {
2861 ALOGE("%s: No available stream use cases!", __FUNCTION__);
2862 return BAD_VALUE;
2863 }
2864 for (int64_t useCase : kSupportedUseCases) {
2865 if (std::find(entry.data.i64, entry.data.i64 + entry.count, useCase) ==
2866 entry.data.i64 + entry.count) {
2867 ALOGE("%s: Mandatory stream use case %" PRId64 " not found!",
2868 __FUNCTION__, useCase);
2869 return BAD_VALUE;
2870 }
2871 }
2872 }
2873
2874 for (size_t templateIdx = 0; templateIdx < kTemplateCount; templateIdx++) {
2875 switch (static_cast<RequestTemplate>(templateIdx)) {
2876 case RequestTemplate::kPreview:
2877 case RequestTemplate::kStillCapture:
2878 case RequestTemplate::kVideoRecord:
2879 case RequestTemplate::kVideoSnapshot:
2880 default_requests_[templateIdx] = HalCameraMetadata::Create(1, 10);
2881 break;
2882 default:
2883 // Noop
2884 break;
2885 }
2886 }
2887
2888 if (supports_yuv_reprocessing_ || supports_private_reprocessing_) {
2889 auto templateIdx = static_cast<size_t>(RequestTemplate::kZeroShutterLag);
2890 default_requests_[templateIdx] = HalCameraMetadata::Create(1, 10);
2891 }
2892
2893 return InitializeInfoDefaults();
2894 }
2895
Initialize(std::unique_ptr<HalCameraMetadata> staticMeta)2896 status_t EmulatedRequestState::Initialize(
2897 std::unique_ptr<HalCameraMetadata> staticMeta) {
2898 std::lock_guard<std::mutex> lock(request_state_mutex_);
2899 static_metadata_ = std::move(staticMeta);
2900
2901 return InitializeRequestDefaults();
2902 }
2903
GetDefaultRequest(RequestTemplate type,std::unique_ptr<HalCameraMetadata> * default_settings)2904 status_t EmulatedRequestState::GetDefaultRequest(
2905 RequestTemplate type, std::unique_ptr<HalCameraMetadata>* default_settings) {
2906 if (default_settings == nullptr) {
2907 ALOGE("%s default_settings is nullptr", __FUNCTION__);
2908 return BAD_VALUE;
2909 }
2910
2911 std::lock_guard<std::mutex> lock(request_state_mutex_);
2912 auto idx = static_cast<size_t>(type);
2913 if (idx >= kTemplateCount) {
2914 ALOGE("%s: Unexpected request type: %d", __FUNCTION__, type);
2915 return BAD_VALUE;
2916 }
2917
2918 if (default_requests_[idx].get() == nullptr) {
2919 ALOGE("%s: Unsupported request type: %d", __FUNCTION__, type);
2920 return BAD_VALUE;
2921 }
2922
2923 *default_settings =
2924 HalCameraMetadata::Clone(default_requests_[idx]->GetRawCameraMetadata());
2925
2926 return OK;
2927 }
2928
2929 } // namespace android
2930