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