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