Gitiles
Code Review Sign In
review.evervolv.com / android_frameworks_av / 4c9eb718352697cd75269752344c0bcc6b05e708 / . / services / camera / libcameraservice / camera2 / Parameters.cpp
blob: 7740df27fc1299f9232a3988eb73c38abbeb1541 [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 Talvala852c3812012-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 Talvala69230df2012-08-29 17:37:16 -0700[diff] [blame]21#include <utils/Log.h>
22#include <utils/Trace.h>
23
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]24#include <math.h>
25#include <stdlib.h>
Eino-Ville Talvalac33e4b52012-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 Talvala596cb972012-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 Talvalab5d91132012-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 Talvalab5d91132012-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 Talvala823b7862012-09-27 18:08:20 -0700[diff] [blame]173 // NOTE: Not scaled like FPS range values are.
Eino-Ville Talvalac85f8262012-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 Talvala823b7862012-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 Talvala823b7862012-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 Talvalaa1e4e302012-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 Talvalac85f8262012-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 Murashkine500bc22012-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 Talvala69230df2012-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 Talvala69230df2012-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 Talvalac33e4b52012-09-11 16:51:32 -0700[diff] [blame]754 char value[PROPERTY_VALUE_MAX];
Eino-Ville Talvalaa2acc962012-09-17 16:57:27 -0700[diff] [blame]755 property_get("camera.disable_zsl_mode", value, "0");
Eino-Ville Talvalac33e4b52012-09-11 16:51:32 -0700[diff] [blame]756 if (!strcmp(value,"1")) {
Eino-Ville Talvalaa2acc962012-09-17 16:57:27 -0700[diff] [blame]757 ALOGI("Camera %d: Disabling ZSL mode", cameraId);
Eino-Ville Talvalac33e4b52012-09-11 16:51:32 -0700[diff] [blame]758 zslMode = false;
Eino-Ville Talvalaa2acc962012-09-17 16:57:27 -0700[diff] [blame]759 } else {
760 zslMode = true;
Eino-Ville Talvalac33e4b52012-09-11 16:51:32 -0700[diff] [blame]761 }
James Painterc3dbf1a2012-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 Talvalac85f8262012-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 Talvalac85f8262012-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 Talvala596cb972012-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 Talvalac85f8262012-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 Talvalac85f8262012-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 Talvalab5d91132012-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 Talvalac85f8262012-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 Talvala823b7862012-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 }
Eino-Ville Talvala02b62d32012-10-03 14:59:29 -0700[diff] [blame]1060 newParams.set(CameraParameters::KEY_PREVIEW_FPS_RANGE,
1061 String8::format("%d,%d",
1062 validatedParams.previewFpsRange[0] * kFpsToApiScale,
1063 validatedParams.previewFpsRange[1] * kFpsToApiScale));
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1064 }
1065
1066 // PICTURE_SIZE
1067 newParams.getPictureSize(&validatedParams.pictureWidth,
1068 &validatedParams.pictureHeight);
1069 if (validatedParams.pictureWidth == pictureWidth ||
1070 validatedParams.pictureHeight == pictureHeight) {
1071 camera_metadata_ro_entry_t availablePictureSizes =
1072 staticInfo(ANDROID_SCALER_AVAILABLE_JPEG_SIZES);
1073 for (i = 0; i < availablePictureSizes.count; i+=2) {
1074 if ((availablePictureSizes.data.i32[i] ==
1075 validatedParams.pictureWidth) &&
1076 (availablePictureSizes.data.i32[i+1] ==
1077 validatedParams.pictureHeight)) break;
1078 }
1079 if (i == availablePictureSizes.count) {
1080 ALOGE("%s: Requested picture size %d x %d is not supported",
1081 __FUNCTION__, validatedParams.pictureWidth,
1082 validatedParams.pictureHeight);
1083 return BAD_VALUE;
1084 }
1085 }
1086
1087 // JPEG_THUMBNAIL_WIDTH/HEIGHT
1088 validatedParams.jpegThumbSize[0] =
1089 newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH);
1090 validatedParams.jpegThumbSize[1] =
1091 newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT);
1092 if (validatedParams.jpegThumbSize[0] != jpegThumbSize[0] ||
1093 validatedParams.jpegThumbSize[1] != jpegThumbSize[1]) {
1094 camera_metadata_ro_entry_t availableJpegThumbSizes =
1095 staticInfo(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES);
1096 for (i = 0; i < availableJpegThumbSizes.count; i+=2) {
1097 if ((availableJpegThumbSizes.data.i32[i] ==
1098 validatedParams.jpegThumbSize[0]) &&
1099 (availableJpegThumbSizes.data.i32[i+1] ==
1100 validatedParams.jpegThumbSize[1])) break;
1101 }
1102 if (i == availableJpegThumbSizes.count) {
1103 ALOGE("%s: Requested JPEG thumbnail size %d x %d is not supported",
1104 __FUNCTION__, validatedParams.jpegThumbSize[0],
1105 validatedParams.jpegThumbSize[1]);
1106 return BAD_VALUE;
1107 }
1108 }
1109
1110 // JPEG_THUMBNAIL_QUALITY
1111 validatedParams.jpegThumbQuality =
1112 newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY);
1113 if (validatedParams.jpegThumbQuality < 0 ||
1114 validatedParams.jpegThumbQuality > 100) {
1115 ALOGE("%s: Requested JPEG thumbnail quality %d is not supported",
1116 __FUNCTION__, validatedParams.jpegThumbQuality);
1117 return BAD_VALUE;
1118 }
1119
1120 // JPEG_QUALITY
1121 validatedParams.jpegQuality =
1122 newParams.getInt(CameraParameters::KEY_JPEG_QUALITY);
1123 if (validatedParams.jpegQuality < 0 || validatedParams.jpegQuality > 100) {
1124 ALOGE("%s: Requested JPEG quality %d is not supported",
1125 __FUNCTION__, validatedParams.jpegQuality);
1126 return BAD_VALUE;
1127 }
1128
1129 // ROTATION
1130 validatedParams.jpegRotation =
1131 newParams.getInt(CameraParameters::KEY_ROTATION);
1132 if (validatedParams.jpegRotation != 0 &&
1133 validatedParams.jpegRotation != 90 &&
1134 validatedParams.jpegRotation != 180 &&
1135 validatedParams.jpegRotation != 270) {
1136 ALOGE("%s: Requested picture rotation angle %d is not supported",
1137 __FUNCTION__, validatedParams.jpegRotation);
1138 return BAD_VALUE;
1139 }
1140
1141 // GPS
1142
1143 const char *gpsLatStr =
1144 newParams.get(CameraParameters::KEY_GPS_LATITUDE);
1145 if (gpsLatStr != NULL) {
1146 const char *gpsLongStr =
1147 newParams.get(CameraParameters::KEY_GPS_LONGITUDE);
1148 const char *gpsAltitudeStr =
1149 newParams.get(CameraParameters::KEY_GPS_ALTITUDE);
1150 const char *gpsTimeStr =
1151 newParams.get(CameraParameters::KEY_GPS_TIMESTAMP);
1152 const char *gpsProcMethodStr =
1153 newParams.get(CameraParameters::KEY_GPS_PROCESSING_METHOD);
1154 if (gpsLongStr == NULL ||
1155 gpsAltitudeStr == NULL ||
1156 gpsTimeStr == NULL ||
1157 gpsProcMethodStr == NULL) {
1158 ALOGE("%s: Incomplete set of GPS parameters provided",
1159 __FUNCTION__);
1160 return BAD_VALUE;
1161 }
1162 char *endPtr;
1163 errno = 0;
1164 validatedParams.gpsCoordinates[0] = strtod(gpsLatStr, &endPtr);
1165 if (errno || endPtr == gpsLatStr) {
1166 ALOGE("%s: Malformed GPS latitude: %s", __FUNCTION__, gpsLatStr);
1167 return BAD_VALUE;
1168 }
1169 errno = 0;
1170 validatedParams.gpsCoordinates[1] = strtod(gpsLongStr, &endPtr);
1171 if (errno || endPtr == gpsLongStr) {
1172 ALOGE("%s: Malformed GPS longitude: %s", __FUNCTION__, gpsLongStr);
1173 return BAD_VALUE;
1174 }
1175 errno = 0;
1176 validatedParams.gpsCoordinates[2] = strtod(gpsAltitudeStr, &endPtr);
1177 if (errno || endPtr == gpsAltitudeStr) {
1178 ALOGE("%s: Malformed GPS altitude: %s", __FUNCTION__,
1179 gpsAltitudeStr);
1180 return BAD_VALUE;
1181 }
1182 errno = 0;
1183 validatedParams.gpsTimestamp = strtoll(gpsTimeStr, &endPtr, 10);
1184 if (errno || endPtr == gpsTimeStr) {
1185 ALOGE("%s: Malformed GPS timestamp: %s", __FUNCTION__, gpsTimeStr);
1186 return BAD_VALUE;
1187 }
1188 validatedParams.gpsProcessingMethod = gpsProcMethodStr;
1189
1190 validatedParams.gpsEnabled = true;
1191 } else {
1192 validatedParams.gpsEnabled = false;
1193 }
1194
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1195 // EFFECT
1196 validatedParams.effectMode = effectModeStringToEnum(
1197 newParams.get(CameraParameters::KEY_EFFECT) );
1198 if (validatedParams.effectMode != effectMode) {
1199 camera_metadata_ro_entry_t availableEffectModes =
1200 staticInfo(ANDROID_CONTROL_AVAILABLE_EFFECTS);
1201 for (i = 0; i < availableEffectModes.count; i++) {
1202 if (validatedParams.effectMode == availableEffectModes.data.u8[i]) break;
1203 }
1204 if (i == availableEffectModes.count) {
1205 ALOGE("%s: Requested effect mode \"%s\" is not supported",
1206 __FUNCTION__,
1207 newParams.get(CameraParameters::KEY_EFFECT) );
1208 return BAD_VALUE;
1209 }
1210 }
1211
1212 // ANTIBANDING
1213 validatedParams.antibandingMode = abModeStringToEnum(
1214 newParams.get(CameraParameters::KEY_ANTIBANDING) );
1215 if (validatedParams.antibandingMode != antibandingMode) {
1216 camera_metadata_ro_entry_t availableAbModes =
1217 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES);
1218 for (i = 0; i < availableAbModes.count; i++) {
1219 if (validatedParams.antibandingMode == availableAbModes.data.u8[i])
1220 break;
1221 }
1222 if (i == availableAbModes.count) {
1223 ALOGE("%s: Requested antibanding mode \"%s\" is not supported",
1224 __FUNCTION__,
1225 newParams.get(CameraParameters::KEY_ANTIBANDING));
1226 return BAD_VALUE;
1227 }
1228 }
1229
1230 // SCENE_MODE
1231 validatedParams.sceneMode = sceneModeStringToEnum(
1232 newParams.get(CameraParameters::KEY_SCENE_MODE) );
1233 if (validatedParams.sceneMode != sceneMode &&
1234 validatedParams.sceneMode !=
1235 ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED) {
1236 camera_metadata_ro_entry_t availableSceneModes =
1237 staticInfo(ANDROID_CONTROL_AVAILABLE_SCENE_MODES);
1238 for (i = 0; i < availableSceneModes.count; i++) {
1239 if (validatedParams.sceneMode == availableSceneModes.data.u8[i])
1240 break;
1241 }
1242 if (i == availableSceneModes.count) {
1243 ALOGE("%s: Requested scene mode \"%s\" is not supported",
1244 __FUNCTION__,
1245 newParams.get(CameraParameters::KEY_SCENE_MODE));
1246 return BAD_VALUE;
1247 }
1248 }
Eino-Ville Talvalac85f8262012-10-02 13:30:04 -0700[diff] [blame]1249 bool sceneModeSet =
1250 validatedParams.sceneMode != ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1251
1252 // FLASH_MODE
Eino-Ville Talvalac85f8262012-10-02 13:30:04 -0700[diff] [blame]1253 if (sceneModeSet) {
1254 validatedParams.flashMode =
1255 fastInfo.sceneModeOverrides.
1256 valueFor(validatedParams.sceneMode).flashMode;
1257 } else {
1258 validatedParams.flashMode = FLASH_MODE_INVALID;
1259 }
1260 if (validatedParams.flashMode == FLASH_MODE_INVALID) {
1261 validatedParams.flashMode = flashModeStringToEnum(
1262 newParams.get(CameraParameters::KEY_FLASH_MODE) );
1263 }
1264
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1265 if (validatedParams.flashMode != flashMode) {
1266 camera_metadata_ro_entry_t flashAvailable =
1267 staticInfo(ANDROID_FLASH_AVAILABLE, 1, 1);
1268 if (!flashAvailable.data.u8[0] &&
1269 validatedParams.flashMode != Parameters::FLASH_MODE_OFF) {
1270 ALOGE("%s: Requested flash mode \"%s\" is not supported: "
1271 "No flash on device", __FUNCTION__,
1272 newParams.get(CameraParameters::KEY_FLASH_MODE));
1273 return BAD_VALUE;
1274 } else if (validatedParams.flashMode == Parameters::FLASH_MODE_RED_EYE) {
1275 camera_metadata_ro_entry_t availableAeModes =
1276 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_MODES);
1277 for (i = 0; i < availableAeModes.count; i++) {
1278 if (validatedParams.flashMode == availableAeModes.data.u8[i])
1279 break;
1280 }
1281 if (i == availableAeModes.count) {
1282 ALOGE("%s: Requested flash mode \"%s\" is not supported",
1283 __FUNCTION__,
1284 newParams.get(CameraParameters::KEY_FLASH_MODE));
1285 return BAD_VALUE;
1286 }
1287 } else if (validatedParams.flashMode == -1) {
1288 ALOGE("%s: Requested flash mode \"%s\" is unknown",
1289 __FUNCTION__,
1290 newParams.get(CameraParameters::KEY_FLASH_MODE));
1291 return BAD_VALUE;
1292 }
Eino-Ville Talvalac85f8262012-10-02 13:30:04 -0700[diff] [blame]1293 // Update in case of override
1294 newParams.set(CameraParameters::KEY_FLASH_MODE,
1295 flashModeEnumToString(validatedParams.flashMode));
1296 }
1297
1298 // WHITE_BALANCE
1299 if (sceneModeSet) {
1300 validatedParams.wbMode =
1301 fastInfo.sceneModeOverrides.
1302 valueFor(validatedParams.sceneMode).wbMode;
1303 } else {
1304 validatedParams.wbMode = ANDROID_CONTROL_AWB_OFF;
1305 }
1306 if (validatedParams.wbMode == ANDROID_CONTROL_AWB_OFF) {
1307 validatedParams.wbMode = wbModeStringToEnum(
1308 newParams.get(CameraParameters::KEY_WHITE_BALANCE) );
1309 }
1310 if (validatedParams.wbMode != wbMode) {
1311 camera_metadata_ro_entry_t availableWbModes =
1312 staticInfo(ANDROID_CONTROL_AWB_AVAILABLE_MODES);
1313 for (i = 0; i < availableWbModes.count; i++) {
1314 if (validatedParams.wbMode == availableWbModes.data.u8[i]) break;
1315 }
1316 if (i == availableWbModes.count) {
1317 ALOGE("%s: Requested white balance mode %s is not supported",
1318 __FUNCTION__,
1319 newParams.get(CameraParameters::KEY_WHITE_BALANCE));
1320 return BAD_VALUE;
1321 }
1322 // Update in case of override
1323 newParams.set(CameraParameters::KEY_WHITE_BALANCE,
1324 wbModeEnumToString(validatedParams.wbMode));
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1325 }
1326
1327 // FOCUS_MODE
Eino-Ville Talvalac85f8262012-10-02 13:30:04 -0700[diff] [blame]1328 if (sceneModeSet) {
1329 validatedParams.focusMode =
1330 fastInfo.sceneModeOverrides.
1331 valueFor(validatedParams.sceneMode).focusMode;
1332 } else {
1333 validatedParams.focusMode = FOCUS_MODE_INVALID;
1334 }
1335 if (validatedParams.focusMode == FOCUS_MODE_INVALID) {
1336 validatedParams.focusMode = focusModeStringToEnum(
1337 newParams.get(CameraParameters::KEY_FOCUS_MODE) );
1338 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1339 if (validatedParams.focusMode != focusMode) {
1340 validatedParams.currentAfTriggerId = -1;
1341 if (validatedParams.focusMode != Parameters::FOCUS_MODE_FIXED) {
1342 camera_metadata_ro_entry_t minFocusDistance =
1343 staticInfo(ANDROID_LENS_MINIMUM_FOCUS_DISTANCE);
1344 if (minFocusDistance.data.f[0] == 0) {
1345 ALOGE("%s: Requested focus mode \"%s\" is not available: "
1346 "fixed focus lens",
1347 __FUNCTION__,
1348 newParams.get(CameraParameters::KEY_FOCUS_MODE));
1349 return BAD_VALUE;
1350 } else if (validatedParams.focusMode !=
1351 Parameters::FOCUS_MODE_INFINITY) {
1352 camera_metadata_ro_entry_t availableFocusModes =
1353 staticInfo(ANDROID_CONTROL_AF_AVAILABLE_MODES);
1354 for (i = 0; i < availableFocusModes.count; i++) {
1355 if (validatedParams.focusMode ==
1356 availableFocusModes.data.u8[i]) break;
1357 }
1358 if (i == availableFocusModes.count) {
1359 ALOGE("%s: Requested focus mode \"%s\" is not supported",
1360 __FUNCTION__,
1361 newParams.get(CameraParameters::KEY_FOCUS_MODE));
1362 return BAD_VALUE;
1363 }
1364 }
1365 }
Eino-Ville Talvalac85f8262012-10-02 13:30:04 -0700[diff] [blame]1366 // Update in case of override
1367 newParams.set(CameraParameters::KEY_FOCUS_MODE,
1368 focusModeEnumToString(validatedParams.focusMode));
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1369 } else {
1370 validatedParams.currentAfTriggerId = currentAfTriggerId;
1371 }
1372
1373 // FOCUS_AREAS
1374 res = parseAreas(newParams.get(CameraParameters::KEY_FOCUS_AREAS),
1375 &validatedParams.focusingAreas);
1376 size_t max3aRegions =
1377 (size_t)staticInfo(ANDROID_CONTROL_MAX_REGIONS, 1, 1).data.i32[0];
1378 if (res == OK) res = validateAreas(validatedParams.focusingAreas,
1379 max3aRegions);
1380 if (res != OK) {
1381 ALOGE("%s: Requested focus areas are malformed: %s",
1382 __FUNCTION__, newParams.get(CameraParameters::KEY_FOCUS_AREAS));
1383 return BAD_VALUE;
1384 }
1385
1386 // EXPOSURE_COMPENSATION
1387 validatedParams.exposureCompensation =
1388 newParams.getInt(CameraParameters::KEY_EXPOSURE_COMPENSATION);
1389 camera_metadata_ro_entry_t exposureCompensationRange =
1390 staticInfo(ANDROID_CONTROL_AE_EXP_COMPENSATION_RANGE);
1391 if ((validatedParams.exposureCompensation <
1392 exposureCompensationRange.data.i32[0]) ||
1393 (validatedParams.exposureCompensation >
1394 exposureCompensationRange.data.i32[1])) {
1395 ALOGE("%s: Requested exposure compensation index is out of bounds: %d",
1396 __FUNCTION__, validatedParams.exposureCompensation);
1397 return BAD_VALUE;
1398 }
1399
1400 // AUTO_EXPOSURE_LOCK (always supported)
1401 validatedParams.autoExposureLock = boolFromString(
1402 newParams.get(CameraParameters::KEY_AUTO_EXPOSURE_LOCK));
1403
1404 // AUTO_WHITEBALANCE_LOCK (always supported)
1405 validatedParams.autoWhiteBalanceLock = boolFromString(
1406 newParams.get(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK));
1407
1408 // METERING_AREAS
1409 res = parseAreas(newParams.get(CameraParameters::KEY_METERING_AREAS),
1410 &validatedParams.meteringAreas);
1411 if (res == OK) {
1412 res = validateAreas(validatedParams.meteringAreas, max3aRegions);
1413 }
1414 if (res != OK) {
1415 ALOGE("%s: Requested metering areas are malformed: %s",
1416 __FUNCTION__,
1417 newParams.get(CameraParameters::KEY_METERING_AREAS));
1418 return BAD_VALUE;
1419 }
1420
1421 // ZOOM
1422 validatedParams.zoom = newParams.getInt(CameraParameters::KEY_ZOOM);
1423 if (validatedParams.zoom < 0 || validatedParams.zoom > (int)NUM_ZOOM_STEPS) {
1424 ALOGE("%s: Requested zoom level %d is not supported",
1425 __FUNCTION__, validatedParams.zoom);
1426 return BAD_VALUE;
1427 }
1428
1429 // VIDEO_SIZE
1430 newParams.getVideoSize(&validatedParams.videoWidth,
1431 &validatedParams.videoHeight);
1432 if (validatedParams.videoWidth != videoWidth ||
1433 validatedParams.videoHeight != videoHeight) {
1434 if (state == RECORD) {
1435 ALOGE("%s: Video size cannot be updated when recording is active!",
1436 __FUNCTION__);
1437 return BAD_VALUE;
1438 }
1439 camera_metadata_ro_entry_t availableVideoSizes =
1440 staticInfo(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES);
1441 for (i = 0; i < availableVideoSizes.count; i += 2 ) {
1442 if ((availableVideoSizes.data.i32[i] ==
1443 validatedParams.videoWidth) &&
1444 (availableVideoSizes.data.i32[i+1] ==
1445 validatedParams.videoHeight)) break;
1446 }
1447 if (i == availableVideoSizes.count) {
1448 ALOGE("%s: Requested video size %d x %d is not supported",
1449 __FUNCTION__, validatedParams.videoWidth,
1450 validatedParams.videoHeight);
1451 return BAD_VALUE;
1452 }
1453 }
1454
1455 // RECORDING_HINT (always supported)
1456 validatedParams.recordingHint = boolFromString(
1457 newParams.get(CameraParameters::KEY_RECORDING_HINT) );
1458
1459 // VIDEO_STABILIZATION
1460 validatedParams.videoStabilization = boolFromString(
1461 newParams.get(CameraParameters::KEY_VIDEO_STABILIZATION) );
1462 camera_metadata_ro_entry_t availableVideoStabilizationModes =
1463 staticInfo(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES);
1464 if (validatedParams.videoStabilization &&
1465 availableVideoStabilizationModes.count == 1) {
1466 ALOGE("%s: Video stabilization not supported", __FUNCTION__);
1467 }
1468
1469 /** Update internal parameters */
1470
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1471 *this = validatedParams;
1472
Eino-Ville Talvalac85f8262012-10-02 13:30:04 -0700[diff] [blame]1473 // Need to flatten again in case of overrides
1474 paramsFlattened = newParams.flatten();
1475 params = newParams;
1476
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1477 return OK;
1478}
1479
Eino-Ville Talvala69230df2012-08-29 17:37:16 -0700[diff] [blame]1480status_t Parameters::updateRequest(CameraMetadata *request) const {
1481 ATRACE_CALL();
1482 status_t res;
1483
1484 uint8_t metadataMode = ANDROID_REQUEST_METADATA_FULL;
1485 res = request->update(ANDROID_REQUEST_METADATA_MODE,
1486 &metadataMode, 1);
1487 if (res != OK) return res;
1488
1489 res = request->update(ANDROID_CONTROL_AE_TARGET_FPS_RANGE,
1490 previewFpsRange, 2);
1491 if (res != OK) return res;
1492
Eino-Ville Talvala2d6a5032012-09-03 10:03:26 -0700[diff] [blame]1493 uint8_t reqWbLock = autoWhiteBalanceLock ?
1494 ANDROID_CONTROL_AWB_LOCK_ON : ANDROID_CONTROL_AWB_LOCK_OFF;
1495 res = request->update(ANDROID_CONTROL_AWB_LOCK,
1496 &reqWbLock, 1);
1497
Eino-Ville Talvala69230df2012-08-29 17:37:16 -0700[diff] [blame]1498 res = request->update(ANDROID_CONTROL_EFFECT_MODE,
1499 &effectMode, 1);
1500 if (res != OK) return res;
1501 res = request->update(ANDROID_CONTROL_AE_ANTIBANDING_MODE,
1502 &antibandingMode, 1);
1503 if (res != OK) return res;
1504
Eino-Ville Talvala2a88b712012-09-07 14:26:29 -0700[diff] [blame]1505 // android.hardware.Camera requires that when face detect is enabled, the
1506 // camera is in a face-priority mode. HAL2 splits this into separate parts
1507 // (face detection statistics and face priority scene mode). Map from other
1508 // to the other.
Eino-Ville Talvalac85f8262012-10-02 13:30:04 -0700[diff] [blame]1509 bool sceneModeActive =
1510 sceneMode != (uint8_t)ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED;
Eino-Ville Talvala2a88b712012-09-07 14:26:29 -0700[diff] [blame]1511 uint8_t reqControlMode = ANDROID_CONTROL_AUTO;
Eino-Ville Talvalac85f8262012-10-02 13:30:04 -0700[diff] [blame]1512 if (enableFaceDetect || sceneModeActive) {
Eino-Ville Talvala2a88b712012-09-07 14:26:29 -0700[diff] [blame]1513 reqControlMode = ANDROID_CONTROL_USE_SCENE_MODE;
1514 }
Eino-Ville Talvala69230df2012-08-29 17:37:16 -0700[diff] [blame]1515 res = request->update(ANDROID_CONTROL_MODE,
1516 &reqControlMode, 1);
1517 if (res != OK) return res;
Eino-Ville Talvala2a88b712012-09-07 14:26:29 -0700[diff] [blame]1518
Eino-Ville Talvala063886e2012-09-17 16:43:14 -0700[diff] [blame]1519 uint8_t reqSceneMode =
Eino-Ville Talvalac85f8262012-10-02 13:30:04 -0700[diff] [blame]1520 sceneModeActive ? sceneMode :
Eino-Ville Talvala063886e2012-09-17 16:43:14 -0700[diff] [blame]1521 enableFaceDetect ? (uint8_t)ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY :
1522 (uint8_t)ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED;
Eino-Ville Talvala2a88b712012-09-07 14:26:29 -0700[diff] [blame]1523 res = request->update(ANDROID_CONTROL_SCENE_MODE,
1524 &reqSceneMode, 1);
1525 if (res != OK) return res;
Eino-Ville Talvala69230df2012-08-29 17:37:16 -0700[diff] [blame]1526
1527 uint8_t reqFlashMode = ANDROID_FLASH_OFF;
Eino-Ville Talvalac85f8262012-10-02 13:30:04 -0700[diff] [blame]1528 uint8_t reqAeMode = ANDROID_CONTROL_AE_OFF;
Eino-Ville Talvala69230df2012-08-29 17:37:16 -0700[diff] [blame]1529 switch (flashMode) {
1530 case Parameters::FLASH_MODE_OFF:
1531 reqAeMode = ANDROID_CONTROL_AE_ON; break;
1532 case Parameters::FLASH_MODE_AUTO:
1533 reqAeMode = ANDROID_CONTROL_AE_ON_AUTO_FLASH; break;
1534 case Parameters::FLASH_MODE_ON:
1535 reqAeMode = ANDROID_CONTROL_AE_ON_ALWAYS_FLASH; break;
1536 case Parameters::FLASH_MODE_TORCH:
1537 reqAeMode = ANDROID_CONTROL_AE_ON;
1538 reqFlashMode = ANDROID_FLASH_TORCH;
1539 break;
1540 case Parameters::FLASH_MODE_RED_EYE:
1541 reqAeMode = ANDROID_CONTROL_AE_ON_AUTO_FLASH_REDEYE; break;
1542 default:
1543 ALOGE("%s: Camera %d: Unknown flash mode %d", __FUNCTION__,
1544 cameraId, flashMode);
Eino-Ville Talvalac85f8262012-10-02 13:30:04 -0700[diff] [blame]1545 return BAD_VALUE;
Eino-Ville Talvala69230df2012-08-29 17:37:16 -0700[diff] [blame]1546 }
Eino-Ville Talvala69230df2012-08-29 17:37:16 -0700[diff] [blame]1547 res = request->update(ANDROID_FLASH_MODE,
1548 &reqFlashMode, 1);
1549 if (res != OK) return res;
1550 res = request->update(ANDROID_CONTROL_AE_MODE,
1551 &reqAeMode, 1);
1552 if (res != OK) return res;
1553
Eino-Ville Talvala2d6a5032012-09-03 10:03:26 -0700[diff] [blame]1554 uint8_t reqAeLock = autoExposureLock ?
1555 ANDROID_CONTROL_AE_LOCK_ON : ANDROID_CONTROL_AE_LOCK_OFF;
1556 res = request->update(ANDROID_CONTROL_AE_LOCK,
1557 &reqAeLock, 1);
Eino-Ville Talvalac85f8262012-10-02 13:30:04 -0700[diff] [blame]1558 if (res != OK) return res;
1559
1560 res = request->update(ANDROID_CONTROL_AWB_MODE,
1561 &wbMode, 1);
1562 if (res != OK) return res;
Eino-Ville Talvala2d6a5032012-09-03 10:03:26 -0700[diff] [blame]1563
Eino-Ville Talvala69230df2012-08-29 17:37:16 -0700[diff] [blame]1564 float reqFocusDistance = 0; // infinity focus in diopters
Eino-Ville Talvalac85f8262012-10-02 13:30:04 -0700[diff] [blame]1565 uint8_t reqFocusMode = ANDROID_CONTROL_AF_OFF;
Eino-Ville Talvala69230df2012-08-29 17:37:16 -0700[diff] [blame]1566 switch (focusMode) {
1567 case Parameters::FOCUS_MODE_AUTO:
1568 case Parameters::FOCUS_MODE_MACRO:
1569 case Parameters::FOCUS_MODE_CONTINUOUS_VIDEO:
1570 case Parameters::FOCUS_MODE_CONTINUOUS_PICTURE:
1571 case Parameters::FOCUS_MODE_EDOF:
1572 reqFocusMode = focusMode;
1573 break;
1574 case Parameters::FOCUS_MODE_INFINITY:
1575 case Parameters::FOCUS_MODE_FIXED:
1576 reqFocusMode = ANDROID_CONTROL_AF_OFF;
1577 break;
1578 default:
Eino-Ville Talvalac85f8262012-10-02 13:30:04 -0700[diff] [blame]1579 ALOGE("%s: Camera %d: Unknown focus mode %d", __FUNCTION__,
1580 cameraId, focusMode);
1581 return BAD_VALUE;
Eino-Ville Talvala69230df2012-08-29 17:37:16 -0700[diff] [blame]1582 }
1583 res = request->update(ANDROID_LENS_FOCUS_DISTANCE,
1584 &reqFocusDistance, 1);
1585 if (res != OK) return res;
1586 res = request->update(ANDROID_CONTROL_AF_MODE,
1587 &reqFocusMode, 1);
1588 if (res != OK) return res;
1589
1590 size_t reqFocusingAreasSize = focusingAreas.size() * 5;
1591 int32_t *reqFocusingAreas = new int32_t[reqFocusingAreasSize];
1592 for (size_t i = 0; i < reqFocusingAreasSize; i += 5) {
1593 if (focusingAreas[i].weight != 0) {
1594 reqFocusingAreas[i + 0] =
1595 normalizedXToArray(focusingAreas[i].left);
1596 reqFocusingAreas[i + 1] =
1597 normalizedYToArray(focusingAreas[i].top);
1598 reqFocusingAreas[i + 2] =
1599 normalizedXToArray(focusingAreas[i].right);
1600 reqFocusingAreas[i + 3] =
1601 normalizedYToArray(focusingAreas[i].bottom);
1602 } else {
1603 reqFocusingAreas[i + 0] = 0;
1604 reqFocusingAreas[i + 1] = 0;
1605 reqFocusingAreas[i + 2] = 0;
1606 reqFocusingAreas[i + 3] = 0;
1607 }
1608 reqFocusingAreas[i + 4] = focusingAreas[i].weight;
1609 }
1610 res = request->update(ANDROID_CONTROL_AF_REGIONS,
1611 reqFocusingAreas, reqFocusingAreasSize);
1612 if (res != OK) return res;
1613 delete[] reqFocusingAreas;
1614
1615 res = request->update(ANDROID_CONTROL_AE_EXP_COMPENSATION,
1616 &exposureCompensation, 1);
1617 if (res != OK) return res;
1618
1619 size_t reqMeteringAreasSize = meteringAreas.size() * 5;
1620 int32_t *reqMeteringAreas = new int32_t[reqMeteringAreasSize];
1621 for (size_t i = 0; i < reqMeteringAreasSize; i += 5) {
1622 if (meteringAreas[i].weight != 0) {
1623 reqMeteringAreas[i + 0] =
1624 normalizedXToArray(meteringAreas[i].left);
1625 reqMeteringAreas[i + 1] =
1626 normalizedYToArray(meteringAreas[i].top);
1627 reqMeteringAreas[i + 2] =
1628 normalizedXToArray(meteringAreas[i].right);
1629 reqMeteringAreas[i + 3] =
1630 normalizedYToArray(meteringAreas[i].bottom);
1631 } else {
1632 reqMeteringAreas[i + 0] = 0;
1633 reqMeteringAreas[i + 1] = 0;
1634 reqMeteringAreas[i + 2] = 0;
1635 reqMeteringAreas[i + 3] = 0;
1636 }
1637 reqMeteringAreas[i + 4] = meteringAreas[i].weight;
1638 }
1639 res = request->update(ANDROID_CONTROL_AE_REGIONS,
1640 reqMeteringAreas, reqMeteringAreasSize);
1641 if (res != OK) return res;
1642
1643 res = request->update(ANDROID_CONTROL_AWB_REGIONS,
1644 reqMeteringAreas, reqMeteringAreasSize);
1645 if (res != OK) return res;
1646 delete[] reqMeteringAreas;
1647
Igor Murashkine500bc22012-09-18 18:23:49 -0700[diff] [blame]1648 CropRegion crop = calculateCropRegion();
1649 int32_t reqCropRegion[3] = { crop.left, crop.top, crop.width };
Eino-Ville Talvala69230df2012-08-29 17:37:16 -0700[diff] [blame]1650 res = request->update(ANDROID_SCALER_CROP_REGION,
1651 reqCropRegion, 3);
1652 if (res != OK) return res;
1653
Eino-Ville Talvala69230df2012-08-29 17:37:16 -0700[diff] [blame]1654 uint8_t reqVstabMode = videoStabilization ?
1655 ANDROID_CONTROL_VIDEO_STABILIZATION_ON :
1656 ANDROID_CONTROL_VIDEO_STABILIZATION_OFF;
1657 res = request->update(ANDROID_CONTROL_VIDEO_STABILIZATION_MODE,
1658 &reqVstabMode, 1);
1659 if (res != OK) return res;
1660
1661 uint8_t reqFaceDetectMode = enableFaceDetect ?
1662 fastInfo.bestFaceDetectMode :
1663 (uint8_t)ANDROID_STATS_FACE_DETECTION_OFF;
1664 res = request->update(ANDROID_STATS_FACE_DETECT_MODE,
1665 &reqFaceDetectMode, 1);
1666 if (res != OK) return res;
1667
1668 return OK;
1669}
1670
Eino-Ville Talvaladb30e682012-10-04 13:21:08 -0700[diff] [blame]1671status_t Parameters::updateRequestJpeg(CameraMetadata *request) const {
1672 status_t res;
1673
1674 res = request->update(ANDROID_JPEG_THUMBNAIL_SIZE,
1675 jpegThumbSize, 2);
1676 if (res != OK) return res;
1677 res = request->update(ANDROID_JPEG_THUMBNAIL_QUALITY,
1678 &jpegThumbQuality, 1);
1679 if (res != OK) return res;
1680 res = request->update(ANDROID_JPEG_QUALITY,
1681 &jpegQuality, 1);
1682 if (res != OK) return res;
1683 res = request->update(
1684 ANDROID_JPEG_ORIENTATION,
1685 &jpegRotation, 1);
1686 if (res != OK) return res;
1687
1688 if (gpsEnabled) {
1689 res = request->update(
1690 ANDROID_JPEG_GPS_COORDINATES,
1691 gpsCoordinates, 3);
1692 if (res != OK) return res;
1693 res = request->update(
1694 ANDROID_JPEG_GPS_TIMESTAMP,
1695 &gpsTimestamp, 1);
1696 if (res != OK) return res;
1697 res = request->update(
1698 ANDROID_JPEG_GPS_PROCESSING_METHOD,
1699 gpsProcessingMethod);
1700 if (res != OK) return res;
1701 } else {
1702 res = request->erase(ANDROID_JPEG_GPS_COORDINATES);
1703 if (res != OK) return res;
1704 res = request->erase(ANDROID_JPEG_GPS_TIMESTAMP);
1705 if (res != OK) return res;
1706 res = request->erase(ANDROID_JPEG_GPS_PROCESSING_METHOD);
1707 if (res != OK) return res;
1708 }
1709 return OK;
1710}
1711
1712
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1713const char* Parameters::getStateName(State state) {
1714#define CASE_ENUM_TO_CHAR(x) case x: return(#x); break;
1715 switch(state) {
1716 CASE_ENUM_TO_CHAR(DISCONNECTED)
1717 CASE_ENUM_TO_CHAR(STOPPED)
1718 CASE_ENUM_TO_CHAR(WAITING_FOR_PREVIEW_WINDOW)
1719 CASE_ENUM_TO_CHAR(PREVIEW)
1720 CASE_ENUM_TO_CHAR(RECORD)
1721 CASE_ENUM_TO_CHAR(STILL_CAPTURE)
1722 CASE_ENUM_TO_CHAR(VIDEO_SNAPSHOT)
1723 default:
1724 return "Unknown state!";
1725 break;
1726 }
1727#undef CASE_ENUM_TO_CHAR
1728}
1729
1730int Parameters::formatStringToEnum(const char *format) {
1731 return
Eino-Ville Talvala4c6b0b82012-09-10 09:53:09 -0700[diff] [blame]1732 !format ?
1733 HAL_PIXEL_FORMAT_YCrCb_420_SP :
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1734 !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV422SP) ?
1735 HAL_PIXEL_FORMAT_YCbCr_422_SP : // NV16
1736 !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV420SP) ?
1737 HAL_PIXEL_FORMAT_YCrCb_420_SP : // NV21
1738 !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV422I) ?
1739 HAL_PIXEL_FORMAT_YCbCr_422_I : // YUY2
1740 !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV420P) ?
1741 HAL_PIXEL_FORMAT_YV12 : // YV12
1742 !strcmp(format, CameraParameters::PIXEL_FORMAT_RGB565) ?
1743 HAL_PIXEL_FORMAT_RGB_565 : // RGB565
1744 !strcmp(format, CameraParameters::PIXEL_FORMAT_RGBA8888) ?
1745 HAL_PIXEL_FORMAT_RGBA_8888 : // RGB8888
1746 !strcmp(format, CameraParameters::PIXEL_FORMAT_BAYER_RGGB) ?
1747 HAL_PIXEL_FORMAT_RAW_SENSOR : // Raw sensor data
1748 -1;
1749}
1750
1751const char* Parameters::formatEnumToString(int format) {
1752 const char *fmt;
1753 switch(format) {
1754 case HAL_PIXEL_FORMAT_YCbCr_422_SP: // NV16
1755 fmt = CameraParameters::PIXEL_FORMAT_YUV422SP;
1756 break;
1757 case HAL_PIXEL_FORMAT_YCrCb_420_SP: // NV21
1758 fmt = CameraParameters::PIXEL_FORMAT_YUV420SP;
1759 break;
1760 case HAL_PIXEL_FORMAT_YCbCr_422_I: // YUY2
1761 fmt = CameraParameters::PIXEL_FORMAT_YUV422I;
1762 break;
1763 case HAL_PIXEL_FORMAT_YV12: // YV12
1764 fmt = CameraParameters::PIXEL_FORMAT_YUV420P;
1765 break;
1766 case HAL_PIXEL_FORMAT_RGB_565: // RGB565
1767 fmt = CameraParameters::PIXEL_FORMAT_RGB565;
1768 break;
1769 case HAL_PIXEL_FORMAT_RGBA_8888: // RGBA8888
1770 fmt = CameraParameters::PIXEL_FORMAT_RGBA8888;
1771 break;
1772 case HAL_PIXEL_FORMAT_RAW_SENSOR:
1773 ALOGW("Raw sensor preview format requested.");
1774 fmt = CameraParameters::PIXEL_FORMAT_BAYER_RGGB;
1775 break;
1776 default:
1777 ALOGE("%s: Unknown preview format: %x",
1778 __FUNCTION__, format);
1779 fmt = NULL;
1780 break;
1781 }
1782 return fmt;
1783}
1784
1785int Parameters::wbModeStringToEnum(const char *wbMode) {
1786 return
Eino-Ville Talvala4c6b0b82012-09-10 09:53:09 -0700[diff] [blame]1787 !wbMode ?
1788 ANDROID_CONTROL_AWB_AUTO :
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1789 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_AUTO) ?
1790 ANDROID_CONTROL_AWB_AUTO :
1791 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_INCANDESCENT) ?
1792 ANDROID_CONTROL_AWB_INCANDESCENT :
1793 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_FLUORESCENT) ?
1794 ANDROID_CONTROL_AWB_FLUORESCENT :
1795 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_WARM_FLUORESCENT) ?
1796 ANDROID_CONTROL_AWB_WARM_FLUORESCENT :
1797 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_DAYLIGHT) ?
1798 ANDROID_CONTROL_AWB_DAYLIGHT :
1799 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT) ?
1800 ANDROID_CONTROL_AWB_CLOUDY_DAYLIGHT :
1801 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_TWILIGHT) ?
1802 ANDROID_CONTROL_AWB_TWILIGHT :
1803 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_SHADE) ?
1804 ANDROID_CONTROL_AWB_SHADE :
1805 -1;
1806}
1807
Eino-Ville Talvalac85f8262012-10-02 13:30:04 -0700[diff] [blame]1808const char* Parameters::wbModeEnumToString(uint8_t wbMode) {
1809 switch (wbMode) {
1810 case ANDROID_CONTROL_AWB_AUTO:
1811 return CameraParameters::WHITE_BALANCE_AUTO;
1812 case ANDROID_CONTROL_AWB_INCANDESCENT:
1813 return CameraParameters::WHITE_BALANCE_INCANDESCENT;
1814 case ANDROID_CONTROL_AWB_FLUORESCENT:
1815 return CameraParameters::WHITE_BALANCE_FLUORESCENT;
1816 case ANDROID_CONTROL_AWB_WARM_FLUORESCENT:
1817 return CameraParameters::WHITE_BALANCE_WARM_FLUORESCENT;
1818 case ANDROID_CONTROL_AWB_DAYLIGHT:
1819 return CameraParameters::WHITE_BALANCE_DAYLIGHT;
1820 case ANDROID_CONTROL_AWB_CLOUDY_DAYLIGHT:
1821 return CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT;
1822 case ANDROID_CONTROL_AWB_TWILIGHT:
1823 return CameraParameters::WHITE_BALANCE_TWILIGHT;
1824 case ANDROID_CONTROL_AWB_SHADE:
1825 return CameraParameters::WHITE_BALANCE_SHADE;
1826 default:
1827 ALOGE("%s: Unknown AWB mode enum: %d",
1828 __FUNCTION__, wbMode);
1829 return "unknown";
1830 }
1831}
1832
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1833int Parameters::effectModeStringToEnum(const char *effectMode) {
1834 return
Eino-Ville Talvala4c6b0b82012-09-10 09:53:09 -0700[diff] [blame]1835 !effectMode ?
1836 ANDROID_CONTROL_EFFECT_OFF :
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1837 !strcmp(effectMode, CameraParameters::EFFECT_NONE) ?
1838 ANDROID_CONTROL_EFFECT_OFF :
1839 !strcmp(effectMode, CameraParameters::EFFECT_MONO) ?
1840 ANDROID_CONTROL_EFFECT_MONO :
1841 !strcmp(effectMode, CameraParameters::EFFECT_NEGATIVE) ?
1842 ANDROID_CONTROL_EFFECT_NEGATIVE :
1843 !strcmp(effectMode, CameraParameters::EFFECT_SOLARIZE) ?
1844 ANDROID_CONTROL_EFFECT_SOLARIZE :
1845 !strcmp(effectMode, CameraParameters::EFFECT_SEPIA) ?
1846 ANDROID_CONTROL_EFFECT_SEPIA :
1847 !strcmp(effectMode, CameraParameters::EFFECT_POSTERIZE) ?
1848 ANDROID_CONTROL_EFFECT_POSTERIZE :
1849 !strcmp(effectMode, CameraParameters::EFFECT_WHITEBOARD) ?
1850 ANDROID_CONTROL_EFFECT_WHITEBOARD :
1851 !strcmp(effectMode, CameraParameters::EFFECT_BLACKBOARD) ?
1852 ANDROID_CONTROL_EFFECT_BLACKBOARD :
1853 !strcmp(effectMode, CameraParameters::EFFECT_AQUA) ?
1854 ANDROID_CONTROL_EFFECT_AQUA :
1855 -1;
1856}
1857
1858int Parameters::abModeStringToEnum(const char *abMode) {
1859 return
Eino-Ville Talvala4c6b0b82012-09-10 09:53:09 -0700[diff] [blame]1860 !abMode ?
1861 ANDROID_CONTROL_AE_ANTIBANDING_AUTO :
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1862 !strcmp(abMode, CameraParameters::ANTIBANDING_AUTO) ?
1863 ANDROID_CONTROL_AE_ANTIBANDING_AUTO :
1864 !strcmp(abMode, CameraParameters::ANTIBANDING_OFF) ?
1865 ANDROID_CONTROL_AE_ANTIBANDING_OFF :
1866 !strcmp(abMode, CameraParameters::ANTIBANDING_50HZ) ?
1867 ANDROID_CONTROL_AE_ANTIBANDING_50HZ :
1868 !strcmp(abMode, CameraParameters::ANTIBANDING_60HZ) ?
1869 ANDROID_CONTROL_AE_ANTIBANDING_60HZ :
1870 -1;
1871}
1872
1873int Parameters::sceneModeStringToEnum(const char *sceneMode) {
1874 return
Eino-Ville Talvala4c6b0b82012-09-10 09:53:09 -0700[diff] [blame]1875 !sceneMode ?
1876 ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED :
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1877 !strcmp(sceneMode, CameraParameters::SCENE_MODE_AUTO) ?
1878 ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED :
1879 !strcmp(sceneMode, CameraParameters::SCENE_MODE_ACTION) ?
1880 ANDROID_CONTROL_SCENE_MODE_ACTION :
1881 !strcmp(sceneMode, CameraParameters::SCENE_MODE_PORTRAIT) ?
1882 ANDROID_CONTROL_SCENE_MODE_PORTRAIT :
1883 !strcmp(sceneMode, CameraParameters::SCENE_MODE_LANDSCAPE) ?
1884 ANDROID_CONTROL_SCENE_MODE_LANDSCAPE :
1885 !strcmp(sceneMode, CameraParameters::SCENE_MODE_NIGHT) ?
1886 ANDROID_CONTROL_SCENE_MODE_NIGHT :
1887 !strcmp(sceneMode, CameraParameters::SCENE_MODE_NIGHT_PORTRAIT) ?
1888 ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT :
1889 !strcmp(sceneMode, CameraParameters::SCENE_MODE_THEATRE) ?
1890 ANDROID_CONTROL_SCENE_MODE_THEATRE :
1891 !strcmp(sceneMode, CameraParameters::SCENE_MODE_BEACH) ?
1892 ANDROID_CONTROL_SCENE_MODE_BEACH :
1893 !strcmp(sceneMode, CameraParameters::SCENE_MODE_SNOW) ?
1894 ANDROID_CONTROL_SCENE_MODE_SNOW :
1895 !strcmp(sceneMode, CameraParameters::SCENE_MODE_SUNSET) ?
1896 ANDROID_CONTROL_SCENE_MODE_SUNSET :
1897 !strcmp(sceneMode, CameraParameters::SCENE_MODE_STEADYPHOTO) ?
1898 ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO :
1899 !strcmp(sceneMode, CameraParameters::SCENE_MODE_FIREWORKS) ?
1900 ANDROID_CONTROL_SCENE_MODE_FIREWORKS :
1901 !strcmp(sceneMode, CameraParameters::SCENE_MODE_SPORTS) ?
1902 ANDROID_CONTROL_SCENE_MODE_SPORTS :
1903 !strcmp(sceneMode, CameraParameters::SCENE_MODE_PARTY) ?
1904 ANDROID_CONTROL_SCENE_MODE_PARTY :
1905 !strcmp(sceneMode, CameraParameters::SCENE_MODE_CANDLELIGHT) ?
1906 ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT :
1907 !strcmp(sceneMode, CameraParameters::SCENE_MODE_BARCODE) ?
1908 ANDROID_CONTROL_SCENE_MODE_BARCODE:
1909 -1;
1910}
1911
1912Parameters::Parameters::flashMode_t Parameters::flashModeStringToEnum(
1913 const char *flashMode) {
1914 return
Eino-Ville Talvala4c6b0b82012-09-10 09:53:09 -0700[diff] [blame]1915 !flashMode ?
1916 Parameters::FLASH_MODE_INVALID :
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1917 !strcmp(flashMode, CameraParameters::FLASH_MODE_OFF) ?
1918 Parameters::FLASH_MODE_OFF :
1919 !strcmp(flashMode, CameraParameters::FLASH_MODE_AUTO) ?
1920 Parameters::FLASH_MODE_AUTO :
1921 !strcmp(flashMode, CameraParameters::FLASH_MODE_ON) ?
1922 Parameters::FLASH_MODE_ON :
1923 !strcmp(flashMode, CameraParameters::FLASH_MODE_RED_EYE) ?
1924 Parameters::FLASH_MODE_RED_EYE :
1925 !strcmp(flashMode, CameraParameters::FLASH_MODE_TORCH) ?
1926 Parameters::FLASH_MODE_TORCH :
1927 Parameters::FLASH_MODE_INVALID;
1928}
1929
Eino-Ville Talvalac85f8262012-10-02 13:30:04 -0700[diff] [blame]1930const char *Parameters::flashModeEnumToString(flashMode_t flashMode) {
1931 switch (flashMode) {
1932 case FLASH_MODE_OFF:
1933 return CameraParameters::FLASH_MODE_OFF;
1934 case FLASH_MODE_AUTO:
1935 return CameraParameters::FLASH_MODE_AUTO;
1936 case FLASH_MODE_ON:
1937 return CameraParameters::FLASH_MODE_ON;
1938 case FLASH_MODE_RED_EYE:
1939 return CameraParameters::FLASH_MODE_RED_EYE;
1940 case FLASH_MODE_TORCH:
1941 return CameraParameters::FLASH_MODE_TORCH;
1942 default:
1943 ALOGE("%s: Unknown flash mode enum %d",
1944 __FUNCTION__, flashMode);
1945 return "unknown";
1946 }
1947}
1948
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1949Parameters::Parameters::focusMode_t Parameters::focusModeStringToEnum(
1950 const char *focusMode) {
1951 return
Eino-Ville Talvala4c6b0b82012-09-10 09:53:09 -0700[diff] [blame]1952 !focusMode ?
1953 Parameters::FOCUS_MODE_INVALID :
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1954 !strcmp(focusMode, CameraParameters::FOCUS_MODE_AUTO) ?
1955 Parameters::FOCUS_MODE_AUTO :
1956 !strcmp(focusMode, CameraParameters::FOCUS_MODE_INFINITY) ?
1957 Parameters::FOCUS_MODE_INFINITY :
1958 !strcmp(focusMode, CameraParameters::FOCUS_MODE_MACRO) ?
1959 Parameters::FOCUS_MODE_MACRO :
1960 !strcmp(focusMode, CameraParameters::FOCUS_MODE_FIXED) ?
1961 Parameters::FOCUS_MODE_FIXED :
1962 !strcmp(focusMode, CameraParameters::FOCUS_MODE_EDOF) ?
1963 Parameters::FOCUS_MODE_EDOF :
1964 !strcmp(focusMode, CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO) ?
1965 Parameters::FOCUS_MODE_CONTINUOUS_VIDEO :
1966 !strcmp(focusMode, CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE) ?
1967 Parameters::FOCUS_MODE_CONTINUOUS_PICTURE :
1968 Parameters::FOCUS_MODE_INVALID;
1969}
1970
Eino-Ville Talvalac85f8262012-10-02 13:30:04 -0700[diff] [blame]1971const char *Parameters::focusModeEnumToString(focusMode_t focusMode) {
1972 switch (focusMode) {
1973 case FOCUS_MODE_AUTO:
1974 return CameraParameters::FOCUS_MODE_AUTO;
1975 case FOCUS_MODE_MACRO:
1976 return CameraParameters::FOCUS_MODE_MACRO;
1977 case FOCUS_MODE_CONTINUOUS_VIDEO:
1978 return CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO;
1979 case FOCUS_MODE_CONTINUOUS_PICTURE:
1980 return CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE;
1981 case FOCUS_MODE_EDOF:
1982 return CameraParameters::FOCUS_MODE_EDOF;
1983 case FOCUS_MODE_INFINITY:
1984 return CameraParameters::FOCUS_MODE_INFINITY;
1985 case FOCUS_MODE_FIXED:
1986 return CameraParameters::FOCUS_MODE_FIXED;
1987 default:
1988 ALOGE("%s: Unknown focus mode enum: %d",
1989 __FUNCTION__, focusMode);
1990 return "unknown";
1991 }
1992}
1993
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1994status_t Parameters::parseAreas(const char *areasCStr,
1995 Vector<Parameters::Area> *areas) {
1996 static const size_t NUM_FIELDS = 5;
1997 areas->clear();
1998 if (areasCStr == NULL) {
1999 // If no key exists, use default (0,0,0,0,0)
2000 areas->push();
2001 return OK;
2002 }
2003 String8 areasStr(areasCStr);
2004 ssize_t areaStart = areasStr.find("(", 0) + 1;
2005 while (areaStart != 0) {
2006 const char* area = areasStr.string() + areaStart;
2007 char *numEnd;
2008 int vals[NUM_FIELDS];
2009 for (size_t i = 0; i < NUM_FIELDS; i++) {
2010 errno = 0;
2011 vals[i] = strtol(area, &numEnd, 10);
2012 if (errno || numEnd == area) return BAD_VALUE;
2013 area = numEnd + 1;
2014 }
2015 areas->push(Parameters::Area(
2016 vals[0], vals[1], vals[2], vals[3], vals[4]) );
2017 areaStart = areasStr.find("(", areaStart) + 1;
2018 }
2019 return OK;
2020}
2021
2022status_t Parameters::validateAreas(const Vector<Parameters::Area> &areas,
2023 size_t maxRegions) {
2024 // Definition of valid area can be found in
2025 // include/camera/CameraParameters.h
2026 if (areas.size() == 0) return BAD_VALUE;
2027 if (areas.size() == 1) {
2028 if (areas[0].left == 0 &&
2029 areas[0].top == 0 &&
2030 areas[0].right == 0 &&
2031 areas[0].bottom == 0 &&
2032 areas[0].weight == 0) {
2033 // Single (0,0,0,0,0) entry is always valid (== driver decides)
2034 return OK;
2035 }
2036 }
2037 if (areas.size() > maxRegions) {
2038 ALOGE("%s: Too many areas requested: %d",
2039 __FUNCTION__, areas.size());
2040 return BAD_VALUE;
2041 }
2042
2043 for (Vector<Parameters::Area>::const_iterator a = areas.begin();
2044 a != areas.end(); a++) {
2045 if (a->weight < 1 || a->weight > 1000) return BAD_VALUE;
2046 if (a->left < -1000 || a->left > 1000) return BAD_VALUE;
2047 if (a->top < -1000 || a->top > 1000) return BAD_VALUE;
2048 if (a->right < -1000 || a->right > 1000) return BAD_VALUE;
2049 if (a->bottom < -1000 || a->bottom > 1000) return BAD_VALUE;
2050 if (a->left >= a->right) return BAD_VALUE;
2051 if (a->top >= a->bottom) return BAD_VALUE;
2052 }
2053 return OK;
2054}
2055
2056bool Parameters::boolFromString(const char *boolStr) {
2057 return !boolStr ? false :
2058 !strcmp(boolStr, CameraParameters::TRUE) ? true :
2059 false;
2060}
2061
2062int Parameters::degToTransform(int degrees, bool mirror) {
2063 if (!mirror) {
2064 if (degrees == 0) return 0;
2065 else if (degrees == 90) return HAL_TRANSFORM_ROT_90;
2066 else if (degrees == 180) return HAL_TRANSFORM_ROT_180;
2067 else if (degrees == 270) return HAL_TRANSFORM_ROT_270;
2068 } else { // Do mirror (horizontal flip)
2069 if (degrees == 0) { // FLIP_H and ROT_0
2070 return HAL_TRANSFORM_FLIP_H;
2071 } else if (degrees == 90) { // FLIP_H and ROT_90
2072 return HAL_TRANSFORM_FLIP_H | HAL_TRANSFORM_ROT_90;
2073 } else if (degrees == 180) { // FLIP_H and ROT_180
2074 return HAL_TRANSFORM_FLIP_V;
2075 } else if (degrees == 270) { // FLIP_H and ROT_270
2076 return HAL_TRANSFORM_FLIP_V | HAL_TRANSFORM_ROT_90;
2077 }
2078 }
2079 ALOGE("%s: Bad input: %d", __FUNCTION__, degrees);
2080 return -1;
2081}
2082
2083int Parameters::arrayXToNormalized(int width) const {
2084 return width * 2000 / (fastInfo.arrayWidth - 1) - 1000;
2085}
2086
2087int Parameters::arrayYToNormalized(int height) const {
2088 return height * 2000 / (fastInfo.arrayHeight - 1) - 1000;
2089}
2090
2091int Parameters::normalizedXToArray(int x) const {
2092 return (x + 1000) * (fastInfo.arrayWidth - 1) / 2000;
2093}
2094
2095int Parameters::normalizedYToArray(int y) const {
2096 return (y + 1000) * (fastInfo.arrayHeight - 1) / 2000;
2097}
2098
Igor Murashkine500bc22012-09-18 18:23:49 -0700[diff] [blame]2099Parameters::CropRegion Parameters::calculateCropRegion(void) const {
2100
2101 float zoomLeft, zoomTop, zoomWidth, zoomHeight;
2102
2103 // Need to convert zoom index into a crop rectangle. The rectangle is
2104 // chosen to maximize its area on the sensor
2105
2106 camera_metadata_ro_entry_t maxDigitalZoom =
2107 staticInfo(ANDROID_SCALER_AVAILABLE_MAX_ZOOM);
2108 // For each zoom step by how many pixels more do we change the zoom
2109 float zoomIncrement = (maxDigitalZoom.data.f[0] - 1) /
2110 (NUM_ZOOM_STEPS-1);
2111 // The desired activeAreaWidth/cropAreaWidth ratio (or height if h>w)
2112 // via interpolating zoom step into a zoom ratio
2113 float zoomRatio = 1 + zoomIncrement * zoom;
2114 ALOG_ASSERT( (zoomRatio >= 1.f && zoomRatio <= maxDigitalZoom.data.f[0]),
2115 "Zoom ratio calculated out of bounds. Expected 1 - %f, actual: %f",
2116 maxDigitalZoom.data.f[0], zoomRatio);
2117
2118 ALOGV("Zoom maxDigital=%f, increment=%f, ratio=%f, previewWidth=%d, "
2119 "previewHeight=%d, activeWidth=%d, activeHeight=%d",
2120 maxDigitalZoom.data.f[0], zoomIncrement, zoomRatio, previewWidth,
2121 previewHeight, fastInfo.arrayWidth, fastInfo.arrayHeight);
2122
2123 /*
2124 * Assumption: On the HAL side each stream buffer calculates its crop
2125 * rectangle as follows:
2126 * cropRect = (zoomLeft, zoomRight,
2127 * zoomWidth, zoomHeight * zoomWidth / outputWidth);
2128 *
2129 * Note that if zoomWidth > bufferWidth, the new cropHeight > zoomHeight
2130 * (we can then get into trouble if the cropHeight > arrayHeight).
2131 * By selecting the zoomRatio based on the smallest outputRatio, we
2132 * guarantee this will never happen.
2133 */
2134
2135 // Enumerate all possible output sizes, select the one with the smallest
2136 // aspect ratio
2137 float minOutputWidth, minOutputHeight, minOutputRatio;
2138 {
2139 float outputSizes[][2] = {
2140 { previewWidth, previewHeight },
2141 { videoWidth, videoHeight },
2142 /* don't include jpeg thumbnail size - it's valid for
2143 it to be set to (0,0), meaning 'no thumbnail' */
2144 // { jpegThumbSize[0], jpegThumbSize[1] },
2145 { pictureWidth, pictureHeight },
2146 };
2147
2148 minOutputWidth = outputSizes[0][0];
2149 minOutputHeight = outputSizes[0][1];
2150 minOutputRatio = minOutputWidth / minOutputHeight;
2151 for (unsigned int i = 0;
2152 i < sizeof(outputSizes) / sizeof(outputSizes[0]);
2153 ++i) {
2154
2155 float outputWidth = outputSizes[i][0];
2156 float outputHeight = outputSizes[i][1];
2157 float outputRatio = outputWidth / outputHeight;
2158
2159 if (minOutputRatio > outputRatio) {
2160 minOutputRatio = outputRatio;
2161 minOutputWidth = outputWidth;
2162 minOutputHeight = outputHeight;
2163 }
2164
2165 // and then use this output ratio instead of preview output ratio
2166 ALOGV("Enumerating output ratio %f = %f / %f, min is %f",
2167 outputRatio, outputWidth, outputHeight, minOutputRatio);
2168 }
2169 }
2170
2171 /* Ensure that the width/height never go out of bounds
2172 * by scaling across a diffent dimension if an out-of-bounds
2173 * possibility exists.
2174 *
2175 * e.g. if the previewratio < arrayratio and e.g. zoomratio = 1.0, then by
2176 * calculating the zoomWidth from zoomHeight we'll actually get a
2177 * zoomheight > arrayheight
2178 */
2179 float arrayRatio = 1.f * fastInfo.arrayWidth / fastInfo.arrayHeight;
2180 if (minOutputRatio >= arrayRatio) {
2181 // Adjust the height based on the width
2182 zoomWidth = fastInfo.arrayWidth / zoomRatio;
2183 zoomHeight = zoomWidth *
2184 minOutputHeight / minOutputWidth;
2185
2186 } else {
2187 // Adjust the width based on the height
2188 zoomHeight = fastInfo.arrayHeight / zoomRatio;
2189 zoomWidth = zoomHeight *
2190 minOutputWidth / minOutputHeight;
2191 }
2192 // centering the zoom area within the active area
2193 zoomLeft = (fastInfo.arrayWidth - zoomWidth) / 2;
2194 zoomTop = (fastInfo.arrayHeight - zoomHeight) / 2;
2195
2196 ALOGV("Crop region calculated (x=%d,y=%d,w=%f,h=%f) for zoom=%d",
2197 (int32_t)zoomLeft, (int32_t)zoomTop, zoomWidth, zoomHeight, this->zoom);
2198
2199
2200 CropRegion crop = { zoomLeft, zoomTop, zoomWidth, zoomHeight };
2201 return crop;
2202}
2203
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]2204}; // namespace camera2
2205}; // namespace android