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