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