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