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