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