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