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
33 namespace android {
34 namespace camera2 {
35
Parameters(int cameraId,int cameraFacing)36 Parameters::Parameters(int cameraId,
37 int cameraFacing) :
38 cameraId(cameraId),
39 cameraFacing(cameraFacing),
40 info(NULL) {
41 }
42
~Parameters()43 Parameters::~Parameters() {
44 }
45
initialize(const CameraMetadata * info)46 status_t Parameters::initialize(const CameraMetadata *info) {
47 status_t res;
48
49 if (info->entryCount() == 0) {
50 ALOGE("%s: No static information provided!", __FUNCTION__);
51 return BAD_VALUE;
52 }
53 Parameters::info = info;
54
55 res = buildFastInfo();
56 if (res != OK) return res;
57
58 res = buildQuirks();
59 if (res != OK) return res;
60
61 camera_metadata_ro_entry_t availableProcessedSizes =
62 staticInfo(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES, 2);
63 if (!availableProcessedSizes.count) return NO_INIT;
64
65 // TODO: Pick more intelligently
66 previewWidth = availableProcessedSizes.data.i32[0];
67 previewHeight = availableProcessedSizes.data.i32[1];
68 videoWidth = previewWidth;
69 videoHeight = previewHeight;
70
71 params.setPreviewSize(previewWidth, previewHeight);
72 params.setVideoSize(videoWidth, videoHeight);
73 params.set(CameraParameters::KEY_PREFERRED_PREVIEW_SIZE_FOR_VIDEO,
74 String8::format("%dx%d",
75 previewWidth, previewHeight));
76 {
77 String8 supportedPreviewSizes;
78 for (size_t i=0; i < availableProcessedSizes.count; i += 2) {
79 if (i != 0) supportedPreviewSizes += ",";
80 supportedPreviewSizes += String8::format("%dx%d",
81 availableProcessedSizes.data.i32[i],
82 availableProcessedSizes.data.i32[i+1]);
83 }
84 params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES,
85 supportedPreviewSizes);
86 params.set(CameraParameters::KEY_SUPPORTED_VIDEO_SIZES,
87 supportedPreviewSizes);
88 }
89
90 camera_metadata_ro_entry_t availableFpsRanges =
91 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES, 2);
92 if (!availableFpsRanges.count) return NO_INIT;
93
94 previewFpsRange[0] = availableFpsRanges.data.i32[0];
95 previewFpsRange[1] = availableFpsRanges.data.i32[1];
96
97 params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE,
98 String8::format("%d,%d",
99 previewFpsRange[0] * kFpsToApiScale,
100 previewFpsRange[1] * kFpsToApiScale));
101
102 {
103 String8 supportedPreviewFpsRange;
104 for (size_t i=0; i < availableFpsRanges.count; i += 2) {
105 if (i != 0) supportedPreviewFpsRange += ",";
106 supportedPreviewFpsRange += String8::format("(%d,%d)",
107 availableFpsRanges.data.i32[i] * kFpsToApiScale,
108 availableFpsRanges.data.i32[i+1] * kFpsToApiScale);
109 }
110 params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE,
111 supportedPreviewFpsRange);
112 }
113
114 previewFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP;
115 params.set(CameraParameters::KEY_PREVIEW_FORMAT,
116 formatEnumToString(previewFormat)); // NV21
117
118 previewTransform = degToTransform(0,
119 cameraFacing == CAMERA_FACING_FRONT);
120
121 camera_metadata_ro_entry_t availableFormats =
122 staticInfo(ANDROID_SCALER_AVAILABLE_FORMATS);
123
124 {
125 String8 supportedPreviewFormats;
126 bool addComma = false;
127 for (size_t i=0; i < availableFormats.count; i++) {
128 if (addComma) supportedPreviewFormats += ",";
129 addComma = true;
130 switch (availableFormats.data.i32[i]) {
131 case HAL_PIXEL_FORMAT_YCbCr_422_SP:
132 supportedPreviewFormats +=
133 CameraParameters::PIXEL_FORMAT_YUV422SP;
134 break;
135 case HAL_PIXEL_FORMAT_YCrCb_420_SP:
136 supportedPreviewFormats +=
137 CameraParameters::PIXEL_FORMAT_YUV420SP;
138 break;
139 case HAL_PIXEL_FORMAT_YCbCr_422_I:
140 supportedPreviewFormats +=
141 CameraParameters::PIXEL_FORMAT_YUV422I;
142 break;
143 case HAL_PIXEL_FORMAT_YV12:
144 supportedPreviewFormats +=
145 CameraParameters::PIXEL_FORMAT_YUV420P;
146 break;
147 case HAL_PIXEL_FORMAT_RGB_565:
148 supportedPreviewFormats +=
149 CameraParameters::PIXEL_FORMAT_RGB565;
150 break;
151 case HAL_PIXEL_FORMAT_RGBA_8888:
152 supportedPreviewFormats +=
153 CameraParameters::PIXEL_FORMAT_RGBA8888;
154 break;
155 // Not advertizing JPEG, RAW_SENSOR, etc, for preview formats
156 case HAL_PIXEL_FORMAT_RAW_SENSOR:
157 case HAL_PIXEL_FORMAT_BLOB:
158 addComma = false;
159 break;
160
161 default:
162 ALOGW("%s: Camera %d: Unknown preview format: %x",
163 __FUNCTION__, cameraId, availableFormats.data.i32[i]);
164 addComma = false;
165 break;
166 }
167 }
168 params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS,
169 supportedPreviewFormats);
170 }
171
172 // PREVIEW_FRAME_RATE / SUPPORTED_PREVIEW_FRAME_RATES are deprecated, but
173 // still have to do something sane for them
174
175 // NOTE: Not scaled like FPS range values are.
176 previewFps = fpsFromRange(previewFpsRange[0], previewFpsRange[1]);
177 params.set(CameraParameters::KEY_PREVIEW_FRAME_RATE,
178 previewFps);
179
180 {
181 SortedVector<int32_t> sortedPreviewFrameRates;
182
183 String8 supportedPreviewFrameRates;
184 for (size_t i=0; i < availableFpsRanges.count; i += 2) {
185 // from the [min, max] fps range use the max value
186 int fps = fpsFromRange(availableFpsRanges.data.i32[i],
187 availableFpsRanges.data.i32[i+1]);
188
189 // de-dupe frame rates
190 if (sortedPreviewFrameRates.indexOf(fps) == NAME_NOT_FOUND) {
191 sortedPreviewFrameRates.add(fps);
192 }
193 else {
194 continue;
195 }
196
197 if (sortedPreviewFrameRates.size() > 1) {
198 supportedPreviewFrameRates += ",";
199 }
200
201 supportedPreviewFrameRates += String8::format("%d",
202 fps);
203
204 ALOGV("%s: Supported preview frame rates: %s",
205 __FUNCTION__, supportedPreviewFrameRates.string());
206 }
207 params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES,
208 supportedPreviewFrameRates);
209 }
210
211 camera_metadata_ro_entry_t availableJpegSizes =
212 staticInfo(ANDROID_SCALER_AVAILABLE_JPEG_SIZES, 2);
213 if (!availableJpegSizes.count) return NO_INIT;
214
215 // TODO: Pick maximum
216 pictureWidth = availableJpegSizes.data.i32[0];
217 pictureHeight = availableJpegSizes.data.i32[1];
218
219 params.setPictureSize(pictureWidth,
220 pictureHeight);
221
222 {
223 String8 supportedPictureSizes;
224 for (size_t i=0; i < availableJpegSizes.count; i += 2) {
225 if (i != 0) supportedPictureSizes += ",";
226 supportedPictureSizes += String8::format("%dx%d",
227 availableJpegSizes.data.i32[i],
228 availableJpegSizes.data.i32[i+1]);
229 }
230 params.set(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES,
231 supportedPictureSizes);
232 }
233
234 params.setPictureFormat(CameraParameters::PIXEL_FORMAT_JPEG);
235 params.set(CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS,
236 CameraParameters::PIXEL_FORMAT_JPEG);
237
238 camera_metadata_ro_entry_t availableJpegThumbnailSizes =
239 staticInfo(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES, 4);
240 if (!availableJpegThumbnailSizes.count) return NO_INIT;
241
242 // TODO: Pick default thumbnail size sensibly
243 jpegThumbSize[0] = availableJpegThumbnailSizes.data.i32[0];
244 jpegThumbSize[1] = availableJpegThumbnailSizes.data.i32[1];
245
246 params.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH,
247 jpegThumbSize[0]);
248 params.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT,
249 jpegThumbSize[1]);
250
251 {
252 String8 supportedJpegThumbSizes;
253 for (size_t i=0; i < availableJpegThumbnailSizes.count; i += 2) {
254 if (i != 0) supportedJpegThumbSizes += ",";
255 supportedJpegThumbSizes += String8::format("%dx%d",
256 availableJpegThumbnailSizes.data.i32[i],
257 availableJpegThumbnailSizes.data.i32[i+1]);
258 }
259 params.set(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES,
260 supportedJpegThumbSizes);
261 }
262
263 jpegThumbQuality = 90;
264 params.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY,
265 jpegThumbQuality);
266 jpegQuality = 90;
267 params.set(CameraParameters::KEY_JPEG_QUALITY,
268 jpegQuality);
269 jpegRotation = 0;
270 params.set(CameraParameters::KEY_ROTATION,
271 jpegRotation);
272
273 gpsEnabled = false;
274 gpsCoordinates[0] = 0.0;
275 gpsCoordinates[1] = 0.0;
276 gpsCoordinates[2] = 0.0;
277 gpsTimestamp = 0;
278 gpsProcessingMethod = "unknown";
279 // GPS fields in CameraParameters are not set by implementation
280
281 wbMode = ANDROID_CONTROL_AWB_AUTO;
282 params.set(CameraParameters::KEY_WHITE_BALANCE,
283 CameraParameters::WHITE_BALANCE_AUTO);
284
285 camera_metadata_ro_entry_t availableWhiteBalanceModes =
286 staticInfo(ANDROID_CONTROL_AWB_AVAILABLE_MODES);
287 {
288 String8 supportedWhiteBalance;
289 bool addComma = false;
290 for (size_t i=0; i < availableWhiteBalanceModes.count; i++) {
291 if (addComma) supportedWhiteBalance += ",";
292 addComma = true;
293 switch (availableWhiteBalanceModes.data.u8[i]) {
294 case ANDROID_CONTROL_AWB_AUTO:
295 supportedWhiteBalance +=
296 CameraParameters::WHITE_BALANCE_AUTO;
297 break;
298 case ANDROID_CONTROL_AWB_INCANDESCENT:
299 supportedWhiteBalance +=
300 CameraParameters::WHITE_BALANCE_INCANDESCENT;
301 break;
302 case ANDROID_CONTROL_AWB_FLUORESCENT:
303 supportedWhiteBalance +=
304 CameraParameters::WHITE_BALANCE_FLUORESCENT;
305 break;
306 case ANDROID_CONTROL_AWB_WARM_FLUORESCENT:
307 supportedWhiteBalance +=
308 CameraParameters::WHITE_BALANCE_WARM_FLUORESCENT;
309 break;
310 case ANDROID_CONTROL_AWB_DAYLIGHT:
311 supportedWhiteBalance +=
312 CameraParameters::WHITE_BALANCE_DAYLIGHT;
313 break;
314 case ANDROID_CONTROL_AWB_CLOUDY_DAYLIGHT:
315 supportedWhiteBalance +=
316 CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT;
317 break;
318 case ANDROID_CONTROL_AWB_TWILIGHT:
319 supportedWhiteBalance +=
320 CameraParameters::WHITE_BALANCE_TWILIGHT;
321 break;
322 case ANDROID_CONTROL_AWB_SHADE:
323 supportedWhiteBalance +=
324 CameraParameters::WHITE_BALANCE_SHADE;
325 break;
326 // Skipping values not mappable to v1 API
327 case ANDROID_CONTROL_AWB_OFF:
328 addComma = false;
329 break;
330 default:
331 ALOGW("%s: Camera %d: Unknown white balance value: %d",
332 __FUNCTION__, cameraId,
333 availableWhiteBalanceModes.data.u8[i]);
334 addComma = false;
335 break;
336 }
337 }
338 params.set(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE,
339 supportedWhiteBalance);
340 }
341
342 effectMode = ANDROID_CONTROL_EFFECT_OFF;
343 params.set(CameraParameters::KEY_EFFECT,
344 CameraParameters::EFFECT_NONE);
345
346 camera_metadata_ro_entry_t availableEffects =
347 staticInfo(ANDROID_CONTROL_AVAILABLE_EFFECTS);
348 if (!availableEffects.count) return NO_INIT;
349 {
350 String8 supportedEffects;
351 bool addComma = false;
352 for (size_t i=0; i < availableEffects.count; i++) {
353 if (addComma) supportedEffects += ",";
354 addComma = true;
355 switch (availableEffects.data.u8[i]) {
356 case ANDROID_CONTROL_EFFECT_OFF:
357 supportedEffects +=
358 CameraParameters::EFFECT_NONE;
359 break;
360 case ANDROID_CONTROL_EFFECT_MONO:
361 supportedEffects +=
362 CameraParameters::EFFECT_MONO;
363 break;
364 case ANDROID_CONTROL_EFFECT_NEGATIVE:
365 supportedEffects +=
366 CameraParameters::EFFECT_NEGATIVE;
367 break;
368 case ANDROID_CONTROL_EFFECT_SOLARIZE:
369 supportedEffects +=
370 CameraParameters::EFFECT_SOLARIZE;
371 break;
372 case ANDROID_CONTROL_EFFECT_SEPIA:
373 supportedEffects +=
374 CameraParameters::EFFECT_SEPIA;
375 break;
376 case ANDROID_CONTROL_EFFECT_POSTERIZE:
377 supportedEffects +=
378 CameraParameters::EFFECT_POSTERIZE;
379 break;
380 case ANDROID_CONTROL_EFFECT_WHITEBOARD:
381 supportedEffects +=
382 CameraParameters::EFFECT_WHITEBOARD;
383 break;
384 case ANDROID_CONTROL_EFFECT_BLACKBOARD:
385 supportedEffects +=
386 CameraParameters::EFFECT_BLACKBOARD;
387 break;
388 case ANDROID_CONTROL_EFFECT_AQUA:
389 supportedEffects +=
390 CameraParameters::EFFECT_AQUA;
391 break;
392 default:
393 ALOGW("%s: Camera %d: Unknown effect value: %d",
394 __FUNCTION__, cameraId, availableEffects.data.u8[i]);
395 addComma = false;
396 break;
397 }
398 }
399 params.set(CameraParameters::KEY_SUPPORTED_EFFECTS, supportedEffects);
400 }
401
402 antibandingMode = ANDROID_CONTROL_AE_ANTIBANDING_AUTO;
403 params.set(CameraParameters::KEY_ANTIBANDING,
404 CameraParameters::ANTIBANDING_AUTO);
405
406 camera_metadata_ro_entry_t availableAntibandingModes =
407 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES);
408 if (!availableAntibandingModes.count) return NO_INIT;
409 {
410 String8 supportedAntibanding;
411 bool addComma = false;
412 for (size_t i=0; i < availableAntibandingModes.count; i++) {
413 if (addComma) supportedAntibanding += ",";
414 addComma = true;
415 switch (availableAntibandingModes.data.u8[i]) {
416 case ANDROID_CONTROL_AE_ANTIBANDING_OFF:
417 supportedAntibanding +=
418 CameraParameters::ANTIBANDING_OFF;
419 break;
420 case ANDROID_CONTROL_AE_ANTIBANDING_50HZ:
421 supportedAntibanding +=
422 CameraParameters::ANTIBANDING_50HZ;
423 break;
424 case ANDROID_CONTROL_AE_ANTIBANDING_60HZ:
425 supportedAntibanding +=
426 CameraParameters::ANTIBANDING_60HZ;
427 break;
428 case ANDROID_CONTROL_AE_ANTIBANDING_AUTO:
429 supportedAntibanding +=
430 CameraParameters::ANTIBANDING_AUTO;
431 break;
432 default:
433 ALOGW("%s: Camera %d: Unknown antibanding value: %d",
434 __FUNCTION__, cameraId,
435 availableAntibandingModes.data.u8[i]);
436 addComma = false;
437 break;
438 }
439 }
440 params.set(CameraParameters::KEY_SUPPORTED_ANTIBANDING,
441 supportedAntibanding);
442 }
443
444 sceneMode = ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED;
445 params.set(CameraParameters::KEY_SCENE_MODE,
446 CameraParameters::SCENE_MODE_AUTO);
447
448 camera_metadata_ro_entry_t availableSceneModes =
449 staticInfo(ANDROID_CONTROL_AVAILABLE_SCENE_MODES);
450 if (!availableSceneModes.count) return NO_INIT;
451 {
452 String8 supportedSceneModes(CameraParameters::SCENE_MODE_AUTO);
453 bool addComma = true;
454 bool noSceneModes = false;
455 for (size_t i=0; i < availableSceneModes.count; i++) {
456 if (addComma) supportedSceneModes += ",";
457 addComma = true;
458 switch (availableSceneModes.data.u8[i]) {
459 case ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED:
460 noSceneModes = true;
461 break;
462 case ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY:
463 // Not in old API
464 addComma = false;
465 break;
466 case ANDROID_CONTROL_SCENE_MODE_ACTION:
467 supportedSceneModes +=
468 CameraParameters::SCENE_MODE_ACTION;
469 break;
470 case ANDROID_CONTROL_SCENE_MODE_PORTRAIT:
471 supportedSceneModes +=
472 CameraParameters::SCENE_MODE_PORTRAIT;
473 break;
474 case ANDROID_CONTROL_SCENE_MODE_LANDSCAPE:
475 supportedSceneModes +=
476 CameraParameters::SCENE_MODE_LANDSCAPE;
477 break;
478 case ANDROID_CONTROL_SCENE_MODE_NIGHT:
479 supportedSceneModes +=
480 CameraParameters::SCENE_MODE_NIGHT;
481 break;
482 case ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT:
483 supportedSceneModes +=
484 CameraParameters::SCENE_MODE_NIGHT_PORTRAIT;
485 break;
486 case ANDROID_CONTROL_SCENE_MODE_THEATRE:
487 supportedSceneModes +=
488 CameraParameters::SCENE_MODE_THEATRE;
489 break;
490 case ANDROID_CONTROL_SCENE_MODE_BEACH:
491 supportedSceneModes +=
492 CameraParameters::SCENE_MODE_BEACH;
493 break;
494 case ANDROID_CONTROL_SCENE_MODE_SNOW:
495 supportedSceneModes +=
496 CameraParameters::SCENE_MODE_SNOW;
497 break;
498 case ANDROID_CONTROL_SCENE_MODE_SUNSET:
499 supportedSceneModes +=
500 CameraParameters::SCENE_MODE_SUNSET;
501 break;
502 case ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO:
503 supportedSceneModes +=
504 CameraParameters::SCENE_MODE_STEADYPHOTO;
505 break;
506 case ANDROID_CONTROL_SCENE_MODE_FIREWORKS:
507 supportedSceneModes +=
508 CameraParameters::SCENE_MODE_FIREWORKS;
509 break;
510 case ANDROID_CONTROL_SCENE_MODE_SPORTS:
511 supportedSceneModes +=
512 CameraParameters::SCENE_MODE_SPORTS;
513 break;
514 case ANDROID_CONTROL_SCENE_MODE_PARTY:
515 supportedSceneModes +=
516 CameraParameters::SCENE_MODE_PARTY;
517 break;
518 case ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT:
519 supportedSceneModes +=
520 CameraParameters::SCENE_MODE_CANDLELIGHT;
521 break;
522 case ANDROID_CONTROL_SCENE_MODE_BARCODE:
523 supportedSceneModes +=
524 CameraParameters::SCENE_MODE_BARCODE;
525 break;
526 default:
527 ALOGW("%s: Camera %d: Unknown scene mode value: %d",
528 __FUNCTION__, cameraId,
529 availableSceneModes.data.u8[i]);
530 addComma = false;
531 break;
532 }
533 }
534 if (!noSceneModes) {
535 params.set(CameraParameters::KEY_SUPPORTED_SCENE_MODES,
536 supportedSceneModes);
537 }
538 }
539
540 camera_metadata_ro_entry_t flashAvailable =
541 staticInfo(ANDROID_FLASH_AVAILABLE, 1, 1);
542 if (!flashAvailable.count) return NO_INIT;
543
544 camera_metadata_ro_entry_t availableAeModes =
545 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_MODES);
546 if (!availableAeModes.count) return NO_INIT;
547
548 if (flashAvailable.data.u8[0]) {
549 flashMode = Parameters::FLASH_MODE_OFF;
550 params.set(CameraParameters::KEY_FLASH_MODE,
551 CameraParameters::FLASH_MODE_OFF);
552
553 String8 supportedFlashModes(CameraParameters::FLASH_MODE_OFF);
554 supportedFlashModes = supportedFlashModes +
555 "," + CameraParameters::FLASH_MODE_AUTO +
556 "," + CameraParameters::FLASH_MODE_ON +
557 "," + CameraParameters::FLASH_MODE_TORCH;
558 for (size_t i=0; i < availableAeModes.count; i++) {
559 if (availableAeModes.data.u8[i] ==
560 ANDROID_CONTROL_AE_ON_AUTO_FLASH_REDEYE) {
561 supportedFlashModes = supportedFlashModes + "," +
562 CameraParameters::FLASH_MODE_RED_EYE;
563 break;
564 }
565 }
566 params.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES,
567 supportedFlashModes);
568 } else {
569 flashMode = Parameters::FLASH_MODE_OFF;
570 params.set(CameraParameters::KEY_FLASH_MODE,
571 CameraParameters::FLASH_MODE_OFF);
572 params.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES,
573 CameraParameters::FLASH_MODE_OFF);
574 }
575
576 camera_metadata_ro_entry_t minFocusDistance =
577 staticInfo(ANDROID_LENS_MINIMUM_FOCUS_DISTANCE, 1, 1);
578 if (!minFocusDistance.count) return NO_INIT;
579
580 camera_metadata_ro_entry_t availableAfModes =
581 staticInfo(ANDROID_CONTROL_AF_AVAILABLE_MODES);
582 if (!availableAfModes.count) return NO_INIT;
583
584 if (minFocusDistance.data.f[0] == 0) {
585 // Fixed-focus lens
586 focusMode = Parameters::FOCUS_MODE_FIXED;
587 params.set(CameraParameters::KEY_FOCUS_MODE,
588 CameraParameters::FOCUS_MODE_FIXED);
589 params.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES,
590 CameraParameters::FOCUS_MODE_FIXED);
591 } else {
592 focusMode = Parameters::FOCUS_MODE_AUTO;
593 params.set(CameraParameters::KEY_FOCUS_MODE,
594 CameraParameters::FOCUS_MODE_AUTO);
595 String8 supportedFocusModes(CameraParameters::FOCUS_MODE_INFINITY);
596 bool addComma = true;
597
598 for (size_t i=0; i < availableAfModes.count; i++) {
599 if (addComma) supportedFocusModes += ",";
600 addComma = true;
601 switch (availableAfModes.data.u8[i]) {
602 case ANDROID_CONTROL_AF_AUTO:
603 supportedFocusModes +=
604 CameraParameters::FOCUS_MODE_AUTO;
605 break;
606 case ANDROID_CONTROL_AF_MACRO:
607 supportedFocusModes +=
608 CameraParameters::FOCUS_MODE_MACRO;
609 break;
610 case ANDROID_CONTROL_AF_CONTINUOUS_VIDEO:
611 supportedFocusModes +=
612 CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO;
613 break;
614 case ANDROID_CONTROL_AF_CONTINUOUS_PICTURE:
615 supportedFocusModes +=
616 CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE;
617 break;
618 case ANDROID_CONTROL_AF_EDOF:
619 supportedFocusModes +=
620 CameraParameters::FOCUS_MODE_EDOF;
621 break;
622 // Not supported in old API
623 case ANDROID_CONTROL_AF_OFF:
624 addComma = false;
625 break;
626 default:
627 ALOGW("%s: Camera %d: Unknown AF mode value: %d",
628 __FUNCTION__, cameraId, availableAfModes.data.u8[i]);
629 addComma = false;
630 break;
631 }
632 }
633 params.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES,
634 supportedFocusModes);
635 }
636 focusState = ANDROID_CONTROL_AF_STATE_INACTIVE;
637 shadowFocusMode = FOCUS_MODE_INVALID;
638
639 camera_metadata_ro_entry_t max3aRegions =
640 staticInfo(ANDROID_CONTROL_MAX_REGIONS, 1, 1);
641 if (!max3aRegions.count) return NO_INIT;
642
643 int32_t maxNumFocusAreas = 0;
644 if (focusMode != Parameters::FOCUS_MODE_FIXED) {
645 maxNumFocusAreas = max3aRegions.data.i32[0];
646 }
647 params.set(CameraParameters::KEY_MAX_NUM_FOCUS_AREAS, maxNumFocusAreas);
648 params.set(CameraParameters::KEY_FOCUS_AREAS,
649 "(0,0,0,0,0)");
650 focusingAreas.clear();
651 focusingAreas.add(Parameters::Area(0,0,0,0,0));
652
653 camera_metadata_ro_entry_t availableFocalLengths =
654 staticInfo(ANDROID_LENS_AVAILABLE_FOCAL_LENGTHS);
655 if (!availableFocalLengths.count) return NO_INIT;
656
657 float minFocalLength = availableFocalLengths.data.f[0];
658 params.setFloat(CameraParameters::KEY_FOCAL_LENGTH, minFocalLength);
659
660 camera_metadata_ro_entry_t sensorSize =
661 staticInfo(ANDROID_SENSOR_PHYSICAL_SIZE, 2, 2);
662 if (!sensorSize.count) return NO_INIT;
663
664 // The fields of view here assume infinity focus, maximum wide angle
665 float horizFov = 180 / M_PI *
666 2 * atanf(sensorSize.data.f[0] / (2 * minFocalLength));
667 float vertFov = 180 / M_PI *
668 2 * atanf(sensorSize.data.f[1] / (2 * minFocalLength));
669 params.setFloat(CameraParameters::KEY_HORIZONTAL_VIEW_ANGLE, horizFov);
670 params.setFloat(CameraParameters::KEY_VERTICAL_VIEW_ANGLE, vertFov);
671
672 exposureCompensation = 0;
673 params.set(CameraParameters::KEY_EXPOSURE_COMPENSATION,
674 exposureCompensation);
675
676 camera_metadata_ro_entry_t exposureCompensationRange =
677 staticInfo(ANDROID_CONTROL_AE_EXP_COMPENSATION_RANGE, 2, 2);
678 if (!exposureCompensationRange.count) return NO_INIT;
679
680 params.set(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION,
681 exposureCompensationRange.data.i32[1]);
682 params.set(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION,
683 exposureCompensationRange.data.i32[0]);
684
685 camera_metadata_ro_entry_t exposureCompensationStep =
686 staticInfo(ANDROID_CONTROL_AE_EXP_COMPENSATION_STEP, 1, 1);
687 if (!exposureCompensationStep.count) return NO_INIT;
688
689 params.setFloat(CameraParameters::KEY_EXPOSURE_COMPENSATION_STEP,
690 (float)exposureCompensationStep.data.r[0].numerator /
691 exposureCompensationStep.data.r[0].denominator);
692
693 autoExposureLock = false;
694 params.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK,
695 CameraParameters::FALSE);
696 params.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED,
697 CameraParameters::TRUE);
698
699 autoWhiteBalanceLock = false;
700 params.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK,
701 CameraParameters::FALSE);
702 params.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED,
703 CameraParameters::TRUE);
704
705 meteringAreas.add(Parameters::Area(0, 0, 0, 0, 0));
706 params.set(CameraParameters::KEY_MAX_NUM_METERING_AREAS,
707 max3aRegions.data.i32[0]);
708 params.set(CameraParameters::KEY_METERING_AREAS,
709 "(0,0,0,0,0)");
710
711 zoom = 0;
712 params.set(CameraParameters::KEY_ZOOM, zoom);
713 params.set(CameraParameters::KEY_MAX_ZOOM, NUM_ZOOM_STEPS - 1);
714
715 camera_metadata_ro_entry_t maxDigitalZoom =
716 staticInfo(ANDROID_SCALER_AVAILABLE_MAX_ZOOM, /*minCount*/1, /*maxCount*/1);
717 if (!maxDigitalZoom.count) return NO_INIT;
718
719 {
720 String8 zoomRatios;
721 float zoom = 1.f;
722 float zoomIncrement = (maxDigitalZoom.data.f[0] - zoom) /
723 (NUM_ZOOM_STEPS-1);
724 bool addComma = false;
725 for (size_t i=0; i < NUM_ZOOM_STEPS; i++) {
726 if (addComma) zoomRatios += ",";
727 addComma = true;
728 zoomRatios += String8::format("%d", static_cast<int>(zoom * 100));
729 zoom += zoomIncrement;
730 }
731 params.set(CameraParameters::KEY_ZOOM_RATIOS, zoomRatios);
732 }
733
734 params.set(CameraParameters::KEY_ZOOM_SUPPORTED,
735 CameraParameters::TRUE);
736 params.set(CameraParameters::KEY_SMOOTH_ZOOM_SUPPORTED,
737 CameraParameters::FALSE);
738
739 params.set(CameraParameters::KEY_FOCUS_DISTANCES,
740 "Infinity,Infinity,Infinity");
741
742 params.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_HW,
743 fastInfo.maxFaces);
744 params.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_SW,
745 0);
746
747 params.set(CameraParameters::KEY_VIDEO_FRAME_FORMAT,
748 CameraParameters::PIXEL_FORMAT_ANDROID_OPAQUE);
749
750 recordingHint = false;
751 params.set(CameraParameters::KEY_RECORDING_HINT,
752 CameraParameters::FALSE);
753
754 params.set(CameraParameters::KEY_VIDEO_SNAPSHOT_SUPPORTED,
755 CameraParameters::TRUE);
756
757 videoStabilization = false;
758 params.set(CameraParameters::KEY_VIDEO_STABILIZATION,
759 CameraParameters::FALSE);
760
761 camera_metadata_ro_entry_t availableVideoStabilizationModes =
762 staticInfo(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES);
763 if (!availableVideoStabilizationModes.count) return NO_INIT;
764
765 if (availableVideoStabilizationModes.count > 1) {
766 params.set(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED,
767 CameraParameters::TRUE);
768 } else {
769 params.set(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED,
770 CameraParameters::FALSE);
771 }
772
773 // Set up initial state for non-Camera.Parameters state variables
774
775 storeMetadataInBuffers = true;
776 playShutterSound = true;
777 enableFaceDetect = false;
778
779 enableFocusMoveMessages = false;
780 afTriggerCounter = 1;
781 currentAfTriggerId = -1;
782 afInMotion = false;
783
784 precaptureTriggerCounter = 1;
785
786 previewCallbackFlags = 0;
787 previewCallbackOneShot = false;
788
789 char value[PROPERTY_VALUE_MAX];
790 property_get("camera.disable_zsl_mode", value, "0");
791 if (!strcmp(value,"1")) {
792 ALOGI("Camera %d: Disabling ZSL mode", cameraId);
793 zslMode = false;
794 } else {
795 zslMode = true;
796 }
797
798 lightFx = LIGHTFX_NONE;
799
800 state = STOPPED;
801
802 paramsFlattened = params.flatten();
803
804 return OK;
805 }
806
get() const807 String8 Parameters::get() const {
808 return paramsFlattened;
809 }
810
buildFastInfo()811 status_t Parameters::buildFastInfo() {
812
813 camera_metadata_ro_entry_t activeArraySize =
814 staticInfo(ANDROID_SENSOR_ACTIVE_ARRAY_SIZE, 2, 2);
815 if (!activeArraySize.count) return NO_INIT;
816 int32_t arrayWidth = activeArraySize.data.i32[0];
817 int32_t arrayHeight = activeArraySize.data.i32[1];
818
819 camera_metadata_ro_entry_t availableFaceDetectModes =
820 staticInfo(ANDROID_STATS_AVAILABLE_FACE_DETECT_MODES);
821 if (!availableFaceDetectModes.count) return NO_INIT;
822
823 uint8_t bestFaceDetectMode =
824 ANDROID_STATS_FACE_DETECTION_OFF;
825 for (size_t i = 0 ; i < availableFaceDetectModes.count; i++) {
826 switch (availableFaceDetectModes.data.u8[i]) {
827 case ANDROID_STATS_FACE_DETECTION_OFF:
828 break;
829 case ANDROID_STATS_FACE_DETECTION_SIMPLE:
830 if (bestFaceDetectMode !=
831 ANDROID_STATS_FACE_DETECTION_FULL) {
832 bestFaceDetectMode =
833 ANDROID_STATS_FACE_DETECTION_SIMPLE;
834 }
835 break;
836 case ANDROID_STATS_FACE_DETECTION_FULL:
837 bestFaceDetectMode =
838 ANDROID_STATS_FACE_DETECTION_FULL;
839 break;
840 default:
841 ALOGE("%s: Camera %d: Unknown face detect mode %d:",
842 __FUNCTION__, cameraId,
843 availableFaceDetectModes.data.u8[i]);
844 return NO_INIT;
845 }
846 }
847
848 camera_metadata_ro_entry_t maxFacesDetected =
849 staticInfo(ANDROID_STATS_MAX_FACE_COUNT, 1, 1);
850 if (!maxFacesDetected.count) return NO_INIT;
851
852 int32_t maxFaces = maxFacesDetected.data.i32[0];
853
854 camera_metadata_ro_entry_t availableSceneModes =
855 staticInfo(ANDROID_CONTROL_AVAILABLE_SCENE_MODES);
856 camera_metadata_ro_entry_t sceneModeOverrides =
857 staticInfo(ANDROID_CONTROL_SCENE_MODE_OVERRIDES);
858 camera_metadata_ro_entry_t minFocusDistance =
859 staticInfo(ANDROID_LENS_MINIMUM_FOCUS_DISTANCE);
860 bool fixedLens = (minFocusDistance.data.f[0] == 0);
861
862 if (sceneModeOverrides.count > 0) {
863 // sceneModeOverrides is defined to have 3 entries for each scene mode,
864 // which are AE, AWB, and AF override modes the HAL wants for that scene
865 // mode.
866 const size_t kModesPerSceneMode = 3;
867 if (sceneModeOverrides.count !=
868 availableSceneModes.count * kModesPerSceneMode) {
869 ALOGE("%s: Camera %d: Scene mode override list is an "
870 "unexpected size: %d (expected %d)", __FUNCTION__,
871 cameraId, sceneModeOverrides.count,
872 availableSceneModes.count);
873 return NO_INIT;
874 }
875 for (size_t i = 0; i < availableSceneModes.count; i++) {
876 DeviceInfo::OverrideModes modes;
877 uint8_t aeMode =
878 sceneModeOverrides.data.u8[i * kModesPerSceneMode + 0];
879 switch(aeMode) {
880 case ANDROID_CONTROL_AE_ON:
881 modes.flashMode = FLASH_MODE_OFF;
882 break;
883 case ANDROID_CONTROL_AE_ON_AUTO_FLASH:
884 modes.flashMode = FLASH_MODE_AUTO;
885 break;
886 case ANDROID_CONTROL_AE_ON_ALWAYS_FLASH:
887 modes.flashMode = FLASH_MODE_ON;
888 break;
889 case ANDROID_CONTROL_AE_ON_AUTO_FLASH_REDEYE:
890 modes.flashMode = FLASH_MODE_RED_EYE;
891 break;
892 default:
893 ALOGE("%s: Unknown override AE mode: %d", __FUNCTION__,
894 aeMode);
895 modes.flashMode = FLASH_MODE_INVALID;
896 break;
897 }
898 modes.wbMode =
899 sceneModeOverrides.data.u8[i * kModesPerSceneMode + 1];
900 uint8_t afMode =
901 sceneModeOverrides.data.u8[i * kModesPerSceneMode + 2];
902 switch(afMode) {
903 case ANDROID_CONTROL_AF_OFF:
904 modes.focusMode = fixedLens ?
905 FOCUS_MODE_FIXED : FOCUS_MODE_INFINITY;
906 break;
907 case ANDROID_CONTROL_AF_AUTO:
908 case ANDROID_CONTROL_AF_MACRO:
909 case ANDROID_CONTROL_AF_CONTINUOUS_VIDEO:
910 case ANDROID_CONTROL_AF_CONTINUOUS_PICTURE:
911 case ANDROID_CONTROL_AF_EDOF:
912 modes.focusMode = static_cast<focusMode_t>(afMode);
913 break;
914 default:
915 ALOGE("%s: Unknown override AF mode: %d", __FUNCTION__,
916 afMode);
917 modes.focusMode = FOCUS_MODE_INVALID;
918 break;
919 }
920 fastInfo.sceneModeOverrides.add(availableSceneModes.data.u8[i],
921 modes);
922 }
923 }
924
925 fastInfo.arrayWidth = arrayWidth;
926 fastInfo.arrayHeight = arrayHeight;
927 fastInfo.bestFaceDetectMode = bestFaceDetectMode;
928 fastInfo.maxFaces = maxFaces;
929 return OK;
930 }
931
buildQuirks()932 status_t Parameters::buildQuirks() {
933 camera_metadata_ro_entry_t entry;
934 entry = info->find(ANDROID_QUIRKS_TRIGGER_AF_WITH_AUTO);
935 quirks.triggerAfWithAuto = (entry.count != 0 && entry.data.u8[0] == 1);
936 ALOGV_IF(quirks.triggerAfWithAuto, "Camera %d: Quirk triggerAfWithAuto enabled",
937 cameraId);
938
939 entry = info->find(ANDROID_QUIRKS_USE_ZSL_FORMAT);
940 quirks.useZslFormat = (entry.count != 0 && entry.data.u8[0] == 1);
941 ALOGV_IF(quirks.useZslFormat, "Camera %d: Quirk useZslFormat enabled",
942 cameraId);
943
944 entry = info->find(ANDROID_QUIRKS_METERING_CROP_REGION);
945 quirks.meteringCropRegion = (entry.count != 0 && entry.data.u8[0] == 1);
946 ALOGV_IF(quirks.meteringCropRegion, "Camera %d: Quirk meteringCropRegion"
947 " enabled", cameraId);
948
949 return OK;
950 }
951
staticInfo(uint32_t tag,size_t minCount,size_t maxCount) const952 camera_metadata_ro_entry_t Parameters::staticInfo(uint32_t tag,
953 size_t minCount, size_t maxCount) const {
954 status_t res;
955 camera_metadata_ro_entry_t entry = info->find(tag);
956
957 if (CC_UNLIKELY( entry.count == 0 )) {
958 const char* tagSection = get_camera_metadata_section_name(tag);
959 if (tagSection == NULL) tagSection = "<unknown>";
960 const char* tagName = get_camera_metadata_tag_name(tag);
961 if (tagName == NULL) tagName = "<unknown>";
962
963 ALOGE("Error finding static metadata entry '%s.%s' (%x)",
964 tagSection, tagName, tag);
965 } else if (CC_UNLIKELY(
966 (minCount != 0 && entry.count < minCount) ||
967 (maxCount != 0 && entry.count > maxCount) ) ) {
968 const char* tagSection = get_camera_metadata_section_name(tag);
969 if (tagSection == NULL) tagSection = "<unknown>";
970 const char* tagName = get_camera_metadata_tag_name(tag);
971 if (tagName == NULL) tagName = "<unknown>";
972 ALOGE("Malformed static metadata entry '%s.%s' (%x):"
973 "Expected between %d and %d values, but got %d values",
974 tagSection, tagName, tag, minCount, maxCount, entry.count);
975 }
976
977 return entry;
978 }
979
set(const String8 & paramString)980 status_t Parameters::set(const String8& paramString) {
981 status_t res;
982
983 CameraParameters newParams(paramString);
984
985 // TODO: Currently ignoring any changes to supposedly read-only parameters
986 // such as supported preview sizes, etc. Should probably produce an error if
987 // they're changed.
988
989 /** Extract and verify new parameters */
990
991 size_t i;
992
993 Parameters validatedParams(*this);
994
995 // PREVIEW_SIZE
996 newParams.getPreviewSize(&validatedParams.previewWidth,
997 &validatedParams.previewHeight);
998
999 if (validatedParams.previewWidth != previewWidth ||
1000 validatedParams.previewHeight != previewHeight) {
1001 if (state >= PREVIEW) {
1002 ALOGE("%s: Preview size cannot be updated when preview "
1003 "is active! (Currently %d x %d, requested %d x %d",
1004 __FUNCTION__,
1005 previewWidth, previewHeight,
1006 validatedParams.previewWidth, validatedParams.previewHeight);
1007 return BAD_VALUE;
1008 }
1009 camera_metadata_ro_entry_t availablePreviewSizes =
1010 staticInfo(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES);
1011 for (i = 0; i < availablePreviewSizes.count; i += 2 ) {
1012 if ((availablePreviewSizes.data.i32[i] ==
1013 validatedParams.previewWidth) &&
1014 (availablePreviewSizes.data.i32[i+1] ==
1015 validatedParams.previewHeight)) break;
1016 }
1017 if (i == availablePreviewSizes.count) {
1018 ALOGE("%s: Requested preview size %d x %d is not supported",
1019 __FUNCTION__, validatedParams.previewWidth,
1020 validatedParams.previewHeight);
1021 return BAD_VALUE;
1022 }
1023 }
1024
1025 // RECORDING_HINT (always supported)
1026 validatedParams.recordingHint = boolFromString(
1027 newParams.get(CameraParameters::KEY_RECORDING_HINT) );
1028 bool recordingHintChanged = validatedParams.recordingHint != recordingHint;
1029 ALOGV_IF(recordingHintChanged, "%s: Recording hint changed to %d",
1030 __FUNCTION__, recordingHintChanged);
1031
1032 // PREVIEW_FPS_RANGE
1033 bool fpsRangeChanged = false;
1034 newParams.getPreviewFpsRange(&validatedParams.previewFpsRange[0],
1035 &validatedParams.previewFpsRange[1]);
1036 validatedParams.previewFpsRange[0] /= kFpsToApiScale;
1037 validatedParams.previewFpsRange[1] /= kFpsToApiScale;
1038
1039 if (validatedParams.previewFpsRange[0] != previewFpsRange[0] ||
1040 validatedParams.previewFpsRange[1] != previewFpsRange[1]) {
1041 fpsRangeChanged = true;
1042 camera_metadata_ro_entry_t availablePreviewFpsRanges =
1043 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES, 2);
1044 for (i = 0; i < availablePreviewFpsRanges.count; i += 2) {
1045 if ((availablePreviewFpsRanges.data.i32[i] ==
1046 validatedParams.previewFpsRange[0]) &&
1047 (availablePreviewFpsRanges.data.i32[i+1] ==
1048 validatedParams.previewFpsRange[1]) ) {
1049 break;
1050 }
1051 }
1052 if (i == availablePreviewFpsRanges.count) {
1053 ALOGE("%s: Requested preview FPS range %d - %d is not supported",
1054 __FUNCTION__, validatedParams.previewFpsRange[0],
1055 validatedParams.previewFpsRange[1]);
1056 return BAD_VALUE;
1057 }
1058 validatedParams.previewFps =
1059 fpsFromRange(validatedParams.previewFpsRange[0],
1060 validatedParams.previewFpsRange[1]);
1061 newParams.setPreviewFrameRate(validatedParams.previewFps);
1062 }
1063
1064 // PREVIEW_FORMAT
1065 validatedParams.previewFormat =
1066 formatStringToEnum(newParams.getPreviewFormat());
1067 if (validatedParams.previewFormat != previewFormat) {
1068 if (state >= PREVIEW) {
1069 ALOGE("%s: Preview format cannot be updated when preview "
1070 "is active!", __FUNCTION__);
1071 return BAD_VALUE;
1072 }
1073 camera_metadata_ro_entry_t availableFormats =
1074 staticInfo(ANDROID_SCALER_AVAILABLE_FORMATS);
1075 for (i = 0; i < availableFormats.count; i++) {
1076 if (availableFormats.data.i32[i] == validatedParams.previewFormat)
1077 break;
1078 }
1079 if (i == availableFormats.count) {
1080 ALOGE("%s: Requested preview format %s (0x%x) is not supported",
1081 __FUNCTION__, newParams.getPreviewFormat(),
1082 validatedParams.previewFormat);
1083 return BAD_VALUE;
1084 }
1085 }
1086
1087 // PREVIEW_FRAME_RATE
1088 // Deprecated, only use if the preview fps range is unchanged this time.
1089 // The single-value FPS is the same as the minimum of the range.
1090 if (!fpsRangeChanged) {
1091 validatedParams.previewFps = newParams.getPreviewFrameRate();
1092 if (validatedParams.previewFps != previewFps || recordingHintChanged) {
1093 camera_metadata_ro_entry_t availableFrameRates =
1094 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES);
1095 /**
1096 * If recording hint is set, find the range that encompasses
1097 * previewFps with the largest min index.
1098 *
1099 * If recording hint is not set, find the range with previewFps
1100 * with the smallest min index.
1101 *
1102 * Either way, in case of multiple ranges, break the tie by
1103 * selecting the smaller range.
1104 */
1105 int targetFps = validatedParams.previewFps;
1106 // all ranges which have targetFps
1107 Vector<Range> candidateRanges;
1108 for (i = 0; i < availableFrameRates.count; i+=2) {
1109 Range r = {
1110 availableFrameRates.data.i32[i],
1111 availableFrameRates.data.i32[i+1]
1112 };
1113
1114 if (r.min <= targetFps && targetFps <= r.max) {
1115 candidateRanges.push(r);
1116 }
1117 }
1118 if (candidateRanges.isEmpty()) {
1119 ALOGE("%s: Requested preview frame rate %d is not supported",
1120 __FUNCTION__, validatedParams.previewFps);
1121 return BAD_VALUE;
1122 }
1123 // most applicable range with targetFps
1124 Range bestRange = candidateRanges[0];
1125 for (i = 1; i < candidateRanges.size(); ++i) {
1126 Range r = candidateRanges[i];
1127
1128 // Find by largest minIndex in recording mode
1129 if (validatedParams.recordingHint) {
1130 if (r.min > bestRange.min) {
1131 bestRange = r;
1132 }
1133 else if (r.min == bestRange.min && r.max < bestRange.max) {
1134 bestRange = r;
1135 }
1136 }
1137 // Find by smallest minIndex in preview mode
1138 else {
1139 if (r.min < bestRange.min) {
1140 bestRange = r;
1141 }
1142 else if (r.min == bestRange.min && r.max < bestRange.max) {
1143 bestRange = r;
1144 }
1145 }
1146 }
1147
1148 validatedParams.previewFpsRange[0] =
1149 bestRange.min;
1150 validatedParams.previewFpsRange[1] =
1151 bestRange.max;
1152
1153 ALOGV("%s: New preview FPS range: %d, %d, recordingHint = %d",
1154 __FUNCTION__,
1155 validatedParams.previewFpsRange[0],
1156 validatedParams.previewFpsRange[1],
1157 validatedParams.recordingHint);
1158 }
1159 newParams.set(CameraParameters::KEY_PREVIEW_FPS_RANGE,
1160 String8::format("%d,%d",
1161 validatedParams.previewFpsRange[0] * kFpsToApiScale,
1162 validatedParams.previewFpsRange[1] * kFpsToApiScale));
1163
1164 }
1165
1166 // PICTURE_SIZE
1167 newParams.getPictureSize(&validatedParams.pictureWidth,
1168 &validatedParams.pictureHeight);
1169 if (validatedParams.pictureWidth == pictureWidth ||
1170 validatedParams.pictureHeight == pictureHeight) {
1171 camera_metadata_ro_entry_t availablePictureSizes =
1172 staticInfo(ANDROID_SCALER_AVAILABLE_JPEG_SIZES);
1173 for (i = 0; i < availablePictureSizes.count; i+=2) {
1174 if ((availablePictureSizes.data.i32[i] ==
1175 validatedParams.pictureWidth) &&
1176 (availablePictureSizes.data.i32[i+1] ==
1177 validatedParams.pictureHeight)) break;
1178 }
1179 if (i == availablePictureSizes.count) {
1180 ALOGE("%s: Requested picture size %d x %d is not supported",
1181 __FUNCTION__, validatedParams.pictureWidth,
1182 validatedParams.pictureHeight);
1183 return BAD_VALUE;
1184 }
1185 }
1186
1187 // JPEG_THUMBNAIL_WIDTH/HEIGHT
1188 validatedParams.jpegThumbSize[0] =
1189 newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH);
1190 validatedParams.jpegThumbSize[1] =
1191 newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT);
1192 if (validatedParams.jpegThumbSize[0] != jpegThumbSize[0] ||
1193 validatedParams.jpegThumbSize[1] != jpegThumbSize[1]) {
1194 camera_metadata_ro_entry_t availableJpegThumbSizes =
1195 staticInfo(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES);
1196 for (i = 0; i < availableJpegThumbSizes.count; i+=2) {
1197 if ((availableJpegThumbSizes.data.i32[i] ==
1198 validatedParams.jpegThumbSize[0]) &&
1199 (availableJpegThumbSizes.data.i32[i+1] ==
1200 validatedParams.jpegThumbSize[1])) break;
1201 }
1202 if (i == availableJpegThumbSizes.count) {
1203 ALOGE("%s: Requested JPEG thumbnail size %d x %d is not supported",
1204 __FUNCTION__, validatedParams.jpegThumbSize[0],
1205 validatedParams.jpegThumbSize[1]);
1206 return BAD_VALUE;
1207 }
1208 }
1209
1210 // JPEG_THUMBNAIL_QUALITY
1211 validatedParams.jpegThumbQuality =
1212 newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY);
1213 if (validatedParams.jpegThumbQuality < 0 ||
1214 validatedParams.jpegThumbQuality > 100) {
1215 ALOGE("%s: Requested JPEG thumbnail quality %d is not supported",
1216 __FUNCTION__, validatedParams.jpegThumbQuality);
1217 return BAD_VALUE;
1218 }
1219
1220 // JPEG_QUALITY
1221 validatedParams.jpegQuality =
1222 newParams.getInt(CameraParameters::KEY_JPEG_QUALITY);
1223 if (validatedParams.jpegQuality < 0 || validatedParams.jpegQuality > 100) {
1224 ALOGE("%s: Requested JPEG quality %d is not supported",
1225 __FUNCTION__, validatedParams.jpegQuality);
1226 return BAD_VALUE;
1227 }
1228
1229 // ROTATION
1230 validatedParams.jpegRotation =
1231 newParams.getInt(CameraParameters::KEY_ROTATION);
1232 if (validatedParams.jpegRotation != 0 &&
1233 validatedParams.jpegRotation != 90 &&
1234 validatedParams.jpegRotation != 180 &&
1235 validatedParams.jpegRotation != 270) {
1236 ALOGE("%s: Requested picture rotation angle %d is not supported",
1237 __FUNCTION__, validatedParams.jpegRotation);
1238 return BAD_VALUE;
1239 }
1240
1241 // GPS
1242
1243 const char *gpsLatStr =
1244 newParams.get(CameraParameters::KEY_GPS_LATITUDE);
1245 if (gpsLatStr != NULL) {
1246 const char *gpsLongStr =
1247 newParams.get(CameraParameters::KEY_GPS_LONGITUDE);
1248 const char *gpsAltitudeStr =
1249 newParams.get(CameraParameters::KEY_GPS_ALTITUDE);
1250 const char *gpsTimeStr =
1251 newParams.get(CameraParameters::KEY_GPS_TIMESTAMP);
1252 const char *gpsProcMethodStr =
1253 newParams.get(CameraParameters::KEY_GPS_PROCESSING_METHOD);
1254 if (gpsLongStr == NULL ||
1255 gpsAltitudeStr == NULL ||
1256 gpsTimeStr == NULL ||
1257 gpsProcMethodStr == NULL) {
1258 ALOGE("%s: Incomplete set of GPS parameters provided",
1259 __FUNCTION__);
1260 return BAD_VALUE;
1261 }
1262 char *endPtr;
1263 errno = 0;
1264 validatedParams.gpsCoordinates[0] = strtod(gpsLatStr, &endPtr);
1265 if (errno || endPtr == gpsLatStr) {
1266 ALOGE("%s: Malformed GPS latitude: %s", __FUNCTION__, gpsLatStr);
1267 return BAD_VALUE;
1268 }
1269 errno = 0;
1270 validatedParams.gpsCoordinates[1] = strtod(gpsLongStr, &endPtr);
1271 if (errno || endPtr == gpsLongStr) {
1272 ALOGE("%s: Malformed GPS longitude: %s", __FUNCTION__, gpsLongStr);
1273 return BAD_VALUE;
1274 }
1275 errno = 0;
1276 validatedParams.gpsCoordinates[2] = strtod(gpsAltitudeStr, &endPtr);
1277 if (errno || endPtr == gpsAltitudeStr) {
1278 ALOGE("%s: Malformed GPS altitude: %s", __FUNCTION__,
1279 gpsAltitudeStr);
1280 return BAD_VALUE;
1281 }
1282 errno = 0;
1283 validatedParams.gpsTimestamp = strtoll(gpsTimeStr, &endPtr, 10);
1284 if (errno || endPtr == gpsTimeStr) {
1285 ALOGE("%s: Malformed GPS timestamp: %s", __FUNCTION__, gpsTimeStr);
1286 return BAD_VALUE;
1287 }
1288 validatedParams.gpsProcessingMethod = gpsProcMethodStr;
1289
1290 validatedParams.gpsEnabled = true;
1291 } else {
1292 validatedParams.gpsEnabled = false;
1293 }
1294
1295 // EFFECT
1296 validatedParams.effectMode = effectModeStringToEnum(
1297 newParams.get(CameraParameters::KEY_EFFECT) );
1298 if (validatedParams.effectMode != effectMode) {
1299 camera_metadata_ro_entry_t availableEffectModes =
1300 staticInfo(ANDROID_CONTROL_AVAILABLE_EFFECTS);
1301 for (i = 0; i < availableEffectModes.count; i++) {
1302 if (validatedParams.effectMode == availableEffectModes.data.u8[i]) break;
1303 }
1304 if (i == availableEffectModes.count) {
1305 ALOGE("%s: Requested effect mode \"%s\" is not supported",
1306 __FUNCTION__,
1307 newParams.get(CameraParameters::KEY_EFFECT) );
1308 return BAD_VALUE;
1309 }
1310 }
1311
1312 // ANTIBANDING
1313 validatedParams.antibandingMode = abModeStringToEnum(
1314 newParams.get(CameraParameters::KEY_ANTIBANDING) );
1315 if (validatedParams.antibandingMode != antibandingMode) {
1316 camera_metadata_ro_entry_t availableAbModes =
1317 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES);
1318 for (i = 0; i < availableAbModes.count; i++) {
1319 if (validatedParams.antibandingMode == availableAbModes.data.u8[i])
1320 break;
1321 }
1322 if (i == availableAbModes.count) {
1323 ALOGE("%s: Requested antibanding mode \"%s\" is not supported",
1324 __FUNCTION__,
1325 newParams.get(CameraParameters::KEY_ANTIBANDING));
1326 return BAD_VALUE;
1327 }
1328 }
1329
1330 // SCENE_MODE
1331 validatedParams.sceneMode = sceneModeStringToEnum(
1332 newParams.get(CameraParameters::KEY_SCENE_MODE) );
1333 if (validatedParams.sceneMode != sceneMode &&
1334 validatedParams.sceneMode !=
1335 ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED) {
1336 camera_metadata_ro_entry_t availableSceneModes =
1337 staticInfo(ANDROID_CONTROL_AVAILABLE_SCENE_MODES);
1338 for (i = 0; i < availableSceneModes.count; i++) {
1339 if (validatedParams.sceneMode == availableSceneModes.data.u8[i])
1340 break;
1341 }
1342 if (i == availableSceneModes.count) {
1343 ALOGE("%s: Requested scene mode \"%s\" is not supported",
1344 __FUNCTION__,
1345 newParams.get(CameraParameters::KEY_SCENE_MODE));
1346 return BAD_VALUE;
1347 }
1348 }
1349 bool sceneModeSet =
1350 validatedParams.sceneMode != ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED;
1351
1352 // FLASH_MODE
1353 if (sceneModeSet) {
1354 validatedParams.flashMode =
1355 fastInfo.sceneModeOverrides.
1356 valueFor(validatedParams.sceneMode).flashMode;
1357 } else {
1358 validatedParams.flashMode = FLASH_MODE_INVALID;
1359 }
1360 if (validatedParams.flashMode == FLASH_MODE_INVALID) {
1361 validatedParams.flashMode = flashModeStringToEnum(
1362 newParams.get(CameraParameters::KEY_FLASH_MODE) );
1363 }
1364
1365 if (validatedParams.flashMode != flashMode) {
1366 camera_metadata_ro_entry_t flashAvailable =
1367 staticInfo(ANDROID_FLASH_AVAILABLE, 1, 1);
1368 if (!flashAvailable.data.u8[0] &&
1369 validatedParams.flashMode != Parameters::FLASH_MODE_OFF) {
1370 ALOGE("%s: Requested flash mode \"%s\" is not supported: "
1371 "No flash on device", __FUNCTION__,
1372 newParams.get(CameraParameters::KEY_FLASH_MODE));
1373 return BAD_VALUE;
1374 } else if (validatedParams.flashMode == Parameters::FLASH_MODE_RED_EYE) {
1375 camera_metadata_ro_entry_t availableAeModes =
1376 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_MODES);
1377 for (i = 0; i < availableAeModes.count; i++) {
1378 if (validatedParams.flashMode == availableAeModes.data.u8[i])
1379 break;
1380 }
1381 if (i == availableAeModes.count) {
1382 ALOGE("%s: Requested flash mode \"%s\" is not supported",
1383 __FUNCTION__,
1384 newParams.get(CameraParameters::KEY_FLASH_MODE));
1385 return BAD_VALUE;
1386 }
1387 } else if (validatedParams.flashMode == -1) {
1388 ALOGE("%s: Requested flash mode \"%s\" is unknown",
1389 __FUNCTION__,
1390 newParams.get(CameraParameters::KEY_FLASH_MODE));
1391 return BAD_VALUE;
1392 }
1393 // Update in case of override
1394 newParams.set(CameraParameters::KEY_FLASH_MODE,
1395 flashModeEnumToString(validatedParams.flashMode));
1396 }
1397
1398 // WHITE_BALANCE
1399 if (sceneModeSet) {
1400 validatedParams.wbMode =
1401 fastInfo.sceneModeOverrides.
1402 valueFor(validatedParams.sceneMode).wbMode;
1403 } else {
1404 validatedParams.wbMode = ANDROID_CONTROL_AWB_OFF;
1405 }
1406 if (validatedParams.wbMode == ANDROID_CONTROL_AWB_OFF) {
1407 validatedParams.wbMode = wbModeStringToEnum(
1408 newParams.get(CameraParameters::KEY_WHITE_BALANCE) );
1409 }
1410 if (validatedParams.wbMode != wbMode) {
1411 camera_metadata_ro_entry_t availableWbModes =
1412 staticInfo(ANDROID_CONTROL_AWB_AVAILABLE_MODES);
1413 for (i = 0; i < availableWbModes.count; i++) {
1414 if (validatedParams.wbMode == availableWbModes.data.u8[i]) break;
1415 }
1416 if (i == availableWbModes.count) {
1417 ALOGE("%s: Requested white balance mode %s is not supported",
1418 __FUNCTION__,
1419 newParams.get(CameraParameters::KEY_WHITE_BALANCE));
1420 return BAD_VALUE;
1421 }
1422 // Update in case of override
1423 newParams.set(CameraParameters::KEY_WHITE_BALANCE,
1424 wbModeEnumToString(validatedParams.wbMode));
1425 }
1426
1427 // FOCUS_MODE
1428 if (sceneModeSet) {
1429 validatedParams.focusMode =
1430 fastInfo.sceneModeOverrides.
1431 valueFor(validatedParams.sceneMode).focusMode;
1432 } else {
1433 validatedParams.focusMode = FOCUS_MODE_INVALID;
1434 }
1435 if (validatedParams.focusMode == FOCUS_MODE_INVALID) {
1436 validatedParams.focusMode = focusModeStringToEnum(
1437 newParams.get(CameraParameters::KEY_FOCUS_MODE) );
1438 }
1439 if (validatedParams.focusMode != focusMode) {
1440 validatedParams.currentAfTriggerId = -1;
1441 if (validatedParams.focusMode != Parameters::FOCUS_MODE_FIXED) {
1442 camera_metadata_ro_entry_t minFocusDistance =
1443 staticInfo(ANDROID_LENS_MINIMUM_FOCUS_DISTANCE);
1444 if (minFocusDistance.data.f[0] == 0) {
1445 ALOGE("%s: Requested focus mode \"%s\" is not available: "
1446 "fixed focus lens",
1447 __FUNCTION__,
1448 newParams.get(CameraParameters::KEY_FOCUS_MODE));
1449 return BAD_VALUE;
1450 } else if (validatedParams.focusMode !=
1451 Parameters::FOCUS_MODE_INFINITY) {
1452 camera_metadata_ro_entry_t availableFocusModes =
1453 staticInfo(ANDROID_CONTROL_AF_AVAILABLE_MODES);
1454 for (i = 0; i < availableFocusModes.count; i++) {
1455 if (validatedParams.focusMode ==
1456 availableFocusModes.data.u8[i]) break;
1457 }
1458 if (i == availableFocusModes.count) {
1459 ALOGE("%s: Requested focus mode \"%s\" is not supported",
1460 __FUNCTION__,
1461 newParams.get(CameraParameters::KEY_FOCUS_MODE));
1462 return BAD_VALUE;
1463 }
1464 }
1465 }
1466 validatedParams.focusState = ANDROID_CONTROL_AF_STATE_INACTIVE;
1467 // Always reset shadow focus mode to avoid reverting settings
1468 validatedParams.shadowFocusMode = FOCUS_MODE_INVALID;
1469 // Update in case of override
1470 newParams.set(CameraParameters::KEY_FOCUS_MODE,
1471 focusModeEnumToString(validatedParams.focusMode));
1472 } else {
1473 validatedParams.currentAfTriggerId = currentAfTriggerId;
1474 }
1475
1476 // FOCUS_AREAS
1477 res = parseAreas(newParams.get(CameraParameters::KEY_FOCUS_AREAS),
1478 &validatedParams.focusingAreas);
1479 size_t max3aRegions =
1480 (size_t)staticInfo(ANDROID_CONTROL_MAX_REGIONS, 1, 1).data.i32[0];
1481 if (res == OK) res = validateAreas(validatedParams.focusingAreas,
1482 max3aRegions, AREA_KIND_FOCUS);
1483 if (res != OK) {
1484 ALOGE("%s: Requested focus areas are malformed: %s",
1485 __FUNCTION__, newParams.get(CameraParameters::KEY_FOCUS_AREAS));
1486 return BAD_VALUE;
1487 }
1488
1489 // EXPOSURE_COMPENSATION
1490 validatedParams.exposureCompensation =
1491 newParams.getInt(CameraParameters::KEY_EXPOSURE_COMPENSATION);
1492 camera_metadata_ro_entry_t exposureCompensationRange =
1493 staticInfo(ANDROID_CONTROL_AE_EXP_COMPENSATION_RANGE);
1494 if ((validatedParams.exposureCompensation <
1495 exposureCompensationRange.data.i32[0]) ||
1496 (validatedParams.exposureCompensation >
1497 exposureCompensationRange.data.i32[1])) {
1498 ALOGE("%s: Requested exposure compensation index is out of bounds: %d",
1499 __FUNCTION__, validatedParams.exposureCompensation);
1500 return BAD_VALUE;
1501 }
1502
1503 // AUTO_EXPOSURE_LOCK (always supported)
1504 validatedParams.autoExposureLock = boolFromString(
1505 newParams.get(CameraParameters::KEY_AUTO_EXPOSURE_LOCK));
1506
1507 // AUTO_WHITEBALANCE_LOCK (always supported)
1508 validatedParams.autoWhiteBalanceLock = boolFromString(
1509 newParams.get(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK));
1510
1511 // METERING_AREAS
1512 res = parseAreas(newParams.get(CameraParameters::KEY_METERING_AREAS),
1513 &validatedParams.meteringAreas);
1514 if (res == OK) {
1515 res = validateAreas(validatedParams.meteringAreas, max3aRegions,
1516 AREA_KIND_METERING);
1517 }
1518 if (res != OK) {
1519 ALOGE("%s: Requested metering areas are malformed: %s",
1520 __FUNCTION__,
1521 newParams.get(CameraParameters::KEY_METERING_AREAS));
1522 return BAD_VALUE;
1523 }
1524
1525 // ZOOM
1526 validatedParams.zoom = newParams.getInt(CameraParameters::KEY_ZOOM);
1527 if (validatedParams.zoom < 0
1528 || validatedParams.zoom >= (int)NUM_ZOOM_STEPS) {
1529 ALOGE("%s: Requested zoom level %d is not supported",
1530 __FUNCTION__, validatedParams.zoom);
1531 return BAD_VALUE;
1532 }
1533
1534 // VIDEO_SIZE
1535 newParams.getVideoSize(&validatedParams.videoWidth,
1536 &validatedParams.videoHeight);
1537 if (validatedParams.videoWidth != videoWidth ||
1538 validatedParams.videoHeight != videoHeight) {
1539 if (state == RECORD) {
1540 ALOGE("%s: Video size cannot be updated when recording is active!",
1541 __FUNCTION__);
1542 return BAD_VALUE;
1543 }
1544 camera_metadata_ro_entry_t availableVideoSizes =
1545 staticInfo(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES);
1546 for (i = 0; i < availableVideoSizes.count; i += 2 ) {
1547 if ((availableVideoSizes.data.i32[i] ==
1548 validatedParams.videoWidth) &&
1549 (availableVideoSizes.data.i32[i+1] ==
1550 validatedParams.videoHeight)) break;
1551 }
1552 if (i == availableVideoSizes.count) {
1553 ALOGE("%s: Requested video size %d x %d is not supported",
1554 __FUNCTION__, validatedParams.videoWidth,
1555 validatedParams.videoHeight);
1556 return BAD_VALUE;
1557 }
1558 }
1559
1560 // VIDEO_STABILIZATION
1561 validatedParams.videoStabilization = boolFromString(
1562 newParams.get(CameraParameters::KEY_VIDEO_STABILIZATION) );
1563 camera_metadata_ro_entry_t availableVideoStabilizationModes =
1564 staticInfo(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES);
1565 if (validatedParams.videoStabilization &&
1566 availableVideoStabilizationModes.count == 1) {
1567 ALOGE("%s: Video stabilization not supported", __FUNCTION__);
1568 }
1569
1570 /** Update internal parameters */
1571
1572 *this = validatedParams;
1573
1574 // Need to flatten again in case of overrides
1575 paramsFlattened = newParams.flatten();
1576 params = newParams;
1577
1578 return OK;
1579 }
1580
updateRequest(CameraMetadata * request) const1581 status_t Parameters::updateRequest(CameraMetadata *request) const {
1582 ATRACE_CALL();
1583 status_t res;
1584
1585 uint8_t metadataMode = ANDROID_REQUEST_METADATA_FULL;
1586 res = request->update(ANDROID_REQUEST_METADATA_MODE,
1587 &metadataMode, 1);
1588 if (res != OK) return res;
1589
1590 res = request->update(ANDROID_CONTROL_AE_TARGET_FPS_RANGE,
1591 previewFpsRange, 2);
1592 if (res != OK) return res;
1593
1594 uint8_t reqWbLock = autoWhiteBalanceLock ?
1595 ANDROID_CONTROL_AWB_LOCK_ON : ANDROID_CONTROL_AWB_LOCK_OFF;
1596 res = request->update(ANDROID_CONTROL_AWB_LOCK,
1597 &reqWbLock, 1);
1598
1599 res = request->update(ANDROID_CONTROL_EFFECT_MODE,
1600 &effectMode, 1);
1601 if (res != OK) return res;
1602 res = request->update(ANDROID_CONTROL_AE_ANTIBANDING_MODE,
1603 &antibandingMode, 1);
1604 if (res != OK) return res;
1605
1606 // android.hardware.Camera requires that when face detect is enabled, the
1607 // camera is in a face-priority mode. HAL2 splits this into separate parts
1608 // (face detection statistics and face priority scene mode). Map from other
1609 // to the other.
1610 bool sceneModeActive =
1611 sceneMode != (uint8_t)ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED;
1612 uint8_t reqControlMode = ANDROID_CONTROL_AUTO;
1613 if (enableFaceDetect || sceneModeActive) {
1614 reqControlMode = ANDROID_CONTROL_USE_SCENE_MODE;
1615 }
1616 res = request->update(ANDROID_CONTROL_MODE,
1617 &reqControlMode, 1);
1618 if (res != OK) return res;
1619
1620 uint8_t reqSceneMode =
1621 sceneModeActive ? sceneMode :
1622 enableFaceDetect ? (uint8_t)ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY :
1623 (uint8_t)ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED;
1624 res = request->update(ANDROID_CONTROL_SCENE_MODE,
1625 &reqSceneMode, 1);
1626 if (res != OK) return res;
1627
1628 uint8_t reqFlashMode = ANDROID_FLASH_OFF;
1629 uint8_t reqAeMode = ANDROID_CONTROL_AE_OFF;
1630 switch (flashMode) {
1631 case Parameters::FLASH_MODE_OFF:
1632 reqAeMode = ANDROID_CONTROL_AE_ON; break;
1633 case Parameters::FLASH_MODE_AUTO:
1634 reqAeMode = ANDROID_CONTROL_AE_ON_AUTO_FLASH; break;
1635 case Parameters::FLASH_MODE_ON:
1636 reqAeMode = ANDROID_CONTROL_AE_ON_ALWAYS_FLASH; break;
1637 case Parameters::FLASH_MODE_TORCH:
1638 reqAeMode = ANDROID_CONTROL_AE_ON;
1639 reqFlashMode = ANDROID_FLASH_TORCH;
1640 break;
1641 case Parameters::FLASH_MODE_RED_EYE:
1642 reqAeMode = ANDROID_CONTROL_AE_ON_AUTO_FLASH_REDEYE; break;
1643 default:
1644 ALOGE("%s: Camera %d: Unknown flash mode %d", __FUNCTION__,
1645 cameraId, flashMode);
1646 return BAD_VALUE;
1647 }
1648 res = request->update(ANDROID_FLASH_MODE,
1649 &reqFlashMode, 1);
1650 if (res != OK) return res;
1651 res = request->update(ANDROID_CONTROL_AE_MODE,
1652 &reqAeMode, 1);
1653 if (res != OK) return res;
1654
1655 uint8_t reqAeLock = autoExposureLock ?
1656 ANDROID_CONTROL_AE_LOCK_ON : ANDROID_CONTROL_AE_LOCK_OFF;
1657 res = request->update(ANDROID_CONTROL_AE_LOCK,
1658 &reqAeLock, 1);
1659 if (res != OK) return res;
1660
1661 res = request->update(ANDROID_CONTROL_AWB_MODE,
1662 &wbMode, 1);
1663 if (res != OK) return res;
1664
1665 float reqFocusDistance = 0; // infinity focus in diopters
1666 uint8_t reqFocusMode = ANDROID_CONTROL_AF_OFF;
1667 switch (focusMode) {
1668 case Parameters::FOCUS_MODE_AUTO:
1669 case Parameters::FOCUS_MODE_MACRO:
1670 case Parameters::FOCUS_MODE_CONTINUOUS_VIDEO:
1671 case Parameters::FOCUS_MODE_CONTINUOUS_PICTURE:
1672 case Parameters::FOCUS_MODE_EDOF:
1673 reqFocusMode = focusMode;
1674 break;
1675 case Parameters::FOCUS_MODE_INFINITY:
1676 case Parameters::FOCUS_MODE_FIXED:
1677 reqFocusMode = ANDROID_CONTROL_AF_OFF;
1678 break;
1679 default:
1680 ALOGE("%s: Camera %d: Unknown focus mode %d", __FUNCTION__,
1681 cameraId, focusMode);
1682 return BAD_VALUE;
1683 }
1684 res = request->update(ANDROID_LENS_FOCUS_DISTANCE,
1685 &reqFocusDistance, 1);
1686 if (res != OK) return res;
1687 res = request->update(ANDROID_CONTROL_AF_MODE,
1688 &reqFocusMode, 1);
1689 if (res != OK) return res;
1690
1691 size_t reqFocusingAreasSize = focusingAreas.size() * 5;
1692 int32_t *reqFocusingAreas = new int32_t[reqFocusingAreasSize];
1693 for (size_t i = 0; i < reqFocusingAreasSize; i += 5) {
1694 if (focusingAreas[i].weight != 0) {
1695 reqFocusingAreas[i + 0] =
1696 normalizedXToArray(focusingAreas[i].left);
1697 reqFocusingAreas[i + 1] =
1698 normalizedYToArray(focusingAreas[i].top);
1699 reqFocusingAreas[i + 2] =
1700 normalizedXToArray(focusingAreas[i].right);
1701 reqFocusingAreas[i + 3] =
1702 normalizedYToArray(focusingAreas[i].bottom);
1703 } else {
1704 reqFocusingAreas[i + 0] = 0;
1705 reqFocusingAreas[i + 1] = 0;
1706 reqFocusingAreas[i + 2] = 0;
1707 reqFocusingAreas[i + 3] = 0;
1708 }
1709 reqFocusingAreas[i + 4] = focusingAreas[i].weight;
1710 }
1711 res = request->update(ANDROID_CONTROL_AF_REGIONS,
1712 reqFocusingAreas, reqFocusingAreasSize);
1713 if (res != OK) return res;
1714 delete[] reqFocusingAreas;
1715
1716 res = request->update(ANDROID_CONTROL_AE_EXP_COMPENSATION,
1717 &exposureCompensation, 1);
1718 if (res != OK) return res;
1719
1720 size_t reqMeteringAreasSize = meteringAreas.size() * 5;
1721 int32_t *reqMeteringAreas = new int32_t[reqMeteringAreasSize];
1722 for (size_t i = 0; i < reqMeteringAreasSize; i += 5) {
1723 if (meteringAreas[i].weight != 0) {
1724 reqMeteringAreas[i + 0] =
1725 normalizedXToArray(meteringAreas[i].left);
1726 reqMeteringAreas[i + 1] =
1727 normalizedYToArray(meteringAreas[i].top);
1728 reqMeteringAreas[i + 2] =
1729 normalizedXToArray(meteringAreas[i].right);
1730 reqMeteringAreas[i + 3] =
1731 normalizedYToArray(meteringAreas[i].bottom);
1732 } else {
1733 reqMeteringAreas[i + 0] = 0;
1734 reqMeteringAreas[i + 1] = 0;
1735 reqMeteringAreas[i + 2] = 0;
1736 reqMeteringAreas[i + 3] = 0;
1737 }
1738 reqMeteringAreas[i + 4] = meteringAreas[i].weight;
1739 }
1740 res = request->update(ANDROID_CONTROL_AE_REGIONS,
1741 reqMeteringAreas, reqMeteringAreasSize);
1742 if (res != OK) return res;
1743
1744 delete[] reqMeteringAreas;
1745
1746 /* don't include jpeg thumbnail size - it's valid for
1747 it to be set to (0,0), meaning 'no thumbnail' */
1748 CropRegion crop = calculateCropRegion( (CropRegion::Outputs)(
1749 CropRegion::OUTPUT_PREVIEW |
1750 CropRegion::OUTPUT_VIDEO |
1751 CropRegion::OUTPUT_PICTURE ));
1752 int32_t reqCropRegion[3] = { crop.left, crop.top, crop.width };
1753 res = request->update(ANDROID_SCALER_CROP_REGION,
1754 reqCropRegion, 3);
1755 if (res != OK) return res;
1756
1757 uint8_t reqVstabMode = videoStabilization ?
1758 ANDROID_CONTROL_VIDEO_STABILIZATION_ON :
1759 ANDROID_CONTROL_VIDEO_STABILIZATION_OFF;
1760 res = request->update(ANDROID_CONTROL_VIDEO_STABILIZATION_MODE,
1761 &reqVstabMode, 1);
1762 if (res != OK) return res;
1763
1764 uint8_t reqFaceDetectMode = enableFaceDetect ?
1765 fastInfo.bestFaceDetectMode :
1766 (uint8_t)ANDROID_STATS_FACE_DETECTION_OFF;
1767 res = request->update(ANDROID_STATS_FACE_DETECT_MODE,
1768 &reqFaceDetectMode, 1);
1769 if (res != OK) return res;
1770
1771 return OK;
1772 }
1773
updateRequestJpeg(CameraMetadata * request) const1774 status_t Parameters::updateRequestJpeg(CameraMetadata *request) const {
1775 status_t res;
1776
1777 res = request->update(ANDROID_JPEG_THUMBNAIL_SIZE,
1778 jpegThumbSize, 2);
1779 if (res != OK) return res;
1780 res = request->update(ANDROID_JPEG_THUMBNAIL_QUALITY,
1781 &jpegThumbQuality, 1);
1782 if (res != OK) return res;
1783 res = request->update(ANDROID_JPEG_QUALITY,
1784 &jpegQuality, 1);
1785 if (res != OK) return res;
1786 res = request->update(
1787 ANDROID_JPEG_ORIENTATION,
1788 &jpegRotation, 1);
1789 if (res != OK) return res;
1790
1791 if (gpsEnabled) {
1792 res = request->update(
1793 ANDROID_JPEG_GPS_COORDINATES,
1794 gpsCoordinates, 3);
1795 if (res != OK) return res;
1796 res = request->update(
1797 ANDROID_JPEG_GPS_TIMESTAMP,
1798 &gpsTimestamp, 1);
1799 if (res != OK) return res;
1800 res = request->update(
1801 ANDROID_JPEG_GPS_PROCESSING_METHOD,
1802 gpsProcessingMethod);
1803 if (res != OK) return res;
1804 } else {
1805 res = request->erase(ANDROID_JPEG_GPS_COORDINATES);
1806 if (res != OK) return res;
1807 res = request->erase(ANDROID_JPEG_GPS_TIMESTAMP);
1808 if (res != OK) return res;
1809 res = request->erase(ANDROID_JPEG_GPS_PROCESSING_METHOD);
1810 if (res != OK) return res;
1811 }
1812 return OK;
1813 }
1814
1815
getStateName(State state)1816 const char* Parameters::getStateName(State state) {
1817 #define CASE_ENUM_TO_CHAR(x) case x: return(#x); break;
1818 switch(state) {
1819 CASE_ENUM_TO_CHAR(DISCONNECTED)
1820 CASE_ENUM_TO_CHAR(STOPPED)
1821 CASE_ENUM_TO_CHAR(WAITING_FOR_PREVIEW_WINDOW)
1822 CASE_ENUM_TO_CHAR(PREVIEW)
1823 CASE_ENUM_TO_CHAR(RECORD)
1824 CASE_ENUM_TO_CHAR(STILL_CAPTURE)
1825 CASE_ENUM_TO_CHAR(VIDEO_SNAPSHOT)
1826 default:
1827 return "Unknown state!";
1828 break;
1829 }
1830 #undef CASE_ENUM_TO_CHAR
1831 }
1832
formatStringToEnum(const char * format)1833 int Parameters::formatStringToEnum(const char *format) {
1834 return
1835 !format ?
1836 HAL_PIXEL_FORMAT_YCrCb_420_SP :
1837 !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV422SP) ?
1838 HAL_PIXEL_FORMAT_YCbCr_422_SP : // NV16
1839 !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV420SP) ?
1840 HAL_PIXEL_FORMAT_YCrCb_420_SP : // NV21
1841 !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV422I) ?
1842 HAL_PIXEL_FORMAT_YCbCr_422_I : // YUY2
1843 !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV420P) ?
1844 HAL_PIXEL_FORMAT_YV12 : // YV12
1845 !strcmp(format, CameraParameters::PIXEL_FORMAT_RGB565) ?
1846 HAL_PIXEL_FORMAT_RGB_565 : // RGB565
1847 !strcmp(format, CameraParameters::PIXEL_FORMAT_RGBA8888) ?
1848 HAL_PIXEL_FORMAT_RGBA_8888 : // RGB8888
1849 !strcmp(format, CameraParameters::PIXEL_FORMAT_BAYER_RGGB) ?
1850 HAL_PIXEL_FORMAT_RAW_SENSOR : // Raw sensor data
1851 -1;
1852 }
1853
formatEnumToString(int format)1854 const char* Parameters::formatEnumToString(int format) {
1855 const char *fmt;
1856 switch(format) {
1857 case HAL_PIXEL_FORMAT_YCbCr_422_SP: // NV16
1858 fmt = CameraParameters::PIXEL_FORMAT_YUV422SP;
1859 break;
1860 case HAL_PIXEL_FORMAT_YCrCb_420_SP: // NV21
1861 fmt = CameraParameters::PIXEL_FORMAT_YUV420SP;
1862 break;
1863 case HAL_PIXEL_FORMAT_YCbCr_422_I: // YUY2
1864 fmt = CameraParameters::PIXEL_FORMAT_YUV422I;
1865 break;
1866 case HAL_PIXEL_FORMAT_YV12: // YV12
1867 fmt = CameraParameters::PIXEL_FORMAT_YUV420P;
1868 break;
1869 case HAL_PIXEL_FORMAT_RGB_565: // RGB565
1870 fmt = CameraParameters::PIXEL_FORMAT_RGB565;
1871 break;
1872 case HAL_PIXEL_FORMAT_RGBA_8888: // RGBA8888
1873 fmt = CameraParameters::PIXEL_FORMAT_RGBA8888;
1874 break;
1875 case HAL_PIXEL_FORMAT_RAW_SENSOR:
1876 ALOGW("Raw sensor preview format requested.");
1877 fmt = CameraParameters::PIXEL_FORMAT_BAYER_RGGB;
1878 break;
1879 default:
1880 ALOGE("%s: Unknown preview format: %x",
1881 __FUNCTION__, format);
1882 fmt = NULL;
1883 break;
1884 }
1885 return fmt;
1886 }
1887
wbModeStringToEnum(const char * wbMode)1888 int Parameters::wbModeStringToEnum(const char *wbMode) {
1889 return
1890 !wbMode ?
1891 ANDROID_CONTROL_AWB_AUTO :
1892 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_AUTO) ?
1893 ANDROID_CONTROL_AWB_AUTO :
1894 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_INCANDESCENT) ?
1895 ANDROID_CONTROL_AWB_INCANDESCENT :
1896 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_FLUORESCENT) ?
1897 ANDROID_CONTROL_AWB_FLUORESCENT :
1898 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_WARM_FLUORESCENT) ?
1899 ANDROID_CONTROL_AWB_WARM_FLUORESCENT :
1900 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_DAYLIGHT) ?
1901 ANDROID_CONTROL_AWB_DAYLIGHT :
1902 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT) ?
1903 ANDROID_CONTROL_AWB_CLOUDY_DAYLIGHT :
1904 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_TWILIGHT) ?
1905 ANDROID_CONTROL_AWB_TWILIGHT :
1906 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_SHADE) ?
1907 ANDROID_CONTROL_AWB_SHADE :
1908 -1;
1909 }
1910
wbModeEnumToString(uint8_t wbMode)1911 const char* Parameters::wbModeEnumToString(uint8_t wbMode) {
1912 switch (wbMode) {
1913 case ANDROID_CONTROL_AWB_AUTO:
1914 return CameraParameters::WHITE_BALANCE_AUTO;
1915 case ANDROID_CONTROL_AWB_INCANDESCENT:
1916 return CameraParameters::WHITE_BALANCE_INCANDESCENT;
1917 case ANDROID_CONTROL_AWB_FLUORESCENT:
1918 return CameraParameters::WHITE_BALANCE_FLUORESCENT;
1919 case ANDROID_CONTROL_AWB_WARM_FLUORESCENT:
1920 return CameraParameters::WHITE_BALANCE_WARM_FLUORESCENT;
1921 case ANDROID_CONTROL_AWB_DAYLIGHT:
1922 return CameraParameters::WHITE_BALANCE_DAYLIGHT;
1923 case ANDROID_CONTROL_AWB_CLOUDY_DAYLIGHT:
1924 return CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT;
1925 case ANDROID_CONTROL_AWB_TWILIGHT:
1926 return CameraParameters::WHITE_BALANCE_TWILIGHT;
1927 case ANDROID_CONTROL_AWB_SHADE:
1928 return CameraParameters::WHITE_BALANCE_SHADE;
1929 default:
1930 ALOGE("%s: Unknown AWB mode enum: %d",
1931 __FUNCTION__, wbMode);
1932 return "unknown";
1933 }
1934 }
1935
effectModeStringToEnum(const char * effectMode)1936 int Parameters::effectModeStringToEnum(const char *effectMode) {
1937 return
1938 !effectMode ?
1939 ANDROID_CONTROL_EFFECT_OFF :
1940 !strcmp(effectMode, CameraParameters::EFFECT_NONE) ?
1941 ANDROID_CONTROL_EFFECT_OFF :
1942 !strcmp(effectMode, CameraParameters::EFFECT_MONO) ?
1943 ANDROID_CONTROL_EFFECT_MONO :
1944 !strcmp(effectMode, CameraParameters::EFFECT_NEGATIVE) ?
1945 ANDROID_CONTROL_EFFECT_NEGATIVE :
1946 !strcmp(effectMode, CameraParameters::EFFECT_SOLARIZE) ?
1947 ANDROID_CONTROL_EFFECT_SOLARIZE :
1948 !strcmp(effectMode, CameraParameters::EFFECT_SEPIA) ?
1949 ANDROID_CONTROL_EFFECT_SEPIA :
1950 !strcmp(effectMode, CameraParameters::EFFECT_POSTERIZE) ?
1951 ANDROID_CONTROL_EFFECT_POSTERIZE :
1952 !strcmp(effectMode, CameraParameters::EFFECT_WHITEBOARD) ?
1953 ANDROID_CONTROL_EFFECT_WHITEBOARD :
1954 !strcmp(effectMode, CameraParameters::EFFECT_BLACKBOARD) ?
1955 ANDROID_CONTROL_EFFECT_BLACKBOARD :
1956 !strcmp(effectMode, CameraParameters::EFFECT_AQUA) ?
1957 ANDROID_CONTROL_EFFECT_AQUA :
1958 -1;
1959 }
1960
abModeStringToEnum(const char * abMode)1961 int Parameters::abModeStringToEnum(const char *abMode) {
1962 return
1963 !abMode ?
1964 ANDROID_CONTROL_AE_ANTIBANDING_AUTO :
1965 !strcmp(abMode, CameraParameters::ANTIBANDING_AUTO) ?
1966 ANDROID_CONTROL_AE_ANTIBANDING_AUTO :
1967 !strcmp(abMode, CameraParameters::ANTIBANDING_OFF) ?
1968 ANDROID_CONTROL_AE_ANTIBANDING_OFF :
1969 !strcmp(abMode, CameraParameters::ANTIBANDING_50HZ) ?
1970 ANDROID_CONTROL_AE_ANTIBANDING_50HZ :
1971 !strcmp(abMode, CameraParameters::ANTIBANDING_60HZ) ?
1972 ANDROID_CONTROL_AE_ANTIBANDING_60HZ :
1973 -1;
1974 }
1975
sceneModeStringToEnum(const char * sceneMode)1976 int Parameters::sceneModeStringToEnum(const char *sceneMode) {
1977 return
1978 !sceneMode ?
1979 ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED :
1980 !strcmp(sceneMode, CameraParameters::SCENE_MODE_AUTO) ?
1981 ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED :
1982 !strcmp(sceneMode, CameraParameters::SCENE_MODE_ACTION) ?
1983 ANDROID_CONTROL_SCENE_MODE_ACTION :
1984 !strcmp(sceneMode, CameraParameters::SCENE_MODE_PORTRAIT) ?
1985 ANDROID_CONTROL_SCENE_MODE_PORTRAIT :
1986 !strcmp(sceneMode, CameraParameters::SCENE_MODE_LANDSCAPE) ?
1987 ANDROID_CONTROL_SCENE_MODE_LANDSCAPE :
1988 !strcmp(sceneMode, CameraParameters::SCENE_MODE_NIGHT) ?
1989 ANDROID_CONTROL_SCENE_MODE_NIGHT :
1990 !strcmp(sceneMode, CameraParameters::SCENE_MODE_NIGHT_PORTRAIT) ?
1991 ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT :
1992 !strcmp(sceneMode, CameraParameters::SCENE_MODE_THEATRE) ?
1993 ANDROID_CONTROL_SCENE_MODE_THEATRE :
1994 !strcmp(sceneMode, CameraParameters::SCENE_MODE_BEACH) ?
1995 ANDROID_CONTROL_SCENE_MODE_BEACH :
1996 !strcmp(sceneMode, CameraParameters::SCENE_MODE_SNOW) ?
1997 ANDROID_CONTROL_SCENE_MODE_SNOW :
1998 !strcmp(sceneMode, CameraParameters::SCENE_MODE_SUNSET) ?
1999 ANDROID_CONTROL_SCENE_MODE_SUNSET :
2000 !strcmp(sceneMode, CameraParameters::SCENE_MODE_STEADYPHOTO) ?
2001 ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO :
2002 !strcmp(sceneMode, CameraParameters::SCENE_MODE_FIREWORKS) ?
2003 ANDROID_CONTROL_SCENE_MODE_FIREWORKS :
2004 !strcmp(sceneMode, CameraParameters::SCENE_MODE_SPORTS) ?
2005 ANDROID_CONTROL_SCENE_MODE_SPORTS :
2006 !strcmp(sceneMode, CameraParameters::SCENE_MODE_PARTY) ?
2007 ANDROID_CONTROL_SCENE_MODE_PARTY :
2008 !strcmp(sceneMode, CameraParameters::SCENE_MODE_CANDLELIGHT) ?
2009 ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT :
2010 !strcmp(sceneMode, CameraParameters::SCENE_MODE_BARCODE) ?
2011 ANDROID_CONTROL_SCENE_MODE_BARCODE:
2012 -1;
2013 }
2014
flashModeStringToEnum(const char * flashMode)2015 Parameters::Parameters::flashMode_t Parameters::flashModeStringToEnum(
2016 const char *flashMode) {
2017 return
2018 !flashMode ?
2019 Parameters::FLASH_MODE_INVALID :
2020 !strcmp(flashMode, CameraParameters::FLASH_MODE_OFF) ?
2021 Parameters::FLASH_MODE_OFF :
2022 !strcmp(flashMode, CameraParameters::FLASH_MODE_AUTO) ?
2023 Parameters::FLASH_MODE_AUTO :
2024 !strcmp(flashMode, CameraParameters::FLASH_MODE_ON) ?
2025 Parameters::FLASH_MODE_ON :
2026 !strcmp(flashMode, CameraParameters::FLASH_MODE_RED_EYE) ?
2027 Parameters::FLASH_MODE_RED_EYE :
2028 !strcmp(flashMode, CameraParameters::FLASH_MODE_TORCH) ?
2029 Parameters::FLASH_MODE_TORCH :
2030 Parameters::FLASH_MODE_INVALID;
2031 }
2032
flashModeEnumToString(flashMode_t flashMode)2033 const char *Parameters::flashModeEnumToString(flashMode_t flashMode) {
2034 switch (flashMode) {
2035 case FLASH_MODE_OFF:
2036 return CameraParameters::FLASH_MODE_OFF;
2037 case FLASH_MODE_AUTO:
2038 return CameraParameters::FLASH_MODE_AUTO;
2039 case FLASH_MODE_ON:
2040 return CameraParameters::FLASH_MODE_ON;
2041 case FLASH_MODE_RED_EYE:
2042 return CameraParameters::FLASH_MODE_RED_EYE;
2043 case FLASH_MODE_TORCH:
2044 return CameraParameters::FLASH_MODE_TORCH;
2045 default:
2046 ALOGE("%s: Unknown flash mode enum %d",
2047 __FUNCTION__, flashMode);
2048 return "unknown";
2049 }
2050 }
2051
focusModeStringToEnum(const char * focusMode)2052 Parameters::Parameters::focusMode_t Parameters::focusModeStringToEnum(
2053 const char *focusMode) {
2054 return
2055 !focusMode ?
2056 Parameters::FOCUS_MODE_INVALID :
2057 !strcmp(focusMode, CameraParameters::FOCUS_MODE_AUTO) ?
2058 Parameters::FOCUS_MODE_AUTO :
2059 !strcmp(focusMode, CameraParameters::FOCUS_MODE_INFINITY) ?
2060 Parameters::FOCUS_MODE_INFINITY :
2061 !strcmp(focusMode, CameraParameters::FOCUS_MODE_MACRO) ?
2062 Parameters::FOCUS_MODE_MACRO :
2063 !strcmp(focusMode, CameraParameters::FOCUS_MODE_FIXED) ?
2064 Parameters::FOCUS_MODE_FIXED :
2065 !strcmp(focusMode, CameraParameters::FOCUS_MODE_EDOF) ?
2066 Parameters::FOCUS_MODE_EDOF :
2067 !strcmp(focusMode, CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO) ?
2068 Parameters::FOCUS_MODE_CONTINUOUS_VIDEO :
2069 !strcmp(focusMode, CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE) ?
2070 Parameters::FOCUS_MODE_CONTINUOUS_PICTURE :
2071 Parameters::FOCUS_MODE_INVALID;
2072 }
2073
focusModeEnumToString(focusMode_t focusMode)2074 const char *Parameters::focusModeEnumToString(focusMode_t focusMode) {
2075 switch (focusMode) {
2076 case FOCUS_MODE_AUTO:
2077 return CameraParameters::FOCUS_MODE_AUTO;
2078 case FOCUS_MODE_MACRO:
2079 return CameraParameters::FOCUS_MODE_MACRO;
2080 case FOCUS_MODE_CONTINUOUS_VIDEO:
2081 return CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO;
2082 case FOCUS_MODE_CONTINUOUS_PICTURE:
2083 return CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE;
2084 case FOCUS_MODE_EDOF:
2085 return CameraParameters::FOCUS_MODE_EDOF;
2086 case FOCUS_MODE_INFINITY:
2087 return CameraParameters::FOCUS_MODE_INFINITY;
2088 case FOCUS_MODE_FIXED:
2089 return CameraParameters::FOCUS_MODE_FIXED;
2090 default:
2091 ALOGE("%s: Unknown focus mode enum: %d",
2092 __FUNCTION__, focusMode);
2093 return "unknown";
2094 }
2095 }
2096
parseAreas(const char * areasCStr,Vector<Parameters::Area> * areas)2097 status_t Parameters::parseAreas(const char *areasCStr,
2098 Vector<Parameters::Area> *areas) {
2099 static const size_t NUM_FIELDS = 5;
2100 areas->clear();
2101 if (areasCStr == NULL) {
2102 // If no key exists, use default (0,0,0,0,0)
2103 areas->push();
2104 return OK;
2105 }
2106 String8 areasStr(areasCStr);
2107 ssize_t areaStart = areasStr.find("(", 0) + 1;
2108 while (areaStart != 0) {
2109 const char* area = areasStr.string() + areaStart;
2110 char *numEnd;
2111 int vals[NUM_FIELDS];
2112 for (size_t i = 0; i < NUM_FIELDS; i++) {
2113 errno = 0;
2114 vals[i] = strtol(area, &numEnd, 10);
2115 if (errno || numEnd == area) return BAD_VALUE;
2116 area = numEnd + 1;
2117 }
2118 areas->push(Parameters::Area(
2119 vals[0], vals[1], vals[2], vals[3], vals[4]) );
2120 areaStart = areasStr.find("(", areaStart) + 1;
2121 }
2122 return OK;
2123 }
2124
validateAreas(const Vector<Parameters::Area> & areas,size_t maxRegions,AreaKind areaKind) const2125 status_t Parameters::validateAreas(const Vector<Parameters::Area> &areas,
2126 size_t maxRegions,
2127 AreaKind areaKind) const {
2128 // Definition of valid area can be found in
2129 // include/camera/CameraParameters.h
2130 if (areas.size() == 0) return BAD_VALUE;
2131 if (areas.size() == 1) {
2132 if (areas[0].left == 0 &&
2133 areas[0].top == 0 &&
2134 areas[0].right == 0 &&
2135 areas[0].bottom == 0 &&
2136 areas[0].weight == 0) {
2137 // Single (0,0,0,0,0) entry is always valid (== driver decides)
2138 return OK;
2139 }
2140 }
2141
2142 // fixed focus can only set (0,0,0,0,0) focus area
2143 if (areaKind == AREA_KIND_FOCUS && focusMode == FOCUS_MODE_FIXED) {
2144 return BAD_VALUE;
2145 }
2146
2147 if (areas.size() > maxRegions) {
2148 ALOGE("%s: Too many areas requested: %d",
2149 __FUNCTION__, areas.size());
2150 return BAD_VALUE;
2151 }
2152
2153 for (Vector<Parameters::Area>::const_iterator a = areas.begin();
2154 a != areas.end(); a++) {
2155 if (a->weight < 1 || a->weight > 1000) return BAD_VALUE;
2156 if (a->left < -1000 || a->left > 1000) return BAD_VALUE;
2157 if (a->top < -1000 || a->top > 1000) return BAD_VALUE;
2158 if (a->right < -1000 || a->right > 1000) return BAD_VALUE;
2159 if (a->bottom < -1000 || a->bottom > 1000) return BAD_VALUE;
2160 if (a->left >= a->right) return BAD_VALUE;
2161 if (a->top >= a->bottom) return BAD_VALUE;
2162 }
2163 return OK;
2164 }
2165
boolFromString(const char * boolStr)2166 bool Parameters::boolFromString(const char *boolStr) {
2167 return !boolStr ? false :
2168 !strcmp(boolStr, CameraParameters::TRUE) ? true :
2169 false;
2170 }
2171
degToTransform(int degrees,bool mirror)2172 int Parameters::degToTransform(int degrees, bool mirror) {
2173 if (!mirror) {
2174 if (degrees == 0) return 0;
2175 else if (degrees == 90) return HAL_TRANSFORM_ROT_90;
2176 else if (degrees == 180) return HAL_TRANSFORM_ROT_180;
2177 else if (degrees == 270) return HAL_TRANSFORM_ROT_270;
2178 } else { // Do mirror (horizontal flip)
2179 if (degrees == 0) { // FLIP_H and ROT_0
2180 return HAL_TRANSFORM_FLIP_H;
2181 } else if (degrees == 90) { // FLIP_H and ROT_90
2182 return HAL_TRANSFORM_FLIP_H | HAL_TRANSFORM_ROT_90;
2183 } else if (degrees == 180) { // FLIP_H and ROT_180
2184 return HAL_TRANSFORM_FLIP_V;
2185 } else if (degrees == 270) { // FLIP_H and ROT_270
2186 return HAL_TRANSFORM_FLIP_V | HAL_TRANSFORM_ROT_90;
2187 }
2188 }
2189 ALOGE("%s: Bad input: %d", __FUNCTION__, degrees);
2190 return -1;
2191 }
2192
cropXToArray(int x) const2193 int Parameters::cropXToArray(int x) const {
2194 ALOG_ASSERT(x >= 0, "Crop-relative X coordinate = '%d' is out of bounds"
2195 "(lower = 0)", x);
2196
2197 CropRegion previewCrop = calculateCropRegion(CropRegion::OUTPUT_PREVIEW);
2198 ALOG_ASSERT(x < previewCrop.width, "Crop-relative X coordinate = '%d' "
2199 "is out of bounds (upper = %d)", x, previewCrop.width);
2200
2201 int ret = x + previewCrop.left;
2202
2203 ALOG_ASSERT( (ret >= 0 && ret < fastInfo.arrayWidth),
2204 "Calculated pixel array value X = '%d' is out of bounds (upper = %d)",
2205 ret, fastInfo.arrayWidth);
2206 return ret;
2207 }
2208
cropYToArray(int y) const2209 int Parameters::cropYToArray(int y) const {
2210 ALOG_ASSERT(y >= 0, "Crop-relative Y coordinate = '%d' is out of bounds "
2211 "(lower = 0)", y);
2212
2213 CropRegion previewCrop = calculateCropRegion(CropRegion::OUTPUT_PREVIEW);
2214 ALOG_ASSERT(y < previewCrop.height, "Crop-relative Y coordinate = '%d' is "
2215 "out of bounds (upper = %d)", y, previewCrop.height);
2216
2217 int ret = y + previewCrop.top;
2218
2219 ALOG_ASSERT( (ret >= 0 && ret < fastInfo.arrayHeight),
2220 "Calculated pixel array value Y = '%d' is out of bounds (upper = %d)",
2221 ret, fastInfo.arrayHeight);
2222
2223 return ret;
2224
2225 }
2226
normalizedXToCrop(int x) const2227 int Parameters::normalizedXToCrop(int x) const {
2228 CropRegion previewCrop = calculateCropRegion(CropRegion::OUTPUT_PREVIEW);
2229 return (x + 1000) * (previewCrop.width - 1) / 2000;
2230 }
2231
normalizedYToCrop(int y) const2232 int Parameters::normalizedYToCrop(int y) const {
2233 CropRegion previewCrop = calculateCropRegion(CropRegion::OUTPUT_PREVIEW);
2234 return (y + 1000) * (previewCrop.height - 1) / 2000;
2235 }
2236
arrayXToCrop(int x) const2237 int Parameters::arrayXToCrop(int x) const {
2238 CropRegion previewCrop = calculateCropRegion(CropRegion::OUTPUT_PREVIEW);
2239 return x - previewCrop.left;
2240 }
2241
arrayYToCrop(int y) const2242 int Parameters::arrayYToCrop(int y) const {
2243 CropRegion previewCrop = calculateCropRegion(CropRegion::OUTPUT_PREVIEW);
2244 return y - previewCrop.top;
2245 }
2246
cropXToNormalized(int x) const2247 int Parameters::cropXToNormalized(int x) const {
2248 CropRegion previewCrop = calculateCropRegion(CropRegion::OUTPUT_PREVIEW);
2249 return x * 2000 / (previewCrop.width - 1) - 1000;
2250 }
2251
cropYToNormalized(int y) const2252 int Parameters::cropYToNormalized(int y) const {
2253 CropRegion previewCrop = calculateCropRegion(CropRegion::OUTPUT_PREVIEW);
2254 return y * 2000 / (previewCrop.height - 1) - 1000;
2255 }
2256
arrayXToNormalized(int width) const2257 int Parameters::arrayXToNormalized(int width) const {
2258 int ret = cropXToNormalized(arrayXToCrop(width));
2259
2260 ALOG_ASSERT(ret >= -1000, "Calculated normalized value out of "
2261 "lower bounds %d", ret);
2262 ALOG_ASSERT(ret <= 1000, "Calculated normalized value out of "
2263 "upper bounds %d", ret);
2264
2265 // Work-around for HAL pre-scaling the coordinates themselves
2266 if (quirks.meteringCropRegion) {
2267 return width * 2000 / (fastInfo.arrayWidth - 1) - 1000;
2268 }
2269
2270 return ret;
2271 }
2272
arrayYToNormalized(int height) const2273 int Parameters::arrayYToNormalized(int height) const {
2274 int ret = cropYToNormalized(arrayYToCrop(height));
2275
2276 ALOG_ASSERT(ret >= -1000, "Calculated normalized value out of lower bounds"
2277 " %d", ret);
2278 ALOG_ASSERT(ret <= 1000, "Calculated normalized value out of upper bounds"
2279 " %d", ret);
2280
2281 // Work-around for HAL pre-scaling the coordinates themselves
2282 if (quirks.meteringCropRegion) {
2283 return height * 2000 / (fastInfo.arrayHeight - 1) - 1000;
2284 }
2285
2286 return ret;
2287 }
2288
normalizedXToArray(int x) const2289 int Parameters::normalizedXToArray(int x) const {
2290
2291 // Work-around for HAL pre-scaling the coordinates themselves
2292 if (quirks.meteringCropRegion) {
2293 return (x + 1000) * (fastInfo.arrayWidth - 1) / 2000;
2294 }
2295
2296 return cropXToArray(normalizedXToCrop(x));
2297 }
2298
normalizedYToArray(int y) const2299 int Parameters::normalizedYToArray(int y) const {
2300 // Work-around for HAL pre-scaling the coordinates themselves
2301 if (quirks.meteringCropRegion) {
2302 return (y + 1000) * (fastInfo.arrayHeight - 1) / 2000;
2303 }
2304
2305 return cropYToArray(normalizedYToCrop(y));
2306 }
2307
calculateCropRegion(Parameters::CropRegion::Outputs outputs) const2308 Parameters::CropRegion Parameters::calculateCropRegion(
2309 Parameters::CropRegion::Outputs outputs) const {
2310
2311 float zoomLeft, zoomTop, zoomWidth, zoomHeight;
2312
2313 // Need to convert zoom index into a crop rectangle. The rectangle is
2314 // chosen to maximize its area on the sensor
2315
2316 camera_metadata_ro_entry_t maxDigitalZoom =
2317 staticInfo(ANDROID_SCALER_AVAILABLE_MAX_ZOOM);
2318 // For each zoom step by how many pixels more do we change the zoom
2319 float zoomIncrement = (maxDigitalZoom.data.f[0] - 1) /
2320 (NUM_ZOOM_STEPS-1);
2321 // The desired activeAreaWidth/cropAreaWidth ratio (or height if h>w)
2322 // via interpolating zoom step into a zoom ratio
2323 float zoomRatio = 1 + zoomIncrement * zoom;
2324 ALOG_ASSERT( (zoomRatio >= 1.f && zoomRatio <= maxDigitalZoom.data.f[0]),
2325 "Zoom ratio calculated out of bounds. Expected 1 - %f, actual: %f",
2326 maxDigitalZoom.data.f[0], zoomRatio);
2327
2328 ALOGV("Zoom maxDigital=%f, increment=%f, ratio=%f, previewWidth=%d, "
2329 "previewHeight=%d, activeWidth=%d, activeHeight=%d",
2330 maxDigitalZoom.data.f[0], zoomIncrement, zoomRatio, previewWidth,
2331 previewHeight, fastInfo.arrayWidth, fastInfo.arrayHeight);
2332
2333 /*
2334 * Assumption: On the HAL side each stream buffer calculates its crop
2335 * rectangle as follows:
2336 * cropRect = (zoomLeft, zoomRight,
2337 * zoomWidth, zoomHeight * zoomWidth / outputWidth);
2338 *
2339 * Note that if zoomWidth > bufferWidth, the new cropHeight > zoomHeight
2340 * (we can then get into trouble if the cropHeight > arrayHeight).
2341 * By selecting the zoomRatio based on the smallest outputRatio, we
2342 * guarantee this will never happen.
2343 */
2344
2345 // Enumerate all possible output sizes, select the one with the smallest
2346 // aspect ratio
2347 float minOutputWidth, minOutputHeight, minOutputRatio;
2348 {
2349 float outputSizes[][2] = {
2350 { previewWidth, previewHeight },
2351 { videoWidth, videoHeight },
2352 { jpegThumbSize[0], jpegThumbSize[1] },
2353 { pictureWidth, pictureHeight },
2354 };
2355
2356 minOutputWidth = outputSizes[0][0];
2357 minOutputHeight = outputSizes[0][1];
2358 minOutputRatio = minOutputWidth / minOutputHeight;
2359 for (unsigned int i = 0;
2360 i < sizeof(outputSizes) / sizeof(outputSizes[0]);
2361 ++i) {
2362
2363 // skip over outputs we don't want to consider for the crop region
2364 if ( !((1 << i) & outputs) ) {
2365 continue;
2366 }
2367
2368 float outputWidth = outputSizes[i][0];
2369 float outputHeight = outputSizes[i][1];
2370 float outputRatio = outputWidth / outputHeight;
2371
2372 if (minOutputRatio > outputRatio) {
2373 minOutputRatio = outputRatio;
2374 minOutputWidth = outputWidth;
2375 minOutputHeight = outputHeight;
2376 }
2377
2378 // and then use this output ratio instead of preview output ratio
2379 ALOGV("Enumerating output ratio %f = %f / %f, min is %f",
2380 outputRatio, outputWidth, outputHeight, minOutputRatio);
2381 }
2382 }
2383
2384 /* Ensure that the width/height never go out of bounds
2385 * by scaling across a diffent dimension if an out-of-bounds
2386 * possibility exists.
2387 *
2388 * e.g. if the previewratio < arrayratio and e.g. zoomratio = 1.0, then by
2389 * calculating the zoomWidth from zoomHeight we'll actually get a
2390 * zoomheight > arrayheight
2391 */
2392 float arrayRatio = 1.f * fastInfo.arrayWidth / fastInfo.arrayHeight;
2393 if (minOutputRatio >= arrayRatio) {
2394 // Adjust the height based on the width
2395 zoomWidth = fastInfo.arrayWidth / zoomRatio;
2396 zoomHeight = zoomWidth *
2397 minOutputHeight / minOutputWidth;
2398
2399 } else {
2400 // Adjust the width based on the height
2401 zoomHeight = fastInfo.arrayHeight / zoomRatio;
2402 zoomWidth = zoomHeight *
2403 minOutputWidth / minOutputHeight;
2404 }
2405 // centering the zoom area within the active area
2406 zoomLeft = (fastInfo.arrayWidth - zoomWidth) / 2;
2407 zoomTop = (fastInfo.arrayHeight - zoomHeight) / 2;
2408
2409 ALOGV("Crop region calculated (x=%d,y=%d,w=%f,h=%f) for zoom=%d",
2410 (int32_t)zoomLeft, (int32_t)zoomTop, zoomWidth, zoomHeight, this->zoom);
2411
2412
2413 CropRegion crop = { zoomLeft, zoomTop, zoomWidth, zoomHeight };
2414 return crop;
2415 }
2416
fpsFromRange(int32_t min,int32_t max) const2417 int32_t Parameters::fpsFromRange(int32_t min, int32_t max) const {
2418 return max;
2419 }
2420
2421 }; // namespace camera2
2422 }; // namespace android
2423