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