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