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