1 /*
2 * Copyright (C) 2012 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 "Camera2-Parameters"
18 #define ATRACE_TAG ATRACE_TAG_CAMERA
19 // #define LOG_NDEBUG 0
20
21 #include <utils/Log.h>
22 #include <utils/Trace.h>
23 #include <utils/Vector.h>
24 #include <utils/SortedVector.h>
25
26 #include <math.h>
27 #include <stdlib.h>
28 #include <cutils/properties.h>
29
30 #include "Parameters.h"
31 #include "system/camera.h"
32 #include "hardware/camera_common.h"
33 #include <android/hardware/ICamera.h>
34 #include <media/MediaProfiles.h>
35 #include <media/mediarecorder.h>
36
37 namespace android {
38 namespace camera2 {
39
Parameters(int cameraId,int cameraFacing)40 Parameters::Parameters(int cameraId,
41 int cameraFacing) :
42 cameraId(cameraId),
43 cameraFacing(cameraFacing),
44 info(NULL) {
45 }
46
~Parameters()47 Parameters::~Parameters() {
48 }
49
initialize(const CameraMetadata * info,int deviceVersion)50 status_t Parameters::initialize(const CameraMetadata *info, int deviceVersion) {
51 status_t res;
52
53 if (info->entryCount() == 0) {
54 ALOGE("%s: No static information provided!", __FUNCTION__);
55 return BAD_VALUE;
56 }
57 Parameters::info = info;
58 mDeviceVersion = deviceVersion;
59
60 res = buildFastInfo();
61 if (res != OK) return res;
62
63 res = buildQuirks();
64 if (res != OK) return res;
65
66 const Size MAX_PREVIEW_SIZE = { MAX_PREVIEW_WIDTH, MAX_PREVIEW_HEIGHT };
67 // Treat the H.264 max size as the max supported video size.
68 MediaProfiles *videoEncoderProfiles = MediaProfiles::getInstance();
69 Vector<video_encoder> encoders = videoEncoderProfiles->getVideoEncoders();
70 int32_t maxVideoWidth = 0;
71 int32_t maxVideoHeight = 0;
72 for (size_t i = 0; i < encoders.size(); i++) {
73 int width = videoEncoderProfiles->getVideoEncoderParamByName(
74 "enc.vid.width.max", encoders[i]);
75 int height = videoEncoderProfiles->getVideoEncoderParamByName(
76 "enc.vid.height.max", encoders[i]);
77 // Treat width/height separately here to handle the case where different
78 // profile might report max size of different aspect ratio
79 if (width > maxVideoWidth) {
80 maxVideoWidth = width;
81 }
82 if (height > maxVideoHeight) {
83 maxVideoHeight = height;
84 }
85 }
86 // This is just an upper bound and may not be an actually valid video size
87 const Size VIDEO_SIZE_UPPER_BOUND = {maxVideoWidth, maxVideoHeight};
88
89 res = getFilteredSizes(MAX_PREVIEW_SIZE, &availablePreviewSizes);
90 if (res != OK) return res;
91 res = getFilteredSizes(VIDEO_SIZE_UPPER_BOUND, &availableVideoSizes);
92 if (res != OK) return res;
93
94 // Select initial preview and video size that's under the initial bound and
95 // on the list of both preview and recording sizes
96 previewWidth = 0;
97 previewHeight = 0;
98 for (size_t i = 0 ; i < availablePreviewSizes.size(); i++) {
99 int newWidth = availablePreviewSizes[i].width;
100 int newHeight = availablePreviewSizes[i].height;
101 if (newWidth >= previewWidth && newHeight >= previewHeight &&
102 newWidth <= MAX_INITIAL_PREVIEW_WIDTH &&
103 newHeight <= MAX_INITIAL_PREVIEW_HEIGHT) {
104 for (size_t j = 0; j < availableVideoSizes.size(); j++) {
105 if (availableVideoSizes[j].width == newWidth &&
106 availableVideoSizes[j].height == newHeight) {
107 previewWidth = newWidth;
108 previewHeight = newHeight;
109 }
110 }
111 }
112 }
113 if (previewWidth == 0) {
114 ALOGE("%s: No initial preview size can be found!", __FUNCTION__);
115 return BAD_VALUE;
116 }
117 videoWidth = previewWidth;
118 videoHeight = previewHeight;
119
120 params.setPreviewSize(previewWidth, previewHeight);
121 params.setVideoSize(videoWidth, videoHeight);
122 params.set(CameraParameters::KEY_PREFERRED_PREVIEW_SIZE_FOR_VIDEO,
123 String8::format("%dx%d",
124 previewWidth, previewHeight));
125 {
126 String8 supportedPreviewSizes;
127 for (size_t i = 0; i < availablePreviewSizes.size(); i++) {
128 if (i != 0) supportedPreviewSizes += ",";
129 supportedPreviewSizes += String8::format("%dx%d",
130 availablePreviewSizes[i].width,
131 availablePreviewSizes[i].height);
132 }
133 ALOGV("Supported preview sizes are: %s", supportedPreviewSizes.string());
134 params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES,
135 supportedPreviewSizes);
136
137 String8 supportedVideoSizes;
138 for (size_t i = 0; i < availableVideoSizes.size(); i++) {
139 if (i != 0) supportedVideoSizes += ",";
140 supportedVideoSizes += String8::format("%dx%d",
141 availableVideoSizes[i].width,
142 availableVideoSizes[i].height);
143 }
144 ALOGV("Supported video sizes are: %s", supportedVideoSizes.string());
145 params.set(CameraParameters::KEY_SUPPORTED_VIDEO_SIZES,
146 supportedVideoSizes);
147 }
148
149 camera_metadata_ro_entry_t availableFpsRanges =
150 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES, 2);
151 if (!availableFpsRanges.count) return NO_INIT;
152
153 previewFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP;
154 params.set(CameraParameters::KEY_PREVIEW_FORMAT,
155 formatEnumToString(previewFormat)); // NV21
156
157 previewTransform = degToTransform(0,
158 cameraFacing == CAMERA_FACING_FRONT);
159
160 {
161 String8 supportedPreviewFormats;
162 SortedVector<int32_t> outputFormats = getAvailableOutputFormats();
163 bool addComma = false;
164 for (size_t i=0; i < outputFormats.size(); i++) {
165 if (addComma) supportedPreviewFormats += ",";
166 addComma = true;
167 switch (outputFormats[i]) {
168 case HAL_PIXEL_FORMAT_YCbCr_422_SP:
169 supportedPreviewFormats +=
170 CameraParameters::PIXEL_FORMAT_YUV422SP;
171 break;
172 case HAL_PIXEL_FORMAT_YCrCb_420_SP:
173 supportedPreviewFormats +=
174 CameraParameters::PIXEL_FORMAT_YUV420SP;
175 break;
176 case HAL_PIXEL_FORMAT_YCbCr_422_I:
177 supportedPreviewFormats +=
178 CameraParameters::PIXEL_FORMAT_YUV422I;
179 break;
180 case HAL_PIXEL_FORMAT_YV12:
181 supportedPreviewFormats +=
182 CameraParameters::PIXEL_FORMAT_YUV420P;
183 break;
184 case HAL_PIXEL_FORMAT_RGB_565:
185 supportedPreviewFormats +=
186 CameraParameters::PIXEL_FORMAT_RGB565;
187 break;
188 case HAL_PIXEL_FORMAT_RGBA_8888:
189 supportedPreviewFormats +=
190 CameraParameters::PIXEL_FORMAT_RGBA8888;
191 break;
192 case HAL_PIXEL_FORMAT_YCbCr_420_888:
193 // Flexible YUV allows both YV12 and NV21
194 supportedPreviewFormats +=
195 CameraParameters::PIXEL_FORMAT_YUV420P;
196 supportedPreviewFormats += ",";
197 supportedPreviewFormats +=
198 CameraParameters::PIXEL_FORMAT_YUV420SP;
199 break;
200 // Not advertizing JPEG, RAW16, etc, for preview formats
201 case HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED:
202 case HAL_PIXEL_FORMAT_RAW16:
203 case HAL_PIXEL_FORMAT_BLOB:
204 addComma = false;
205 break;
206
207 default:
208 ALOGW("%s: Camera %d: Unknown preview format: %x",
209 __FUNCTION__, cameraId, outputFormats[i]);
210 addComma = false;
211 break;
212 }
213 }
214 params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS,
215 supportedPreviewFormats);
216 }
217
218 previewFpsRange[0] = fastInfo.bestStillCaptureFpsRange[0];
219 previewFpsRange[1] = fastInfo.bestStillCaptureFpsRange[1];
220
221 // PREVIEW_FRAME_RATE / SUPPORTED_PREVIEW_FRAME_RATES are deprecated, but
222 // still have to do something sane for them
223
224 // NOTE: Not scaled like FPS range values are.
225 int previewFps = fpsFromRange(previewFpsRange[0], previewFpsRange[1]);
226 params.set(CameraParameters::KEY_PREVIEW_FRAME_RATE,
227 previewFps);
228
229 // PREVIEW_FPS_RANGE
230 // -- Order matters. Set range after single value to so that a roundtrip
231 // of setParameters(getParameters()) would keep the FPS range in higher
232 // order.
233 params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE,
234 String8::format("%d,%d",
235 previewFpsRange[0] * kFpsToApiScale,
236 previewFpsRange[1] * kFpsToApiScale));
237
238 {
239 String8 supportedPreviewFpsRange;
240 for (size_t i=0; i < availableFpsRanges.count; i += 2) {
241 if (i != 0) supportedPreviewFpsRange += ",";
242 supportedPreviewFpsRange += String8::format("(%d,%d)",
243 availableFpsRanges.data.i32[i] * kFpsToApiScale,
244 availableFpsRanges.data.i32[i+1] * kFpsToApiScale);
245 }
246 params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE,
247 supportedPreviewFpsRange);
248 }
249
250 {
251 SortedVector<int32_t> sortedPreviewFrameRates;
252
253 String8 supportedPreviewFrameRates;
254 for (size_t i=0; i < availableFpsRanges.count; i += 2) {
255 // from the [min, max] fps range use the max value
256 int fps = fpsFromRange(availableFpsRanges.data.i32[i],
257 availableFpsRanges.data.i32[i+1]);
258
259 // de-dupe frame rates
260 if (sortedPreviewFrameRates.indexOf(fps) == NAME_NOT_FOUND) {
261 sortedPreviewFrameRates.add(fps);
262 }
263 else {
264 continue;
265 }
266
267 if (sortedPreviewFrameRates.size() > 1) {
268 supportedPreviewFrameRates += ",";
269 }
270
271 supportedPreviewFrameRates += String8::format("%d",
272 fps);
273
274 ALOGV("%s: Supported preview frame rates: %s",
275 __FUNCTION__, supportedPreviewFrameRates.string());
276 }
277 params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES,
278 supportedPreviewFrameRates);
279 }
280
281 Vector<Size> availableJpegSizes = getAvailableJpegSizes();
282 if (!availableJpegSizes.size()) return NO_INIT;
283
284 // TODO: Pick maximum
285 pictureWidth = availableJpegSizes[0].width;
286 pictureHeight = availableJpegSizes[0].height;
287 pictureWidthLastSet = pictureWidth;
288 pictureHeightLastSet = pictureHeight;
289 pictureSizeOverriden = false;
290
291 params.setPictureSize(pictureWidth,
292 pictureHeight);
293
294 {
295 String8 supportedPictureSizes;
296 for (size_t i=0; i < availableJpegSizes.size(); i++) {
297 if (i != 0) supportedPictureSizes += ",";
298 supportedPictureSizes += String8::format("%dx%d",
299 availableJpegSizes[i].width,
300 availableJpegSizes[i].height);
301 }
302 params.set(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES,
303 supportedPictureSizes);
304 }
305
306 params.setPictureFormat(CameraParameters::PIXEL_FORMAT_JPEG);
307 params.set(CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS,
308 CameraParameters::PIXEL_FORMAT_JPEG);
309
310 camera_metadata_ro_entry_t availableJpegThumbnailSizes =
311 staticInfo(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES, 4);
312 if (!availableJpegThumbnailSizes.count) return NO_INIT;
313
314 // Pick the largest thumbnail size that matches still image aspect ratio.
315 ALOG_ASSERT(pictureWidth > 0 && pictureHeight > 0,
316 "Invalid picture size, %d x %d", pictureWidth, pictureHeight);
317 float picAspectRatio = static_cast<float>(pictureWidth) / pictureHeight;
318 Size thumbnailSize =
319 getMaxSizeForRatio(
320 picAspectRatio,
321 &availableJpegThumbnailSizes.data.i32[0],
322 availableJpegThumbnailSizes.count);
323 jpegThumbSize[0] = thumbnailSize.width;
324 jpegThumbSize[1] = thumbnailSize.height;
325
326 params.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH,
327 jpegThumbSize[0]);
328 params.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT,
329 jpegThumbSize[1]);
330
331 {
332 String8 supportedJpegThumbSizes;
333 for (size_t i=0; i < availableJpegThumbnailSizes.count; i += 2) {
334 if (i != 0) supportedJpegThumbSizes += ",";
335 supportedJpegThumbSizes += String8::format("%dx%d",
336 availableJpegThumbnailSizes.data.i32[i],
337 availableJpegThumbnailSizes.data.i32[i+1]);
338 }
339 params.set(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES,
340 supportedJpegThumbSizes);
341 }
342
343 jpegThumbQuality = 90;
344 params.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY,
345 jpegThumbQuality);
346 jpegQuality = 90;
347 params.set(CameraParameters::KEY_JPEG_QUALITY,
348 jpegQuality);
349 jpegRotation = 0;
350 params.set(CameraParameters::KEY_ROTATION,
351 jpegRotation);
352
353 gpsEnabled = false;
354 gpsCoordinates[0] = 0.0;
355 gpsCoordinates[1] = 0.0;
356 gpsCoordinates[2] = 0.0;
357 gpsTimestamp = 0;
358 gpsProcessingMethod = "unknown";
359 // GPS fields in CameraParameters are not set by implementation
360
361 wbMode = ANDROID_CONTROL_AWB_MODE_AUTO;
362 params.set(CameraParameters::KEY_WHITE_BALANCE,
363 CameraParameters::WHITE_BALANCE_AUTO);
364
365 camera_metadata_ro_entry_t availableWhiteBalanceModes =
366 staticInfo(ANDROID_CONTROL_AWB_AVAILABLE_MODES, 0, 0, false);
367 if (!availableWhiteBalanceModes.count) {
368 params.set(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE,
369 CameraParameters::WHITE_BALANCE_AUTO);
370 } else {
371 String8 supportedWhiteBalance;
372 bool addComma = false;
373 for (size_t i=0; i < availableWhiteBalanceModes.count; i++) {
374 if (addComma) supportedWhiteBalance += ",";
375 addComma = true;
376 switch (availableWhiteBalanceModes.data.u8[i]) {
377 case ANDROID_CONTROL_AWB_MODE_AUTO:
378 supportedWhiteBalance +=
379 CameraParameters::WHITE_BALANCE_AUTO;
380 break;
381 case ANDROID_CONTROL_AWB_MODE_INCANDESCENT:
382 supportedWhiteBalance +=
383 CameraParameters::WHITE_BALANCE_INCANDESCENT;
384 break;
385 case ANDROID_CONTROL_AWB_MODE_FLUORESCENT:
386 supportedWhiteBalance +=
387 CameraParameters::WHITE_BALANCE_FLUORESCENT;
388 break;
389 case ANDROID_CONTROL_AWB_MODE_WARM_FLUORESCENT:
390 supportedWhiteBalance +=
391 CameraParameters::WHITE_BALANCE_WARM_FLUORESCENT;
392 break;
393 case ANDROID_CONTROL_AWB_MODE_DAYLIGHT:
394 supportedWhiteBalance +=
395 CameraParameters::WHITE_BALANCE_DAYLIGHT;
396 break;
397 case ANDROID_CONTROL_AWB_MODE_CLOUDY_DAYLIGHT:
398 supportedWhiteBalance +=
399 CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT;
400 break;
401 case ANDROID_CONTROL_AWB_MODE_TWILIGHT:
402 supportedWhiteBalance +=
403 CameraParameters::WHITE_BALANCE_TWILIGHT;
404 break;
405 case ANDROID_CONTROL_AWB_MODE_SHADE:
406 supportedWhiteBalance +=
407 CameraParameters::WHITE_BALANCE_SHADE;
408 break;
409 // Skipping values not mappable to v1 API
410 case ANDROID_CONTROL_AWB_MODE_OFF:
411 addComma = false;
412 break;
413 default:
414 ALOGW("%s: Camera %d: Unknown white balance value: %d",
415 __FUNCTION__, cameraId,
416 availableWhiteBalanceModes.data.u8[i]);
417 addComma = false;
418 break;
419 }
420 }
421 params.set(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE,
422 supportedWhiteBalance);
423 }
424
425 effectMode = ANDROID_CONTROL_EFFECT_MODE_OFF;
426 params.set(CameraParameters::KEY_EFFECT,
427 CameraParameters::EFFECT_NONE);
428
429 camera_metadata_ro_entry_t availableEffects =
430 staticInfo(ANDROID_CONTROL_AVAILABLE_EFFECTS, 0, 0, false);
431 if (!availableEffects.count) {
432 params.set(CameraParameters::KEY_SUPPORTED_EFFECTS,
433 CameraParameters::EFFECT_NONE);
434 } else {
435 String8 supportedEffects;
436 bool addComma = false;
437 for (size_t i=0; i < availableEffects.count; i++) {
438 if (addComma) supportedEffects += ",";
439 addComma = true;
440 switch (availableEffects.data.u8[i]) {
441 case ANDROID_CONTROL_EFFECT_MODE_OFF:
442 supportedEffects +=
443 CameraParameters::EFFECT_NONE;
444 break;
445 case ANDROID_CONTROL_EFFECT_MODE_MONO:
446 supportedEffects +=
447 CameraParameters::EFFECT_MONO;
448 break;
449 case ANDROID_CONTROL_EFFECT_MODE_NEGATIVE:
450 supportedEffects +=
451 CameraParameters::EFFECT_NEGATIVE;
452 break;
453 case ANDROID_CONTROL_EFFECT_MODE_SOLARIZE:
454 supportedEffects +=
455 CameraParameters::EFFECT_SOLARIZE;
456 break;
457 case ANDROID_CONTROL_EFFECT_MODE_SEPIA:
458 supportedEffects +=
459 CameraParameters::EFFECT_SEPIA;
460 break;
461 case ANDROID_CONTROL_EFFECT_MODE_POSTERIZE:
462 supportedEffects +=
463 CameraParameters::EFFECT_POSTERIZE;
464 break;
465 case ANDROID_CONTROL_EFFECT_MODE_WHITEBOARD:
466 supportedEffects +=
467 CameraParameters::EFFECT_WHITEBOARD;
468 break;
469 case ANDROID_CONTROL_EFFECT_MODE_BLACKBOARD:
470 supportedEffects +=
471 CameraParameters::EFFECT_BLACKBOARD;
472 break;
473 case ANDROID_CONTROL_EFFECT_MODE_AQUA:
474 supportedEffects +=
475 CameraParameters::EFFECT_AQUA;
476 break;
477 default:
478 ALOGW("%s: Camera %d: Unknown effect value: %d",
479 __FUNCTION__, cameraId, availableEffects.data.u8[i]);
480 addComma = false;
481 break;
482 }
483 }
484 params.set(CameraParameters::KEY_SUPPORTED_EFFECTS, supportedEffects);
485 }
486
487 antibandingMode = ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO;
488 params.set(CameraParameters::KEY_ANTIBANDING,
489 CameraParameters::ANTIBANDING_AUTO);
490
491 camera_metadata_ro_entry_t availableAntibandingModes =
492 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES, 0, 0, false);
493 if (!availableAntibandingModes.count) {
494 params.set(CameraParameters::KEY_SUPPORTED_ANTIBANDING,
495 CameraParameters::ANTIBANDING_OFF);
496 } else {
497 String8 supportedAntibanding;
498 bool addComma = false;
499 for (size_t i=0; i < availableAntibandingModes.count; i++) {
500 if (addComma) supportedAntibanding += ",";
501 addComma = true;
502 switch (availableAntibandingModes.data.u8[i]) {
503 case ANDROID_CONTROL_AE_ANTIBANDING_MODE_OFF:
504 supportedAntibanding +=
505 CameraParameters::ANTIBANDING_OFF;
506 break;
507 case ANDROID_CONTROL_AE_ANTIBANDING_MODE_50HZ:
508 supportedAntibanding +=
509 CameraParameters::ANTIBANDING_50HZ;
510 break;
511 case ANDROID_CONTROL_AE_ANTIBANDING_MODE_60HZ:
512 supportedAntibanding +=
513 CameraParameters::ANTIBANDING_60HZ;
514 break;
515 case ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO:
516 supportedAntibanding +=
517 CameraParameters::ANTIBANDING_AUTO;
518 break;
519 default:
520 ALOGW("%s: Camera %d: Unknown antibanding value: %d",
521 __FUNCTION__, cameraId,
522 availableAntibandingModes.data.u8[i]);
523 addComma = false;
524 break;
525 }
526 }
527 params.set(CameraParameters::KEY_SUPPORTED_ANTIBANDING,
528 supportedAntibanding);
529 }
530
531 sceneMode = ANDROID_CONTROL_SCENE_MODE_DISABLED;
532 params.set(CameraParameters::KEY_SCENE_MODE,
533 CameraParameters::SCENE_MODE_AUTO);
534
535 camera_metadata_ro_entry_t availableSceneModes =
536 staticInfo(ANDROID_CONTROL_AVAILABLE_SCENE_MODES, 0, 0, false);
537 if (!availableSceneModes.count) {
538 params.remove(CameraParameters::KEY_SCENE_MODE);
539 } else {
540 String8 supportedSceneModes(CameraParameters::SCENE_MODE_AUTO);
541 bool addComma = true;
542 bool noSceneModes = false;
543 for (size_t i=0; i < availableSceneModes.count; i++) {
544 if (addComma) supportedSceneModes += ",";
545 addComma = true;
546 switch (availableSceneModes.data.u8[i]) {
547 case ANDROID_CONTROL_SCENE_MODE_DISABLED:
548 noSceneModes = true;
549 break;
550 case ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY:
551 // Not in old API
552 addComma = false;
553 break;
554 case ANDROID_CONTROL_SCENE_MODE_ACTION:
555 supportedSceneModes +=
556 CameraParameters::SCENE_MODE_ACTION;
557 break;
558 case ANDROID_CONTROL_SCENE_MODE_PORTRAIT:
559 supportedSceneModes +=
560 CameraParameters::SCENE_MODE_PORTRAIT;
561 break;
562 case ANDROID_CONTROL_SCENE_MODE_LANDSCAPE:
563 supportedSceneModes +=
564 CameraParameters::SCENE_MODE_LANDSCAPE;
565 break;
566 case ANDROID_CONTROL_SCENE_MODE_NIGHT:
567 supportedSceneModes +=
568 CameraParameters::SCENE_MODE_NIGHT;
569 break;
570 case ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT:
571 supportedSceneModes +=
572 CameraParameters::SCENE_MODE_NIGHT_PORTRAIT;
573 break;
574 case ANDROID_CONTROL_SCENE_MODE_THEATRE:
575 supportedSceneModes +=
576 CameraParameters::SCENE_MODE_THEATRE;
577 break;
578 case ANDROID_CONTROL_SCENE_MODE_BEACH:
579 supportedSceneModes +=
580 CameraParameters::SCENE_MODE_BEACH;
581 break;
582 case ANDROID_CONTROL_SCENE_MODE_SNOW:
583 supportedSceneModes +=
584 CameraParameters::SCENE_MODE_SNOW;
585 break;
586 case ANDROID_CONTROL_SCENE_MODE_SUNSET:
587 supportedSceneModes +=
588 CameraParameters::SCENE_MODE_SUNSET;
589 break;
590 case ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO:
591 supportedSceneModes +=
592 CameraParameters::SCENE_MODE_STEADYPHOTO;
593 break;
594 case ANDROID_CONTROL_SCENE_MODE_FIREWORKS:
595 supportedSceneModes +=
596 CameraParameters::SCENE_MODE_FIREWORKS;
597 break;
598 case ANDROID_CONTROL_SCENE_MODE_SPORTS:
599 supportedSceneModes +=
600 CameraParameters::SCENE_MODE_SPORTS;
601 break;
602 case ANDROID_CONTROL_SCENE_MODE_PARTY:
603 supportedSceneModes +=
604 CameraParameters::SCENE_MODE_PARTY;
605 break;
606 case ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT:
607 supportedSceneModes +=
608 CameraParameters::SCENE_MODE_CANDLELIGHT;
609 break;
610 case ANDROID_CONTROL_SCENE_MODE_BARCODE:
611 supportedSceneModes +=
612 CameraParameters::SCENE_MODE_BARCODE;
613 break;
614 case ANDROID_CONTROL_SCENE_MODE_HDR:
615 supportedSceneModes +=
616 CameraParameters::SCENE_MODE_HDR;
617 break;
618 default:
619 ALOGW("%s: Camera %d: Unknown scene mode value: %d",
620 __FUNCTION__, cameraId,
621 availableSceneModes.data.u8[i]);
622 addComma = false;
623 break;
624 }
625 }
626 if (!noSceneModes) {
627 params.set(CameraParameters::KEY_SUPPORTED_SCENE_MODES,
628 supportedSceneModes);
629 } else {
630 params.remove(CameraParameters::KEY_SCENE_MODE);
631 }
632 }
633
634 bool isFlashAvailable = false;
635 camera_metadata_ro_entry_t flashAvailable =
636 staticInfo(ANDROID_FLASH_INFO_AVAILABLE, 0, 1, false);
637 if (flashAvailable.count) {
638 isFlashAvailable = flashAvailable.data.u8[0];
639 }
640
641 camera_metadata_ro_entry_t availableAeModes =
642 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_MODES, 0, 0, false);
643
644 flashMode = Parameters::FLASH_MODE_OFF;
645 if (isFlashAvailable) {
646 params.set(CameraParameters::KEY_FLASH_MODE,
647 CameraParameters::FLASH_MODE_OFF);
648
649 String8 supportedFlashModes(CameraParameters::FLASH_MODE_OFF);
650 supportedFlashModes = supportedFlashModes +
651 "," + CameraParameters::FLASH_MODE_AUTO +
652 "," + CameraParameters::FLASH_MODE_ON +
653 "," + CameraParameters::FLASH_MODE_TORCH;
654 for (size_t i=0; i < availableAeModes.count; i++) {
655 if (availableAeModes.data.u8[i] ==
656 ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH_REDEYE) {
657 supportedFlashModes = supportedFlashModes + "," +
658 CameraParameters::FLASH_MODE_RED_EYE;
659 break;
660 }
661 }
662 params.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES,
663 supportedFlashModes);
664 } else {
665 // No flash means null flash mode and supported flash modes keys, so
666 // remove them just to be safe
667 params.remove(CameraParameters::KEY_FLASH_MODE);
668 params.remove(CameraParameters::KEY_SUPPORTED_FLASH_MODES);
669 }
670
671 camera_metadata_ro_entry_t minFocusDistance =
672 staticInfo(ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE, 0, 1, false);
673
674 camera_metadata_ro_entry_t availableAfModes =
675 staticInfo(ANDROID_CONTROL_AF_AVAILABLE_MODES, 0, 0, false);
676
677 if (!minFocusDistance.count || minFocusDistance.data.f[0] == 0) {
678 // Fixed-focus lens
679 focusMode = Parameters::FOCUS_MODE_FIXED;
680 params.set(CameraParameters::KEY_FOCUS_MODE,
681 CameraParameters::FOCUS_MODE_FIXED);
682 params.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES,
683 CameraParameters::FOCUS_MODE_FIXED);
684 } else {
685 focusMode = Parameters::FOCUS_MODE_AUTO;
686 params.set(CameraParameters::KEY_FOCUS_MODE,
687 CameraParameters::FOCUS_MODE_AUTO);
688 String8 supportedFocusModes;
689 bool addComma = false;
690 camera_metadata_ro_entry_t focusDistanceCalibration =
691 staticInfo(ANDROID_LENS_INFO_FOCUS_DISTANCE_CALIBRATION, 0, 0, false);
692
693 if (focusDistanceCalibration.count &&
694 focusDistanceCalibration.data.u8[0] !=
695 ANDROID_LENS_INFO_FOCUS_DISTANCE_CALIBRATION_UNCALIBRATED) {
696 supportedFocusModes += CameraParameters::FOCUS_MODE_INFINITY;
697 addComma = true;
698 }
699
700 for (size_t i=0; i < availableAfModes.count; i++) {
701 if (addComma) supportedFocusModes += ",";
702 addComma = true;
703 switch (availableAfModes.data.u8[i]) {
704 case ANDROID_CONTROL_AF_MODE_AUTO:
705 supportedFocusModes +=
706 CameraParameters::FOCUS_MODE_AUTO;
707 break;
708 case ANDROID_CONTROL_AF_MODE_MACRO:
709 supportedFocusModes +=
710 CameraParameters::FOCUS_MODE_MACRO;
711 break;
712 case ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO:
713 supportedFocusModes +=
714 CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO;
715 break;
716 case ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE:
717 supportedFocusModes +=
718 CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE;
719 break;
720 case ANDROID_CONTROL_AF_MODE_EDOF:
721 supportedFocusModes +=
722 CameraParameters::FOCUS_MODE_EDOF;
723 break;
724 // Not supported in old API
725 case ANDROID_CONTROL_AF_MODE_OFF:
726 addComma = false;
727 break;
728 default:
729 ALOGW("%s: Camera %d: Unknown AF mode value: %d",
730 __FUNCTION__, cameraId, availableAfModes.data.u8[i]);
731 addComma = false;
732 break;
733 }
734 }
735 params.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES,
736 supportedFocusModes);
737 }
738 focusState = ANDROID_CONTROL_AF_STATE_INACTIVE;
739 shadowFocusMode = FOCUS_MODE_INVALID;
740
741 camera_metadata_ro_entry_t max3aRegions = staticInfo(ANDROID_CONTROL_MAX_REGIONS,
742 Parameters::NUM_REGION, Parameters::NUM_REGION);
743 if (max3aRegions.count != Parameters::NUM_REGION) return NO_INIT;
744
745 int32_t maxNumFocusAreas = 0;
746 if (focusMode != Parameters::FOCUS_MODE_FIXED) {
747 maxNumFocusAreas = max3aRegions.data.i32[Parameters::REGION_AF];
748 }
749 params.set(CameraParameters::KEY_MAX_NUM_FOCUS_AREAS, maxNumFocusAreas);
750 params.set(CameraParameters::KEY_FOCUS_AREAS,
751 "(0,0,0,0,0)");
752 focusingAreas.clear();
753 focusingAreas.add(Parameters::Area(0,0,0,0,0));
754
755 camera_metadata_ro_entry_t availableFocalLengths =
756 staticInfo(ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS, 0, 0, false);
757 if (!availableFocalLengths.count) return NO_INIT;
758
759 float minFocalLength = availableFocalLengths.data.f[0];
760 params.setFloat(CameraParameters::KEY_FOCAL_LENGTH, minFocalLength);
761
762 float horizFov, vertFov;
763 res = calculatePictureFovs(&horizFov, &vertFov);
764 if (res != OK) {
765 ALOGE("%s: Can't calculate field of views!", __FUNCTION__);
766 return res;
767 }
768
769 params.setFloat(CameraParameters::KEY_HORIZONTAL_VIEW_ANGLE, horizFov);
770 params.setFloat(CameraParameters::KEY_VERTICAL_VIEW_ANGLE, vertFov);
771
772 exposureCompensation = 0;
773 params.set(CameraParameters::KEY_EXPOSURE_COMPENSATION,
774 exposureCompensation);
775
776 camera_metadata_ro_entry_t exposureCompensationRange =
777 staticInfo(ANDROID_CONTROL_AE_COMPENSATION_RANGE, 2, 2);
778 if (!exposureCompensationRange.count) return NO_INIT;
779
780 params.set(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION,
781 exposureCompensationRange.data.i32[1]);
782 params.set(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION,
783 exposureCompensationRange.data.i32[0]);
784
785 camera_metadata_ro_entry_t exposureCompensationStep =
786 staticInfo(ANDROID_CONTROL_AE_COMPENSATION_STEP, 1, 1);
787 if (!exposureCompensationStep.count) return NO_INIT;
788
789 params.setFloat(CameraParameters::KEY_EXPOSURE_COMPENSATION_STEP,
790 (float)exposureCompensationStep.data.r[0].numerator /
791 exposureCompensationStep.data.r[0].denominator);
792
793 autoExposureLock = false;
794 params.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK,
795 CameraParameters::FALSE);
796 params.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED,
797 CameraParameters::TRUE);
798
799 autoWhiteBalanceLock = false;
800 params.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK,
801 CameraParameters::FALSE);
802 params.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED,
803 CameraParameters::TRUE);
804
805 meteringAreas.add(Parameters::Area(0, 0, 0, 0, 0));
806 params.set(CameraParameters::KEY_MAX_NUM_METERING_AREAS,
807 max3aRegions.data.i32[Parameters::REGION_AE]);
808 params.set(CameraParameters::KEY_METERING_AREAS,
809 "(0,0,0,0,0)");
810
811 zoom = 0;
812 params.set(CameraParameters::KEY_ZOOM, zoom);
813 params.set(CameraParameters::KEY_MAX_ZOOM, NUM_ZOOM_STEPS - 1);
814
815 camera_metadata_ro_entry_t maxDigitalZoom =
816 staticInfo(ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM, /*minCount*/1, /*maxCount*/1);
817 if (!maxDigitalZoom.count) return NO_INIT;
818
819 {
820 String8 zoomRatios;
821 float zoom = 1.f;
822 float zoomIncrement = (maxDigitalZoom.data.f[0] - zoom) /
823 (NUM_ZOOM_STEPS-1);
824 bool addComma = false;
825 for (size_t i=0; i < NUM_ZOOM_STEPS; i++) {
826 if (addComma) zoomRatios += ",";
827 addComma = true;
828 zoomRatios += String8::format("%d", static_cast<int>(zoom * 100));
829 zoom += zoomIncrement;
830 }
831 params.set(CameraParameters::KEY_ZOOM_RATIOS, zoomRatios);
832 }
833
834 params.set(CameraParameters::KEY_ZOOM_SUPPORTED,
835 CameraParameters::TRUE);
836 params.set(CameraParameters::KEY_SMOOTH_ZOOM_SUPPORTED,
837 CameraParameters::FALSE);
838
839 params.set(CameraParameters::KEY_FOCUS_DISTANCES,
840 "Infinity,Infinity,Infinity");
841
842 params.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_HW,
843 fastInfo.maxFaces);
844 params.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_SW,
845 0);
846
847 params.set(CameraParameters::KEY_VIDEO_FRAME_FORMAT,
848 CameraParameters::PIXEL_FORMAT_ANDROID_OPAQUE);
849
850 recordingHint = false;
851 params.set(CameraParameters::KEY_RECORDING_HINT,
852 CameraParameters::FALSE);
853
854 params.set(CameraParameters::KEY_VIDEO_SNAPSHOT_SUPPORTED,
855 CameraParameters::TRUE);
856
857 videoStabilization = false;
858 params.set(CameraParameters::KEY_VIDEO_STABILIZATION,
859 CameraParameters::FALSE);
860
861 camera_metadata_ro_entry_t availableVideoStabilizationModes =
862 staticInfo(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES, 0, 0,
863 false);
864
865 if (availableVideoStabilizationModes.count > 1) {
866 params.set(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED,
867 CameraParameters::TRUE);
868 } else {
869 params.set(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED,
870 CameraParameters::FALSE);
871 }
872
873 // Set up initial state for non-Camera.Parameters state variables
874 videoFormat = HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED;
875 videoDataSpace = HAL_DATASPACE_V0_BT709;
876 videoBufferMode = hardware::ICamera::VIDEO_BUFFER_MODE_DATA_CALLBACK_YUV;
877 playShutterSound = true;
878 enableFaceDetect = false;
879
880 enableFocusMoveMessages = false;
881 afTriggerCounter = 1;
882 afStateCounter = 0;
883 currentAfTriggerId = -1;
884 afInMotion = false;
885
886 precaptureTriggerCounter = 1;
887
888 takePictureCounter = 0;
889
890 previewCallbackFlags = 0;
891 previewCallbackOneShot = false;
892 previewCallbackSurface = false;
893
894 Size maxJpegSize = getMaxSize(getAvailableJpegSizes());
895 int64_t minFrameDurationNs = getJpegStreamMinFrameDurationNs(maxJpegSize);
896
897 slowJpegMode = false;
898 if (minFrameDurationNs > kSlowJpegModeThreshold) {
899 slowJpegMode = true;
900 // Slow jpeg devices does not support video snapshot without
901 // slowing down preview.
902 // TODO: support video size video snapshot only?
903 params.set(CameraParameters::KEY_VIDEO_SNAPSHOT_SUPPORTED,
904 CameraParameters::FALSE);
905 }
906
907 char value[PROPERTY_VALUE_MAX];
908 property_get("camera.disable_zsl_mode", value, "0");
909 if (!strcmp(value,"1") || slowJpegMode) {
910 ALOGI("Camera %d: Disabling ZSL mode", cameraId);
911 allowZslMode = false;
912 } else {
913 allowZslMode = true;
914 }
915
916 ALOGI("%s: allowZslMode: %d slowJpegMode %d", __FUNCTION__, allowZslMode, slowJpegMode);
917
918 state = STOPPED;
919
920 paramsFlattened = params.flatten();
921
922 return OK;
923 }
924
get() const925 String8 Parameters::get() const {
926 return paramsFlattened;
927 }
928
buildFastInfo()929 status_t Parameters::buildFastInfo() {
930
931 camera_metadata_ro_entry_t activeArraySize =
932 staticInfo(ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE, 2, 4);
933 if (!activeArraySize.count) return NO_INIT;
934 int32_t arrayWidth;
935 int32_t arrayHeight;
936 if (activeArraySize.count == 2) {
937 ALOGW("%s: Camera %d: activeArraySize is missing xmin/ymin!",
938 __FUNCTION__, cameraId);
939 arrayWidth = activeArraySize.data.i32[0];
940 arrayHeight = activeArraySize.data.i32[1];
941 } else if (activeArraySize.count == 4) {
942 arrayWidth = activeArraySize.data.i32[2];
943 arrayHeight = activeArraySize.data.i32[3];
944 } else return NO_INIT;
945
946 // We'll set the target FPS range for still captures to be as wide
947 // as possible to give the HAL maximum latitude for exposure selection
948 camera_metadata_ro_entry_t availableFpsRanges =
949 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES, 2);
950 if (availableFpsRanges.count < 2 || availableFpsRanges.count % 2 != 0) {
951 return NO_INIT;
952 }
953
954 int32_t bestStillCaptureFpsRange[2] = {
955 availableFpsRanges.data.i32[0], availableFpsRanges.data.i32[1]
956 };
957 int32_t curRange =
958 bestStillCaptureFpsRange[1] - bestStillCaptureFpsRange[0];
959 for (size_t i = 2; i < availableFpsRanges.count; i += 2) {
960 int32_t nextRange =
961 availableFpsRanges.data.i32[i + 1] -
962 availableFpsRanges.data.i32[i];
963 if ( (nextRange > curRange) || // Maximize size of FPS range first
964 (nextRange == curRange && // Then minimize low-end FPS
965 bestStillCaptureFpsRange[0] > availableFpsRanges.data.i32[i])) {
966
967 bestStillCaptureFpsRange[0] = availableFpsRanges.data.i32[i];
968 bestStillCaptureFpsRange[1] = availableFpsRanges.data.i32[i + 1];
969 curRange = nextRange;
970 }
971 }
972
973 camera_metadata_ro_entry_t availableFaceDetectModes =
974 staticInfo(ANDROID_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES, 0, 0,
975 false);
976
977 uint8_t bestFaceDetectMode =
978 ANDROID_STATISTICS_FACE_DETECT_MODE_OFF;
979 for (size_t i = 0 ; i < availableFaceDetectModes.count; i++) {
980 switch (availableFaceDetectModes.data.u8[i]) {
981 case ANDROID_STATISTICS_FACE_DETECT_MODE_OFF:
982 break;
983 case ANDROID_STATISTICS_FACE_DETECT_MODE_SIMPLE:
984 if (bestFaceDetectMode !=
985 ANDROID_STATISTICS_FACE_DETECT_MODE_FULL) {
986 bestFaceDetectMode =
987 ANDROID_STATISTICS_FACE_DETECT_MODE_SIMPLE;
988 }
989 break;
990 case ANDROID_STATISTICS_FACE_DETECT_MODE_FULL:
991 bestFaceDetectMode =
992 ANDROID_STATISTICS_FACE_DETECT_MODE_FULL;
993 break;
994 default:
995 ALOGE("%s: Camera %d: Unknown face detect mode %d:",
996 __FUNCTION__, cameraId,
997 availableFaceDetectModes.data.u8[i]);
998 return NO_INIT;
999 }
1000 }
1001
1002 int32_t maxFaces = 0;
1003 camera_metadata_ro_entry_t maxFacesDetected =
1004 staticInfo(ANDROID_STATISTICS_INFO_MAX_FACE_COUNT, 0, 1, false);
1005 if (maxFacesDetected.count) {
1006 maxFaces = maxFacesDetected.data.i32[0];
1007 }
1008
1009 camera_metadata_ro_entry_t availableSceneModes =
1010 staticInfo(ANDROID_CONTROL_AVAILABLE_SCENE_MODES, 0, 0, false);
1011 camera_metadata_ro_entry_t sceneModeOverrides =
1012 staticInfo(ANDROID_CONTROL_SCENE_MODE_OVERRIDES, 0, 0, false);
1013 camera_metadata_ro_entry_t minFocusDistance =
1014 staticInfo(ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE, 0, 0, false);
1015 bool fixedLens = minFocusDistance.count == 0 ||
1016 minFocusDistance.data.f[0] == 0;
1017
1018 camera_metadata_ro_entry_t focusDistanceCalibration =
1019 staticInfo(ANDROID_LENS_INFO_FOCUS_DISTANCE_CALIBRATION, 0, 0,
1020 false);
1021 bool canFocusInfinity = (focusDistanceCalibration.count &&
1022 focusDistanceCalibration.data.u8[0] !=
1023 ANDROID_LENS_INFO_FOCUS_DISTANCE_CALIBRATION_UNCALIBRATED);
1024
1025 camera_metadata_ro_entry_t availableFocalLengths =
1026 staticInfo(ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS);
1027 if (!availableFocalLengths.count) return NO_INIT;
1028
1029 SortedVector<int32_t> availableFormats = getAvailableOutputFormats();
1030 if (!availableFormats.size()) return NO_INIT;
1031
1032
1033 if (sceneModeOverrides.count > 0) {
1034 // sceneModeOverrides is defined to have 3 entries for each scene mode,
1035 // which are AE, AWB, and AF override modes the HAL wants for that scene
1036 // mode.
1037 const size_t kModesPerSceneMode = 3;
1038 if (sceneModeOverrides.count !=
1039 availableSceneModes.count * kModesPerSceneMode) {
1040 ALOGE("%s: Camera %d: Scene mode override list is an "
1041 "unexpected size: %zu (expected %zu)", __FUNCTION__,
1042 cameraId, sceneModeOverrides.count,
1043 availableSceneModes.count * kModesPerSceneMode);
1044 return NO_INIT;
1045 }
1046 for (size_t i = 0; i < availableSceneModes.count; i++) {
1047 DeviceInfo::OverrideModes modes;
1048 uint8_t aeMode =
1049 sceneModeOverrides.data.u8[i * kModesPerSceneMode + 0];
1050 switch(aeMode) {
1051 case ANDROID_CONTROL_AE_MODE_ON:
1052 modes.flashMode = FLASH_MODE_OFF;
1053 break;
1054 case ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH:
1055 modes.flashMode = FLASH_MODE_AUTO;
1056 break;
1057 case ANDROID_CONTROL_AE_MODE_ON_ALWAYS_FLASH:
1058 modes.flashMode = FLASH_MODE_ON;
1059 break;
1060 case ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH_REDEYE:
1061 modes.flashMode = FLASH_MODE_RED_EYE;
1062 break;
1063 default:
1064 ALOGE("%s: Unknown override AE mode: %d", __FUNCTION__,
1065 aeMode);
1066 modes.flashMode = FLASH_MODE_INVALID;
1067 break;
1068 }
1069 modes.wbMode =
1070 sceneModeOverrides.data.u8[i * kModesPerSceneMode + 1];
1071 uint8_t afMode =
1072 sceneModeOverrides.data.u8[i * kModesPerSceneMode + 2];
1073 switch(afMode) {
1074 case ANDROID_CONTROL_AF_MODE_OFF:
1075 if (!fixedLens && !canFocusInfinity) {
1076 ALOGE("%s: Camera %d: Scene mode override lists asks for"
1077 " fixed focus on a device with focuser but not"
1078 " calibrated for infinity focus", __FUNCTION__,
1079 cameraId);
1080 return NO_INIT;
1081 }
1082 modes.focusMode = fixedLens ?
1083 FOCUS_MODE_FIXED : FOCUS_MODE_INFINITY;
1084 break;
1085 case ANDROID_CONTROL_AF_MODE_AUTO:
1086 case ANDROID_CONTROL_AF_MODE_MACRO:
1087 case ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO:
1088 case ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE:
1089 case ANDROID_CONTROL_AF_MODE_EDOF:
1090 modes.focusMode = static_cast<focusMode_t>(afMode);
1091 break;
1092 default:
1093 ALOGE("%s: Unknown override AF mode: %d", __FUNCTION__,
1094 afMode);
1095 modes.focusMode = FOCUS_MODE_INVALID;
1096 break;
1097 }
1098 fastInfo.sceneModeOverrides.add(availableSceneModes.data.u8[i],
1099 modes);
1100 }
1101 }
1102
1103 fastInfo.arrayWidth = arrayWidth;
1104 fastInfo.arrayHeight = arrayHeight;
1105 fastInfo.bestStillCaptureFpsRange[0] = bestStillCaptureFpsRange[0];
1106 fastInfo.bestStillCaptureFpsRange[1] = bestStillCaptureFpsRange[1];
1107 fastInfo.bestFaceDetectMode = bestFaceDetectMode;
1108 fastInfo.maxFaces = maxFaces;
1109
1110 // Find smallest (widest-angle) focal length to use as basis of still
1111 // picture FOV reporting.
1112 fastInfo.minFocalLength = availableFocalLengths.data.f[0];
1113 for (size_t i = 1; i < availableFocalLengths.count; i++) {
1114 if (fastInfo.minFocalLength > availableFocalLengths.data.f[i]) {
1115 fastInfo.minFocalLength = availableFocalLengths.data.f[i];
1116 }
1117 }
1118
1119 // Check if the HAL supports HAL_PIXEL_FORMAT_YCbCr_420_888
1120 fastInfo.useFlexibleYuv = false;
1121 for (size_t i = 0; i < availableFormats.size(); i++) {
1122 if (availableFormats[i] == HAL_PIXEL_FORMAT_YCbCr_420_888) {
1123 fastInfo.useFlexibleYuv = true;
1124 break;
1125 }
1126 }
1127 ALOGV("Camera %d: Flexible YUV %s supported",
1128 cameraId, fastInfo.useFlexibleYuv ? "is" : "is not");
1129
1130 fastInfo.maxJpegSize = getMaxSize(getAvailableJpegSizes());
1131
1132 return OK;
1133 }
1134
buildQuirks()1135 status_t Parameters::buildQuirks() {
1136 camera_metadata_ro_entry_t entry;
1137 entry = info->find(ANDROID_QUIRKS_TRIGGER_AF_WITH_AUTO);
1138 quirks.triggerAfWithAuto = (entry.count != 0 && entry.data.u8[0] == 1);
1139 ALOGV_IF(quirks.triggerAfWithAuto, "Camera %d: Quirk triggerAfWithAuto enabled",
1140 cameraId);
1141
1142 entry = info->find(ANDROID_QUIRKS_USE_ZSL_FORMAT);
1143 quirks.useZslFormat = (entry.count != 0 && entry.data.u8[0] == 1);
1144 ALOGV_IF(quirks.useZslFormat, "Camera %d: Quirk useZslFormat enabled",
1145 cameraId);
1146
1147 entry = info->find(ANDROID_QUIRKS_METERING_CROP_REGION);
1148 quirks.meteringCropRegion = (entry.count != 0 && entry.data.u8[0] == 1);
1149 ALOGV_IF(quirks.meteringCropRegion, "Camera %d: Quirk meteringCropRegion"
1150 " enabled", cameraId);
1151
1152 entry = info->find(ANDROID_QUIRKS_USE_PARTIAL_RESULT);
1153 quirks.partialResults = (entry.count != 0 && entry.data.u8[0] == 1);
1154 ALOGV_IF(quirks.partialResults, "Camera %d: Quirk usePartialResult"
1155 " enabled", cameraId);
1156
1157 return OK;
1158 }
1159
staticInfo(uint32_t tag,size_t minCount,size_t maxCount,bool required) const1160 camera_metadata_ro_entry_t Parameters::staticInfo(uint32_t tag,
1161 size_t minCount, size_t maxCount, bool required) const {
1162 camera_metadata_ro_entry_t entry = info->find(tag);
1163
1164 if (CC_UNLIKELY( entry.count == 0 ) && required) {
1165 const char* tagSection = get_camera_metadata_section_name(tag);
1166 if (tagSection == NULL) tagSection = "<unknown>";
1167 const char* tagName = get_camera_metadata_tag_name(tag);
1168 if (tagName == NULL) tagName = "<unknown>";
1169
1170 ALOGE("Error finding static metadata entry '%s.%s' (%x)",
1171 tagSection, tagName, tag);
1172 } else if (CC_UNLIKELY(
1173 (minCount != 0 && entry.count < minCount) ||
1174 (maxCount != 0 && entry.count > maxCount) ) ) {
1175 const char* tagSection = get_camera_metadata_section_name(tag);
1176 if (tagSection == NULL) tagSection = "<unknown>";
1177 const char* tagName = get_camera_metadata_tag_name(tag);
1178 if (tagName == NULL) tagName = "<unknown>";
1179 ALOGE("Malformed static metadata entry '%s.%s' (%x):"
1180 "Expected between %zu and %zu values, but got %zu values",
1181 tagSection, tagName, tag, minCount, maxCount, entry.count);
1182 }
1183
1184 return entry;
1185 }
1186
set(const String8 & paramString)1187 status_t Parameters::set(const String8& paramString) {
1188 status_t res;
1189
1190 CameraParameters2 newParams(paramString);
1191
1192 // TODO: Currently ignoring any changes to supposedly read-only parameters
1193 // such as supported preview sizes, etc. Should probably produce an error if
1194 // they're changed.
1195
1196 /** Extract and verify new parameters */
1197
1198 size_t i;
1199
1200 Parameters validatedParams(*this);
1201
1202 // PREVIEW_SIZE
1203 newParams.getPreviewSize(&validatedParams.previewWidth,
1204 &validatedParams.previewHeight);
1205
1206 if (validatedParams.previewWidth != previewWidth ||
1207 validatedParams.previewHeight != previewHeight) {
1208 if (state >= PREVIEW) {
1209 ALOGE("%s: Preview size cannot be updated when preview "
1210 "is active! (Currently %d x %d, requested %d x %d",
1211 __FUNCTION__,
1212 previewWidth, previewHeight,
1213 validatedParams.previewWidth, validatedParams.previewHeight);
1214 return BAD_VALUE;
1215 }
1216 for (i = 0; i < availablePreviewSizes.size(); i++) {
1217 if ((availablePreviewSizes[i].width ==
1218 validatedParams.previewWidth) &&
1219 (availablePreviewSizes[i].height ==
1220 validatedParams.previewHeight)) break;
1221 }
1222 if (i == availablePreviewSizes.size()) {
1223 ALOGE("%s: Requested preview size %d x %d is not supported",
1224 __FUNCTION__, validatedParams.previewWidth,
1225 validatedParams.previewHeight);
1226 return BAD_VALUE;
1227 }
1228 }
1229
1230 // RECORDING_HINT (always supported)
1231 validatedParams.recordingHint = boolFromString(
1232 newParams.get(CameraParameters::KEY_RECORDING_HINT) );
1233 IF_ALOGV() { // Avoid unused variable warning
1234 bool recordingHintChanged =
1235 validatedParams.recordingHint != recordingHint;
1236 if (recordingHintChanged) {
1237 ALOGV("%s: Recording hint changed to %d",
1238 __FUNCTION__, validatedParams.recordingHint);
1239 }
1240 }
1241
1242 // PREVIEW_FPS_RANGE
1243
1244 /**
1245 * Use the single FPS value if it was set later than the range.
1246 * Otherwise, use the range value.
1247 */
1248 bool fpsUseSingleValue;
1249 {
1250 const char *fpsRange, *fpsSingle;
1251
1252 fpsRange = newParams.get(CameraParameters::KEY_PREVIEW_FRAME_RATE);
1253 fpsSingle = newParams.get(CameraParameters::KEY_PREVIEW_FPS_RANGE);
1254
1255 /**
1256 * Pick either the range or the single key if only one was set.
1257 *
1258 * If both are set, pick the one that has greater set order.
1259 */
1260 if (fpsRange == NULL && fpsSingle == NULL) {
1261 ALOGE("%s: FPS was not set. One of %s or %s must be set.",
1262 __FUNCTION__, CameraParameters::KEY_PREVIEW_FRAME_RATE,
1263 CameraParameters::KEY_PREVIEW_FPS_RANGE);
1264 return BAD_VALUE;
1265 } else if (fpsRange == NULL) {
1266 fpsUseSingleValue = true;
1267 ALOGV("%s: FPS range not set, using FPS single value",
1268 __FUNCTION__);
1269 } else if (fpsSingle == NULL) {
1270 fpsUseSingleValue = false;
1271 ALOGV("%s: FPS single not set, using FPS range value",
1272 __FUNCTION__);
1273 } else {
1274 int fpsKeyOrder;
1275 res = newParams.compareSetOrder(
1276 CameraParameters::KEY_PREVIEW_FRAME_RATE,
1277 CameraParameters::KEY_PREVIEW_FPS_RANGE,
1278 &fpsKeyOrder);
1279 LOG_ALWAYS_FATAL_IF(res != OK, "Impossibly bad FPS keys");
1280
1281 fpsUseSingleValue = (fpsKeyOrder > 0);
1282
1283 }
1284
1285 ALOGV("%s: Preview FPS value is used from '%s'",
1286 __FUNCTION__, fpsUseSingleValue ? "single" : "range");
1287 }
1288 newParams.getPreviewFpsRange(&validatedParams.previewFpsRange[0],
1289 &validatedParams.previewFpsRange[1]);
1290
1291 validatedParams.previewFpsRange[0] /= kFpsToApiScale;
1292 validatedParams.previewFpsRange[1] /= kFpsToApiScale;
1293
1294 // Ignore the FPS range if the FPS single has higher precedence
1295 if (!fpsUseSingleValue) {
1296 ALOGV("%s: Preview FPS range (%d, %d)", __FUNCTION__,
1297 validatedParams.previewFpsRange[0],
1298 validatedParams.previewFpsRange[1]);
1299
1300 camera_metadata_ro_entry_t availablePreviewFpsRanges =
1301 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES, 2);
1302 for (i = 0; i < availablePreviewFpsRanges.count; i += 2) {
1303 if ((availablePreviewFpsRanges.data.i32[i] ==
1304 validatedParams.previewFpsRange[0]) &&
1305 (availablePreviewFpsRanges.data.i32[i+1] ==
1306 validatedParams.previewFpsRange[1]) ) {
1307 break;
1308 }
1309 }
1310 if (i == availablePreviewFpsRanges.count) {
1311 ALOGE("%s: Requested preview FPS range %d - %d is not supported",
1312 __FUNCTION__, validatedParams.previewFpsRange[0],
1313 validatedParams.previewFpsRange[1]);
1314 return BAD_VALUE;
1315 }
1316 }
1317
1318 // PREVIEW_FORMAT
1319 validatedParams.previewFormat =
1320 formatStringToEnum(newParams.getPreviewFormat());
1321 if (validatedParams.previewFormat != previewFormat) {
1322 if (state >= PREVIEW) {
1323 ALOGE("%s: Preview format cannot be updated when preview "
1324 "is active!", __FUNCTION__);
1325 return BAD_VALUE;
1326 }
1327 SortedVector<int32_t> availableFormats = getAvailableOutputFormats();
1328 // If using flexible YUV, always support NV21/YV12. Otherwise, check
1329 // HAL's list.
1330 if (! (fastInfo.useFlexibleYuv &&
1331 (validatedParams.previewFormat ==
1332 HAL_PIXEL_FORMAT_YCrCb_420_SP ||
1333 validatedParams.previewFormat ==
1334 HAL_PIXEL_FORMAT_YV12) ) ) {
1335 // Not using flexible YUV format, so check explicitly
1336 for (i = 0; i < availableFormats.size(); i++) {
1337 if (availableFormats[i] == validatedParams.previewFormat) break;
1338 }
1339 if (i == availableFormats.size()) {
1340 ALOGE("%s: Requested preview format %s (0x%x) is not supported",
1341 __FUNCTION__, newParams.getPreviewFormat(),
1342 validatedParams.previewFormat);
1343 return BAD_VALUE;
1344 }
1345 }
1346 }
1347
1348 // PREVIEW_FRAME_RATE Deprecated
1349 // - Use only if the single FPS value was set later than the FPS range
1350 if (fpsUseSingleValue) {
1351 int previewFps = newParams.getPreviewFrameRate();
1352 ALOGV("%s: Preview FPS single value requested: %d",
1353 __FUNCTION__, previewFps);
1354 {
1355 camera_metadata_ro_entry_t availableFrameRates =
1356 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES);
1357 /**
1358 * If recording hint is set, find the range that encompasses
1359 * previewFps with the largest min index.
1360 *
1361 * If recording hint is not set, find the range with previewFps
1362 * with the smallest min index.
1363 *
1364 * Either way, in case of multiple ranges, break the tie by
1365 * selecting the smaller range.
1366 */
1367
1368 // all ranges which have previewFps
1369 Vector<Range> candidateRanges;
1370 for (i = 0; i < availableFrameRates.count; i+=2) {
1371 Range r = {
1372 availableFrameRates.data.i32[i],
1373 availableFrameRates.data.i32[i+1]
1374 };
1375
1376 if (r.min <= previewFps && previewFps <= r.max) {
1377 candidateRanges.push(r);
1378 }
1379 }
1380 if (candidateRanges.isEmpty()) {
1381 ALOGE("%s: Requested preview frame rate %d is not supported",
1382 __FUNCTION__, previewFps);
1383 return BAD_VALUE;
1384 }
1385 // most applicable range with targetFps
1386 Range bestRange = candidateRanges[0];
1387 for (i = 1; i < candidateRanges.size(); ++i) {
1388 Range r = candidateRanges[i];
1389
1390 // Find by largest minIndex in recording mode
1391 if (validatedParams.recordingHint) {
1392 if (r.min > bestRange.min) {
1393 bestRange = r;
1394 }
1395 else if (r.min == bestRange.min && r.max < bestRange.max) {
1396 bestRange = r;
1397 }
1398 }
1399 // Find by smallest minIndex in preview mode
1400 else {
1401 if (r.min < bestRange.min) {
1402 bestRange = r;
1403 }
1404 else if (r.min == bestRange.min && r.max < bestRange.max) {
1405 bestRange = r;
1406 }
1407 }
1408 }
1409
1410 validatedParams.previewFpsRange[0] =
1411 bestRange.min;
1412 validatedParams.previewFpsRange[1] =
1413 bestRange.max;
1414
1415 ALOGV("%s: New preview FPS range: %d, %d, recordingHint = %d",
1416 __FUNCTION__,
1417 validatedParams.previewFpsRange[0],
1418 validatedParams.previewFpsRange[1],
1419 validatedParams.recordingHint);
1420 }
1421 }
1422
1423 /**
1424 * Update Preview FPS and Preview FPS ranges based on
1425 * what we actually set.
1426 *
1427 * This updates the API-visible (Camera.Parameters#getParameters) values of
1428 * the FPS fields, not only the internal versions.
1429 *
1430 * Order matters: The value that was set last takes precedence.
1431 * - If the client does a setParameters(getParameters()) we retain
1432 * the same order for preview FPS.
1433 */
1434 if (!fpsUseSingleValue) {
1435 // Set fps single, then fps range (range wins)
1436 newParams.setPreviewFrameRate(
1437 fpsFromRange(/*min*/validatedParams.previewFpsRange[0],
1438 /*max*/validatedParams.previewFpsRange[1]));
1439 newParams.setPreviewFpsRange(
1440 validatedParams.previewFpsRange[0] * kFpsToApiScale,
1441 validatedParams.previewFpsRange[1] * kFpsToApiScale);
1442 } else {
1443 // Set fps range, then fps single (single wins)
1444 newParams.setPreviewFpsRange(
1445 validatedParams.previewFpsRange[0] * kFpsToApiScale,
1446 validatedParams.previewFpsRange[1] * kFpsToApiScale);
1447 // Set this to the same value, but with higher priority
1448 newParams.setPreviewFrameRate(
1449 newParams.getPreviewFrameRate());
1450 }
1451
1452 // PICTURE_SIZE
1453 newParams.getPictureSize(&validatedParams.pictureWidth,
1454 &validatedParams.pictureHeight);
1455 if (validatedParams.pictureWidth != pictureWidth ||
1456 validatedParams.pictureHeight != pictureHeight) {
1457 Vector<Size> availablePictureSizes = getAvailableJpegSizes();
1458 for (i = 0; i < availablePictureSizes.size(); i++) {
1459 if ((availablePictureSizes[i].width ==
1460 validatedParams.pictureWidth) &&
1461 (availablePictureSizes[i].height ==
1462 validatedParams.pictureHeight)) break;
1463 }
1464 if (i == availablePictureSizes.size()) {
1465 ALOGE("%s: Requested picture size %d x %d is not supported",
1466 __FUNCTION__, validatedParams.pictureWidth,
1467 validatedParams.pictureHeight);
1468 return BAD_VALUE;
1469 }
1470 }
1471
1472 // JPEG_THUMBNAIL_WIDTH/HEIGHT
1473 validatedParams.jpegThumbSize[0] =
1474 newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH);
1475 validatedParams.jpegThumbSize[1] =
1476 newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT);
1477 if (validatedParams.jpegThumbSize[0] != jpegThumbSize[0] ||
1478 validatedParams.jpegThumbSize[1] != jpegThumbSize[1]) {
1479 camera_metadata_ro_entry_t availableJpegThumbSizes =
1480 staticInfo(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES);
1481 for (i = 0; i < availableJpegThumbSizes.count; i+=2) {
1482 if ((availableJpegThumbSizes.data.i32[i] ==
1483 validatedParams.jpegThumbSize[0]) &&
1484 (availableJpegThumbSizes.data.i32[i+1] ==
1485 validatedParams.jpegThumbSize[1])) break;
1486 }
1487 if (i == availableJpegThumbSizes.count) {
1488 ALOGE("%s: Requested JPEG thumbnail size %d x %d is not supported",
1489 __FUNCTION__, validatedParams.jpegThumbSize[0],
1490 validatedParams.jpegThumbSize[1]);
1491 return BAD_VALUE;
1492 }
1493 }
1494
1495 // JPEG_THUMBNAIL_QUALITY
1496 int quality = newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY);
1497 // also makes sure quality fits in uint8_t
1498 if (quality < 0 || quality > 100) {
1499 ALOGE("%s: Requested JPEG thumbnail quality %d is not supported",
1500 __FUNCTION__, quality);
1501 return BAD_VALUE;
1502 }
1503 validatedParams.jpegThumbQuality = quality;
1504
1505 // JPEG_QUALITY
1506 quality = newParams.getInt(CameraParameters::KEY_JPEG_QUALITY);
1507 // also makes sure quality fits in uint8_t
1508 if (quality < 0 || quality > 100) {
1509 ALOGE("%s: Requested JPEG quality %d is not supported",
1510 __FUNCTION__, quality);
1511 return BAD_VALUE;
1512 }
1513 validatedParams.jpegQuality = quality;
1514
1515 // ROTATION
1516 validatedParams.jpegRotation =
1517 newParams.getInt(CameraParameters::KEY_ROTATION);
1518 if (validatedParams.jpegRotation != 0 &&
1519 validatedParams.jpegRotation != 90 &&
1520 validatedParams.jpegRotation != 180 &&
1521 validatedParams.jpegRotation != 270) {
1522 ALOGE("%s: Requested picture rotation angle %d is not supported",
1523 __FUNCTION__, validatedParams.jpegRotation);
1524 return BAD_VALUE;
1525 }
1526
1527 // GPS
1528
1529 const char *gpsLatStr =
1530 newParams.get(CameraParameters::KEY_GPS_LATITUDE);
1531 if (gpsLatStr != NULL) {
1532 const char *gpsLongStr =
1533 newParams.get(CameraParameters::KEY_GPS_LONGITUDE);
1534 const char *gpsAltitudeStr =
1535 newParams.get(CameraParameters::KEY_GPS_ALTITUDE);
1536 const char *gpsTimeStr =
1537 newParams.get(CameraParameters::KEY_GPS_TIMESTAMP);
1538 const char *gpsProcMethodStr =
1539 newParams.get(CameraParameters::KEY_GPS_PROCESSING_METHOD);
1540 if (gpsLongStr == NULL ||
1541 gpsAltitudeStr == NULL ||
1542 gpsTimeStr == NULL ||
1543 gpsProcMethodStr == NULL) {
1544 ALOGE("%s: Incomplete set of GPS parameters provided",
1545 __FUNCTION__);
1546 return BAD_VALUE;
1547 }
1548 char *endPtr;
1549 errno = 0;
1550 validatedParams.gpsCoordinates[0] = strtod(gpsLatStr, &endPtr);
1551 if (errno || endPtr == gpsLatStr) {
1552 ALOGE("%s: Malformed GPS latitude: %s", __FUNCTION__, gpsLatStr);
1553 return BAD_VALUE;
1554 }
1555 errno = 0;
1556 validatedParams.gpsCoordinates[1] = strtod(gpsLongStr, &endPtr);
1557 if (errno || endPtr == gpsLongStr) {
1558 ALOGE("%s: Malformed GPS longitude: %s", __FUNCTION__, gpsLongStr);
1559 return BAD_VALUE;
1560 }
1561 errno = 0;
1562 validatedParams.gpsCoordinates[2] = strtod(gpsAltitudeStr, &endPtr);
1563 if (errno || endPtr == gpsAltitudeStr) {
1564 ALOGE("%s: Malformed GPS altitude: %s", __FUNCTION__,
1565 gpsAltitudeStr);
1566 return BAD_VALUE;
1567 }
1568 errno = 0;
1569 validatedParams.gpsTimestamp = strtoll(gpsTimeStr, &endPtr, 10);
1570 if (errno || endPtr == gpsTimeStr) {
1571 ALOGE("%s: Malformed GPS timestamp: %s", __FUNCTION__, gpsTimeStr);
1572 return BAD_VALUE;
1573 }
1574 validatedParams.gpsProcessingMethod = gpsProcMethodStr;
1575
1576 validatedParams.gpsEnabled = true;
1577 } else {
1578 validatedParams.gpsEnabled = false;
1579 }
1580
1581 // EFFECT
1582 validatedParams.effectMode = effectModeStringToEnum(
1583 newParams.get(CameraParameters::KEY_EFFECT) );
1584 if (validatedParams.effectMode != effectMode) {
1585 camera_metadata_ro_entry_t availableEffectModes =
1586 staticInfo(ANDROID_CONTROL_AVAILABLE_EFFECTS);
1587 for (i = 0; i < availableEffectModes.count; i++) {
1588 if (validatedParams.effectMode == availableEffectModes.data.u8[i]) break;
1589 }
1590 if (i == availableEffectModes.count) {
1591 ALOGE("%s: Requested effect mode \"%s\" is not supported",
1592 __FUNCTION__,
1593 newParams.get(CameraParameters::KEY_EFFECT) );
1594 return BAD_VALUE;
1595 }
1596 }
1597
1598 // ANTIBANDING
1599 validatedParams.antibandingMode = abModeStringToEnum(
1600 newParams.get(CameraParameters::KEY_ANTIBANDING) );
1601 if (validatedParams.antibandingMode != antibandingMode) {
1602 camera_metadata_ro_entry_t availableAbModes =
1603 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES);
1604 for (i = 0; i < availableAbModes.count; i++) {
1605 if (validatedParams.antibandingMode == availableAbModes.data.u8[i])
1606 break;
1607 }
1608 if (i == availableAbModes.count) {
1609 ALOGE("%s: Requested antibanding mode \"%s\" is not supported",
1610 __FUNCTION__,
1611 newParams.get(CameraParameters::KEY_ANTIBANDING));
1612 return BAD_VALUE;
1613 }
1614 }
1615
1616 // SCENE_MODE
1617 validatedParams.sceneMode = sceneModeStringToEnum(
1618 newParams.get(CameraParameters::KEY_SCENE_MODE) );
1619 if (validatedParams.sceneMode != sceneMode &&
1620 validatedParams.sceneMode !=
1621 ANDROID_CONTROL_SCENE_MODE_DISABLED) {
1622 camera_metadata_ro_entry_t availableSceneModes =
1623 staticInfo(ANDROID_CONTROL_AVAILABLE_SCENE_MODES);
1624 for (i = 0; i < availableSceneModes.count; i++) {
1625 if (validatedParams.sceneMode == availableSceneModes.data.u8[i])
1626 break;
1627 }
1628 if (i == availableSceneModes.count) {
1629 ALOGE("%s: Requested scene mode \"%s\" is not supported",
1630 __FUNCTION__,
1631 newParams.get(CameraParameters::KEY_SCENE_MODE));
1632 return BAD_VALUE;
1633 }
1634 }
1635 bool sceneModeSet =
1636 validatedParams.sceneMode != ANDROID_CONTROL_SCENE_MODE_DISABLED;
1637
1638 // FLASH_MODE
1639 if (sceneModeSet) {
1640 validatedParams.flashMode =
1641 fastInfo.sceneModeOverrides.
1642 valueFor(validatedParams.sceneMode).flashMode;
1643 } else {
1644 validatedParams.flashMode = FLASH_MODE_INVALID;
1645 }
1646 if (validatedParams.flashMode == FLASH_MODE_INVALID) {
1647 validatedParams.flashMode = flashModeStringToEnum(
1648 newParams.get(CameraParameters::KEY_FLASH_MODE) );
1649 }
1650
1651 if (validatedParams.flashMode != flashMode) {
1652 camera_metadata_ro_entry_t flashAvailable =
1653 staticInfo(ANDROID_FLASH_INFO_AVAILABLE, 1, 1);
1654 bool isFlashAvailable =
1655 flashAvailable.data.u8[0] == ANDROID_FLASH_INFO_AVAILABLE_TRUE;
1656 if (!isFlashAvailable &&
1657 validatedParams.flashMode != Parameters::FLASH_MODE_OFF) {
1658 ALOGE("%s: Requested flash mode \"%s\" is not supported: "
1659 "No flash on device", __FUNCTION__,
1660 newParams.get(CameraParameters::KEY_FLASH_MODE));
1661 return BAD_VALUE;
1662 } else if (validatedParams.flashMode == Parameters::FLASH_MODE_RED_EYE) {
1663 camera_metadata_ro_entry_t availableAeModes =
1664 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_MODES);
1665 for (i = 0; i < availableAeModes.count; i++) {
1666 if (validatedParams.flashMode == availableAeModes.data.u8[i])
1667 break;
1668 }
1669 if (i == availableAeModes.count) {
1670 ALOGE("%s: Requested flash mode \"%s\" is not supported",
1671 __FUNCTION__,
1672 newParams.get(CameraParameters::KEY_FLASH_MODE));
1673 return BAD_VALUE;
1674 }
1675 } else if (validatedParams.flashMode == -1) {
1676 ALOGE("%s: Requested flash mode \"%s\" is unknown",
1677 __FUNCTION__,
1678 newParams.get(CameraParameters::KEY_FLASH_MODE));
1679 return BAD_VALUE;
1680 }
1681 // Update in case of override, but only if flash is supported
1682 if (isFlashAvailable) {
1683 newParams.set(CameraParameters::KEY_FLASH_MODE,
1684 flashModeEnumToString(validatedParams.flashMode));
1685 }
1686 }
1687
1688 // WHITE_BALANCE
1689 if (sceneModeSet) {
1690 validatedParams.wbMode =
1691 fastInfo.sceneModeOverrides.
1692 valueFor(validatedParams.sceneMode).wbMode;
1693 } else {
1694 validatedParams.wbMode = ANDROID_CONTROL_AWB_MODE_OFF;
1695 }
1696 if (validatedParams.wbMode == ANDROID_CONTROL_AWB_MODE_OFF) {
1697 validatedParams.wbMode = wbModeStringToEnum(
1698 newParams.get(CameraParameters::KEY_WHITE_BALANCE) );
1699 }
1700 if (validatedParams.wbMode != wbMode) {
1701 camera_metadata_ro_entry_t availableWbModes =
1702 staticInfo(ANDROID_CONTROL_AWB_AVAILABLE_MODES, 0, 0, false);
1703 for (i = 0; i < availableWbModes.count; i++) {
1704 if (validatedParams.wbMode == availableWbModes.data.u8[i]) break;
1705 }
1706 if (i == availableWbModes.count) {
1707 ALOGE("%s: Requested white balance mode %s is not supported",
1708 __FUNCTION__,
1709 newParams.get(CameraParameters::KEY_WHITE_BALANCE));
1710 return BAD_VALUE;
1711 }
1712 // Update in case of override
1713 newParams.set(CameraParameters::KEY_WHITE_BALANCE,
1714 wbModeEnumToString(validatedParams.wbMode));
1715 }
1716
1717 // FOCUS_MODE
1718 if (sceneModeSet) {
1719 validatedParams.focusMode =
1720 fastInfo.sceneModeOverrides.
1721 valueFor(validatedParams.sceneMode).focusMode;
1722 } else {
1723 validatedParams.focusMode = FOCUS_MODE_INVALID;
1724 }
1725 if (validatedParams.focusMode == FOCUS_MODE_INVALID) {
1726 validatedParams.focusMode = focusModeStringToEnum(
1727 newParams.get(CameraParameters::KEY_FOCUS_MODE) );
1728 }
1729 if (validatedParams.focusMode != focusMode) {
1730 validatedParams.currentAfTriggerId = -1;
1731 if (validatedParams.focusMode != Parameters::FOCUS_MODE_FIXED) {
1732 camera_metadata_ro_entry_t minFocusDistance =
1733 staticInfo(ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE, 0, 0,
1734 false);
1735 if (minFocusDistance.count && minFocusDistance.data.f[0] == 0) {
1736 ALOGE("%s: Requested focus mode \"%s\" is not available: "
1737 "fixed focus lens",
1738 __FUNCTION__,
1739 newParams.get(CameraParameters::KEY_FOCUS_MODE));
1740 return BAD_VALUE;
1741 } else if (validatedParams.focusMode !=
1742 Parameters::FOCUS_MODE_INFINITY) {
1743 camera_metadata_ro_entry_t availableFocusModes =
1744 staticInfo(ANDROID_CONTROL_AF_AVAILABLE_MODES);
1745 for (i = 0; i < availableFocusModes.count; i++) {
1746 if (validatedParams.focusMode ==
1747 availableFocusModes.data.u8[i]) break;
1748 }
1749 if (i == availableFocusModes.count) {
1750 ALOGE("%s: Requested focus mode \"%s\" is not supported",
1751 __FUNCTION__,
1752 newParams.get(CameraParameters::KEY_FOCUS_MODE));
1753 return BAD_VALUE;
1754 }
1755 }
1756 }
1757 validatedParams.focusState = ANDROID_CONTROL_AF_STATE_INACTIVE;
1758 // Always reset shadow focus mode to avoid reverting settings
1759 validatedParams.shadowFocusMode = FOCUS_MODE_INVALID;
1760 // Update in case of override
1761 newParams.set(CameraParameters::KEY_FOCUS_MODE,
1762 focusModeEnumToString(validatedParams.focusMode));
1763 } else {
1764 validatedParams.currentAfTriggerId = currentAfTriggerId;
1765 }
1766
1767 // FOCUS_AREAS
1768 res = parseAreas(newParams.get(CameraParameters::KEY_FOCUS_AREAS),
1769 &validatedParams.focusingAreas);
1770 size_t maxAfRegions = (size_t)staticInfo(ANDROID_CONTROL_MAX_REGIONS,
1771 Parameters::NUM_REGION, Parameters::NUM_REGION).
1772 data.i32[Parameters::REGION_AF];
1773 if (res == OK) res = validateAreas(validatedParams.focusingAreas,
1774 maxAfRegions, AREA_KIND_FOCUS);
1775 if (res != OK) {
1776 ALOGE("%s: Requested focus areas are malformed: %s",
1777 __FUNCTION__, newParams.get(CameraParameters::KEY_FOCUS_AREAS));
1778 return BAD_VALUE;
1779 }
1780
1781 // EXPOSURE_COMPENSATION
1782 validatedParams.exposureCompensation =
1783 newParams.getInt(CameraParameters::KEY_EXPOSURE_COMPENSATION);
1784 camera_metadata_ro_entry_t exposureCompensationRange =
1785 staticInfo(ANDROID_CONTROL_AE_COMPENSATION_RANGE);
1786 if ((validatedParams.exposureCompensation <
1787 exposureCompensationRange.data.i32[0]) ||
1788 (validatedParams.exposureCompensation >
1789 exposureCompensationRange.data.i32[1])) {
1790 ALOGE("%s: Requested exposure compensation index is out of bounds: %d",
1791 __FUNCTION__, validatedParams.exposureCompensation);
1792 return BAD_VALUE;
1793 }
1794
1795 // AUTO_EXPOSURE_LOCK (always supported)
1796 validatedParams.autoExposureLock = boolFromString(
1797 newParams.get(CameraParameters::KEY_AUTO_EXPOSURE_LOCK));
1798
1799 // AUTO_WHITEBALANCE_LOCK (always supported)
1800 validatedParams.autoWhiteBalanceLock = boolFromString(
1801 newParams.get(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK));
1802
1803 // METERING_AREAS
1804 size_t maxAeRegions = (size_t)staticInfo(ANDROID_CONTROL_MAX_REGIONS,
1805 Parameters::NUM_REGION, Parameters::NUM_REGION).
1806 data.i32[Parameters::REGION_AE];
1807 res = parseAreas(newParams.get(CameraParameters::KEY_METERING_AREAS),
1808 &validatedParams.meteringAreas);
1809 if (res == OK) {
1810 res = validateAreas(validatedParams.meteringAreas, maxAeRegions,
1811 AREA_KIND_METERING);
1812 }
1813 if (res != OK) {
1814 ALOGE("%s: Requested metering areas are malformed: %s",
1815 __FUNCTION__,
1816 newParams.get(CameraParameters::KEY_METERING_AREAS));
1817 return BAD_VALUE;
1818 }
1819
1820 // ZOOM
1821 validatedParams.zoom = newParams.getInt(CameraParameters::KEY_ZOOM);
1822 if (validatedParams.zoom < 0
1823 || validatedParams.zoom >= (int)NUM_ZOOM_STEPS) {
1824 ALOGE("%s: Requested zoom level %d is not supported",
1825 __FUNCTION__, validatedParams.zoom);
1826 return BAD_VALUE;
1827 }
1828
1829 // VIDEO_SIZE
1830 newParams.getVideoSize(&validatedParams.videoWidth,
1831 &validatedParams.videoHeight);
1832 if (validatedParams.videoWidth != videoWidth ||
1833 validatedParams.videoHeight != videoHeight) {
1834 if (state == RECORD) {
1835 ALOGW("%s: Video size cannot be updated (from %d x %d to %d x %d)"
1836 " when recording is active! Ignore the size update!",
1837 __FUNCTION__, videoWidth, videoHeight, validatedParams.videoWidth,
1838 validatedParams.videoHeight);
1839 validatedParams.videoWidth = videoWidth;
1840 validatedParams.videoHeight = videoHeight;
1841 newParams.setVideoSize(videoWidth, videoHeight);
1842 } else {
1843 for (i = 0; i < availableVideoSizes.size(); i++) {
1844 if ((availableVideoSizes[i].width ==
1845 validatedParams.videoWidth) &&
1846 (availableVideoSizes[i].height ==
1847 validatedParams.videoHeight)) break;
1848 }
1849 if (i == availableVideoSizes.size()) {
1850 ALOGE("%s: Requested video size %d x %d is not supported",
1851 __FUNCTION__, validatedParams.videoWidth,
1852 validatedParams.videoHeight);
1853 return BAD_VALUE;
1854 }
1855 }
1856 }
1857
1858 // VIDEO_STABILIZATION
1859 validatedParams.videoStabilization = boolFromString(
1860 newParams.get(CameraParameters::KEY_VIDEO_STABILIZATION) );
1861 camera_metadata_ro_entry_t availableVideoStabilizationModes =
1862 staticInfo(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES, 0, 0,
1863 false);
1864 if (validatedParams.videoStabilization &&
1865 availableVideoStabilizationModes.count == 1) {
1866 ALOGE("%s: Video stabilization not supported", __FUNCTION__);
1867 }
1868
1869 /** Update internal parameters */
1870
1871 *this = validatedParams;
1872 updateOverriddenJpegSize();
1873
1874 /** Update external parameters calculated from the internal ones */
1875
1876 // HORIZONTAL/VERTICAL FIELD OF VIEW
1877 float horizFov, vertFov;
1878 res = calculatePictureFovs(&horizFov, &vertFov);
1879 if (res != OK) {
1880 ALOGE("%s: Can't calculate FOVs", __FUNCTION__);
1881 // continue so parameters are at least consistent
1882 }
1883 newParams.setFloat(CameraParameters::KEY_HORIZONTAL_VIEW_ANGLE,
1884 horizFov);
1885 newParams.setFloat(CameraParameters::KEY_VERTICAL_VIEW_ANGLE,
1886 vertFov);
1887 ALOGV("Current still picture FOV: %f x %f deg", horizFov, vertFov);
1888
1889 // Need to flatten again in case of overrides
1890 paramsFlattened = newParams.flatten();
1891 params = newParams;
1892
1893 return OK;
1894 }
1895
updateRequest(CameraMetadata * request) const1896 status_t Parameters::updateRequest(CameraMetadata *request) const {
1897 ATRACE_CALL();
1898 status_t res;
1899
1900 /**
1901 * Mixin default important security values
1902 * - android.led.transmit = defaulted ON
1903 */
1904 camera_metadata_ro_entry_t entry = staticInfo(ANDROID_LED_AVAILABLE_LEDS,
1905 /*minimumCount*/0,
1906 /*maximumCount*/0,
1907 /*required*/false);
1908 for(size_t i = 0; i < entry.count; ++i) {
1909 uint8_t led = entry.data.u8[i];
1910
1911 switch(led) {
1912 // Transmit LED is unconditionally on when using
1913 // the android.hardware.Camera API
1914 case ANDROID_LED_AVAILABLE_LEDS_TRANSMIT: {
1915 uint8_t transmitDefault = ANDROID_LED_TRANSMIT_ON;
1916 res = request->update(ANDROID_LED_TRANSMIT,
1917 &transmitDefault, 1);
1918 if (res != OK) return res;
1919 break;
1920 }
1921 }
1922 }
1923
1924 /**
1925 * Construct metadata from parameters
1926 */
1927
1928 uint8_t metadataMode = ANDROID_REQUEST_METADATA_MODE_FULL;
1929 res = request->update(ANDROID_REQUEST_METADATA_MODE,
1930 &metadataMode, 1);
1931 if (res != OK) return res;
1932
1933 camera_metadata_entry_t intent =
1934 request->find(ANDROID_CONTROL_CAPTURE_INTENT);
1935
1936 if (intent.count == 0) return BAD_VALUE;
1937
1938 if (intent.data.u8[0] == ANDROID_CONTROL_CAPTURE_INTENT_STILL_CAPTURE) {
1939 res = request->update(ANDROID_CONTROL_AE_TARGET_FPS_RANGE,
1940 fastInfo.bestStillCaptureFpsRange, 2);
1941 } else {
1942 res = request->update(ANDROID_CONTROL_AE_TARGET_FPS_RANGE,
1943 previewFpsRange, 2);
1944 }
1945 if (res != OK) return res;
1946
1947 uint8_t reqWbLock = autoWhiteBalanceLock ?
1948 ANDROID_CONTROL_AWB_LOCK_ON : ANDROID_CONTROL_AWB_LOCK_OFF;
1949 res = request->update(ANDROID_CONTROL_AWB_LOCK,
1950 &reqWbLock, 1);
1951
1952 res = request->update(ANDROID_CONTROL_EFFECT_MODE,
1953 &effectMode, 1);
1954 if (res != OK) return res;
1955 res = request->update(ANDROID_CONTROL_AE_ANTIBANDING_MODE,
1956 &antibandingMode, 1);
1957 if (res != OK) return res;
1958
1959 // android.hardware.Camera requires that when face detect is enabled, the
1960 // camera is in a face-priority mode. HAL3.x splits this into separate parts
1961 // (face detection statistics and face priority scene mode). Map from other
1962 // to the other.
1963 bool sceneModeActive =
1964 sceneMode != (uint8_t)ANDROID_CONTROL_SCENE_MODE_DISABLED;
1965 uint8_t reqControlMode = ANDROID_CONTROL_MODE_AUTO;
1966 if (enableFaceDetect || sceneModeActive) {
1967 reqControlMode = ANDROID_CONTROL_MODE_USE_SCENE_MODE;
1968 }
1969 res = request->update(ANDROID_CONTROL_MODE,
1970 &reqControlMode, 1);
1971 if (res != OK) return res;
1972
1973 uint8_t reqSceneMode =
1974 sceneModeActive ? sceneMode :
1975 enableFaceDetect ? (uint8_t)ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY :
1976 (uint8_t)ANDROID_CONTROL_SCENE_MODE_DISABLED;
1977 res = request->update(ANDROID_CONTROL_SCENE_MODE,
1978 &reqSceneMode, 1);
1979 if (res != OK) return res;
1980
1981 uint8_t reqFlashMode = ANDROID_FLASH_MODE_OFF;
1982 uint8_t reqAeMode = ANDROID_CONTROL_AE_MODE_OFF;
1983 switch (flashMode) {
1984 case Parameters::FLASH_MODE_OFF:
1985 reqAeMode = ANDROID_CONTROL_AE_MODE_ON; break;
1986 case Parameters::FLASH_MODE_AUTO:
1987 reqAeMode = ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH; break;
1988 case Parameters::FLASH_MODE_ON:
1989 reqAeMode = ANDROID_CONTROL_AE_MODE_ON_ALWAYS_FLASH; break;
1990 case Parameters::FLASH_MODE_TORCH:
1991 reqAeMode = ANDROID_CONTROL_AE_MODE_ON;
1992 reqFlashMode = ANDROID_FLASH_MODE_TORCH;
1993 break;
1994 case Parameters::FLASH_MODE_RED_EYE:
1995 reqAeMode = ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH_REDEYE; break;
1996 default:
1997 ALOGE("%s: Camera %d: Unknown flash mode %d", __FUNCTION__,
1998 cameraId, flashMode);
1999 return BAD_VALUE;
2000 }
2001 res = request->update(ANDROID_FLASH_MODE,
2002 &reqFlashMode, 1);
2003 if (res != OK) return res;
2004 res = request->update(ANDROID_CONTROL_AE_MODE,
2005 &reqAeMode, 1);
2006 if (res != OK) return res;
2007
2008 uint8_t reqAeLock = autoExposureLock ?
2009 ANDROID_CONTROL_AE_LOCK_ON : ANDROID_CONTROL_AE_LOCK_OFF;
2010 res = request->update(ANDROID_CONTROL_AE_LOCK,
2011 &reqAeLock, 1);
2012 if (res != OK) return res;
2013
2014 res = request->update(ANDROID_CONTROL_AWB_MODE,
2015 &wbMode, 1);
2016 if (res != OK) return res;
2017
2018 float reqFocusDistance = 0; // infinity focus in diopters
2019 uint8_t reqFocusMode = ANDROID_CONTROL_AF_MODE_OFF;
2020 switch (focusMode) {
2021 case Parameters::FOCUS_MODE_AUTO:
2022 case Parameters::FOCUS_MODE_MACRO:
2023 case Parameters::FOCUS_MODE_CONTINUOUS_VIDEO:
2024 case Parameters::FOCUS_MODE_CONTINUOUS_PICTURE:
2025 case Parameters::FOCUS_MODE_EDOF:
2026 reqFocusMode = focusMode;
2027 break;
2028 case Parameters::FOCUS_MODE_INFINITY:
2029 case Parameters::FOCUS_MODE_FIXED:
2030 reqFocusMode = ANDROID_CONTROL_AF_MODE_OFF;
2031 break;
2032 default:
2033 ALOGE("%s: Camera %d: Unknown focus mode %d", __FUNCTION__,
2034 cameraId, focusMode);
2035 return BAD_VALUE;
2036 }
2037 res = request->update(ANDROID_LENS_FOCUS_DISTANCE,
2038 &reqFocusDistance, 1);
2039 if (res != OK) return res;
2040 res = request->update(ANDROID_CONTROL_AF_MODE,
2041 &reqFocusMode, 1);
2042 if (res != OK) return res;
2043
2044 size_t reqFocusingAreasSize = focusingAreas.size() * 5;
2045 int32_t *reqFocusingAreas = new int32_t[reqFocusingAreasSize];
2046 for (size_t i = 0, j = 0; i < reqFocusingAreasSize; i += 5, j++) {
2047 if (focusingAreas[j].weight != 0) {
2048 reqFocusingAreas[i + 0] =
2049 normalizedXToArray(focusingAreas[j].left);
2050 reqFocusingAreas[i + 1] =
2051 normalizedYToArray(focusingAreas[j].top);
2052 reqFocusingAreas[i + 2] =
2053 normalizedXToArray(focusingAreas[j].right);
2054 reqFocusingAreas[i + 3] =
2055 normalizedYToArray(focusingAreas[j].bottom);
2056 } else {
2057 reqFocusingAreas[i + 0] = 0;
2058 reqFocusingAreas[i + 1] = 0;
2059 reqFocusingAreas[i + 2] = 0;
2060 reqFocusingAreas[i + 3] = 0;
2061 }
2062 reqFocusingAreas[i + 4] = focusingAreas[j].weight;
2063 }
2064 res = request->update(ANDROID_CONTROL_AF_REGIONS,
2065 reqFocusingAreas, reqFocusingAreasSize);
2066 if (res != OK) return res;
2067 delete[] reqFocusingAreas;
2068
2069 res = request->update(ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION,
2070 &exposureCompensation, 1);
2071 if (res != OK) return res;
2072
2073 size_t reqMeteringAreasSize = meteringAreas.size() * 5;
2074 int32_t *reqMeteringAreas = new int32_t[reqMeteringAreasSize];
2075 for (size_t i = 0, j = 0; i < reqMeteringAreasSize; i += 5, j++) {
2076 if (meteringAreas[j].weight != 0) {
2077 reqMeteringAreas[i + 0] =
2078 normalizedXToArray(meteringAreas[j].left);
2079 reqMeteringAreas[i + 1] =
2080 normalizedYToArray(meteringAreas[j].top);
2081 reqMeteringAreas[i + 2] =
2082 normalizedXToArray(meteringAreas[j].right);
2083 reqMeteringAreas[i + 3] =
2084 normalizedYToArray(meteringAreas[j].bottom);
2085 } else {
2086 reqMeteringAreas[i + 0] = 0;
2087 reqMeteringAreas[i + 1] = 0;
2088 reqMeteringAreas[i + 2] = 0;
2089 reqMeteringAreas[i + 3] = 0;
2090 }
2091 reqMeteringAreas[i + 4] = meteringAreas[j].weight;
2092 }
2093 res = request->update(ANDROID_CONTROL_AE_REGIONS,
2094 reqMeteringAreas, reqMeteringAreasSize);
2095 if (res != OK) return res;
2096
2097 // Set awb regions to be the same as the metering regions if allowed
2098 size_t maxAwbRegions = (size_t)staticInfo(ANDROID_CONTROL_MAX_REGIONS,
2099 Parameters::NUM_REGION, Parameters::NUM_REGION).
2100 data.i32[Parameters::REGION_AWB];
2101 if (maxAwbRegions > 0) {
2102 if (maxAwbRegions >= meteringAreas.size()) {
2103 res = request->update(ANDROID_CONTROL_AWB_REGIONS,
2104 reqMeteringAreas, reqMeteringAreasSize);
2105 } else {
2106 // Ensure the awb regions are zeroed if the region count is too high.
2107 int32_t zeroedAwbAreas[5] = {0, 0, 0, 0, 0};
2108 res = request->update(ANDROID_CONTROL_AWB_REGIONS,
2109 zeroedAwbAreas, sizeof(zeroedAwbAreas)/sizeof(int32_t));
2110 }
2111 if (res != OK) return res;
2112 }
2113
2114 delete[] reqMeteringAreas;
2115
2116 CropRegion crop = calculateCropRegion(/*previewOnly*/ false);
2117 int32_t reqCropRegion[4] = {
2118 static_cast<int32_t>(crop.left),
2119 static_cast<int32_t>(crop.top),
2120 static_cast<int32_t>(crop.width),
2121 static_cast<int32_t>(crop.height)
2122 };
2123 res = request->update(ANDROID_SCALER_CROP_REGION,
2124 reqCropRegion, 4);
2125 if (res != OK) return res;
2126
2127 uint8_t reqVstabMode = videoStabilization ?
2128 ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_ON :
2129 ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF;
2130 res = request->update(ANDROID_CONTROL_VIDEO_STABILIZATION_MODE,
2131 &reqVstabMode, 1);
2132 if (res != OK) return res;
2133
2134 uint8_t reqFaceDetectMode = enableFaceDetect ?
2135 fastInfo.bestFaceDetectMode :
2136 (uint8_t)ANDROID_STATISTICS_FACE_DETECT_MODE_OFF;
2137 res = request->update(ANDROID_STATISTICS_FACE_DETECT_MODE,
2138 &reqFaceDetectMode, 1);
2139 if (res != OK) return res;
2140
2141 return OK;
2142 }
2143
updateRequestJpeg(CameraMetadata * request) const2144 status_t Parameters::updateRequestJpeg(CameraMetadata *request) const {
2145 status_t res;
2146
2147 res = request->update(ANDROID_JPEG_THUMBNAIL_SIZE,
2148 jpegThumbSize, 2);
2149 if (res != OK) return res;
2150 res = request->update(ANDROID_JPEG_THUMBNAIL_QUALITY,
2151 &jpegThumbQuality, 1);
2152 if (res != OK) return res;
2153 res = request->update(ANDROID_JPEG_QUALITY,
2154 &jpegQuality, 1);
2155 if (res != OK) return res;
2156 res = request->update(
2157 ANDROID_JPEG_ORIENTATION,
2158 &jpegRotation, 1);
2159 if (res != OK) return res;
2160
2161 if (gpsEnabled) {
2162 res = request->update(
2163 ANDROID_JPEG_GPS_COORDINATES,
2164 gpsCoordinates, 3);
2165 if (res != OK) return res;
2166 res = request->update(
2167 ANDROID_JPEG_GPS_TIMESTAMP,
2168 &gpsTimestamp, 1);
2169 if (res != OK) return res;
2170 res = request->update(
2171 ANDROID_JPEG_GPS_PROCESSING_METHOD,
2172 gpsProcessingMethod);
2173 if (res != OK) return res;
2174 } else {
2175 res = request->erase(ANDROID_JPEG_GPS_COORDINATES);
2176 if (res != OK) return res;
2177 res = request->erase(ANDROID_JPEG_GPS_TIMESTAMP);
2178 if (res != OK) return res;
2179 res = request->erase(ANDROID_JPEG_GPS_PROCESSING_METHOD);
2180 if (res != OK) return res;
2181 }
2182 return OK;
2183 }
2184
overrideJpegSizeByVideoSize()2185 status_t Parameters::overrideJpegSizeByVideoSize() {
2186 if (pictureSizeOverriden) {
2187 ALOGV("Picture size has been overridden. Skip overriding");
2188 return OK;
2189 }
2190
2191 pictureSizeOverriden = true;
2192 pictureWidthLastSet = pictureWidth;
2193 pictureHeightLastSet = pictureHeight;
2194 pictureWidth = videoWidth;
2195 pictureHeight = videoHeight;
2196 // This change of picture size is invisible to app layer.
2197 // Do not update app visible params
2198 return OK;
2199 }
2200
updateOverriddenJpegSize()2201 status_t Parameters::updateOverriddenJpegSize() {
2202 if (!pictureSizeOverriden) {
2203 ALOGV("Picture size has not been overridden. Skip checking");
2204 return OK;
2205 }
2206
2207 pictureWidthLastSet = pictureWidth;
2208 pictureHeightLastSet = pictureHeight;
2209
2210 if (pictureWidth <= videoWidth && pictureHeight <= videoHeight) {
2211 // Picture size is now smaller than video size. No need to override anymore
2212 return recoverOverriddenJpegSize();
2213 }
2214
2215 pictureWidth = videoWidth;
2216 pictureHeight = videoHeight;
2217
2218 return OK;
2219 }
2220
recoverOverriddenJpegSize()2221 status_t Parameters::recoverOverriddenJpegSize() {
2222 if (!pictureSizeOverriden) {
2223 ALOGV("Picture size has not been overridden. Skip recovering");
2224 return OK;
2225 }
2226 pictureSizeOverriden = false;
2227 pictureWidth = pictureWidthLastSet;
2228 pictureHeight = pictureHeightLastSet;
2229 return OK;
2230 }
2231
isJpegSizeOverridden()2232 bool Parameters::isJpegSizeOverridden() {
2233 return pictureSizeOverriden;
2234 }
2235
useZeroShutterLag() const2236 bool Parameters::useZeroShutterLag() const {
2237 // If ZSL mode is disabled, don't use it
2238 if (!allowZslMode) return false;
2239 // If recording hint is enabled, don't do ZSL
2240 if (recordingHint) return false;
2241 // If still capture size is no bigger than preview or video size,
2242 // don't do ZSL
2243 if (pictureWidth <= previewWidth || pictureHeight <= previewHeight ||
2244 pictureWidth <= videoWidth || pictureHeight <= videoHeight) {
2245 return false;
2246 }
2247 // If still capture size is less than quarter of max, don't do ZSL
2248 if ((pictureWidth * pictureHeight) <
2249 (fastInfo.maxJpegSize.width * fastInfo.maxJpegSize.height / 4) ) {
2250 return false;
2251 }
2252 return true;
2253 }
2254
getStateName(State state)2255 const char* Parameters::getStateName(State state) {
2256 #define CASE_ENUM_TO_CHAR(x) case x: return(#x); break;
2257 switch(state) {
2258 CASE_ENUM_TO_CHAR(DISCONNECTED)
2259 CASE_ENUM_TO_CHAR(STOPPED)
2260 CASE_ENUM_TO_CHAR(WAITING_FOR_PREVIEW_WINDOW)
2261 CASE_ENUM_TO_CHAR(PREVIEW)
2262 CASE_ENUM_TO_CHAR(RECORD)
2263 CASE_ENUM_TO_CHAR(STILL_CAPTURE)
2264 CASE_ENUM_TO_CHAR(VIDEO_SNAPSHOT)
2265 default:
2266 return "Unknown state!";
2267 break;
2268 }
2269 #undef CASE_ENUM_TO_CHAR
2270 }
2271
formatStringToEnum(const char * format)2272 int Parameters::formatStringToEnum(const char *format) {
2273 return CameraParameters::previewFormatToEnum(format);
2274 }
2275
formatEnumToString(int format)2276 const char* Parameters::formatEnumToString(int format) {
2277 const char *fmt;
2278 switch(format) {
2279 case HAL_PIXEL_FORMAT_YCbCr_422_SP: // NV16
2280 fmt = CameraParameters::PIXEL_FORMAT_YUV422SP;
2281 break;
2282 case HAL_PIXEL_FORMAT_YCrCb_420_SP: // NV21
2283 fmt = CameraParameters::PIXEL_FORMAT_YUV420SP;
2284 break;
2285 case HAL_PIXEL_FORMAT_YCbCr_422_I: // YUY2
2286 fmt = CameraParameters::PIXEL_FORMAT_YUV422I;
2287 break;
2288 case HAL_PIXEL_FORMAT_YV12: // YV12
2289 fmt = CameraParameters::PIXEL_FORMAT_YUV420P;
2290 break;
2291 case HAL_PIXEL_FORMAT_RGB_565: // RGB565
2292 fmt = CameraParameters::PIXEL_FORMAT_RGB565;
2293 break;
2294 case HAL_PIXEL_FORMAT_RGBA_8888: // RGBA8888
2295 fmt = CameraParameters::PIXEL_FORMAT_RGBA8888;
2296 break;
2297 case HAL_PIXEL_FORMAT_RAW16:
2298 ALOGW("Raw sensor preview format requested.");
2299 fmt = CameraParameters::PIXEL_FORMAT_BAYER_RGGB;
2300 break;
2301 default:
2302 ALOGE("%s: Unknown preview format: %x",
2303 __FUNCTION__, format);
2304 fmt = NULL;
2305 break;
2306 }
2307 return fmt;
2308 }
2309
wbModeStringToEnum(const char * wbMode)2310 int Parameters::wbModeStringToEnum(const char *wbMode) {
2311 return
2312 !wbMode ?
2313 ANDROID_CONTROL_AWB_MODE_AUTO :
2314 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_AUTO) ?
2315 ANDROID_CONTROL_AWB_MODE_AUTO :
2316 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_INCANDESCENT) ?
2317 ANDROID_CONTROL_AWB_MODE_INCANDESCENT :
2318 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_FLUORESCENT) ?
2319 ANDROID_CONTROL_AWB_MODE_FLUORESCENT :
2320 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_WARM_FLUORESCENT) ?
2321 ANDROID_CONTROL_AWB_MODE_WARM_FLUORESCENT :
2322 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_DAYLIGHT) ?
2323 ANDROID_CONTROL_AWB_MODE_DAYLIGHT :
2324 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT) ?
2325 ANDROID_CONTROL_AWB_MODE_CLOUDY_DAYLIGHT :
2326 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_TWILIGHT) ?
2327 ANDROID_CONTROL_AWB_MODE_TWILIGHT :
2328 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_SHADE) ?
2329 ANDROID_CONTROL_AWB_MODE_SHADE :
2330 -1;
2331 }
2332
wbModeEnumToString(uint8_t wbMode)2333 const char* Parameters::wbModeEnumToString(uint8_t wbMode) {
2334 switch (wbMode) {
2335 case ANDROID_CONTROL_AWB_MODE_AUTO:
2336 return CameraParameters::WHITE_BALANCE_AUTO;
2337 case ANDROID_CONTROL_AWB_MODE_INCANDESCENT:
2338 return CameraParameters::WHITE_BALANCE_INCANDESCENT;
2339 case ANDROID_CONTROL_AWB_MODE_FLUORESCENT:
2340 return CameraParameters::WHITE_BALANCE_FLUORESCENT;
2341 case ANDROID_CONTROL_AWB_MODE_WARM_FLUORESCENT:
2342 return CameraParameters::WHITE_BALANCE_WARM_FLUORESCENT;
2343 case ANDROID_CONTROL_AWB_MODE_DAYLIGHT:
2344 return CameraParameters::WHITE_BALANCE_DAYLIGHT;
2345 case ANDROID_CONTROL_AWB_MODE_CLOUDY_DAYLIGHT:
2346 return CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT;
2347 case ANDROID_CONTROL_AWB_MODE_TWILIGHT:
2348 return CameraParameters::WHITE_BALANCE_TWILIGHT;
2349 case ANDROID_CONTROL_AWB_MODE_SHADE:
2350 return CameraParameters::WHITE_BALANCE_SHADE;
2351 default:
2352 ALOGE("%s: Unknown AWB mode enum: %d",
2353 __FUNCTION__, wbMode);
2354 return "unknown";
2355 }
2356 }
2357
effectModeStringToEnum(const char * effectMode)2358 int Parameters::effectModeStringToEnum(const char *effectMode) {
2359 return
2360 !effectMode ?
2361 ANDROID_CONTROL_EFFECT_MODE_OFF :
2362 !strcmp(effectMode, CameraParameters::EFFECT_NONE) ?
2363 ANDROID_CONTROL_EFFECT_MODE_OFF :
2364 !strcmp(effectMode, CameraParameters::EFFECT_MONO) ?
2365 ANDROID_CONTROL_EFFECT_MODE_MONO :
2366 !strcmp(effectMode, CameraParameters::EFFECT_NEGATIVE) ?
2367 ANDROID_CONTROL_EFFECT_MODE_NEGATIVE :
2368 !strcmp(effectMode, CameraParameters::EFFECT_SOLARIZE) ?
2369 ANDROID_CONTROL_EFFECT_MODE_SOLARIZE :
2370 !strcmp(effectMode, CameraParameters::EFFECT_SEPIA) ?
2371 ANDROID_CONTROL_EFFECT_MODE_SEPIA :
2372 !strcmp(effectMode, CameraParameters::EFFECT_POSTERIZE) ?
2373 ANDROID_CONTROL_EFFECT_MODE_POSTERIZE :
2374 !strcmp(effectMode, CameraParameters::EFFECT_WHITEBOARD) ?
2375 ANDROID_CONTROL_EFFECT_MODE_WHITEBOARD :
2376 !strcmp(effectMode, CameraParameters::EFFECT_BLACKBOARD) ?
2377 ANDROID_CONTROL_EFFECT_MODE_BLACKBOARD :
2378 !strcmp(effectMode, CameraParameters::EFFECT_AQUA) ?
2379 ANDROID_CONTROL_EFFECT_MODE_AQUA :
2380 -1;
2381 }
2382
abModeStringToEnum(const char * abMode)2383 int Parameters::abModeStringToEnum(const char *abMode) {
2384 return
2385 !abMode ?
2386 ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO :
2387 !strcmp(abMode, CameraParameters::ANTIBANDING_AUTO) ?
2388 ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO :
2389 !strcmp(abMode, CameraParameters::ANTIBANDING_OFF) ?
2390 ANDROID_CONTROL_AE_ANTIBANDING_MODE_OFF :
2391 !strcmp(abMode, CameraParameters::ANTIBANDING_50HZ) ?
2392 ANDROID_CONTROL_AE_ANTIBANDING_MODE_50HZ :
2393 !strcmp(abMode, CameraParameters::ANTIBANDING_60HZ) ?
2394 ANDROID_CONTROL_AE_ANTIBANDING_MODE_60HZ :
2395 -1;
2396 }
2397
sceneModeStringToEnum(const char * sceneMode)2398 int Parameters::sceneModeStringToEnum(const char *sceneMode) {
2399 return
2400 !sceneMode ?
2401 ANDROID_CONTROL_SCENE_MODE_DISABLED :
2402 !strcmp(sceneMode, CameraParameters::SCENE_MODE_AUTO) ?
2403 ANDROID_CONTROL_SCENE_MODE_DISABLED :
2404 !strcmp(sceneMode, CameraParameters::SCENE_MODE_ACTION) ?
2405 ANDROID_CONTROL_SCENE_MODE_ACTION :
2406 !strcmp(sceneMode, CameraParameters::SCENE_MODE_PORTRAIT) ?
2407 ANDROID_CONTROL_SCENE_MODE_PORTRAIT :
2408 !strcmp(sceneMode, CameraParameters::SCENE_MODE_LANDSCAPE) ?
2409 ANDROID_CONTROL_SCENE_MODE_LANDSCAPE :
2410 !strcmp(sceneMode, CameraParameters::SCENE_MODE_NIGHT) ?
2411 ANDROID_CONTROL_SCENE_MODE_NIGHT :
2412 !strcmp(sceneMode, CameraParameters::SCENE_MODE_NIGHT_PORTRAIT) ?
2413 ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT :
2414 !strcmp(sceneMode, CameraParameters::SCENE_MODE_THEATRE) ?
2415 ANDROID_CONTROL_SCENE_MODE_THEATRE :
2416 !strcmp(sceneMode, CameraParameters::SCENE_MODE_BEACH) ?
2417 ANDROID_CONTROL_SCENE_MODE_BEACH :
2418 !strcmp(sceneMode, CameraParameters::SCENE_MODE_SNOW) ?
2419 ANDROID_CONTROL_SCENE_MODE_SNOW :
2420 !strcmp(sceneMode, CameraParameters::SCENE_MODE_SUNSET) ?
2421 ANDROID_CONTROL_SCENE_MODE_SUNSET :
2422 !strcmp(sceneMode, CameraParameters::SCENE_MODE_STEADYPHOTO) ?
2423 ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO :
2424 !strcmp(sceneMode, CameraParameters::SCENE_MODE_FIREWORKS) ?
2425 ANDROID_CONTROL_SCENE_MODE_FIREWORKS :
2426 !strcmp(sceneMode, CameraParameters::SCENE_MODE_SPORTS) ?
2427 ANDROID_CONTROL_SCENE_MODE_SPORTS :
2428 !strcmp(sceneMode, CameraParameters::SCENE_MODE_PARTY) ?
2429 ANDROID_CONTROL_SCENE_MODE_PARTY :
2430 !strcmp(sceneMode, CameraParameters::SCENE_MODE_CANDLELIGHT) ?
2431 ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT :
2432 !strcmp(sceneMode, CameraParameters::SCENE_MODE_BARCODE) ?
2433 ANDROID_CONTROL_SCENE_MODE_BARCODE:
2434 !strcmp(sceneMode, CameraParameters::SCENE_MODE_HDR) ?
2435 ANDROID_CONTROL_SCENE_MODE_HDR:
2436 -1;
2437 }
2438
flashModeStringToEnum(const char * flashMode)2439 Parameters::Parameters::flashMode_t Parameters::flashModeStringToEnum(
2440 const char *flashMode) {
2441 return
2442 !flashMode ?
2443 Parameters::FLASH_MODE_OFF :
2444 !strcmp(flashMode, CameraParameters::FLASH_MODE_OFF) ?
2445 Parameters::FLASH_MODE_OFF :
2446 !strcmp(flashMode, CameraParameters::FLASH_MODE_AUTO) ?
2447 Parameters::FLASH_MODE_AUTO :
2448 !strcmp(flashMode, CameraParameters::FLASH_MODE_ON) ?
2449 Parameters::FLASH_MODE_ON :
2450 !strcmp(flashMode, CameraParameters::FLASH_MODE_RED_EYE) ?
2451 Parameters::FLASH_MODE_RED_EYE :
2452 !strcmp(flashMode, CameraParameters::FLASH_MODE_TORCH) ?
2453 Parameters::FLASH_MODE_TORCH :
2454 Parameters::FLASH_MODE_INVALID;
2455 }
2456
flashModeEnumToString(flashMode_t flashMode)2457 const char *Parameters::flashModeEnumToString(flashMode_t flashMode) {
2458 switch (flashMode) {
2459 case FLASH_MODE_OFF:
2460 return CameraParameters::FLASH_MODE_OFF;
2461 case FLASH_MODE_AUTO:
2462 return CameraParameters::FLASH_MODE_AUTO;
2463 case FLASH_MODE_ON:
2464 return CameraParameters::FLASH_MODE_ON;
2465 case FLASH_MODE_RED_EYE:
2466 return CameraParameters::FLASH_MODE_RED_EYE;
2467 case FLASH_MODE_TORCH:
2468 return CameraParameters::FLASH_MODE_TORCH;
2469 default:
2470 ALOGE("%s: Unknown flash mode enum %d",
2471 __FUNCTION__, flashMode);
2472 return "unknown";
2473 }
2474 }
2475
focusModeStringToEnum(const char * focusMode)2476 Parameters::Parameters::focusMode_t Parameters::focusModeStringToEnum(
2477 const char *focusMode) {
2478 return
2479 !focusMode ?
2480 Parameters::FOCUS_MODE_INVALID :
2481 !strcmp(focusMode, CameraParameters::FOCUS_MODE_AUTO) ?
2482 Parameters::FOCUS_MODE_AUTO :
2483 !strcmp(focusMode, CameraParameters::FOCUS_MODE_INFINITY) ?
2484 Parameters::FOCUS_MODE_INFINITY :
2485 !strcmp(focusMode, CameraParameters::FOCUS_MODE_MACRO) ?
2486 Parameters::FOCUS_MODE_MACRO :
2487 !strcmp(focusMode, CameraParameters::FOCUS_MODE_FIXED) ?
2488 Parameters::FOCUS_MODE_FIXED :
2489 !strcmp(focusMode, CameraParameters::FOCUS_MODE_EDOF) ?
2490 Parameters::FOCUS_MODE_EDOF :
2491 !strcmp(focusMode, CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO) ?
2492 Parameters::FOCUS_MODE_CONTINUOUS_VIDEO :
2493 !strcmp(focusMode, CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE) ?
2494 Parameters::FOCUS_MODE_CONTINUOUS_PICTURE :
2495 Parameters::FOCUS_MODE_INVALID;
2496 }
2497
focusModeEnumToString(focusMode_t focusMode)2498 const char *Parameters::focusModeEnumToString(focusMode_t focusMode) {
2499 switch (focusMode) {
2500 case FOCUS_MODE_AUTO:
2501 return CameraParameters::FOCUS_MODE_AUTO;
2502 case FOCUS_MODE_MACRO:
2503 return CameraParameters::FOCUS_MODE_MACRO;
2504 case FOCUS_MODE_CONTINUOUS_VIDEO:
2505 return CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO;
2506 case FOCUS_MODE_CONTINUOUS_PICTURE:
2507 return CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE;
2508 case FOCUS_MODE_EDOF:
2509 return CameraParameters::FOCUS_MODE_EDOF;
2510 case FOCUS_MODE_INFINITY:
2511 return CameraParameters::FOCUS_MODE_INFINITY;
2512 case FOCUS_MODE_FIXED:
2513 return CameraParameters::FOCUS_MODE_FIXED;
2514 default:
2515 ALOGE("%s: Unknown focus mode enum: %d",
2516 __FUNCTION__, focusMode);
2517 return "unknown";
2518 }
2519 }
2520
parseAreas(const char * areasCStr,Vector<Parameters::Area> * areas)2521 status_t Parameters::parseAreas(const char *areasCStr,
2522 Vector<Parameters::Area> *areas) {
2523 static const size_t NUM_FIELDS = 5;
2524 areas->clear();
2525 if (areasCStr == NULL) {
2526 // If no key exists, use default (0,0,0,0,0)
2527 areas->push();
2528 return OK;
2529 }
2530 String8 areasStr(areasCStr);
2531 ssize_t areaStart = areasStr.find("(", 0) + 1;
2532 while (areaStart != 0) {
2533 const char* area = areasStr.string() + areaStart;
2534 char *numEnd;
2535 int vals[NUM_FIELDS];
2536 for (size_t i = 0; i < NUM_FIELDS; i++) {
2537 errno = 0;
2538 vals[i] = strtol(area, &numEnd, 10);
2539 if (errno || numEnd == area) return BAD_VALUE;
2540 area = numEnd + 1;
2541 }
2542 areas->push(Parameters::Area(
2543 vals[0], vals[1], vals[2], vals[3], vals[4]) );
2544 areaStart = areasStr.find("(", areaStart) + 1;
2545 }
2546 return OK;
2547 }
2548
validateAreas(const Vector<Parameters::Area> & areas,size_t maxRegions,AreaKind areaKind) const2549 status_t Parameters::validateAreas(const Vector<Parameters::Area> &areas,
2550 size_t maxRegions,
2551 AreaKind areaKind) const {
2552 // Definition of valid area can be found in
2553 // include/camera/CameraParameters.h
2554 if (areas.size() == 0) return BAD_VALUE;
2555 if (areas.size() == 1) {
2556 if (areas[0].left == 0 &&
2557 areas[0].top == 0 &&
2558 areas[0].right == 0 &&
2559 areas[0].bottom == 0 &&
2560 areas[0].weight == 0) {
2561 // Single (0,0,0,0,0) entry is always valid (== driver decides)
2562 return OK;
2563 }
2564 }
2565
2566 // fixed focus can only set (0,0,0,0,0) focus area
2567 if (areaKind == AREA_KIND_FOCUS && focusMode == FOCUS_MODE_FIXED) {
2568 return BAD_VALUE;
2569 }
2570
2571 if (areas.size() > maxRegions) {
2572 ALOGE("%s: Too many areas requested: %zu",
2573 __FUNCTION__, areas.size());
2574 return BAD_VALUE;
2575 }
2576
2577 for (Vector<Parameters::Area>::const_iterator a = areas.begin();
2578 a != areas.end(); a++) {
2579 if (a->weight < 1 || a->weight > 1000) return BAD_VALUE;
2580 if (a->left < -1000 || a->left > 1000) return BAD_VALUE;
2581 if (a->top < -1000 || a->top > 1000) return BAD_VALUE;
2582 if (a->right < -1000 || a->right > 1000) return BAD_VALUE;
2583 if (a->bottom < -1000 || a->bottom > 1000) return BAD_VALUE;
2584 if (a->left >= a->right) return BAD_VALUE;
2585 if (a->top >= a->bottom) return BAD_VALUE;
2586 }
2587 return OK;
2588 }
2589
boolFromString(const char * boolStr)2590 bool Parameters::boolFromString(const char *boolStr) {
2591 return !boolStr ? false :
2592 !strcmp(boolStr, CameraParameters::TRUE) ? true :
2593 false;
2594 }
2595
degToTransform(int degrees,bool mirror)2596 int Parameters::degToTransform(int degrees, bool mirror) {
2597 if (!mirror) {
2598 if (degrees == 0) return 0;
2599 else if (degrees == 90) return HAL_TRANSFORM_ROT_90;
2600 else if (degrees == 180) return HAL_TRANSFORM_ROT_180;
2601 else if (degrees == 270) return HAL_TRANSFORM_ROT_270;
2602 } else { // Do mirror (horizontal flip)
2603 if (degrees == 0) { // FLIP_H and ROT_0
2604 return HAL_TRANSFORM_FLIP_H;
2605 } else if (degrees == 90) { // FLIP_H and ROT_90
2606 return HAL_TRANSFORM_FLIP_H | HAL_TRANSFORM_ROT_90;
2607 } else if (degrees == 180) { // FLIP_H and ROT_180
2608 return HAL_TRANSFORM_FLIP_V;
2609 } else if (degrees == 270) { // FLIP_H and ROT_270
2610 return HAL_TRANSFORM_FLIP_V | HAL_TRANSFORM_ROT_90;
2611 }
2612 }
2613 ALOGE("%s: Bad input: %d", __FUNCTION__, degrees);
2614 return -1;
2615 }
2616
cropXToArray(int x) const2617 int Parameters::cropXToArray(int x) const {
2618 ALOG_ASSERT(x >= 0, "Crop-relative X coordinate = '%d' is out of bounds"
2619 "(lower = 0)", x);
2620
2621 CropRegion previewCrop = calculateCropRegion(/*previewOnly*/ true);
2622 ALOG_ASSERT(x < previewCrop.width, "Crop-relative X coordinate = '%d' "
2623 "is out of bounds (upper = %f)", x, previewCrop.width);
2624
2625 int ret = x + previewCrop.left;
2626
2627 ALOG_ASSERT( (ret >= 0 && ret < fastInfo.arrayWidth),
2628 "Calculated pixel array value X = '%d' is out of bounds (upper = %d)",
2629 ret, fastInfo.arrayWidth);
2630 return ret;
2631 }
2632
cropYToArray(int y) const2633 int Parameters::cropYToArray(int y) const {
2634 ALOG_ASSERT(y >= 0, "Crop-relative Y coordinate = '%d' is out of bounds "
2635 "(lower = 0)", y);
2636
2637 CropRegion previewCrop = calculateCropRegion(/*previewOnly*/ true);
2638 ALOG_ASSERT(y < previewCrop.height, "Crop-relative Y coordinate = '%d' is "
2639 "out of bounds (upper = %f)", y, previewCrop.height);
2640
2641 int ret = y + previewCrop.top;
2642
2643 ALOG_ASSERT( (ret >= 0 && ret < fastInfo.arrayHeight),
2644 "Calculated pixel array value Y = '%d' is out of bounds (upper = %d)",
2645 ret, fastInfo.arrayHeight);
2646
2647 return ret;
2648
2649 }
2650
normalizedXToCrop(int x) const2651 int Parameters::normalizedXToCrop(int x) const {
2652 CropRegion previewCrop = calculateCropRegion(/*previewOnly*/ true);
2653 return (x + 1000) * (previewCrop.width - 1) / 2000;
2654 }
2655
normalizedYToCrop(int y) const2656 int Parameters::normalizedYToCrop(int y) const {
2657 CropRegion previewCrop = calculateCropRegion(/*previewOnly*/ true);
2658 return (y + 1000) * (previewCrop.height - 1) / 2000;
2659 }
2660
normalizedXToArray(int x) const2661 int Parameters::normalizedXToArray(int x) const {
2662
2663 // Work-around for HAL pre-scaling the coordinates themselves
2664 if (quirks.meteringCropRegion) {
2665 return (x + 1000) * (fastInfo.arrayWidth - 1) / 2000;
2666 }
2667
2668 return cropXToArray(normalizedXToCrop(x));
2669 }
2670
normalizedYToArray(int y) const2671 int Parameters::normalizedYToArray(int y) const {
2672 // Work-around for HAL pre-scaling the coordinates themselves
2673 if (quirks.meteringCropRegion) {
2674 return (y + 1000) * (fastInfo.arrayHeight - 1) / 2000;
2675 }
2676
2677 return cropYToArray(normalizedYToCrop(y));
2678 }
2679
2680
calculatePreviewCrop(const CropRegion & scalerCrop) const2681 Parameters::CropRegion Parameters::calculatePreviewCrop(
2682 const CropRegion &scalerCrop) const {
2683 float left, top, width, height;
2684 float previewAspect = static_cast<float>(previewWidth) / previewHeight;
2685 float cropAspect = scalerCrop.width / scalerCrop.height;
2686
2687 if (previewAspect > cropAspect) {
2688 width = scalerCrop.width;
2689 height = cropAspect * scalerCrop.height / previewAspect;
2690
2691 left = scalerCrop.left;
2692 top = scalerCrop.top + (scalerCrop.height - height) / 2;
2693 } else {
2694 width = previewAspect * scalerCrop.width / cropAspect;
2695 height = scalerCrop.height;
2696
2697 left = scalerCrop.left + (scalerCrop.width - width) / 2;
2698 top = scalerCrop.top;
2699 }
2700
2701 CropRegion previewCrop = {left, top, width, height};
2702
2703 return previewCrop;
2704 }
2705
arrayXToNormalizedWithCrop(int x,const CropRegion & scalerCrop) const2706 int Parameters::arrayXToNormalizedWithCrop(int x,
2707 const CropRegion &scalerCrop) const {
2708 // Work-around for HAL pre-scaling the coordinates themselves
2709 if (quirks.meteringCropRegion) {
2710 return x * 2000 / (fastInfo.arrayWidth - 1) - 1000;
2711 } else {
2712 CropRegion previewCrop = calculatePreviewCrop(scalerCrop);
2713 return (x - previewCrop.left) * 2000 / (previewCrop.width - 1) - 1000;
2714 }
2715 }
2716
arrayYToNormalizedWithCrop(int y,const CropRegion & scalerCrop) const2717 int Parameters::arrayYToNormalizedWithCrop(int y,
2718 const CropRegion &scalerCrop) const {
2719 // Work-around for HAL pre-scaling the coordinates themselves
2720 if (quirks.meteringCropRegion) {
2721 return y * 2000 / (fastInfo.arrayHeight - 1) - 1000;
2722 } else {
2723 CropRegion previewCrop = calculatePreviewCrop(scalerCrop);
2724 return (y - previewCrop.top) * 2000 / (previewCrop.height - 1) - 1000;
2725 }
2726 }
2727
getFilteredSizes(Size limit,Vector<Size> * sizes)2728 status_t Parameters::getFilteredSizes(Size limit, Vector<Size> *sizes) {
2729 if (info == NULL) {
2730 ALOGE("%s: Static metadata is not initialized", __FUNCTION__);
2731 return NO_INIT;
2732 }
2733 if (sizes == NULL) {
2734 ALOGE("%s: Input size is null", __FUNCTION__);
2735 return BAD_VALUE;
2736 }
2737 sizes->clear();
2738
2739 if (mDeviceVersion >= CAMERA_DEVICE_API_VERSION_3_2) {
2740 Vector<StreamConfiguration> scs = getStreamConfigurations();
2741 for (size_t i=0; i < scs.size(); i++) {
2742 const StreamConfiguration &sc = scs[i];
2743 if (sc.isInput == ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT &&
2744 sc.format == HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED &&
2745 sc.width <= limit.width && sc.height <= limit.height) {
2746 Size sz = {sc.width, sc.height};
2747 sizes->push(sz);
2748 }
2749 }
2750 } else {
2751 const size_t SIZE_COUNT = sizeof(Size) / sizeof(int);
2752 camera_metadata_ro_entry_t availableProcessedSizes =
2753 staticInfo(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES, SIZE_COUNT);
2754 if (availableProcessedSizes.count < SIZE_COUNT) return BAD_VALUE;
2755
2756 Size filteredSize;
2757 for (size_t i = 0; i < availableProcessedSizes.count; i += SIZE_COUNT) {
2758 filteredSize.width = availableProcessedSizes.data.i32[i];
2759 filteredSize.height = availableProcessedSizes.data.i32[i+1];
2760 // Need skip the preview sizes that are too large.
2761 if (filteredSize.width <= limit.width &&
2762 filteredSize.height <= limit.height) {
2763 sizes->push(filteredSize);
2764 }
2765 }
2766 }
2767
2768 if (sizes->isEmpty()) {
2769 ALOGE("generated preview size list is empty!!");
2770 return BAD_VALUE;
2771 }
2772 return OK;
2773 }
2774
getMaxSizeForRatio(float ratio,const int32_t * sizeArray,size_t count)2775 Parameters::Size Parameters::getMaxSizeForRatio(
2776 float ratio, const int32_t* sizeArray, size_t count) {
2777 ALOG_ASSERT(sizeArray != NULL, "size array shouldn't be NULL");
2778 ALOG_ASSERT(count >= 2 && count % 2 == 0, "count must be a positive even number");
2779
2780 Size maxSize = {0, 0};
2781 for (size_t i = 0; i < count; i += 2) {
2782 if (sizeArray[i] > 0 && sizeArray[i+1] > 0) {
2783 float curRatio = static_cast<float>(sizeArray[i]) / sizeArray[i+1];
2784 if (fabs(curRatio - ratio) < ASPECT_RATIO_TOLERANCE && maxSize.width < sizeArray[i]) {
2785 maxSize.width = sizeArray[i];
2786 maxSize.height = sizeArray[i+1];
2787 }
2788 }
2789 }
2790
2791 if (maxSize.width == 0 || maxSize.height == 0) {
2792 maxSize.width = sizeArray[0];
2793 maxSize.height = sizeArray[1];
2794 ALOGW("Unable to find the size to match the given aspect ratio %f."
2795 "Fall back to %d x %d", ratio, maxSize.width, maxSize.height);
2796 }
2797
2798 return maxSize;
2799 }
2800
getMaxSize(const Vector<Parameters::Size> & sizes)2801 Parameters::Size Parameters::getMaxSize(const Vector<Parameters::Size> &sizes) {
2802 Size maxSize = {-1, -1};
2803 for (size_t i = 0; i < sizes.size(); i++) {
2804 if (sizes[i].width > maxSize.width ||
2805 (sizes[i].width == maxSize.width && sizes[i].height > maxSize.height )) {
2806 maxSize = sizes[i];
2807 }
2808 }
2809 return maxSize;
2810 }
2811
getStreamConfigurations()2812 Vector<Parameters::StreamConfiguration> Parameters::getStreamConfigurations() {
2813 const int STREAM_CONFIGURATION_SIZE = 4;
2814 const int STREAM_FORMAT_OFFSET = 0;
2815 const int STREAM_WIDTH_OFFSET = 1;
2816 const int STREAM_HEIGHT_OFFSET = 2;
2817 const int STREAM_IS_INPUT_OFFSET = 3;
2818 Vector<StreamConfiguration> scs;
2819 if (mDeviceVersion < CAMERA_DEVICE_API_VERSION_3_2) {
2820 ALOGE("StreamConfiguration is only valid after device HAL 3.2!");
2821 return scs;
2822 }
2823
2824 camera_metadata_ro_entry_t availableStreamConfigs =
2825 staticInfo(ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS);
2826 for (size_t i = 0; i < availableStreamConfigs.count; i+= STREAM_CONFIGURATION_SIZE) {
2827 int32_t format = availableStreamConfigs.data.i32[i + STREAM_FORMAT_OFFSET];
2828 int32_t width = availableStreamConfigs.data.i32[i + STREAM_WIDTH_OFFSET];
2829 int32_t height = availableStreamConfigs.data.i32[i + STREAM_HEIGHT_OFFSET];
2830 int32_t isInput = availableStreamConfigs.data.i32[i + STREAM_IS_INPUT_OFFSET];
2831 StreamConfiguration sc = {format, width, height, isInput};
2832 scs.add(sc);
2833 }
2834 return scs;
2835 }
2836
getJpegStreamMinFrameDurationNs(Parameters::Size size)2837 int64_t Parameters::getJpegStreamMinFrameDurationNs(Parameters::Size size) {
2838 if (mDeviceVersion >= CAMERA_DEVICE_API_VERSION_3_2) {
2839 const int STREAM_DURATION_SIZE = 4;
2840 const int STREAM_FORMAT_OFFSET = 0;
2841 const int STREAM_WIDTH_OFFSET = 1;
2842 const int STREAM_HEIGHT_OFFSET = 2;
2843 const int STREAM_DURATION_OFFSET = 3;
2844 camera_metadata_ro_entry_t availableStreamMinDurations =
2845 staticInfo(ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS);
2846 for (size_t i = 0; i < availableStreamMinDurations.count; i+= STREAM_DURATION_SIZE) {
2847 int64_t format = availableStreamMinDurations.data.i64[i + STREAM_FORMAT_OFFSET];
2848 int64_t width = availableStreamMinDurations.data.i64[i + STREAM_WIDTH_OFFSET];
2849 int64_t height = availableStreamMinDurations.data.i64[i + STREAM_HEIGHT_OFFSET];
2850 int64_t duration = availableStreamMinDurations.data.i64[i + STREAM_DURATION_OFFSET];
2851 if (format == HAL_PIXEL_FORMAT_BLOB && width == size.width && height == size.height) {
2852 return duration;
2853 }
2854 }
2855 } else {
2856 Vector<Size> availableJpegSizes = getAvailableJpegSizes();
2857 size_t streamIdx = availableJpegSizes.size();
2858 for (size_t i = 0; i < availableJpegSizes.size(); i++) {
2859 if (availableJpegSizes[i].width == size.width &&
2860 availableJpegSizes[i].height == size.height) {
2861 streamIdx = i;
2862 break;
2863 }
2864 }
2865 if (streamIdx != availableJpegSizes.size()) {
2866 camera_metadata_ro_entry_t jpegMinDurations =
2867 staticInfo(ANDROID_SCALER_AVAILABLE_JPEG_MIN_DURATIONS);
2868 if (streamIdx < jpegMinDurations.count) {
2869 return jpegMinDurations.data.i64[streamIdx];
2870 }
2871 }
2872 }
2873 ALOGE("%s: cannot find min frame duration for jpeg size %dx%d",
2874 __FUNCTION__, size.width, size.height);
2875 return -1;
2876 }
2877
getAvailableOutputFormats()2878 SortedVector<int32_t> Parameters::getAvailableOutputFormats() {
2879 SortedVector<int32_t> outputFormats; // Non-duplicated output formats
2880 if (mDeviceVersion >= CAMERA_DEVICE_API_VERSION_3_2) {
2881 Vector<StreamConfiguration> scs = getStreamConfigurations();
2882 for (size_t i = 0; i < scs.size(); i++) {
2883 const StreamConfiguration &sc = scs[i];
2884 if (sc.isInput == ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT) {
2885 outputFormats.add(sc.format);
2886 }
2887 }
2888 } else {
2889 camera_metadata_ro_entry_t availableFormats = staticInfo(ANDROID_SCALER_AVAILABLE_FORMATS);
2890 for (size_t i = 0; i < availableFormats.count; i++) {
2891 outputFormats.add(availableFormats.data.i32[i]);
2892 }
2893 }
2894 return outputFormats;
2895 }
2896
getAvailableJpegSizes()2897 Vector<Parameters::Size> Parameters::getAvailableJpegSizes() {
2898 Vector<Parameters::Size> jpegSizes;
2899 if (mDeviceVersion >= CAMERA_DEVICE_API_VERSION_3_2) {
2900 Vector<StreamConfiguration> scs = getStreamConfigurations();
2901 for (size_t i = 0; i < scs.size(); i++) {
2902 const StreamConfiguration &sc = scs[i];
2903 if (sc.isInput == ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT &&
2904 sc.format == HAL_PIXEL_FORMAT_BLOB) {
2905 Size sz = {sc.width, sc.height};
2906 jpegSizes.add(sz);
2907 }
2908 }
2909 } else {
2910 const int JPEG_SIZE_ENTRY_COUNT = 2;
2911 const int WIDTH_OFFSET = 0;
2912 const int HEIGHT_OFFSET = 1;
2913 camera_metadata_ro_entry_t availableJpegSizes =
2914 staticInfo(ANDROID_SCALER_AVAILABLE_JPEG_SIZES);
2915 for (size_t i = 0; i < availableJpegSizes.count; i+= JPEG_SIZE_ENTRY_COUNT) {
2916 int width = availableJpegSizes.data.i32[i + WIDTH_OFFSET];
2917 int height = availableJpegSizes.data.i32[i + HEIGHT_OFFSET];
2918 Size sz = {width, height};
2919 jpegSizes.add(sz);
2920 }
2921 }
2922 return jpegSizes;
2923 }
2924
calculateCropRegion(bool previewOnly) const2925 Parameters::CropRegion Parameters::calculateCropRegion(bool previewOnly) const {
2926
2927 float zoomLeft, zoomTop, zoomWidth, zoomHeight;
2928
2929 // Need to convert zoom index into a crop rectangle. The rectangle is
2930 // chosen to maximize its area on the sensor
2931
2932 camera_metadata_ro_entry_t maxDigitalZoom =
2933 staticInfo(ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM);
2934 // For each zoom step by how many pixels more do we change the zoom
2935 float zoomIncrement = (maxDigitalZoom.data.f[0] - 1) /
2936 (NUM_ZOOM_STEPS-1);
2937 // The desired activeAreaWidth/cropAreaWidth ratio (or height if h>w)
2938 // via interpolating zoom step into a zoom ratio
2939 float zoomRatio = 1 + zoomIncrement * zoom;
2940 ALOG_ASSERT( (zoomRatio >= 1.f && zoomRatio <= maxDigitalZoom.data.f[0]),
2941 "Zoom ratio calculated out of bounds. Expected 1 - %f, actual: %f",
2942 maxDigitalZoom.data.f[0], zoomRatio);
2943
2944 ALOGV("Zoom maxDigital=%f, increment=%f, ratio=%f, previewWidth=%d, "
2945 "previewHeight=%d, activeWidth=%d, activeHeight=%d",
2946 maxDigitalZoom.data.f[0], zoomIncrement, zoomRatio, previewWidth,
2947 previewHeight, fastInfo.arrayWidth, fastInfo.arrayHeight);
2948
2949 if (previewOnly) {
2950 // Calculate a tight crop region for the preview stream only
2951 float previewRatio = static_cast<float>(previewWidth) / previewHeight;
2952
2953 /* Ensure that the width/height never go out of bounds
2954 * by scaling across a diffent dimension if an out-of-bounds
2955 * possibility exists.
2956 *
2957 * e.g. if the previewratio < arrayratio and e.g. zoomratio = 1.0, then by
2958 * calculating the zoomWidth from zoomHeight we'll actually get a
2959 * zoomheight > arrayheight
2960 */
2961 float arrayRatio = 1.f * fastInfo.arrayWidth / fastInfo.arrayHeight;
2962 if (previewRatio >= arrayRatio) {
2963 // Adjust the height based on the width
2964 zoomWidth = fastInfo.arrayWidth / zoomRatio;
2965 zoomHeight = zoomWidth *
2966 previewHeight / previewWidth;
2967
2968 } else {
2969 // Adjust the width based on the height
2970 zoomHeight = fastInfo.arrayHeight / zoomRatio;
2971 zoomWidth = zoomHeight *
2972 previewWidth / previewHeight;
2973 }
2974 } else {
2975 // Calculate the global crop region with a shape matching the active
2976 // array.
2977 zoomWidth = fastInfo.arrayWidth / zoomRatio;
2978 zoomHeight = fastInfo.arrayHeight / zoomRatio;
2979 }
2980
2981 // center the zoom area within the active area
2982 zoomLeft = (fastInfo.arrayWidth - zoomWidth) / 2;
2983 zoomTop = (fastInfo.arrayHeight - zoomHeight) / 2;
2984
2985 ALOGV("Crop region calculated (x=%d,y=%d,w=%f,h=%f) for zoom=%d",
2986 (int32_t)zoomLeft, (int32_t)zoomTop, zoomWidth, zoomHeight, this->zoom);
2987
2988 CropRegion crop = { zoomLeft, zoomTop, zoomWidth, zoomHeight };
2989 return crop;
2990 }
2991
calculatePictureFovs(float * horizFov,float * vertFov) const2992 status_t Parameters::calculatePictureFovs(float *horizFov, float *vertFov)
2993 const {
2994 camera_metadata_ro_entry_t sensorSize =
2995 staticInfo(ANDROID_SENSOR_INFO_PHYSICAL_SIZE, 2, 2);
2996 if (!sensorSize.count) return NO_INIT;
2997
2998 camera_metadata_ro_entry_t pixelArraySize =
2999 staticInfo(ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE, 2, 2);
3000 if (!pixelArraySize.count) return NO_INIT;
3001
3002 float arrayAspect = static_cast<float>(fastInfo.arrayWidth) /
3003 fastInfo.arrayHeight;
3004 float stillAspect = static_cast<float>(pictureWidth) / pictureHeight;
3005 ALOGV("Array aspect: %f, still aspect: %f", arrayAspect, stillAspect);
3006
3007 // The crop factors from the full sensor array to the still picture crop
3008 // region
3009 float horizCropFactor = 1.f;
3010 float vertCropFactor = 1.f;
3011
3012 /**
3013 * Need to calculate the still image field of view based on the total pixel
3014 * array field of view, and the relative aspect ratios of the pixel array
3015 * and output streams.
3016 *
3017 * Special treatment for quirky definition of crop region and relative
3018 * stream cropping.
3019 */
3020 if (quirks.meteringCropRegion) {
3021 // Use max of preview and video as first crop
3022 float previewAspect = static_cast<float>(previewWidth) / previewHeight;
3023 float videoAspect = static_cast<float>(videoWidth) / videoHeight;
3024 if (videoAspect > previewAspect) {
3025 previewAspect = videoAspect;
3026 }
3027 // First crop sensor to preview aspect ratio
3028 if (arrayAspect < previewAspect) {
3029 vertCropFactor = arrayAspect / previewAspect;
3030 } else {
3031 horizCropFactor = previewAspect / arrayAspect;
3032 }
3033 // Second crop to still aspect ratio
3034 if (stillAspect < previewAspect) {
3035 horizCropFactor *= stillAspect / previewAspect;
3036 } else {
3037 vertCropFactor *= previewAspect / stillAspect;
3038 }
3039 } else {
3040 /**
3041 * Crop are just a function of just the still/array relative aspect
3042 * ratios. Since each stream will maximize its area within the crop
3043 * region, and for FOV we assume a full-sensor crop region, we only ever
3044 * crop the FOV either vertically or horizontally, never both.
3045 */
3046 horizCropFactor = (arrayAspect > stillAspect) ?
3047 (stillAspect / arrayAspect) : 1.f;
3048 vertCropFactor = (arrayAspect < stillAspect) ?
3049 (arrayAspect / stillAspect) : 1.f;
3050 }
3051
3052 /**
3053 * Convert the crop factors w.r.t the active array size to the crop factors
3054 * w.r.t the pixel array size.
3055 */
3056 horizCropFactor *= (static_cast<float>(fastInfo.arrayWidth) /
3057 pixelArraySize.data.i32[0]);
3058 vertCropFactor *= (static_cast<float>(fastInfo.arrayHeight) /
3059 pixelArraySize.data.i32[1]);
3060
3061 ALOGV("Horiz crop factor: %f, vert crop fact: %f",
3062 horizCropFactor, vertCropFactor);
3063 /**
3064 * Basic field of view formula is:
3065 * angle of view = 2 * arctangent ( d / 2f )
3066 * where d is the physical sensor dimension of interest, and f is
3067 * the focal length. This only applies to rectilinear sensors, for focusing
3068 * at distances >> f, etc.
3069 */
3070 if (horizFov != NULL) {
3071 *horizFov = 180 / M_PI * 2 *
3072 atanf(horizCropFactor * sensorSize.data.f[0] /
3073 (2 * fastInfo.minFocalLength));
3074 }
3075 if (vertFov != NULL) {
3076 *vertFov = 180 / M_PI * 2 *
3077 atanf(vertCropFactor * sensorSize.data.f[1] /
3078 (2 * fastInfo.minFocalLength));
3079 }
3080 return OK;
3081 }
3082
fpsFromRange(int32_t,int32_t max) const3083 int32_t Parameters::fpsFromRange(int32_t /*min*/, int32_t max) const {
3084 return max;
3085 }
3086
3087 }; // namespace camera2
3088 }; // namespace android
3089