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