Camera2Client.cpp revision bd47b7bcfe7f5a97fef81143f4282c41590626fe 
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 ATRACE_TAG ATRACE_TAG_CAMERA
19//#define LOG_NDEBUG 0
20
21#include <utils/Log.h>
22#include <utils/Trace.h>
23
24#include <cutils/properties.h>
25#include <gui/SurfaceTextureClient.h>
26#include <gui/Surface.h>
27
28#include <math.h>
29
30#include "Camera2Client.h"
31
32namespace android {
33
34#define ALOG1(...) ALOGD_IF(gLogLevel >= 1, __VA_ARGS__);
35#define ALOG2(...) ALOGD_IF(gLogLevel >= 2, __VA_ARGS__);
36
37static int getCallingPid() {
38    return IPCThreadState::self()->getCallingPid();
39}
40
41static int getCallingUid() {
42    return IPCThreadState::self()->getCallingUid();
43}
44
45// Interface used by CameraService
46
47Camera2Client::Camera2Client(const sp<CameraService>& cameraService,
48        const sp<ICameraClient>& cameraClient,
49        int cameraId,
50        int cameraFacing,
51        int clientPid):
52        Client(cameraService, cameraClient,
53                cameraId, cameraFacing, clientPid),
54        mState(NOT_INITIALIZED),
55        mPreviewStreamId(NO_PREVIEW_STREAM),
56        mPreviewRequest(NULL)
57{
58    ATRACE_CALL();
59
60    mDevice = new Camera2Device(cameraId);
61}
62
63status_t Camera2Client::initialize(camera_module_t *module)
64{
65    ATRACE_CALL();
66    status_t res;
67
68    res = mDevice->initialize(module);
69    if (res != OK) {
70        ALOGE("%s: Camera %d: unable to initialize device: %s (%d)",
71                __FUNCTION__, mCameraId, strerror(-res), res);
72        return NO_INIT;
73    }
74
75    res = buildDefaultParameters();
76    if (res != OK) {
77        ALOGE("%s: Camera %d: unable to build defaults: %s (%d)",
78                __FUNCTION__, mCameraId, strerror(-res), res);
79        return NO_INIT;
80    }
81
82    if (gLogLevel >= 1) {
83        ALOGD("%s: Default parameters converted from camera %d:", __FUNCTION__,
84              mCameraId);
85        ALOGD("%s", mParamsFlattened.string());
86    }
87
88    mState = STOPPED;
89
90    return OK;
91}
92
93Camera2Client::~Camera2Client() {
94    ATRACE_CALL();
95    mDestructionStarted = true;
96
97    disconnect();
98
99}
100
101status_t Camera2Client::dump(int fd, const Vector<String16>& args) {
102    String8 result;
103    result.appendFormat("Client2[%d] (%p) PID: %d:\n",
104            mCameraId,
105            getCameraClient()->asBinder().get(),
106            mClientPid);
107    result.append("  State: ");
108#define CASE_APPEND_ENUM(x) case x: result.append(#x "\n"); break;
109
110    switch (mState) {
111        CASE_APPEND_ENUM(NOT_INITIALIZED)
112        CASE_APPEND_ENUM(STOPPED)
113        CASE_APPEND_ENUM(WAITING_FOR_PREVIEW_WINDOW)
114        CASE_APPEND_ENUM(PREVIEW)
115        CASE_APPEND_ENUM(RECORD)
116        CASE_APPEND_ENUM(STILL_CAPTURE)
117        default: result.append("UNKNOWN\n"); break;
118    }
119
120    result.append("  Current parameters:\n");
121    result.appendFormat("    Preview size: %d x %d\n",
122            mParameters.previewWidth, mParameters.previewHeight);
123    result.appendFormat("    Preview FPS range: %d - %d\n",
124            mParameters.previewFpsRangeMin, mParameters.previewFpsRangeMax);
125    result.appendFormat("    Preview HAL pixel format: 0x%x\n",
126            mParameters.previewFormat);
127    result.appendFormat("    Picture size: %d x %d\n",
128            mParameters.pictureWidth, mParameters.pictureHeight);
129    result.appendFormat("    Jpeg thumbnail size: %d x %d\n",
130            mParameters.jpegThumbWidth, mParameters.jpegThumbHeight);
131    result.appendFormat("    Jpeg quality: %d, thumbnail quality: %d\n",
132            mParameters.jpegQuality, mParameters.jpegThumbQuality);
133    result.appendFormat("    Jpeg rotation: %d\n", mParameters.jpegRotation);
134    result.appendFormat("    GPS tags %s\n",
135            mParameters.gpsEnabled ? "enabled" : "disabled");
136    if (mParameters.gpsEnabled) {
137        result.appendFormat("    GPS lat x long x alt: %f x %f x %f\n",
138                mParameters.gpsLatitude, mParameters.gpsLongitude,
139                mParameters.gpsAltitude);
140        result.appendFormat("    GPS timestamp: %lld\n",
141                mParameters.gpsTimestamp);
142        result.appendFormat("    GPS processing method: %s\n",
143                mParameters.gpsProcessingMethod.string());
144    }
145
146    result.append("    White balance mode: ");
147    switch (mParameters.wbMode) {
148        CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_AUTO)
149        CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_INCANDESCENT)
150        CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_FLUORESCENT)
151        CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_WARM_FLUORESCENT)
152        CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_DAYLIGHT)
153        CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_CLOUDY_DAYLIGHT)
154        CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_TWILIGHT)
155        CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_SHADE)
156        default: result.append("UNKNOWN\n");
157    }
158
159    result.append("    Effect mode: ");
160    switch (mParameters.effectMode) {
161        CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_OFF)
162        CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MONO)
163        CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_NEGATIVE)
164        CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_SOLARIZE)
165        CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_SEPIA)
166        CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_POSTERIZE)
167        CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_WHITEBOARD)
168        CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_BLACKBOARD)
169        CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_AQUA)
170        default: result.append("UNKNOWN\n");
171    }
172
173    result.append("    Antibanding mode: ");
174    switch (mParameters.antibandingMode) {
175        CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_AUTO)
176        CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_OFF)
177        CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_50HZ)
178        CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_60HZ)
179        default: result.append("UNKNOWN\n");
180    }
181
182    result.append("    Scene mode: ");
183    switch (mParameters.sceneMode) {
184        case ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED:
185            result.append("AUTO\n"); break;
186        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_ACTION)
187        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_PORTRAIT)
188        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_LANDSCAPE)
189        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_NIGHT)
190        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT)
191        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_THEATRE)
192        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_BEACH)
193        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SNOW)
194        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SUNSET)
195        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO)
196        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_FIREWORKS)
197        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SPORTS)
198        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_PARTY)
199        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT)
200        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_BARCODE)
201        default: result.append("UNKNOWN\n");
202    }
203
204    result.append("    Flash mode: ");
205    switch (mParameters.flashMode) {
206        CASE_APPEND_ENUM(Parameters::FLASH_MODE_OFF)
207        CASE_APPEND_ENUM(Parameters::FLASH_MODE_AUTO)
208        CASE_APPEND_ENUM(Parameters::FLASH_MODE_ON)
209        CASE_APPEND_ENUM(Parameters::FLASH_MODE_TORCH)
210        CASE_APPEND_ENUM(Parameters::FLASH_MODE_RED_EYE)
211        CASE_APPEND_ENUM(Parameters::FLASH_MODE_INVALID)
212        default: result.append("UNKNOWN\n");
213    }
214
215    result.append("    Focus mode: ");
216    switch (mParameters.focusMode) {
217        CASE_APPEND_ENUM(Parameters::FOCUS_MODE_AUTO)
218        CASE_APPEND_ENUM(Parameters::FOCUS_MODE_MACRO)
219        CASE_APPEND_ENUM(Parameters::FOCUS_MODE_CONTINUOUS_VIDEO)
220        CASE_APPEND_ENUM(Parameters::FOCUS_MODE_CONTINUOUS_PICTURE)
221        CASE_APPEND_ENUM(Parameters::FOCUS_MODE_EDOF)
222        CASE_APPEND_ENUM(Parameters::FOCUS_MODE_INFINITY)
223        CASE_APPEND_ENUM(Parameters::FOCUS_MODE_FIXED)
224        CASE_APPEND_ENUM(Parameters::FOCUS_MODE_INVALID)
225        default: result.append("UNKNOWN\n");
226    }
227
228    result.append("    Focusing areas:\n");
229    for (size_t i = 0; i < mParameters.focusingAreas.size(); i++) {
230        result.appendFormat("      [ (%d, %d, %d, %d), weight %d ]\n",
231                mParameters.focusingAreas[i].left,
232                mParameters.focusingAreas[i].top,
233                mParameters.focusingAreas[i].right,
234                mParameters.focusingAreas[i].bottom,
235                mParameters.focusingAreas[i].weight);
236    }
237
238    result.appendFormat("    Exposure compensation index: %d\n",
239            mParameters.exposureCompensation);
240
241    result.appendFormat("    AE lock %s, AWB lock %s\n",
242            mParameters.autoExposureLock ? "enabled" : "disabled",
243            mParameters.autoWhiteBalanceLock ? "enabled" : "disabled" );
244
245    result.appendFormat("    Metering areas:\n");
246    for (size_t i = 0; i < mParameters.meteringAreas.size(); i++) {
247        result.appendFormat("      [ (%d, %d, %d, %d), weight %d ]\n",
248                mParameters.meteringAreas[i].left,
249                mParameters.meteringAreas[i].top,
250                mParameters.meteringAreas[i].right,
251                mParameters.meteringAreas[i].bottom,
252                mParameters.meteringAreas[i].weight);
253    }
254
255    result.appendFormat("   Zoom index: %d\n", mParameters.zoom);
256    result.appendFormat("   Video size: %d x %d\n", mParameters.videoWidth,
257            mParameters.videoHeight);
258
259    result.appendFormat("   Recording hint is %s\n",
260            mParameters.recordingHint ? "set" : "not set");
261
262    result.appendFormat("   Video stabilization is %s\n",
263            mParameters.videoStabilization ? "enabled" : "disabled");
264
265    write(fd, result.string(), result.size());
266
267    // TODO: Dump Camera2Device
268
269#undef CASE_APPEND_ENUM
270    return NO_ERROR;
271}
272
273// ICamera interface
274
275void Camera2Client::disconnect() {
276    ATRACE_CALL();
277    Mutex::Autolock icl(mICameraLock);
278
279    if (mDevice == 0) return;
280
281    stopPreviewLocked();
282
283    if (mPreviewStreamId != NO_PREVIEW_STREAM) {
284        mDevice->deleteStream(mPreviewStreamId);
285        mPreviewStreamId = NO_PREVIEW_STREAM;
286    }
287
288    CameraService::Client::disconnect();
289}
290
291status_t Camera2Client::connect(const sp<ICameraClient>& client) {
292    ATRACE_CALL();
293    Mutex::Autolock icl(mICameraLock);
294
295    return BAD_VALUE;
296}
297
298status_t Camera2Client::lock() {
299    ATRACE_CALL();
300    Mutex::Autolock icl(mICameraLock);
301
302    return BAD_VALUE;
303}
304
305status_t Camera2Client::unlock() {
306    ATRACE_CALL();
307    Mutex::Autolock icl(mICameraLock);
308
309    return BAD_VALUE;
310}
311
312status_t Camera2Client::setPreviewDisplay(
313        const sp<Surface>& surface) {
314    ATRACE_CALL();
315    Mutex::Autolock icl(mICameraLock);
316
317    if (mState >= PREVIEW) return INVALID_OPERATION;
318
319    sp<IBinder> binder;
320    sp<ANativeWindow> window;
321    if (surface != 0) {
322        binder = surface->asBinder();
323        window = surface;
324    }
325
326    return setPreviewWindow(binder,window);
327}
328
329status_t Camera2Client::setPreviewTexture(
330        const sp<ISurfaceTexture>& surfaceTexture) {
331    ATRACE_CALL();
332    Mutex::Autolock icl(mICameraLock);
333
334    if (mState >= PREVIEW) return INVALID_OPERATION;
335
336    sp<IBinder> binder;
337    sp<ANativeWindow> window;
338    if (surfaceTexture != 0) {
339        binder = surfaceTexture->asBinder();
340        window = new SurfaceTextureClient(surfaceTexture);
341    }
342    return setPreviewWindow(binder, window);
343}
344
345status_t Camera2Client::setPreviewWindow(const sp<IBinder>& binder,
346        const sp<ANativeWindow>& window) {
347    ATRACE_CALL();
348    status_t res;
349
350    if (binder == mPreviewSurface) {
351        return NO_ERROR;
352    }
353
354    if (mPreviewStreamId != NO_PREVIEW_STREAM) {
355        res = mDevice->deleteStream(mPreviewStreamId);
356        if (res != OK) {
357            return res;
358        }
359    }
360    res = mDevice->createStream(window,
361            mParameters.previewWidth, mParameters.previewHeight,
362            CAMERA2_HAL_PIXEL_FORMAT_OPAQUE,
363            &mPreviewStreamId);
364    if (res != OK) {
365        return res;
366    }
367
368    mPreviewSurface = binder;
369
370    if (mState == WAITING_FOR_PREVIEW_WINDOW) {
371        return startPreview();
372    }
373
374    return OK;
375}
376
377void Camera2Client::setPreviewCallbackFlag(int flag) {
378    ATRACE_CALL();
379    Mutex::Autolock icl(mICameraLock);
380}
381
382status_t Camera2Client::startPreview() {
383    ATRACE_CALL();
384    Mutex::Autolock icl(mICameraLock);
385
386    status_t res;
387    if (mState == PREVIEW) return INVALID_OPERATION;
388
389    if (mPreviewStreamId == NO_PREVIEW_STREAM) {
390        mState = WAITING_FOR_PREVIEW_WINDOW;
391        return OK;
392    }
393
394    if (mPreviewRequest == NULL) {
395        updatePreviewRequest();
396    }
397
398    uint8_t outputStream = mPreviewStreamId;
399
400    camera_metadata_entry_t outputStreams;
401    res = find_camera_metadata_entry(mPreviewRequest,
402            ANDROID_REQUEST_OUTPUT_STREAMS,
403            &outputStreams);
404    if (res == NAME_NOT_FOUND) {
405        res = add_camera_metadata_entry(mPreviewRequest,
406                ANDROID_REQUEST_OUTPUT_STREAMS,
407                &outputStream, 1);
408    } else if (res == OK) {
409        res = update_camera_metadata_entry(mPreviewRequest,
410                outputStreams.index, &outputStream, 1, NULL);
411    }
412
413    if (res != OK) {
414        ALOGE("%s: Camera %d: Unable to set up preview request: %s (%d)",
415                __FUNCTION__, mCameraId, strerror(-res), res);
416        mState = STOPPED;
417        return res;
418    }
419
420    res = mDevice->setStreamingRequest(mPreviewRequest);
421    if (res != OK) {
422        ALOGE("%s: Camera %d: Unable to set preview request to start preview: "
423                "%s (%d)",
424                __FUNCTION__, mCameraId, strerror(-res), res);
425        mState = STOPPED;
426        return res;
427    }
428    mState = PREVIEW;
429
430    return OK;
431}
432
433void Camera2Client::stopPreview() {
434    ATRACE_CALL();
435    Mutex::Autolock icl(mICameraLock);
436    stopPreviewLocked();
437}
438
439void Camera2Client::stopPreviewLocked() {
440    ATRACE_CALL();
441    if (mState != PREVIEW) return;
442
443    mDevice->setStreamingRequest(NULL);
444    mState = STOPPED;
445}
446
447bool Camera2Client::previewEnabled() {
448    ATRACE_CALL();
449    Mutex::Autolock icl(mICameraLock);
450    return mState == PREVIEW;
451}
452
453status_t Camera2Client::storeMetaDataInBuffers(bool enabled) {
454    ATRACE_CALL();
455    Mutex::Autolock icl(mICameraLock);
456    return BAD_VALUE;
457}
458
459status_t Camera2Client::startRecording() {
460    ATRACE_CALL();
461    Mutex::Autolock icl(mICameraLock);
462    return BAD_VALUE;
463}
464
465void Camera2Client::stopRecording() {
466    ATRACE_CALL();
467    Mutex::Autolock icl(mICameraLock);
468}
469
470bool Camera2Client::recordingEnabled() {
471    ATRACE_CALL();
472    Mutex::Autolock icl(mICameraLock);
473    return BAD_VALUE;
474}
475
476void Camera2Client::releaseRecordingFrame(const sp<IMemory>& mem) {
477    ATRACE_CALL();
478    Mutex::Autolock icl(mICameraLock);
479}
480
481status_t Camera2Client::autoFocus() {
482    ATRACE_CALL();
483    Mutex::Autolock icl(mICameraLock);
484    return OK;
485}
486
487status_t Camera2Client::cancelAutoFocus() {
488    ATRACE_CALL();
489    Mutex::Autolock icl(mICameraLock);
490    return OK;
491}
492
493status_t Camera2Client::takePicture(int msgType) {
494    ATRACE_CALL();
495    Mutex::Autolock icl(mICameraLock);
496    return BAD_VALUE;
497}
498
499status_t Camera2Client::setParameters(const String8& params) {
500    ATRACE_CALL();
501    Mutex::Autolock icl(mICameraLock);
502    Mutex::Autolock pl(mParamsLock);
503    status_t res;
504
505    CameraParameters newParams(params);
506
507    // TODO: Currently ignoring any changes to supposedly read-only
508    // parameters such as supported preview sizes, etc. Should probably
509    // produce an error if they're changed.
510
511    /** Extract and verify new parameters */
512
513    size_t i;
514
515    // PREVIEW_SIZE
516    int previewWidth, previewHeight;
517    newParams.getPreviewSize(&previewWidth, &previewHeight);
518
519    if (previewWidth != mParameters.previewWidth ||
520            previewHeight != mParameters.previewHeight) {
521        if (mState >= PREVIEW) {
522            ALOGE("%s: Preview size cannot be updated when preview "
523                    "is active!", __FUNCTION__);
524            return BAD_VALUE;
525        }
526        camera_metadata_entry_t availablePreviewSizes =
527            staticInfo(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES);
528        for (i = 0; i < availablePreviewSizes.count; i += 2 ) {
529            if (availablePreviewSizes.data.i32[i] == previewWidth &&
530                    availablePreviewSizes.data.i32[i+1] == previewHeight) break;
531        }
532        if (i == availablePreviewSizes.count) {
533            ALOGE("%s: Requested preview size %d x %d is not supported",
534                    __FUNCTION__, previewWidth, previewHeight);
535            return BAD_VALUE;
536        }
537    }
538
539    // PREVIEW_FPS_RANGE
540    int previewFpsRangeMin, previewFpsRangeMax, previewFps = 0;
541    bool fpsRangeChanged = false;
542    newParams.getPreviewFpsRange(&previewFpsRangeMin, &previewFpsRangeMax);
543    if (previewFpsRangeMin != mParameters.previewFpsRangeMin ||
544            previewFpsRangeMax != mParameters.previewFpsRangeMax) {
545        fpsRangeChanged = true;
546        camera_metadata_entry_t availablePreviewFpsRanges =
547            staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES, 2);
548        for (i = 0; i < availablePreviewFpsRanges.count; i += 2) {
549            if ((availablePreviewFpsRanges.data.i32[i] ==
550                    previewFpsRangeMin) &&
551                (availablePreviewFpsRanges.data.i32[i+1] ==
552                    previewFpsRangeMax) ) {
553                break;
554            }
555        }
556        if (i == availablePreviewFpsRanges.count) {
557            ALOGE("%s: Requested preview FPS range %d - %d is not supported",
558                __FUNCTION__, previewFpsRangeMin, previewFpsRangeMax);
559            return BAD_VALUE;
560        }
561        previewFps = previewFpsRangeMin;
562    }
563
564    // PREVIEW_FORMAT
565    int previewFormat = formatStringToEnum(newParams.getPreviewFormat());
566    if (previewFormat != mParameters.previewFormat) {
567        if (mState >= PREVIEW) {
568            ALOGE("%s: Preview format cannot be updated when preview "
569                    "is active!", __FUNCTION__);
570            return BAD_VALUE;
571        }
572        camera_metadata_entry_t availableFormats =
573            staticInfo(ANDROID_SCALER_AVAILABLE_FORMATS);
574        for (i = 0; i < availableFormats.count; i++) {
575            if (availableFormats.data.i32[i] == previewFormat) break;
576        }
577        if (i == availableFormats.count) {
578            ALOGE("%s: Requested preview format %s (0x%x) is not supported",
579                    __FUNCTION__, newParams.getPreviewFormat(), previewFormat);
580            return BAD_VALUE;
581        }
582    }
583
584    // PREVIEW_FRAME_RATE
585    // Deprecated, only use if the preview fps range is unchanged this time.
586    // The single-value FPS is the same as the minimum of the range.
587    if (!fpsRangeChanged) {
588        previewFps = newParams.getPreviewFrameRate();
589        if (previewFps != mParameters.previewFps) {
590            camera_metadata_entry_t availableFrameRates =
591                staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES);
592            for (i = 0; i < availableFrameRates.count; i+=2) {
593                if (availableFrameRates.data.i32[i] == previewFps) break;
594            }
595            if (i == availableFrameRates.count) {
596                ALOGE("%s: Requested preview frame rate %d is not supported",
597                        __FUNCTION__, previewFps);
598                return BAD_VALUE;
599            }
600            previewFpsRangeMin = availableFrameRates.data.i32[i];
601            previewFpsRangeMax = availableFrameRates.data.i32[i+1];
602        }
603    }
604
605    // PICTURE_SIZE
606    int pictureWidth, pictureHeight;
607    newParams.getPictureSize(&pictureWidth, &pictureHeight);
608    if (pictureWidth == mParameters.pictureWidth ||
609            pictureHeight == mParameters.pictureHeight) {
610        camera_metadata_entry_t availablePictureSizes =
611            staticInfo(ANDROID_SCALER_AVAILABLE_JPEG_SIZES);
612        for (i = 0; i < availablePictureSizes.count; i+=2) {
613            if (availablePictureSizes.data.i32[i] == pictureWidth &&
614                    availablePictureSizes.data.i32[i+1] == pictureHeight) break;
615        }
616        if (i == availablePictureSizes.count) {
617            ALOGE("%s: Requested picture size %d x %d is not supported",
618                    __FUNCTION__, pictureWidth, pictureHeight);
619            return BAD_VALUE;
620        }
621    }
622
623    // JPEG_THUMBNAIL_WIDTH/HEIGHT
624    int jpegThumbWidth, jpegThumbHeight;
625    jpegThumbWidth =
626            newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH);
627    jpegThumbHeight =
628            newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT);
629    if (jpegThumbWidth != mParameters.jpegThumbWidth ||
630            jpegThumbHeight != mParameters.jpegThumbHeight) {
631        camera_metadata_entry_t availableJpegThumbSizes =
632            staticInfo(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES);
633        for (i = 0; i < availableJpegThumbSizes.count; i+=2) {
634            if (availableJpegThumbSizes.data.i32[i] == jpegThumbWidth &&
635                    availableJpegThumbSizes.data.i32[i+1] == jpegThumbHeight) {
636                break;
637            }
638        }
639        if (i == availableJpegThumbSizes.count) {
640            ALOGE("%s: Requested JPEG thumbnail size %d x %d is not supported",
641                    __FUNCTION__, jpegThumbWidth, jpegThumbHeight);
642            return BAD_VALUE;
643        }
644    }
645
646    // JPEG_THUMBNAIL_QUALITY
647    int jpegThumbQuality =
648            newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY);
649    if (jpegThumbQuality < 0 || jpegThumbQuality > 100) {
650        ALOGE("%s: Requested JPEG thumbnail quality %d is not supported",
651                __FUNCTION__, jpegThumbQuality);
652        return BAD_VALUE;
653    }
654
655    // JPEG_QUALITY
656    int jpegQuality =
657            newParams.getInt(CameraParameters::KEY_JPEG_QUALITY);
658    if (jpegQuality < 0 || jpegQuality > 100) {
659        ALOGE("%s: Requested JPEG quality %d is not supported",
660                __FUNCTION__, jpegQuality);
661        return BAD_VALUE;
662    }
663
664    // ROTATION
665    int jpegRotation =
666            newParams.getInt(CameraParameters::KEY_ROTATION);
667    if (jpegRotation != 0 &&
668            jpegRotation != 90 &&
669            jpegRotation != 180 &&
670            jpegRotation != 270) {
671        ALOGE("%s: Requested picture rotation angle %d is not supported",
672                __FUNCTION__, jpegRotation);
673        return BAD_VALUE;
674    }
675
676    // GPS
677    bool gpsEnabled = false;
678    double gpsLatitude = 0, gpsLongitude = 0, gpsAltitude = 0;
679    int64_t gpsTimestamp = 0;
680    String8 gpsProcessingMethod;
681    const char *gpsLatStr =
682            newParams.get(CameraParameters::KEY_GPS_LATITUDE);
683    if (gpsLatStr != NULL) {
684        const char *gpsLongStr =
685                newParams.get(CameraParameters::KEY_GPS_LONGITUDE);
686        const char *gpsAltitudeStr =
687                newParams.get(CameraParameters::KEY_GPS_ALTITUDE);
688        const char *gpsTimeStr =
689                newParams.get(CameraParameters::KEY_GPS_TIMESTAMP);
690        const char *gpsProcMethodStr =
691                newParams.get(CameraParameters::KEY_GPS_PROCESSING_METHOD);
692        if (gpsLongStr == NULL ||
693                gpsAltitudeStr == NULL ||
694                gpsTimeStr == NULL ||
695                gpsProcMethodStr == NULL) {
696            ALOGE("%s: Incomplete set of GPS parameters provided",
697                    __FUNCTION__);
698            return BAD_VALUE;
699        }
700        char *endPtr;
701        errno = 0;
702        gpsLatitude = strtod(gpsLatStr, &endPtr);
703        if (errno || endPtr == gpsLatStr) {
704            ALOGE("%s: Malformed GPS latitude: %s", __FUNCTION__, gpsLatStr);
705            return BAD_VALUE;
706        }
707        errno = 0;
708        gpsLongitude = strtod(gpsLongStr, &endPtr);
709        if (errno || endPtr == gpsLongStr) {
710            ALOGE("%s: Malformed GPS longitude: %s", __FUNCTION__, gpsLongStr);
711            return BAD_VALUE;
712        }
713        errno = 0;
714        gpsAltitude = strtod(gpsAltitudeStr, &endPtr);
715        if (errno || endPtr == gpsAltitudeStr) {
716            ALOGE("%s: Malformed GPS altitude: %s", __FUNCTION__,
717                    gpsAltitudeStr);
718            return BAD_VALUE;
719        }
720        errno = 0;
721        gpsTimestamp = strtoll(gpsTimeStr, &endPtr, 10);
722        if (errno || endPtr == gpsTimeStr) {
723            ALOGE("%s: Malformed GPS timestamp: %s", __FUNCTION__, gpsTimeStr);
724            return BAD_VALUE;
725        }
726        gpsProcessingMethod = gpsProcMethodStr;
727
728        gpsEnabled = true;
729    }
730
731    // WHITE_BALANCE
732    int wbMode = wbModeStringToEnum(
733        newParams.get(CameraParameters::KEY_WHITE_BALANCE) );
734    if (wbMode != mParameters.wbMode) {
735        camera_metadata_entry_t availableWbModes =
736            staticInfo(ANDROID_CONTROL_AWB_AVAILABLE_MODES);
737        for (i = 0; i < availableWbModes.count; i++) {
738            if (wbMode == availableWbModes.data.u8[i]) break;
739        }
740        if (i == availableWbModes.count) {
741            ALOGE("%s: Requested white balance mode %s is not supported",
742                    __FUNCTION__,
743                    newParams.get(CameraParameters::KEY_WHITE_BALANCE));
744            return BAD_VALUE;
745        }
746    }
747
748    // EFFECT
749    int effectMode = effectModeStringToEnum(
750        newParams.get(CameraParameters::KEY_EFFECT) );
751    if (effectMode != mParameters.effectMode) {
752        camera_metadata_entry_t availableEffectModes =
753            staticInfo(ANDROID_CONTROL_AVAILABLE_EFFECTS);
754        for (i = 0; i < availableEffectModes.count; i++) {
755            if (effectMode == availableEffectModes.data.u8[i]) break;
756        }
757        if (i == availableEffectModes.count) {
758            ALOGE("%s: Requested effect mode \"%s\" is not supported",
759                    __FUNCTION__,
760                    newParams.get(CameraParameters::KEY_EFFECT) );
761            return BAD_VALUE;
762        }
763    }
764
765    // ANTIBANDING
766    int antibandingMode = abModeStringToEnum(
767        newParams.get(CameraParameters::KEY_ANTIBANDING) );
768    if (antibandingMode != mParameters.antibandingMode) {
769        camera_metadata_entry_t availableAbModes =
770            staticInfo(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES);
771        for (i = 0; i < availableAbModes.count; i++) {
772            if (antibandingMode == availableAbModes.data.u8[i]) break;
773        }
774        if (i == availableAbModes.count) {
775            ALOGE("%s: Requested antibanding mode \"%s\" is not supported",
776                    __FUNCTION__,
777                    newParams.get(CameraParameters::KEY_ANTIBANDING));
778            return BAD_VALUE;
779        }
780    }
781
782    // SCENE_MODE
783    int sceneMode = sceneModeStringToEnum(
784        newParams.get(CameraParameters::KEY_SCENE_MODE) );
785    if (sceneMode != mParameters.sceneMode) {
786        camera_metadata_entry_t availableSceneModes =
787            staticInfo(ANDROID_CONTROL_AVAILABLE_SCENE_MODES);
788        for (i = 0; i < availableSceneModes.count; i++) {
789            if (sceneMode == availableSceneModes.data.u8[i]) break;
790        }
791        if (i == availableSceneModes.count) {
792            ALOGE("%s: Requested scene mode \"%s\" is not supported",
793                    __FUNCTION__,
794                    newParams.get(CameraParameters::KEY_SCENE_MODE));
795            return BAD_VALUE;
796        }
797    }
798
799    // FLASH_MODE
800    Parameters::flashMode_t flashMode = flashModeStringToEnum(
801        newParams.get(CameraParameters::KEY_FLASH_MODE) );
802    if (flashMode != mParameters.flashMode) {
803        camera_metadata_entry_t flashAvailable =
804            staticInfo(ANDROID_FLASH_AVAILABLE, 1, 1);
805        if (!flashAvailable.data.u8[0] &&
806                flashMode != Parameters::FLASH_MODE_OFF) {
807            ALOGE("%s: Requested flash mode \"%s\" is not supported: "
808                    "No flash on device", __FUNCTION__,
809                    newParams.get(CameraParameters::KEY_FLASH_MODE));
810            return BAD_VALUE;
811        } else if (flashMode == Parameters::FLASH_MODE_RED_EYE) {
812            camera_metadata_entry_t availableAeModes =
813                staticInfo(ANDROID_CONTROL_AE_AVAILABLE_MODES);
814            for (i = 0; i < availableAeModes.count; i++) {
815                if (flashMode == availableAeModes.data.u8[i]) break;
816            }
817            if (i == availableAeModes.count) {
818                ALOGE("%s: Requested flash mode \"%s\" is not supported",
819                        __FUNCTION__,
820                        newParams.get(CameraParameters::KEY_FLASH_MODE));
821                return BAD_VALUE;
822            }
823        } else if (flashMode == -1) {
824            ALOGE("%s: Requested flash mode \"%s\" is unknown",
825                    __FUNCTION__,
826                    newParams.get(CameraParameters::KEY_FLASH_MODE));
827            return BAD_VALUE;
828        }
829    }
830
831    // FOCUS_MODE
832    Parameters::focusMode_t focusMode = focusModeStringToEnum(
833        newParams.get(CameraParameters::KEY_FOCUS_MODE));
834    if (focusMode != mParameters.focusMode) {
835        if (focusMode != Parameters::FOCUS_MODE_FIXED) {
836            camera_metadata_entry_t minFocusDistance =
837                staticInfo(ANDROID_LENS_MINIMUM_FOCUS_DISTANCE);
838            if (minFocusDistance.data.f[0] == 0) {
839                ALOGE("%s: Requested focus mode \"%s\" is not available: "
840                        "fixed focus lens",
841                        __FUNCTION__,
842                        newParams.get(CameraParameters::KEY_FOCUS_MODE));
843                return BAD_VALUE;
844            } else if (focusMode != Parameters::FOCUS_MODE_INFINITY) {
845                camera_metadata_entry_t availableFocusModes =
846                    staticInfo(ANDROID_CONTROL_AF_AVAILABLE_MODES);
847                for (i = 0; i < availableFocusModes.count; i++) {
848                    if (focusMode == availableFocusModes.data.u8[i]) break;
849                }
850                if (i == availableFocusModes.count) {
851                    ALOGE("%s: Requested focus mode \"%s\" is not supported",
852                            __FUNCTION__,
853                            newParams.get(CameraParameters::KEY_FOCUS_MODE));
854                    return BAD_VALUE;
855                }
856            }
857        }
858    }
859
860    // FOCUS_AREAS
861    Vector<Parameters::Area> focusingAreas;
862    res = parseAreas(newParams.get(CameraParameters::KEY_FOCUS_AREAS),
863            &focusingAreas);
864    size_t max3aRegions =
865        (size_t)staticInfo(ANDROID_CONTROL_MAX_REGIONS, 1, 1).data.i32[0];
866    if (res == OK) res = validateAreas(focusingAreas, max3aRegions);
867    if (res != OK) {
868        ALOGE("%s: Requested focus areas are malformed: %s",
869                __FUNCTION__, newParams.get(CameraParameters::KEY_FOCUS_AREAS));
870        return BAD_VALUE;
871    }
872
873    // EXPOSURE_COMPENSATION
874    int exposureCompensation =
875        newParams.getInt(CameraParameters::KEY_EXPOSURE_COMPENSATION);
876    camera_metadata_entry_t exposureCompensationRange =
877        staticInfo(ANDROID_CONTROL_AE_EXP_COMPENSATION_RANGE);
878    if (exposureCompensation < exposureCompensationRange.data.i32[0] ||
879            exposureCompensation > exposureCompensationRange.data.i32[1]) {
880        ALOGE("%s: Requested exposure compensation index is out of bounds: %d",
881                __FUNCTION__, exposureCompensation);
882        return BAD_VALUE;
883    }
884
885    // AUTO_EXPOSURE_LOCK (always supported)
886    bool autoExposureLock = boolFromString(
887        newParams.get(CameraParameters::KEY_AUTO_EXPOSURE_LOCK));
888
889    // AUTO_WHITEBALANCE_LOCK (always supported)
890    bool autoWhiteBalanceLock = boolFromString(
891        newParams.get(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK));
892
893    // METERING_AREAS
894    Vector<Parameters::Area> meteringAreas;
895    res = parseAreas(newParams.get(CameraParameters::KEY_METERING_AREAS),
896            &meteringAreas);
897    if (res == OK) res = validateAreas(focusingAreas, max3aRegions);
898    if (res != OK) {
899        ALOGE("%s: Requested metering areas are malformed: %s",
900                __FUNCTION__,
901                newParams.get(CameraParameters::KEY_METERING_AREAS));
902        return BAD_VALUE;
903    }
904
905    // ZOOM
906    int zoom = newParams.getInt(CameraParameters::KEY_ZOOM);
907    if (zoom < 0 || zoom > (int)NUM_ZOOM_STEPS) {
908        ALOGE("%s: Requested zoom level %d is not supported",
909                __FUNCTION__, zoom);
910        return BAD_VALUE;
911    }
912
913    // VIDEO_SIZE
914    int videoWidth, videoHeight;
915    newParams.getVideoSize(&videoWidth, &videoHeight);
916    if (videoWidth != mParameters.videoWidth ||
917            videoHeight != mParameters.videoHeight) {
918        if (mState == RECORD) {
919            ALOGE("%s: Video size cannot be updated when recording is active!",
920                    __FUNCTION__);
921            return BAD_VALUE;
922        }
923        camera_metadata_entry_t availableVideoSizes =
924            staticInfo(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES);
925        for (i = 0; i < availableVideoSizes.count; i += 2 ) {
926            if (availableVideoSizes.data.i32[i] == videoWidth &&
927                    availableVideoSizes.data.i32[i+1] == videoHeight)  break;
928        }
929        if (i == availableVideoSizes.count) {
930            ALOGE("%s: Requested video size %d x %d is not supported",
931                    __FUNCTION__, videoWidth, videoHeight);
932            return BAD_VALUE;
933        }
934    }
935
936    // RECORDING_HINT (always supported)
937    bool recordingHint = boolFromString(
938        newParams.get(CameraParameters::KEY_RECORDING_HINT) );
939
940    // VIDEO_STABILIZATION
941    bool videoStabilization = boolFromString(
942        newParams.get(CameraParameters::KEY_VIDEO_STABILIZATION) );
943    camera_metadata_entry_t availableVideoStabilizationModes =
944        staticInfo(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES);
945    if (videoStabilization && availableVideoStabilizationModes.count == 1) {
946        ALOGE("%s: Video stabilization not supported", __FUNCTION__);
947    }
948
949    /** Update internal parameters */
950    mParameters.previewWidth = previewWidth;
951    mParameters.previewHeight = previewHeight;
952    mParameters.previewFpsRangeMin = previewFpsRangeMin;
953    mParameters.previewFpsRangeMax = previewFpsRangeMax;
954    mParameters.previewFps = previewFps;
955    mParameters.previewFormat = previewFormat;
956
957    mParameters.pictureWidth = pictureWidth;
958    mParameters.pictureHeight = pictureHeight;
959
960    mParameters.jpegThumbWidth = jpegThumbWidth;
961    mParameters.jpegThumbHeight = jpegThumbHeight;
962    mParameters.jpegQuality = jpegQuality;
963    mParameters.jpegThumbQuality = jpegThumbQuality;
964
965    mParameters.gpsEnabled = gpsEnabled;
966    mParameters.gpsLatitude = gpsLatitude;
967    mParameters.gpsLongitude = gpsLongitude;
968    mParameters.gpsAltitude = gpsAltitude;
969    mParameters.gpsTimestamp = gpsTimestamp;
970    mParameters.gpsProcessingMethod = gpsProcessingMethod;
971
972    mParameters.wbMode = wbMode;
973    mParameters.effectMode = effectMode;
974    mParameters.antibandingMode = antibandingMode;
975    mParameters.sceneMode = sceneMode;
976
977    mParameters.flashMode = flashMode;
978    mParameters.focusMode = focusMode;
979
980    mParameters.focusingAreas = focusingAreas;
981    mParameters.exposureCompensation = exposureCompensation;
982    mParameters.autoExposureLock = autoExposureLock;
983    mParameters.autoWhiteBalanceLock = autoWhiteBalanceLock;
984    mParameters.meteringAreas = meteringAreas;
985    mParameters.zoom = zoom;
986
987    mParameters.videoWidth = videoWidth;
988    mParameters.videoHeight = videoHeight;
989
990    mParameters.recordingHint = recordingHint;
991    mParameters.videoStabilization = videoStabilization;
992
993    updatePreviewRequest();
994
995    return OK;
996}
997
998String8 Camera2Client::getParameters() const {
999    ATRACE_CALL();
1000    Mutex::Autolock icl(mICameraLock);
1001
1002    Mutex::Autolock pl(mParamsLock);
1003
1004    // TODO: Deal with focus distances
1005    return mParamsFlattened;
1006}
1007
1008status_t Camera2Client::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) {
1009    ATRACE_CALL();
1010    Mutex::Autolock icl(mICameraLock);
1011    return OK;
1012}
1013
1014/** Device-related methods */
1015
1016camera_metadata_entry_t Camera2Client::staticInfo(uint32_t tag,
1017        size_t minCount, size_t maxCount) {
1018    status_t res;
1019    camera_metadata_entry_t entry;
1020    res = find_camera_metadata_entry(mDevice->info(),
1021            tag,
1022            &entry);
1023    if (CC_UNLIKELY( res != OK )) {
1024        const char* tagSection = get_camera_metadata_section_name(tag);
1025        if (tagSection == NULL) tagSection = "<unknown>";
1026        const char* tagName = get_camera_metadata_tag_name(tag);
1027        if (tagName == NULL) tagName = "<unknown>";
1028
1029        ALOGE("Error finding static metadata entry '%s.%s' (%x): %s (%d)",
1030                tagSection, tagName, tag, strerror(-res), res);
1031        entry.count = 0;
1032        entry.data.u8 = NULL;
1033    } else if (CC_UNLIKELY(
1034            (minCount != 0 && entry.count < minCount) ||
1035            (maxCount != 0 && entry.count > maxCount) ) ) {
1036        const char* tagSection = get_camera_metadata_section_name(tag);
1037        if (tagSection == NULL) tagSection = "<unknown>";
1038        const char* tagName = get_camera_metadata_tag_name(tag);
1039        if (tagName == NULL) tagName = "<unknown>";
1040        ALOGE("Malformed static metadata entry '%s.%s' (%x):"
1041                "Expected between %d and %d values, but got %d values",
1042                tagSection, tagName, tag, minCount, maxCount, entry.count);
1043        entry.count = 0;
1044        entry.data.u8 = NULL;
1045    }
1046
1047    return entry;
1048}
1049
1050/** Utility methods */
1051
1052
1053status_t Camera2Client::buildDefaultParameters() {
1054    ATRACE_CALL();
1055    Mutex::Autolock pl(mParamsLock);
1056
1057    status_t res;
1058    CameraParameters params;
1059
1060    camera_metadata_entry_t availableProcessedSizes =
1061        staticInfo(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES, 2);
1062    if (!availableProcessedSizes.count) return NO_INIT;
1063
1064    // TODO: Pick more intelligently
1065    mParameters.previewWidth = availableProcessedSizes.data.i32[0];
1066    mParameters.previewHeight = availableProcessedSizes.data.i32[1];
1067    mParameters.videoWidth = mParameters.previewWidth;
1068    mParameters.videoHeight = mParameters.previewHeight;
1069
1070    params.setPreviewSize(mParameters.previewWidth, mParameters.previewHeight);
1071    params.setVideoSize(mParameters.videoWidth, mParameters.videoHeight);
1072    params.set(CameraParameters::KEY_PREFERRED_PREVIEW_SIZE_FOR_VIDEO,
1073            String8::format("%dx%d",
1074                    mParameters.previewWidth, mParameters.previewHeight));
1075    {
1076        String8 supportedPreviewSizes;
1077        for (size_t i=0; i < availableProcessedSizes.count; i += 2) {
1078            if (i != 0) supportedPreviewSizes += ",";
1079            supportedPreviewSizes += String8::format("%dx%d",
1080                    availableProcessedSizes.data.i32[i],
1081                    availableProcessedSizes.data.i32[i+1]);
1082        }
1083        params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES,
1084                supportedPreviewSizes);
1085        params.set(CameraParameters::KEY_SUPPORTED_VIDEO_SIZES,
1086                supportedPreviewSizes);
1087    }
1088
1089    camera_metadata_entry_t availableFpsRanges =
1090        staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES, 2);
1091    if (!availableFpsRanges.count) return NO_INIT;
1092
1093    mParameters.previewFpsRangeMin = availableFpsRanges.data.i32[0];
1094    mParameters.previewFpsRangeMax = availableFpsRanges.data.i32[1];
1095
1096    params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE,
1097            String8::format("%d,%d",
1098                    mParameters.previewFpsRangeMin,
1099                    mParameters.previewFpsRangeMax));
1100
1101    {
1102        String8 supportedPreviewFpsRange;
1103        for (size_t i=0; i < availableFpsRanges.count; i += 2) {
1104            if (i != 0) supportedPreviewFpsRange += ",";
1105            supportedPreviewFpsRange += String8::format("(%d,%d)",
1106                    availableFpsRanges.data.i32[i],
1107                    availableFpsRanges.data.i32[i+1]);
1108        }
1109        params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE,
1110                supportedPreviewFpsRange);
1111    }
1112
1113    mParameters.previewFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP;
1114    params.set(CameraParameters::KEY_PREVIEW_FORMAT,
1115            formatEnumToString(mParameters.previewFormat)); // NV21
1116
1117    camera_metadata_entry_t availableFormats =
1118        staticInfo(ANDROID_SCALER_AVAILABLE_FORMATS);
1119
1120    {
1121        String8 supportedPreviewFormats;
1122        bool addComma = false;
1123        for (size_t i=0; i < availableFormats.count; i++) {
1124            if (addComma) supportedPreviewFormats += ",";
1125            addComma = true;
1126            switch (availableFormats.data.i32[i]) {
1127            case HAL_PIXEL_FORMAT_YCbCr_422_SP:
1128                supportedPreviewFormats +=
1129                    CameraParameters::PIXEL_FORMAT_YUV422SP;
1130                break;
1131            case HAL_PIXEL_FORMAT_YCrCb_420_SP:
1132                supportedPreviewFormats +=
1133                    CameraParameters::PIXEL_FORMAT_YUV420SP;
1134                break;
1135            case HAL_PIXEL_FORMAT_YCbCr_422_I:
1136                supportedPreviewFormats +=
1137                    CameraParameters::PIXEL_FORMAT_YUV422I;
1138                break;
1139            case HAL_PIXEL_FORMAT_YV12:
1140                supportedPreviewFormats +=
1141                    CameraParameters::PIXEL_FORMAT_YUV420P;
1142                break;
1143            case HAL_PIXEL_FORMAT_RGB_565:
1144                supportedPreviewFormats +=
1145                    CameraParameters::PIXEL_FORMAT_RGB565;
1146                break;
1147                // Not advertizing JPEG, RAW_SENSOR, etc, for preview formats
1148            case HAL_PIXEL_FORMAT_RAW_SENSOR:
1149                addComma = false;
1150                break;
1151            default:
1152                ALOGW("%s: Camera %d: Unknown preview format: %x",
1153                        __FUNCTION__, mCameraId, availableFormats.data.i32[i]);
1154                addComma = false;
1155                break;
1156            }
1157        }
1158        params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS,
1159                supportedPreviewFormats);
1160    }
1161
1162    // PREVIEW_FRAME_RATE / SUPPORTED_PREVIEW_FRAME_RATES are deprecated, but
1163    // still have to do something sane for them
1164
1165    params.set(CameraParameters::KEY_PREVIEW_FRAME_RATE,
1166            mParameters.previewFpsRangeMin);
1167
1168    {
1169        String8 supportedPreviewFrameRates;
1170        for (size_t i=0; i < availableFpsRanges.count; i += 2) {
1171            if (i != 0) supportedPreviewFrameRates += ",";
1172            supportedPreviewFrameRates += String8::format("%d",
1173                    availableFpsRanges.data.i32[i]);
1174        }
1175        params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES,
1176                supportedPreviewFrameRates);
1177    }
1178
1179    camera_metadata_entry_t availableJpegSizes =
1180        staticInfo(ANDROID_SCALER_AVAILABLE_JPEG_SIZES, 2);
1181    if (!availableJpegSizes.count) return NO_INIT;
1182
1183    // TODO: Pick maximum
1184    mParameters.pictureWidth = availableJpegSizes.data.i32[0];
1185    mParameters.pictureHeight = availableJpegSizes.data.i32[1];
1186
1187    params.setPictureSize(mParameters.pictureWidth,
1188            mParameters.pictureHeight);
1189
1190    {
1191        String8 supportedPictureSizes;
1192        for (size_t i=0; i < availableJpegSizes.count; i += 2) {
1193            if (i != 0) supportedPictureSizes += ",";
1194            supportedPictureSizes += String8::format("%dx%d",
1195                    availableJpegSizes.data.i32[i],
1196                    availableJpegSizes.data.i32[i+1]);
1197        }
1198        params.set(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES,
1199                supportedPictureSizes);
1200    }
1201
1202    params.setPictureFormat(CameraParameters::PIXEL_FORMAT_JPEG);
1203    params.set(CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS,
1204            CameraParameters::PIXEL_FORMAT_JPEG);
1205
1206    camera_metadata_entry_t availableJpegThumbnailSizes =
1207        staticInfo(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES, 2);
1208    if (!availableJpegThumbnailSizes.count) return NO_INIT;
1209
1210    // TODO: Pick default thumbnail size sensibly
1211    mParameters.jpegThumbWidth = availableJpegThumbnailSizes.data.i32[0];
1212    mParameters.jpegThumbHeight = availableJpegThumbnailSizes.data.i32[1];
1213
1214    params.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH,
1215            mParameters.jpegThumbWidth);
1216    params.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT,
1217            mParameters.jpegThumbHeight);
1218
1219    {
1220        String8 supportedJpegThumbSizes;
1221        for (size_t i=0; i < availableJpegThumbnailSizes.count; i += 2) {
1222            if (i != 0) supportedJpegThumbSizes += ",";
1223            supportedJpegThumbSizes += String8::format("%dx%d",
1224                    availableJpegThumbnailSizes.data.i32[i],
1225                    availableJpegThumbnailSizes.data.i32[i+1]);
1226        }
1227        params.set(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES,
1228                supportedJpegThumbSizes);
1229    }
1230
1231    mParameters.jpegThumbQuality = 90;
1232    params.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY,
1233            mParameters.jpegThumbQuality);
1234    mParameters.jpegQuality = 90;
1235    params.set(CameraParameters::KEY_JPEG_QUALITY,
1236            mParameters.jpegQuality);
1237    mParameters.jpegRotation = 0;
1238    params.set(CameraParameters::KEY_ROTATION,
1239            mParameters.jpegRotation);
1240
1241    mParameters.gpsEnabled = false;
1242    mParameters.gpsProcessingMethod = "unknown";
1243    // GPS fields in CameraParameters are not set by implementation
1244
1245    mParameters.wbMode = ANDROID_CONTROL_AWB_AUTO;
1246    params.set(CameraParameters::KEY_WHITE_BALANCE,
1247            CameraParameters::WHITE_BALANCE_AUTO);
1248
1249    camera_metadata_entry_t availableWhiteBalanceModes =
1250        staticInfo(ANDROID_CONTROL_AWB_AVAILABLE_MODES);
1251    {
1252        String8 supportedWhiteBalance;
1253        bool addComma = false;
1254        for (size_t i=0; i < availableWhiteBalanceModes.count; i++) {
1255            if (addComma) supportedWhiteBalance += ",";
1256            addComma = true;
1257            switch (availableWhiteBalanceModes.data.u8[i]) {
1258            case ANDROID_CONTROL_AWB_AUTO:
1259                supportedWhiteBalance +=
1260                    CameraParameters::WHITE_BALANCE_AUTO;
1261                break;
1262            case ANDROID_CONTROL_AWB_INCANDESCENT:
1263                supportedWhiteBalance +=
1264                    CameraParameters::WHITE_BALANCE_INCANDESCENT;
1265                break;
1266            case ANDROID_CONTROL_AWB_FLUORESCENT:
1267                supportedWhiteBalance +=
1268                    CameraParameters::WHITE_BALANCE_FLUORESCENT;
1269                break;
1270            case ANDROID_CONTROL_AWB_WARM_FLUORESCENT:
1271                supportedWhiteBalance +=
1272                    CameraParameters::WHITE_BALANCE_WARM_FLUORESCENT;
1273                break;
1274            case ANDROID_CONTROL_AWB_DAYLIGHT:
1275                supportedWhiteBalance +=
1276                    CameraParameters::WHITE_BALANCE_DAYLIGHT;
1277                break;
1278            case ANDROID_CONTROL_AWB_CLOUDY_DAYLIGHT:
1279                supportedWhiteBalance +=
1280                    CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT;
1281                break;
1282            case ANDROID_CONTROL_AWB_TWILIGHT:
1283                supportedWhiteBalance +=
1284                    CameraParameters::WHITE_BALANCE_TWILIGHT;
1285                break;
1286            case ANDROID_CONTROL_AWB_SHADE:
1287                supportedWhiteBalance +=
1288                    CameraParameters::WHITE_BALANCE_SHADE;
1289                break;
1290            // Skipping values not mappable to v1 API
1291            case ANDROID_CONTROL_AWB_OFF:
1292                addComma = false;
1293                break;
1294            default:
1295                ALOGW("%s: Camera %d: Unknown white balance value: %d",
1296                        __FUNCTION__, mCameraId,
1297                        availableWhiteBalanceModes.data.u8[i]);
1298                addComma = false;
1299                break;
1300            }
1301        }
1302        params.set(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE,
1303                supportedWhiteBalance);
1304    }
1305
1306    mParameters.effectMode = ANDROID_CONTROL_EFFECT_OFF;
1307    params.set(CameraParameters::KEY_EFFECT,
1308            CameraParameters::EFFECT_NONE);
1309
1310    camera_metadata_entry_t availableEffects =
1311        staticInfo(ANDROID_CONTROL_AVAILABLE_EFFECTS);
1312    if (!availableEffects.count) return NO_INIT;
1313    {
1314        String8 supportedEffects;
1315        bool addComma = false;
1316        for (size_t i=0; i < availableEffects.count; i++) {
1317            if (addComma) supportedEffects += ",";
1318            addComma = true;
1319            switch (availableEffects.data.u8[i]) {
1320                case ANDROID_CONTROL_EFFECT_OFF:
1321                    supportedEffects +=
1322                        CameraParameters::EFFECT_NONE;
1323                    break;
1324                case ANDROID_CONTROL_EFFECT_MONO:
1325                    supportedEffects +=
1326                        CameraParameters::EFFECT_MONO;
1327                    break;
1328                case ANDROID_CONTROL_EFFECT_NEGATIVE:
1329                    supportedEffects +=
1330                        CameraParameters::EFFECT_NEGATIVE;
1331                    break;
1332                case ANDROID_CONTROL_EFFECT_SOLARIZE:
1333                    supportedEffects +=
1334                        CameraParameters::EFFECT_SOLARIZE;
1335                    break;
1336                case ANDROID_CONTROL_EFFECT_SEPIA:
1337                    supportedEffects +=
1338                        CameraParameters::EFFECT_SEPIA;
1339                    break;
1340                case ANDROID_CONTROL_EFFECT_POSTERIZE:
1341                    supportedEffects +=
1342                        CameraParameters::EFFECT_POSTERIZE;
1343                    break;
1344                case ANDROID_CONTROL_EFFECT_WHITEBOARD:
1345                    supportedEffects +=
1346                        CameraParameters::EFFECT_WHITEBOARD;
1347                    break;
1348                case ANDROID_CONTROL_EFFECT_BLACKBOARD:
1349                    supportedEffects +=
1350                        CameraParameters::EFFECT_BLACKBOARD;
1351                    break;
1352                case ANDROID_CONTROL_EFFECT_AQUA:
1353                    supportedEffects +=
1354                        CameraParameters::EFFECT_AQUA;
1355                    break;
1356                default:
1357                    ALOGW("%s: Camera %d: Unknown effect value: %d",
1358                        __FUNCTION__, mCameraId, availableEffects.data.u8[i]);
1359                    addComma = false;
1360                    break;
1361            }
1362        }
1363        params.set(CameraParameters::KEY_SUPPORTED_EFFECTS, supportedEffects);
1364    }
1365
1366    mParameters.antibandingMode = ANDROID_CONTROL_AE_ANTIBANDING_AUTO;
1367    params.set(CameraParameters::KEY_ANTIBANDING,
1368            CameraParameters::ANTIBANDING_AUTO);
1369
1370    camera_metadata_entry_t availableAntibandingModes =
1371        staticInfo(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES);
1372    if (!availableAntibandingModes.count) return NO_INIT;
1373    {
1374        String8 supportedAntibanding;
1375        bool addComma = false;
1376        for (size_t i=0; i < availableAntibandingModes.count; i++) {
1377            if (addComma) supportedAntibanding += ",";
1378            addComma = true;
1379            switch (availableAntibandingModes.data.u8[i]) {
1380                case ANDROID_CONTROL_AE_ANTIBANDING_OFF:
1381                    supportedAntibanding +=
1382                        CameraParameters::ANTIBANDING_OFF;
1383                    break;
1384                case ANDROID_CONTROL_AE_ANTIBANDING_50HZ:
1385                    supportedAntibanding +=
1386                        CameraParameters::ANTIBANDING_50HZ;
1387                    break;
1388                case ANDROID_CONTROL_AE_ANTIBANDING_60HZ:
1389                    supportedAntibanding +=
1390                        CameraParameters::ANTIBANDING_60HZ;
1391                    break;
1392                case ANDROID_CONTROL_AE_ANTIBANDING_AUTO:
1393                    supportedAntibanding +=
1394                        CameraParameters::ANTIBANDING_AUTO;
1395                    break;
1396                default:
1397                    ALOGW("%s: Camera %d: Unknown antibanding value: %d",
1398                        __FUNCTION__, mCameraId,
1399                            availableAntibandingModes.data.u8[i]);
1400                    addComma = false;
1401                    break;
1402            }
1403        }
1404        params.set(CameraParameters::KEY_SUPPORTED_ANTIBANDING,
1405                supportedAntibanding);
1406    }
1407
1408    mParameters.sceneMode = ANDROID_CONTROL_OFF;
1409    params.set(CameraParameters::KEY_SCENE_MODE,
1410            CameraParameters::SCENE_MODE_AUTO);
1411
1412    camera_metadata_entry_t availableSceneModes =
1413        staticInfo(ANDROID_CONTROL_AVAILABLE_SCENE_MODES);
1414    if (!availableSceneModes.count) return NO_INIT;
1415    {
1416        String8 supportedSceneModes(CameraParameters::SCENE_MODE_AUTO);
1417        bool addComma = true;
1418        bool noSceneModes = false;
1419        for (size_t i=0; i < availableSceneModes.count; i++) {
1420            if (addComma) supportedSceneModes += ",";
1421            addComma = true;
1422            switch (availableSceneModes.data.u8[i]) {
1423                case ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED:
1424                    noSceneModes = true;
1425                    break;
1426                case ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY:
1427                    // Not in old API
1428                    addComma = false;
1429                    break;
1430                case ANDROID_CONTROL_SCENE_MODE_ACTION:
1431                    supportedSceneModes +=
1432                        CameraParameters::SCENE_MODE_ACTION;
1433                    break;
1434                case ANDROID_CONTROL_SCENE_MODE_PORTRAIT:
1435                    supportedSceneModes +=
1436                        CameraParameters::SCENE_MODE_PORTRAIT;
1437                    break;
1438                case ANDROID_CONTROL_SCENE_MODE_LANDSCAPE:
1439                    supportedSceneModes +=
1440                        CameraParameters::SCENE_MODE_LANDSCAPE;
1441                    break;
1442                case ANDROID_CONTROL_SCENE_MODE_NIGHT:
1443                    supportedSceneModes +=
1444                        CameraParameters::SCENE_MODE_NIGHT;
1445                    break;
1446                case ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT:
1447                    supportedSceneModes +=
1448                        CameraParameters::SCENE_MODE_NIGHT_PORTRAIT;
1449                    break;
1450                case ANDROID_CONTROL_SCENE_MODE_THEATRE:
1451                    supportedSceneModes +=
1452                        CameraParameters::SCENE_MODE_THEATRE;
1453                    break;
1454                case ANDROID_CONTROL_SCENE_MODE_BEACH:
1455                    supportedSceneModes +=
1456                        CameraParameters::SCENE_MODE_BEACH;
1457                    break;
1458                case ANDROID_CONTROL_SCENE_MODE_SNOW:
1459                    supportedSceneModes +=
1460                        CameraParameters::SCENE_MODE_SNOW;
1461                    break;
1462                case ANDROID_CONTROL_SCENE_MODE_SUNSET:
1463                    supportedSceneModes +=
1464                        CameraParameters::SCENE_MODE_SUNSET;
1465                    break;
1466                case ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO:
1467                    supportedSceneModes +=
1468                        CameraParameters::SCENE_MODE_STEADYPHOTO;
1469                    break;
1470                case ANDROID_CONTROL_SCENE_MODE_FIREWORKS:
1471                    supportedSceneModes +=
1472                        CameraParameters::SCENE_MODE_FIREWORKS;
1473                    break;
1474                case ANDROID_CONTROL_SCENE_MODE_SPORTS:
1475                    supportedSceneModes +=
1476                        CameraParameters::SCENE_MODE_SPORTS;
1477                    break;
1478                case ANDROID_CONTROL_SCENE_MODE_PARTY:
1479                    supportedSceneModes +=
1480                        CameraParameters::SCENE_MODE_PARTY;
1481                    break;
1482                case ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT:
1483                    supportedSceneModes +=
1484                        CameraParameters::SCENE_MODE_CANDLELIGHT;
1485                    break;
1486                case ANDROID_CONTROL_SCENE_MODE_BARCODE:
1487                    supportedSceneModes +=
1488                        CameraParameters::SCENE_MODE_BARCODE;
1489                    break;
1490                default:
1491                    ALOGW("%s: Camera %d: Unknown scene mode value: %d",
1492                        __FUNCTION__, mCameraId,
1493                            availableSceneModes.data.u8[i]);
1494                    addComma = false;
1495                    break;
1496            }
1497        }
1498        if (!noSceneModes) {
1499            params.set(CameraParameters::KEY_SUPPORTED_SCENE_MODES,
1500                    supportedSceneModes);
1501        }
1502    }
1503
1504    camera_metadata_entry_t flashAvailable =
1505        staticInfo(ANDROID_FLASH_AVAILABLE, 1, 1);
1506    if (!flashAvailable.count) return NO_INIT;
1507
1508    camera_metadata_entry_t availableAeModes =
1509        staticInfo(ANDROID_CONTROL_AE_AVAILABLE_MODES);
1510    if (!availableAeModes.count) return NO_INIT;
1511
1512    if (flashAvailable.data.u8[0]) {
1513        mParameters.flashMode = Parameters::FLASH_MODE_AUTO;
1514        params.set(CameraParameters::KEY_FLASH_MODE,
1515                CameraParameters::FLASH_MODE_AUTO);
1516
1517        String8 supportedFlashModes(CameraParameters::FLASH_MODE_OFF);
1518        supportedFlashModes = supportedFlashModes +
1519            "," + CameraParameters::FLASH_MODE_AUTO +
1520            "," + CameraParameters::FLASH_MODE_ON +
1521            "," + CameraParameters::FLASH_MODE_TORCH;
1522        for (size_t i=0; i < availableAeModes.count; i++) {
1523            if (availableAeModes.data.u8[i] ==
1524                    ANDROID_CONTROL_AE_ON_AUTO_FLASH_REDEYE) {
1525                supportedFlashModes = supportedFlashModes + "," +
1526                    CameraParameters::FLASH_MODE_RED_EYE;
1527                break;
1528            }
1529        }
1530        params.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES,
1531                supportedFlashModes);
1532    } else {
1533        mParameters.flashMode = Parameters::FLASH_MODE_OFF;
1534        params.set(CameraParameters::KEY_FLASH_MODE,
1535                CameraParameters::FLASH_MODE_OFF);
1536        params.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES,
1537                CameraParameters::FLASH_MODE_OFF);
1538    }
1539
1540    camera_metadata_entry_t minFocusDistance =
1541        staticInfo(ANDROID_LENS_MINIMUM_FOCUS_DISTANCE, 1, 1);
1542    if (!minFocusDistance.count) return NO_INIT;
1543
1544    camera_metadata_entry_t availableAfModes =
1545        staticInfo(ANDROID_CONTROL_AF_AVAILABLE_MODES);
1546    if (!availableAfModes.count) return NO_INIT;
1547
1548    if (minFocusDistance.data.f[0] == 0) {
1549        // Fixed-focus lens
1550        mParameters.focusMode = Parameters::FOCUS_MODE_FIXED;
1551        params.set(CameraParameters::KEY_FOCUS_MODE,
1552                CameraParameters::FOCUS_MODE_FIXED);
1553        params.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES,
1554                CameraParameters::FOCUS_MODE_FIXED);
1555    } else {
1556        mParameters.focusMode = Parameters::FOCUS_MODE_AUTO;
1557        params.set(CameraParameters::KEY_FOCUS_MODE,
1558                CameraParameters::FOCUS_MODE_AUTO);
1559        String8 supportedFocusModes(CameraParameters::FOCUS_MODE_FIXED);
1560        supportedFocusModes = supportedFocusModes + "," +
1561            CameraParameters::FOCUS_MODE_INFINITY;
1562        bool addComma = true;
1563
1564        for (size_t i=0; i < availableAfModes.count; i++) {
1565            if (addComma) supportedFocusModes += ",";
1566            addComma = true;
1567            switch (availableAfModes.data.u8[i]) {
1568                case ANDROID_CONTROL_AF_AUTO:
1569                    supportedFocusModes +=
1570                        CameraParameters::FOCUS_MODE_AUTO;
1571                    break;
1572                case ANDROID_CONTROL_AF_MACRO:
1573                    supportedFocusModes +=
1574                        CameraParameters::FOCUS_MODE_MACRO;
1575                    break;
1576                case ANDROID_CONTROL_AF_CONTINUOUS_VIDEO:
1577                    supportedFocusModes +=
1578                        CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO;
1579                    break;
1580                case ANDROID_CONTROL_AF_CONTINUOUS_PICTURE:
1581                    supportedFocusModes +=
1582                        CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE;
1583                    break;
1584                case ANDROID_CONTROL_AF_EDOF:
1585                    supportedFocusModes +=
1586                        CameraParameters::FOCUS_MODE_EDOF;
1587                    break;
1588                // Not supported in old API
1589                case ANDROID_CONTROL_AF_OFF:
1590                    addComma = false;
1591                    break;
1592                default:
1593                    ALOGW("%s: Camera %d: Unknown AF mode value: %d",
1594                        __FUNCTION__, mCameraId, availableAfModes.data.u8[i]);
1595                    addComma = false;
1596                    break;
1597            }
1598        }
1599        params.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES,
1600                supportedFocusModes);
1601    }
1602
1603    camera_metadata_entry_t max3aRegions =
1604        staticInfo(ANDROID_CONTROL_MAX_REGIONS, 1, 1);
1605    if (!max3aRegions.count) return NO_INIT;
1606
1607    params.set(CameraParameters::KEY_MAX_NUM_FOCUS_AREAS,
1608            max3aRegions.data.i32[0]);
1609    params.set(CameraParameters::KEY_FOCUS_AREAS,
1610            "(0,0,0,0,0)");
1611    mParameters.focusingAreas.clear();
1612    mParameters.focusingAreas.add(Parameters::Area(0,0,0,0,0));
1613
1614    camera_metadata_entry_t availableFocalLengths =
1615        staticInfo(ANDROID_LENS_AVAILABLE_FOCAL_LENGTHS);
1616    if (!availableFocalLengths.count) return NO_INIT;
1617
1618    float minFocalLength = availableFocalLengths.data.f[0];
1619    params.setFloat(CameraParameters::KEY_FOCAL_LENGTH, minFocalLength);
1620
1621    camera_metadata_entry_t sensorSize =
1622        staticInfo(ANDROID_SENSOR_PHYSICAL_SIZE, 2, 2);
1623    if (!sensorSize.count) return NO_INIT;
1624
1625    // The fields of view here assume infinity focus, maximum wide angle
1626    float horizFov = 180 / M_PI *
1627            2 * atanf(sensorSize.data.f[0] / (2 * minFocalLength));
1628    float vertFov  = 180 / M_PI *
1629            2 * atanf(sensorSize.data.f[1] / (2 * minFocalLength));
1630    params.setFloat(CameraParameters::KEY_HORIZONTAL_VIEW_ANGLE, horizFov);
1631    params.setFloat(CameraParameters::KEY_VERTICAL_VIEW_ANGLE, vertFov);
1632
1633    mParameters.exposureCompensation = 0;
1634    params.set(CameraParameters::KEY_EXPOSURE_COMPENSATION,
1635                mParameters.exposureCompensation);
1636
1637    camera_metadata_entry_t exposureCompensationRange =
1638        staticInfo(ANDROID_CONTROL_AE_EXP_COMPENSATION_RANGE, 2, 2);
1639    if (!exposureCompensationRange.count) return NO_INIT;
1640
1641    params.set(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION,
1642            exposureCompensationRange.data.i32[1]);
1643    params.set(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION,
1644            exposureCompensationRange.data.i32[0]);
1645
1646    camera_metadata_entry_t exposureCompensationStep =
1647        staticInfo(ANDROID_CONTROL_AE_EXP_COMPENSATION_STEP, 1, 1);
1648    if (!exposureCompensationStep.count) return NO_INIT;
1649
1650    params.setFloat(CameraParameters::KEY_EXPOSURE_COMPENSATION_STEP,
1651            exposureCompensationStep.data.r[0].numerator /
1652            exposureCompensationStep.data.r[0].denominator);
1653
1654    mParameters.autoExposureLock = false;
1655    params.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK,
1656            CameraParameters::FALSE);
1657    params.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED,
1658            CameraParameters::TRUE);
1659
1660    mParameters.autoWhiteBalanceLock = false;
1661    params.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK,
1662            CameraParameters::FALSE);
1663    params.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED,
1664            CameraParameters::TRUE);
1665
1666    mParameters.meteringAreas.add(Parameters::Area(0, 0, 0, 0, 0));
1667    params.set(CameraParameters::KEY_MAX_NUM_METERING_AREAS,
1668            max3aRegions.data.i32[0]);
1669    params.set(CameraParameters::KEY_METERING_AREAS,
1670            "(0,0,0,0,0)");
1671
1672    mParameters.zoom = 0;
1673    params.set(CameraParameters::KEY_ZOOM, mParameters.zoom);
1674    params.set(CameraParameters::KEY_MAX_ZOOM, NUM_ZOOM_STEPS - 1);
1675
1676    camera_metadata_entry_t maxDigitalZoom =
1677        staticInfo(ANDROID_SCALER_AVAILABLE_MAX_ZOOM, 1, 1);
1678    if (!maxDigitalZoom.count) return NO_INIT;
1679
1680    {
1681        String8 zoomRatios;
1682        float zoom = 1.f;
1683        float zoomIncrement = (maxDigitalZoom.data.f[0] - zoom) /
1684                (NUM_ZOOM_STEPS-1);
1685        bool addComma = false;
1686        for (size_t i=0; i < NUM_ZOOM_STEPS; i++) {
1687            if (addComma) zoomRatios += ",";
1688            addComma = true;
1689            zoomRatios += String8::format("%d", static_cast<int>(zoom * 100));
1690            zoom += zoomIncrement;
1691        }
1692        params.set(CameraParameters::KEY_ZOOM_RATIOS, zoomRatios);
1693    }
1694
1695    params.set(CameraParameters::KEY_ZOOM_SUPPORTED,
1696            CameraParameters::TRUE);
1697    params.set(CameraParameters::KEY_SMOOTH_ZOOM_SUPPORTED,
1698            CameraParameters::TRUE);
1699
1700    params.set(CameraParameters::KEY_FOCUS_DISTANCES,
1701            "Infinity,Infinity,Infinity");
1702
1703    camera_metadata_entry_t maxFacesDetected =
1704        staticInfo(ANDROID_STATS_MAX_FACE_COUNT, 1, 1);
1705    params.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_HW,
1706            maxFacesDetected.data.i32[0]);
1707    params.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_SW,
1708            0);
1709
1710    params.set(CameraParameters::KEY_VIDEO_FRAME_FORMAT,
1711            formatEnumToString(HAL_PIXEL_FORMAT_YCrCb_420_SP));
1712
1713    params.set(CameraParameters::KEY_RECORDING_HINT,
1714            CameraParameters::FALSE);
1715
1716    params.set(CameraParameters::KEY_VIDEO_SNAPSHOT_SUPPORTED,
1717            CameraParameters::TRUE);
1718
1719    params.set(CameraParameters::KEY_VIDEO_STABILIZATION,
1720            CameraParameters::FALSE);
1721
1722    camera_metadata_entry_t availableVideoStabilizationModes =
1723        staticInfo(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES);
1724    if (!availableVideoStabilizationModes.count) return NO_INIT;
1725
1726    if (availableVideoStabilizationModes.count > 1) {
1727        params.set(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED,
1728                CameraParameters::TRUE);
1729    } else {
1730        params.set(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED,
1731                CameraParameters::FALSE);
1732    }
1733
1734    mParamsFlattened = params.flatten();
1735
1736    return OK;
1737}
1738
1739status_t Camera2Client::updatePreviewRequest() {
1740    ATRACE_CALL();
1741    status_t res;
1742    if (mPreviewRequest == NULL) {
1743        res = mDevice->createDefaultRequest(CAMERA2_TEMPLATE_PREVIEW,
1744                &mPreviewRequest);
1745        if (res != OK) {
1746            ALOGE("%s: Camera %d: Unable to create default preview request: "
1747                    "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
1748            return res;
1749        }
1750    }
1751    // TODO: Adjust for params changes
1752    return OK;
1753}
1754
1755int Camera2Client::formatStringToEnum(const char *format) {
1756    return
1757        !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV422SP) ?
1758            HAL_PIXEL_FORMAT_YCbCr_422_SP : // NV16
1759        !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV420SP) ?
1760            HAL_PIXEL_FORMAT_YCrCb_420_SP : // NV21
1761        !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV422I) ?
1762            HAL_PIXEL_FORMAT_YCbCr_422_I :  // YUY2
1763        !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV420P) ?
1764            HAL_PIXEL_FORMAT_YV12 :         // YV12
1765        !strcmp(format, CameraParameters::PIXEL_FORMAT_RGB565) ?
1766            HAL_PIXEL_FORMAT_RGB_565 :      // RGB565
1767        !strcmp(format, CameraParameters::PIXEL_FORMAT_RGBA8888) ?
1768            HAL_PIXEL_FORMAT_RGBA_8888 :    // RGB8888
1769        !strcmp(format, CameraParameters::PIXEL_FORMAT_BAYER_RGGB) ?
1770            HAL_PIXEL_FORMAT_RAW_SENSOR :   // Raw sensor data
1771        -1;
1772}
1773
1774const char* Camera2Client::formatEnumToString(int format) {
1775    const char *fmt;
1776    switch(format) {
1777        case HAL_PIXEL_FORMAT_YCbCr_422_SP: // NV16
1778            fmt = CameraParameters::PIXEL_FORMAT_YUV422SP;
1779            break;
1780        case HAL_PIXEL_FORMAT_YCrCb_420_SP: // NV21
1781            fmt = CameraParameters::PIXEL_FORMAT_YUV420SP;
1782            break;
1783        case HAL_PIXEL_FORMAT_YCbCr_422_I: // YUY2
1784            fmt = CameraParameters::PIXEL_FORMAT_YUV422I;
1785            break;
1786        case HAL_PIXEL_FORMAT_YV12:        // YV12
1787            fmt = CameraParameters::PIXEL_FORMAT_YUV420P;
1788            break;
1789        case HAL_PIXEL_FORMAT_RGB_565:     // RGB565
1790            fmt = CameraParameters::PIXEL_FORMAT_RGB565;
1791            break;
1792        case HAL_PIXEL_FORMAT_RGBA_8888:   // RGBA8888
1793            fmt = CameraParameters::PIXEL_FORMAT_RGBA8888;
1794            break;
1795        case HAL_PIXEL_FORMAT_RAW_SENSOR:
1796            ALOGW("Raw sensor preview format requested.");
1797            fmt = CameraParameters::PIXEL_FORMAT_BAYER_RGGB;
1798            break;
1799        default:
1800            ALOGE("%s: Unknown preview format: %x",
1801                    __FUNCTION__,  format);
1802            fmt = NULL;
1803            break;
1804    }
1805    return fmt;
1806}
1807
1808int Camera2Client::wbModeStringToEnum(const char *wbMode) {
1809    return
1810        !strcmp(wbMode, CameraParameters::WHITE_BALANCE_AUTO) ?
1811            ANDROID_CONTROL_AWB_AUTO :
1812        !strcmp(wbMode, CameraParameters::WHITE_BALANCE_INCANDESCENT) ?
1813            ANDROID_CONTROL_AWB_INCANDESCENT :
1814        !strcmp(wbMode, CameraParameters::WHITE_BALANCE_FLUORESCENT) ?
1815            ANDROID_CONTROL_AWB_FLUORESCENT :
1816        !strcmp(wbMode, CameraParameters::WHITE_BALANCE_WARM_FLUORESCENT) ?
1817            ANDROID_CONTROL_AWB_WARM_FLUORESCENT :
1818        !strcmp(wbMode, CameraParameters::WHITE_BALANCE_DAYLIGHT) ?
1819            ANDROID_CONTROL_AWB_DAYLIGHT :
1820        !strcmp(wbMode, CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT) ?
1821            ANDROID_CONTROL_AWB_CLOUDY_DAYLIGHT :
1822        !strcmp(wbMode, CameraParameters::WHITE_BALANCE_TWILIGHT) ?
1823            ANDROID_CONTROL_AWB_TWILIGHT :
1824        !strcmp(wbMode, CameraParameters::WHITE_BALANCE_SHADE) ?
1825            ANDROID_CONTROL_AWB_SHADE :
1826        -1;
1827}
1828
1829int Camera2Client::effectModeStringToEnum(const char *effectMode) {
1830    return
1831        !strcmp(effectMode, CameraParameters::EFFECT_NONE) ?
1832            ANDROID_CONTROL_EFFECT_OFF :
1833        !strcmp(effectMode, CameraParameters::EFFECT_MONO) ?
1834            ANDROID_CONTROL_EFFECT_MONO :
1835        !strcmp(effectMode, CameraParameters::EFFECT_NEGATIVE) ?
1836            ANDROID_CONTROL_EFFECT_NEGATIVE :
1837        !strcmp(effectMode, CameraParameters::EFFECT_SOLARIZE) ?
1838            ANDROID_CONTROL_EFFECT_SOLARIZE :
1839        !strcmp(effectMode, CameraParameters::EFFECT_SEPIA) ?
1840            ANDROID_CONTROL_EFFECT_SEPIA :
1841        !strcmp(effectMode, CameraParameters::EFFECT_POSTERIZE) ?
1842            ANDROID_CONTROL_EFFECT_POSTERIZE :
1843        !strcmp(effectMode, CameraParameters::EFFECT_WHITEBOARD) ?
1844            ANDROID_CONTROL_EFFECT_WHITEBOARD :
1845        !strcmp(effectMode, CameraParameters::EFFECT_BLACKBOARD) ?
1846            ANDROID_CONTROL_EFFECT_BLACKBOARD :
1847        !strcmp(effectMode, CameraParameters::EFFECT_AQUA) ?
1848            ANDROID_CONTROL_EFFECT_AQUA :
1849        -1;
1850}
1851
1852int Camera2Client::abModeStringToEnum(const char *abMode) {
1853    return
1854        !strcmp(abMode, CameraParameters::ANTIBANDING_AUTO) ?
1855            ANDROID_CONTROL_AE_ANTIBANDING_AUTO :
1856        !strcmp(abMode, CameraParameters::ANTIBANDING_OFF) ?
1857            ANDROID_CONTROL_AE_ANTIBANDING_OFF :
1858        !strcmp(abMode, CameraParameters::ANTIBANDING_50HZ) ?
1859            ANDROID_CONTROL_AE_ANTIBANDING_50HZ :
1860        !strcmp(abMode, CameraParameters::ANTIBANDING_60HZ) ?
1861            ANDROID_CONTROL_AE_ANTIBANDING_60HZ :
1862        -1;
1863}
1864
1865int Camera2Client::sceneModeStringToEnum(const char *sceneMode) {
1866    return
1867        !strcmp(sceneMode, CameraParameters::SCENE_MODE_AUTO) ?
1868            ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED :
1869        !strcmp(sceneMode, CameraParameters::SCENE_MODE_ACTION) ?
1870            ANDROID_CONTROL_SCENE_MODE_ACTION :
1871        !strcmp(sceneMode, CameraParameters::SCENE_MODE_PORTRAIT) ?
1872            ANDROID_CONTROL_SCENE_MODE_PORTRAIT :
1873        !strcmp(sceneMode, CameraParameters::SCENE_MODE_LANDSCAPE) ?
1874            ANDROID_CONTROL_SCENE_MODE_LANDSCAPE :
1875        !strcmp(sceneMode, CameraParameters::SCENE_MODE_NIGHT) ?
1876            ANDROID_CONTROL_SCENE_MODE_NIGHT :
1877        !strcmp(sceneMode, CameraParameters::SCENE_MODE_NIGHT_PORTRAIT) ?
1878            ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT :
1879        !strcmp(sceneMode, CameraParameters::SCENE_MODE_THEATRE) ?
1880            ANDROID_CONTROL_SCENE_MODE_THEATRE :
1881        !strcmp(sceneMode, CameraParameters::SCENE_MODE_BEACH) ?
1882            ANDROID_CONTROL_SCENE_MODE_BEACH :
1883        !strcmp(sceneMode, CameraParameters::SCENE_MODE_SNOW) ?
1884            ANDROID_CONTROL_SCENE_MODE_SNOW :
1885        !strcmp(sceneMode, CameraParameters::SCENE_MODE_SUNSET) ?
1886            ANDROID_CONTROL_SCENE_MODE_SUNSET :
1887        !strcmp(sceneMode, CameraParameters::SCENE_MODE_STEADYPHOTO) ?
1888            ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO :
1889        !strcmp(sceneMode, CameraParameters::SCENE_MODE_FIREWORKS) ?
1890            ANDROID_CONTROL_SCENE_MODE_FIREWORKS :
1891        !strcmp(sceneMode, CameraParameters::SCENE_MODE_SPORTS) ?
1892            ANDROID_CONTROL_SCENE_MODE_SPORTS :
1893        !strcmp(sceneMode, CameraParameters::SCENE_MODE_PARTY) ?
1894            ANDROID_CONTROL_SCENE_MODE_PARTY :
1895        !strcmp(sceneMode, CameraParameters::SCENE_MODE_CANDLELIGHT) ?
1896            ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT :
1897        !strcmp(sceneMode, CameraParameters::SCENE_MODE_BARCODE) ?
1898            ANDROID_CONTROL_SCENE_MODE_BARCODE:
1899        -1;
1900}
1901
1902Camera2Client::Parameters::flashMode_t Camera2Client::flashModeStringToEnum(
1903        const char *flashMode) {
1904    return
1905        !strcmp(flashMode, CameraParameters::FLASH_MODE_OFF) ?
1906            Parameters::FLASH_MODE_OFF :
1907        !strcmp(flashMode, CameraParameters::FLASH_MODE_AUTO) ?
1908            Parameters::FLASH_MODE_AUTO :
1909        !strcmp(flashMode, CameraParameters::FLASH_MODE_ON) ?
1910            Parameters::FLASH_MODE_ON :
1911        !strcmp(flashMode, CameraParameters::FLASH_MODE_RED_EYE) ?
1912            Parameters::FLASH_MODE_RED_EYE :
1913        !strcmp(flashMode, CameraParameters::FLASH_MODE_TORCH) ?
1914            Parameters::FLASH_MODE_TORCH :
1915        Parameters::FLASH_MODE_INVALID;
1916}
1917
1918Camera2Client::Parameters::focusMode_t Camera2Client::focusModeStringToEnum(
1919        const char *focusMode) {
1920    return
1921        !strcmp(focusMode, CameraParameters::FOCUS_MODE_AUTO) ?
1922            Parameters::FOCUS_MODE_AUTO :
1923        !strcmp(focusMode, CameraParameters::FOCUS_MODE_INFINITY) ?
1924            Parameters::FOCUS_MODE_INFINITY :
1925        !strcmp(focusMode, CameraParameters::FOCUS_MODE_MACRO) ?
1926            Parameters::FOCUS_MODE_MACRO :
1927        !strcmp(focusMode, CameraParameters::FOCUS_MODE_FIXED) ?
1928            Parameters::FOCUS_MODE_FIXED :
1929        !strcmp(focusMode, CameraParameters::FOCUS_MODE_EDOF) ?
1930            Parameters::FOCUS_MODE_EDOF :
1931        !strcmp(focusMode, CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO) ?
1932            Parameters::FOCUS_MODE_CONTINUOUS_VIDEO :
1933        !strcmp(focusMode, CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE) ?
1934            Parameters::FOCUS_MODE_CONTINUOUS_PICTURE :
1935        Parameters::FOCUS_MODE_INVALID;
1936}
1937
1938status_t Camera2Client::parseAreas(const char *areasCStr,
1939        Vector<Parameters::Area> *areas) {
1940    static const size_t NUM_FIELDS = 5;
1941    areas->clear();
1942    if (areasCStr == NULL) {
1943        // If no key exists, use default (0,0,0,0,0)
1944        areas->push();
1945        return OK;
1946    }
1947    String8 areasStr(areasCStr);
1948    ssize_t areaStart = areasStr.find("(", 0) + 1;
1949    while (areaStart != 0) {
1950        const char* area = areasStr.string() + areaStart;
1951        char *numEnd;
1952        int vals[NUM_FIELDS];
1953        for (size_t i = 0; i < NUM_FIELDS; i++) {
1954            errno = 0;
1955            vals[i] = strtol(area, &numEnd, 10);
1956            if (errno || numEnd == area) return BAD_VALUE;
1957            area = numEnd + 1;
1958        }
1959        areas->push(Parameters::Area(
1960            vals[0], vals[1], vals[2], vals[3], vals[4]) );
1961        areaStart = areasStr.find("(", areaStart) + 1;
1962    }
1963    return OK;
1964}
1965
1966status_t Camera2Client::validateAreas(const Vector<Parameters::Area> &areas,
1967                                      size_t maxRegions) {
1968    // Definition of valid area can be found in
1969    // include/camera/CameraParameters.h
1970    if (areas.size() == 0) return BAD_VALUE;
1971    if (areas.size() == 1) {
1972        if (areas[0].left == 0 &&
1973                areas[0].top == 0 &&
1974                areas[0].right == 0 &&
1975                areas[0].bottom == 0 &&
1976                areas[0].weight == 0) {
1977            // Single (0,0,0,0,0) entry is always valid (== driver decides)
1978            return OK;
1979        }
1980    }
1981    if (areas.size() > maxRegions) {
1982        ALOGE("%s: Too many areas requested: %d",
1983                __FUNCTION__, areas.size());
1984        return BAD_VALUE;
1985    }
1986
1987    for (Vector<Parameters::Area>::const_iterator a = areas.begin();
1988         a != areas.end(); a++) {
1989        if (a->weight < 1 || a->weight > 1000) return BAD_VALUE;
1990        if (a->left < -1000 || a->left > 1000) return BAD_VALUE;
1991        if (a->top < -1000 || a->top > 1000) return BAD_VALUE;
1992        if (a->right < -1000 || a->right > 1000) return BAD_VALUE;
1993        if (a->bottom < -1000 || a->bottom > 1000) return BAD_VALUE;
1994        if (a->left >= a->right) return BAD_VALUE;
1995        if (a->top >= a->bottom) return BAD_VALUE;
1996    }
1997    return OK;
1998}
1999
2000bool Camera2Client::boolFromString(const char *boolStr) {
2001    return !boolStr ? false :
2002        !strcmp(boolStr, CameraParameters::TRUE) ? true :
2003        false;
2004}
2005
2006
2007} // namespace android
2008