Camera2Client.cpp revision f69c70ded4316ea3ee504ac779bd024433ed4ef7 
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 "Camera2Client"
18//#define LOG_NDEBUG 0
19#include <utils/Log.h>
20
21#include <cutils/properties.h>
22#include <gui/SurfaceTextureClient.h>
23#include <gui/Surface.h>
24
25#include <math.h>
26
27#include "Camera2Client.h"
28
29namespace android {
30
31#define ALOG1(...) ALOGD_IF(gLogLevel >= 1, __VA_ARGS__);
32#define ALOG2(...) ALOGD_IF(gLogLevel >= 2, __VA_ARGS__);
33
34#define ALOG1_ENTRY        \
35    int callingPid = getCallingPid(); \
36    ALOG1("%s: E (pid %d, id %d) ", __FUNCTION__, \
37            callingPid, mCameraId)
38
39#define ALOG1_EXIT        \
40    ALOG1("%s: X (pid %d, id %d) ", __FUNCTION__, \
41            callingPid, mCameraId)
42
43static int getCallingPid() {
44    return IPCThreadState::self()->getCallingPid();
45}
46
47static int getCallingUid() {
48    return IPCThreadState::self()->getCallingUid();
49}
50
51// Interface used by CameraService
52
53Camera2Client::Camera2Client(const sp<CameraService>& cameraService,
54        const sp<ICameraClient>& cameraClient,
55        int cameraId,
56        int cameraFacing,
57        int clientPid):
58        Client(cameraService, cameraClient,
59                cameraId, cameraFacing, clientPid),
60        mParams(NULL)
61{
62    ALOG1_ENTRY;
63
64    mDevice = new Camera2Device(cameraId);
65
66    ALOG1_EXIT;
67}
68
69status_t Camera2Client::initialize(camera_module_t *module)
70{
71    ALOG1_ENTRY;
72    status_t res;
73
74    res = mDevice->initialize(module);
75    if (res != OK) {
76        ALOGE("%s: Camera %d: unable to initialize device: %s (%d)",
77                __FUNCTION__, mCameraId, strerror(-res), res);
78        return NO_INIT;
79    }
80
81    res = buildDefaultParameters();
82    if (res != OK) {
83        ALOGE("%s: Camera %d: unable to build defaults: %s (%d)",
84                __FUNCTION__, mCameraId, strerror(-res), res);
85        return NO_INIT;
86    }
87    if (gLogLevel >= 1) {
88        ALOGD("%s: Default parameters converted from camera %d:", __FUNCTION__,
89              mCameraId);
90        mParams->dump();
91    }
92
93    ALOG1_EXIT;
94    return OK;
95}
96
97Camera2Client::~Camera2Client() {
98    mDestructionStarted = true;
99
100    if (mParams) delete mParams;
101
102    disconnect();
103}
104
105status_t Camera2Client::dump(int fd, const Vector<String16>& args) {
106    return BAD_VALUE;
107}
108
109// ICamera interface
110
111void Camera2Client::disconnect() {
112
113    if (mDevice == 0) return;
114
115    mDevice->setStreamingRequest(NULL);
116
117    CameraService::Client::disconnect();
118}
119
120status_t Camera2Client::connect(const sp<ICameraClient>& client) {
121    return BAD_VALUE;
122}
123
124status_t Camera2Client::lock() {
125    return BAD_VALUE;
126}
127
128status_t Camera2Client::unlock() {
129    return BAD_VALUE;
130}
131
132status_t Camera2Client::setPreviewDisplay(const sp<Surface>& surface) {
133    return BAD_VALUE;
134}
135
136status_t Camera2Client::setPreviewTexture(const sp<ISurfaceTexture>& surfaceTexture) {
137    return BAD_VALUE;
138}
139
140void Camera2Client::setPreviewCallbackFlag(int flag) {
141
142}
143
144status_t Camera2Client::startPreview() {
145    return BAD_VALUE;
146}
147
148void Camera2Client::stopPreview() {
149
150}
151
152bool Camera2Client::previewEnabled() {
153    return false;
154}
155
156status_t Camera2Client::storeMetaDataInBuffers(bool enabled) {
157    return BAD_VALUE;
158}
159
160status_t Camera2Client::startRecording() {
161    return BAD_VALUE;
162}
163
164void Camera2Client::stopRecording() {
165}
166
167bool Camera2Client::recordingEnabled() {
168    return BAD_VALUE;
169}
170
171void Camera2Client::releaseRecordingFrame(const sp<IMemory>& mem) {
172
173}
174
175status_t Camera2Client::autoFocus() {
176    return BAD_VALUE;
177}
178
179status_t Camera2Client::cancelAutoFocus() {
180    return BAD_VALUE;
181}
182
183status_t Camera2Client::takePicture(int msgType) {
184    return BAD_VALUE;
185}
186
187status_t Camera2Client::setParameters(const String8& params) {
188    return BAD_VALUE;
189}
190
191String8 Camera2Client::getParameters() const {
192    return mParams->flatten();
193}
194
195status_t Camera2Client::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) {
196    return BAD_VALUE;
197}
198
199// private methods
200
201status_t Camera2Client::buildDefaultParameters() {
202    status_t res;
203    if (mParams) {
204        delete mParams;
205    }
206    mParams = new CameraParameters;
207
208    camera_metadata_entry_t availableProcessedSizes;
209    res = find_camera_metadata_entry(mDevice->info(),
210            ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES,
211            &availableProcessedSizes);
212    if (res != OK) return res;
213    if (availableProcessedSizes.count < 2) {
214        ALOGE("%s: Camera %d: "
215                "Malformed %s entry",
216                __FUNCTION__, mCameraId,
217                get_camera_metadata_tag_name(
218                    ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES));
219        return NO_INIT;
220    }
221
222    // TODO: Pick more intelligently
223    int previewWidth = availableProcessedSizes.data.i32[0];
224    int previewHeight = availableProcessedSizes.data.i32[1];
225
226    mParams->setPreviewSize(previewWidth, previewHeight);
227    mParams->setVideoSize(previewWidth, previewHeight);
228    mParams->set(CameraParameters::KEY_PREFERRED_PREVIEW_SIZE_FOR_VIDEO,
229            String8::format("%dx%d",previewWidth,previewHeight));
230    {
231        String8 supportedPreviewSizes;
232        for (size_t i=0; i < availableProcessedSizes.count; i += 2) {
233            if (i != 0) supportedPreviewSizes += ",";
234            supportedPreviewSizes += String8::format("%dx%d",
235                    availableProcessedSizes.data.i32[i],
236                    availableProcessedSizes.data.i32[i+1]);
237        }
238        mParams->set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES,
239                supportedPreviewSizes);
240        mParams->set(CameraParameters::KEY_SUPPORTED_VIDEO_SIZES,
241                supportedPreviewSizes);
242    }
243
244    camera_metadata_entry_t availableFpsRanges;
245    res = find_camera_metadata_entry(mDevice->info(),
246            ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES,
247            &availableFpsRanges);
248    if (res != OK) return res;
249    if (availableFpsRanges.count < 2) {
250        ALOGE("%s: Camera %d: "
251                "Malformed %s entry",
252                __FUNCTION__, mCameraId,
253                get_camera_metadata_tag_name(
254                    ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES));
255        return NO_INIT;
256    }
257
258    int previewFpsRangeMin = availableFpsRanges.data.i32[0];
259    int previewFpsRangeMax = availableFpsRanges.data.i32[1];
260
261    mParams->set(CameraParameters::KEY_PREVIEW_FPS_RANGE,
262            String8::format("%d,%d", previewFpsRangeMin, previewFpsRangeMax));
263
264    {
265        String8 supportedPreviewFpsRange;
266        for (size_t i=0; i < availableFpsRanges.count; i += 2) {
267            if (i != 0) supportedPreviewFpsRange += ",";
268            supportedPreviewFpsRange += String8::format("(%d,%d)",
269                    availableFpsRanges.data.i32[i],
270                    availableFpsRanges.data.i32[i+1]);
271        }
272        mParams->set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE,
273                supportedPreviewFpsRange);
274    }
275
276    mParams->set(CameraParameters::KEY_PREVIEW_FORMAT,
277            "yuv420sp"); // NV21
278
279    camera_metadata_entry_t availableFormats;
280    res = find_camera_metadata_entry(mDevice->info(),
281            ANDROID_SCALER_AVAILABLE_FORMATS,
282            &availableFormats);
283    {
284        String8 supportedPreviewFormats;
285        bool addComma = false;
286        for (size_t i=0; i < availableFormats.count; i++) {
287            if (addComma) supportedPreviewFormats += ",";
288            addComma = true;
289            switch (availableFormats.data.i32[i]) {
290            case HAL_PIXEL_FORMAT_YCbCr_422_SP:
291                supportedPreviewFormats += "yuv422sp";
292                break;
293            case HAL_PIXEL_FORMAT_YCrCb_420_SP:
294                supportedPreviewFormats += "yuv420sp";
295                break;
296            case HAL_PIXEL_FORMAT_YCbCr_422_I:
297                supportedPreviewFormats += "yuv422i-yuyv";
298                break;
299            case HAL_PIXEL_FORMAT_YV12:
300                supportedPreviewFormats += "yuv420p";
301                break;
302            case HAL_PIXEL_FORMAT_RGB_565:
303                supportedPreviewFormats += "rgb565";
304                break;
305                // Not advertizing JPEG, RAW_SENSOR, etc, for preview formats
306            case HAL_PIXEL_FORMAT_RAW_SENSOR:
307                addComma = false;
308                break;
309            default:
310                ALOGW("%s: Camera %d: Unknown preview format: %x",
311                        __FUNCTION__, mCameraId, availableFormats.data.i32[i]);
312                addComma = false;
313                break;
314            }
315        }
316        mParams->set(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS,
317                supportedPreviewFormats);
318    }
319
320    // PREVIEW_FRAME_RATE / SUPPORTED_PREVIEW_FRAME_RATES are deprecated, but
321    // still have to do something sane for them
322
323    mParams->set(CameraParameters::KEY_PREVIEW_FRAME_RATE,
324            previewFpsRangeMin);
325
326    {
327        String8 supportedPreviewFrameRates;
328        for (size_t i=0; i < availableFpsRanges.count; i += 2) {
329            if (i != 0) supportedPreviewFrameRates += ",";
330            supportedPreviewFrameRates += String8::format("%d",
331                    availableFpsRanges.data.i32[i]);
332        }
333        mParams->set(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES,
334                supportedPreviewFrameRates);
335    }
336
337    camera_metadata_entry_t availableJpegSizes;
338    res = find_camera_metadata_entry(mDevice->info(),
339            ANDROID_SCALER_AVAILABLE_JPEG_SIZES,
340            &availableJpegSizes);
341    if (res != OK) return res;
342    if (availableJpegSizes.count < 2) {
343        ALOGE("%s: Camera %d: "
344                "Malformed %s entry",
345                __FUNCTION__, mCameraId,
346                get_camera_metadata_tag_name(
347                    ANDROID_SCALER_AVAILABLE_JPEG_SIZES));
348        return NO_INIT;
349    }
350
351    // TODO: Pick maximum
352    int32_t pictureWidth = availableJpegSizes.data.i32[0];
353    int32_t pictureHeight = availableJpegSizes.data.i32[1];
354
355    mParams->setPictureSize(pictureWidth, pictureHeight);
356
357    {
358        String8 supportedPictureSizes;
359        for (size_t i=0; i < availableJpegSizes.count; i += 2) {
360            if (i != 0) supportedPictureSizes += ",";
361            supportedPictureSizes += String8::format("%dx%d",
362                    availableJpegSizes.data.i32[i],
363                    availableJpegSizes.data.i32[i+1]);
364        }
365        mParams->set(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES,
366                supportedPictureSizes);
367    }
368
369    mParams->setPictureFormat("jpeg");
370
371    mParams->set(CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS,
372            "jpeg");
373
374    camera_metadata_entry_t availableJpegThumbnailSizes;
375    res = find_camera_metadata_entry(mDevice->info(),
376            ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES,
377            &availableJpegThumbnailSizes);
378    if (res != OK) return res;
379    if (availableJpegThumbnailSizes.count < 2) {
380        ALOGE("%s: Camera %d: "
381                "Malformed %s entry",
382                __FUNCTION__, mCameraId,
383                get_camera_metadata_tag_name(
384                    ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES));
385        return NO_INIT;
386    }
387
388    // TODO: Pick default thumbnail size sensibly
389    int32_t jpegThumbWidth = availableJpegThumbnailSizes.data.i32[0];
390    int32_t jpegThumbHeight = availableJpegThumbnailSizes.data.i32[1];
391
392    mParams->set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH,
393            jpegThumbWidth);
394    mParams->set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT,
395            jpegThumbHeight);
396
397    {
398        String8 supportedJpegThumbSizes;
399        for (size_t i=0; i < availableJpegThumbnailSizes.count; i += 2) {
400            if (i != 0) supportedJpegThumbSizes += ",";
401            supportedJpegThumbSizes += String8::format("%dx%d",
402                    availableJpegThumbnailSizes.data.i32[i],
403                    availableJpegThumbnailSizes.data.i32[i+1]);
404        }
405        mParams->set(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES,
406                supportedJpegThumbSizes);
407    }
408
409    mParams->set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY,
410            "90");
411    mParams->set(CameraParameters::KEY_JPEG_QUALITY,
412            "90");
413    mParams->set(CameraParameters::KEY_ROTATION,
414            "0");
415    // Not settting GPS fields
416
417    mParams->set(CameraParameters::KEY_WHITE_BALANCE,
418            "auto");
419
420    camera_metadata_entry_t availableWhiteBalanceModes;
421    res = find_camera_metadata_entry(mDevice->info(),
422            ANDROID_CONTROL_AWB_AVAILABLE_MODES,
423            &availableWhiteBalanceModes);
424    {
425        String8 supportedWhiteBalance;
426        bool addComma = false;
427        for (size_t i=0; i < availableWhiteBalanceModes.count; i++) {
428            if (addComma) supportedWhiteBalance += ",";
429            addComma = true;
430            switch (availableWhiteBalanceModes.data.u8[i]) {
431            case ANDROID_CONTROL_AWB_AUTO:
432                supportedWhiteBalance += "auto";
433                break;
434            case ANDROID_CONTROL_AWB_INCANDESCENT:
435                supportedWhiteBalance += "incandescent";
436                break;
437            case ANDROID_CONTROL_AWB_FLUORESCENT:
438                supportedWhiteBalance += "fluorescent";
439                break;
440            case ANDROID_CONTROL_AWB_WARM_FLUORESCENT:
441                supportedWhiteBalance += "warm-fluorescent";
442                break;
443            case ANDROID_CONTROL_AWB_DAYLIGHT:
444                supportedWhiteBalance += "daylight";
445                break;
446            case ANDROID_CONTROL_AWB_CLOUDY_DAYLIGHT:
447                supportedWhiteBalance += "cloudy-daylight";
448                break;
449            case ANDROID_CONTROL_AWB_TWILIGHT:
450                supportedWhiteBalance += "twilight";
451                break;
452            case ANDROID_CONTROL_AWB_SHADE:
453                supportedWhiteBalance += "shade";
454                break;
455            // Skipping values not mappable to v1 API
456            case ANDROID_CONTROL_AWB_OFF:
457                addComma = false;
458                break;
459            default:
460                ALOGW("%s: Camera %d: Unknown white balance value: %d",
461                        __FUNCTION__, mCameraId,
462                        availableWhiteBalanceModes.data.u8[i]);
463                addComma = false;
464                break;
465            }
466        }
467        mParams->set(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE,
468                supportedWhiteBalance);
469    }
470
471    mParams->set(CameraParameters::KEY_EFFECT, "none");
472    camera_metadata_entry_t availableEffects;
473    res = find_camera_metadata_entry(mDevice->info(),
474            ANDROID_CONTROL_AVAILABLE_EFFECTS,
475            &availableEffects);
476    if (res != OK) return res;
477    {
478        String8 supportedEffects;
479        bool addComma = false;
480        for (size_t i=0; i < availableEffects.count; i++) {
481            if (addComma) supportedEffects += ",";
482            addComma = true;
483            switch (availableEffects.data.u8[i]) {
484                case ANDROID_CONTROL_EFFECT_OFF:
485                    supportedEffects += "none";
486                    break;
487                case ANDROID_CONTROL_EFFECT_MONO:
488                    supportedEffects += "mono";
489                case ANDROID_CONTROL_EFFECT_NEGATIVE:
490                    supportedEffects += "negative";
491                    break;
492                case ANDROID_CONTROL_EFFECT_SOLARIZE:
493                    supportedEffects += "solarize";
494                    break;
495                case ANDROID_CONTROL_EFFECT_SEPIA:
496                    supportedEffects += "sepia";
497                    break;
498                case ANDROID_CONTROL_EFFECT_POSTERIZE:
499                    supportedEffects += "posterize";
500                    break;
501                case ANDROID_CONTROL_EFFECT_WHITEBOARD:
502                    supportedEffects += "whiteboard";
503                    break;
504                case ANDROID_CONTROL_EFFECT_BLACKBOARD:
505                    supportedEffects += "blackboard";
506                    break;
507                case ANDROID_CONTROL_EFFECT_AQUA:
508                    supportedEffects += "aqua";
509                    break;
510                default:
511                    ALOGW("%s: Camera %d: Unknown effect value: %d",
512                        __FUNCTION__, mCameraId, availableEffects.data.u8[i]);
513                    addComma = false;
514                    break;
515            }
516        }
517        mParams->set(CameraParameters::KEY_SUPPORTED_EFFECTS, supportedEffects);
518    }
519
520    mParams->set(CameraParameters::KEY_ANTIBANDING, "auto");
521    camera_metadata_entry_t availableAntibandingModes;
522    res = find_camera_metadata_entry(mDevice->info(),
523            ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES,
524            &availableAntibandingModes);
525    if (res != OK) return res;
526    {
527        String8 supportedAntibanding;
528        bool addComma = false;
529        for (size_t i=0; i < availableAntibandingModes.count; i++) {
530            if (addComma) supportedAntibanding += ",";
531            addComma = true;
532            switch (availableAntibandingModes.data.u8[i]) {
533                case ANDROID_CONTROL_AE_ANTIBANDING_OFF:
534                    supportedAntibanding += "off";
535                    break;
536                case ANDROID_CONTROL_AE_ANTIBANDING_50HZ:
537                    supportedAntibanding += "50hz";
538                    break;
539                case ANDROID_CONTROL_AE_ANTIBANDING_60HZ:
540                    supportedAntibanding += "60hz";
541                    break;
542                case ANDROID_CONTROL_AE_ANTIBANDING_AUTO:
543                    supportedAntibanding += "auto";
544                    break;
545                default:
546                    ALOGW("%s: Camera %d: Unknown antibanding value: %d",
547                        __FUNCTION__, mCameraId,
548                            availableAntibandingModes.data.u8[i]);
549                    addComma = false;
550                    break;
551            }
552        }
553        mParams->set(CameraParameters::KEY_SUPPORTED_ANTIBANDING,
554                supportedAntibanding);
555    }
556
557    mParams->set(CameraParameters::KEY_SCENE_MODE, "auto");
558    camera_metadata_entry_t availableSceneModes;
559    res = find_camera_metadata_entry(mDevice->info(),
560            ANDROID_CONTROL_AVAILABLE_SCENE_MODES,
561            &availableSceneModes);
562    if (res != OK) return res;
563    {
564        String8 supportedSceneModes("auto");
565        bool addComma = true;
566        bool noSceneModes = false;
567        for (size_t i=0; i < availableSceneModes.count; i++) {
568            if (addComma) supportedSceneModes += ",";
569            addComma = true;
570            switch (availableSceneModes.data.u8[i]) {
571                case ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED:
572                    noSceneModes = true;
573                    break;
574                case ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY:
575                    // Not in old API
576                    addComma = false;
577                    break;
578                case ANDROID_CONTROL_SCENE_MODE_ACTION:
579                    supportedSceneModes += "action";
580                    break;
581                case ANDROID_CONTROL_SCENE_MODE_PORTRAIT:
582                    supportedSceneModes += "portrait";
583                    break;
584                case ANDROID_CONTROL_SCENE_MODE_LANDSCAPE:
585                    supportedSceneModes += "landscape";
586                    break;
587                case ANDROID_CONTROL_SCENE_MODE_NIGHT:
588                    supportedSceneModes += "night";
589                    break;
590                case ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT:
591                    supportedSceneModes += "night-portrait";
592                    break;
593                case ANDROID_CONTROL_SCENE_MODE_THEATRE:
594                    supportedSceneModes += "theatre";
595                    break;
596                case ANDROID_CONTROL_SCENE_MODE_BEACH:
597                    supportedSceneModes += "beach";
598                    break;
599                case ANDROID_CONTROL_SCENE_MODE_SNOW:
600                    supportedSceneModes += "snow";
601                    break;
602                case ANDROID_CONTROL_SCENE_MODE_SUNSET:
603                    supportedSceneModes += "sunset";
604                    break;
605                case ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO:
606                    supportedSceneModes += "steadyphoto";
607                    break;
608                case ANDROID_CONTROL_SCENE_MODE_FIREWORKS:
609                    supportedSceneModes += "fireworks";
610                    break;
611                case ANDROID_CONTROL_SCENE_MODE_SPORTS:
612                    supportedSceneModes += "sports";
613                    break;
614                case ANDROID_CONTROL_SCENE_MODE_PARTY:
615                    supportedSceneModes += "party";
616                    break;
617                case ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT:
618                    supportedSceneModes += "candlelight";
619                    break;
620                case ANDROID_CONTROL_SCENE_MODE_BARCODE:
621                    supportedSceneModes += "barcode";
622                    break;
623                default:
624                    ALOGW("%s: Camera %d: Unknown scene mode value: %d",
625                        __FUNCTION__, mCameraId, availableSceneModes.data.u8[i]);
626                    addComma = false;
627                    break;
628            }
629        }
630        if (!noSceneModes) {
631            mParams->set(CameraParameters::KEY_SUPPORTED_SCENE_MODES,
632                    supportedSceneModes);
633        }
634    }
635
636    camera_metadata_entry_t flashAvailable;
637    res = find_camera_metadata_entry(mDevice->info(),
638            ANDROID_FLASH_AVAILABLE, &flashAvailable);
639    if (res != OK) return res;
640
641    camera_metadata_entry_t availableAeModes;
642    res = find_camera_metadata_entry(mDevice->info(),
643            ANDROID_CONTROL_AE_AVAILABLE_MODES,
644            &availableAeModes);
645    if (res != OK) return res;
646
647    if (flashAvailable.data.u8[0]) {
648        mParams->set(CameraParameters::KEY_FLASH_MODE, "auto");
649        String8 supportedFlashModes("off,auto,on,torch");
650        for (size_t i=0; i < availableAeModes.count; i++) {
651            if (availableAeModes.data.u8[i] ==
652                    ANDROID_CONTROL_AE_ON_AUTO_FLASH_REDEYE) {
653                supportedFlashModes += ",red-eye";
654                break;
655            }
656        }
657        mParams->set(CameraParameters::KEY_SUPPORTED_FLASH_MODES,
658                supportedFlashModes);
659    }
660
661    camera_metadata_entry_t minFocusDistance;
662    res = find_camera_metadata_entry(mDevice->info(),
663            ANDROID_LENS_MINIMUM_FOCUS_DISTANCE,
664            &minFocusDistance);
665    if (res != OK) return res;
666    camera_metadata_entry_t availableAfModes;
667    res = find_camera_metadata_entry(mDevice->info(),
668            ANDROID_CONTROL_AF_AVAILABLE_MODES,
669            &availableAfModes);
670    if (res != OK) return res;
671    if (minFocusDistance.data.f[0] == 0) {
672        // Fixed-focus lens
673        mParams->set(CameraParameters::KEY_FOCUS_MODE, "fixed");
674        mParams->set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES, "fixed");
675    } else {
676        mParams->set(CameraParameters::KEY_FOCUS_MODE, "auto");
677        String8 supportedFocusModes("fixed,infinity");
678        bool addComma = true;
679        for (size_t i=0; i < availableAfModes.count; i++) {
680            if (addComma) supportedFocusModes += ",";
681            addComma = true;
682            switch (availableAfModes.data.u8[i]) {
683                case ANDROID_CONTROL_AF_AUTO:
684                    supportedFocusModes += "auto";
685                    break;
686                case ANDROID_CONTROL_AF_MACRO:
687                    supportedFocusModes += "macro";
688                    break;
689                case ANDROID_CONTROL_AF_CONTINUOUS_VIDEO:
690                    supportedFocusModes += "continuous-video";
691                    break;
692                case ANDROID_CONTROL_AF_CONTINUOUS_PICTURE:
693                    supportedFocusModes += "continuous-picture";
694                    break;
695                case ANDROID_CONTROL_AF_EDOF:
696                    supportedFocusModes += "edof";
697                    break;
698                // Not supported in v1 API
699                case ANDROID_CONTROL_AF_OFF:
700                    addComma = false;
701                    break;
702                default:
703                    ALOGW("%s: Camera %d: Unknown AF mode value: %d",
704                        __FUNCTION__, mCameraId, availableAfModes.data.u8[i]);
705                    addComma = false;
706                    break;
707            }
708        }
709        mParams->set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES,
710                supportedFocusModes);
711    }
712
713    camera_metadata_entry_t max3aRegions;
714    res = find_camera_metadata_entry(mDevice->info(),
715            ANDROID_CONTROL_MAX_REGIONS, &max3aRegions);
716    if (res != OK) return res;
717
718    mParams->set(CameraParameters::KEY_MAX_NUM_FOCUS_AREAS,
719            max3aRegions.data.i32[0]);
720    mParams->set(CameraParameters::KEY_FOCUS_AREAS,
721            "(0,0,0,0,0)");
722
723    camera_metadata_entry_t availableFocalLengths;
724    res = find_camera_metadata_entry(mDevice->info(),
725            ANDROID_LENS_AVAILABLE_FOCAL_LENGTHS,
726            &availableFocalLengths);
727    if (res != OK) return res;
728    float minFocalLength = availableFocalLengths.data.f[0];
729    mParams->setFloat(CameraParameters::KEY_FOCAL_LENGTH, minFocalLength);
730
731    camera_metadata_entry_t sensorSize;
732    res = find_camera_metadata_entry(mDevice->info(),
733            ANDROID_SENSOR_PHYSICAL_SIZE,
734            &sensorSize);
735    if (res != OK) return res;
736
737    // The fields of view here assume infinity focus, maximum wide angle
738    float horizFov = 180 / M_PI *
739            2 * atanf(sensorSize.data.f[0] / (2 * minFocalLength));
740    float vertFov  = 180 / M_PI *
741            2 * atanf(sensorSize.data.f[1] / (2 * minFocalLength));
742    mParams->setFloat(CameraParameters::KEY_HORIZONTAL_VIEW_ANGLE, horizFov);
743    mParams->setFloat(CameraParameters::KEY_VERTICAL_VIEW_ANGLE, vertFov);
744
745    mParams->set(CameraParameters::KEY_EXPOSURE_COMPENSATION, 0);
746
747    camera_metadata_entry_t exposureCompensationRange;
748    res = find_camera_metadata_entry(mDevice->info(),
749            ANDROID_CONTROL_AE_EXP_COMPENSATION_RANGE,
750            &exposureCompensationRange);
751    if (res != OK) return res;
752    mParams->set(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION,
753            exposureCompensationRange.data.i32[1]);
754    mParams->set(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION,
755            exposureCompensationRange.data.i32[0]);
756
757    camera_metadata_entry_t exposureCompensationStep;
758    res = find_camera_metadata_entry(mDevice->info(),
759            ANDROID_CONTROL_AE_EXP_COMPENSATION_STEP,
760            &exposureCompensationStep);
761    if (res != OK) return res;
762    mParams->setFloat(CameraParameters::KEY_EXPOSURE_COMPENSATION_STEP,
763            exposureCompensationStep.data.r[0].numerator /
764            exposureCompensationStep.data.r[0].denominator);
765
766    mParams->set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK, "false");
767    mParams->set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED, "true");
768
769    mParams->set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, "false");
770    mParams->set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED, "true");
771
772    mParams->set(CameraParameters::KEY_MAX_NUM_METERING_AREAS,
773            max3aRegions.data.i32[0]);
774    mParams->set(CameraParameters::KEY_METERING_AREAS,
775            "(0,0,0,0,0)");
776
777    mParams->set(CameraParameters::KEY_ZOOM, 0);
778    mParams->set(CameraParameters::KEY_MAX_ZOOM, kNumZoomSteps - 1);
779
780    camera_metadata_entry_t maxDigitalZoom;
781    res = find_camera_metadata_entry(mDevice->info(),
782            ANDROID_SCALER_AVAILABLE_MAX_ZOOM, &maxDigitalZoom);
783    if (res != OK) return res;
784
785    {
786        String8 zoomRatios;
787        float zoom = 1.f;
788        float zoomIncrement = (maxDigitalZoom.data.f[0] - zoom) /
789                (kNumZoomSteps-1);
790        bool addComma = false;
791        for (size_t i=0; i < kNumZoomSteps; i++) {
792            if (addComma) zoomRatios += ",";
793            addComma = true;
794            zoomRatios += String8::format("%d", static_cast<int>(zoom * 100));
795            zoom += zoomIncrement;
796        }
797        mParams->set(CameraParameters::KEY_ZOOM_RATIOS, zoomRatios);
798    }
799
800    mParams->set(CameraParameters::KEY_ZOOM_SUPPORTED, "true");
801    mParams->set(CameraParameters::KEY_SMOOTH_ZOOM_SUPPORTED, "true");
802
803    mParams->set(CameraParameters::KEY_FOCUS_DISTANCES,
804            "Infinity,Infinity,Infinity");
805
806    camera_metadata_entry_t maxFacesDetected;
807    res = find_camera_metadata_entry(mDevice->info(),
808            ANDROID_STATS_MAX_FACE_COUNT,
809            &maxFacesDetected);
810    mParams->set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_HW,
811            maxFacesDetected.data.i32[0]);
812    mParams->set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_SW,
813            0);
814
815    mParams->set(CameraParameters::KEY_VIDEO_FRAME_FORMAT,
816            "yuv420sp");
817
818    mParams->set(CameraParameters::KEY_RECORDING_HINT,
819            "false");
820
821    mParams->set(CameraParameters::KEY_VIDEO_SNAPSHOT_SUPPORTED,
822            "true");
823
824    mParams->set(CameraParameters::KEY_VIDEO_STABILIZATION,
825            "false");
826
827    camera_metadata_entry_t availableVideoStabilizationModes;
828    res = find_camera_metadata_entry(mDevice->info(),
829            ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES,
830            &availableVideoStabilizationModes);
831    if (res != OK) return res;
832    if (availableVideoStabilizationModes.count > 1) {
833        mParams->set(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED,
834                "true");
835    } else {
836        mParams->set(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED,
837                "false");
838    }
839
840    return OK;
841}
842
843} // namespace android
844