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