Gitiles
Code Review Sign In
review.evervolv.com / android_frameworks_av / 2a88b7130e50ea579401a4407847e57fd36eab85 / . / services / camera / libcameraservice / camera2 / Parameters.cpp
blob: f490b2a50cbbbde45ae468cae39e1bc06613ea04 [file] [log] [blame]
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]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
Eino-Ville Talvala69230df2012-08-29 17:37:16 -0700[diff] [blame]21#include <utils/Log.h>
22#include <utils/Trace.h>
23
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]24#include <math.h>
25#include <stdlib.h>
26
27#include "Parameters.h"
28#include "system/camera.h"
29#include "camera/CameraParameters.h"
30
31namespace android {
32namespace camera2 {
33
34Parameters::Parameters(int cameraId,
35 int cameraFacing) :
36 cameraId(cameraId),
37 cameraFacing(cameraFacing),
38 info(NULL) {
39}
40
41Parameters::~Parameters() {
42}
43
44status_t Parameters::initialize(const CameraMetadata *info) {
45 status_t res;
46
47 if (info->entryCount() == 0) {
48 ALOGE("%s: No static information provided!", __FUNCTION__);
49 return BAD_VALUE;
50 }
51 Parameters::info = info;
52
53 res = buildFastInfo();
54 if (res != OK) return res;
55
56 CameraParameters params;
57
58 camera_metadata_ro_entry_t availableProcessedSizes =
59 staticInfo(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES, 2);
60 if (!availableProcessedSizes.count) return NO_INIT;
61
62 // TODO: Pick more intelligently
63 previewWidth = availableProcessedSizes.data.i32[0];
64 previewHeight = availableProcessedSizes.data.i32[1];
65 videoWidth = previewWidth;
66 videoHeight = previewHeight;
67
68 params.setPreviewSize(previewWidth, previewHeight);
69 params.setVideoSize(videoWidth, videoHeight);
70 params.set(CameraParameters::KEY_PREFERRED_PREVIEW_SIZE_FOR_VIDEO,
71 String8::format("%dx%d",
72 previewWidth, previewHeight));
73 {
74 String8 supportedPreviewSizes;
75 for (size_t i=0; i < availableProcessedSizes.count; i += 2) {
76 if (i != 0) supportedPreviewSizes += ",";
77 supportedPreviewSizes += String8::format("%dx%d",
78 availableProcessedSizes.data.i32[i],
79 availableProcessedSizes.data.i32[i+1]);
80 }
81 params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES,
82 supportedPreviewSizes);
83 params.set(CameraParameters::KEY_SUPPORTED_VIDEO_SIZES,
84 supportedPreviewSizes);
85 }
86
87 camera_metadata_ro_entry_t availableFpsRanges =
88 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES, 2);
89 if (!availableFpsRanges.count) return NO_INIT;
90
91 previewFpsRange[0] = availableFpsRanges.data.i32[0];
92 previewFpsRange[1] = availableFpsRanges.data.i32[1];
93
94 params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE,
95 String8::format("%d,%d",
96 previewFpsRange[0],
97 previewFpsRange[1]));
98
99 {
100 String8 supportedPreviewFpsRange;
101 for (size_t i=0; i < availableFpsRanges.count; i += 2) {
102 if (i != 0) supportedPreviewFpsRange += ",";
103 supportedPreviewFpsRange += String8::format("(%d,%d)",
104 availableFpsRanges.data.i32[i],
105 availableFpsRanges.data.i32[i+1]);
106 }
107 params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE,
108 supportedPreviewFpsRange);
109 }
110
111 previewFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP;
112 params.set(CameraParameters::KEY_PREVIEW_FORMAT,
113 formatEnumToString(previewFormat)); // NV21
114
115 previewTransform = degToTransform(0,
116 cameraFacing == CAMERA_FACING_FRONT);
117
118 camera_metadata_ro_entry_t availableFormats =
119 staticInfo(ANDROID_SCALER_AVAILABLE_FORMATS);
120
121 {
122 String8 supportedPreviewFormats;
123 bool addComma = false;
124 for (size_t i=0; i < availableFormats.count; i++) {
125 if (addComma) supportedPreviewFormats += ",";
126 addComma = true;
127 switch (availableFormats.data.i32[i]) {
128 case HAL_PIXEL_FORMAT_YCbCr_422_SP:
129 supportedPreviewFormats +=
130 CameraParameters::PIXEL_FORMAT_YUV422SP;
131 break;
132 case HAL_PIXEL_FORMAT_YCrCb_420_SP:
133 supportedPreviewFormats +=
134 CameraParameters::PIXEL_FORMAT_YUV420SP;
135 break;
136 case HAL_PIXEL_FORMAT_YCbCr_422_I:
137 supportedPreviewFormats +=
138 CameraParameters::PIXEL_FORMAT_YUV422I;
139 break;
140 case HAL_PIXEL_FORMAT_YV12:
141 supportedPreviewFormats +=
142 CameraParameters::PIXEL_FORMAT_YUV420P;
143 break;
144 case HAL_PIXEL_FORMAT_RGB_565:
145 supportedPreviewFormats +=
146 CameraParameters::PIXEL_FORMAT_RGB565;
147 break;
148 case HAL_PIXEL_FORMAT_RGBA_8888:
149 supportedPreviewFormats +=
150 CameraParameters::PIXEL_FORMAT_RGBA8888;
151 break;
152 // Not advertizing JPEG, RAW_SENSOR, etc, for preview formats
153 case HAL_PIXEL_FORMAT_RAW_SENSOR:
154 case HAL_PIXEL_FORMAT_BLOB:
155 addComma = false;
156 break;
157
158 default:
159 ALOGW("%s: Camera %d: Unknown preview format: %x",
160 __FUNCTION__, cameraId, availableFormats.data.i32[i]);
161 addComma = false;
162 break;
163 }
164 }
165 params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS,
166 supportedPreviewFormats);
167 }
168
169 // PREVIEW_FRAME_RATE / SUPPORTED_PREVIEW_FRAME_RATES are deprecated, but
170 // still have to do something sane for them
171
172 params.set(CameraParameters::KEY_PREVIEW_FRAME_RATE,
173 previewFpsRange[0]);
174
175 {
176 String8 supportedPreviewFrameRates;
177 for (size_t i=0; i < availableFpsRanges.count; i += 2) {
178 if (i != 0) supportedPreviewFrameRates += ",";
179 supportedPreviewFrameRates += String8::format("%d",
180 availableFpsRanges.data.i32[i]);
181 }
182 params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES,
183 supportedPreviewFrameRates);
184 }
185
186 camera_metadata_ro_entry_t availableJpegSizes =
187 staticInfo(ANDROID_SCALER_AVAILABLE_JPEG_SIZES, 2);
188 if (!availableJpegSizes.count) return NO_INIT;
189
190 // TODO: Pick maximum
191 pictureWidth = availableJpegSizes.data.i32[0];
192 pictureHeight = availableJpegSizes.data.i32[1];
193
194 params.setPictureSize(pictureWidth,
195 pictureHeight);
196
197 {
198 String8 supportedPictureSizes;
199 for (size_t i=0; i < availableJpegSizes.count; i += 2) {
200 if (i != 0) supportedPictureSizes += ",";
201 supportedPictureSizes += String8::format("%dx%d",
202 availableJpegSizes.data.i32[i],
203 availableJpegSizes.data.i32[i+1]);
204 }
205 params.set(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES,
206 supportedPictureSizes);
207 }
208
209 params.setPictureFormat(CameraParameters::PIXEL_FORMAT_JPEG);
210 params.set(CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS,
211 CameraParameters::PIXEL_FORMAT_JPEG);
212
213 camera_metadata_ro_entry_t availableJpegThumbnailSizes =
Eino-Ville Talvalaa1e4e302012-08-28 13:38:23 -0700[diff] [blame]214 staticInfo(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES, 4);
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]215 if (!availableJpegThumbnailSizes.count) return NO_INIT;
216
217 // TODO: Pick default thumbnail size sensibly
218 jpegThumbSize[0] = availableJpegThumbnailSizes.data.i32[0];
219 jpegThumbSize[1] = availableJpegThumbnailSizes.data.i32[1];
220
221 params.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH,
222 jpegThumbSize[0]);
223 params.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT,
224 jpegThumbSize[1]);
225
226 {
227 String8 supportedJpegThumbSizes;
228 for (size_t i=0; i < availableJpegThumbnailSizes.count; i += 2) {
229 if (i != 0) supportedJpegThumbSizes += ",";
230 supportedJpegThumbSizes += String8::format("%dx%d",
231 availableJpegThumbnailSizes.data.i32[i],
232 availableJpegThumbnailSizes.data.i32[i+1]);
233 }
234 params.set(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES,
235 supportedJpegThumbSizes);
236 }
237
238 jpegThumbQuality = 90;
239 params.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY,
240 jpegThumbQuality);
241 jpegQuality = 90;
242 params.set(CameraParameters::KEY_JPEG_QUALITY,
243 jpegQuality);
244 jpegRotation = 0;
245 params.set(CameraParameters::KEY_ROTATION,
246 jpegRotation);
247
248 gpsEnabled = false;
249 gpsProcessingMethod = "unknown";
250 // GPS fields in CameraParameters are not set by implementation
251
252 wbMode = ANDROID_CONTROL_AWB_AUTO;
253 params.set(CameraParameters::KEY_WHITE_BALANCE,
254 CameraParameters::WHITE_BALANCE_AUTO);
255
256 camera_metadata_ro_entry_t availableWhiteBalanceModes =
257 staticInfo(ANDROID_CONTROL_AWB_AVAILABLE_MODES);
258 {
259 String8 supportedWhiteBalance;
260 bool addComma = false;
261 for (size_t i=0; i < availableWhiteBalanceModes.count; i++) {
262 if (addComma) supportedWhiteBalance += ",";
263 addComma = true;
264 switch (availableWhiteBalanceModes.data.u8[i]) {
265 case ANDROID_CONTROL_AWB_AUTO:
266 supportedWhiteBalance +=
267 CameraParameters::WHITE_BALANCE_AUTO;
268 break;
269 case ANDROID_CONTROL_AWB_INCANDESCENT:
270 supportedWhiteBalance +=
271 CameraParameters::WHITE_BALANCE_INCANDESCENT;
272 break;
273 case ANDROID_CONTROL_AWB_FLUORESCENT:
274 supportedWhiteBalance +=
275 CameraParameters::WHITE_BALANCE_FLUORESCENT;
276 break;
277 case ANDROID_CONTROL_AWB_WARM_FLUORESCENT:
278 supportedWhiteBalance +=
279 CameraParameters::WHITE_BALANCE_WARM_FLUORESCENT;
280 break;
281 case ANDROID_CONTROL_AWB_DAYLIGHT:
282 supportedWhiteBalance +=
283 CameraParameters::WHITE_BALANCE_DAYLIGHT;
284 break;
285 case ANDROID_CONTROL_AWB_CLOUDY_DAYLIGHT:
286 supportedWhiteBalance +=
287 CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT;
288 break;
289 case ANDROID_CONTROL_AWB_TWILIGHT:
290 supportedWhiteBalance +=
291 CameraParameters::WHITE_BALANCE_TWILIGHT;
292 break;
293 case ANDROID_CONTROL_AWB_SHADE:
294 supportedWhiteBalance +=
295 CameraParameters::WHITE_BALANCE_SHADE;
296 break;
297 // Skipping values not mappable to v1 API
298 case ANDROID_CONTROL_AWB_OFF:
299 addComma = false;
300 break;
301 default:
302 ALOGW("%s: Camera %d: Unknown white balance value: %d",
303 __FUNCTION__, cameraId,
304 availableWhiteBalanceModes.data.u8[i]);
305 addComma = false;
306 break;
307 }
308 }
309 params.set(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE,
310 supportedWhiteBalance);
311 }
312
313 effectMode = ANDROID_CONTROL_EFFECT_OFF;
314 params.set(CameraParameters::KEY_EFFECT,
315 CameraParameters::EFFECT_NONE);
316
317 camera_metadata_ro_entry_t availableEffects =
318 staticInfo(ANDROID_CONTROL_AVAILABLE_EFFECTS);
319 if (!availableEffects.count) return NO_INIT;
320 {
321 String8 supportedEffects;
322 bool addComma = false;
323 for (size_t i=0; i < availableEffects.count; i++) {
324 if (addComma) supportedEffects += ",";
325 addComma = true;
326 switch (availableEffects.data.u8[i]) {
327 case ANDROID_CONTROL_EFFECT_OFF:
328 supportedEffects +=
329 CameraParameters::EFFECT_NONE;
330 break;
331 case ANDROID_CONTROL_EFFECT_MONO:
332 supportedEffects +=
333 CameraParameters::EFFECT_MONO;
334 break;
335 case ANDROID_CONTROL_EFFECT_NEGATIVE:
336 supportedEffects +=
337 CameraParameters::EFFECT_NEGATIVE;
338 break;
339 case ANDROID_CONTROL_EFFECT_SOLARIZE:
340 supportedEffects +=
341 CameraParameters::EFFECT_SOLARIZE;
342 break;
343 case ANDROID_CONTROL_EFFECT_SEPIA:
344 supportedEffects +=
345 CameraParameters::EFFECT_SEPIA;
346 break;
347 case ANDROID_CONTROL_EFFECT_POSTERIZE:
348 supportedEffects +=
349 CameraParameters::EFFECT_POSTERIZE;
350 break;
351 case ANDROID_CONTROL_EFFECT_WHITEBOARD:
352 supportedEffects +=
353 CameraParameters::EFFECT_WHITEBOARD;
354 break;
355 case ANDROID_CONTROL_EFFECT_BLACKBOARD:
356 supportedEffects +=
357 CameraParameters::EFFECT_BLACKBOARD;
358 break;
359 case ANDROID_CONTROL_EFFECT_AQUA:
360 supportedEffects +=
361 CameraParameters::EFFECT_AQUA;
362 break;
363 default:
364 ALOGW("%s: Camera %d: Unknown effect value: %d",
365 __FUNCTION__, cameraId, availableEffects.data.u8[i]);
366 addComma = false;
367 break;
368 }
369 }
370 params.set(CameraParameters::KEY_SUPPORTED_EFFECTS, supportedEffects);
371 }
372
373 antibandingMode = ANDROID_CONTROL_AE_ANTIBANDING_AUTO;
374 params.set(CameraParameters::KEY_ANTIBANDING,
375 CameraParameters::ANTIBANDING_AUTO);
376
377 camera_metadata_ro_entry_t availableAntibandingModes =
378 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES);
379 if (!availableAntibandingModes.count) return NO_INIT;
380 {
381 String8 supportedAntibanding;
382 bool addComma = false;
383 for (size_t i=0; i < availableAntibandingModes.count; i++) {
384 if (addComma) supportedAntibanding += ",";
385 addComma = true;
386 switch (availableAntibandingModes.data.u8[i]) {
387 case ANDROID_CONTROL_AE_ANTIBANDING_OFF:
388 supportedAntibanding +=
389 CameraParameters::ANTIBANDING_OFF;
390 break;
391 case ANDROID_CONTROL_AE_ANTIBANDING_50HZ:
392 supportedAntibanding +=
393 CameraParameters::ANTIBANDING_50HZ;
394 break;
395 case ANDROID_CONTROL_AE_ANTIBANDING_60HZ:
396 supportedAntibanding +=
397 CameraParameters::ANTIBANDING_60HZ;
398 break;
399 case ANDROID_CONTROL_AE_ANTIBANDING_AUTO:
400 supportedAntibanding +=
401 CameraParameters::ANTIBANDING_AUTO;
402 break;
403 default:
404 ALOGW("%s: Camera %d: Unknown antibanding value: %d",
405 __FUNCTION__, cameraId,
406 availableAntibandingModes.data.u8[i]);
407 addComma = false;
408 break;
409 }
410 }
411 params.set(CameraParameters::KEY_SUPPORTED_ANTIBANDING,
412 supportedAntibanding);
413 }
414
415 sceneMode = ANDROID_CONTROL_OFF;
416 params.set(CameraParameters::KEY_SCENE_MODE,
417 CameraParameters::SCENE_MODE_AUTO);
418
419 camera_metadata_ro_entry_t availableSceneModes =
420 staticInfo(ANDROID_CONTROL_AVAILABLE_SCENE_MODES);
421 if (!availableSceneModes.count) return NO_INIT;
422 {
423 String8 supportedSceneModes(CameraParameters::SCENE_MODE_AUTO);
424 bool addComma = true;
425 bool noSceneModes = false;
426 for (size_t i=0; i < availableSceneModes.count; i++) {
427 if (addComma) supportedSceneModes += ",";
428 addComma = true;
429 switch (availableSceneModes.data.u8[i]) {
430 case ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED:
431 noSceneModes = true;
432 break;
433 case ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY:
434 // Not in old API
435 addComma = false;
436 break;
437 case ANDROID_CONTROL_SCENE_MODE_ACTION:
438 supportedSceneModes +=
439 CameraParameters::SCENE_MODE_ACTION;
440 break;
441 case ANDROID_CONTROL_SCENE_MODE_PORTRAIT:
442 supportedSceneModes +=
443 CameraParameters::SCENE_MODE_PORTRAIT;
444 break;
445 case ANDROID_CONTROL_SCENE_MODE_LANDSCAPE:
446 supportedSceneModes +=
447 CameraParameters::SCENE_MODE_LANDSCAPE;
448 break;
449 case ANDROID_CONTROL_SCENE_MODE_NIGHT:
450 supportedSceneModes +=
451 CameraParameters::SCENE_MODE_NIGHT;
452 break;
453 case ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT:
454 supportedSceneModes +=
455 CameraParameters::SCENE_MODE_NIGHT_PORTRAIT;
456 break;
457 case ANDROID_CONTROL_SCENE_MODE_THEATRE:
458 supportedSceneModes +=
459 CameraParameters::SCENE_MODE_THEATRE;
460 break;
461 case ANDROID_CONTROL_SCENE_MODE_BEACH:
462 supportedSceneModes +=
463 CameraParameters::SCENE_MODE_BEACH;
464 break;
465 case ANDROID_CONTROL_SCENE_MODE_SNOW:
466 supportedSceneModes +=
467 CameraParameters::SCENE_MODE_SNOW;
468 break;
469 case ANDROID_CONTROL_SCENE_MODE_SUNSET:
470 supportedSceneModes +=
471 CameraParameters::SCENE_MODE_SUNSET;
472 break;
473 case ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO:
474 supportedSceneModes +=
475 CameraParameters::SCENE_MODE_STEADYPHOTO;
476 break;
477 case ANDROID_CONTROL_SCENE_MODE_FIREWORKS:
478 supportedSceneModes +=
479 CameraParameters::SCENE_MODE_FIREWORKS;
480 break;
481 case ANDROID_CONTROL_SCENE_MODE_SPORTS:
482 supportedSceneModes +=
483 CameraParameters::SCENE_MODE_SPORTS;
484 break;
485 case ANDROID_CONTROL_SCENE_MODE_PARTY:
486 supportedSceneModes +=
487 CameraParameters::SCENE_MODE_PARTY;
488 break;
489 case ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT:
490 supportedSceneModes +=
491 CameraParameters::SCENE_MODE_CANDLELIGHT;
492 break;
493 case ANDROID_CONTROL_SCENE_MODE_BARCODE:
494 supportedSceneModes +=
495 CameraParameters::SCENE_MODE_BARCODE;
496 break;
497 default:
498 ALOGW("%s: Camera %d: Unknown scene mode value: %d",
499 __FUNCTION__, cameraId,
500 availableSceneModes.data.u8[i]);
501 addComma = false;
502 break;
503 }
504 }
505 if (!noSceneModes) {
506 params.set(CameraParameters::KEY_SUPPORTED_SCENE_MODES,
507 supportedSceneModes);
508 }
509 }
510
511 camera_metadata_ro_entry_t flashAvailable =
512 staticInfo(ANDROID_FLASH_AVAILABLE, 1, 1);
513 if (!flashAvailable.count) return NO_INIT;
514
515 camera_metadata_ro_entry_t availableAeModes =
516 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_MODES);
517 if (!availableAeModes.count) return NO_INIT;
518
519 if (flashAvailable.data.u8[0]) {
520 flashMode = Parameters::FLASH_MODE_AUTO;
521 params.set(CameraParameters::KEY_FLASH_MODE,
522 CameraParameters::FLASH_MODE_AUTO);
523
524 String8 supportedFlashModes(CameraParameters::FLASH_MODE_OFF);
525 supportedFlashModes = supportedFlashModes +
526 "," + CameraParameters::FLASH_MODE_AUTO +
527 "," + CameraParameters::FLASH_MODE_ON +
528 "," + CameraParameters::FLASH_MODE_TORCH;
529 for (size_t i=0; i < availableAeModes.count; i++) {
530 if (availableAeModes.data.u8[i] ==
531 ANDROID_CONTROL_AE_ON_AUTO_FLASH_REDEYE) {
532 supportedFlashModes = supportedFlashModes + "," +
533 CameraParameters::FLASH_MODE_RED_EYE;
534 break;
535 }
536 }
537 params.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES,
538 supportedFlashModes);
539 } else {
540 flashMode = Parameters::FLASH_MODE_OFF;
541 params.set(CameraParameters::KEY_FLASH_MODE,
542 CameraParameters::FLASH_MODE_OFF);
543 params.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES,
544 CameraParameters::FLASH_MODE_OFF);
545 }
546
547 camera_metadata_ro_entry_t minFocusDistance =
548 staticInfo(ANDROID_LENS_MINIMUM_FOCUS_DISTANCE, 1, 1);
549 if (!minFocusDistance.count) return NO_INIT;
550
551 camera_metadata_ro_entry_t availableAfModes =
552 staticInfo(ANDROID_CONTROL_AF_AVAILABLE_MODES);
553 if (!availableAfModes.count) return NO_INIT;
554
555 if (minFocusDistance.data.f[0] == 0) {
556 // Fixed-focus lens
557 focusMode = Parameters::FOCUS_MODE_FIXED;
558 params.set(CameraParameters::KEY_FOCUS_MODE,
559 CameraParameters::FOCUS_MODE_FIXED);
560 params.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES,
561 CameraParameters::FOCUS_MODE_FIXED);
562 } else {
563 focusMode = Parameters::FOCUS_MODE_AUTO;
564 params.set(CameraParameters::KEY_FOCUS_MODE,
565 CameraParameters::FOCUS_MODE_AUTO);
566 String8 supportedFocusModes(CameraParameters::FOCUS_MODE_INFINITY);
567 bool addComma = true;
568
569 for (size_t i=0; i < availableAfModes.count; i++) {
570 if (addComma) supportedFocusModes += ",";
571 addComma = true;
572 switch (availableAfModes.data.u8[i]) {
573 case ANDROID_CONTROL_AF_AUTO:
574 supportedFocusModes +=
575 CameraParameters::FOCUS_MODE_AUTO;
576 break;
577 case ANDROID_CONTROL_AF_MACRO:
578 supportedFocusModes +=
579 CameraParameters::FOCUS_MODE_MACRO;
580 break;
581 case ANDROID_CONTROL_AF_CONTINUOUS_VIDEO:
582 supportedFocusModes +=
583 CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO;
584 break;
585 case ANDROID_CONTROL_AF_CONTINUOUS_PICTURE:
586 supportedFocusModes +=
587 CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE;
588 break;
589 case ANDROID_CONTROL_AF_EDOF:
590 supportedFocusModes +=
591 CameraParameters::FOCUS_MODE_EDOF;
592 break;
593 // Not supported in old API
594 case ANDROID_CONTROL_AF_OFF:
595 addComma = false;
596 break;
597 default:
598 ALOGW("%s: Camera %d: Unknown AF mode value: %d",
599 __FUNCTION__, cameraId, availableAfModes.data.u8[i]);
600 addComma = false;
601 break;
602 }
603 }
604 params.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES,
605 supportedFocusModes);
606 }
607
608 camera_metadata_ro_entry_t max3aRegions =
609 staticInfo(ANDROID_CONTROL_MAX_REGIONS, 1, 1);
610 if (!max3aRegions.count) return NO_INIT;
611
612 params.set(CameraParameters::KEY_MAX_NUM_FOCUS_AREAS,
613 max3aRegions.data.i32[0]);
614 params.set(CameraParameters::KEY_FOCUS_AREAS,
615 "(0,0,0,0,0)");
616 focusingAreas.clear();
617 focusingAreas.add(Parameters::Area(0,0,0,0,0));
618
619 camera_metadata_ro_entry_t availableFocalLengths =
620 staticInfo(ANDROID_LENS_AVAILABLE_FOCAL_LENGTHS);
621 if (!availableFocalLengths.count) return NO_INIT;
622
623 float minFocalLength = availableFocalLengths.data.f[0];
624 params.setFloat(CameraParameters::KEY_FOCAL_LENGTH, minFocalLength);
625
626 camera_metadata_ro_entry_t sensorSize =
627 staticInfo(ANDROID_SENSOR_PHYSICAL_SIZE, 2, 2);
628 if (!sensorSize.count) return NO_INIT;
629
630 // The fields of view here assume infinity focus, maximum wide angle
631 float horizFov = 180 / M_PI *
632 2 * atanf(sensorSize.data.f[0] / (2 * minFocalLength));
633 float vertFov = 180 / M_PI *
634 2 * atanf(sensorSize.data.f[1] / (2 * minFocalLength));
635 params.setFloat(CameraParameters::KEY_HORIZONTAL_VIEW_ANGLE, horizFov);
636 params.setFloat(CameraParameters::KEY_VERTICAL_VIEW_ANGLE, vertFov);
637
638 exposureCompensation = 0;
639 params.set(CameraParameters::KEY_EXPOSURE_COMPENSATION,
640 exposureCompensation);
641
642 camera_metadata_ro_entry_t exposureCompensationRange =
643 staticInfo(ANDROID_CONTROL_AE_EXP_COMPENSATION_RANGE, 2, 2);
644 if (!exposureCompensationRange.count) return NO_INIT;
645
646 params.set(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION,
647 exposureCompensationRange.data.i32[1]);
648 params.set(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION,
649 exposureCompensationRange.data.i32[0]);
650
651 camera_metadata_ro_entry_t exposureCompensationStep =
652 staticInfo(ANDROID_CONTROL_AE_EXP_COMPENSATION_STEP, 1, 1);
653 if (!exposureCompensationStep.count) return NO_INIT;
654
655 params.setFloat(CameraParameters::KEY_EXPOSURE_COMPENSATION_STEP,
656 (float)exposureCompensationStep.data.r[0].numerator /
657 exposureCompensationStep.data.r[0].denominator);
658
659 autoExposureLock = false;
660 params.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK,
661 CameraParameters::FALSE);
662 params.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED,
663 CameraParameters::TRUE);
664
665 autoWhiteBalanceLock = false;
666 params.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK,
667 CameraParameters::FALSE);
668 params.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED,
669 CameraParameters::TRUE);
670
671 meteringAreas.add(Parameters::Area(0, 0, 0, 0, 0));
672 params.set(CameraParameters::KEY_MAX_NUM_METERING_AREAS,
673 max3aRegions.data.i32[0]);
674 params.set(CameraParameters::KEY_METERING_AREAS,
675 "(0,0,0,0,0)");
676
677 zoom = 0;
678 params.set(CameraParameters::KEY_ZOOM, zoom);
679 params.set(CameraParameters::KEY_MAX_ZOOM, NUM_ZOOM_STEPS - 1);
680
681 camera_metadata_ro_entry_t maxDigitalZoom =
682 staticInfo(ANDROID_SCALER_AVAILABLE_MAX_ZOOM, 1, 1);
683 if (!maxDigitalZoom.count) return NO_INIT;
684
685 {
686 String8 zoomRatios;
687 float zoom = 1.f;
688 float zoomIncrement = (maxDigitalZoom.data.f[0] - zoom) /
689 (NUM_ZOOM_STEPS-1);
690 bool addComma = false;
691 for (size_t i=0; i < NUM_ZOOM_STEPS; i++) {
692 if (addComma) zoomRatios += ",";
693 addComma = true;
694 zoomRatios += String8::format("%d", static_cast<int>(zoom * 100));
695 zoom += zoomIncrement;
696 }
697 params.set(CameraParameters::KEY_ZOOM_RATIOS, zoomRatios);
698 }
699
700 params.set(CameraParameters::KEY_ZOOM_SUPPORTED,
701 CameraParameters::TRUE);
702 params.set(CameraParameters::KEY_SMOOTH_ZOOM_SUPPORTED,
703 CameraParameters::TRUE);
704
705 params.set(CameraParameters::KEY_FOCUS_DISTANCES,
706 "Infinity,Infinity,Infinity");
707
708 params.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_HW,
709 fastInfo.maxFaces);
710 params.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_SW,
711 0);
712
713 params.set(CameraParameters::KEY_VIDEO_FRAME_FORMAT,
714 CameraParameters::PIXEL_FORMAT_ANDROID_OPAQUE);
715
716 params.set(CameraParameters::KEY_RECORDING_HINT,
717 CameraParameters::FALSE);
718
719 params.set(CameraParameters::KEY_VIDEO_SNAPSHOT_SUPPORTED,
720 CameraParameters::TRUE);
721
722 params.set(CameraParameters::KEY_VIDEO_STABILIZATION,
723 CameraParameters::FALSE);
724
725 camera_metadata_ro_entry_t availableVideoStabilizationModes =
726 staticInfo(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES);
727 if (!availableVideoStabilizationModes.count) return NO_INIT;
728
729 if (availableVideoStabilizationModes.count > 1) {
730 params.set(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED,
731 CameraParameters::TRUE);
732 } else {
733 params.set(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED,
734 CameraParameters::FALSE);
735 }
736
737 // Set up initial state for non-Camera.Parameters state variables
738
739 storeMetadataInBuffers = true;
740 playShutterSound = true;
741 enableFaceDetect = false;
742
743 enableFocusMoveMessages = false;
Eino-Ville Talvala69230df2012-08-29 17:37:16 -0700[diff] [blame]744 afTriggerCounter = 1;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]745 currentAfTriggerId = -1;
746
Eino-Ville Talvala69230df2012-08-29 17:37:16 -0700[diff] [blame]747 precaptureTriggerCounter = 1;
748
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]749 previewCallbackFlags = 0;
750
James Painterc3dbf1a2012-09-05 18:02:32 -0700[diff] [blame]751 zslMode = false;
752
753 lightFx = LIGHTFX_NONE;
754
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]755 state = STOPPED;
756
757 paramsFlattened = params.flatten();
758
759 return OK;
760}
761
762status_t Parameters::buildFastInfo() {
763
764 camera_metadata_ro_entry_t activeArraySize =
765 staticInfo(ANDROID_SENSOR_ACTIVE_ARRAY_SIZE, 2, 2);
766 if (!activeArraySize.count) return NO_INIT;
767 int32_t arrayWidth = activeArraySize.data.i32[0];
768 int32_t arrayHeight = activeArraySize.data.i32[1];
769
770 camera_metadata_ro_entry_t availableFaceDetectModes =
771 staticInfo(ANDROID_STATS_AVAILABLE_FACE_DETECT_MODES);
772 if (!availableFaceDetectModes.count) return NO_INIT;
773
774 uint8_t bestFaceDetectMode =
775 ANDROID_STATS_FACE_DETECTION_OFF;
776 for (size_t i = 0 ; i < availableFaceDetectModes.count; i++) {
777 switch (availableFaceDetectModes.data.u8[i]) {
778 case ANDROID_STATS_FACE_DETECTION_OFF:
779 break;
780 case ANDROID_STATS_FACE_DETECTION_SIMPLE:
781 if (bestFaceDetectMode !=
782 ANDROID_STATS_FACE_DETECTION_FULL) {
783 bestFaceDetectMode =
784 ANDROID_STATS_FACE_DETECTION_SIMPLE;
785 }
786 break;
787 case ANDROID_STATS_FACE_DETECTION_FULL:
788 bestFaceDetectMode =
789 ANDROID_STATS_FACE_DETECTION_FULL;
790 break;
791 default:
792 ALOGE("%s: Camera %d: Unknown face detect mode %d:",
793 __FUNCTION__, cameraId,
794 availableFaceDetectModes.data.u8[i]);
795 return NO_INIT;
796 }
797 }
798
799 camera_metadata_ro_entry_t maxFacesDetected =
800 staticInfo(ANDROID_STATS_MAX_FACE_COUNT, 1, 1);
801 if (!maxFacesDetected.count) return NO_INIT;
802
803 int32_t maxFaces = maxFacesDetected.data.i32[0];
804
805 fastInfo.arrayWidth = arrayWidth;
806 fastInfo.arrayHeight = arrayHeight;
807 fastInfo.bestFaceDetectMode = bestFaceDetectMode;
808 fastInfo.maxFaces = maxFaces;
809 return OK;
810}
811
812camera_metadata_ro_entry_t Parameters::staticInfo(uint32_t tag,
813 size_t minCount, size_t maxCount) const {
814 status_t res;
815 camera_metadata_ro_entry_t entry = info->find(tag);
816
817 if (CC_UNLIKELY( entry.count == 0 )) {
818 const char* tagSection = get_camera_metadata_section_name(tag);
819 if (tagSection == NULL) tagSection = "<unknown>";
820 const char* tagName = get_camera_metadata_tag_name(tag);
821 if (tagName == NULL) tagName = "<unknown>";
822
823 ALOGE("Error finding static metadata entry '%s.%s' (%x)",
824 tagSection, tagName, tag);
825 } else if (CC_UNLIKELY(
826 (minCount != 0 && entry.count < minCount) ||
827 (maxCount != 0 && entry.count > maxCount) ) ) {
828 const char* tagSection = get_camera_metadata_section_name(tag);
829 if (tagSection == NULL) tagSection = "<unknown>";
830 const char* tagName = get_camera_metadata_tag_name(tag);
831 if (tagName == NULL) tagName = "<unknown>";
832 ALOGE("Malformed static metadata entry '%s.%s' (%x):"
833 "Expected between %d and %d values, but got %d values",
834 tagSection, tagName, tag, minCount, maxCount, entry.count);
835 }
836
837 return entry;
838}
839
840status_t Parameters::set(const String8& params) {
841 status_t res;
842
843 CameraParameters newParams(params);
844
845 // TODO: Currently ignoring any changes to supposedly read-only parameters
846 // such as supported preview sizes, etc. Should probably produce an error if
847 // they're changed.
848
849 /** Extract and verify new parameters */
850
851 size_t i;
852
853 Parameters validatedParams(*this);
854
855 // PREVIEW_SIZE
856 newParams.getPreviewSize(&validatedParams.previewWidth,
857 &validatedParams.previewHeight);
858
859 if (validatedParams.previewWidth != previewWidth ||
860 validatedParams.previewHeight != previewHeight) {
861 if (state >= PREVIEW) {
862 ALOGE("%s: Preview size cannot be updated when preview "
863 "is active! (Currently %d x %d, requested %d x %d",
864 __FUNCTION__,
865 previewWidth, previewHeight,
866 validatedParams.previewWidth, validatedParams.previewHeight);
867 return BAD_VALUE;
868 }
869 camera_metadata_ro_entry_t availablePreviewSizes =
870 staticInfo(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES);
871 for (i = 0; i < availablePreviewSizes.count; i += 2 ) {
872 if ((availablePreviewSizes.data.i32[i] ==
873 validatedParams.previewWidth) &&
874 (availablePreviewSizes.data.i32[i+1] ==
875 validatedParams.previewHeight)) break;
876 }
877 if (i == availablePreviewSizes.count) {
878 ALOGE("%s: Requested preview size %d x %d is not supported",
879 __FUNCTION__, validatedParams.previewWidth,
880 validatedParams.previewHeight);
881 return BAD_VALUE;
882 }
883 }
884
885 // PREVIEW_FPS_RANGE
886 bool fpsRangeChanged = false;
887 newParams.getPreviewFpsRange(&validatedParams.previewFpsRange[0],
888 &validatedParams.previewFpsRange[1]);
889 if (validatedParams.previewFpsRange[0] != previewFpsRange[0] ||
890 validatedParams.previewFpsRange[1] != previewFpsRange[1]) {
891 fpsRangeChanged = true;
892 camera_metadata_ro_entry_t availablePreviewFpsRanges =
893 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES, 2);
894 for (i = 0; i < availablePreviewFpsRanges.count; i += 2) {
895 if ((availablePreviewFpsRanges.data.i32[i] ==
896 validatedParams.previewFpsRange[0]) &&
897 (availablePreviewFpsRanges.data.i32[i+1] ==
898 validatedParams.previewFpsRange[1]) ) {
899 break;
900 }
901 }
902 if (i == availablePreviewFpsRanges.count) {
903 ALOGE("%s: Requested preview FPS range %d - %d is not supported",
904 __FUNCTION__, validatedParams.previewFpsRange[0],
905 validatedParams.previewFpsRange[1]);
906 return BAD_VALUE;
907 }
908 validatedParams.previewFps = validatedParams.previewFpsRange[0];
909 }
910
911 // PREVIEW_FORMAT
912 validatedParams.previewFormat =
913 formatStringToEnum(newParams.getPreviewFormat());
914 if (validatedParams.previewFormat != previewFormat) {
915 if (state >= PREVIEW) {
916 ALOGE("%s: Preview format cannot be updated when preview "
917 "is active!", __FUNCTION__);
918 return BAD_VALUE;
919 }
920 camera_metadata_ro_entry_t availableFormats =
921 staticInfo(ANDROID_SCALER_AVAILABLE_FORMATS);
922 for (i = 0; i < availableFormats.count; i++) {
923 if (availableFormats.data.i32[i] == validatedParams.previewFormat)
924 break;
925 }
926 if (i == availableFormats.count) {
927 ALOGE("%s: Requested preview format %s (0x%x) is not supported",
928 __FUNCTION__, newParams.getPreviewFormat(),
929 validatedParams.previewFormat);
930 return BAD_VALUE;
931 }
932 }
933
934 // PREVIEW_FRAME_RATE
935 // Deprecated, only use if the preview fps range is unchanged this time.
936 // The single-value FPS is the same as the minimum of the range.
937 if (!fpsRangeChanged) {
938 validatedParams.previewFps = newParams.getPreviewFrameRate();
939 if (validatedParams.previewFps != previewFps) {
940 camera_metadata_ro_entry_t availableFrameRates =
941 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES);
942 for (i = 0; i < availableFrameRates.count; i+=2) {
943 if (availableFrameRates.data.i32[i] ==
944 validatedParams.previewFps) break;
945 }
946 if (i == availableFrameRates.count) {
947 ALOGE("%s: Requested preview frame rate %d is not supported",
948 __FUNCTION__, validatedParams.previewFps);
949 return BAD_VALUE;
950 }
951 validatedParams.previewFpsRange[0] =
952 availableFrameRates.data.i32[i];
953 validatedParams.previewFpsRange[1] =
954 availableFrameRates.data.i32[i+1];
955 }
956 }
957
958 // PICTURE_SIZE
959 newParams.getPictureSize(&validatedParams.pictureWidth,
960 &validatedParams.pictureHeight);
961 if (validatedParams.pictureWidth == pictureWidth ||
962 validatedParams.pictureHeight == pictureHeight) {
963 camera_metadata_ro_entry_t availablePictureSizes =
964 staticInfo(ANDROID_SCALER_AVAILABLE_JPEG_SIZES);
965 for (i = 0; i < availablePictureSizes.count; i+=2) {
966 if ((availablePictureSizes.data.i32[i] ==
967 validatedParams.pictureWidth) &&
968 (availablePictureSizes.data.i32[i+1] ==
969 validatedParams.pictureHeight)) break;
970 }
971 if (i == availablePictureSizes.count) {
972 ALOGE("%s: Requested picture size %d x %d is not supported",
973 __FUNCTION__, validatedParams.pictureWidth,
974 validatedParams.pictureHeight);
975 return BAD_VALUE;
976 }
977 }
978
979 // JPEG_THUMBNAIL_WIDTH/HEIGHT
980 validatedParams.jpegThumbSize[0] =
981 newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH);
982 validatedParams.jpegThumbSize[1] =
983 newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT);
984 if (validatedParams.jpegThumbSize[0] != jpegThumbSize[0] ||
985 validatedParams.jpegThumbSize[1] != jpegThumbSize[1]) {
986 camera_metadata_ro_entry_t availableJpegThumbSizes =
987 staticInfo(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES);
988 for (i = 0; i < availableJpegThumbSizes.count; i+=2) {
989 if ((availableJpegThumbSizes.data.i32[i] ==
990 validatedParams.jpegThumbSize[0]) &&
991 (availableJpegThumbSizes.data.i32[i+1] ==
992 validatedParams.jpegThumbSize[1])) break;
993 }
994 if (i == availableJpegThumbSizes.count) {
995 ALOGE("%s: Requested JPEG thumbnail size %d x %d is not supported",
996 __FUNCTION__, validatedParams.jpegThumbSize[0],
997 validatedParams.jpegThumbSize[1]);
998 return BAD_VALUE;
999 }
1000 }
1001
1002 // JPEG_THUMBNAIL_QUALITY
1003 validatedParams.jpegThumbQuality =
1004 newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY);
1005 if (validatedParams.jpegThumbQuality < 0 ||
1006 validatedParams.jpegThumbQuality > 100) {
1007 ALOGE("%s: Requested JPEG thumbnail quality %d is not supported",
1008 __FUNCTION__, validatedParams.jpegThumbQuality);
1009 return BAD_VALUE;
1010 }
1011
1012 // JPEG_QUALITY
1013 validatedParams.jpegQuality =
1014 newParams.getInt(CameraParameters::KEY_JPEG_QUALITY);
1015 if (validatedParams.jpegQuality < 0 || validatedParams.jpegQuality > 100) {
1016 ALOGE("%s: Requested JPEG quality %d is not supported",
1017 __FUNCTION__, validatedParams.jpegQuality);
1018 return BAD_VALUE;
1019 }
1020
1021 // ROTATION
1022 validatedParams.jpegRotation =
1023 newParams.getInt(CameraParameters::KEY_ROTATION);
1024 if (validatedParams.jpegRotation != 0 &&
1025 validatedParams.jpegRotation != 90 &&
1026 validatedParams.jpegRotation != 180 &&
1027 validatedParams.jpegRotation != 270) {
1028 ALOGE("%s: Requested picture rotation angle %d is not supported",
1029 __FUNCTION__, validatedParams.jpegRotation);
1030 return BAD_VALUE;
1031 }
1032
1033 // GPS
1034
1035 const char *gpsLatStr =
1036 newParams.get(CameraParameters::KEY_GPS_LATITUDE);
1037 if (gpsLatStr != NULL) {
1038 const char *gpsLongStr =
1039 newParams.get(CameraParameters::KEY_GPS_LONGITUDE);
1040 const char *gpsAltitudeStr =
1041 newParams.get(CameraParameters::KEY_GPS_ALTITUDE);
1042 const char *gpsTimeStr =
1043 newParams.get(CameraParameters::KEY_GPS_TIMESTAMP);
1044 const char *gpsProcMethodStr =
1045 newParams.get(CameraParameters::KEY_GPS_PROCESSING_METHOD);
1046 if (gpsLongStr == NULL ||
1047 gpsAltitudeStr == NULL ||
1048 gpsTimeStr == NULL ||
1049 gpsProcMethodStr == NULL) {
1050 ALOGE("%s: Incomplete set of GPS parameters provided",
1051 __FUNCTION__);
1052 return BAD_VALUE;
1053 }
1054 char *endPtr;
1055 errno = 0;
1056 validatedParams.gpsCoordinates[0] = strtod(gpsLatStr, &endPtr);
1057 if (errno || endPtr == gpsLatStr) {
1058 ALOGE("%s: Malformed GPS latitude: %s", __FUNCTION__, gpsLatStr);
1059 return BAD_VALUE;
1060 }
1061 errno = 0;
1062 validatedParams.gpsCoordinates[1] = strtod(gpsLongStr, &endPtr);
1063 if (errno || endPtr == gpsLongStr) {
1064 ALOGE("%s: Malformed GPS longitude: %s", __FUNCTION__, gpsLongStr);
1065 return BAD_VALUE;
1066 }
1067 errno = 0;
1068 validatedParams.gpsCoordinates[2] = strtod(gpsAltitudeStr, &endPtr);
1069 if (errno || endPtr == gpsAltitudeStr) {
1070 ALOGE("%s: Malformed GPS altitude: %s", __FUNCTION__,
1071 gpsAltitudeStr);
1072 return BAD_VALUE;
1073 }
1074 errno = 0;
1075 validatedParams.gpsTimestamp = strtoll(gpsTimeStr, &endPtr, 10);
1076 if (errno || endPtr == gpsTimeStr) {
1077 ALOGE("%s: Malformed GPS timestamp: %s", __FUNCTION__, gpsTimeStr);
1078 return BAD_VALUE;
1079 }
1080 validatedParams.gpsProcessingMethod = gpsProcMethodStr;
1081
1082 validatedParams.gpsEnabled = true;
1083 } else {
1084 validatedParams.gpsEnabled = false;
1085 }
1086
1087 // WHITE_BALANCE
1088 validatedParams.wbMode = wbModeStringToEnum(
1089 newParams.get(CameraParameters::KEY_WHITE_BALANCE) );
1090 if (validatedParams.wbMode != wbMode) {
1091 camera_metadata_ro_entry_t availableWbModes =
1092 staticInfo(ANDROID_CONTROL_AWB_AVAILABLE_MODES);
1093 for (i = 0; i < availableWbModes.count; i++) {
1094 if (validatedParams.wbMode == availableWbModes.data.u8[i]) break;
1095 }
1096 if (i == availableWbModes.count) {
1097 ALOGE("%s: Requested white balance mode %s is not supported",
1098 __FUNCTION__,
1099 newParams.get(CameraParameters::KEY_WHITE_BALANCE));
1100 return BAD_VALUE;
1101 }
1102 }
1103
1104 // EFFECT
1105 validatedParams.effectMode = effectModeStringToEnum(
1106 newParams.get(CameraParameters::KEY_EFFECT) );
1107 if (validatedParams.effectMode != effectMode) {
1108 camera_metadata_ro_entry_t availableEffectModes =
1109 staticInfo(ANDROID_CONTROL_AVAILABLE_EFFECTS);
1110 for (i = 0; i < availableEffectModes.count; i++) {
1111 if (validatedParams.effectMode == availableEffectModes.data.u8[i]) break;
1112 }
1113 if (i == availableEffectModes.count) {
1114 ALOGE("%s: Requested effect mode \"%s\" is not supported",
1115 __FUNCTION__,
1116 newParams.get(CameraParameters::KEY_EFFECT) );
1117 return BAD_VALUE;
1118 }
1119 }
1120
1121 // ANTIBANDING
1122 validatedParams.antibandingMode = abModeStringToEnum(
1123 newParams.get(CameraParameters::KEY_ANTIBANDING) );
1124 if (validatedParams.antibandingMode != antibandingMode) {
1125 camera_metadata_ro_entry_t availableAbModes =
1126 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES);
1127 for (i = 0; i < availableAbModes.count; i++) {
1128 if (validatedParams.antibandingMode == availableAbModes.data.u8[i])
1129 break;
1130 }
1131 if (i == availableAbModes.count) {
1132 ALOGE("%s: Requested antibanding mode \"%s\" is not supported",
1133 __FUNCTION__,
1134 newParams.get(CameraParameters::KEY_ANTIBANDING));
1135 return BAD_VALUE;
1136 }
1137 }
1138
1139 // SCENE_MODE
1140 validatedParams.sceneMode = sceneModeStringToEnum(
1141 newParams.get(CameraParameters::KEY_SCENE_MODE) );
1142 if (validatedParams.sceneMode != sceneMode &&
1143 validatedParams.sceneMode !=
1144 ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED) {
1145 camera_metadata_ro_entry_t availableSceneModes =
1146 staticInfo(ANDROID_CONTROL_AVAILABLE_SCENE_MODES);
1147 for (i = 0; i < availableSceneModes.count; i++) {
1148 if (validatedParams.sceneMode == availableSceneModes.data.u8[i])
1149 break;
1150 }
1151 if (i == availableSceneModes.count) {
1152 ALOGE("%s: Requested scene mode \"%s\" is not supported",
1153 __FUNCTION__,
1154 newParams.get(CameraParameters::KEY_SCENE_MODE));
1155 return BAD_VALUE;
1156 }
1157 }
1158
1159 // FLASH_MODE
1160 validatedParams.flashMode = flashModeStringToEnum(
1161 newParams.get(CameraParameters::KEY_FLASH_MODE) );
1162 if (validatedParams.flashMode != flashMode) {
1163 camera_metadata_ro_entry_t flashAvailable =
1164 staticInfo(ANDROID_FLASH_AVAILABLE, 1, 1);
1165 if (!flashAvailable.data.u8[0] &&
1166 validatedParams.flashMode != Parameters::FLASH_MODE_OFF) {
1167 ALOGE("%s: Requested flash mode \"%s\" is not supported: "
1168 "No flash on device", __FUNCTION__,
1169 newParams.get(CameraParameters::KEY_FLASH_MODE));
1170 return BAD_VALUE;
1171 } else if (validatedParams.flashMode == Parameters::FLASH_MODE_RED_EYE) {
1172 camera_metadata_ro_entry_t availableAeModes =
1173 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_MODES);
1174 for (i = 0; i < availableAeModes.count; i++) {
1175 if (validatedParams.flashMode == availableAeModes.data.u8[i])
1176 break;
1177 }
1178 if (i == availableAeModes.count) {
1179 ALOGE("%s: Requested flash mode \"%s\" is not supported",
1180 __FUNCTION__,
1181 newParams.get(CameraParameters::KEY_FLASH_MODE));
1182 return BAD_VALUE;
1183 }
1184 } else if (validatedParams.flashMode == -1) {
1185 ALOGE("%s: Requested flash mode \"%s\" is unknown",
1186 __FUNCTION__,
1187 newParams.get(CameraParameters::KEY_FLASH_MODE));
1188 return BAD_VALUE;
1189 }
1190 }
1191
1192 // FOCUS_MODE
1193 validatedParams.focusMode = focusModeStringToEnum(
1194 newParams.get(CameraParameters::KEY_FOCUS_MODE));
1195 if (validatedParams.focusMode != focusMode) {
1196 validatedParams.currentAfTriggerId = -1;
1197 if (validatedParams.focusMode != Parameters::FOCUS_MODE_FIXED) {
1198 camera_metadata_ro_entry_t minFocusDistance =
1199 staticInfo(ANDROID_LENS_MINIMUM_FOCUS_DISTANCE);
1200 if (minFocusDistance.data.f[0] == 0) {
1201 ALOGE("%s: Requested focus mode \"%s\" is not available: "
1202 "fixed focus lens",
1203 __FUNCTION__,
1204 newParams.get(CameraParameters::KEY_FOCUS_MODE));
1205 return BAD_VALUE;
1206 } else if (validatedParams.focusMode !=
1207 Parameters::FOCUS_MODE_INFINITY) {
1208 camera_metadata_ro_entry_t availableFocusModes =
1209 staticInfo(ANDROID_CONTROL_AF_AVAILABLE_MODES);
1210 for (i = 0; i < availableFocusModes.count; i++) {
1211 if (validatedParams.focusMode ==
1212 availableFocusModes.data.u8[i]) break;
1213 }
1214 if (i == availableFocusModes.count) {
1215 ALOGE("%s: Requested focus mode \"%s\" is not supported",
1216 __FUNCTION__,
1217 newParams.get(CameraParameters::KEY_FOCUS_MODE));
1218 return BAD_VALUE;
1219 }
1220 }
1221 }
1222 } else {
1223 validatedParams.currentAfTriggerId = currentAfTriggerId;
1224 }
1225
1226 // FOCUS_AREAS
1227 res = parseAreas(newParams.get(CameraParameters::KEY_FOCUS_AREAS),
1228 &validatedParams.focusingAreas);
1229 size_t max3aRegions =
1230 (size_t)staticInfo(ANDROID_CONTROL_MAX_REGIONS, 1, 1).data.i32[0];
1231 if (res == OK) res = validateAreas(validatedParams.focusingAreas,
1232 max3aRegions);
1233 if (res != OK) {
1234 ALOGE("%s: Requested focus areas are malformed: %s",
1235 __FUNCTION__, newParams.get(CameraParameters::KEY_FOCUS_AREAS));
1236 return BAD_VALUE;
1237 }
1238
1239 // EXPOSURE_COMPENSATION
1240 validatedParams.exposureCompensation =
1241 newParams.getInt(CameraParameters::KEY_EXPOSURE_COMPENSATION);
1242 camera_metadata_ro_entry_t exposureCompensationRange =
1243 staticInfo(ANDROID_CONTROL_AE_EXP_COMPENSATION_RANGE);
1244 if ((validatedParams.exposureCompensation <
1245 exposureCompensationRange.data.i32[0]) ||
1246 (validatedParams.exposureCompensation >
1247 exposureCompensationRange.data.i32[1])) {
1248 ALOGE("%s: Requested exposure compensation index is out of bounds: %d",
1249 __FUNCTION__, validatedParams.exposureCompensation);
1250 return BAD_VALUE;
1251 }
1252
1253 // AUTO_EXPOSURE_LOCK (always supported)
1254 validatedParams.autoExposureLock = boolFromString(
1255 newParams.get(CameraParameters::KEY_AUTO_EXPOSURE_LOCK));
1256
1257 // AUTO_WHITEBALANCE_LOCK (always supported)
1258 validatedParams.autoWhiteBalanceLock = boolFromString(
1259 newParams.get(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK));
1260
1261 // METERING_AREAS
1262 res = parseAreas(newParams.get(CameraParameters::KEY_METERING_AREAS),
1263 &validatedParams.meteringAreas);
1264 if (res == OK) {
1265 res = validateAreas(validatedParams.meteringAreas, max3aRegions);
1266 }
1267 if (res != OK) {
1268 ALOGE("%s: Requested metering areas are malformed: %s",
1269 __FUNCTION__,
1270 newParams.get(CameraParameters::KEY_METERING_AREAS));
1271 return BAD_VALUE;
1272 }
1273
1274 // ZOOM
1275 validatedParams.zoom = newParams.getInt(CameraParameters::KEY_ZOOM);
1276 if (validatedParams.zoom < 0 || validatedParams.zoom > (int)NUM_ZOOM_STEPS) {
1277 ALOGE("%s: Requested zoom level %d is not supported",
1278 __FUNCTION__, validatedParams.zoom);
1279 return BAD_VALUE;
1280 }
1281
1282 // VIDEO_SIZE
1283 newParams.getVideoSize(&validatedParams.videoWidth,
1284 &validatedParams.videoHeight);
1285 if (validatedParams.videoWidth != videoWidth ||
1286 validatedParams.videoHeight != videoHeight) {
1287 if (state == RECORD) {
1288 ALOGE("%s: Video size cannot be updated when recording is active!",
1289 __FUNCTION__);
1290 return BAD_VALUE;
1291 }
1292 camera_metadata_ro_entry_t availableVideoSizes =
1293 staticInfo(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES);
1294 for (i = 0; i < availableVideoSizes.count; i += 2 ) {
1295 if ((availableVideoSizes.data.i32[i] ==
1296 validatedParams.videoWidth) &&
1297 (availableVideoSizes.data.i32[i+1] ==
1298 validatedParams.videoHeight)) break;
1299 }
1300 if (i == availableVideoSizes.count) {
1301 ALOGE("%s: Requested video size %d x %d is not supported",
1302 __FUNCTION__, validatedParams.videoWidth,
1303 validatedParams.videoHeight);
1304 return BAD_VALUE;
1305 }
1306 }
1307
1308 // RECORDING_HINT (always supported)
1309 validatedParams.recordingHint = boolFromString(
1310 newParams.get(CameraParameters::KEY_RECORDING_HINT) );
1311
1312 // VIDEO_STABILIZATION
1313 validatedParams.videoStabilization = boolFromString(
1314 newParams.get(CameraParameters::KEY_VIDEO_STABILIZATION) );
1315 camera_metadata_ro_entry_t availableVideoStabilizationModes =
1316 staticInfo(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES);
1317 if (validatedParams.videoStabilization &&
1318 availableVideoStabilizationModes.count == 1) {
1319 ALOGE("%s: Video stabilization not supported", __FUNCTION__);
1320 }
1321
James Painterc3dbf1a2012-09-05 18:02:32 -0700[diff] [blame]1322 // LIGHTFX
1323 validatedParams.lightFx = lightFxStringToEnum(
1324 newParams.get(CameraParameters::KEY_LIGHTFX));
1325
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1326 /** Update internal parameters */
1327
1328 validatedParams.paramsFlattened = params;
1329 *this = validatedParams;
1330
1331 return OK;
1332}
1333
Eino-Ville Talvala69230df2012-08-29 17:37:16 -0700[diff] [blame]1334status_t Parameters::updateRequest(CameraMetadata *request) const {
1335 ATRACE_CALL();
1336 status_t res;
1337
1338 uint8_t metadataMode = ANDROID_REQUEST_METADATA_FULL;
1339 res = request->update(ANDROID_REQUEST_METADATA_MODE,
1340 &metadataMode, 1);
1341 if (res != OK) return res;
1342
1343 res = request->update(ANDROID_CONTROL_AE_TARGET_FPS_RANGE,
1344 previewFpsRange, 2);
1345 if (res != OK) return res;
1346
Eino-Ville Talvala69230df2012-08-29 17:37:16 -0700[diff] [blame]1347 res = request->update(ANDROID_CONTROL_AWB_MODE,
Eino-Ville Talvala2d6a5032012-09-03 10:03:26 -0700[diff] [blame]1348 &wbMode, 1);
Eino-Ville Talvala69230df2012-08-29 17:37:16 -0700[diff] [blame]1349 if (res != OK) return res;
Eino-Ville Talvala2d6a5032012-09-03 10:03:26 -0700[diff] [blame]1350
1351 uint8_t reqWbLock = autoWhiteBalanceLock ?
1352 ANDROID_CONTROL_AWB_LOCK_ON : ANDROID_CONTROL_AWB_LOCK_OFF;
1353 res = request->update(ANDROID_CONTROL_AWB_LOCK,
1354 &reqWbLock, 1);
1355
Eino-Ville Talvala69230df2012-08-29 17:37:16 -0700[diff] [blame]1356 res = request->update(ANDROID_CONTROL_EFFECT_MODE,
1357 &effectMode, 1);
1358 if (res != OK) return res;
1359 res = request->update(ANDROID_CONTROL_AE_ANTIBANDING_MODE,
1360 &antibandingMode, 1);
1361 if (res != OK) return res;
1362
Eino-Ville Talvala2a88b712012-09-07 14:26:29 -0700[diff] [blame^]1363 // android.hardware.Camera requires that when face detect is enabled, the
1364 // camera is in a face-priority mode. HAL2 splits this into separate parts
1365 // (face detection statistics and face priority scene mode). Map from other
1366 // to the other.
1367 uint8_t reqControlMode = ANDROID_CONTROL_AUTO;
1368 if (enableFaceDetect || sceneMode != ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED) {
1369 reqControlMode = ANDROID_CONTROL_USE_SCENE_MODE;
1370 }
Eino-Ville Talvala69230df2012-08-29 17:37:16 -0700[diff] [blame]1371 res = request->update(ANDROID_CONTROL_MODE,
1372 &reqControlMode, 1);
1373 if (res != OK) return res;
Eino-Ville Talvala2a88b712012-09-07 14:26:29 -0700[diff] [blame^]1374
1375 uint8_t reqSceneMode = enableFaceDetect ?
1376 (uint8_t)ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY : sceneMode;
1377 res = request->update(ANDROID_CONTROL_SCENE_MODE,
1378 &reqSceneMode, 1);
1379 if (res != OK) return res;
Eino-Ville Talvala69230df2012-08-29 17:37:16 -0700[diff] [blame]1380
1381 uint8_t reqFlashMode = ANDROID_FLASH_OFF;
1382 uint8_t reqAeMode;
1383 switch (flashMode) {
1384 case Parameters::FLASH_MODE_OFF:
1385 reqAeMode = ANDROID_CONTROL_AE_ON; break;
1386 case Parameters::FLASH_MODE_AUTO:
1387 reqAeMode = ANDROID_CONTROL_AE_ON_AUTO_FLASH; break;
1388 case Parameters::FLASH_MODE_ON:
1389 reqAeMode = ANDROID_CONTROL_AE_ON_ALWAYS_FLASH; break;
1390 case Parameters::FLASH_MODE_TORCH:
1391 reqAeMode = ANDROID_CONTROL_AE_ON;
1392 reqFlashMode = ANDROID_FLASH_TORCH;
1393 break;
1394 case Parameters::FLASH_MODE_RED_EYE:
1395 reqAeMode = ANDROID_CONTROL_AE_ON_AUTO_FLASH_REDEYE; break;
1396 default:
1397 ALOGE("%s: Camera %d: Unknown flash mode %d", __FUNCTION__,
1398 cameraId, flashMode);
1399 return BAD_VALUE;
1400 }
Eino-Ville Talvala69230df2012-08-29 17:37:16 -0700[diff] [blame]1401 res = request->update(ANDROID_FLASH_MODE,
1402 &reqFlashMode, 1);
1403 if (res != OK) return res;
1404 res = request->update(ANDROID_CONTROL_AE_MODE,
1405 &reqAeMode, 1);
1406 if (res != OK) return res;
1407
Eino-Ville Talvala2d6a5032012-09-03 10:03:26 -0700[diff] [blame]1408 uint8_t reqAeLock = autoExposureLock ?
1409 ANDROID_CONTROL_AE_LOCK_ON : ANDROID_CONTROL_AE_LOCK_OFF;
1410 res = request->update(ANDROID_CONTROL_AE_LOCK,
1411 &reqAeLock, 1);
1412
Eino-Ville Talvala69230df2012-08-29 17:37:16 -0700[diff] [blame]1413 float reqFocusDistance = 0; // infinity focus in diopters
1414 uint8_t reqFocusMode;
1415 switch (focusMode) {
1416 case Parameters::FOCUS_MODE_AUTO:
1417 case Parameters::FOCUS_MODE_MACRO:
1418 case Parameters::FOCUS_MODE_CONTINUOUS_VIDEO:
1419 case Parameters::FOCUS_MODE_CONTINUOUS_PICTURE:
1420 case Parameters::FOCUS_MODE_EDOF:
1421 reqFocusMode = focusMode;
1422 break;
1423 case Parameters::FOCUS_MODE_INFINITY:
1424 case Parameters::FOCUS_MODE_FIXED:
1425 reqFocusMode = ANDROID_CONTROL_AF_OFF;
1426 break;
1427 default:
1428 ALOGE("%s: Camera %d: Unknown focus mode %d", __FUNCTION__,
1429 cameraId, focusMode);
1430 return BAD_VALUE;
1431 }
1432 res = request->update(ANDROID_LENS_FOCUS_DISTANCE,
1433 &reqFocusDistance, 1);
1434 if (res != OK) return res;
1435 res = request->update(ANDROID_CONTROL_AF_MODE,
1436 &reqFocusMode, 1);
1437 if (res != OK) return res;
1438
1439 size_t reqFocusingAreasSize = focusingAreas.size() * 5;
1440 int32_t *reqFocusingAreas = new int32_t[reqFocusingAreasSize];
1441 for (size_t i = 0; i < reqFocusingAreasSize; i += 5) {
1442 if (focusingAreas[i].weight != 0) {
1443 reqFocusingAreas[i + 0] =
1444 normalizedXToArray(focusingAreas[i].left);
1445 reqFocusingAreas[i + 1] =
1446 normalizedYToArray(focusingAreas[i].top);
1447 reqFocusingAreas[i + 2] =
1448 normalizedXToArray(focusingAreas[i].right);
1449 reqFocusingAreas[i + 3] =
1450 normalizedYToArray(focusingAreas[i].bottom);
1451 } else {
1452 reqFocusingAreas[i + 0] = 0;
1453 reqFocusingAreas[i + 1] = 0;
1454 reqFocusingAreas[i + 2] = 0;
1455 reqFocusingAreas[i + 3] = 0;
1456 }
1457 reqFocusingAreas[i + 4] = focusingAreas[i].weight;
1458 }
1459 res = request->update(ANDROID_CONTROL_AF_REGIONS,
1460 reqFocusingAreas, reqFocusingAreasSize);
1461 if (res != OK) return res;
1462 delete[] reqFocusingAreas;
1463
1464 res = request->update(ANDROID_CONTROL_AE_EXP_COMPENSATION,
1465 &exposureCompensation, 1);
1466 if (res != OK) return res;
1467
1468 size_t reqMeteringAreasSize = meteringAreas.size() * 5;
1469 int32_t *reqMeteringAreas = new int32_t[reqMeteringAreasSize];
1470 for (size_t i = 0; i < reqMeteringAreasSize; i += 5) {
1471 if (meteringAreas[i].weight != 0) {
1472 reqMeteringAreas[i + 0] =
1473 normalizedXToArray(meteringAreas[i].left);
1474 reqMeteringAreas[i + 1] =
1475 normalizedYToArray(meteringAreas[i].top);
1476 reqMeteringAreas[i + 2] =
1477 normalizedXToArray(meteringAreas[i].right);
1478 reqMeteringAreas[i + 3] =
1479 normalizedYToArray(meteringAreas[i].bottom);
1480 } else {
1481 reqMeteringAreas[i + 0] = 0;
1482 reqMeteringAreas[i + 1] = 0;
1483 reqMeteringAreas[i + 2] = 0;
1484 reqMeteringAreas[i + 3] = 0;
1485 }
1486 reqMeteringAreas[i + 4] = meteringAreas[i].weight;
1487 }
1488 res = request->update(ANDROID_CONTROL_AE_REGIONS,
1489 reqMeteringAreas, reqMeteringAreasSize);
1490 if (res != OK) return res;
1491
1492 res = request->update(ANDROID_CONTROL_AWB_REGIONS,
1493 reqMeteringAreas, reqMeteringAreasSize);
1494 if (res != OK) return res;
1495 delete[] reqMeteringAreas;
1496
1497 // Need to convert zoom index into a crop rectangle. The rectangle is
1498 // chosen to maximize its area on the sensor
1499
1500 camera_metadata_ro_entry_t maxDigitalZoom =
1501 staticInfo(ANDROID_SCALER_AVAILABLE_MAX_ZOOM);
1502 float zoomIncrement = (maxDigitalZoom.data.f[0] - 1) /
1503 (NUM_ZOOM_STEPS-1);
1504 float zoomRatio = 1 + zoomIncrement * zoom;
1505
1506 float zoomLeft, zoomTop, zoomWidth, zoomHeight;
1507 if (previewWidth >= previewHeight) {
1508 zoomWidth = fastInfo.arrayWidth / zoomRatio;
1509 zoomHeight = zoomWidth *
1510 previewHeight / previewWidth;
1511 } else {
1512 zoomHeight = fastInfo.arrayHeight / zoomRatio;
1513 zoomWidth = zoomHeight *
1514 previewWidth / previewHeight;
1515 }
1516 zoomLeft = (fastInfo.arrayWidth - zoomWidth) / 2;
1517 zoomTop = (fastInfo.arrayHeight - zoomHeight) / 2;
1518
1519 int32_t reqCropRegion[3] = { zoomLeft, zoomTop, zoomWidth };
1520 res = request->update(ANDROID_SCALER_CROP_REGION,
1521 reqCropRegion, 3);
1522 if (res != OK) return res;
1523
Eino-Ville Talvala69230df2012-08-29 17:37:16 -0700[diff] [blame]1524 uint8_t reqVstabMode = videoStabilization ?
1525 ANDROID_CONTROL_VIDEO_STABILIZATION_ON :
1526 ANDROID_CONTROL_VIDEO_STABILIZATION_OFF;
1527 res = request->update(ANDROID_CONTROL_VIDEO_STABILIZATION_MODE,
1528 &reqVstabMode, 1);
1529 if (res != OK) return res;
1530
1531 uint8_t reqFaceDetectMode = enableFaceDetect ?
1532 fastInfo.bestFaceDetectMode :
1533 (uint8_t)ANDROID_STATS_FACE_DETECTION_OFF;
1534 res = request->update(ANDROID_STATS_FACE_DETECT_MODE,
1535 &reqFaceDetectMode, 1);
1536 if (res != OK) return res;
1537
1538 return OK;
1539}
1540
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1541const char* Parameters::getStateName(State state) {
1542#define CASE_ENUM_TO_CHAR(x) case x: return(#x); break;
1543 switch(state) {
1544 CASE_ENUM_TO_CHAR(DISCONNECTED)
1545 CASE_ENUM_TO_CHAR(STOPPED)
1546 CASE_ENUM_TO_CHAR(WAITING_FOR_PREVIEW_WINDOW)
1547 CASE_ENUM_TO_CHAR(PREVIEW)
1548 CASE_ENUM_TO_CHAR(RECORD)
1549 CASE_ENUM_TO_CHAR(STILL_CAPTURE)
1550 CASE_ENUM_TO_CHAR(VIDEO_SNAPSHOT)
1551 default:
1552 return "Unknown state!";
1553 break;
1554 }
1555#undef CASE_ENUM_TO_CHAR
1556}
1557
1558int Parameters::formatStringToEnum(const char *format) {
1559 return
Eino-Ville Talvala4c6b0b82012-09-10 09:53:09 -0700[diff] [blame]1560 !format ?
1561 HAL_PIXEL_FORMAT_YCrCb_420_SP :
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1562 !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV422SP) ?
1563 HAL_PIXEL_FORMAT_YCbCr_422_SP : // NV16
1564 !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV420SP) ?
1565 HAL_PIXEL_FORMAT_YCrCb_420_SP : // NV21
1566 !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV422I) ?
1567 HAL_PIXEL_FORMAT_YCbCr_422_I : // YUY2
1568 !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV420P) ?
1569 HAL_PIXEL_FORMAT_YV12 : // YV12
1570 !strcmp(format, CameraParameters::PIXEL_FORMAT_RGB565) ?
1571 HAL_PIXEL_FORMAT_RGB_565 : // RGB565
1572 !strcmp(format, CameraParameters::PIXEL_FORMAT_RGBA8888) ?
1573 HAL_PIXEL_FORMAT_RGBA_8888 : // RGB8888
1574 !strcmp(format, CameraParameters::PIXEL_FORMAT_BAYER_RGGB) ?
1575 HAL_PIXEL_FORMAT_RAW_SENSOR : // Raw sensor data
1576 -1;
1577}
1578
1579const char* Parameters::formatEnumToString(int format) {
1580 const char *fmt;
1581 switch(format) {
1582 case HAL_PIXEL_FORMAT_YCbCr_422_SP: // NV16
1583 fmt = CameraParameters::PIXEL_FORMAT_YUV422SP;
1584 break;
1585 case HAL_PIXEL_FORMAT_YCrCb_420_SP: // NV21
1586 fmt = CameraParameters::PIXEL_FORMAT_YUV420SP;
1587 break;
1588 case HAL_PIXEL_FORMAT_YCbCr_422_I: // YUY2
1589 fmt = CameraParameters::PIXEL_FORMAT_YUV422I;
1590 break;
1591 case HAL_PIXEL_FORMAT_YV12: // YV12
1592 fmt = CameraParameters::PIXEL_FORMAT_YUV420P;
1593 break;
1594 case HAL_PIXEL_FORMAT_RGB_565: // RGB565
1595 fmt = CameraParameters::PIXEL_FORMAT_RGB565;
1596 break;
1597 case HAL_PIXEL_FORMAT_RGBA_8888: // RGBA8888
1598 fmt = CameraParameters::PIXEL_FORMAT_RGBA8888;
1599 break;
1600 case HAL_PIXEL_FORMAT_RAW_SENSOR:
1601 ALOGW("Raw sensor preview format requested.");
1602 fmt = CameraParameters::PIXEL_FORMAT_BAYER_RGGB;
1603 break;
1604 default:
1605 ALOGE("%s: Unknown preview format: %x",
1606 __FUNCTION__, format);
1607 fmt = NULL;
1608 break;
1609 }
1610 return fmt;
1611}
1612
1613int Parameters::wbModeStringToEnum(const char *wbMode) {
1614 return
Eino-Ville Talvala4c6b0b82012-09-10 09:53:09 -0700[diff] [blame]1615 !wbMode ?
1616 ANDROID_CONTROL_AWB_AUTO :
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1617 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_AUTO) ?
1618 ANDROID_CONTROL_AWB_AUTO :
1619 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_INCANDESCENT) ?
1620 ANDROID_CONTROL_AWB_INCANDESCENT :
1621 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_FLUORESCENT) ?
1622 ANDROID_CONTROL_AWB_FLUORESCENT :
1623 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_WARM_FLUORESCENT) ?
1624 ANDROID_CONTROL_AWB_WARM_FLUORESCENT :
1625 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_DAYLIGHT) ?
1626 ANDROID_CONTROL_AWB_DAYLIGHT :
1627 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT) ?
1628 ANDROID_CONTROL_AWB_CLOUDY_DAYLIGHT :
1629 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_TWILIGHT) ?
1630 ANDROID_CONTROL_AWB_TWILIGHT :
1631 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_SHADE) ?
1632 ANDROID_CONTROL_AWB_SHADE :
1633 -1;
1634}
1635
1636int Parameters::effectModeStringToEnum(const char *effectMode) {
1637 return
Eino-Ville Talvala4c6b0b82012-09-10 09:53:09 -0700[diff] [blame]1638 !effectMode ?
1639 ANDROID_CONTROL_EFFECT_OFF :
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1640 !strcmp(effectMode, CameraParameters::EFFECT_NONE) ?
1641 ANDROID_CONTROL_EFFECT_OFF :
1642 !strcmp(effectMode, CameraParameters::EFFECT_MONO) ?
1643 ANDROID_CONTROL_EFFECT_MONO :
1644 !strcmp(effectMode, CameraParameters::EFFECT_NEGATIVE) ?
1645 ANDROID_CONTROL_EFFECT_NEGATIVE :
1646 !strcmp(effectMode, CameraParameters::EFFECT_SOLARIZE) ?
1647 ANDROID_CONTROL_EFFECT_SOLARIZE :
1648 !strcmp(effectMode, CameraParameters::EFFECT_SEPIA) ?
1649 ANDROID_CONTROL_EFFECT_SEPIA :
1650 !strcmp(effectMode, CameraParameters::EFFECT_POSTERIZE) ?
1651 ANDROID_CONTROL_EFFECT_POSTERIZE :
1652 !strcmp(effectMode, CameraParameters::EFFECT_WHITEBOARD) ?
1653 ANDROID_CONTROL_EFFECT_WHITEBOARD :
1654 !strcmp(effectMode, CameraParameters::EFFECT_BLACKBOARD) ?
1655 ANDROID_CONTROL_EFFECT_BLACKBOARD :
1656 !strcmp(effectMode, CameraParameters::EFFECT_AQUA) ?
1657 ANDROID_CONTROL_EFFECT_AQUA :
1658 -1;
1659}
1660
1661int Parameters::abModeStringToEnum(const char *abMode) {
1662 return
Eino-Ville Talvala4c6b0b82012-09-10 09:53:09 -0700[diff] [blame]1663 !abMode ?
1664 ANDROID_CONTROL_AE_ANTIBANDING_AUTO :
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1665 !strcmp(abMode, CameraParameters::ANTIBANDING_AUTO) ?
1666 ANDROID_CONTROL_AE_ANTIBANDING_AUTO :
1667 !strcmp(abMode, CameraParameters::ANTIBANDING_OFF) ?
1668 ANDROID_CONTROL_AE_ANTIBANDING_OFF :
1669 !strcmp(abMode, CameraParameters::ANTIBANDING_50HZ) ?
1670 ANDROID_CONTROL_AE_ANTIBANDING_50HZ :
1671 !strcmp(abMode, CameraParameters::ANTIBANDING_60HZ) ?
1672 ANDROID_CONTROL_AE_ANTIBANDING_60HZ :
1673 -1;
1674}
1675
1676int Parameters::sceneModeStringToEnum(const char *sceneMode) {
1677 return
Eino-Ville Talvala4c6b0b82012-09-10 09:53:09 -0700[diff] [blame]1678 !sceneMode ?
1679 ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED :
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1680 !strcmp(sceneMode, CameraParameters::SCENE_MODE_AUTO) ?
1681 ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED :
1682 !strcmp(sceneMode, CameraParameters::SCENE_MODE_ACTION) ?
1683 ANDROID_CONTROL_SCENE_MODE_ACTION :
1684 !strcmp(sceneMode, CameraParameters::SCENE_MODE_PORTRAIT) ?
1685 ANDROID_CONTROL_SCENE_MODE_PORTRAIT :
1686 !strcmp(sceneMode, CameraParameters::SCENE_MODE_LANDSCAPE) ?
1687 ANDROID_CONTROL_SCENE_MODE_LANDSCAPE :
1688 !strcmp(sceneMode, CameraParameters::SCENE_MODE_NIGHT) ?
1689 ANDROID_CONTROL_SCENE_MODE_NIGHT :
1690 !strcmp(sceneMode, CameraParameters::SCENE_MODE_NIGHT_PORTRAIT) ?
1691 ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT :
1692 !strcmp(sceneMode, CameraParameters::SCENE_MODE_THEATRE) ?
1693 ANDROID_CONTROL_SCENE_MODE_THEATRE :
1694 !strcmp(sceneMode, CameraParameters::SCENE_MODE_BEACH) ?
1695 ANDROID_CONTROL_SCENE_MODE_BEACH :
1696 !strcmp(sceneMode, CameraParameters::SCENE_MODE_SNOW) ?
1697 ANDROID_CONTROL_SCENE_MODE_SNOW :
1698 !strcmp(sceneMode, CameraParameters::SCENE_MODE_SUNSET) ?
1699 ANDROID_CONTROL_SCENE_MODE_SUNSET :
1700 !strcmp(sceneMode, CameraParameters::SCENE_MODE_STEADYPHOTO) ?
1701 ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO :
1702 !strcmp(sceneMode, CameraParameters::SCENE_MODE_FIREWORKS) ?
1703 ANDROID_CONTROL_SCENE_MODE_FIREWORKS :
1704 !strcmp(sceneMode, CameraParameters::SCENE_MODE_SPORTS) ?
1705 ANDROID_CONTROL_SCENE_MODE_SPORTS :
1706 !strcmp(sceneMode, CameraParameters::SCENE_MODE_PARTY) ?
1707 ANDROID_CONTROL_SCENE_MODE_PARTY :
1708 !strcmp(sceneMode, CameraParameters::SCENE_MODE_CANDLELIGHT) ?
1709 ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT :
1710 !strcmp(sceneMode, CameraParameters::SCENE_MODE_BARCODE) ?
1711 ANDROID_CONTROL_SCENE_MODE_BARCODE:
1712 -1;
1713}
1714
1715Parameters::Parameters::flashMode_t Parameters::flashModeStringToEnum(
1716 const char *flashMode) {
1717 return
Eino-Ville Talvala4c6b0b82012-09-10 09:53:09 -0700[diff] [blame]1718 !flashMode ?
1719 Parameters::FLASH_MODE_INVALID :
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1720 !strcmp(flashMode, CameraParameters::FLASH_MODE_OFF) ?
1721 Parameters::FLASH_MODE_OFF :
1722 !strcmp(flashMode, CameraParameters::FLASH_MODE_AUTO) ?
1723 Parameters::FLASH_MODE_AUTO :
1724 !strcmp(flashMode, CameraParameters::FLASH_MODE_ON) ?
1725 Parameters::FLASH_MODE_ON :
1726 !strcmp(flashMode, CameraParameters::FLASH_MODE_RED_EYE) ?
1727 Parameters::FLASH_MODE_RED_EYE :
1728 !strcmp(flashMode, CameraParameters::FLASH_MODE_TORCH) ?
1729 Parameters::FLASH_MODE_TORCH :
1730 Parameters::FLASH_MODE_INVALID;
1731}
1732
1733Parameters::Parameters::focusMode_t Parameters::focusModeStringToEnum(
1734 const char *focusMode) {
1735 return
Eino-Ville Talvala4c6b0b82012-09-10 09:53:09 -0700[diff] [blame]1736 !focusMode ?
1737 Parameters::FOCUS_MODE_INVALID :
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1738 !strcmp(focusMode, CameraParameters::FOCUS_MODE_AUTO) ?
1739 Parameters::FOCUS_MODE_AUTO :
1740 !strcmp(focusMode, CameraParameters::FOCUS_MODE_INFINITY) ?
1741 Parameters::FOCUS_MODE_INFINITY :
1742 !strcmp(focusMode, CameraParameters::FOCUS_MODE_MACRO) ?
1743 Parameters::FOCUS_MODE_MACRO :
1744 !strcmp(focusMode, CameraParameters::FOCUS_MODE_FIXED) ?
1745 Parameters::FOCUS_MODE_FIXED :
1746 !strcmp(focusMode, CameraParameters::FOCUS_MODE_EDOF) ?
1747 Parameters::FOCUS_MODE_EDOF :
1748 !strcmp(focusMode, CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO) ?
1749 Parameters::FOCUS_MODE_CONTINUOUS_VIDEO :
1750 !strcmp(focusMode, CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE) ?
1751 Parameters::FOCUS_MODE_CONTINUOUS_PICTURE :
1752 Parameters::FOCUS_MODE_INVALID;
1753}
1754
James Painterc3dbf1a2012-09-05 18:02:32 -0700[diff] [blame]1755Parameters::Parameters::lightFxMode_t Parameters::lightFxStringToEnum(
1756 const char *lightFxMode) {
1757 return
Eino-Ville Talvala4c6b0b82012-09-10 09:53:09 -0700[diff] [blame]1758 !lightFxMode ?
1759 Parameters::LIGHTFX_NONE :
James Painterc3dbf1a2012-09-05 18:02:32 -0700[diff] [blame]1760 !strcmp(lightFxMode, CameraParameters::LIGHTFX_LOWLIGHT) ?
1761 Parameters::LIGHTFX_LOWLIGHT :
1762 !strcmp(lightFxMode, CameraParameters::LIGHTFX_HDR) ?
1763 Parameters::LIGHTFX_HDR :
1764 Parameters::LIGHTFX_NONE;
1765}
1766
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1767status_t Parameters::parseAreas(const char *areasCStr,
1768 Vector<Parameters::Area> *areas) {
1769 static const size_t NUM_FIELDS = 5;
1770 areas->clear();
1771 if (areasCStr == NULL) {
1772 // If no key exists, use default (0,0,0,0,0)
1773 areas->push();
1774 return OK;
1775 }
1776 String8 areasStr(areasCStr);
1777 ssize_t areaStart = areasStr.find("(", 0) + 1;
1778 while (areaStart != 0) {
1779 const char* area = areasStr.string() + areaStart;
1780 char *numEnd;
1781 int vals[NUM_FIELDS];
1782 for (size_t i = 0; i < NUM_FIELDS; i++) {
1783 errno = 0;
1784 vals[i] = strtol(area, &numEnd, 10);
1785 if (errno || numEnd == area) return BAD_VALUE;
1786 area = numEnd + 1;
1787 }
1788 areas->push(Parameters::Area(
1789 vals[0], vals[1], vals[2], vals[3], vals[4]) );
1790 areaStart = areasStr.find("(", areaStart) + 1;
1791 }
1792 return OK;
1793}
1794
1795status_t Parameters::validateAreas(const Vector<Parameters::Area> &areas,
1796 size_t maxRegions) {
1797 // Definition of valid area can be found in
1798 // include/camera/CameraParameters.h
1799 if (areas.size() == 0) return BAD_VALUE;
1800 if (areas.size() == 1) {
1801 if (areas[0].left == 0 &&
1802 areas[0].top == 0 &&
1803 areas[0].right == 0 &&
1804 areas[0].bottom == 0 &&
1805 areas[0].weight == 0) {
1806 // Single (0,0,0,0,0) entry is always valid (== driver decides)
1807 return OK;
1808 }
1809 }
1810 if (areas.size() > maxRegions) {
1811 ALOGE("%s: Too many areas requested: %d",
1812 __FUNCTION__, areas.size());
1813 return BAD_VALUE;
1814 }
1815
1816 for (Vector<Parameters::Area>::const_iterator a = areas.begin();
1817 a != areas.end(); a++) {
1818 if (a->weight < 1 || a->weight > 1000) return BAD_VALUE;
1819 if (a->left < -1000 || a->left > 1000) return BAD_VALUE;
1820 if (a->top < -1000 || a->top > 1000) return BAD_VALUE;
1821 if (a->right < -1000 || a->right > 1000) return BAD_VALUE;
1822 if (a->bottom < -1000 || a->bottom > 1000) return BAD_VALUE;
1823 if (a->left >= a->right) return BAD_VALUE;
1824 if (a->top >= a->bottom) return BAD_VALUE;
1825 }
1826 return OK;
1827}
1828
1829bool Parameters::boolFromString(const char *boolStr) {
1830 return !boolStr ? false :
1831 !strcmp(boolStr, CameraParameters::TRUE) ? true :
1832 false;
1833}
1834
1835int Parameters::degToTransform(int degrees, bool mirror) {
1836 if (!mirror) {
1837 if (degrees == 0) return 0;
1838 else if (degrees == 90) return HAL_TRANSFORM_ROT_90;
1839 else if (degrees == 180) return HAL_TRANSFORM_ROT_180;
1840 else if (degrees == 270) return HAL_TRANSFORM_ROT_270;
1841 } else { // Do mirror (horizontal flip)
1842 if (degrees == 0) { // FLIP_H and ROT_0
1843 return HAL_TRANSFORM_FLIP_H;
1844 } else if (degrees == 90) { // FLIP_H and ROT_90
1845 return HAL_TRANSFORM_FLIP_H | HAL_TRANSFORM_ROT_90;
1846 } else if (degrees == 180) { // FLIP_H and ROT_180
1847 return HAL_TRANSFORM_FLIP_V;
1848 } else if (degrees == 270) { // FLIP_H and ROT_270
1849 return HAL_TRANSFORM_FLIP_V | HAL_TRANSFORM_ROT_90;
1850 }
1851 }
1852 ALOGE("%s: Bad input: %d", __FUNCTION__, degrees);
1853 return -1;
1854}
1855
1856int Parameters::arrayXToNormalized(int width) const {
1857 return width * 2000 / (fastInfo.arrayWidth - 1) - 1000;
1858}
1859
1860int Parameters::arrayYToNormalized(int height) const {
1861 return height * 2000 / (fastInfo.arrayHeight - 1) - 1000;
1862}
1863
1864int Parameters::normalizedXToArray(int x) const {
1865 return (x + 1000) * (fastInfo.arrayWidth - 1) / 2000;
1866}
1867
1868int Parameters::normalizedYToArray(int y) const {
1869 return (y + 1000) * (fastInfo.arrayHeight - 1) / 2000;
1870}
1871
1872}; // namespace camera2
1873}; // namespace android