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