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