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