Gitiles
Code Review Sign In
review.evervolv.com / android_frameworks_av / e382ee28709b83264a46b09e8f766c5ef42efa35 / . / services / camera / libcameraservice / camera2 / Parameters.cpp
blob: 5248e97e1caf478ecad85e7ed1593bc1a9326cdf [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 }
610
611 camera_metadata_ro_entry_t max3aRegions =
612 staticInfo(ANDROID_CONTROL_MAX_REGIONS, 1, 1);
613 if (!max3aRegions.count) return NO_INIT;
614
615 params.set(CameraParameters::KEY_MAX_NUM_FOCUS_AREAS,
616 max3aRegions.data.i32[0]);
617 params.set(CameraParameters::KEY_FOCUS_AREAS,
618 "(0,0,0,0,0)");
619 focusingAreas.clear();
620 focusingAreas.add(Parameters::Area(0,0,0,0,0));
621
622 camera_metadata_ro_entry_t availableFocalLengths =
623 staticInfo(ANDROID_LENS_AVAILABLE_FOCAL_LENGTHS);
624 if (!availableFocalLengths.count) return NO_INIT;
625
626 float minFocalLength = availableFocalLengths.data.f[0];
627 params.setFloat(CameraParameters::KEY_FOCAL_LENGTH, minFocalLength);
628
629 camera_metadata_ro_entry_t sensorSize =
630 staticInfo(ANDROID_SENSOR_PHYSICAL_SIZE, 2, 2);
631 if (!sensorSize.count) return NO_INIT;
632
633 // The fields of view here assume infinity focus, maximum wide angle
634 float horizFov = 180 / M_PI *
635 2 * atanf(sensorSize.data.f[0] / (2 * minFocalLength));
636 float vertFov = 180 / M_PI *
637 2 * atanf(sensorSize.data.f[1] / (2 * minFocalLength));
638 params.setFloat(CameraParameters::KEY_HORIZONTAL_VIEW_ANGLE, horizFov);
639 params.setFloat(CameraParameters::KEY_VERTICAL_VIEW_ANGLE, vertFov);
640
641 exposureCompensation = 0;
642 params.set(CameraParameters::KEY_EXPOSURE_COMPENSATION,
643 exposureCompensation);
644
645 camera_metadata_ro_entry_t exposureCompensationRange =
646 staticInfo(ANDROID_CONTROL_AE_EXP_COMPENSATION_RANGE, 2, 2);
647 if (!exposureCompensationRange.count) return NO_INIT;
648
649 params.set(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION,
650 exposureCompensationRange.data.i32[1]);
651 params.set(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION,
652 exposureCompensationRange.data.i32[0]);
653
654 camera_metadata_ro_entry_t exposureCompensationStep =
655 staticInfo(ANDROID_CONTROL_AE_EXP_COMPENSATION_STEP, 1, 1);
656 if (!exposureCompensationStep.count) return NO_INIT;
657
658 params.setFloat(CameraParameters::KEY_EXPOSURE_COMPENSATION_STEP,
659 (float)exposureCompensationStep.data.r[0].numerator /
660 exposureCompensationStep.data.r[0].denominator);
661
662 autoExposureLock = false;
663 params.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK,
664 CameraParameters::FALSE);
665 params.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED,
666 CameraParameters::TRUE);
667
668 autoWhiteBalanceLock = false;
669 params.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK,
670 CameraParameters::FALSE);
671 params.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED,
672 CameraParameters::TRUE);
673
674 meteringAreas.add(Parameters::Area(0, 0, 0, 0, 0));
675 params.set(CameraParameters::KEY_MAX_NUM_METERING_AREAS,
676 max3aRegions.data.i32[0]);
677 params.set(CameraParameters::KEY_METERING_AREAS,
678 "(0,0,0,0,0)");
679
680 zoom = 0;
681 params.set(CameraParameters::KEY_ZOOM, zoom);
682 params.set(CameraParameters::KEY_MAX_ZOOM, NUM_ZOOM_STEPS - 1);
683
684 camera_metadata_ro_entry_t maxDigitalZoom =
Igor Murashkin018d2282012-09-18 18:23:49 -0700[diff] [blame]685 staticInfo(ANDROID_SCALER_AVAILABLE_MAX_ZOOM, /*minCount*/1, /*maxCount*/1);
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]686 if (!maxDigitalZoom.count) return NO_INIT;
687
688 {
689 String8 zoomRatios;
690 float zoom = 1.f;
691 float zoomIncrement = (maxDigitalZoom.data.f[0] - zoom) /
692 (NUM_ZOOM_STEPS-1);
693 bool addComma = false;
694 for (size_t i=0; i < NUM_ZOOM_STEPS; i++) {
695 if (addComma) zoomRatios += ",";
696 addComma = true;
697 zoomRatios += String8::format("%d", static_cast<int>(zoom * 100));
698 zoom += zoomIncrement;
699 }
700 params.set(CameraParameters::KEY_ZOOM_RATIOS, zoomRatios);
701 }
702
703 params.set(CameraParameters::KEY_ZOOM_SUPPORTED,
704 CameraParameters::TRUE);
705 params.set(CameraParameters::KEY_SMOOTH_ZOOM_SUPPORTED,
706 CameraParameters::TRUE);
707
708 params.set(CameraParameters::KEY_FOCUS_DISTANCES,
709 "Infinity,Infinity,Infinity");
710
711 params.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_HW,
712 fastInfo.maxFaces);
713 params.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_SW,
714 0);
715
716 params.set(CameraParameters::KEY_VIDEO_FRAME_FORMAT,
717 CameraParameters::PIXEL_FORMAT_ANDROID_OPAQUE);
718
719 params.set(CameraParameters::KEY_RECORDING_HINT,
720 CameraParameters::FALSE);
721
722 params.set(CameraParameters::KEY_VIDEO_SNAPSHOT_SUPPORTED,
723 CameraParameters::TRUE);
724
725 params.set(CameraParameters::KEY_VIDEO_STABILIZATION,
726 CameraParameters::FALSE);
727
728 camera_metadata_ro_entry_t availableVideoStabilizationModes =
729 staticInfo(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES);
730 if (!availableVideoStabilizationModes.count) return NO_INIT;
731
732 if (availableVideoStabilizationModes.count > 1) {
733 params.set(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED,
734 CameraParameters::TRUE);
735 } else {
736 params.set(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED,
737 CameraParameters::FALSE);
738 }
739
740 // Set up initial state for non-Camera.Parameters state variables
741
742 storeMetadataInBuffers = true;
743 playShutterSound = true;
744 enableFaceDetect = false;
745
746 enableFocusMoveMessages = false;
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700[diff] [blame]747 afTriggerCounter = 1;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]748 currentAfTriggerId = -1;
749
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700[diff] [blame]750 precaptureTriggerCounter = 1;
751
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]752 previewCallbackFlags = 0;
753
Eino-Ville Talvalab0752522012-09-11 16:51:32 -0700[diff] [blame]754 char value[PROPERTY_VALUE_MAX];
Eino-Ville Talvala2f931272012-09-17 16:57:27 -0700[diff] [blame]755 property_get("camera.disable_zsl_mode", value, "0");
Eino-Ville Talvalab0752522012-09-11 16:51:32 -0700[diff] [blame]756 if (!strcmp(value,"1")) {
Eino-Ville Talvala2f931272012-09-17 16:57:27 -0700[diff] [blame]757 ALOGI("Camera %d: Disabling ZSL mode", cameraId);
Eino-Ville Talvalab0752522012-09-11 16:51:32 -0700[diff] [blame]758 zslMode = false;
Eino-Ville Talvala2f931272012-09-17 16:57:27 -0700[diff] [blame]759 } else {
760 zslMode = true;
Eino-Ville Talvalab0752522012-09-11 16:51:32 -0700[diff] [blame]761 }
James Paintere5382062012-09-05 18:02:32 -0700[diff] [blame]762
763 lightFx = LIGHTFX_NONE;
764
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]765 state = STOPPED;
766
767 paramsFlattened = params.flatten();
768
769 return OK;
770}
771
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -0700[diff] [blame]772String8 Parameters::get() const {
773 return paramsFlattened;
774}
775
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]776status_t Parameters::buildFastInfo() {
777
778 camera_metadata_ro_entry_t activeArraySize =
779 staticInfo(ANDROID_SENSOR_ACTIVE_ARRAY_SIZE, 2, 2);
780 if (!activeArraySize.count) return NO_INIT;
781 int32_t arrayWidth = activeArraySize.data.i32[0];
782 int32_t arrayHeight = activeArraySize.data.i32[1];
783
784 camera_metadata_ro_entry_t availableFaceDetectModes =
785 staticInfo(ANDROID_STATS_AVAILABLE_FACE_DETECT_MODES);
786 if (!availableFaceDetectModes.count) return NO_INIT;
787
788 uint8_t bestFaceDetectMode =
789 ANDROID_STATS_FACE_DETECTION_OFF;
790 for (size_t i = 0 ; i < availableFaceDetectModes.count; i++) {
791 switch (availableFaceDetectModes.data.u8[i]) {
792 case ANDROID_STATS_FACE_DETECTION_OFF:
793 break;
794 case ANDROID_STATS_FACE_DETECTION_SIMPLE:
795 if (bestFaceDetectMode !=
796 ANDROID_STATS_FACE_DETECTION_FULL) {
797 bestFaceDetectMode =
798 ANDROID_STATS_FACE_DETECTION_SIMPLE;
799 }
800 break;
801 case ANDROID_STATS_FACE_DETECTION_FULL:
802 bestFaceDetectMode =
803 ANDROID_STATS_FACE_DETECTION_FULL;
804 break;
805 default:
806 ALOGE("%s: Camera %d: Unknown face detect mode %d:",
807 __FUNCTION__, cameraId,
808 availableFaceDetectModes.data.u8[i]);
809 return NO_INIT;
810 }
811 }
812
813 camera_metadata_ro_entry_t maxFacesDetected =
814 staticInfo(ANDROID_STATS_MAX_FACE_COUNT, 1, 1);
815 if (!maxFacesDetected.count) return NO_INIT;
816
817 int32_t maxFaces = maxFacesDetected.data.i32[0];
818
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -0700[diff] [blame]819 camera_metadata_ro_entry_t availableSceneModes =
820 staticInfo(ANDROID_CONTROL_AVAILABLE_SCENE_MODES);
821 camera_metadata_ro_entry_t sceneModeOverrides =
822 staticInfo(ANDROID_CONTROL_SCENE_MODE_OVERRIDES);
823 camera_metadata_ro_entry_t minFocusDistance =
824 staticInfo(ANDROID_LENS_MINIMUM_FOCUS_DISTANCE);
825 bool fixedLens = (minFocusDistance.data.f[0] == 0);
826
827 if (sceneModeOverrides.count > 0) {
828 // sceneModeOverrides is defined to have 3 entries for each scene mode,
829 // which are AE, AWB, and AF override modes the HAL wants for that scene
830 // mode.
831 const size_t kModesPerSceneMode = 3;
832 if (sceneModeOverrides.count !=
833 availableSceneModes.count * kModesPerSceneMode) {
834 ALOGE("%s: Camera %d: Scene mode override list is an "
835 "unexpected size: %d (expected %d)", __FUNCTION__,
836 cameraId, sceneModeOverrides.count,
837 availableSceneModes.count);
838 return NO_INIT;
839 }
840 for (size_t i = 0; i < availableSceneModes.count; i++) {
841 DeviceInfo::OverrideModes modes;
842 uint8_t aeMode =
843 sceneModeOverrides.data.u8[i * kModesPerSceneMode + 0];
844 switch(aeMode) {
845 case ANDROID_CONTROL_AE_ON:
846 modes.flashMode = FLASH_MODE_OFF;
847 break;
848 case ANDROID_CONTROL_AE_ON_AUTO_FLASH:
849 modes.flashMode = FLASH_MODE_AUTO;
850 break;
851 case ANDROID_CONTROL_AE_ON_ALWAYS_FLASH:
852 modes.flashMode = FLASH_MODE_ON;
853 break;
854 case ANDROID_CONTROL_AE_ON_AUTO_FLASH_REDEYE:
855 modes.flashMode = FLASH_MODE_RED_EYE;
856 break;
857 default:
858 ALOGE("%s: Unknown override AE mode: %d", __FUNCTION__,
859 aeMode);
860 modes.flashMode = FLASH_MODE_INVALID;
861 break;
862 }
863 modes.wbMode =
864 sceneModeOverrides.data.u8[i * kModesPerSceneMode + 1];
865 uint8_t afMode =
866 sceneModeOverrides.data.u8[i * kModesPerSceneMode + 2];
867 switch(afMode) {
868 case ANDROID_CONTROL_AF_OFF:
869 modes.focusMode = fixedLens ?
870 FOCUS_MODE_FIXED : FOCUS_MODE_INFINITY;
871 break;
872 case ANDROID_CONTROL_AF_AUTO:
873 case ANDROID_CONTROL_AF_MACRO:
874 case ANDROID_CONTROL_AF_CONTINUOUS_VIDEO:
875 case ANDROID_CONTROL_AF_CONTINUOUS_PICTURE:
876 case ANDROID_CONTROL_AF_EDOF:
877 modes.focusMode = static_cast<focusMode_t>(afMode);
878 break;
879 default:
880 ALOGE("%s: Unknown override AF mode: %d", __FUNCTION__,
881 afMode);
882 modes.focusMode = FOCUS_MODE_INVALID;
883 break;
884 }
885 fastInfo.sceneModeOverrides.add(availableSceneModes.data.u8[i],
886 modes);
887 }
888 }
889
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]890 fastInfo.arrayWidth = arrayWidth;
891 fastInfo.arrayHeight = arrayHeight;
892 fastInfo.bestFaceDetectMode = bestFaceDetectMode;
893 fastInfo.maxFaces = maxFaces;
894 return OK;
895}
896
Eino-Ville Talvalae382ee22012-10-02 18:14:49 -0700[diff] [blame^]897status_t Parameters::buildQuirks() {
898 camera_metadata_ro_entry_t entry;
899 entry = info->find(ANDROID_QUIRKS_TRIGGER_AF_WITH_AUTO);
900 quirks.triggerAfWithAuto = (entry.count != 0 && entry.data.u8[0] == 1);
901 ALOGV_IF(quirks.triggerAfWithAuto, "Camera %d: Quirk triggerAfWithAuto enabled",
902 cameraId);
903
904 entry = info->find(ANDROID_QUIRKS_USE_ZSL_FORMAT);
905 quirks.useZslFormat = (entry.count != 0 && entry.data.u8[0] == 1);
906 ALOGV_IF(quirks.useZslFormat, "Camera %d: Quirk useZslFormat enabled",
907 cameraId);
908
909 return OK;
910}
911
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]912camera_metadata_ro_entry_t Parameters::staticInfo(uint32_t tag,
913 size_t minCount, size_t maxCount) const {
914 status_t res;
915 camera_metadata_ro_entry_t entry = info->find(tag);
916
917 if (CC_UNLIKELY( entry.count == 0 )) {
918 const char* tagSection = get_camera_metadata_section_name(tag);
919 if (tagSection == NULL) tagSection = "<unknown>";
920 const char* tagName = get_camera_metadata_tag_name(tag);
921 if (tagName == NULL) tagName = "<unknown>";
922
923 ALOGE("Error finding static metadata entry '%s.%s' (%x)",
924 tagSection, tagName, tag);
925 } else if (CC_UNLIKELY(
926 (minCount != 0 && entry.count < minCount) ||
927 (maxCount != 0 && entry.count > maxCount) ) ) {
928 const char* tagSection = get_camera_metadata_section_name(tag);
929 if (tagSection == NULL) tagSection = "<unknown>";
930 const char* tagName = get_camera_metadata_tag_name(tag);
931 if (tagName == NULL) tagName = "<unknown>";
932 ALOGE("Malformed static metadata entry '%s.%s' (%x):"
933 "Expected between %d and %d values, but got %d values",
934 tagSection, tagName, tag, minCount, maxCount, entry.count);
935 }
936
937 return entry;
938}
939
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -0700[diff] [blame]940status_t Parameters::set(const String8& paramString) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]941 status_t res;
942
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -0700[diff] [blame]943 CameraParameters newParams(paramString);
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]944
945 // TODO: Currently ignoring any changes to supposedly read-only parameters
946 // such as supported preview sizes, etc. Should probably produce an error if
947 // they're changed.
948
949 /** Extract and verify new parameters */
950
951 size_t i;
952
953 Parameters validatedParams(*this);
954
955 // PREVIEW_SIZE
956 newParams.getPreviewSize(&validatedParams.previewWidth,
957 &validatedParams.previewHeight);
958
959 if (validatedParams.previewWidth != previewWidth ||
960 validatedParams.previewHeight != previewHeight) {
961 if (state >= PREVIEW) {
962 ALOGE("%s: Preview size cannot be updated when preview "
963 "is active! (Currently %d x %d, requested %d x %d",
964 __FUNCTION__,
965 previewWidth, previewHeight,
966 validatedParams.previewWidth, validatedParams.previewHeight);
967 return BAD_VALUE;
968 }
969 camera_metadata_ro_entry_t availablePreviewSizes =
970 staticInfo(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES);
971 for (i = 0; i < availablePreviewSizes.count; i += 2 ) {
972 if ((availablePreviewSizes.data.i32[i] ==
973 validatedParams.previewWidth) &&
974 (availablePreviewSizes.data.i32[i+1] ==
975 validatedParams.previewHeight)) break;
976 }
977 if (i == availablePreviewSizes.count) {
978 ALOGE("%s: Requested preview size %d x %d is not supported",
979 __FUNCTION__, validatedParams.previewWidth,
980 validatedParams.previewHeight);
981 return BAD_VALUE;
982 }
983 }
984
985 // PREVIEW_FPS_RANGE
986 bool fpsRangeChanged = false;
987 newParams.getPreviewFpsRange(&validatedParams.previewFpsRange[0],
988 &validatedParams.previewFpsRange[1]);
Eino-Ville Talvalac9d7e4d2012-09-27 14:18:13 -0700[diff] [blame]989 validatedParams.previewFpsRange[0] /= kFpsToApiScale;
990 validatedParams.previewFpsRange[1] /= kFpsToApiScale;
991
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]992 if (validatedParams.previewFpsRange[0] != previewFpsRange[0] ||
993 validatedParams.previewFpsRange[1] != previewFpsRange[1]) {
994 fpsRangeChanged = true;
995 camera_metadata_ro_entry_t availablePreviewFpsRanges =
996 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES, 2);
997 for (i = 0; i < availablePreviewFpsRanges.count; i += 2) {
998 if ((availablePreviewFpsRanges.data.i32[i] ==
999 validatedParams.previewFpsRange[0]) &&
1000 (availablePreviewFpsRanges.data.i32[i+1] ==
1001 validatedParams.previewFpsRange[1]) ) {
1002 break;
1003 }
1004 }
1005 if (i == availablePreviewFpsRanges.count) {
1006 ALOGE("%s: Requested preview FPS range %d - %d is not supported",
1007 __FUNCTION__, validatedParams.previewFpsRange[0],
1008 validatedParams.previewFpsRange[1]);
1009 return BAD_VALUE;
1010 }
1011 validatedParams.previewFps = validatedParams.previewFpsRange[0];
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -0700[diff] [blame]1012 newParams.setPreviewFrameRate(validatedParams.previewFps);
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1013 }
1014
1015 // PREVIEW_FORMAT
1016 validatedParams.previewFormat =
1017 formatStringToEnum(newParams.getPreviewFormat());
1018 if (validatedParams.previewFormat != previewFormat) {
1019 if (state >= PREVIEW) {
1020 ALOGE("%s: Preview format cannot be updated when preview "
1021 "is active!", __FUNCTION__);
1022 return BAD_VALUE;
1023 }
1024 camera_metadata_ro_entry_t availableFormats =
1025 staticInfo(ANDROID_SCALER_AVAILABLE_FORMATS);
1026 for (i = 0; i < availableFormats.count; i++) {
1027 if (availableFormats.data.i32[i] == validatedParams.previewFormat)
1028 break;
1029 }
1030 if (i == availableFormats.count) {
1031 ALOGE("%s: Requested preview format %s (0x%x) is not supported",
1032 __FUNCTION__, newParams.getPreviewFormat(),
1033 validatedParams.previewFormat);
1034 return BAD_VALUE;
1035 }
1036 }
1037
1038 // PREVIEW_FRAME_RATE
1039 // Deprecated, only use if the preview fps range is unchanged this time.
1040 // The single-value FPS is the same as the minimum of the range.
1041 if (!fpsRangeChanged) {
Eino-Ville Talvalad0cec0c2012-09-27 18:08:20 -0700[diff] [blame]1042 validatedParams.previewFps = newParams.getPreviewFrameRate();
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1043 if (validatedParams.previewFps != previewFps) {
1044 camera_metadata_ro_entry_t availableFrameRates =
1045 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES);
1046 for (i = 0; i < availableFrameRates.count; i+=2) {
1047 if (availableFrameRates.data.i32[i] ==
1048 validatedParams.previewFps) break;
1049 }
1050 if (i == availableFrameRates.count) {
1051 ALOGE("%s: Requested preview frame rate %d is not supported",
1052 __FUNCTION__, validatedParams.previewFps);
1053 return BAD_VALUE;
1054 }
1055 validatedParams.previewFpsRange[0] =
1056 availableFrameRates.data.i32[i];
1057 validatedParams.previewFpsRange[1] =
1058 availableFrameRates.data.i32[i+1];
1059 }
1060 }
1061
1062 // PICTURE_SIZE
1063 newParams.getPictureSize(&validatedParams.pictureWidth,
1064 &validatedParams.pictureHeight);
1065 if (validatedParams.pictureWidth == pictureWidth ||
1066 validatedParams.pictureHeight == pictureHeight) {
1067 camera_metadata_ro_entry_t availablePictureSizes =
1068 staticInfo(ANDROID_SCALER_AVAILABLE_JPEG_SIZES);
1069 for (i = 0; i < availablePictureSizes.count; i+=2) {
1070 if ((availablePictureSizes.data.i32[i] ==
1071 validatedParams.pictureWidth) &&
1072 (availablePictureSizes.data.i32[i+1] ==
1073 validatedParams.pictureHeight)) break;
1074 }
1075 if (i == availablePictureSizes.count) {
1076 ALOGE("%s: Requested picture size %d x %d is not supported",
1077 __FUNCTION__, validatedParams.pictureWidth,
1078 validatedParams.pictureHeight);
1079 return BAD_VALUE;
1080 }
1081 }
1082
1083 // JPEG_THUMBNAIL_WIDTH/HEIGHT
1084 validatedParams.jpegThumbSize[0] =
1085 newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH);
1086 validatedParams.jpegThumbSize[1] =
1087 newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT);
1088 if (validatedParams.jpegThumbSize[0] != jpegThumbSize[0] ||
1089 validatedParams.jpegThumbSize[1] != jpegThumbSize[1]) {
1090 camera_metadata_ro_entry_t availableJpegThumbSizes =
1091 staticInfo(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES);
1092 for (i = 0; i < availableJpegThumbSizes.count; i+=2) {
1093 if ((availableJpegThumbSizes.data.i32[i] ==
1094 validatedParams.jpegThumbSize[0]) &&
1095 (availableJpegThumbSizes.data.i32[i+1] ==
1096 validatedParams.jpegThumbSize[1])) break;
1097 }
1098 if (i == availableJpegThumbSizes.count) {
1099 ALOGE("%s: Requested JPEG thumbnail size %d x %d is not supported",
1100 __FUNCTION__, validatedParams.jpegThumbSize[0],
1101 validatedParams.jpegThumbSize[1]);
1102 return BAD_VALUE;
1103 }
1104 }
1105
1106 // JPEG_THUMBNAIL_QUALITY
1107 validatedParams.jpegThumbQuality =
1108 newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY);
1109 if (validatedParams.jpegThumbQuality < 0 ||
1110 validatedParams.jpegThumbQuality > 100) {
1111 ALOGE("%s: Requested JPEG thumbnail quality %d is not supported",
1112 __FUNCTION__, validatedParams.jpegThumbQuality);
1113 return BAD_VALUE;
1114 }
1115
1116 // JPEG_QUALITY
1117 validatedParams.jpegQuality =
1118 newParams.getInt(CameraParameters::KEY_JPEG_QUALITY);
1119 if (validatedParams.jpegQuality < 0 || validatedParams.jpegQuality > 100) {
1120 ALOGE("%s: Requested JPEG quality %d is not supported",
1121 __FUNCTION__, validatedParams.jpegQuality);
1122 return BAD_VALUE;
1123 }
1124
1125 // ROTATION
1126 validatedParams.jpegRotation =
1127 newParams.getInt(CameraParameters::KEY_ROTATION);
1128 if (validatedParams.jpegRotation != 0 &&
1129 validatedParams.jpegRotation != 90 &&
1130 validatedParams.jpegRotation != 180 &&
1131 validatedParams.jpegRotation != 270) {
1132 ALOGE("%s: Requested picture rotation angle %d is not supported",
1133 __FUNCTION__, validatedParams.jpegRotation);
1134 return BAD_VALUE;
1135 }
1136
1137 // GPS
1138
1139 const char *gpsLatStr =
1140 newParams.get(CameraParameters::KEY_GPS_LATITUDE);
1141 if (gpsLatStr != NULL) {
1142 const char *gpsLongStr =
1143 newParams.get(CameraParameters::KEY_GPS_LONGITUDE);
1144 const char *gpsAltitudeStr =
1145 newParams.get(CameraParameters::KEY_GPS_ALTITUDE);
1146 const char *gpsTimeStr =
1147 newParams.get(CameraParameters::KEY_GPS_TIMESTAMP);
1148 const char *gpsProcMethodStr =
1149 newParams.get(CameraParameters::KEY_GPS_PROCESSING_METHOD);
1150 if (gpsLongStr == NULL ||
1151 gpsAltitudeStr == NULL ||
1152 gpsTimeStr == NULL ||
1153 gpsProcMethodStr == NULL) {
1154 ALOGE("%s: Incomplete set of GPS parameters provided",
1155 __FUNCTION__);
1156 return BAD_VALUE;
1157 }
1158 char *endPtr;
1159 errno = 0;
1160 validatedParams.gpsCoordinates[0] = strtod(gpsLatStr, &endPtr);
1161 if (errno || endPtr == gpsLatStr) {
1162 ALOGE("%s: Malformed GPS latitude: %s", __FUNCTION__, gpsLatStr);
1163 return BAD_VALUE;
1164 }
1165 errno = 0;
1166 validatedParams.gpsCoordinates[1] = strtod(gpsLongStr, &endPtr);
1167 if (errno || endPtr == gpsLongStr) {
1168 ALOGE("%s: Malformed GPS longitude: %s", __FUNCTION__, gpsLongStr);
1169 return BAD_VALUE;
1170 }
1171 errno = 0;
1172 validatedParams.gpsCoordinates[2] = strtod(gpsAltitudeStr, &endPtr);
1173 if (errno || endPtr == gpsAltitudeStr) {
1174 ALOGE("%s: Malformed GPS altitude: %s", __FUNCTION__,
1175 gpsAltitudeStr);
1176 return BAD_VALUE;
1177 }
1178 errno = 0;
1179 validatedParams.gpsTimestamp = strtoll(gpsTimeStr, &endPtr, 10);
1180 if (errno || endPtr == gpsTimeStr) {
1181 ALOGE("%s: Malformed GPS timestamp: %s", __FUNCTION__, gpsTimeStr);
1182 return BAD_VALUE;
1183 }
1184 validatedParams.gpsProcessingMethod = gpsProcMethodStr;
1185
1186 validatedParams.gpsEnabled = true;
1187 } else {
1188 validatedParams.gpsEnabled = false;
1189 }
1190
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1191 // EFFECT
1192 validatedParams.effectMode = effectModeStringToEnum(
1193 newParams.get(CameraParameters::KEY_EFFECT) );
1194 if (validatedParams.effectMode != effectMode) {
1195 camera_metadata_ro_entry_t availableEffectModes =
1196 staticInfo(ANDROID_CONTROL_AVAILABLE_EFFECTS);
1197 for (i = 0; i < availableEffectModes.count; i++) {
1198 if (validatedParams.effectMode == availableEffectModes.data.u8[i]) break;
1199 }
1200 if (i == availableEffectModes.count) {
1201 ALOGE("%s: Requested effect mode \"%s\" is not supported",
1202 __FUNCTION__,
1203 newParams.get(CameraParameters::KEY_EFFECT) );
1204 return BAD_VALUE;
1205 }
1206 }
1207
1208 // ANTIBANDING
1209 validatedParams.antibandingMode = abModeStringToEnum(
1210 newParams.get(CameraParameters::KEY_ANTIBANDING) );
1211 if (validatedParams.antibandingMode != antibandingMode) {
1212 camera_metadata_ro_entry_t availableAbModes =
1213 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES);
1214 for (i = 0; i < availableAbModes.count; i++) {
1215 if (validatedParams.antibandingMode == availableAbModes.data.u8[i])
1216 break;
1217 }
1218 if (i == availableAbModes.count) {
1219 ALOGE("%s: Requested antibanding mode \"%s\" is not supported",
1220 __FUNCTION__,
1221 newParams.get(CameraParameters::KEY_ANTIBANDING));
1222 return BAD_VALUE;
1223 }
1224 }
1225
1226 // SCENE_MODE
1227 validatedParams.sceneMode = sceneModeStringToEnum(
1228 newParams.get(CameraParameters::KEY_SCENE_MODE) );
1229 if (validatedParams.sceneMode != sceneMode &&
1230 validatedParams.sceneMode !=
1231 ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED) {
1232 camera_metadata_ro_entry_t availableSceneModes =
1233 staticInfo(ANDROID_CONTROL_AVAILABLE_SCENE_MODES);
1234 for (i = 0; i < availableSceneModes.count; i++) {
1235 if (validatedParams.sceneMode == availableSceneModes.data.u8[i])
1236 break;
1237 }
1238 if (i == availableSceneModes.count) {
1239 ALOGE("%s: Requested scene mode \"%s\" is not supported",
1240 __FUNCTION__,
1241 newParams.get(CameraParameters::KEY_SCENE_MODE));
1242 return BAD_VALUE;
1243 }
1244 }
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -0700[diff] [blame]1245 bool sceneModeSet =
1246 validatedParams.sceneMode != ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1247
1248 // FLASH_MODE
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -0700[diff] [blame]1249 if (sceneModeSet) {
1250 validatedParams.flashMode =
1251 fastInfo.sceneModeOverrides.
1252 valueFor(validatedParams.sceneMode).flashMode;
1253 } else {
1254 validatedParams.flashMode = FLASH_MODE_INVALID;
1255 }
1256 if (validatedParams.flashMode == FLASH_MODE_INVALID) {
1257 validatedParams.flashMode = flashModeStringToEnum(
1258 newParams.get(CameraParameters::KEY_FLASH_MODE) );
1259 }
1260
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1261 if (validatedParams.flashMode != flashMode) {
1262 camera_metadata_ro_entry_t flashAvailable =
1263 staticInfo(ANDROID_FLASH_AVAILABLE, 1, 1);
1264 if (!flashAvailable.data.u8[0] &&
1265 validatedParams.flashMode != Parameters::FLASH_MODE_OFF) {
1266 ALOGE("%s: Requested flash mode \"%s\" is not supported: "
1267 "No flash on device", __FUNCTION__,
1268 newParams.get(CameraParameters::KEY_FLASH_MODE));
1269 return BAD_VALUE;
1270 } else if (validatedParams.flashMode == Parameters::FLASH_MODE_RED_EYE) {
1271 camera_metadata_ro_entry_t availableAeModes =
1272 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_MODES);
1273 for (i = 0; i < availableAeModes.count; i++) {
1274 if (validatedParams.flashMode == availableAeModes.data.u8[i])
1275 break;
1276 }
1277 if (i == availableAeModes.count) {
1278 ALOGE("%s: Requested flash mode \"%s\" is not supported",
1279 __FUNCTION__,
1280 newParams.get(CameraParameters::KEY_FLASH_MODE));
1281 return BAD_VALUE;
1282 }
1283 } else if (validatedParams.flashMode == -1) {
1284 ALOGE("%s: Requested flash mode \"%s\" is unknown",
1285 __FUNCTION__,
1286 newParams.get(CameraParameters::KEY_FLASH_MODE));
1287 return BAD_VALUE;
1288 }
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -0700[diff] [blame]1289 // Update in case of override
1290 newParams.set(CameraParameters::KEY_FLASH_MODE,
1291 flashModeEnumToString(validatedParams.flashMode));
1292 }
1293
1294 // WHITE_BALANCE
1295 if (sceneModeSet) {
1296 validatedParams.wbMode =
1297 fastInfo.sceneModeOverrides.
1298 valueFor(validatedParams.sceneMode).wbMode;
1299 } else {
1300 validatedParams.wbMode = ANDROID_CONTROL_AWB_OFF;
1301 }
1302 if (validatedParams.wbMode == ANDROID_CONTROL_AWB_OFF) {
1303 validatedParams.wbMode = wbModeStringToEnum(
1304 newParams.get(CameraParameters::KEY_WHITE_BALANCE) );
1305 }
1306 if (validatedParams.wbMode != wbMode) {
1307 camera_metadata_ro_entry_t availableWbModes =
1308 staticInfo(ANDROID_CONTROL_AWB_AVAILABLE_MODES);
1309 for (i = 0; i < availableWbModes.count; i++) {
1310 if (validatedParams.wbMode == availableWbModes.data.u8[i]) break;
1311 }
1312 if (i == availableWbModes.count) {
1313 ALOGE("%s: Requested white balance mode %s is not supported",
1314 __FUNCTION__,
1315 newParams.get(CameraParameters::KEY_WHITE_BALANCE));
1316 return BAD_VALUE;
1317 }
1318 // Update in case of override
1319 newParams.set(CameraParameters::KEY_WHITE_BALANCE,
1320 wbModeEnumToString(validatedParams.wbMode));
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1321 }
1322
1323 // FOCUS_MODE
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -0700[diff] [blame]1324 if (sceneModeSet) {
1325 validatedParams.focusMode =
1326 fastInfo.sceneModeOverrides.
1327 valueFor(validatedParams.sceneMode).focusMode;
1328 } else {
1329 validatedParams.focusMode = FOCUS_MODE_INVALID;
1330 }
1331 if (validatedParams.focusMode == FOCUS_MODE_INVALID) {
1332 validatedParams.focusMode = focusModeStringToEnum(
1333 newParams.get(CameraParameters::KEY_FOCUS_MODE) );
1334 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1335 if (validatedParams.focusMode != focusMode) {
1336 validatedParams.currentAfTriggerId = -1;
1337 if (validatedParams.focusMode != Parameters::FOCUS_MODE_FIXED) {
1338 camera_metadata_ro_entry_t minFocusDistance =
1339 staticInfo(ANDROID_LENS_MINIMUM_FOCUS_DISTANCE);
1340 if (minFocusDistance.data.f[0] == 0) {
1341 ALOGE("%s: Requested focus mode \"%s\" is not available: "
1342 "fixed focus lens",
1343 __FUNCTION__,
1344 newParams.get(CameraParameters::KEY_FOCUS_MODE));
1345 return BAD_VALUE;
1346 } else if (validatedParams.focusMode !=
1347 Parameters::FOCUS_MODE_INFINITY) {
1348 camera_metadata_ro_entry_t availableFocusModes =
1349 staticInfo(ANDROID_CONTROL_AF_AVAILABLE_MODES);
1350 for (i = 0; i < availableFocusModes.count; i++) {
1351 if (validatedParams.focusMode ==
1352 availableFocusModes.data.u8[i]) break;
1353 }
1354 if (i == availableFocusModes.count) {
1355 ALOGE("%s: Requested focus mode \"%s\" is not supported",
1356 __FUNCTION__,
1357 newParams.get(CameraParameters::KEY_FOCUS_MODE));
1358 return BAD_VALUE;
1359 }
1360 }
1361 }
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -0700[diff] [blame]1362 // Update in case of override
1363 newParams.set(CameraParameters::KEY_FOCUS_MODE,
1364 focusModeEnumToString(validatedParams.focusMode));
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1365 } else {
1366 validatedParams.currentAfTriggerId = currentAfTriggerId;
1367 }
1368
1369 // FOCUS_AREAS
1370 res = parseAreas(newParams.get(CameraParameters::KEY_FOCUS_AREAS),
1371 &validatedParams.focusingAreas);
1372 size_t max3aRegions =
1373 (size_t)staticInfo(ANDROID_CONTROL_MAX_REGIONS, 1, 1).data.i32[0];
1374 if (res == OK) res = validateAreas(validatedParams.focusingAreas,
1375 max3aRegions);
1376 if (res != OK) {
1377 ALOGE("%s: Requested focus areas are malformed: %s",
1378 __FUNCTION__, newParams.get(CameraParameters::KEY_FOCUS_AREAS));
1379 return BAD_VALUE;
1380 }
1381
1382 // EXPOSURE_COMPENSATION
1383 validatedParams.exposureCompensation =
1384 newParams.getInt(CameraParameters::KEY_EXPOSURE_COMPENSATION);
1385 camera_metadata_ro_entry_t exposureCompensationRange =
1386 staticInfo(ANDROID_CONTROL_AE_EXP_COMPENSATION_RANGE);
1387 if ((validatedParams.exposureCompensation <
1388 exposureCompensationRange.data.i32[0]) ||
1389 (validatedParams.exposureCompensation >
1390 exposureCompensationRange.data.i32[1])) {
1391 ALOGE("%s: Requested exposure compensation index is out of bounds: %d",
1392 __FUNCTION__, validatedParams.exposureCompensation);
1393 return BAD_VALUE;
1394 }
1395
1396 // AUTO_EXPOSURE_LOCK (always supported)
1397 validatedParams.autoExposureLock = boolFromString(
1398 newParams.get(CameraParameters::KEY_AUTO_EXPOSURE_LOCK));
1399
1400 // AUTO_WHITEBALANCE_LOCK (always supported)
1401 validatedParams.autoWhiteBalanceLock = boolFromString(
1402 newParams.get(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK));
1403
1404 // METERING_AREAS
1405 res = parseAreas(newParams.get(CameraParameters::KEY_METERING_AREAS),
1406 &validatedParams.meteringAreas);
1407 if (res == OK) {
1408 res = validateAreas(validatedParams.meteringAreas, max3aRegions);
1409 }
1410 if (res != OK) {
1411 ALOGE("%s: Requested metering areas are malformed: %s",
1412 __FUNCTION__,
1413 newParams.get(CameraParameters::KEY_METERING_AREAS));
1414 return BAD_VALUE;
1415 }
1416
1417 // ZOOM
1418 validatedParams.zoom = newParams.getInt(CameraParameters::KEY_ZOOM);
1419 if (validatedParams.zoom < 0 || validatedParams.zoom > (int)NUM_ZOOM_STEPS) {
1420 ALOGE("%s: Requested zoom level %d is not supported",
1421 __FUNCTION__, validatedParams.zoom);
1422 return BAD_VALUE;
1423 }
1424
1425 // VIDEO_SIZE
1426 newParams.getVideoSize(&validatedParams.videoWidth,
1427 &validatedParams.videoHeight);
1428 if (validatedParams.videoWidth != videoWidth ||
1429 validatedParams.videoHeight != videoHeight) {
1430 if (state == RECORD) {
1431 ALOGE("%s: Video size cannot be updated when recording is active!",
1432 __FUNCTION__);
1433 return BAD_VALUE;
1434 }
1435 camera_metadata_ro_entry_t availableVideoSizes =
1436 staticInfo(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES);
1437 for (i = 0; i < availableVideoSizes.count; i += 2 ) {
1438 if ((availableVideoSizes.data.i32[i] ==
1439 validatedParams.videoWidth) &&
1440 (availableVideoSizes.data.i32[i+1] ==
1441 validatedParams.videoHeight)) break;
1442 }
1443 if (i == availableVideoSizes.count) {
1444 ALOGE("%s: Requested video size %d x %d is not supported",
1445 __FUNCTION__, validatedParams.videoWidth,
1446 validatedParams.videoHeight);
1447 return BAD_VALUE;
1448 }
1449 }
1450
1451 // RECORDING_HINT (always supported)
1452 validatedParams.recordingHint = boolFromString(
1453 newParams.get(CameraParameters::KEY_RECORDING_HINT) );
1454
1455 // VIDEO_STABILIZATION
1456 validatedParams.videoStabilization = boolFromString(
1457 newParams.get(CameraParameters::KEY_VIDEO_STABILIZATION) );
1458 camera_metadata_ro_entry_t availableVideoStabilizationModes =
1459 staticInfo(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES);
1460 if (validatedParams.videoStabilization &&
1461 availableVideoStabilizationModes.count == 1) {
1462 ALOGE("%s: Video stabilization not supported", __FUNCTION__);
1463 }
1464
1465 /** Update internal parameters */
1466
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1467 *this = validatedParams;
1468
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -0700[diff] [blame]1469 // Need to flatten again in case of overrides
1470 paramsFlattened = newParams.flatten();
1471 params = newParams;
1472
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1473 return OK;
1474}
1475
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700[diff] [blame]1476status_t Parameters::updateRequest(CameraMetadata *request) const {
1477 ATRACE_CALL();
1478 status_t res;
1479
1480 uint8_t metadataMode = ANDROID_REQUEST_METADATA_FULL;
1481 res = request->update(ANDROID_REQUEST_METADATA_MODE,
1482 &metadataMode, 1);
1483 if (res != OK) return res;
1484
1485 res = request->update(ANDROID_CONTROL_AE_TARGET_FPS_RANGE,
1486 previewFpsRange, 2);
1487 if (res != OK) return res;
1488
Eino-Ville Talvala96150cf2012-09-03 10:03:26 -0700[diff] [blame]1489 uint8_t reqWbLock = autoWhiteBalanceLock ?
1490 ANDROID_CONTROL_AWB_LOCK_ON : ANDROID_CONTROL_AWB_LOCK_OFF;
1491 res = request->update(ANDROID_CONTROL_AWB_LOCK,
1492 &reqWbLock, 1);
1493
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700[diff] [blame]1494 res = request->update(ANDROID_CONTROL_EFFECT_MODE,
1495 &effectMode, 1);
1496 if (res != OK) return res;
1497 res = request->update(ANDROID_CONTROL_AE_ANTIBANDING_MODE,
1498 &antibandingMode, 1);
1499 if (res != OK) return res;
1500
Eino-Ville Talvala61c0cc62012-09-07 14:26:29 -0700[diff] [blame]1501 // android.hardware.Camera requires that when face detect is enabled, the
1502 // camera is in a face-priority mode. HAL2 splits this into separate parts
1503 // (face detection statistics and face priority scene mode). Map from other
1504 // to the other.
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -0700[diff] [blame]1505 bool sceneModeActive =
1506 sceneMode != (uint8_t)ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED;
Eino-Ville Talvala61c0cc62012-09-07 14:26:29 -0700[diff] [blame]1507 uint8_t reqControlMode = ANDROID_CONTROL_AUTO;
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -0700[diff] [blame]1508 if (enableFaceDetect || sceneModeActive) {
Eino-Ville Talvala61c0cc62012-09-07 14:26:29 -0700[diff] [blame]1509 reqControlMode = ANDROID_CONTROL_USE_SCENE_MODE;
1510 }
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700[diff] [blame]1511 res = request->update(ANDROID_CONTROL_MODE,
1512 &reqControlMode, 1);
1513 if (res != OK) return res;
Eino-Ville Talvala61c0cc62012-09-07 14:26:29 -0700[diff] [blame]1514
Eino-Ville Talvalad14de472012-09-17 16:43:14 -0700[diff] [blame]1515 uint8_t reqSceneMode =
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -0700[diff] [blame]1516 sceneModeActive ? sceneMode :
Eino-Ville Talvalad14de472012-09-17 16:43:14 -0700[diff] [blame]1517 enableFaceDetect ? (uint8_t)ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY :
1518 (uint8_t)ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED;
Eino-Ville Talvala61c0cc62012-09-07 14:26:29 -0700[diff] [blame]1519 res = request->update(ANDROID_CONTROL_SCENE_MODE,
1520 &reqSceneMode, 1);
1521 if (res != OK) return res;
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700[diff] [blame]1522
1523 uint8_t reqFlashMode = ANDROID_FLASH_OFF;
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -0700[diff] [blame]1524 uint8_t reqAeMode = ANDROID_CONTROL_AE_OFF;
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700[diff] [blame]1525 switch (flashMode) {
1526 case Parameters::FLASH_MODE_OFF:
1527 reqAeMode = ANDROID_CONTROL_AE_ON; break;
1528 case Parameters::FLASH_MODE_AUTO:
1529 reqAeMode = ANDROID_CONTROL_AE_ON_AUTO_FLASH; break;
1530 case Parameters::FLASH_MODE_ON:
1531 reqAeMode = ANDROID_CONTROL_AE_ON_ALWAYS_FLASH; break;
1532 case Parameters::FLASH_MODE_TORCH:
1533 reqAeMode = ANDROID_CONTROL_AE_ON;
1534 reqFlashMode = ANDROID_FLASH_TORCH;
1535 break;
1536 case Parameters::FLASH_MODE_RED_EYE:
1537 reqAeMode = ANDROID_CONTROL_AE_ON_AUTO_FLASH_REDEYE; break;
1538 default:
1539 ALOGE("%s: Camera %d: Unknown flash mode %d", __FUNCTION__,
1540 cameraId, flashMode);
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -0700[diff] [blame]1541 return BAD_VALUE;
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700[diff] [blame]1542 }
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700[diff] [blame]1543 res = request->update(ANDROID_FLASH_MODE,
1544 &reqFlashMode, 1);
1545 if (res != OK) return res;
1546 res = request->update(ANDROID_CONTROL_AE_MODE,
1547 &reqAeMode, 1);
1548 if (res != OK) return res;
1549
Eino-Ville Talvala96150cf2012-09-03 10:03:26 -0700[diff] [blame]1550 uint8_t reqAeLock = autoExposureLock ?
1551 ANDROID_CONTROL_AE_LOCK_ON : ANDROID_CONTROL_AE_LOCK_OFF;
1552 res = request->update(ANDROID_CONTROL_AE_LOCK,
1553 &reqAeLock, 1);
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -0700[diff] [blame]1554 if (res != OK) return res;
1555
1556 res = request->update(ANDROID_CONTROL_AWB_MODE,
1557 &wbMode, 1);
1558 if (res != OK) return res;
Eino-Ville Talvala96150cf2012-09-03 10:03:26 -0700[diff] [blame]1559
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700[diff] [blame]1560 float reqFocusDistance = 0; // infinity focus in diopters
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -0700[diff] [blame]1561 uint8_t reqFocusMode = ANDROID_CONTROL_AF_OFF;
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700[diff] [blame]1562 switch (focusMode) {
1563 case Parameters::FOCUS_MODE_AUTO:
1564 case Parameters::FOCUS_MODE_MACRO:
1565 case Parameters::FOCUS_MODE_CONTINUOUS_VIDEO:
1566 case Parameters::FOCUS_MODE_CONTINUOUS_PICTURE:
1567 case Parameters::FOCUS_MODE_EDOF:
1568 reqFocusMode = focusMode;
1569 break;
1570 case Parameters::FOCUS_MODE_INFINITY:
1571 case Parameters::FOCUS_MODE_FIXED:
1572 reqFocusMode = ANDROID_CONTROL_AF_OFF;
1573 break;
1574 default:
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -0700[diff] [blame]1575 ALOGE("%s: Camera %d: Unknown focus mode %d", __FUNCTION__,
1576 cameraId, focusMode);
1577 return BAD_VALUE;
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700[diff] [blame]1578 }
1579 res = request->update(ANDROID_LENS_FOCUS_DISTANCE,
1580 &reqFocusDistance, 1);
1581 if (res != OK) return res;
1582 res = request->update(ANDROID_CONTROL_AF_MODE,
1583 &reqFocusMode, 1);
1584 if (res != OK) return res;
1585
1586 size_t reqFocusingAreasSize = focusingAreas.size() * 5;
1587 int32_t *reqFocusingAreas = new int32_t[reqFocusingAreasSize];
1588 for (size_t i = 0; i < reqFocusingAreasSize; i += 5) {
1589 if (focusingAreas[i].weight != 0) {
1590 reqFocusingAreas[i + 0] =
1591 normalizedXToArray(focusingAreas[i].left);
1592 reqFocusingAreas[i + 1] =
1593 normalizedYToArray(focusingAreas[i].top);
1594 reqFocusingAreas[i + 2] =
1595 normalizedXToArray(focusingAreas[i].right);
1596 reqFocusingAreas[i + 3] =
1597 normalizedYToArray(focusingAreas[i].bottom);
1598 } else {
1599 reqFocusingAreas[i + 0] = 0;
1600 reqFocusingAreas[i + 1] = 0;
1601 reqFocusingAreas[i + 2] = 0;
1602 reqFocusingAreas[i + 3] = 0;
1603 }
1604 reqFocusingAreas[i + 4] = focusingAreas[i].weight;
1605 }
1606 res = request->update(ANDROID_CONTROL_AF_REGIONS,
1607 reqFocusingAreas, reqFocusingAreasSize);
1608 if (res != OK) return res;
1609 delete[] reqFocusingAreas;
1610
1611 res = request->update(ANDROID_CONTROL_AE_EXP_COMPENSATION,
1612 &exposureCompensation, 1);
1613 if (res != OK) return res;
1614
1615 size_t reqMeteringAreasSize = meteringAreas.size() * 5;
1616 int32_t *reqMeteringAreas = new int32_t[reqMeteringAreasSize];
1617 for (size_t i = 0; i < reqMeteringAreasSize; i += 5) {
1618 if (meteringAreas[i].weight != 0) {
1619 reqMeteringAreas[i + 0] =
1620 normalizedXToArray(meteringAreas[i].left);
1621 reqMeteringAreas[i + 1] =
1622 normalizedYToArray(meteringAreas[i].top);
1623 reqMeteringAreas[i + 2] =
1624 normalizedXToArray(meteringAreas[i].right);
1625 reqMeteringAreas[i + 3] =
1626 normalizedYToArray(meteringAreas[i].bottom);
1627 } else {
1628 reqMeteringAreas[i + 0] = 0;
1629 reqMeteringAreas[i + 1] = 0;
1630 reqMeteringAreas[i + 2] = 0;
1631 reqMeteringAreas[i + 3] = 0;
1632 }
1633 reqMeteringAreas[i + 4] = meteringAreas[i].weight;
1634 }
1635 res = request->update(ANDROID_CONTROL_AE_REGIONS,
1636 reqMeteringAreas, reqMeteringAreasSize);
1637 if (res != OK) return res;
1638
1639 res = request->update(ANDROID_CONTROL_AWB_REGIONS,
1640 reqMeteringAreas, reqMeteringAreasSize);
1641 if (res != OK) return res;
1642 delete[] reqMeteringAreas;
1643
Igor Murashkin018d2282012-09-18 18:23:49 -0700[diff] [blame]1644 CropRegion crop = calculateCropRegion();
1645 int32_t reqCropRegion[3] = { crop.left, crop.top, crop.width };
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700[diff] [blame]1646 res = request->update(ANDROID_SCALER_CROP_REGION,
1647 reqCropRegion, 3);
1648 if (res != OK) return res;
1649
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700[diff] [blame]1650 uint8_t reqVstabMode = videoStabilization ?
1651 ANDROID_CONTROL_VIDEO_STABILIZATION_ON :
1652 ANDROID_CONTROL_VIDEO_STABILIZATION_OFF;
1653 res = request->update(ANDROID_CONTROL_VIDEO_STABILIZATION_MODE,
1654 &reqVstabMode, 1);
1655 if (res != OK) return res;
1656
1657 uint8_t reqFaceDetectMode = enableFaceDetect ?
1658 fastInfo.bestFaceDetectMode :
1659 (uint8_t)ANDROID_STATS_FACE_DETECTION_OFF;
1660 res = request->update(ANDROID_STATS_FACE_DETECT_MODE,
1661 &reqFaceDetectMode, 1);
1662 if (res != OK) return res;
1663
1664 return OK;
1665}
1666
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1667const char* Parameters::getStateName(State state) {
1668#define CASE_ENUM_TO_CHAR(x) case x: return(#x); break;
1669 switch(state) {
1670 CASE_ENUM_TO_CHAR(DISCONNECTED)
1671 CASE_ENUM_TO_CHAR(STOPPED)
1672 CASE_ENUM_TO_CHAR(WAITING_FOR_PREVIEW_WINDOW)
1673 CASE_ENUM_TO_CHAR(PREVIEW)
1674 CASE_ENUM_TO_CHAR(RECORD)
1675 CASE_ENUM_TO_CHAR(STILL_CAPTURE)
1676 CASE_ENUM_TO_CHAR(VIDEO_SNAPSHOT)
1677 default:
1678 return "Unknown state!";
1679 break;
1680 }
1681#undef CASE_ENUM_TO_CHAR
1682}
1683
1684int Parameters::formatStringToEnum(const char *format) {
1685 return
Eino-Ville Talvala4a02cc82012-09-10 09:53:09 -0700[diff] [blame]1686 !format ?
1687 HAL_PIXEL_FORMAT_YCrCb_420_SP :
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1688 !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV422SP) ?
1689 HAL_PIXEL_FORMAT_YCbCr_422_SP : // NV16
1690 !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV420SP) ?
1691 HAL_PIXEL_FORMAT_YCrCb_420_SP : // NV21
1692 !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV422I) ?
1693 HAL_PIXEL_FORMAT_YCbCr_422_I : // YUY2
1694 !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV420P) ?
1695 HAL_PIXEL_FORMAT_YV12 : // YV12
1696 !strcmp(format, CameraParameters::PIXEL_FORMAT_RGB565) ?
1697 HAL_PIXEL_FORMAT_RGB_565 : // RGB565
1698 !strcmp(format, CameraParameters::PIXEL_FORMAT_RGBA8888) ?
1699 HAL_PIXEL_FORMAT_RGBA_8888 : // RGB8888
1700 !strcmp(format, CameraParameters::PIXEL_FORMAT_BAYER_RGGB) ?
1701 HAL_PIXEL_FORMAT_RAW_SENSOR : // Raw sensor data
1702 -1;
1703}
1704
1705const char* Parameters::formatEnumToString(int format) {
1706 const char *fmt;
1707 switch(format) {
1708 case HAL_PIXEL_FORMAT_YCbCr_422_SP: // NV16
1709 fmt = CameraParameters::PIXEL_FORMAT_YUV422SP;
1710 break;
1711 case HAL_PIXEL_FORMAT_YCrCb_420_SP: // NV21
1712 fmt = CameraParameters::PIXEL_FORMAT_YUV420SP;
1713 break;
1714 case HAL_PIXEL_FORMAT_YCbCr_422_I: // YUY2
1715 fmt = CameraParameters::PIXEL_FORMAT_YUV422I;
1716 break;
1717 case HAL_PIXEL_FORMAT_YV12: // YV12
1718 fmt = CameraParameters::PIXEL_FORMAT_YUV420P;
1719 break;
1720 case HAL_PIXEL_FORMAT_RGB_565: // RGB565
1721 fmt = CameraParameters::PIXEL_FORMAT_RGB565;
1722 break;
1723 case HAL_PIXEL_FORMAT_RGBA_8888: // RGBA8888
1724 fmt = CameraParameters::PIXEL_FORMAT_RGBA8888;
1725 break;
1726 case HAL_PIXEL_FORMAT_RAW_SENSOR:
1727 ALOGW("Raw sensor preview format requested.");
1728 fmt = CameraParameters::PIXEL_FORMAT_BAYER_RGGB;
1729 break;
1730 default:
1731 ALOGE("%s: Unknown preview format: %x",
1732 __FUNCTION__, format);
1733 fmt = NULL;
1734 break;
1735 }
1736 return fmt;
1737}
1738
1739int Parameters::wbModeStringToEnum(const char *wbMode) {
1740 return
Eino-Ville Talvala4a02cc82012-09-10 09:53:09 -0700[diff] [blame]1741 !wbMode ?
1742 ANDROID_CONTROL_AWB_AUTO :
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1743 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_AUTO) ?
1744 ANDROID_CONTROL_AWB_AUTO :
1745 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_INCANDESCENT) ?
1746 ANDROID_CONTROL_AWB_INCANDESCENT :
1747 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_FLUORESCENT) ?
1748 ANDROID_CONTROL_AWB_FLUORESCENT :
1749 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_WARM_FLUORESCENT) ?
1750 ANDROID_CONTROL_AWB_WARM_FLUORESCENT :
1751 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_DAYLIGHT) ?
1752 ANDROID_CONTROL_AWB_DAYLIGHT :
1753 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT) ?
1754 ANDROID_CONTROL_AWB_CLOUDY_DAYLIGHT :
1755 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_TWILIGHT) ?
1756 ANDROID_CONTROL_AWB_TWILIGHT :
1757 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_SHADE) ?
1758 ANDROID_CONTROL_AWB_SHADE :
1759 -1;
1760}
1761
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -0700[diff] [blame]1762const char* Parameters::wbModeEnumToString(uint8_t wbMode) {
1763 switch (wbMode) {
1764 case ANDROID_CONTROL_AWB_AUTO:
1765 return CameraParameters::WHITE_BALANCE_AUTO;
1766 case ANDROID_CONTROL_AWB_INCANDESCENT:
1767 return CameraParameters::WHITE_BALANCE_INCANDESCENT;
1768 case ANDROID_CONTROL_AWB_FLUORESCENT:
1769 return CameraParameters::WHITE_BALANCE_FLUORESCENT;
1770 case ANDROID_CONTROL_AWB_WARM_FLUORESCENT:
1771 return CameraParameters::WHITE_BALANCE_WARM_FLUORESCENT;
1772 case ANDROID_CONTROL_AWB_DAYLIGHT:
1773 return CameraParameters::WHITE_BALANCE_DAYLIGHT;
1774 case ANDROID_CONTROL_AWB_CLOUDY_DAYLIGHT:
1775 return CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT;
1776 case ANDROID_CONTROL_AWB_TWILIGHT:
1777 return CameraParameters::WHITE_BALANCE_TWILIGHT;
1778 case ANDROID_CONTROL_AWB_SHADE:
1779 return CameraParameters::WHITE_BALANCE_SHADE;
1780 default:
1781 ALOGE("%s: Unknown AWB mode enum: %d",
1782 __FUNCTION__, wbMode);
1783 return "unknown";
1784 }
1785}
1786
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1787int Parameters::effectModeStringToEnum(const char *effectMode) {
1788 return
Eino-Ville Talvala4a02cc82012-09-10 09:53:09 -0700[diff] [blame]1789 !effectMode ?
1790 ANDROID_CONTROL_EFFECT_OFF :
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1791 !strcmp(effectMode, CameraParameters::EFFECT_NONE) ?
1792 ANDROID_CONTROL_EFFECT_OFF :
1793 !strcmp(effectMode, CameraParameters::EFFECT_MONO) ?
1794 ANDROID_CONTROL_EFFECT_MONO :
1795 !strcmp(effectMode, CameraParameters::EFFECT_NEGATIVE) ?
1796 ANDROID_CONTROL_EFFECT_NEGATIVE :
1797 !strcmp(effectMode, CameraParameters::EFFECT_SOLARIZE) ?
1798 ANDROID_CONTROL_EFFECT_SOLARIZE :
1799 !strcmp(effectMode, CameraParameters::EFFECT_SEPIA) ?
1800 ANDROID_CONTROL_EFFECT_SEPIA :
1801 !strcmp(effectMode, CameraParameters::EFFECT_POSTERIZE) ?
1802 ANDROID_CONTROL_EFFECT_POSTERIZE :
1803 !strcmp(effectMode, CameraParameters::EFFECT_WHITEBOARD) ?
1804 ANDROID_CONTROL_EFFECT_WHITEBOARD :
1805 !strcmp(effectMode, CameraParameters::EFFECT_BLACKBOARD) ?
1806 ANDROID_CONTROL_EFFECT_BLACKBOARD :
1807 !strcmp(effectMode, CameraParameters::EFFECT_AQUA) ?
1808 ANDROID_CONTROL_EFFECT_AQUA :
1809 -1;
1810}
1811
1812int Parameters::abModeStringToEnum(const char *abMode) {
1813 return
Eino-Ville Talvala4a02cc82012-09-10 09:53:09 -0700[diff] [blame]1814 !abMode ?
1815 ANDROID_CONTROL_AE_ANTIBANDING_AUTO :
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1816 !strcmp(abMode, CameraParameters::ANTIBANDING_AUTO) ?
1817 ANDROID_CONTROL_AE_ANTIBANDING_AUTO :
1818 !strcmp(abMode, CameraParameters::ANTIBANDING_OFF) ?
1819 ANDROID_CONTROL_AE_ANTIBANDING_OFF :
1820 !strcmp(abMode, CameraParameters::ANTIBANDING_50HZ) ?
1821 ANDROID_CONTROL_AE_ANTIBANDING_50HZ :
1822 !strcmp(abMode, CameraParameters::ANTIBANDING_60HZ) ?
1823 ANDROID_CONTROL_AE_ANTIBANDING_60HZ :
1824 -1;
1825}
1826
1827int Parameters::sceneModeStringToEnum(const char *sceneMode) {
1828 return
Eino-Ville Talvala4a02cc82012-09-10 09:53:09 -0700[diff] [blame]1829 !sceneMode ?
1830 ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED :
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1831 !strcmp(sceneMode, CameraParameters::SCENE_MODE_AUTO) ?
1832 ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED :
1833 !strcmp(sceneMode, CameraParameters::SCENE_MODE_ACTION) ?
1834 ANDROID_CONTROL_SCENE_MODE_ACTION :
1835 !strcmp(sceneMode, CameraParameters::SCENE_MODE_PORTRAIT) ?
1836 ANDROID_CONTROL_SCENE_MODE_PORTRAIT :
1837 !strcmp(sceneMode, CameraParameters::SCENE_MODE_LANDSCAPE) ?
1838 ANDROID_CONTROL_SCENE_MODE_LANDSCAPE :
1839 !strcmp(sceneMode, CameraParameters::SCENE_MODE_NIGHT) ?
1840 ANDROID_CONTROL_SCENE_MODE_NIGHT :
1841 !strcmp(sceneMode, CameraParameters::SCENE_MODE_NIGHT_PORTRAIT) ?
1842 ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT :
1843 !strcmp(sceneMode, CameraParameters::SCENE_MODE_THEATRE) ?
1844 ANDROID_CONTROL_SCENE_MODE_THEATRE :
1845 !strcmp(sceneMode, CameraParameters::SCENE_MODE_BEACH) ?
1846 ANDROID_CONTROL_SCENE_MODE_BEACH :
1847 !strcmp(sceneMode, CameraParameters::SCENE_MODE_SNOW) ?
1848 ANDROID_CONTROL_SCENE_MODE_SNOW :
1849 !strcmp(sceneMode, CameraParameters::SCENE_MODE_SUNSET) ?
1850 ANDROID_CONTROL_SCENE_MODE_SUNSET :
1851 !strcmp(sceneMode, CameraParameters::SCENE_MODE_STEADYPHOTO) ?
1852 ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO :
1853 !strcmp(sceneMode, CameraParameters::SCENE_MODE_FIREWORKS) ?
1854 ANDROID_CONTROL_SCENE_MODE_FIREWORKS :
1855 !strcmp(sceneMode, CameraParameters::SCENE_MODE_SPORTS) ?
1856 ANDROID_CONTROL_SCENE_MODE_SPORTS :
1857 !strcmp(sceneMode, CameraParameters::SCENE_MODE_PARTY) ?
1858 ANDROID_CONTROL_SCENE_MODE_PARTY :
1859 !strcmp(sceneMode, CameraParameters::SCENE_MODE_CANDLELIGHT) ?
1860 ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT :
1861 !strcmp(sceneMode, CameraParameters::SCENE_MODE_BARCODE) ?
1862 ANDROID_CONTROL_SCENE_MODE_BARCODE:
1863 -1;
1864}
1865
1866Parameters::Parameters::flashMode_t Parameters::flashModeStringToEnum(
1867 const char *flashMode) {
1868 return
Eino-Ville Talvala4a02cc82012-09-10 09:53:09 -0700[diff] [blame]1869 !flashMode ?
1870 Parameters::FLASH_MODE_INVALID :
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1871 !strcmp(flashMode, CameraParameters::FLASH_MODE_OFF) ?
1872 Parameters::FLASH_MODE_OFF :
1873 !strcmp(flashMode, CameraParameters::FLASH_MODE_AUTO) ?
1874 Parameters::FLASH_MODE_AUTO :
1875 !strcmp(flashMode, CameraParameters::FLASH_MODE_ON) ?
1876 Parameters::FLASH_MODE_ON :
1877 !strcmp(flashMode, CameraParameters::FLASH_MODE_RED_EYE) ?
1878 Parameters::FLASH_MODE_RED_EYE :
1879 !strcmp(flashMode, CameraParameters::FLASH_MODE_TORCH) ?
1880 Parameters::FLASH_MODE_TORCH :
1881 Parameters::FLASH_MODE_INVALID;
1882}
1883
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -0700[diff] [blame]1884const char *Parameters::flashModeEnumToString(flashMode_t flashMode) {
1885 switch (flashMode) {
1886 case FLASH_MODE_OFF:
1887 return CameraParameters::FLASH_MODE_OFF;
1888 case FLASH_MODE_AUTO:
1889 return CameraParameters::FLASH_MODE_AUTO;
1890 case FLASH_MODE_ON:
1891 return CameraParameters::FLASH_MODE_ON;
1892 case FLASH_MODE_RED_EYE:
1893 return CameraParameters::FLASH_MODE_RED_EYE;
1894 case FLASH_MODE_TORCH:
1895 return CameraParameters::FLASH_MODE_TORCH;
1896 default:
1897 ALOGE("%s: Unknown flash mode enum %d",
1898 __FUNCTION__, flashMode);
1899 return "unknown";
1900 }
1901}
1902
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1903Parameters::Parameters::focusMode_t Parameters::focusModeStringToEnum(
1904 const char *focusMode) {
1905 return
Eino-Ville Talvala4a02cc82012-09-10 09:53:09 -0700[diff] [blame]1906 !focusMode ?
1907 Parameters::FOCUS_MODE_INVALID :
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1908 !strcmp(focusMode, CameraParameters::FOCUS_MODE_AUTO) ?
1909 Parameters::FOCUS_MODE_AUTO :
1910 !strcmp(focusMode, CameraParameters::FOCUS_MODE_INFINITY) ?
1911 Parameters::FOCUS_MODE_INFINITY :
1912 !strcmp(focusMode, CameraParameters::FOCUS_MODE_MACRO) ?
1913 Parameters::FOCUS_MODE_MACRO :
1914 !strcmp(focusMode, CameraParameters::FOCUS_MODE_FIXED) ?
1915 Parameters::FOCUS_MODE_FIXED :
1916 !strcmp(focusMode, CameraParameters::FOCUS_MODE_EDOF) ?
1917 Parameters::FOCUS_MODE_EDOF :
1918 !strcmp(focusMode, CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO) ?
1919 Parameters::FOCUS_MODE_CONTINUOUS_VIDEO :
1920 !strcmp(focusMode, CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE) ?
1921 Parameters::FOCUS_MODE_CONTINUOUS_PICTURE :
1922 Parameters::FOCUS_MODE_INVALID;
1923}
1924
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -0700[diff] [blame]1925const char *Parameters::focusModeEnumToString(focusMode_t focusMode) {
1926 switch (focusMode) {
1927 case FOCUS_MODE_AUTO:
1928 return CameraParameters::FOCUS_MODE_AUTO;
1929 case FOCUS_MODE_MACRO:
1930 return CameraParameters::FOCUS_MODE_MACRO;
1931 case FOCUS_MODE_CONTINUOUS_VIDEO:
1932 return CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO;
1933 case FOCUS_MODE_CONTINUOUS_PICTURE:
1934 return CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE;
1935 case FOCUS_MODE_EDOF:
1936 return CameraParameters::FOCUS_MODE_EDOF;
1937 case FOCUS_MODE_INFINITY:
1938 return CameraParameters::FOCUS_MODE_INFINITY;
1939 case FOCUS_MODE_FIXED:
1940 return CameraParameters::FOCUS_MODE_FIXED;
1941 default:
1942 ALOGE("%s: Unknown focus mode enum: %d",
1943 __FUNCTION__, focusMode);
1944 return "unknown";
1945 }
1946}
1947
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1948status_t Parameters::parseAreas(const char *areasCStr,
1949 Vector<Parameters::Area> *areas) {
1950 static const size_t NUM_FIELDS = 5;
1951 areas->clear();
1952 if (areasCStr == NULL) {
1953 // If no key exists, use default (0,0,0,0,0)
1954 areas->push();
1955 return OK;
1956 }
1957 String8 areasStr(areasCStr);
1958 ssize_t areaStart = areasStr.find("(", 0) + 1;
1959 while (areaStart != 0) {
1960 const char* area = areasStr.string() + areaStart;
1961 char *numEnd;
1962 int vals[NUM_FIELDS];
1963 for (size_t i = 0; i < NUM_FIELDS; i++) {
1964 errno = 0;
1965 vals[i] = strtol(area, &numEnd, 10);
1966 if (errno || numEnd == area) return BAD_VALUE;
1967 area = numEnd + 1;
1968 }
1969 areas->push(Parameters::Area(
1970 vals[0], vals[1], vals[2], vals[3], vals[4]) );
1971 areaStart = areasStr.find("(", areaStart) + 1;
1972 }
1973 return OK;
1974}
1975
1976status_t Parameters::validateAreas(const Vector<Parameters::Area> &areas,
1977 size_t maxRegions) {
1978 // Definition of valid area can be found in
1979 // include/camera/CameraParameters.h
1980 if (areas.size() == 0) return BAD_VALUE;
1981 if (areas.size() == 1) {
1982 if (areas[0].left == 0 &&
1983 areas[0].top == 0 &&
1984 areas[0].right == 0 &&
1985 areas[0].bottom == 0 &&
1986 areas[0].weight == 0) {
1987 // Single (0,0,0,0,0) entry is always valid (== driver decides)
1988 return OK;
1989 }
1990 }
1991 if (areas.size() > maxRegions) {
1992 ALOGE("%s: Too many areas requested: %d",
1993 __FUNCTION__, areas.size());
1994 return BAD_VALUE;
1995 }
1996
1997 for (Vector<Parameters::Area>::const_iterator a = areas.begin();
1998 a != areas.end(); a++) {
1999 if (a->weight < 1 || a->weight > 1000) return BAD_VALUE;
2000 if (a->left < -1000 || a->left > 1000) return BAD_VALUE;
2001 if (a->top < -1000 || a->top > 1000) return BAD_VALUE;
2002 if (a->right < -1000 || a->right > 1000) return BAD_VALUE;
2003 if (a->bottom < -1000 || a->bottom > 1000) return BAD_VALUE;
2004 if (a->left >= a->right) return BAD_VALUE;
2005 if (a->top >= a->bottom) return BAD_VALUE;
2006 }
2007 return OK;
2008}
2009
2010bool Parameters::boolFromString(const char *boolStr) {
2011 return !boolStr ? false :
2012 !strcmp(boolStr, CameraParameters::TRUE) ? true :
2013 false;
2014}
2015
2016int Parameters::degToTransform(int degrees, bool mirror) {
2017 if (!mirror) {
2018 if (degrees == 0) return 0;
2019 else if (degrees == 90) return HAL_TRANSFORM_ROT_90;
2020 else if (degrees == 180) return HAL_TRANSFORM_ROT_180;
2021 else if (degrees == 270) return HAL_TRANSFORM_ROT_270;
2022 } else { // Do mirror (horizontal flip)
2023 if (degrees == 0) { // FLIP_H and ROT_0
2024 return HAL_TRANSFORM_FLIP_H;
2025 } else if (degrees == 90) { // FLIP_H and ROT_90
2026 return HAL_TRANSFORM_FLIP_H | HAL_TRANSFORM_ROT_90;
2027 } else if (degrees == 180) { // FLIP_H and ROT_180
2028 return HAL_TRANSFORM_FLIP_V;
2029 } else if (degrees == 270) { // FLIP_H and ROT_270
2030 return HAL_TRANSFORM_FLIP_V | HAL_TRANSFORM_ROT_90;
2031 }
2032 }
2033 ALOGE("%s: Bad input: %d", __FUNCTION__, degrees);
2034 return -1;
2035}
2036
2037int Parameters::arrayXToNormalized(int width) const {
2038 return width * 2000 / (fastInfo.arrayWidth - 1) - 1000;
2039}
2040
2041int Parameters::arrayYToNormalized(int height) const {
2042 return height * 2000 / (fastInfo.arrayHeight - 1) - 1000;
2043}
2044
2045int Parameters::normalizedXToArray(int x) const {
2046 return (x + 1000) * (fastInfo.arrayWidth - 1) / 2000;
2047}
2048
2049int Parameters::normalizedYToArray(int y) const {
2050 return (y + 1000) * (fastInfo.arrayHeight - 1) / 2000;
2051}
2052
Igor Murashkin018d2282012-09-18 18:23:49 -0700[diff] [blame]2053Parameters::CropRegion Parameters::calculateCropRegion(void) const {
2054
2055 float zoomLeft, zoomTop, zoomWidth, zoomHeight;
2056
2057 // Need to convert zoom index into a crop rectangle. The rectangle is
2058 // chosen to maximize its area on the sensor
2059
2060 camera_metadata_ro_entry_t maxDigitalZoom =
2061 staticInfo(ANDROID_SCALER_AVAILABLE_MAX_ZOOM);
2062 // For each zoom step by how many pixels more do we change the zoom
2063 float zoomIncrement = (maxDigitalZoom.data.f[0] - 1) /
2064 (NUM_ZOOM_STEPS-1);
2065 // The desired activeAreaWidth/cropAreaWidth ratio (or height if h>w)
2066 // via interpolating zoom step into a zoom ratio
2067 float zoomRatio = 1 + zoomIncrement * zoom;
2068 ALOG_ASSERT( (zoomRatio >= 1.f && zoomRatio <= maxDigitalZoom.data.f[0]),
2069 "Zoom ratio calculated out of bounds. Expected 1 - %f, actual: %f",
2070 maxDigitalZoom.data.f[0], zoomRatio);
2071
2072 ALOGV("Zoom maxDigital=%f, increment=%f, ratio=%f, previewWidth=%d, "
2073 "previewHeight=%d, activeWidth=%d, activeHeight=%d",
2074 maxDigitalZoom.data.f[0], zoomIncrement, zoomRatio, previewWidth,
2075 previewHeight, fastInfo.arrayWidth, fastInfo.arrayHeight);
2076
2077 /*
2078 * Assumption: On the HAL side each stream buffer calculates its crop
2079 * rectangle as follows:
2080 * cropRect = (zoomLeft, zoomRight,
2081 * zoomWidth, zoomHeight * zoomWidth / outputWidth);
2082 *
2083 * Note that if zoomWidth > bufferWidth, the new cropHeight > zoomHeight
2084 * (we can then get into trouble if the cropHeight > arrayHeight).
2085 * By selecting the zoomRatio based on the smallest outputRatio, we
2086 * guarantee this will never happen.
2087 */
2088
2089 // Enumerate all possible output sizes, select the one with the smallest
2090 // aspect ratio
2091 float minOutputWidth, minOutputHeight, minOutputRatio;
2092 {
2093 float outputSizes[][2] = {
2094 { previewWidth, previewHeight },
2095 { videoWidth, videoHeight },
2096 /* don't include jpeg thumbnail size - it's valid for
2097 it to be set to (0,0), meaning 'no thumbnail' */
2098 // { jpegThumbSize[0], jpegThumbSize[1] },
2099 { pictureWidth, pictureHeight },
2100 };
2101
2102 minOutputWidth = outputSizes[0][0];
2103 minOutputHeight = outputSizes[0][1];
2104 minOutputRatio = minOutputWidth / minOutputHeight;
2105 for (unsigned int i = 0;
2106 i < sizeof(outputSizes) / sizeof(outputSizes[0]);
2107 ++i) {
2108
2109 float outputWidth = outputSizes[i][0];
2110 float outputHeight = outputSizes[i][1];
2111 float outputRatio = outputWidth / outputHeight;
2112
2113 if (minOutputRatio > outputRatio) {
2114 minOutputRatio = outputRatio;
2115 minOutputWidth = outputWidth;
2116 minOutputHeight = outputHeight;
2117 }
2118
2119 // and then use this output ratio instead of preview output ratio
2120 ALOGV("Enumerating output ratio %f = %f / %f, min is %f",
2121 outputRatio, outputWidth, outputHeight, minOutputRatio);
2122 }
2123 }
2124
2125 /* Ensure that the width/height never go out of bounds
2126 * by scaling across a diffent dimension if an out-of-bounds
2127 * possibility exists.
2128 *
2129 * e.g. if the previewratio < arrayratio and e.g. zoomratio = 1.0, then by
2130 * calculating the zoomWidth from zoomHeight we'll actually get a
2131 * zoomheight > arrayheight
2132 */
2133 float arrayRatio = 1.f * fastInfo.arrayWidth / fastInfo.arrayHeight;
2134 if (minOutputRatio >= arrayRatio) {
2135 // Adjust the height based on the width
2136 zoomWidth = fastInfo.arrayWidth / zoomRatio;
2137 zoomHeight = zoomWidth *
2138 minOutputHeight / minOutputWidth;
2139
2140 } else {
2141 // Adjust the width based on the height
2142 zoomHeight = fastInfo.arrayHeight / zoomRatio;
2143 zoomWidth = zoomHeight *
2144 minOutputWidth / minOutputHeight;
2145 }
2146 // centering the zoom area within the active area
2147 zoomLeft = (fastInfo.arrayWidth - zoomWidth) / 2;
2148 zoomTop = (fastInfo.arrayHeight - zoomHeight) / 2;
2149
2150 ALOGV("Crop region calculated (x=%d,y=%d,w=%f,h=%f) for zoom=%d",
2151 (int32_t)zoomLeft, (int32_t)zoomTop, zoomWidth, zoomHeight, this->zoom);
2152
2153
2154 CropRegion crop = { zoomLeft, zoomTop, zoomWidth, zoomHeight };
2155 return crop;
2156}
2157
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]2158}; // namespace camera2
2159}; // namespace android