Gitiles
Code Review Sign In
review.evervolv.com / android_frameworks_av / ebe3f69ef09777001b14a1cb9a2a21090655a14b / . / services / camera / libcameraservice / camera2 / Parameters.cpp
blob: 93927e61b250eb6564d24603a0f6cca75de5703d [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 {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]954 camera_metadata_ro_entry_t entry = info->find(tag);
955
956 if (CC_UNLIKELY( entry.count == 0 )) {
957 const char* tagSection = get_camera_metadata_section_name(tag);
958 if (tagSection == NULL) tagSection = "<unknown>";
959 const char* tagName = get_camera_metadata_tag_name(tag);
960 if (tagName == NULL) tagName = "<unknown>";
961
962 ALOGE("Error finding static metadata entry '%s.%s' (%x)",
963 tagSection, tagName, tag);
964 } else if (CC_UNLIKELY(
965 (minCount != 0 && entry.count < minCount) ||
966 (maxCount != 0 && entry.count > maxCount) ) ) {
967 const char* tagSection = get_camera_metadata_section_name(tag);
968 if (tagSection == NULL) tagSection = "<unknown>";
969 const char* tagName = get_camera_metadata_tag_name(tag);
970 if (tagName == NULL) tagName = "<unknown>";
971 ALOGE("Malformed static metadata entry '%s.%s' (%x):"
972 "Expected between %d and %d values, but got %d values",
973 tagSection, tagName, tag, minCount, maxCount, entry.count);
974 }
975
976 return entry;
977}
978
Eino-Ville Talvalac85f8262012-10-02 13:30:04 -0700[diff] [blame]979status_t Parameters::set(const String8& paramString) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]980 status_t res;
981
Eino-Ville Talvalac85f8262012-10-02 13:30:04 -0700[diff] [blame]982 CameraParameters newParams(paramString);
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]983
984 // TODO: Currently ignoring any changes to supposedly read-only parameters
985 // such as supported preview sizes, etc. Should probably produce an error if
986 // they're changed.
987
988 /** Extract and verify new parameters */
989
990 size_t i;
991
992 Parameters validatedParams(*this);
993
994 // PREVIEW_SIZE
995 newParams.getPreviewSize(&validatedParams.previewWidth,
996 &validatedParams.previewHeight);
997
998 if (validatedParams.previewWidth != previewWidth ||
999 validatedParams.previewHeight != previewHeight) {
1000 if (state >= PREVIEW) {
1001 ALOGE("%s: Preview size cannot be updated when preview "
1002 "is active! (Currently %d x %d, requested %d x %d",
1003 __FUNCTION__,
1004 previewWidth, previewHeight,
1005 validatedParams.previewWidth, validatedParams.previewHeight);
1006 return BAD_VALUE;
1007 }
1008 camera_metadata_ro_entry_t availablePreviewSizes =
1009 staticInfo(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES);
1010 for (i = 0; i < availablePreviewSizes.count; i += 2 ) {
1011 if ((availablePreviewSizes.data.i32[i] ==
1012 validatedParams.previewWidth) &&
1013 (availablePreviewSizes.data.i32[i+1] ==
1014 validatedParams.previewHeight)) break;
1015 }
1016 if (i == availablePreviewSizes.count) {
1017 ALOGE("%s: Requested preview size %d x %d is not supported",
1018 __FUNCTION__, validatedParams.previewWidth,
1019 validatedParams.previewHeight);
1020 return BAD_VALUE;
1021 }
1022 }
1023
Igor Murashkin63dc1992012-10-04 14:22:18 -0700[diff] [blame]1024 // RECORDING_HINT (always supported)
1025 validatedParams.recordingHint = boolFromString(
1026 newParams.get(CameraParameters::KEY_RECORDING_HINT) );
1027 bool recordingHintChanged = validatedParams.recordingHint != recordingHint;
1028 ALOGV_IF(recordingHintChanged, "%s: Recording hint changed to %d",
1029 __FUNCTION__, recordingHintChanged);
1030
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1031 // PREVIEW_FPS_RANGE
1032 bool fpsRangeChanged = false;
1033 newParams.getPreviewFpsRange(&validatedParams.previewFpsRange[0],
1034 &validatedParams.previewFpsRange[1]);
Eino-Ville Talvalab5d91132012-09-27 14:18:13 -0700[diff] [blame]1035 validatedParams.previewFpsRange[0] /= kFpsToApiScale;
1036 validatedParams.previewFpsRange[1] /= kFpsToApiScale;
1037
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1038 if (validatedParams.previewFpsRange[0] != previewFpsRange[0] ||
1039 validatedParams.previewFpsRange[1] != previewFpsRange[1]) {
1040 fpsRangeChanged = true;
1041 camera_metadata_ro_entry_t availablePreviewFpsRanges =
1042 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES, 2);
1043 for (i = 0; i < availablePreviewFpsRanges.count; i += 2) {
1044 if ((availablePreviewFpsRanges.data.i32[i] ==
1045 validatedParams.previewFpsRange[0]) &&
1046 (availablePreviewFpsRanges.data.i32[i+1] ==
1047 validatedParams.previewFpsRange[1]) ) {
1048 break;
1049 }
1050 }
1051 if (i == availablePreviewFpsRanges.count) {
1052 ALOGE("%s: Requested preview FPS range %d - %d is not supported",
1053 __FUNCTION__, validatedParams.previewFpsRange[0],
1054 validatedParams.previewFpsRange[1]);
1055 return BAD_VALUE;
1056 }
Igor Murashkin63dc1992012-10-04 14:22:18 -0700[diff] [blame]1057 validatedParams.previewFps =
1058 fpsFromRange(validatedParams.previewFpsRange[0],
1059 validatedParams.previewFpsRange[1]);
Eino-Ville Talvalac85f8262012-10-02 13:30:04 -0700[diff] [blame]1060 newParams.setPreviewFrameRate(validatedParams.previewFps);
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1061 }
1062
1063 // PREVIEW_FORMAT
1064 validatedParams.previewFormat =
1065 formatStringToEnum(newParams.getPreviewFormat());
1066 if (validatedParams.previewFormat != previewFormat) {
1067 if (state >= PREVIEW) {
1068 ALOGE("%s: Preview format cannot be updated when preview "
1069 "is active!", __FUNCTION__);
1070 return BAD_VALUE;
1071 }
1072 camera_metadata_ro_entry_t availableFormats =
1073 staticInfo(ANDROID_SCALER_AVAILABLE_FORMATS);
1074 for (i = 0; i < availableFormats.count; i++) {
1075 if (availableFormats.data.i32[i] == validatedParams.previewFormat)
1076 break;
1077 }
1078 if (i == availableFormats.count) {
1079 ALOGE("%s: Requested preview format %s (0x%x) is not supported",
1080 __FUNCTION__, newParams.getPreviewFormat(),
1081 validatedParams.previewFormat);
1082 return BAD_VALUE;
1083 }
1084 }
1085
1086 // PREVIEW_FRAME_RATE
1087 // Deprecated, only use if the preview fps range is unchanged this time.
1088 // The single-value FPS is the same as the minimum of the range.
1089 if (!fpsRangeChanged) {
Eino-Ville Talvala823b7862012-09-27 18:08:20 -0700[diff] [blame]1090 validatedParams.previewFps = newParams.getPreviewFrameRate();
Igor Murashkin63dc1992012-10-04 14:22:18 -0700[diff] [blame]1091 if (validatedParams.previewFps != previewFps || recordingHintChanged) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1092 camera_metadata_ro_entry_t availableFrameRates =
1093 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES);
Igor Murashkin63dc1992012-10-04 14:22:18 -0700[diff] [blame]1094 /**
1095 * If recording hint is set, find the range that encompasses
1096 * previewFps with the largest min index.
1097 *
1098 * If recording hint is not set, find the range with previewFps
1099 * with the smallest min index.
1100 *
1101 * Either way, in case of multiple ranges, break the tie by
1102 * selecting the smaller range.
1103 */
1104 int targetFps = validatedParams.previewFps;
1105 // all ranges which have targetFps
1106 Vector<Range> candidateRanges;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1107 for (i = 0; i < availableFrameRates.count; i+=2) {
Igor Murashkin63dc1992012-10-04 14:22:18 -0700[diff] [blame]1108 Range r = {
1109 availableFrameRates.data.i32[i],
1110 availableFrameRates.data.i32[i+1]
1111 };
1112
1113 if (r.min <= targetFps && targetFps <= r.max) {
1114 candidateRanges.push(r);
1115 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1116 }
Igor Murashkin63dc1992012-10-04 14:22:18 -0700[diff] [blame]1117 if (candidateRanges.isEmpty()) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1118 ALOGE("%s: Requested preview frame rate %d is not supported",
1119 __FUNCTION__, validatedParams.previewFps);
1120 return BAD_VALUE;
1121 }
Igor Murashkin63dc1992012-10-04 14:22:18 -0700[diff] [blame]1122 // most applicable range with targetFps
1123 Range bestRange = candidateRanges[0];
1124 for (i = 1; i < candidateRanges.size(); ++i) {
1125 Range r = candidateRanges[i];
1126
1127 // Find by largest minIndex in recording mode
1128 if (validatedParams.recordingHint) {
1129 if (r.min > bestRange.min) {
1130 bestRange = r;
1131 }
1132 else if (r.min == bestRange.min && r.max < bestRange.max) {
1133 bestRange = r;
1134 }
1135 }
1136 // Find by smallest minIndex in preview mode
1137 else {
1138 if (r.min < bestRange.min) {
1139 bestRange = r;
1140 }
1141 else if (r.min == bestRange.min && r.max < bestRange.max) {
1142 bestRange = r;
1143 }
1144 }
1145 }
1146
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1147 validatedParams.previewFpsRange[0] =
Igor Murashkin63dc1992012-10-04 14:22:18 -0700[diff] [blame]1148 bestRange.min;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1149 validatedParams.previewFpsRange[1] =
Igor Murashkin63dc1992012-10-04 14:22:18 -0700[diff] [blame]1150 bestRange.max;
1151
1152 ALOGV("%s: New preview FPS range: %d, %d, recordingHint = %d",
1153 __FUNCTION__,
1154 validatedParams.previewFpsRange[0],
1155 validatedParams.previewFpsRange[1],
1156 validatedParams.recordingHint);
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1157 }
Eino-Ville Talvala02b62d32012-10-03 14:59:29 -0700[diff] [blame]1158 newParams.set(CameraParameters::KEY_PREVIEW_FPS_RANGE,
1159 String8::format("%d,%d",
1160 validatedParams.previewFpsRange[0] * kFpsToApiScale,
1161 validatedParams.previewFpsRange[1] * kFpsToApiScale));
Igor Murashkin63dc1992012-10-04 14:22:18 -0700[diff] [blame]1162
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1163 }
1164
1165 // PICTURE_SIZE
1166 newParams.getPictureSize(&validatedParams.pictureWidth,
1167 &validatedParams.pictureHeight);
1168 if (validatedParams.pictureWidth == pictureWidth ||
1169 validatedParams.pictureHeight == pictureHeight) {
1170 camera_metadata_ro_entry_t availablePictureSizes =
1171 staticInfo(ANDROID_SCALER_AVAILABLE_JPEG_SIZES);
1172 for (i = 0; i < availablePictureSizes.count; i+=2) {
1173 if ((availablePictureSizes.data.i32[i] ==
1174 validatedParams.pictureWidth) &&
1175 (availablePictureSizes.data.i32[i+1] ==
1176 validatedParams.pictureHeight)) break;
1177 }
1178 if (i == availablePictureSizes.count) {
1179 ALOGE("%s: Requested picture size %d x %d is not supported",
1180 __FUNCTION__, validatedParams.pictureWidth,
1181 validatedParams.pictureHeight);
1182 return BAD_VALUE;
1183 }
1184 }
1185
1186 // JPEG_THUMBNAIL_WIDTH/HEIGHT
1187 validatedParams.jpegThumbSize[0] =
1188 newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH);
1189 validatedParams.jpegThumbSize[1] =
1190 newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT);
1191 if (validatedParams.jpegThumbSize[0] != jpegThumbSize[0] ||
1192 validatedParams.jpegThumbSize[1] != jpegThumbSize[1]) {
1193 camera_metadata_ro_entry_t availableJpegThumbSizes =
1194 staticInfo(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES);
1195 for (i = 0; i < availableJpegThumbSizes.count; i+=2) {
1196 if ((availableJpegThumbSizes.data.i32[i] ==
1197 validatedParams.jpegThumbSize[0]) &&
1198 (availableJpegThumbSizes.data.i32[i+1] ==
1199 validatedParams.jpegThumbSize[1])) break;
1200 }
1201 if (i == availableJpegThumbSizes.count) {
1202 ALOGE("%s: Requested JPEG thumbnail size %d x %d is not supported",
1203 __FUNCTION__, validatedParams.jpegThumbSize[0],
1204 validatedParams.jpegThumbSize[1]);
1205 return BAD_VALUE;
1206 }
1207 }
1208
1209 // JPEG_THUMBNAIL_QUALITY
1210 validatedParams.jpegThumbQuality =
1211 newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY);
1212 if (validatedParams.jpegThumbQuality < 0 ||
1213 validatedParams.jpegThumbQuality > 100) {
1214 ALOGE("%s: Requested JPEG thumbnail quality %d is not supported",
1215 __FUNCTION__, validatedParams.jpegThumbQuality);
1216 return BAD_VALUE;
1217 }
1218
1219 // JPEG_QUALITY
1220 validatedParams.jpegQuality =
1221 newParams.getInt(CameraParameters::KEY_JPEG_QUALITY);
1222 if (validatedParams.jpegQuality < 0 || validatedParams.jpegQuality > 100) {
1223 ALOGE("%s: Requested JPEG quality %d is not supported",
1224 __FUNCTION__, validatedParams.jpegQuality);
1225 return BAD_VALUE;
1226 }
1227
1228 // ROTATION
1229 validatedParams.jpegRotation =
1230 newParams.getInt(CameraParameters::KEY_ROTATION);
1231 if (validatedParams.jpegRotation != 0 &&
1232 validatedParams.jpegRotation != 90 &&
1233 validatedParams.jpegRotation != 180 &&
1234 validatedParams.jpegRotation != 270) {
1235 ALOGE("%s: Requested picture rotation angle %d is not supported",
1236 __FUNCTION__, validatedParams.jpegRotation);
1237 return BAD_VALUE;
1238 }
1239
1240 // GPS
1241
1242 const char *gpsLatStr =
1243 newParams.get(CameraParameters::KEY_GPS_LATITUDE);
1244 if (gpsLatStr != NULL) {
1245 const char *gpsLongStr =
1246 newParams.get(CameraParameters::KEY_GPS_LONGITUDE);
1247 const char *gpsAltitudeStr =
1248 newParams.get(CameraParameters::KEY_GPS_ALTITUDE);
1249 const char *gpsTimeStr =
1250 newParams.get(CameraParameters::KEY_GPS_TIMESTAMP);
1251 const char *gpsProcMethodStr =
1252 newParams.get(CameraParameters::KEY_GPS_PROCESSING_METHOD);
1253 if (gpsLongStr == NULL ||
1254 gpsAltitudeStr == NULL ||
1255 gpsTimeStr == NULL ||
1256 gpsProcMethodStr == NULL) {
1257 ALOGE("%s: Incomplete set of GPS parameters provided",
1258 __FUNCTION__);
1259 return BAD_VALUE;
1260 }
1261 char *endPtr;
1262 errno = 0;
1263 validatedParams.gpsCoordinates[0] = strtod(gpsLatStr, &endPtr);
1264 if (errno || endPtr == gpsLatStr) {
1265 ALOGE("%s: Malformed GPS latitude: %s", __FUNCTION__, gpsLatStr);
1266 return BAD_VALUE;
1267 }
1268 errno = 0;
1269 validatedParams.gpsCoordinates[1] = strtod(gpsLongStr, &endPtr);
1270 if (errno || endPtr == gpsLongStr) {
1271 ALOGE("%s: Malformed GPS longitude: %s", __FUNCTION__, gpsLongStr);
1272 return BAD_VALUE;
1273 }
1274 errno = 0;
1275 validatedParams.gpsCoordinates[2] = strtod(gpsAltitudeStr, &endPtr);
1276 if (errno || endPtr == gpsAltitudeStr) {
1277 ALOGE("%s: Malformed GPS altitude: %s", __FUNCTION__,
1278 gpsAltitudeStr);
1279 return BAD_VALUE;
1280 }
1281 errno = 0;
1282 validatedParams.gpsTimestamp = strtoll(gpsTimeStr, &endPtr, 10);
1283 if (errno || endPtr == gpsTimeStr) {
1284 ALOGE("%s: Malformed GPS timestamp: %s", __FUNCTION__, gpsTimeStr);
1285 return BAD_VALUE;
1286 }
1287 validatedParams.gpsProcessingMethod = gpsProcMethodStr;
1288
1289 validatedParams.gpsEnabled = true;
1290 } else {
1291 validatedParams.gpsEnabled = false;
1292 }
1293
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1294 // EFFECT
1295 validatedParams.effectMode = effectModeStringToEnum(
1296 newParams.get(CameraParameters::KEY_EFFECT) );
1297 if (validatedParams.effectMode != effectMode) {
1298 camera_metadata_ro_entry_t availableEffectModes =
1299 staticInfo(ANDROID_CONTROL_AVAILABLE_EFFECTS);
1300 for (i = 0; i < availableEffectModes.count; i++) {
1301 if (validatedParams.effectMode == availableEffectModes.data.u8[i]) break;
1302 }
1303 if (i == availableEffectModes.count) {
1304 ALOGE("%s: Requested effect mode \"%s\" is not supported",
1305 __FUNCTION__,
1306 newParams.get(CameraParameters::KEY_EFFECT) );
1307 return BAD_VALUE;
1308 }
1309 }
1310
1311 // ANTIBANDING
1312 validatedParams.antibandingMode = abModeStringToEnum(
1313 newParams.get(CameraParameters::KEY_ANTIBANDING) );
1314 if (validatedParams.antibandingMode != antibandingMode) {
1315 camera_metadata_ro_entry_t availableAbModes =
1316 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES);
1317 for (i = 0; i < availableAbModes.count; i++) {
1318 if (validatedParams.antibandingMode == availableAbModes.data.u8[i])
1319 break;
1320 }
1321 if (i == availableAbModes.count) {
1322 ALOGE("%s: Requested antibanding mode \"%s\" is not supported",
1323 __FUNCTION__,
1324 newParams.get(CameraParameters::KEY_ANTIBANDING));
1325 return BAD_VALUE;
1326 }
1327 }
1328
1329 // SCENE_MODE
1330 validatedParams.sceneMode = sceneModeStringToEnum(
1331 newParams.get(CameraParameters::KEY_SCENE_MODE) );
1332 if (validatedParams.sceneMode != sceneMode &&
1333 validatedParams.sceneMode !=
1334 ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED) {
1335 camera_metadata_ro_entry_t availableSceneModes =
1336 staticInfo(ANDROID_CONTROL_AVAILABLE_SCENE_MODES);
1337 for (i = 0; i < availableSceneModes.count; i++) {
1338 if (validatedParams.sceneMode == availableSceneModes.data.u8[i])
1339 break;
1340 }
1341 if (i == availableSceneModes.count) {
1342 ALOGE("%s: Requested scene mode \"%s\" is not supported",
1343 __FUNCTION__,
1344 newParams.get(CameraParameters::KEY_SCENE_MODE));
1345 return BAD_VALUE;
1346 }
1347 }
Eino-Ville Talvalac85f8262012-10-02 13:30:04 -0700[diff] [blame]1348 bool sceneModeSet =
1349 validatedParams.sceneMode != ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1350
1351 // FLASH_MODE
Eino-Ville Talvalac85f8262012-10-02 13:30:04 -0700[diff] [blame]1352 if (sceneModeSet) {
1353 validatedParams.flashMode =
1354 fastInfo.sceneModeOverrides.
1355 valueFor(validatedParams.sceneMode).flashMode;
1356 } else {
1357 validatedParams.flashMode = FLASH_MODE_INVALID;
1358 }
1359 if (validatedParams.flashMode == FLASH_MODE_INVALID) {
1360 validatedParams.flashMode = flashModeStringToEnum(
1361 newParams.get(CameraParameters::KEY_FLASH_MODE) );
1362 }
1363
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1364 if (validatedParams.flashMode != flashMode) {
1365 camera_metadata_ro_entry_t flashAvailable =
1366 staticInfo(ANDROID_FLASH_AVAILABLE, 1, 1);
1367 if (!flashAvailable.data.u8[0] &&
1368 validatedParams.flashMode != Parameters::FLASH_MODE_OFF) {
1369 ALOGE("%s: Requested flash mode \"%s\" is not supported: "
1370 "No flash on device", __FUNCTION__,
1371 newParams.get(CameraParameters::KEY_FLASH_MODE));
1372 return BAD_VALUE;
1373 } else if (validatedParams.flashMode == Parameters::FLASH_MODE_RED_EYE) {
1374 camera_metadata_ro_entry_t availableAeModes =
1375 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_MODES);
1376 for (i = 0; i < availableAeModes.count; i++) {
1377 if (validatedParams.flashMode == availableAeModes.data.u8[i])
1378 break;
1379 }
1380 if (i == availableAeModes.count) {
1381 ALOGE("%s: Requested flash mode \"%s\" is not supported",
1382 __FUNCTION__,
1383 newParams.get(CameraParameters::KEY_FLASH_MODE));
1384 return BAD_VALUE;
1385 }
1386 } else if (validatedParams.flashMode == -1) {
1387 ALOGE("%s: Requested flash mode \"%s\" is unknown",
1388 __FUNCTION__,
1389 newParams.get(CameraParameters::KEY_FLASH_MODE));
1390 return BAD_VALUE;
1391 }
Eino-Ville Talvalac85f8262012-10-02 13:30:04 -0700[diff] [blame]1392 // Update in case of override
1393 newParams.set(CameraParameters::KEY_FLASH_MODE,
1394 flashModeEnumToString(validatedParams.flashMode));
1395 }
1396
1397 // WHITE_BALANCE
1398 if (sceneModeSet) {
1399 validatedParams.wbMode =
1400 fastInfo.sceneModeOverrides.
1401 valueFor(validatedParams.sceneMode).wbMode;
1402 } else {
1403 validatedParams.wbMode = ANDROID_CONTROL_AWB_OFF;
1404 }
1405 if (validatedParams.wbMode == ANDROID_CONTROL_AWB_OFF) {
1406 validatedParams.wbMode = wbModeStringToEnum(
1407 newParams.get(CameraParameters::KEY_WHITE_BALANCE) );
1408 }
1409 if (validatedParams.wbMode != wbMode) {
1410 camera_metadata_ro_entry_t availableWbModes =
1411 staticInfo(ANDROID_CONTROL_AWB_AVAILABLE_MODES);
1412 for (i = 0; i < availableWbModes.count; i++) {
1413 if (validatedParams.wbMode == availableWbModes.data.u8[i]) break;
1414 }
1415 if (i == availableWbModes.count) {
1416 ALOGE("%s: Requested white balance mode %s is not supported",
1417 __FUNCTION__,
1418 newParams.get(CameraParameters::KEY_WHITE_BALANCE));
1419 return BAD_VALUE;
1420 }
1421 // Update in case of override
1422 newParams.set(CameraParameters::KEY_WHITE_BALANCE,
1423 wbModeEnumToString(validatedParams.wbMode));
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1424 }
1425
1426 // FOCUS_MODE
Eino-Ville Talvalac85f8262012-10-02 13:30:04 -0700[diff] [blame]1427 if (sceneModeSet) {
1428 validatedParams.focusMode =
1429 fastInfo.sceneModeOverrides.
1430 valueFor(validatedParams.sceneMode).focusMode;
1431 } else {
1432 validatedParams.focusMode = FOCUS_MODE_INVALID;
1433 }
1434 if (validatedParams.focusMode == FOCUS_MODE_INVALID) {
1435 validatedParams.focusMode = focusModeStringToEnum(
1436 newParams.get(CameraParameters::KEY_FOCUS_MODE) );
1437 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1438 if (validatedParams.focusMode != focusMode) {
1439 validatedParams.currentAfTriggerId = -1;
1440 if (validatedParams.focusMode != Parameters::FOCUS_MODE_FIXED) {
1441 camera_metadata_ro_entry_t minFocusDistance =
1442 staticInfo(ANDROID_LENS_MINIMUM_FOCUS_DISTANCE);
1443 if (minFocusDistance.data.f[0] == 0) {
1444 ALOGE("%s: Requested focus mode \"%s\" is not available: "
1445 "fixed focus lens",
1446 __FUNCTION__,
1447 newParams.get(CameraParameters::KEY_FOCUS_MODE));
1448 return BAD_VALUE;
1449 } else if (validatedParams.focusMode !=
1450 Parameters::FOCUS_MODE_INFINITY) {
1451 camera_metadata_ro_entry_t availableFocusModes =
1452 staticInfo(ANDROID_CONTROL_AF_AVAILABLE_MODES);
1453 for (i = 0; i < availableFocusModes.count; i++) {
1454 if (validatedParams.focusMode ==
1455 availableFocusModes.data.u8[i]) break;
1456 }
1457 if (i == availableFocusModes.count) {
1458 ALOGE("%s: Requested focus mode \"%s\" is not supported",
1459 __FUNCTION__,
1460 newParams.get(CameraParameters::KEY_FOCUS_MODE));
1461 return BAD_VALUE;
1462 }
1463 }
1464 }
Eino-Ville Talvalaf1a6e0d2012-10-16 10:17:30 -0700[diff] [blame]1465 validatedParams.focusState = ANDROID_CONTROL_AF_STATE_INACTIVE;
Eino-Ville Talvala4c843702012-10-04 00:56:40 -0700[diff] [blame]1466 // Always reset shadow focus mode to avoid reverting settings
Eino-Ville Talvalaf1a6e0d2012-10-16 10:17:30 -0700[diff] [blame]1467 validatedParams.shadowFocusMode = FOCUS_MODE_INVALID;
Eino-Ville Talvalac85f8262012-10-02 13:30:04 -0700[diff] [blame]1468 // Update in case of override
1469 newParams.set(CameraParameters::KEY_FOCUS_MODE,
1470 focusModeEnumToString(validatedParams.focusMode));
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1471 } else {
1472 validatedParams.currentAfTriggerId = currentAfTriggerId;
1473 }
1474
1475 // FOCUS_AREAS
1476 res = parseAreas(newParams.get(CameraParameters::KEY_FOCUS_AREAS),
1477 &validatedParams.focusingAreas);
1478 size_t max3aRegions =
1479 (size_t)staticInfo(ANDROID_CONTROL_MAX_REGIONS, 1, 1).data.i32[0];
1480 if (res == OK) res = validateAreas(validatedParams.focusingAreas,
Igor Murashkin572bf9a2012-10-05 17:09:09 -0700[diff] [blame]1481 max3aRegions, AREA_KIND_FOCUS);
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1482 if (res != OK) {
1483 ALOGE("%s: Requested focus areas are malformed: %s",
1484 __FUNCTION__, newParams.get(CameraParameters::KEY_FOCUS_AREAS));
1485 return BAD_VALUE;
1486 }
1487
1488 // EXPOSURE_COMPENSATION
1489 validatedParams.exposureCompensation =
1490 newParams.getInt(CameraParameters::KEY_EXPOSURE_COMPENSATION);
1491 camera_metadata_ro_entry_t exposureCompensationRange =
1492 staticInfo(ANDROID_CONTROL_AE_EXP_COMPENSATION_RANGE);
1493 if ((validatedParams.exposureCompensation <
1494 exposureCompensationRange.data.i32[0]) ||
1495 (validatedParams.exposureCompensation >
1496 exposureCompensationRange.data.i32[1])) {
1497 ALOGE("%s: Requested exposure compensation index is out of bounds: %d",
1498 __FUNCTION__, validatedParams.exposureCompensation);
1499 return BAD_VALUE;
1500 }
1501
1502 // AUTO_EXPOSURE_LOCK (always supported)
1503 validatedParams.autoExposureLock = boolFromString(
1504 newParams.get(CameraParameters::KEY_AUTO_EXPOSURE_LOCK));
1505
1506 // AUTO_WHITEBALANCE_LOCK (always supported)
1507 validatedParams.autoWhiteBalanceLock = boolFromString(
1508 newParams.get(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK));
1509
1510 // METERING_AREAS
1511 res = parseAreas(newParams.get(CameraParameters::KEY_METERING_AREAS),
1512 &validatedParams.meteringAreas);
1513 if (res == OK) {
Igor Murashkin572bf9a2012-10-05 17:09:09 -0700[diff] [blame]1514 res = validateAreas(validatedParams.meteringAreas, max3aRegions,
1515 AREA_KIND_METERING);
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1516 }
1517 if (res != OK) {
1518 ALOGE("%s: Requested metering areas are malformed: %s",
1519 __FUNCTION__,
1520 newParams.get(CameraParameters::KEY_METERING_AREAS));
1521 return BAD_VALUE;
1522 }
1523
1524 // ZOOM
1525 validatedParams.zoom = newParams.getInt(CameraParameters::KEY_ZOOM);
Igor Murashkincfdd8422012-10-08 11:16:03 -0700[diff] [blame]1526 if (validatedParams.zoom < 0
1527 || validatedParams.zoom >= (int)NUM_ZOOM_STEPS) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1528 ALOGE("%s: Requested zoom level %d is not supported",
1529 __FUNCTION__, validatedParams.zoom);
1530 return BAD_VALUE;
1531 }
1532
1533 // VIDEO_SIZE
1534 newParams.getVideoSize(&validatedParams.videoWidth,
1535 &validatedParams.videoHeight);
1536 if (validatedParams.videoWidth != videoWidth ||
1537 validatedParams.videoHeight != videoHeight) {
1538 if (state == RECORD) {
1539 ALOGE("%s: Video size cannot be updated when recording is active!",
1540 __FUNCTION__);
1541 return BAD_VALUE;
1542 }
1543 camera_metadata_ro_entry_t availableVideoSizes =
1544 staticInfo(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES);
1545 for (i = 0; i < availableVideoSizes.count; i += 2 ) {
1546 if ((availableVideoSizes.data.i32[i] ==
1547 validatedParams.videoWidth) &&
1548 (availableVideoSizes.data.i32[i+1] ==
1549 validatedParams.videoHeight)) break;
1550 }
1551 if (i == availableVideoSizes.count) {
1552 ALOGE("%s: Requested video size %d x %d is not supported",
1553 __FUNCTION__, validatedParams.videoWidth,
1554 validatedParams.videoHeight);
1555 return BAD_VALUE;
1556 }
1557 }
1558
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1559 // VIDEO_STABILIZATION
1560 validatedParams.videoStabilization = boolFromString(
1561 newParams.get(CameraParameters::KEY_VIDEO_STABILIZATION) );
1562 camera_metadata_ro_entry_t availableVideoStabilizationModes =
1563 staticInfo(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES);
1564 if (validatedParams.videoStabilization &&
1565 availableVideoStabilizationModes.count == 1) {
1566 ALOGE("%s: Video stabilization not supported", __FUNCTION__);
1567 }
1568
James Painterc3dbf1a2012-09-05 18:02:32 -0700[diff] [blame]1569 // LIGHTFX
1570 validatedParams.lightFx = lightFxStringToEnum(
1571 newParams.get(CameraParameters::KEY_LIGHTFX));
1572
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1573 /** Update internal parameters */
1574
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1575 *this = validatedParams;
1576
Eino-Ville Talvalac85f8262012-10-02 13:30:04 -0700[diff] [blame]1577 // Need to flatten again in case of overrides
1578 paramsFlattened = newParams.flatten();
1579 params = newParams;
1580
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1581 return OK;
1582}
1583
Eino-Ville Talvala69230df2012-08-29 17:37:16 -0700[diff] [blame]1584status_t Parameters::updateRequest(CameraMetadata *request) const {
1585 ATRACE_CALL();
1586 status_t res;
1587
1588 uint8_t metadataMode = ANDROID_REQUEST_METADATA_FULL;
1589 res = request->update(ANDROID_REQUEST_METADATA_MODE,
1590 &metadataMode, 1);
1591 if (res != OK) return res;
1592
1593 res = request->update(ANDROID_CONTROL_AE_TARGET_FPS_RANGE,
1594 previewFpsRange, 2);
1595 if (res != OK) return res;
1596
Eino-Ville Talvala2d6a5032012-09-03 10:03:26 -0700[diff] [blame]1597 uint8_t reqWbLock = autoWhiteBalanceLock ?
1598 ANDROID_CONTROL_AWB_LOCK_ON : ANDROID_CONTROL_AWB_LOCK_OFF;
1599 res = request->update(ANDROID_CONTROL_AWB_LOCK,
1600 &reqWbLock, 1);
1601
Eino-Ville Talvala69230df2012-08-29 17:37:16 -0700[diff] [blame]1602 res = request->update(ANDROID_CONTROL_EFFECT_MODE,
1603 &effectMode, 1);
1604 if (res != OK) return res;
1605 res = request->update(ANDROID_CONTROL_AE_ANTIBANDING_MODE,
1606 &antibandingMode, 1);
1607 if (res != OK) return res;
1608
Eino-Ville Talvala2a88b712012-09-07 14:26:29 -0700[diff] [blame]1609 // android.hardware.Camera requires that when face detect is enabled, the
1610 // camera is in a face-priority mode. HAL2 splits this into separate parts
1611 // (face detection statistics and face priority scene mode). Map from other
1612 // to the other.
Eino-Ville Talvalac85f8262012-10-02 13:30:04 -0700[diff] [blame]1613 bool sceneModeActive =
1614 sceneMode != (uint8_t)ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED;
Eino-Ville Talvala2a88b712012-09-07 14:26:29 -0700[diff] [blame]1615 uint8_t reqControlMode = ANDROID_CONTROL_AUTO;
Eino-Ville Talvalac85f8262012-10-02 13:30:04 -0700[diff] [blame]1616 if (enableFaceDetect || sceneModeActive) {
Eino-Ville Talvala2a88b712012-09-07 14:26:29 -0700[diff] [blame]1617 reqControlMode = ANDROID_CONTROL_USE_SCENE_MODE;
1618 }
Eino-Ville Talvala69230df2012-08-29 17:37:16 -0700[diff] [blame]1619 res = request->update(ANDROID_CONTROL_MODE,
1620 &reqControlMode, 1);
1621 if (res != OK) return res;
Eino-Ville Talvala2a88b712012-09-07 14:26:29 -0700[diff] [blame]1622
Eino-Ville Talvala063886e2012-09-17 16:43:14 -0700[diff] [blame]1623 uint8_t reqSceneMode =
Eino-Ville Talvalac85f8262012-10-02 13:30:04 -0700[diff] [blame]1624 sceneModeActive ? sceneMode :
Eino-Ville Talvala063886e2012-09-17 16:43:14 -0700[diff] [blame]1625 enableFaceDetect ? (uint8_t)ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY :
1626 (uint8_t)ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED;
Eino-Ville Talvala2a88b712012-09-07 14:26:29 -0700[diff] [blame]1627 res = request->update(ANDROID_CONTROL_SCENE_MODE,
1628 &reqSceneMode, 1);
1629 if (res != OK) return res;
Eino-Ville Talvala69230df2012-08-29 17:37:16 -0700[diff] [blame]1630
1631 uint8_t reqFlashMode = ANDROID_FLASH_OFF;
Eino-Ville Talvalac85f8262012-10-02 13:30:04 -0700[diff] [blame]1632 uint8_t reqAeMode = ANDROID_CONTROL_AE_OFF;
Eino-Ville Talvala69230df2012-08-29 17:37:16 -0700[diff] [blame]1633 switch (flashMode) {
1634 case Parameters::FLASH_MODE_OFF:
1635 reqAeMode = ANDROID_CONTROL_AE_ON; break;
1636 case Parameters::FLASH_MODE_AUTO:
1637 reqAeMode = ANDROID_CONTROL_AE_ON_AUTO_FLASH; break;
1638 case Parameters::FLASH_MODE_ON:
1639 reqAeMode = ANDROID_CONTROL_AE_ON_ALWAYS_FLASH; break;
1640 case Parameters::FLASH_MODE_TORCH:
1641 reqAeMode = ANDROID_CONTROL_AE_ON;
1642 reqFlashMode = ANDROID_FLASH_TORCH;
1643 break;
1644 case Parameters::FLASH_MODE_RED_EYE:
1645 reqAeMode = ANDROID_CONTROL_AE_ON_AUTO_FLASH_REDEYE; break;
1646 default:
1647 ALOGE("%s: Camera %d: Unknown flash mode %d", __FUNCTION__,
1648 cameraId, flashMode);
Eino-Ville Talvalac85f8262012-10-02 13:30:04 -0700[diff] [blame]1649 return BAD_VALUE;
Eino-Ville Talvala69230df2012-08-29 17:37:16 -0700[diff] [blame]1650 }
Eino-Ville Talvala69230df2012-08-29 17:37:16 -0700[diff] [blame]1651 res = request->update(ANDROID_FLASH_MODE,
1652 &reqFlashMode, 1);
1653 if (res != OK) return res;
1654 res = request->update(ANDROID_CONTROL_AE_MODE,
1655 &reqAeMode, 1);
1656 if (res != OK) return res;
1657
Eino-Ville Talvala2d6a5032012-09-03 10:03:26 -0700[diff] [blame]1658 uint8_t reqAeLock = autoExposureLock ?
1659 ANDROID_CONTROL_AE_LOCK_ON : ANDROID_CONTROL_AE_LOCK_OFF;
1660 res = request->update(ANDROID_CONTROL_AE_LOCK,
1661 &reqAeLock, 1);
Eino-Ville Talvalac85f8262012-10-02 13:30:04 -0700[diff] [blame]1662 if (res != OK) return res;
1663
1664 res = request->update(ANDROID_CONTROL_AWB_MODE,
1665 &wbMode, 1);
1666 if (res != OK) return res;
Eino-Ville Talvala2d6a5032012-09-03 10:03:26 -0700[diff] [blame]1667
Eino-Ville Talvala69230df2012-08-29 17:37:16 -0700[diff] [blame]1668 float reqFocusDistance = 0; // infinity focus in diopters
Eino-Ville Talvalac85f8262012-10-02 13:30:04 -0700[diff] [blame]1669 uint8_t reqFocusMode = ANDROID_CONTROL_AF_OFF;
Eino-Ville Talvala69230df2012-08-29 17:37:16 -0700[diff] [blame]1670 switch (focusMode) {
1671 case Parameters::FOCUS_MODE_AUTO:
1672 case Parameters::FOCUS_MODE_MACRO:
1673 case Parameters::FOCUS_MODE_CONTINUOUS_VIDEO:
1674 case Parameters::FOCUS_MODE_CONTINUOUS_PICTURE:
1675 case Parameters::FOCUS_MODE_EDOF:
1676 reqFocusMode = focusMode;
1677 break;
1678 case Parameters::FOCUS_MODE_INFINITY:
1679 case Parameters::FOCUS_MODE_FIXED:
1680 reqFocusMode = ANDROID_CONTROL_AF_OFF;
1681 break;
1682 default:
Eino-Ville Talvalac85f8262012-10-02 13:30:04 -0700[diff] [blame]1683 ALOGE("%s: Camera %d: Unknown focus mode %d", __FUNCTION__,
1684 cameraId, focusMode);
1685 return BAD_VALUE;
Eino-Ville Talvala69230df2012-08-29 17:37:16 -0700[diff] [blame]1686 }
1687 res = request->update(ANDROID_LENS_FOCUS_DISTANCE,
1688 &reqFocusDistance, 1);
1689 if (res != OK) return res;
1690 res = request->update(ANDROID_CONTROL_AF_MODE,
1691 &reqFocusMode, 1);
1692 if (res != OK) return res;
1693
1694 size_t reqFocusingAreasSize = focusingAreas.size() * 5;
1695 int32_t *reqFocusingAreas = new int32_t[reqFocusingAreasSize];
1696 for (size_t i = 0; i < reqFocusingAreasSize; i += 5) {
1697 if (focusingAreas[i].weight != 0) {
1698 reqFocusingAreas[i + 0] =
1699 normalizedXToArray(focusingAreas[i].left);
1700 reqFocusingAreas[i + 1] =
1701 normalizedYToArray(focusingAreas[i].top);
1702 reqFocusingAreas[i + 2] =
1703 normalizedXToArray(focusingAreas[i].right);
1704 reqFocusingAreas[i + 3] =
1705 normalizedYToArray(focusingAreas[i].bottom);
1706 } else {
1707 reqFocusingAreas[i + 0] = 0;
1708 reqFocusingAreas[i + 1] = 0;
1709 reqFocusingAreas[i + 2] = 0;
1710 reqFocusingAreas[i + 3] = 0;
1711 }
1712 reqFocusingAreas[i + 4] = focusingAreas[i].weight;
1713 }
1714 res = request->update(ANDROID_CONTROL_AF_REGIONS,
1715 reqFocusingAreas, reqFocusingAreasSize);
1716 if (res != OK) return res;
1717 delete[] reqFocusingAreas;
1718
1719 res = request->update(ANDROID_CONTROL_AE_EXP_COMPENSATION,
1720 &exposureCompensation, 1);
1721 if (res != OK) return res;
1722
1723 size_t reqMeteringAreasSize = meteringAreas.size() * 5;
1724 int32_t *reqMeteringAreas = new int32_t[reqMeteringAreasSize];
1725 for (size_t i = 0; i < reqMeteringAreasSize; i += 5) {
1726 if (meteringAreas[i].weight != 0) {
1727 reqMeteringAreas[i + 0] =
1728 normalizedXToArray(meteringAreas[i].left);
1729 reqMeteringAreas[i + 1] =
1730 normalizedYToArray(meteringAreas[i].top);
1731 reqMeteringAreas[i + 2] =
1732 normalizedXToArray(meteringAreas[i].right);
1733 reqMeteringAreas[i + 3] =
1734 normalizedYToArray(meteringAreas[i].bottom);
1735 } else {
1736 reqMeteringAreas[i + 0] = 0;
1737 reqMeteringAreas[i + 1] = 0;
1738 reqMeteringAreas[i + 2] = 0;
1739 reqMeteringAreas[i + 3] = 0;
1740 }
1741 reqMeteringAreas[i + 4] = meteringAreas[i].weight;
1742 }
1743 res = request->update(ANDROID_CONTROL_AE_REGIONS,
1744 reqMeteringAreas, reqMeteringAreasSize);
1745 if (res != OK) return res;
1746
Eino-Ville Talvala69230df2012-08-29 17:37:16 -0700[diff] [blame]1747 delete[] reqMeteringAreas;
1748
Igor Murashkin3a6e4532012-09-28 15:30:03 -0700[diff] [blame]1749 /* don't include jpeg thumbnail size - it's valid for
1750 it to be set to (0,0), meaning 'no thumbnail' */
1751 CropRegion crop = calculateCropRegion( (CropRegion::Outputs)(
1752 CropRegion::OUTPUT_PREVIEW |
1753 CropRegion::OUTPUT_VIDEO |
1754 CropRegion::OUTPUT_PICTURE ));
Igor Murashkine500bc22012-09-18 18:23:49 -0700[diff] [blame]1755 int32_t reqCropRegion[3] = { crop.left, crop.top, crop.width };
Eino-Ville Talvala69230df2012-08-29 17:37:16 -0700[diff] [blame]1756 res = request->update(ANDROID_SCALER_CROP_REGION,
1757 reqCropRegion, 3);
1758 if (res != OK) return res;
1759
Eino-Ville Talvala69230df2012-08-29 17:37:16 -0700[diff] [blame]1760 uint8_t reqVstabMode = videoStabilization ?
1761 ANDROID_CONTROL_VIDEO_STABILIZATION_ON :
1762 ANDROID_CONTROL_VIDEO_STABILIZATION_OFF;
1763 res = request->update(ANDROID_CONTROL_VIDEO_STABILIZATION_MODE,
1764 &reqVstabMode, 1);
1765 if (res != OK) return res;
1766
1767 uint8_t reqFaceDetectMode = enableFaceDetect ?
1768 fastInfo.bestFaceDetectMode :
1769 (uint8_t)ANDROID_STATS_FACE_DETECTION_OFF;
1770 res = request->update(ANDROID_STATS_FACE_DETECT_MODE,
1771 &reqFaceDetectMode, 1);
1772 if (res != OK) return res;
1773
1774 return OK;
1775}
1776
Eino-Ville Talvaladb30e682012-10-04 13:21:08 -0700[diff] [blame]1777status_t Parameters::updateRequestJpeg(CameraMetadata *request) const {
1778 status_t res;
1779
1780 res = request->update(ANDROID_JPEG_THUMBNAIL_SIZE,
1781 jpegThumbSize, 2);
1782 if (res != OK) return res;
1783 res = request->update(ANDROID_JPEG_THUMBNAIL_QUALITY,
1784 &jpegThumbQuality, 1);
1785 if (res != OK) return res;
1786 res = request->update(ANDROID_JPEG_QUALITY,
1787 &jpegQuality, 1);
1788 if (res != OK) return res;
1789 res = request->update(
1790 ANDROID_JPEG_ORIENTATION,
1791 &jpegRotation, 1);
1792 if (res != OK) return res;
1793
1794 if (gpsEnabled) {
1795 res = request->update(
1796 ANDROID_JPEG_GPS_COORDINATES,
1797 gpsCoordinates, 3);
1798 if (res != OK) return res;
1799 res = request->update(
1800 ANDROID_JPEG_GPS_TIMESTAMP,
1801 &gpsTimestamp, 1);
1802 if (res != OK) return res;
1803 res = request->update(
1804 ANDROID_JPEG_GPS_PROCESSING_METHOD,
1805 gpsProcessingMethod);
1806 if (res != OK) return res;
1807 } else {
1808 res = request->erase(ANDROID_JPEG_GPS_COORDINATES);
1809 if (res != OK) return res;
1810 res = request->erase(ANDROID_JPEG_GPS_TIMESTAMP);
1811 if (res != OK) return res;
1812 res = request->erase(ANDROID_JPEG_GPS_PROCESSING_METHOD);
1813 if (res != OK) return res;
1814 }
1815 return OK;
1816}
1817
1818
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1819const char* Parameters::getStateName(State state) {
1820#define CASE_ENUM_TO_CHAR(x) case x: return(#x); break;
1821 switch(state) {
1822 CASE_ENUM_TO_CHAR(DISCONNECTED)
1823 CASE_ENUM_TO_CHAR(STOPPED)
1824 CASE_ENUM_TO_CHAR(WAITING_FOR_PREVIEW_WINDOW)
1825 CASE_ENUM_TO_CHAR(PREVIEW)
1826 CASE_ENUM_TO_CHAR(RECORD)
1827 CASE_ENUM_TO_CHAR(STILL_CAPTURE)
1828 CASE_ENUM_TO_CHAR(VIDEO_SNAPSHOT)
1829 default:
1830 return "Unknown state!";
1831 break;
1832 }
1833#undef CASE_ENUM_TO_CHAR
1834}
1835
1836int Parameters::formatStringToEnum(const char *format) {
1837 return
Eino-Ville Talvala4c6b0b82012-09-10 09:53:09 -0700[diff] [blame]1838 !format ?
1839 HAL_PIXEL_FORMAT_YCrCb_420_SP :
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1840 !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV422SP) ?
1841 HAL_PIXEL_FORMAT_YCbCr_422_SP : // NV16
1842 !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV420SP) ?
1843 HAL_PIXEL_FORMAT_YCrCb_420_SP : // NV21
1844 !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV422I) ?
1845 HAL_PIXEL_FORMAT_YCbCr_422_I : // YUY2
1846 !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV420P) ?
1847 HAL_PIXEL_FORMAT_YV12 : // YV12
1848 !strcmp(format, CameraParameters::PIXEL_FORMAT_RGB565) ?
1849 HAL_PIXEL_FORMAT_RGB_565 : // RGB565
1850 !strcmp(format, CameraParameters::PIXEL_FORMAT_RGBA8888) ?
1851 HAL_PIXEL_FORMAT_RGBA_8888 : // RGB8888
1852 !strcmp(format, CameraParameters::PIXEL_FORMAT_BAYER_RGGB) ?
1853 HAL_PIXEL_FORMAT_RAW_SENSOR : // Raw sensor data
1854 -1;
1855}
1856
1857const char* Parameters::formatEnumToString(int format) {
1858 const char *fmt;
1859 switch(format) {
1860 case HAL_PIXEL_FORMAT_YCbCr_422_SP: // NV16
1861 fmt = CameraParameters::PIXEL_FORMAT_YUV422SP;
1862 break;
1863 case HAL_PIXEL_FORMAT_YCrCb_420_SP: // NV21
1864 fmt = CameraParameters::PIXEL_FORMAT_YUV420SP;
1865 break;
1866 case HAL_PIXEL_FORMAT_YCbCr_422_I: // YUY2
1867 fmt = CameraParameters::PIXEL_FORMAT_YUV422I;
1868 break;
1869 case HAL_PIXEL_FORMAT_YV12: // YV12
1870 fmt = CameraParameters::PIXEL_FORMAT_YUV420P;
1871 break;
1872 case HAL_PIXEL_FORMAT_RGB_565: // RGB565
1873 fmt = CameraParameters::PIXEL_FORMAT_RGB565;
1874 break;
1875 case HAL_PIXEL_FORMAT_RGBA_8888: // RGBA8888
1876 fmt = CameraParameters::PIXEL_FORMAT_RGBA8888;
1877 break;
1878 case HAL_PIXEL_FORMAT_RAW_SENSOR:
1879 ALOGW("Raw sensor preview format requested.");
1880 fmt = CameraParameters::PIXEL_FORMAT_BAYER_RGGB;
1881 break;
1882 default:
1883 ALOGE("%s: Unknown preview format: %x",
1884 __FUNCTION__, format);
1885 fmt = NULL;
1886 break;
1887 }
1888 return fmt;
1889}
1890
1891int Parameters::wbModeStringToEnum(const char *wbMode) {
1892 return
Eino-Ville Talvala4c6b0b82012-09-10 09:53:09 -0700[diff] [blame]1893 !wbMode ?
1894 ANDROID_CONTROL_AWB_AUTO :
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1895 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_AUTO) ?
1896 ANDROID_CONTROL_AWB_AUTO :
1897 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_INCANDESCENT) ?
1898 ANDROID_CONTROL_AWB_INCANDESCENT :
1899 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_FLUORESCENT) ?
1900 ANDROID_CONTROL_AWB_FLUORESCENT :
1901 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_WARM_FLUORESCENT) ?
1902 ANDROID_CONTROL_AWB_WARM_FLUORESCENT :
1903 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_DAYLIGHT) ?
1904 ANDROID_CONTROL_AWB_DAYLIGHT :
1905 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT) ?
1906 ANDROID_CONTROL_AWB_CLOUDY_DAYLIGHT :
1907 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_TWILIGHT) ?
1908 ANDROID_CONTROL_AWB_TWILIGHT :
1909 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_SHADE) ?
1910 ANDROID_CONTROL_AWB_SHADE :
1911 -1;
1912}
1913
Eino-Ville Talvalac85f8262012-10-02 13:30:04 -0700[diff] [blame]1914const char* Parameters::wbModeEnumToString(uint8_t wbMode) {
1915 switch (wbMode) {
1916 case ANDROID_CONTROL_AWB_AUTO:
1917 return CameraParameters::WHITE_BALANCE_AUTO;
1918 case ANDROID_CONTROL_AWB_INCANDESCENT:
1919 return CameraParameters::WHITE_BALANCE_INCANDESCENT;
1920 case ANDROID_CONTROL_AWB_FLUORESCENT:
1921 return CameraParameters::WHITE_BALANCE_FLUORESCENT;
1922 case ANDROID_CONTROL_AWB_WARM_FLUORESCENT:
1923 return CameraParameters::WHITE_BALANCE_WARM_FLUORESCENT;
1924 case ANDROID_CONTROL_AWB_DAYLIGHT:
1925 return CameraParameters::WHITE_BALANCE_DAYLIGHT;
1926 case ANDROID_CONTROL_AWB_CLOUDY_DAYLIGHT:
1927 return CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT;
1928 case ANDROID_CONTROL_AWB_TWILIGHT:
1929 return CameraParameters::WHITE_BALANCE_TWILIGHT;
1930 case ANDROID_CONTROL_AWB_SHADE:
1931 return CameraParameters::WHITE_BALANCE_SHADE;
1932 default:
1933 ALOGE("%s: Unknown AWB mode enum: %d",
1934 __FUNCTION__, wbMode);
1935 return "unknown";
1936 }
1937}
1938
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1939int Parameters::effectModeStringToEnum(const char *effectMode) {
1940 return
Eino-Ville Talvala4c6b0b82012-09-10 09:53:09 -0700[diff] [blame]1941 !effectMode ?
1942 ANDROID_CONTROL_EFFECT_OFF :
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1943 !strcmp(effectMode, CameraParameters::EFFECT_NONE) ?
1944 ANDROID_CONTROL_EFFECT_OFF :
1945 !strcmp(effectMode, CameraParameters::EFFECT_MONO) ?
1946 ANDROID_CONTROL_EFFECT_MONO :
1947 !strcmp(effectMode, CameraParameters::EFFECT_NEGATIVE) ?
1948 ANDROID_CONTROL_EFFECT_NEGATIVE :
1949 !strcmp(effectMode, CameraParameters::EFFECT_SOLARIZE) ?
1950 ANDROID_CONTROL_EFFECT_SOLARIZE :
1951 !strcmp(effectMode, CameraParameters::EFFECT_SEPIA) ?
1952 ANDROID_CONTROL_EFFECT_SEPIA :
1953 !strcmp(effectMode, CameraParameters::EFFECT_POSTERIZE) ?
1954 ANDROID_CONTROL_EFFECT_POSTERIZE :
1955 !strcmp(effectMode, CameraParameters::EFFECT_WHITEBOARD) ?
1956 ANDROID_CONTROL_EFFECT_WHITEBOARD :
1957 !strcmp(effectMode, CameraParameters::EFFECT_BLACKBOARD) ?
1958 ANDROID_CONTROL_EFFECT_BLACKBOARD :
1959 !strcmp(effectMode, CameraParameters::EFFECT_AQUA) ?
1960 ANDROID_CONTROL_EFFECT_AQUA :
1961 -1;
1962}
1963
1964int Parameters::abModeStringToEnum(const char *abMode) {
1965 return
Eino-Ville Talvala4c6b0b82012-09-10 09:53:09 -0700[diff] [blame]1966 !abMode ?
1967 ANDROID_CONTROL_AE_ANTIBANDING_AUTO :
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1968 !strcmp(abMode, CameraParameters::ANTIBANDING_AUTO) ?
1969 ANDROID_CONTROL_AE_ANTIBANDING_AUTO :
1970 !strcmp(abMode, CameraParameters::ANTIBANDING_OFF) ?
1971 ANDROID_CONTROL_AE_ANTIBANDING_OFF :
1972 !strcmp(abMode, CameraParameters::ANTIBANDING_50HZ) ?
1973 ANDROID_CONTROL_AE_ANTIBANDING_50HZ :
1974 !strcmp(abMode, CameraParameters::ANTIBANDING_60HZ) ?
1975 ANDROID_CONTROL_AE_ANTIBANDING_60HZ :
1976 -1;
1977}
1978
1979int Parameters::sceneModeStringToEnum(const char *sceneMode) {
1980 return
Eino-Ville Talvala4c6b0b82012-09-10 09:53:09 -0700[diff] [blame]1981 !sceneMode ?
1982 ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED :
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]1983 !strcmp(sceneMode, CameraParameters::SCENE_MODE_AUTO) ?
1984 ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED :
1985 !strcmp(sceneMode, CameraParameters::SCENE_MODE_ACTION) ?
1986 ANDROID_CONTROL_SCENE_MODE_ACTION :
1987 !strcmp(sceneMode, CameraParameters::SCENE_MODE_PORTRAIT) ?
1988 ANDROID_CONTROL_SCENE_MODE_PORTRAIT :
1989 !strcmp(sceneMode, CameraParameters::SCENE_MODE_LANDSCAPE) ?
1990 ANDROID_CONTROL_SCENE_MODE_LANDSCAPE :
1991 !strcmp(sceneMode, CameraParameters::SCENE_MODE_NIGHT) ?
1992 ANDROID_CONTROL_SCENE_MODE_NIGHT :
1993 !strcmp(sceneMode, CameraParameters::SCENE_MODE_NIGHT_PORTRAIT) ?
1994 ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT :
1995 !strcmp(sceneMode, CameraParameters::SCENE_MODE_THEATRE) ?
1996 ANDROID_CONTROL_SCENE_MODE_THEATRE :
1997 !strcmp(sceneMode, CameraParameters::SCENE_MODE_BEACH) ?
1998 ANDROID_CONTROL_SCENE_MODE_BEACH :
1999 !strcmp(sceneMode, CameraParameters::SCENE_MODE_SNOW) ?
2000 ANDROID_CONTROL_SCENE_MODE_SNOW :
2001 !strcmp(sceneMode, CameraParameters::SCENE_MODE_SUNSET) ?
2002 ANDROID_CONTROL_SCENE_MODE_SUNSET :
2003 !strcmp(sceneMode, CameraParameters::SCENE_MODE_STEADYPHOTO) ?
2004 ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO :
2005 !strcmp(sceneMode, CameraParameters::SCENE_MODE_FIREWORKS) ?
2006 ANDROID_CONTROL_SCENE_MODE_FIREWORKS :
2007 !strcmp(sceneMode, CameraParameters::SCENE_MODE_SPORTS) ?
2008 ANDROID_CONTROL_SCENE_MODE_SPORTS :
2009 !strcmp(sceneMode, CameraParameters::SCENE_MODE_PARTY) ?
2010 ANDROID_CONTROL_SCENE_MODE_PARTY :
2011 !strcmp(sceneMode, CameraParameters::SCENE_MODE_CANDLELIGHT) ?
2012 ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT :
2013 !strcmp(sceneMode, CameraParameters::SCENE_MODE_BARCODE) ?
2014 ANDROID_CONTROL_SCENE_MODE_BARCODE:
2015 -1;
2016}
2017
2018Parameters::Parameters::flashMode_t Parameters::flashModeStringToEnum(
2019 const char *flashMode) {
2020 return
Eino-Ville Talvala4c6b0b82012-09-10 09:53:09 -0700[diff] [blame]2021 !flashMode ?
2022 Parameters::FLASH_MODE_INVALID :
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]2023 !strcmp(flashMode, CameraParameters::FLASH_MODE_OFF) ?
2024 Parameters::FLASH_MODE_OFF :
2025 !strcmp(flashMode, CameraParameters::FLASH_MODE_AUTO) ?
2026 Parameters::FLASH_MODE_AUTO :
2027 !strcmp(flashMode, CameraParameters::FLASH_MODE_ON) ?
2028 Parameters::FLASH_MODE_ON :
2029 !strcmp(flashMode, CameraParameters::FLASH_MODE_RED_EYE) ?
2030 Parameters::FLASH_MODE_RED_EYE :
2031 !strcmp(flashMode, CameraParameters::FLASH_MODE_TORCH) ?
2032 Parameters::FLASH_MODE_TORCH :
2033 Parameters::FLASH_MODE_INVALID;
2034}
2035
Eino-Ville Talvalac85f8262012-10-02 13:30:04 -0700[diff] [blame]2036const char *Parameters::flashModeEnumToString(flashMode_t flashMode) {
2037 switch (flashMode) {
2038 case FLASH_MODE_OFF:
2039 return CameraParameters::FLASH_MODE_OFF;
2040 case FLASH_MODE_AUTO:
2041 return CameraParameters::FLASH_MODE_AUTO;
2042 case FLASH_MODE_ON:
2043 return CameraParameters::FLASH_MODE_ON;
2044 case FLASH_MODE_RED_EYE:
2045 return CameraParameters::FLASH_MODE_RED_EYE;
2046 case FLASH_MODE_TORCH:
2047 return CameraParameters::FLASH_MODE_TORCH;
2048 default:
2049 ALOGE("%s: Unknown flash mode enum %d",
2050 __FUNCTION__, flashMode);
2051 return "unknown";
2052 }
2053}
2054
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]2055Parameters::Parameters::focusMode_t Parameters::focusModeStringToEnum(
2056 const char *focusMode) {
2057 return
Eino-Ville Talvala4c6b0b82012-09-10 09:53:09 -0700[diff] [blame]2058 !focusMode ?
2059 Parameters::FOCUS_MODE_INVALID :
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]2060 !strcmp(focusMode, CameraParameters::FOCUS_MODE_AUTO) ?
2061 Parameters::FOCUS_MODE_AUTO :
2062 !strcmp(focusMode, CameraParameters::FOCUS_MODE_INFINITY) ?
2063 Parameters::FOCUS_MODE_INFINITY :
2064 !strcmp(focusMode, CameraParameters::FOCUS_MODE_MACRO) ?
2065 Parameters::FOCUS_MODE_MACRO :
2066 !strcmp(focusMode, CameraParameters::FOCUS_MODE_FIXED) ?
2067 Parameters::FOCUS_MODE_FIXED :
2068 !strcmp(focusMode, CameraParameters::FOCUS_MODE_EDOF) ?
2069 Parameters::FOCUS_MODE_EDOF :
2070 !strcmp(focusMode, CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO) ?
2071 Parameters::FOCUS_MODE_CONTINUOUS_VIDEO :
2072 !strcmp(focusMode, CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE) ?
2073 Parameters::FOCUS_MODE_CONTINUOUS_PICTURE :
2074 Parameters::FOCUS_MODE_INVALID;
2075}
2076
Eino-Ville Talvalac85f8262012-10-02 13:30:04 -0700[diff] [blame]2077const char *Parameters::focusModeEnumToString(focusMode_t focusMode) {
2078 switch (focusMode) {
2079 case FOCUS_MODE_AUTO:
2080 return CameraParameters::FOCUS_MODE_AUTO;
2081 case FOCUS_MODE_MACRO:
2082 return CameraParameters::FOCUS_MODE_MACRO;
2083 case FOCUS_MODE_CONTINUOUS_VIDEO:
2084 return CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO;
2085 case FOCUS_MODE_CONTINUOUS_PICTURE:
2086 return CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE;
2087 case FOCUS_MODE_EDOF:
2088 return CameraParameters::FOCUS_MODE_EDOF;
2089 case FOCUS_MODE_INFINITY:
2090 return CameraParameters::FOCUS_MODE_INFINITY;
2091 case FOCUS_MODE_FIXED:
2092 return CameraParameters::FOCUS_MODE_FIXED;
2093 default:
2094 ALOGE("%s: Unknown focus mode enum: %d",
2095 __FUNCTION__, focusMode);
2096 return "unknown";
2097 }
2098}
2099
James Painterc3dbf1a2012-09-05 18:02:32 -0700[diff] [blame]2100Parameters::Parameters::lightFxMode_t Parameters::lightFxStringToEnum(
2101 const char *lightFxMode) {
2102 return
Eino-Ville Talvala4c6b0b82012-09-10 09:53:09 -0700[diff] [blame]2103 !lightFxMode ?
2104 Parameters::LIGHTFX_NONE :
James Painterc3dbf1a2012-09-05 18:02:32 -0700[diff] [blame]2105 !strcmp(lightFxMode, CameraParameters::LIGHTFX_LOWLIGHT) ?
2106 Parameters::LIGHTFX_LOWLIGHT :
2107 !strcmp(lightFxMode, CameraParameters::LIGHTFX_HDR) ?
2108 Parameters::LIGHTFX_HDR :
2109 Parameters::LIGHTFX_NONE;
2110}
2111
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]2112status_t Parameters::parseAreas(const char *areasCStr,
2113 Vector<Parameters::Area> *areas) {
2114 static const size_t NUM_FIELDS = 5;
2115 areas->clear();
2116 if (areasCStr == NULL) {
2117 // If no key exists, use default (0,0,0,0,0)
2118 areas->push();
2119 return OK;
2120 }
2121 String8 areasStr(areasCStr);
2122 ssize_t areaStart = areasStr.find("(", 0) + 1;
2123 while (areaStart != 0) {
2124 const char* area = areasStr.string() + areaStart;
2125 char *numEnd;
2126 int vals[NUM_FIELDS];
2127 for (size_t i = 0; i < NUM_FIELDS; i++) {
2128 errno = 0;
2129 vals[i] = strtol(area, &numEnd, 10);
2130 if (errno || numEnd == area) return BAD_VALUE;
2131 area = numEnd + 1;
2132 }
2133 areas->push(Parameters::Area(
2134 vals[0], vals[1], vals[2], vals[3], vals[4]) );
2135 areaStart = areasStr.find("(", areaStart) + 1;
2136 }
2137 return OK;
2138}
2139
2140status_t Parameters::validateAreas(const Vector<Parameters::Area> &areas,
Igor Murashkin572bf9a2012-10-05 17:09:09 -0700[diff] [blame]2141 size_t maxRegions,
2142 AreaKind areaKind) const {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]2143 // Definition of valid area can be found in
2144 // include/camera/CameraParameters.h
2145 if (areas.size() == 0) return BAD_VALUE;
2146 if (areas.size() == 1) {
2147 if (areas[0].left == 0 &&
2148 areas[0].top == 0 &&
2149 areas[0].right == 0 &&
2150 areas[0].bottom == 0 &&
2151 areas[0].weight == 0) {
2152 // Single (0,0,0,0,0) entry is always valid (== driver decides)
2153 return OK;
2154 }
2155 }
Igor Murashkin572bf9a2012-10-05 17:09:09 -0700[diff] [blame]2156
2157 // fixed focus can only set (0,0,0,0,0) focus area
2158 if (areaKind == AREA_KIND_FOCUS && focusMode == FOCUS_MODE_FIXED) {
2159 return BAD_VALUE;
2160 }
2161
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]2162 if (areas.size() > maxRegions) {
2163 ALOGE("%s: Too many areas requested: %d",
2164 __FUNCTION__, areas.size());
2165 return BAD_VALUE;
2166 }
2167
2168 for (Vector<Parameters::Area>::const_iterator a = areas.begin();
2169 a != areas.end(); a++) {
2170 if (a->weight < 1 || a->weight > 1000) return BAD_VALUE;
2171 if (a->left < -1000 || a->left > 1000) return BAD_VALUE;
2172 if (a->top < -1000 || a->top > 1000) return BAD_VALUE;
2173 if (a->right < -1000 || a->right > 1000) return BAD_VALUE;
2174 if (a->bottom < -1000 || a->bottom > 1000) return BAD_VALUE;
2175 if (a->left >= a->right) return BAD_VALUE;
2176 if (a->top >= a->bottom) return BAD_VALUE;
2177 }
2178 return OK;
2179}
2180
2181bool Parameters::boolFromString(const char *boolStr) {
2182 return !boolStr ? false :
2183 !strcmp(boolStr, CameraParameters::TRUE) ? true :
2184 false;
2185}
2186
2187int Parameters::degToTransform(int degrees, bool mirror) {
2188 if (!mirror) {
2189 if (degrees == 0) return 0;
2190 else if (degrees == 90) return HAL_TRANSFORM_ROT_90;
2191 else if (degrees == 180) return HAL_TRANSFORM_ROT_180;
2192 else if (degrees == 270) return HAL_TRANSFORM_ROT_270;
2193 } else { // Do mirror (horizontal flip)
2194 if (degrees == 0) { // FLIP_H and ROT_0
2195 return HAL_TRANSFORM_FLIP_H;
2196 } else if (degrees == 90) { // FLIP_H and ROT_90
2197 return HAL_TRANSFORM_FLIP_H | HAL_TRANSFORM_ROT_90;
2198 } else if (degrees == 180) { // FLIP_H and ROT_180
2199 return HAL_TRANSFORM_FLIP_V;
2200 } else if (degrees == 270) { // FLIP_H and ROT_270
2201 return HAL_TRANSFORM_FLIP_V | HAL_TRANSFORM_ROT_90;
2202 }
2203 }
2204 ALOGE("%s: Bad input: %d", __FUNCTION__, degrees);
2205 return -1;
2206}
2207
Igor Murashkin3a6e4532012-09-28 15:30:03 -0700[diff] [blame]2208int Parameters::cropXToArray(int x) const {
2209 ALOG_ASSERT(x >= 0, "Crop-relative X coordinate = '%d' is out of bounds"
2210 "(lower = 0)", x);
2211
2212 CropRegion previewCrop = calculateCropRegion(CropRegion::OUTPUT_PREVIEW);
2213 ALOG_ASSERT(x < previewCrop.width, "Crop-relative X coordinate = '%d' "
2214 "is out of bounds (upper = %d)", x, previewCrop.width);
2215
2216 int ret = x + previewCrop.left;
2217
2218 ALOG_ASSERT( (ret >= 0 && ret < fastInfo.arrayWidth),
2219 "Calculated pixel array value X = '%d' is out of bounds (upper = %d)",
2220 ret, fastInfo.arrayWidth);
2221 return ret;
2222}
2223
2224int Parameters::cropYToArray(int y) const {
2225 ALOG_ASSERT(y >= 0, "Crop-relative Y coordinate = '%d' is out of bounds "
2226 "(lower = 0)", y);
2227
2228 CropRegion previewCrop = calculateCropRegion(CropRegion::OUTPUT_PREVIEW);
2229 ALOG_ASSERT(y < previewCrop.height, "Crop-relative Y coordinate = '%d' is "
2230 "out of bounds (upper = %d)", y, previewCrop.height);
2231
2232 int ret = y + previewCrop.top;
2233
2234 ALOG_ASSERT( (ret >= 0 && ret < fastInfo.arrayHeight),
2235 "Calculated pixel array value Y = '%d' is out of bounds (upper = %d)",
2236 ret, fastInfo.arrayHeight);
2237
2238 return ret;
2239
2240}
2241
2242int Parameters::normalizedXToCrop(int x) const {
2243 CropRegion previewCrop = calculateCropRegion(CropRegion::OUTPUT_PREVIEW);
2244 return (x + 1000) * (previewCrop.width - 1) / 2000;
2245}
2246
2247int Parameters::normalizedYToCrop(int y) const {
2248 CropRegion previewCrop = calculateCropRegion(CropRegion::OUTPUT_PREVIEW);
2249 return (y + 1000) * (previewCrop.height - 1) / 2000;
2250}
2251
2252int Parameters::arrayXToCrop(int x) const {
2253 CropRegion previewCrop = calculateCropRegion(CropRegion::OUTPUT_PREVIEW);
2254 return x - previewCrop.left;
2255}
2256
2257int Parameters::arrayYToCrop(int y) const {
2258 CropRegion previewCrop = calculateCropRegion(CropRegion::OUTPUT_PREVIEW);
2259 return y - previewCrop.top;
2260}
2261
2262int Parameters::cropXToNormalized(int x) const {
2263 CropRegion previewCrop = calculateCropRegion(CropRegion::OUTPUT_PREVIEW);
2264 return x * 2000 / (previewCrop.width - 1) - 1000;
2265}
2266
2267int Parameters::cropYToNormalized(int y) const {
2268 CropRegion previewCrop = calculateCropRegion(CropRegion::OUTPUT_PREVIEW);
2269 return y * 2000 / (previewCrop.height - 1) - 1000;
2270}
2271
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]2272int Parameters::arrayXToNormalized(int width) const {
Igor Murashkin3a6e4532012-09-28 15:30:03 -0700[diff] [blame]2273 int ret = cropXToNormalized(arrayXToCrop(width));
2274
2275 ALOG_ASSERT(ret >= -1000, "Calculated normalized value out of "
2276 "lower bounds %d", ret);
2277 ALOG_ASSERT(ret <= 1000, "Calculated normalized value out of "
2278 "upper bounds %d", ret);
2279
2280 // Work-around for HAL pre-scaling the coordinates themselves
2281 if (quirks.meteringCropRegion) {
2282 return width * 2000 / (fastInfo.arrayWidth - 1) - 1000;
2283 }
2284
2285 return ret;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]2286}
2287
2288int Parameters::arrayYToNormalized(int height) const {
Igor Murashkin3a6e4532012-09-28 15:30:03 -0700[diff] [blame]2289 int ret = cropYToNormalized(arrayYToCrop(height));
2290
2291 ALOG_ASSERT(ret >= -1000, "Calculated normalized value out of lower bounds"
2292 " %d", ret);
2293 ALOG_ASSERT(ret <= 1000, "Calculated normalized value out of upper bounds"
2294 " %d", ret);
2295
2296 // Work-around for HAL pre-scaling the coordinates themselves
2297 if (quirks.meteringCropRegion) {
2298 return height * 2000 / (fastInfo.arrayHeight - 1) - 1000;
2299 }
2300
2301 return ret;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]2302}
2303
2304int Parameters::normalizedXToArray(int x) const {
Igor Murashkin3a6e4532012-09-28 15:30:03 -0700[diff] [blame]2305
2306 // Work-around for HAL pre-scaling the coordinates themselves
2307 if (quirks.meteringCropRegion) {
2308 return (x + 1000) * (fastInfo.arrayWidth - 1) / 2000;
2309 }
2310
2311 return cropXToArray(normalizedXToCrop(x));
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]2312}
2313
2314int Parameters::normalizedYToArray(int y) const {
Igor Murashkin3a6e4532012-09-28 15:30:03 -0700[diff] [blame]2315 // Work-around for HAL pre-scaling the coordinates themselves
2316 if (quirks.meteringCropRegion) {
2317 return (y + 1000) * (fastInfo.arrayHeight - 1) / 2000;
2318 }
2319
2320 return cropYToArray(normalizedYToCrop(y));
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]2321}
2322
Igor Murashkin3a6e4532012-09-28 15:30:03 -0700[diff] [blame]2323Parameters::CropRegion Parameters::calculateCropRegion(
2324 Parameters::CropRegion::Outputs outputs) const {
Igor Murashkine500bc22012-09-18 18:23:49 -0700[diff] [blame]2325
2326 float zoomLeft, zoomTop, zoomWidth, zoomHeight;
2327
2328 // Need to convert zoom index into a crop rectangle. The rectangle is
2329 // chosen to maximize its area on the sensor
2330
2331 camera_metadata_ro_entry_t maxDigitalZoom =
2332 staticInfo(ANDROID_SCALER_AVAILABLE_MAX_ZOOM);
2333 // For each zoom step by how many pixels more do we change the zoom
2334 float zoomIncrement = (maxDigitalZoom.data.f[0] - 1) /
2335 (NUM_ZOOM_STEPS-1);
2336 // The desired activeAreaWidth/cropAreaWidth ratio (or height if h>w)
2337 // via interpolating zoom step into a zoom ratio
2338 float zoomRatio = 1 + zoomIncrement * zoom;
2339 ALOG_ASSERT( (zoomRatio >= 1.f && zoomRatio <= maxDigitalZoom.data.f[0]),
2340 "Zoom ratio calculated out of bounds. Expected 1 - %f, actual: %f",
2341 maxDigitalZoom.data.f[0], zoomRatio);
2342
2343 ALOGV("Zoom maxDigital=%f, increment=%f, ratio=%f, previewWidth=%d, "
2344 "previewHeight=%d, activeWidth=%d, activeHeight=%d",
2345 maxDigitalZoom.data.f[0], zoomIncrement, zoomRatio, previewWidth,
2346 previewHeight, fastInfo.arrayWidth, fastInfo.arrayHeight);
2347
2348 /*
2349 * Assumption: On the HAL side each stream buffer calculates its crop
2350 * rectangle as follows:
2351 * cropRect = (zoomLeft, zoomRight,
2352 * zoomWidth, zoomHeight * zoomWidth / outputWidth);
2353 *
2354 * Note that if zoomWidth > bufferWidth, the new cropHeight > zoomHeight
2355 * (we can then get into trouble if the cropHeight > arrayHeight).
2356 * By selecting the zoomRatio based on the smallest outputRatio, we
2357 * guarantee this will never happen.
2358 */
2359
2360 // Enumerate all possible output sizes, select the one with the smallest
2361 // aspect ratio
2362 float minOutputWidth, minOutputHeight, minOutputRatio;
2363 {
2364 float outputSizes[][2] = {
2365 { previewWidth, previewHeight },
2366 { videoWidth, videoHeight },
Igor Murashkin3a6e4532012-09-28 15:30:03 -0700[diff] [blame]2367 { jpegThumbSize[0], jpegThumbSize[1] },
Igor Murashkine500bc22012-09-18 18:23:49 -0700[diff] [blame]2368 { pictureWidth, pictureHeight },
2369 };
2370
2371 minOutputWidth = outputSizes[0][0];
2372 minOutputHeight = outputSizes[0][1];
2373 minOutputRatio = minOutputWidth / minOutputHeight;
2374 for (unsigned int i = 0;
2375 i < sizeof(outputSizes) / sizeof(outputSizes[0]);
2376 ++i) {
2377
Igor Murashkin3a6e4532012-09-28 15:30:03 -0700[diff] [blame]2378 // skip over outputs we don't want to consider for the crop region
2379 if ( !((1 << i) & outputs) ) {
2380 continue;
2381 }
2382
Igor Murashkine500bc22012-09-18 18:23:49 -0700[diff] [blame]2383 float outputWidth = outputSizes[i][0];
2384 float outputHeight = outputSizes[i][1];
2385 float outputRatio = outputWidth / outputHeight;
2386
2387 if (minOutputRatio > outputRatio) {
2388 minOutputRatio = outputRatio;
2389 minOutputWidth = outputWidth;
2390 minOutputHeight = outputHeight;
2391 }
2392
2393 // and then use this output ratio instead of preview output ratio
2394 ALOGV("Enumerating output ratio %f = %f / %f, min is %f",
2395 outputRatio, outputWidth, outputHeight, minOutputRatio);
2396 }
2397 }
2398
2399 /* Ensure that the width/height never go out of bounds
2400 * by scaling across a diffent dimension if an out-of-bounds
2401 * possibility exists.
2402 *
2403 * e.g. if the previewratio < arrayratio and e.g. zoomratio = 1.0, then by
2404 * calculating the zoomWidth from zoomHeight we'll actually get a
2405 * zoomheight > arrayheight
2406 */
2407 float arrayRatio = 1.f * fastInfo.arrayWidth / fastInfo.arrayHeight;
2408 if (minOutputRatio >= arrayRatio) {
2409 // Adjust the height based on the width
2410 zoomWidth = fastInfo.arrayWidth / zoomRatio;
2411 zoomHeight = zoomWidth *
2412 minOutputHeight / minOutputWidth;
2413
2414 } else {
2415 // Adjust the width based on the height
2416 zoomHeight = fastInfo.arrayHeight / zoomRatio;
2417 zoomWidth = zoomHeight *
2418 minOutputWidth / minOutputHeight;
2419 }
2420 // centering the zoom area within the active area
2421 zoomLeft = (fastInfo.arrayWidth - zoomWidth) / 2;
2422 zoomTop = (fastInfo.arrayHeight - zoomHeight) / 2;
2423
2424 ALOGV("Crop region calculated (x=%d,y=%d,w=%f,h=%f) for zoom=%d",
2425 (int32_t)zoomLeft, (int32_t)zoomTop, zoomWidth, zoomHeight, this->zoom);
2426
2427
2428 CropRegion crop = { zoomLeft, zoomTop, zoomWidth, zoomHeight };
2429 return crop;
2430}
2431
Igor Murashkinebe3f692012-10-12 16:56:11 -0700[diff] [blame^]2432int32_t Parameters::fpsFromRange(int32_t /*min*/, int32_t max) const {
Igor Murashkin63dc1992012-10-04 14:22:18 -0700[diff] [blame]2433 return max;
2434}
2435
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700[diff] [blame]2436}; // namespace camera2
2437}; // namespace android