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