Camera2Client.cpp revision 836b81f3c5a5bacb800f698f90ded6bd6e6bc5ce 
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#include <media/hardware/MetadataBufferType.h>
28
29#include <math.h>
30
31#include "Camera2Client.h"
32
33namespace android {
34
35#define ALOG1(...) ALOGD_IF(gLogLevel >= 1, __VA_ARGS__);
36#define ALOG2(...) ALOGD_IF(gLogLevel >= 2, __VA_ARGS__);
37
38static int getCallingPid() {
39    return IPCThreadState::self()->getCallingPid();
40}
41
42static int getCallingUid() {
43    return IPCThreadState::self()->getCallingUid();
44}
45
46// Interface used by CameraService
47
48Camera2Client::Camera2Client(const sp<CameraService>& cameraService,
49        const sp<ICameraClient>& cameraClient,
50        int cameraId,
51        int cameraFacing,
52        int clientPid):
53        Client(cameraService, cameraClient,
54                cameraId, cameraFacing, clientPid),
55        mState(NOT_INITIALIZED),
56        mPreviewStreamId(NO_STREAM),
57        mPreviewRequest(NULL),
58        mCaptureStreamId(NO_STREAM),
59        mCaptureRequest(NULL),
60        mRecordingStreamId(NO_STREAM),
61        mRecordingRequest(NULL)
62{
63    ATRACE_CALL();
64
65    mDevice = new Camera2Device(cameraId);
66}
67
68status_t Camera2Client::initialize(camera_module_t *module)
69{
70    ATRACE_CALL();
71    ALOGV("%s: E", __FUNCTION__);
72    status_t res;
73
74    res = mDevice->initialize(module);
75    if (res != OK) {
76        ALOGE("%s: Camera %d: unable to initialize device: %s (%d)",
77                __FUNCTION__, mCameraId, strerror(-res), res);
78        return NO_INIT;
79    }
80
81    res = buildDefaultParameters();
82    if (res != OK) {
83        ALOGE("%s: Camera %d: unable to build defaults: %s (%d)",
84                __FUNCTION__, mCameraId, strerror(-res), res);
85        return NO_INIT;
86    }
87
88    if (gLogLevel >= 1) {
89        LockedParameters::Key k(mParameters);
90        ALOGD("%s: Default parameters converted from camera %d:", __FUNCTION__,
91              mCameraId);
92        ALOGD("%s", k.mParameters.paramsFlattened.string());
93    }
94
95    mState = STOPPED;
96
97    return OK;
98}
99
100Camera2Client::~Camera2Client() {
101    ATRACE_CALL();
102    ALOGV("%s: Camera %d: Shutting down", __FUNCTION__, mCameraId);
103
104    mDestructionStarted = true;
105
106    disconnect();
107
108}
109
110status_t Camera2Client::dump(int fd, const Vector<String16>& args) {
111    String8 result;
112    result.appendFormat("Client2[%d] (%p) PID: %d, dump:\n",
113            mCameraId,
114            getCameraClient()->asBinder().get(),
115            mClientPid);
116    result.append("  State: ");
117#define CASE_APPEND_ENUM(x) case x: result.append(#x "\n"); break;
118
119    const Parameters& p = mParameters.unsafeUnlock();
120
121    result.append(getStateName(mState));
122
123    result.append("\n  Current parameters:\n");
124    result.appendFormat("    Preview size: %d x %d\n",
125            p.previewWidth, p.previewHeight);
126    result.appendFormat("    Preview FPS range: %d - %d\n",
127            p.previewFpsRange[0], p.previewFpsRange[1]);
128    result.appendFormat("    Preview HAL pixel format: 0x%x\n",
129            p.previewFormat);
130    result.appendFormat("    Preview transform: %x\n",
131            p.previewTransform);
132    result.appendFormat("    Picture size: %d x %d\n",
133            p.pictureWidth, p.pictureHeight);
134    result.appendFormat("    Jpeg thumbnail size: %d x %d\n",
135            p.jpegThumbSize[0], p.jpegThumbSize[1]);
136    result.appendFormat("    Jpeg quality: %d, thumbnail quality: %d\n",
137            p.jpegQuality, p.jpegThumbQuality);
138    result.appendFormat("    Jpeg rotation: %d\n", p.jpegRotation);
139    result.appendFormat("    GPS tags %s\n",
140            p.gpsEnabled ? "enabled" : "disabled");
141    if (p.gpsEnabled) {
142        result.appendFormat("    GPS lat x long x alt: %f x %f x %f\n",
143                p.gpsCoordinates[0], p.gpsCoordinates[1],
144                p.gpsCoordinates[2]);
145        result.appendFormat("    GPS timestamp: %lld\n",
146                p.gpsTimestamp);
147        result.appendFormat("    GPS processing method: %s\n",
148                p.gpsProcessingMethod.string());
149    }
150
151    result.append("    White balance mode: ");
152    switch (p.wbMode) {
153        CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_AUTO)
154        CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_INCANDESCENT)
155        CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_FLUORESCENT)
156        CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_WARM_FLUORESCENT)
157        CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_DAYLIGHT)
158        CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_CLOUDY_DAYLIGHT)
159        CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_TWILIGHT)
160        CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_SHADE)
161        default: result.append("UNKNOWN\n");
162    }
163
164    result.append("    Effect mode: ");
165    switch (p.effectMode) {
166        CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_OFF)
167        CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MONO)
168        CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_NEGATIVE)
169        CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_SOLARIZE)
170        CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_SEPIA)
171        CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_POSTERIZE)
172        CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_WHITEBOARD)
173        CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_BLACKBOARD)
174        CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_AQUA)
175        default: result.append("UNKNOWN\n");
176    }
177
178    result.append("    Antibanding mode: ");
179    switch (p.antibandingMode) {
180        CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_AUTO)
181        CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_OFF)
182        CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_50HZ)
183        CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_60HZ)
184        default: result.append("UNKNOWN\n");
185    }
186
187    result.append("    Scene mode: ");
188    switch (p.sceneMode) {
189        case ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED:
190            result.append("AUTO\n"); break;
191        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_ACTION)
192        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_PORTRAIT)
193        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_LANDSCAPE)
194        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_NIGHT)
195        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT)
196        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_THEATRE)
197        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_BEACH)
198        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SNOW)
199        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SUNSET)
200        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO)
201        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_FIREWORKS)
202        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SPORTS)
203        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_PARTY)
204        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT)
205        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_BARCODE)
206        default: result.append("UNKNOWN\n");
207    }
208
209    result.append("    Flash mode: ");
210    switch (p.flashMode) {
211        CASE_APPEND_ENUM(Parameters::FLASH_MODE_OFF)
212        CASE_APPEND_ENUM(Parameters::FLASH_MODE_AUTO)
213        CASE_APPEND_ENUM(Parameters::FLASH_MODE_ON)
214        CASE_APPEND_ENUM(Parameters::FLASH_MODE_TORCH)
215        CASE_APPEND_ENUM(Parameters::FLASH_MODE_RED_EYE)
216        CASE_APPEND_ENUM(Parameters::FLASH_MODE_INVALID)
217        default: result.append("UNKNOWN\n");
218    }
219
220    result.append("    Focus mode: ");
221    switch (p.focusMode) {
222        CASE_APPEND_ENUM(Parameters::FOCUS_MODE_AUTO)
223        CASE_APPEND_ENUM(Parameters::FOCUS_MODE_MACRO)
224        CASE_APPEND_ENUM(Parameters::FOCUS_MODE_CONTINUOUS_VIDEO)
225        CASE_APPEND_ENUM(Parameters::FOCUS_MODE_CONTINUOUS_PICTURE)
226        CASE_APPEND_ENUM(Parameters::FOCUS_MODE_EDOF)
227        CASE_APPEND_ENUM(Parameters::FOCUS_MODE_INFINITY)
228        CASE_APPEND_ENUM(Parameters::FOCUS_MODE_FIXED)
229        CASE_APPEND_ENUM(Parameters::FOCUS_MODE_INVALID)
230        default: result.append("UNKNOWN\n");
231    }
232
233    result.append("    Focusing areas:\n");
234    for (size_t i = 0; i < p.focusingAreas.size(); i++) {
235        result.appendFormat("      [ (%d, %d, %d, %d), weight %d ]\n",
236                p.focusingAreas[i].left,
237                p.focusingAreas[i].top,
238                p.focusingAreas[i].right,
239                p.focusingAreas[i].bottom,
240                p.focusingAreas[i].weight);
241    }
242
243    result.appendFormat("    Exposure compensation index: %d\n",
244            p.exposureCompensation);
245
246    result.appendFormat("    AE lock %s, AWB lock %s\n",
247            p.autoExposureLock ? "enabled" : "disabled",
248            p.autoWhiteBalanceLock ? "enabled" : "disabled" );
249
250    result.appendFormat("    Metering areas:\n");
251    for (size_t i = 0; i < p.meteringAreas.size(); i++) {
252        result.appendFormat("      [ (%d, %d, %d, %d), weight %d ]\n",
253                p.meteringAreas[i].left,
254                p.meteringAreas[i].top,
255                p.meteringAreas[i].right,
256                p.meteringAreas[i].bottom,
257                p.meteringAreas[i].weight);
258    }
259
260    result.appendFormat("    Zoom index: %d\n", p.zoom);
261    result.appendFormat("    Video size: %d x %d\n", p.videoWidth,
262            p.videoHeight);
263
264    result.appendFormat("    Recording hint is %s\n",
265            p.recordingHint ? "set" : "not set");
266
267    result.appendFormat("    Video stabilization is %s\n",
268            p.videoStabilization ? "enabled" : "disabled");
269
270    result.append("  Current streams:\n");
271    result.appendFormat("    Preview stream ID: %d\n", mPreviewStreamId);
272    result.appendFormat("    Capture stream ID: %d\n", mCaptureStreamId);
273    result.appendFormat("    Recording stream ID: %d\n", mRecordingStreamId);
274
275    result.append("  Current requests:\n");
276    if (mPreviewRequest != NULL) {
277        result.append("    Preview request:\n");
278        write(fd, result.string(), result.size());
279        dump_camera_metadata(mPreviewRequest, fd, 2);
280    } else {
281        result.append("    Preview request: undefined\n");
282        write(fd, result.string(), result.size());
283    }
284
285    if (mCaptureRequest != NULL) {
286        result = "    Capture request:\n";
287        write(fd, result.string(), result.size());
288        dump_camera_metadata(mCaptureRequest, fd, 2);
289    } else {
290        result = "    Capture request: undefined\n";
291        write(fd, result.string(), result.size());
292    }
293
294    result = "  Device dump:\n";
295    write(fd, result.string(), result.size());
296
297    status_t res = mDevice->dump(fd, args);
298    if (res != OK) {
299        result = String8::format("   Error dumping device: %s (%d)",
300                strerror(-res), res);
301        write(fd, result.string(), result.size());
302    }
303
304#undef CASE_APPEND_ENUM
305    return NO_ERROR;
306}
307
308const char* Camera2Client::getStateName(State state) {
309#define CASE_ENUM_TO_CHAR(x) case x: return(#x); break;
310    switch(state) {
311        CASE_ENUM_TO_CHAR(NOT_INITIALIZED)
312        CASE_ENUM_TO_CHAR(STOPPED)
313        CASE_ENUM_TO_CHAR(WAITING_FOR_PREVIEW_WINDOW)
314        CASE_ENUM_TO_CHAR(PREVIEW)
315        CASE_ENUM_TO_CHAR(RECORD)
316        CASE_ENUM_TO_CHAR(STILL_CAPTURE)
317        CASE_ENUM_TO_CHAR(VIDEO_SNAPSHOT)
318        default:
319            return "Unknown state!";
320            break;
321    }
322#undef CASE_ENUM_TO_CHAR
323}
324
325// ICamera interface
326
327void Camera2Client::disconnect() {
328    ATRACE_CALL();
329    ALOGV("%s: E", __FUNCTION__);
330    Mutex::Autolock icl(mICameraLock);
331
332    if (mDevice == 0) return;
333
334    stopPreviewLocked();
335
336    mDevice->waitUntilDrained();
337
338    if (mPreviewStreamId != NO_STREAM) {
339        mDevice->deleteStream(mPreviewStreamId);
340        mPreviewStreamId = NO_STREAM;
341    }
342
343    if (mCaptureStreamId != NO_STREAM) {
344        mDevice->deleteStream(mCaptureStreamId);
345        mCaptureStreamId = NO_STREAM;
346    }
347
348    if (mRecordingStreamId != NO_STREAM) {
349        mDevice->deleteStream(mRecordingStreamId);
350        mRecordingStreamId = NO_STREAM;
351    }
352
353    CameraService::Client::disconnect();
354}
355
356status_t Camera2Client::connect(const sp<ICameraClient>& client) {
357    ATRACE_CALL();
358    ALOGV("%s: E", __FUNCTION__);
359    Mutex::Autolock icl(mICameraLock);
360
361    if (mClientPid != 0 && getCallingPid() != mClientPid) {
362        ALOGE("%s: Camera %d: Connection attempt from pid %d; "
363                "current locked to pid %d", __FUNCTION__,
364                mCameraId, getCallingPid(), mClientPid);
365        return BAD_VALUE;
366    }
367
368    mClientPid = getCallingPid();
369    mCameraClient = client;
370
371    return OK;
372}
373
374status_t Camera2Client::lock() {
375    ATRACE_CALL();
376    ALOGV("%s: E", __FUNCTION__);
377    Mutex::Autolock icl(mICameraLock);
378    ALOGV("%s: Camera %d: Lock call from pid %d; current client pid %d",
379            __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
380
381    if (mClientPid == 0) {
382        mClientPid = getCallingPid();
383        return OK;
384    }
385
386    if (mClientPid != getCallingPid()) {
387        ALOGE("%s: Camera %d: Lock call from pid %d; currently locked to pid %d",
388                __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
389        return EBUSY;
390    }
391
392    return OK;
393}
394
395status_t Camera2Client::unlock() {
396    ATRACE_CALL();
397    ALOGV("%s: E", __FUNCTION__);
398    Mutex::Autolock icl(mICameraLock);
399    ALOGV("%s: Camera %d: Unlock call from pid %d; current client pid %d",
400            __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
401
402    // TODO: Check for uninterruptable conditions
403
404    if (mClientPid == getCallingPid()) {
405        mClientPid = 0;
406        mCameraClient.clear();
407        return OK;
408    }
409
410    ALOGE("%s: Camera %d: Unlock call from pid %d; currently locked to pid %d",
411            __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
412    return EBUSY;
413}
414
415status_t Camera2Client::setPreviewDisplay(
416        const sp<Surface>& surface) {
417    ATRACE_CALL();
418    ALOGV("%s: E", __FUNCTION__);
419    Mutex::Autolock icl(mICameraLock);
420
421    sp<IBinder> binder;
422    sp<ANativeWindow> window;
423    if (surface != 0) {
424        binder = surface->asBinder();
425        window = surface;
426    }
427
428    return setPreviewWindowLocked(binder,window);
429}
430
431status_t Camera2Client::setPreviewTexture(
432        const sp<ISurfaceTexture>& surfaceTexture) {
433    ATRACE_CALL();
434    ALOGV("%s: E", __FUNCTION__);
435    Mutex::Autolock icl(mICameraLock);
436
437    sp<IBinder> binder;
438    sp<ANativeWindow> window;
439    if (surfaceTexture != 0) {
440        binder = surfaceTexture->asBinder();
441        window = new SurfaceTextureClient(surfaceTexture);
442    }
443    return setPreviewWindowLocked(binder, window);
444}
445
446status_t Camera2Client::setPreviewWindowLocked(const sp<IBinder>& binder,
447        sp<ANativeWindow> window) {
448    ATRACE_CALL();
449    status_t res;
450
451    if (binder == mPreviewSurface) {
452        ALOGV("%s: Camera %d: New window is same as old window",
453                __FUNCTION__, mCameraId);
454        return NO_ERROR;
455    }
456
457    switch (mState) {
458        case NOT_INITIALIZED:
459        case RECORD:
460        case STILL_CAPTURE:
461        case VIDEO_SNAPSHOT:
462            ALOGE("%s: Camera %d: Cannot set preview display while in state %s",
463                    __FUNCTION__, mCameraId, getStateName(mState));
464            return INVALID_OPERATION;
465        case STOPPED:
466        case WAITING_FOR_PREVIEW_WINDOW:
467            // OK
468            break;
469        case PREVIEW:
470            // Already running preview - need to stop and create a new stream
471            // TODO: Optimize this so that we don't wait for old stream to drain
472            // before spinning up new stream
473            mDevice->setStreamingRequest(NULL);
474            mState = WAITING_FOR_PREVIEW_WINDOW;
475            break;
476    }
477
478    if (mPreviewStreamId != NO_STREAM) {
479        res = mDevice->waitUntilDrained();
480        if (res != OK) {
481            ALOGE("%s: Error waiting for preview to drain: %s (%d)",
482                    __FUNCTION__, strerror(-res), res);
483            return res;
484        }
485        res = mDevice->deleteStream(mPreviewStreamId);
486        if (res != OK) {
487            ALOGE("%s: Unable to delete old preview stream: %s (%d)",
488                    __FUNCTION__, strerror(-res), res);
489            return res;
490        }
491        mPreviewStreamId = NO_STREAM;
492    }
493
494    mPreviewSurface = binder;
495    mPreviewWindow = window;
496
497    if (mState == WAITING_FOR_PREVIEW_WINDOW) {
498        return startPreviewLocked();
499    }
500
501    return OK;
502}
503
504void Camera2Client::setPreviewCallbackFlag(int flag) {
505    ATRACE_CALL();
506    Mutex::Autolock icl(mICameraLock);
507}
508
509status_t Camera2Client::startPreview() {
510    ATRACE_CALL();
511    ALOGV("%s: E", __FUNCTION__);
512    Mutex::Autolock icl(mICameraLock);
513    return startPreviewLocked();
514}
515
516status_t Camera2Client::startPreviewLocked() {
517    ATRACE_CALL();
518    status_t res;
519    if (mState >= PREVIEW) {
520        ALOGE("%s: Can't start preview in state %s",
521                __FUNCTION__, getStateName(mState));
522        return INVALID_OPERATION;
523    }
524
525    if (mPreviewWindow == 0) {
526        mState = WAITING_FOR_PREVIEW_WINDOW;
527        return OK;
528    }
529    mState = STOPPED;
530
531    LockedParameters::Key k(mParameters);
532
533    res = updatePreviewStream(k.mParameters);
534    if (res != OK) {
535        ALOGE("%s: Camera %d: Unable to update preview stream: %s (%d)",
536                __FUNCTION__, mCameraId, strerror(-res), res);
537        return res;
538    }
539
540    if (mPreviewRequest == NULL) {
541        res = updatePreviewRequest(k.mParameters);
542        if (res != OK) {
543            ALOGE("%s: Camera %d: Unable to create preview request: %s (%d)",
544                    __FUNCTION__, mCameraId, strerror(-res), res);
545            return res;
546        }
547    }
548
549    res = updateEntry(mPreviewRequest,
550            ANDROID_REQUEST_OUTPUT_STREAMS,
551            &mPreviewStreamId, 1);
552    if (res != OK) {
553        ALOGE("%s: Camera %d: Unable to set up preview request: %s (%d)",
554                __FUNCTION__, mCameraId, strerror(-res), res);
555        return res;
556    }
557    res = sort_camera_metadata(mPreviewRequest);
558    if (res != OK) {
559        ALOGE("%s: Camera %d: Error sorting preview request: %s (%d)",
560                __FUNCTION__, mCameraId, strerror(-res), res);
561        return res;
562    }
563
564    res = mDevice->setStreamingRequest(mPreviewRequest);
565    if (res != OK) {
566        ALOGE("%s: Camera %d: Unable to set preview request to start preview: "
567                "%s (%d)",
568                __FUNCTION__, mCameraId, strerror(-res), res);
569        return res;
570    }
571    mState = PREVIEW;
572
573    return OK;
574}
575
576void Camera2Client::stopPreview() {
577    ATRACE_CALL();
578    ALOGV("%s: E", __FUNCTION__);
579    Mutex::Autolock icl(mICameraLock);
580    stopPreviewLocked();
581}
582
583void Camera2Client::stopPreviewLocked() {
584    ATRACE_CALL();
585    switch (mState) {
586        case NOT_INITIALIZED:
587            ALOGE("%s: Camera %d: Call before initialized",
588                    __FUNCTION__, mCameraId);
589            break;
590        case STOPPED:
591            break;
592        case STILL_CAPTURE:
593            ALOGE("%s: Camera %d: Cannot stop preview during still capture.",
594                    __FUNCTION__, mCameraId);
595            break;
596        case RECORD:
597            // TODO: Handle record stop here
598        case PREVIEW:
599            mDevice->setStreamingRequest(NULL);
600            mDevice->waitUntilDrained();
601        case WAITING_FOR_PREVIEW_WINDOW:
602            mState = STOPPED;
603            break;
604        default:
605            ALOGE("%s: Camera %d: Unknown state %d", __FUNCTION__, mCameraId,
606                    mState);
607    }
608}
609
610bool Camera2Client::previewEnabled() {
611    ATRACE_CALL();
612    Mutex::Autolock icl(mICameraLock);
613    return mState == PREVIEW;
614}
615
616status_t Camera2Client::storeMetaDataInBuffers(bool enabled) {
617    ATRACE_CALL();
618    Mutex::Autolock icl(mICameraLock);
619    switch (mState) {
620        case RECORD:
621        case VIDEO_SNAPSHOT:
622            ALOGE("%s: Camera %d: Can't be called in state %s",
623                    __FUNCTION__, mCameraId, getStateName(mState));
624            return INVALID_OPERATION;
625        default:
626            // OK
627            break;
628    }
629    LockedParameters::Key k(mParameters);
630
631    k.mParameters.storeMetadataInBuffers = enabled;
632
633    return OK;
634}
635
636status_t Camera2Client::startRecording() {
637    ATRACE_CALL();
638    ALOGV("%s: E", __FUNCTION__);
639    Mutex::Autolock icl(mICameraLock);
640    status_t res;
641    switch (mState) {
642        case STOPPED:
643            res = startPreviewLocked();
644            if (res != OK) return res;
645            break;
646        case PREVIEW:
647            // Ready to go
648            break;
649        case RECORD:
650        case VIDEO_SNAPSHOT:
651            // OK to call this when recording is already on
652            return OK;
653            break;
654        default:
655            ALOGE("%s: Camera %d: Can't start recording in state %s",
656                    __FUNCTION__, mCameraId, getStateName(mState));
657            return INVALID_OPERATION;
658    };
659
660    LockedParameters::Key k(mParameters);
661
662    if (!k.mParameters.storeMetadataInBuffers) {
663        ALOGE("%s: Camera %d: Recording only supported in metadata mode, but "
664                "non-metadata recording mode requested!", __FUNCTION__,
665                mCameraId);
666        return INVALID_OPERATION;
667    }
668
669    res = updateRecordingStream(k.mParameters);
670    if (res != OK) {
671        ALOGE("%s: Camera %d: Unable to update recording stream: %s (%d)",
672                __FUNCTION__, mCameraId, strerror(-res), res);
673        return res;
674    }
675
676    if (mRecordingRequest == NULL) {
677        res = updateRecordingRequest(k.mParameters);
678        if (res != OK) {
679            ALOGE("%s: Camera %d: Unable to create recording request: %s (%d)",
680                    __FUNCTION__, mCameraId, strerror(-res), res);
681            return res;
682        }
683    }
684
685    uint8_t outputStreams[2] = { mPreviewStreamId, mRecordingStreamId };
686    res = updateEntry(mRecordingRequest,
687            ANDROID_REQUEST_OUTPUT_STREAMS,
688            outputStreams, 2);
689    if (res != OK) {
690        ALOGE("%s: Camera %d: Unable to set up recording request: %s (%d)",
691                __FUNCTION__, mCameraId, strerror(-res), res);
692        return res;
693    }
694    res = sort_camera_metadata(mRecordingRequest);
695    if (res != OK) {
696        ALOGE("%s: Camera %d: Error sorting recording request: %s (%d)",
697                __FUNCTION__, mCameraId, strerror(-res), res);
698        return res;
699    }
700
701    res = mDevice->setStreamingRequest(mRecordingRequest);
702    if (res != OK) {
703        ALOGE("%s: Camera %d: Unable to set recording request to start "
704                "recording: %s (%d)", __FUNCTION__, mCameraId,
705                strerror(-res), res);
706        return res;
707    }
708    mState = RECORD;
709
710    return OK;
711}
712
713void Camera2Client::stopRecording() {
714    ATRACE_CALL();
715    ALOGV("%s: E", __FUNCTION__);
716    Mutex::Autolock icl(mICameraLock);
717    status_t res;
718    switch (mState) {
719        case RECORD:
720            // OK to stop
721            break;
722        case STOPPED:
723        case PREVIEW:
724        case STILL_CAPTURE:
725        case VIDEO_SNAPSHOT:
726        default:
727            ALOGE("%s: Camera %d: Can't stop recording in state %s",
728                    __FUNCTION__, mCameraId, getStateName(mState));
729            return;
730    };
731
732    // Back to preview. Since record can only be reached through preview,
733    // all preview stream setup should be up to date.
734    res = mDevice->setStreamingRequest(mPreviewRequest);
735    if (res != OK) {
736        ALOGE("%s: Camera %d: Unable to switch back to preview request: "
737                "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
738        return;
739    }
740
741    // TODO: Should recording heap be freed? Can't do it yet since requests
742    // could still be in flight.
743
744    mState = PREVIEW;
745}
746
747bool Camera2Client::recordingEnabled() {
748    ATRACE_CALL();
749    Mutex::Autolock icl(mICameraLock);
750    return (mState == RECORD || mState == VIDEO_SNAPSHOT);
751}
752
753void Camera2Client::releaseRecordingFrame(const sp<IMemory>& mem) {
754    ATRACE_CALL();
755    Mutex::Autolock icl(mICameraLock);
756    // Make sure this is for the current heap
757    ssize_t offset;
758    size_t size;
759    status_t res;
760    sp<IMemoryHeap> heap = mem->getMemory(&offset, &size);
761    if (heap->getHeapID() != mRecordingHeap->mHeap->getHeapID()) {
762        ALOGW("%s: Camera %d: Mismatched heap ID, ignoring release "
763                "(got %x, expected %x)", __FUNCTION__, mCameraId,
764                heap->getHeapID(), mRecordingHeap->mHeap->getHeapID());
765        return;
766    }
767    uint8_t *data = (uint8_t*)heap->getBase() + offset;
768    uint32_t type = *(uint32_t*)data;
769    if (type != kMetadataBufferTypeGrallocSource) {
770        ALOGE("%s: Camera %d: Recording frame type invalid (got %x, expected %x)",
771                __FUNCTION__, mCameraId, type, kMetadataBufferTypeGrallocSource);
772        return;
773    }
774    buffer_handle_t imgBuffer = *(buffer_handle_t*)(data + 4);
775    ALOGV("%s: Camera %d: Freeing buffer_handle_t %p", __FUNCTION__, mCameraId,
776            imgBuffer);
777    res = mRecordingConsumer->freeBuffer(imgBuffer);
778    if (res != OK) {
779        ALOGE("%s: Camera %d: Unable to free recording frame (buffer_handle_t: %p):"
780                "%s (%d)",
781                __FUNCTION__, mCameraId, imgBuffer, strerror(-res), res);
782        return;
783    }
784
785    mRecordingHeapFree++;
786}
787
788status_t Camera2Client::autoFocus() {
789    ATRACE_CALL();
790    Mutex::Autolock icl(mICameraLock);
791    return OK;
792}
793
794status_t Camera2Client::cancelAutoFocus() {
795    ATRACE_CALL();
796    Mutex::Autolock icl(mICameraLock);
797    return OK;
798}
799
800status_t Camera2Client::takePicture(int msgType) {
801    ATRACE_CALL();
802    Mutex::Autolock icl(mICameraLock);
803    status_t res;
804
805    switch (mState) {
806        case NOT_INITIALIZED:
807        case STOPPED:
808        case WAITING_FOR_PREVIEW_WINDOW:
809            ALOGE("%s: Camera %d: Cannot take picture without preview enabled",
810                    __FUNCTION__, mCameraId);
811            return INVALID_OPERATION;
812        case PREVIEW:
813        case RECORD:
814            // Good to go for takePicture
815            break;
816        case STILL_CAPTURE:
817        case VIDEO_SNAPSHOT:
818            ALOGE("%s: Camera %d: Already taking a picture",
819                    __FUNCTION__, mCameraId);
820            return INVALID_OPERATION;
821    }
822
823    LockedParameters::Key k(mParameters);
824
825    res = updateCaptureStream(k.mParameters);
826    if (res != OK) {
827        ALOGE("%s: Camera %d: Can't set up still image stream: %s (%d)",
828                __FUNCTION__, mCameraId, strerror(-res), res);
829        return res;
830    }
831
832    if (mCaptureRequest == NULL) {
833        res = updateCaptureRequest(k.mParameters);
834        if (res != OK) {
835            ALOGE("%s: Camera %d: Can't create still image capture request: "
836                    "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
837            return res;
838        }
839    }
840
841    camera_metadata_entry_t outputStreams;
842    if (mState == PREVIEW) {
843        uint8_t streamIds[2] = { mPreviewStreamId, mCaptureStreamId };
844        res = updateEntry(mCaptureRequest, ANDROID_REQUEST_OUTPUT_STREAMS,
845                &streamIds, 2);
846    } else if (mState == RECORD) {
847        uint8_t streamIds[3] = { mPreviewStreamId, mRecordingStreamId,
848                                 mCaptureStreamId };
849        res = updateEntry(mCaptureRequest, ANDROID_REQUEST_OUTPUT_STREAMS,
850                &streamIds, 3);
851    }
852
853    if (res != OK) {
854        ALOGE("%s: Camera %d: Unable to set up still image capture request: "
855                "%s (%d)",
856                __FUNCTION__, mCameraId, strerror(-res), res);
857        return res;
858    }
859    res = sort_camera_metadata(mCaptureRequest);
860    if (res != OK) {
861        ALOGE("%s: Camera %d: Unable to sort capture request: %s (%d)",
862                __FUNCTION__, mCameraId, strerror(-res), res);
863        return res;
864    }
865
866    camera_metadata_t *captureCopy = clone_camera_metadata(mCaptureRequest);
867    if (captureCopy == NULL) {
868        ALOGE("%s: Camera %d: Unable to copy capture request for HAL device",
869                __FUNCTION__, mCameraId);
870        return NO_MEMORY;
871    }
872
873    if (mState == PREVIEW) {
874        res = mDevice->setStreamingRequest(NULL);
875        if (res != OK) {
876            ALOGE("%s: Camera %d: Unable to stop preview for still capture: "
877                    "%s (%d)",
878                    __FUNCTION__, mCameraId, strerror(-res), res);
879            return res;
880        }
881    }
882    // TODO: Capture should be atomic with setStreamingRequest here
883    res = mDevice->capture(captureCopy);
884    if (res != OK) {
885        ALOGE("%s: Camera %d: Unable to submit still image capture request: "
886                "%s (%d)",
887                __FUNCTION__, mCameraId, strerror(-res), res);
888        return res;
889    }
890
891    switch (mState) {
892        case PREVIEW:
893            mState = STILL_CAPTURE;
894            break;
895        case RECORD:
896            mState = VIDEO_SNAPSHOT;
897            break;
898        default:
899            ALOGE("%s: Camera %d: Unknown state for still capture!",
900                    __FUNCTION__, mCameraId);
901            return INVALID_OPERATION;
902    }
903
904    return OK;
905}
906
907status_t Camera2Client::setParameters(const String8& params) {
908    ATRACE_CALL();
909    ALOGV("%s: E", __FUNCTION__);
910    Mutex::Autolock icl(mICameraLock);
911    LockedParameters::Key k(mParameters);
912    status_t res;
913
914    CameraParameters newParams(params);
915
916    // TODO: Currently ignoring any changes to supposedly read-only
917    // parameters such as supported preview sizes, etc. Should probably
918    // produce an error if they're changed.
919
920    /** Extract and verify new parameters */
921
922    size_t i;
923
924    // PREVIEW_SIZE
925    int previewWidth, previewHeight;
926    newParams.getPreviewSize(&previewWidth, &previewHeight);
927
928    if (previewWidth != k.mParameters.previewWidth ||
929            previewHeight != k.mParameters.previewHeight) {
930        if (mState >= PREVIEW) {
931            ALOGE("%s: Preview size cannot be updated when preview "
932                    "is active! (Currently %d x %d, requested %d x %d",
933                    __FUNCTION__,
934                    k.mParameters.previewWidth, k.mParameters.previewHeight,
935                    previewWidth, previewHeight);
936            return BAD_VALUE;
937        }
938        camera_metadata_entry_t availablePreviewSizes =
939            staticInfo(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES);
940        for (i = 0; i < availablePreviewSizes.count; i += 2 ) {
941            if (availablePreviewSizes.data.i32[i] == previewWidth &&
942                    availablePreviewSizes.data.i32[i+1] == previewHeight) break;
943        }
944        if (i == availablePreviewSizes.count) {
945            ALOGE("%s: Requested preview size %d x %d is not supported",
946                    __FUNCTION__, previewWidth, previewHeight);
947            return BAD_VALUE;
948        }
949    }
950
951    // PREVIEW_FPS_RANGE
952    int previewFpsRange[2];
953    int previewFps = 0;
954    bool fpsRangeChanged = false;
955    newParams.getPreviewFpsRange(&previewFpsRange[0], &previewFpsRange[1]);
956    if (previewFpsRange[0] != k.mParameters.previewFpsRange[0] ||
957            previewFpsRange[1] != k.mParameters.previewFpsRange[1]) {
958        fpsRangeChanged = true;
959        camera_metadata_entry_t availablePreviewFpsRanges =
960            staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES, 2);
961        for (i = 0; i < availablePreviewFpsRanges.count; i += 2) {
962            if ((availablePreviewFpsRanges.data.i32[i] ==
963                    previewFpsRange[0]) &&
964                (availablePreviewFpsRanges.data.i32[i+1] ==
965                    previewFpsRange[1]) ) {
966                break;
967            }
968        }
969        if (i == availablePreviewFpsRanges.count) {
970            ALOGE("%s: Requested preview FPS range %d - %d is not supported",
971                __FUNCTION__, previewFpsRange[0], previewFpsRange[1]);
972            return BAD_VALUE;
973        }
974        previewFps = previewFpsRange[0];
975    }
976
977    // PREVIEW_FORMAT
978    int previewFormat = formatStringToEnum(newParams.getPreviewFormat());
979    if (previewFormat != k.mParameters.previewFormat) {
980        if (mState >= PREVIEW) {
981            ALOGE("%s: Preview format cannot be updated when preview "
982                    "is active!", __FUNCTION__);
983            return BAD_VALUE;
984        }
985        camera_metadata_entry_t availableFormats =
986            staticInfo(ANDROID_SCALER_AVAILABLE_FORMATS);
987        for (i = 0; i < availableFormats.count; i++) {
988            if (availableFormats.data.i32[i] == previewFormat) break;
989        }
990        if (i == availableFormats.count) {
991            ALOGE("%s: Requested preview format %s (0x%x) is not supported",
992                    __FUNCTION__, newParams.getPreviewFormat(), previewFormat);
993            return BAD_VALUE;
994        }
995    }
996
997    // PREVIEW_FRAME_RATE
998    // Deprecated, only use if the preview fps range is unchanged this time.
999    // The single-value FPS is the same as the minimum of the range.
1000    if (!fpsRangeChanged) {
1001        previewFps = newParams.getPreviewFrameRate();
1002        if (previewFps != k.mParameters.previewFps) {
1003            camera_metadata_entry_t availableFrameRates =
1004                staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES);
1005            for (i = 0; i < availableFrameRates.count; i+=2) {
1006                if (availableFrameRates.data.i32[i] == previewFps) break;
1007            }
1008            if (i == availableFrameRates.count) {
1009                ALOGE("%s: Requested preview frame rate %d is not supported",
1010                        __FUNCTION__, previewFps);
1011                return BAD_VALUE;
1012            }
1013            previewFpsRange[0] = availableFrameRates.data.i32[i];
1014            previewFpsRange[1] = availableFrameRates.data.i32[i+1];
1015        }
1016    }
1017
1018    // PICTURE_SIZE
1019    int pictureWidth, pictureHeight;
1020    newParams.getPictureSize(&pictureWidth, &pictureHeight);
1021    if (pictureWidth == k.mParameters.pictureWidth ||
1022            pictureHeight == k.mParameters.pictureHeight) {
1023        camera_metadata_entry_t availablePictureSizes =
1024            staticInfo(ANDROID_SCALER_AVAILABLE_JPEG_SIZES);
1025        for (i = 0; i < availablePictureSizes.count; i+=2) {
1026            if (availablePictureSizes.data.i32[i] == pictureWidth &&
1027                    availablePictureSizes.data.i32[i+1] == pictureHeight) break;
1028        }
1029        if (i == availablePictureSizes.count) {
1030            ALOGE("%s: Requested picture size %d x %d is not supported",
1031                    __FUNCTION__, pictureWidth, pictureHeight);
1032            return BAD_VALUE;
1033        }
1034    }
1035
1036    // JPEG_THUMBNAIL_WIDTH/HEIGHT
1037    int jpegThumbSize[2];
1038    jpegThumbSize[0] =
1039            newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH);
1040    jpegThumbSize[1] =
1041            newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT);
1042    if (jpegThumbSize[0] != k.mParameters.jpegThumbSize[0] ||
1043            jpegThumbSize[1] != k.mParameters.jpegThumbSize[1]) {
1044        camera_metadata_entry_t availableJpegThumbSizes =
1045            staticInfo(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES);
1046        for (i = 0; i < availableJpegThumbSizes.count; i+=2) {
1047            if (availableJpegThumbSizes.data.i32[i] == jpegThumbSize[0] &&
1048                    availableJpegThumbSizes.data.i32[i+1] == jpegThumbSize[1]) {
1049                break;
1050            }
1051        }
1052        if (i == availableJpegThumbSizes.count) {
1053            ALOGE("%s: Requested JPEG thumbnail size %d x %d is not supported",
1054                    __FUNCTION__, jpegThumbSize[0], jpegThumbSize[1]);
1055            return BAD_VALUE;
1056        }
1057    }
1058
1059    // JPEG_THUMBNAIL_QUALITY
1060    int jpegThumbQuality =
1061            newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY);
1062    if (jpegThumbQuality < 0 || jpegThumbQuality > 100) {
1063        ALOGE("%s: Requested JPEG thumbnail quality %d is not supported",
1064                __FUNCTION__, jpegThumbQuality);
1065        return BAD_VALUE;
1066    }
1067
1068    // JPEG_QUALITY
1069    int jpegQuality =
1070            newParams.getInt(CameraParameters::KEY_JPEG_QUALITY);
1071    if (jpegQuality < 0 || jpegQuality > 100) {
1072        ALOGE("%s: Requested JPEG quality %d is not supported",
1073                __FUNCTION__, jpegQuality);
1074        return BAD_VALUE;
1075    }
1076
1077    // ROTATION
1078    int jpegRotation =
1079            newParams.getInt(CameraParameters::KEY_ROTATION);
1080    if (jpegRotation != 0 &&
1081            jpegRotation != 90 &&
1082            jpegRotation != 180 &&
1083            jpegRotation != 270) {
1084        ALOGE("%s: Requested picture rotation angle %d is not supported",
1085                __FUNCTION__, jpegRotation);
1086        return BAD_VALUE;
1087    }
1088
1089    // GPS
1090    bool gpsEnabled = false;
1091    double gpsCoordinates[3] = {0,0,0};
1092    int64_t gpsTimestamp = 0;
1093    String8 gpsProcessingMethod;
1094    const char *gpsLatStr =
1095            newParams.get(CameraParameters::KEY_GPS_LATITUDE);
1096    if (gpsLatStr != NULL) {
1097        const char *gpsLongStr =
1098                newParams.get(CameraParameters::KEY_GPS_LONGITUDE);
1099        const char *gpsAltitudeStr =
1100                newParams.get(CameraParameters::KEY_GPS_ALTITUDE);
1101        const char *gpsTimeStr =
1102                newParams.get(CameraParameters::KEY_GPS_TIMESTAMP);
1103        const char *gpsProcMethodStr =
1104                newParams.get(CameraParameters::KEY_GPS_PROCESSING_METHOD);
1105        if (gpsLongStr == NULL ||
1106                gpsAltitudeStr == NULL ||
1107                gpsTimeStr == NULL ||
1108                gpsProcMethodStr == NULL) {
1109            ALOGE("%s: Incomplete set of GPS parameters provided",
1110                    __FUNCTION__);
1111            return BAD_VALUE;
1112        }
1113        char *endPtr;
1114        errno = 0;
1115        gpsCoordinates[0] = strtod(gpsLatStr, &endPtr);
1116        if (errno || endPtr == gpsLatStr) {
1117            ALOGE("%s: Malformed GPS latitude: %s", __FUNCTION__, gpsLatStr);
1118            return BAD_VALUE;
1119        }
1120        errno = 0;
1121        gpsCoordinates[1] = strtod(gpsLongStr, &endPtr);
1122        if (errno || endPtr == gpsLongStr) {
1123            ALOGE("%s: Malformed GPS longitude: %s", __FUNCTION__, gpsLongStr);
1124            return BAD_VALUE;
1125        }
1126        errno = 0;
1127        gpsCoordinates[2] = strtod(gpsAltitudeStr, &endPtr);
1128        if (errno || endPtr == gpsAltitudeStr) {
1129            ALOGE("%s: Malformed GPS altitude: %s", __FUNCTION__,
1130                    gpsAltitudeStr);
1131            return BAD_VALUE;
1132        }
1133        errno = 0;
1134        gpsTimestamp = strtoll(gpsTimeStr, &endPtr, 10);
1135        if (errno || endPtr == gpsTimeStr) {
1136            ALOGE("%s: Malformed GPS timestamp: %s", __FUNCTION__, gpsTimeStr);
1137            return BAD_VALUE;
1138        }
1139        gpsProcessingMethod = gpsProcMethodStr;
1140
1141        gpsEnabled = true;
1142    }
1143
1144    // WHITE_BALANCE
1145    int wbMode = wbModeStringToEnum(
1146        newParams.get(CameraParameters::KEY_WHITE_BALANCE) );
1147    if (wbMode != k.mParameters.wbMode) {
1148        camera_metadata_entry_t availableWbModes =
1149            staticInfo(ANDROID_CONTROL_AWB_AVAILABLE_MODES);
1150        for (i = 0; i < availableWbModes.count; i++) {
1151            if (wbMode == availableWbModes.data.u8[i]) break;
1152        }
1153        if (i == availableWbModes.count) {
1154            ALOGE("%s: Requested white balance mode %s is not supported",
1155                    __FUNCTION__,
1156                    newParams.get(CameraParameters::KEY_WHITE_BALANCE));
1157            return BAD_VALUE;
1158        }
1159    }
1160
1161    // EFFECT
1162    int effectMode = effectModeStringToEnum(
1163        newParams.get(CameraParameters::KEY_EFFECT) );
1164    if (effectMode != k.mParameters.effectMode) {
1165        camera_metadata_entry_t availableEffectModes =
1166            staticInfo(ANDROID_CONTROL_AVAILABLE_EFFECTS);
1167        for (i = 0; i < availableEffectModes.count; i++) {
1168            if (effectMode == availableEffectModes.data.u8[i]) break;
1169        }
1170        if (i == availableEffectModes.count) {
1171            ALOGE("%s: Requested effect mode \"%s\" is not supported",
1172                    __FUNCTION__,
1173                    newParams.get(CameraParameters::KEY_EFFECT) );
1174            return BAD_VALUE;
1175        }
1176    }
1177
1178    // ANTIBANDING
1179    int antibandingMode = abModeStringToEnum(
1180        newParams.get(CameraParameters::KEY_ANTIBANDING) );
1181    if (antibandingMode != k.mParameters.antibandingMode) {
1182        camera_metadata_entry_t availableAbModes =
1183            staticInfo(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES);
1184        for (i = 0; i < availableAbModes.count; i++) {
1185            if (antibandingMode == availableAbModes.data.u8[i]) break;
1186        }
1187        if (i == availableAbModes.count) {
1188            ALOGE("%s: Requested antibanding mode \"%s\" is not supported",
1189                    __FUNCTION__,
1190                    newParams.get(CameraParameters::KEY_ANTIBANDING));
1191            return BAD_VALUE;
1192        }
1193    }
1194
1195    // SCENE_MODE
1196    int sceneMode = sceneModeStringToEnum(
1197        newParams.get(CameraParameters::KEY_SCENE_MODE) );
1198    if (sceneMode != k.mParameters.sceneMode) {
1199        camera_metadata_entry_t availableSceneModes =
1200            staticInfo(ANDROID_CONTROL_AVAILABLE_SCENE_MODES);
1201        for (i = 0; i < availableSceneModes.count; i++) {
1202            if (sceneMode == availableSceneModes.data.u8[i]) break;
1203        }
1204        if (i == availableSceneModes.count) {
1205            ALOGE("%s: Requested scene mode \"%s\" is not supported",
1206                    __FUNCTION__,
1207                    newParams.get(CameraParameters::KEY_SCENE_MODE));
1208            return BAD_VALUE;
1209        }
1210    }
1211
1212    // FLASH_MODE
1213    Parameters::flashMode_t flashMode = flashModeStringToEnum(
1214        newParams.get(CameraParameters::KEY_FLASH_MODE) );
1215    if (flashMode != k.mParameters.flashMode) {
1216        camera_metadata_entry_t flashAvailable =
1217            staticInfo(ANDROID_FLASH_AVAILABLE, 1, 1);
1218        if (!flashAvailable.data.u8[0] &&
1219                flashMode != Parameters::FLASH_MODE_OFF) {
1220            ALOGE("%s: Requested flash mode \"%s\" is not supported: "
1221                    "No flash on device", __FUNCTION__,
1222                    newParams.get(CameraParameters::KEY_FLASH_MODE));
1223            return BAD_VALUE;
1224        } else if (flashMode == Parameters::FLASH_MODE_RED_EYE) {
1225            camera_metadata_entry_t availableAeModes =
1226                staticInfo(ANDROID_CONTROL_AE_AVAILABLE_MODES);
1227            for (i = 0; i < availableAeModes.count; i++) {
1228                if (flashMode == availableAeModes.data.u8[i]) break;
1229            }
1230            if (i == availableAeModes.count) {
1231                ALOGE("%s: Requested flash mode \"%s\" is not supported",
1232                        __FUNCTION__,
1233                        newParams.get(CameraParameters::KEY_FLASH_MODE));
1234                return BAD_VALUE;
1235            }
1236        } else if (flashMode == -1) {
1237            ALOGE("%s: Requested flash mode \"%s\" is unknown",
1238                    __FUNCTION__,
1239                    newParams.get(CameraParameters::KEY_FLASH_MODE));
1240            return BAD_VALUE;
1241        }
1242    }
1243
1244    // FOCUS_MODE
1245    Parameters::focusMode_t focusMode = focusModeStringToEnum(
1246        newParams.get(CameraParameters::KEY_FOCUS_MODE));
1247    if (focusMode != k.mParameters.focusMode) {
1248        if (focusMode != Parameters::FOCUS_MODE_FIXED) {
1249            camera_metadata_entry_t minFocusDistance =
1250                staticInfo(ANDROID_LENS_MINIMUM_FOCUS_DISTANCE);
1251            if (minFocusDistance.data.f[0] == 0) {
1252                ALOGE("%s: Requested focus mode \"%s\" is not available: "
1253                        "fixed focus lens",
1254                        __FUNCTION__,
1255                        newParams.get(CameraParameters::KEY_FOCUS_MODE));
1256                return BAD_VALUE;
1257            } else if (focusMode != Parameters::FOCUS_MODE_INFINITY) {
1258                camera_metadata_entry_t availableFocusModes =
1259                    staticInfo(ANDROID_CONTROL_AF_AVAILABLE_MODES);
1260                for (i = 0; i < availableFocusModes.count; i++) {
1261                    if (focusMode == availableFocusModes.data.u8[i]) break;
1262                }
1263                if (i == availableFocusModes.count) {
1264                    ALOGE("%s: Requested focus mode \"%s\" is not supported",
1265                            __FUNCTION__,
1266                            newParams.get(CameraParameters::KEY_FOCUS_MODE));
1267                    return BAD_VALUE;
1268                }
1269            }
1270        }
1271    }
1272
1273    // FOCUS_AREAS
1274    Vector<Parameters::Area> focusingAreas;
1275    res = parseAreas(newParams.get(CameraParameters::KEY_FOCUS_AREAS),
1276            &focusingAreas);
1277    size_t max3aRegions =
1278        (size_t)staticInfo(ANDROID_CONTROL_MAX_REGIONS, 1, 1).data.i32[0];
1279    if (res == OK) res = validateAreas(focusingAreas, max3aRegions);
1280    if (res != OK) {
1281        ALOGE("%s: Requested focus areas are malformed: %s",
1282                __FUNCTION__, newParams.get(CameraParameters::KEY_FOCUS_AREAS));
1283        return BAD_VALUE;
1284    }
1285
1286    // EXPOSURE_COMPENSATION
1287    int exposureCompensation =
1288        newParams.getInt(CameraParameters::KEY_EXPOSURE_COMPENSATION);
1289    camera_metadata_entry_t exposureCompensationRange =
1290        staticInfo(ANDROID_CONTROL_AE_EXP_COMPENSATION_RANGE);
1291    if (exposureCompensation < exposureCompensationRange.data.i32[0] ||
1292            exposureCompensation > exposureCompensationRange.data.i32[1]) {
1293        ALOGE("%s: Requested exposure compensation index is out of bounds: %d",
1294                __FUNCTION__, exposureCompensation);
1295        return BAD_VALUE;
1296    }
1297
1298    // AUTO_EXPOSURE_LOCK (always supported)
1299    bool autoExposureLock = boolFromString(
1300        newParams.get(CameraParameters::KEY_AUTO_EXPOSURE_LOCK));
1301
1302    // AUTO_WHITEBALANCE_LOCK (always supported)
1303    bool autoWhiteBalanceLock = boolFromString(
1304        newParams.get(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK));
1305
1306    // METERING_AREAS
1307    Vector<Parameters::Area> meteringAreas;
1308    res = parseAreas(newParams.get(CameraParameters::KEY_METERING_AREAS),
1309            &meteringAreas);
1310    if (res == OK) res = validateAreas(focusingAreas, max3aRegions);
1311    if (res != OK) {
1312        ALOGE("%s: Requested metering areas are malformed: %s",
1313                __FUNCTION__,
1314                newParams.get(CameraParameters::KEY_METERING_AREAS));
1315        return BAD_VALUE;
1316    }
1317
1318    // ZOOM
1319    int zoom = newParams.getInt(CameraParameters::KEY_ZOOM);
1320    if (zoom < 0 || zoom > (int)NUM_ZOOM_STEPS) {
1321        ALOGE("%s: Requested zoom level %d is not supported",
1322                __FUNCTION__, zoom);
1323        return BAD_VALUE;
1324    }
1325
1326    // VIDEO_SIZE
1327    int videoWidth, videoHeight;
1328    newParams.getVideoSize(&videoWidth, &videoHeight);
1329    if (videoWidth != k.mParameters.videoWidth ||
1330            videoHeight != k.mParameters.videoHeight) {
1331        if (mState == RECORD) {
1332            ALOGE("%s: Video size cannot be updated when recording is active!",
1333                    __FUNCTION__);
1334            return BAD_VALUE;
1335        }
1336        camera_metadata_entry_t availableVideoSizes =
1337            staticInfo(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES);
1338        for (i = 0; i < availableVideoSizes.count; i += 2 ) {
1339            if (availableVideoSizes.data.i32[i] == videoWidth &&
1340                    availableVideoSizes.data.i32[i+1] == videoHeight)  break;
1341        }
1342        if (i == availableVideoSizes.count) {
1343            ALOGE("%s: Requested video size %d x %d is not supported",
1344                    __FUNCTION__, videoWidth, videoHeight);
1345            return BAD_VALUE;
1346        }
1347    }
1348
1349    // RECORDING_HINT (always supported)
1350    bool recordingHint = boolFromString(
1351        newParams.get(CameraParameters::KEY_RECORDING_HINT) );
1352
1353    // VIDEO_STABILIZATION
1354    bool videoStabilization = boolFromString(
1355        newParams.get(CameraParameters::KEY_VIDEO_STABILIZATION) );
1356    camera_metadata_entry_t availableVideoStabilizationModes =
1357        staticInfo(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES);
1358    if (videoStabilization && availableVideoStabilizationModes.count == 1) {
1359        ALOGE("%s: Video stabilization not supported", __FUNCTION__);
1360    }
1361
1362    /** Update internal parameters */
1363
1364    k.mParameters.previewWidth = previewWidth;
1365    k.mParameters.previewHeight = previewHeight;
1366    k.mParameters.previewFpsRange[0] = previewFpsRange[0];
1367    k.mParameters.previewFpsRange[1] = previewFpsRange[1];
1368    k.mParameters.previewFps = previewFps;
1369    k.mParameters.previewFormat = previewFormat;
1370
1371    k.mParameters.pictureWidth = pictureWidth;
1372    k.mParameters.pictureHeight = pictureHeight;
1373
1374    k.mParameters.jpegThumbSize[0] = jpegThumbSize[0];
1375    k.mParameters.jpegThumbSize[1] = jpegThumbSize[1];
1376    k.mParameters.jpegQuality = jpegQuality;
1377    k.mParameters.jpegThumbQuality = jpegThumbQuality;
1378
1379    k.mParameters.gpsEnabled = gpsEnabled;
1380    k.mParameters.gpsCoordinates[0] = gpsCoordinates[0];
1381    k.mParameters.gpsCoordinates[1] = gpsCoordinates[1];
1382    k.mParameters.gpsCoordinates[2] = gpsCoordinates[2];
1383    k.mParameters.gpsTimestamp = gpsTimestamp;
1384    k.mParameters.gpsProcessingMethod = gpsProcessingMethod;
1385
1386    k.mParameters.wbMode = wbMode;
1387    k.mParameters.effectMode = effectMode;
1388    k.mParameters.antibandingMode = antibandingMode;
1389    k.mParameters.sceneMode = sceneMode;
1390
1391    k.mParameters.flashMode = flashMode;
1392    k.mParameters.focusMode = focusMode;
1393
1394    k.mParameters.focusingAreas = focusingAreas;
1395    k.mParameters.exposureCompensation = exposureCompensation;
1396    k.mParameters.autoExposureLock = autoExposureLock;
1397    k.mParameters.autoWhiteBalanceLock = autoWhiteBalanceLock;
1398    k.mParameters.meteringAreas = meteringAreas;
1399    k.mParameters.zoom = zoom;
1400
1401    k.mParameters.videoWidth = videoWidth;
1402    k.mParameters.videoHeight = videoHeight;
1403
1404    k.mParameters.recordingHint = recordingHint;
1405    k.mParameters.videoStabilization = videoStabilization;
1406
1407    res = updatePreviewRequest(k.mParameters);
1408    if (res != OK) {
1409        ALOGE("%s: Camera %d: Unable to update preview request: %s (%d)",
1410                __FUNCTION__, mCameraId, strerror(-res), res);
1411        return res;
1412    }
1413    res = updateCaptureRequest(k.mParameters);
1414    if (res != OK) {
1415        ALOGE("%s: Camera %d: Unable to update capture request: %s (%d)",
1416                __FUNCTION__, mCameraId, strerror(-res), res);
1417        return res;
1418    }
1419
1420    res = updateRecordingRequest(k.mParameters);
1421    if (res != OK) {
1422        ALOGE("%s: Camera %d: Unable to update recording request: %s (%d)",
1423                __FUNCTION__, mCameraId, strerror(-res), res);
1424        return res;
1425    }
1426
1427    if (mState == PREVIEW) {
1428        res = mDevice->setStreamingRequest(mPreviewRequest);
1429        if (res != OK) {
1430            ALOGE("%s: Camera %d: Error streaming new preview request: %s (%d)",
1431                    __FUNCTION__, mCameraId, strerror(-res), res);
1432            return res;
1433        }
1434    } else if (mState == RECORD || mState == VIDEO_SNAPSHOT) {
1435        res = mDevice->setStreamingRequest(mRecordingRequest);
1436        if (res != OK) {
1437            ALOGE("%s: Camera %d: Error streaming new record request: %s (%d)",
1438                    __FUNCTION__, mCameraId, strerror(-res), res);
1439            return res;
1440        }
1441    }
1442
1443    k.mParameters.paramsFlattened = params;
1444
1445    return OK;
1446}
1447
1448String8 Camera2Client::getParameters() const {
1449    ATRACE_CALL();
1450    Mutex::Autolock icl(mICameraLock);
1451
1452    LockedParameters::ReadKey k(mParameters);
1453
1454    // TODO: Deal with focus distances
1455    return k.mParameters.paramsFlattened;
1456}
1457
1458status_t Camera2Client::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) {
1459    ATRACE_CALL();
1460    Mutex::Autolock icl(mICameraLock);
1461
1462    ALOGV("%s: Camera %d: Command %d (%d, %d)", __FUNCTION__, mCameraId,
1463            cmd, arg1, arg2);
1464
1465    if (cmd == CAMERA_CMD_SET_DISPLAY_ORIENTATION) {
1466        LockedParameters::Key k(mParameters);
1467        int transform = degToTransform(arg1,
1468                mCameraFacing == CAMERA_FACING_FRONT);
1469        if (transform == -1) {
1470            ALOGE("%s: Camera %d: Error setting %d as display orientation value",
1471                    __FUNCTION__, mCameraId, arg1);
1472            return BAD_VALUE;
1473        }
1474        if (transform != k.mParameters.previewTransform &&
1475                mPreviewStreamId != NO_STREAM) {
1476            mDevice->setStreamTransform(mPreviewStreamId, transform);
1477        }
1478        k.mParameters.previewTransform = transform;
1479        return OK;
1480    }
1481
1482    ALOGE("%s: Camera %d: Unimplemented command %d (%d, %d)", __FUNCTION__,
1483            mCameraId, cmd, arg1, arg2);
1484
1485    return OK;
1486}
1487
1488/** Device-related methods */
1489
1490void Camera2Client::onCaptureAvailable() {
1491    ATRACE_CALL();
1492    status_t res;
1493    sp<ICameraClient> currentClient;
1494    ALOGV("%s: Camera %d: Still capture available", __FUNCTION__, mCameraId);
1495
1496    CpuConsumer::LockedBuffer imgBuffer;
1497    {
1498        Mutex::Autolock icl(mICameraLock);
1499
1500        // TODO: Signal errors here upstream
1501        if (mState != STILL_CAPTURE && mState != VIDEO_SNAPSHOT) {
1502            ALOGE("%s: Camera %d: Still image produced unexpectedly!",
1503                    __FUNCTION__, mCameraId);
1504            return;
1505        }
1506
1507        res = mCaptureConsumer->lockNextBuffer(&imgBuffer);
1508        if (res != OK) {
1509            ALOGE("%s: Camera %d: Error receiving still image buffer: %s (%d)",
1510                    __FUNCTION__, mCameraId, strerror(-res), res);
1511            return;
1512        }
1513
1514        if (imgBuffer.format != HAL_PIXEL_FORMAT_BLOB) {
1515            ALOGE("%s: Camera %d: Unexpected format for still image: "
1516                    "%x, expected %x", __FUNCTION__, mCameraId,
1517                    imgBuffer.format,
1518                    HAL_PIXEL_FORMAT_BLOB);
1519            mCaptureConsumer->unlockBuffer(imgBuffer);
1520            return;
1521        }
1522
1523        // TODO: Optimize this to avoid memcopy
1524        void* captureMemory = mCaptureHeap->mHeap->getBase();
1525        size_t size = mCaptureHeap->mHeap->getSize();
1526        memcpy(captureMemory, imgBuffer.data, size);
1527
1528        mCaptureConsumer->unlockBuffer(imgBuffer);
1529
1530        currentClient = mCameraClient;
1531        switch (mState) {
1532            case STILL_CAPTURE:
1533                mState = STOPPED;
1534                break;
1535            case VIDEO_SNAPSHOT:
1536                mState = RECORD;
1537                break;
1538            default:
1539                ALOGE("%s: Camera %d: Unexpected state %d", __FUNCTION__,
1540                        mCameraId, mState);
1541                break;
1542        }
1543    }
1544    // Call outside mICameraLock to allow re-entrancy from notification
1545    if (currentClient != 0) {
1546        currentClient->dataCallback(CAMERA_MSG_COMPRESSED_IMAGE,
1547                mCaptureHeap->mBuffers[0], NULL);
1548    }
1549}
1550
1551void Camera2Client::onRecordingFrameAvailable() {
1552    ATRACE_CALL();
1553    status_t res;
1554    sp<ICameraClient> currentClient;
1555    size_t heapIdx = 0;
1556    nsecs_t timestamp;
1557    {
1558        Mutex::Autolock icl(mICameraLock);
1559        // TODO: Signal errors here upstream
1560        bool discardData = false;
1561        if (mState != RECORD && mState != VIDEO_SNAPSHOT) {
1562            ALOGV("%s: Camera %d: Discarding recording image buffers received after "
1563                    "recording done",
1564                    __FUNCTION__, mCameraId);
1565            discardData = true;
1566        }
1567
1568        buffer_handle_t imgBuffer;
1569        res = mRecordingConsumer->getNextBuffer(&imgBuffer, &timestamp);
1570        if (res != OK) {
1571            ALOGE("%s: Camera %d: Error receiving recording buffer: %s (%d)",
1572                    __FUNCTION__, mCameraId, strerror(-res), res);
1573            return;
1574        }
1575
1576        if (discardData) {
1577            mRecordingConsumer->freeBuffer(imgBuffer);
1578            return;
1579        }
1580
1581        if (mRecordingHeap == 0) {
1582            const size_t bufferSize = 4 + sizeof(buffer_handle_t);
1583            ALOGV("%s: Camera %d: Creating recording heap with %d buffers of "
1584                    "size %d bytes", __FUNCTION__, mCameraId,
1585                    kRecordingHeapCount, bufferSize);
1586            if (mRecordingHeap != 0) {
1587                ALOGV("%s: Camera %d: Previous heap has size %d "
1588                        "(new will be %d) bytes", __FUNCTION__, mCameraId,
1589                        mRecordingHeap->mHeap->getSize(),
1590                        bufferSize * kRecordingHeapCount);
1591            }
1592            // Need to allocate memory for heap
1593            mRecordingHeap.clear();
1594
1595            mRecordingHeap = new Camera2Heap(bufferSize, kRecordingHeapCount,
1596                    "Camera2Client::RecordingHeap");
1597            if (mRecordingHeap->mHeap->getSize() == 0) {
1598                ALOGE("%s: Camera %d: Unable to allocate memory for recording",
1599                        __FUNCTION__, mCameraId);
1600                mRecordingConsumer->freeBuffer(imgBuffer);
1601                return;
1602            }
1603            mRecordingHeapHead = 0;
1604            mRecordingHeapFree = kRecordingHeapCount;
1605        }
1606
1607        if ( mRecordingHeapFree == 0) {
1608            ALOGE("%s: Camera %d: No free recording buffers, dropping frame",
1609                    __FUNCTION__, mCameraId);
1610            mRecordingConsumer->freeBuffer(imgBuffer);
1611            return;
1612        }
1613        heapIdx = mRecordingHeapHead;
1614        mRecordingHeapHead = (mRecordingHeapHead + 1) % kRecordingHeapCount;
1615        mRecordingHeapFree--;
1616
1617        ALOGV("%s: Camera %d: Timestamp %lld",
1618                __FUNCTION__, mCameraId, timestamp);
1619
1620        ssize_t offset;
1621        size_t size;
1622        sp<IMemoryHeap> heap =
1623                mRecordingHeap->mBuffers[heapIdx]->getMemory(&offset,
1624                        &size);
1625
1626        uint8_t *data = (uint8_t*)heap->getBase() + offset;
1627        uint32_t type = kMetadataBufferTypeGrallocSource;
1628        memcpy(data, &type, 4);
1629        memcpy(data + 4, &imgBuffer, sizeof(buffer_handle_t));
1630        ALOGV("%s: Camera %d: Sending out buffer_handle_t %p",
1631                __FUNCTION__, mCameraId, imgBuffer);
1632        currentClient = mCameraClient;
1633    }
1634    // Call outside mICameraLock to allow re-entrancy from notification
1635    if (currentClient != 0) {
1636        currentClient->dataCallbackTimestamp(timestamp,
1637                CAMERA_MSG_VIDEO_FRAME,
1638                mRecordingHeap->mBuffers[heapIdx]);
1639    }
1640}
1641
1642camera_metadata_entry_t Camera2Client::staticInfo(uint32_t tag,
1643        size_t minCount, size_t maxCount) {
1644    status_t res;
1645    camera_metadata_entry_t entry;
1646    res = find_camera_metadata_entry(mDevice->info(),
1647            tag,
1648            &entry);
1649    if (CC_UNLIKELY( res != OK )) {
1650        const char* tagSection = get_camera_metadata_section_name(tag);
1651        if (tagSection == NULL) tagSection = "<unknown>";
1652        const char* tagName = get_camera_metadata_tag_name(tag);
1653        if (tagName == NULL) tagName = "<unknown>";
1654
1655        ALOGE("Error finding static metadata entry '%s.%s' (%x): %s (%d)",
1656                tagSection, tagName, tag, strerror(-res), res);
1657        entry.count = 0;
1658        entry.data.u8 = NULL;
1659    } else if (CC_UNLIKELY(
1660            (minCount != 0 && entry.count < minCount) ||
1661            (maxCount != 0 && entry.count > maxCount) ) ) {
1662        const char* tagSection = get_camera_metadata_section_name(tag);
1663        if (tagSection == NULL) tagSection = "<unknown>";
1664        const char* tagName = get_camera_metadata_tag_name(tag);
1665        if (tagName == NULL) tagName = "<unknown>";
1666        ALOGE("Malformed static metadata entry '%s.%s' (%x):"
1667                "Expected between %d and %d values, but got %d values",
1668                tagSection, tagName, tag, minCount, maxCount, entry.count);
1669        entry.count = 0;
1670        entry.data.u8 = NULL;
1671    }
1672
1673    return entry;
1674}
1675
1676/** Utility methods */
1677
1678
1679status_t Camera2Client::buildDefaultParameters() {
1680    ATRACE_CALL();
1681    LockedParameters::Key k(mParameters);
1682
1683    status_t res;
1684    CameraParameters params;
1685
1686    camera_metadata_entry_t availableProcessedSizes =
1687        staticInfo(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES, 2);
1688    if (!availableProcessedSizes.count) return NO_INIT;
1689
1690    // TODO: Pick more intelligently
1691    k.mParameters.previewWidth = availableProcessedSizes.data.i32[0];
1692    k.mParameters.previewHeight = availableProcessedSizes.data.i32[1];
1693    k.mParameters.videoWidth = k.mParameters.previewWidth;
1694    k.mParameters.videoHeight = k.mParameters.previewHeight;
1695
1696    params.setPreviewSize(k.mParameters.previewWidth, k.mParameters.previewHeight);
1697    params.setVideoSize(k.mParameters.videoWidth, k.mParameters.videoHeight);
1698    params.set(CameraParameters::KEY_PREFERRED_PREVIEW_SIZE_FOR_VIDEO,
1699            String8::format("%dx%d",
1700                    k.mParameters.previewWidth, k.mParameters.previewHeight));
1701    {
1702        String8 supportedPreviewSizes;
1703        for (size_t i=0; i < availableProcessedSizes.count; i += 2) {
1704            if (i != 0) supportedPreviewSizes += ",";
1705            supportedPreviewSizes += String8::format("%dx%d",
1706                    availableProcessedSizes.data.i32[i],
1707                    availableProcessedSizes.data.i32[i+1]);
1708        }
1709        params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES,
1710                supportedPreviewSizes);
1711        params.set(CameraParameters::KEY_SUPPORTED_VIDEO_SIZES,
1712                supportedPreviewSizes);
1713    }
1714
1715    camera_metadata_entry_t availableFpsRanges =
1716        staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES, 2);
1717    if (!availableFpsRanges.count) return NO_INIT;
1718
1719    k.mParameters.previewFpsRange[0] = availableFpsRanges.data.i32[0];
1720    k.mParameters.previewFpsRange[1] = availableFpsRanges.data.i32[1];
1721
1722    params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE,
1723            String8::format("%d,%d",
1724                    k.mParameters.previewFpsRange[0],
1725                    k.mParameters.previewFpsRange[1]));
1726
1727    {
1728        String8 supportedPreviewFpsRange;
1729        for (size_t i=0; i < availableFpsRanges.count; i += 2) {
1730            if (i != 0) supportedPreviewFpsRange += ",";
1731            supportedPreviewFpsRange += String8::format("(%d,%d)",
1732                    availableFpsRanges.data.i32[i],
1733                    availableFpsRanges.data.i32[i+1]);
1734        }
1735        params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE,
1736                supportedPreviewFpsRange);
1737    }
1738
1739    k.mParameters.previewFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP;
1740    params.set(CameraParameters::KEY_PREVIEW_FORMAT,
1741            formatEnumToString(k.mParameters.previewFormat)); // NV21
1742
1743    k.mParameters.previewTransform = degToTransform(0,
1744            mCameraFacing == CAMERA_FACING_FRONT);
1745
1746    camera_metadata_entry_t availableFormats =
1747        staticInfo(ANDROID_SCALER_AVAILABLE_FORMATS);
1748
1749    {
1750        String8 supportedPreviewFormats;
1751        bool addComma = false;
1752        for (size_t i=0; i < availableFormats.count; i++) {
1753            if (addComma) supportedPreviewFormats += ",";
1754            addComma = true;
1755            switch (availableFormats.data.i32[i]) {
1756            case HAL_PIXEL_FORMAT_YCbCr_422_SP:
1757                supportedPreviewFormats +=
1758                    CameraParameters::PIXEL_FORMAT_YUV422SP;
1759                break;
1760            case HAL_PIXEL_FORMAT_YCrCb_420_SP:
1761                supportedPreviewFormats +=
1762                    CameraParameters::PIXEL_FORMAT_YUV420SP;
1763                break;
1764            case HAL_PIXEL_FORMAT_YCbCr_422_I:
1765                supportedPreviewFormats +=
1766                    CameraParameters::PIXEL_FORMAT_YUV422I;
1767                break;
1768            case HAL_PIXEL_FORMAT_YV12:
1769                supportedPreviewFormats +=
1770                    CameraParameters::PIXEL_FORMAT_YUV420P;
1771                break;
1772            case HAL_PIXEL_FORMAT_RGB_565:
1773                supportedPreviewFormats +=
1774                    CameraParameters::PIXEL_FORMAT_RGB565;
1775                break;
1776            case HAL_PIXEL_FORMAT_RGBA_8888:
1777                supportedPreviewFormats +=
1778                    CameraParameters::PIXEL_FORMAT_RGBA8888;
1779                break;
1780            // Not advertizing JPEG, RAW_SENSOR, etc, for preview formats
1781            case HAL_PIXEL_FORMAT_RAW_SENSOR:
1782            case HAL_PIXEL_FORMAT_BLOB:
1783                addComma = false;
1784                break;
1785
1786            default:
1787                ALOGW("%s: Camera %d: Unknown preview format: %x",
1788                        __FUNCTION__, mCameraId, availableFormats.data.i32[i]);
1789                addComma = false;
1790                break;
1791            }
1792        }
1793        params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS,
1794                supportedPreviewFormats);
1795    }
1796
1797    // PREVIEW_FRAME_RATE / SUPPORTED_PREVIEW_FRAME_RATES are deprecated, but
1798    // still have to do something sane for them
1799
1800    params.set(CameraParameters::KEY_PREVIEW_FRAME_RATE,
1801            k.mParameters.previewFpsRange[0]);
1802
1803    {
1804        String8 supportedPreviewFrameRates;
1805        for (size_t i=0; i < availableFpsRanges.count; i += 2) {
1806            if (i != 0) supportedPreviewFrameRates += ",";
1807            supportedPreviewFrameRates += String8::format("%d",
1808                    availableFpsRanges.data.i32[i]);
1809        }
1810        params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES,
1811                supportedPreviewFrameRates);
1812    }
1813
1814    camera_metadata_entry_t availableJpegSizes =
1815        staticInfo(ANDROID_SCALER_AVAILABLE_JPEG_SIZES, 2);
1816    if (!availableJpegSizes.count) return NO_INIT;
1817
1818    // TODO: Pick maximum
1819    k.mParameters.pictureWidth = availableJpegSizes.data.i32[0];
1820    k.mParameters.pictureHeight = availableJpegSizes.data.i32[1];
1821
1822    params.setPictureSize(k.mParameters.pictureWidth,
1823            k.mParameters.pictureHeight);
1824
1825    {
1826        String8 supportedPictureSizes;
1827        for (size_t i=0; i < availableJpegSizes.count; i += 2) {
1828            if (i != 0) supportedPictureSizes += ",";
1829            supportedPictureSizes += String8::format("%dx%d",
1830                    availableJpegSizes.data.i32[i],
1831                    availableJpegSizes.data.i32[i+1]);
1832        }
1833        params.set(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES,
1834                supportedPictureSizes);
1835    }
1836
1837    params.setPictureFormat(CameraParameters::PIXEL_FORMAT_JPEG);
1838    params.set(CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS,
1839            CameraParameters::PIXEL_FORMAT_JPEG);
1840
1841    camera_metadata_entry_t availableJpegThumbnailSizes =
1842        staticInfo(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES, 2);
1843    if (!availableJpegThumbnailSizes.count) return NO_INIT;
1844
1845    // TODO: Pick default thumbnail size sensibly
1846    k.mParameters.jpegThumbSize[0] = availableJpegThumbnailSizes.data.i32[0];
1847    k.mParameters.jpegThumbSize[1] = availableJpegThumbnailSizes.data.i32[1];
1848
1849    params.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH,
1850            k.mParameters.jpegThumbSize[0]);
1851    params.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT,
1852            k.mParameters.jpegThumbSize[1]);
1853
1854    {
1855        String8 supportedJpegThumbSizes;
1856        for (size_t i=0; i < availableJpegThumbnailSizes.count; i += 2) {
1857            if (i != 0) supportedJpegThumbSizes += ",";
1858            supportedJpegThumbSizes += String8::format("%dx%d",
1859                    availableJpegThumbnailSizes.data.i32[i],
1860                    availableJpegThumbnailSizes.data.i32[i+1]);
1861        }
1862        params.set(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES,
1863                supportedJpegThumbSizes);
1864    }
1865
1866    k.mParameters.jpegThumbQuality = 90;
1867    params.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY,
1868            k.mParameters.jpegThumbQuality);
1869    k.mParameters.jpegQuality = 90;
1870    params.set(CameraParameters::KEY_JPEG_QUALITY,
1871            k.mParameters.jpegQuality);
1872    k.mParameters.jpegRotation = 0;
1873    params.set(CameraParameters::KEY_ROTATION,
1874            k.mParameters.jpegRotation);
1875
1876    k.mParameters.gpsEnabled = false;
1877    k.mParameters.gpsProcessingMethod = "unknown";
1878    // GPS fields in CameraParameters are not set by implementation
1879
1880    k.mParameters.wbMode = ANDROID_CONTROL_AWB_AUTO;
1881    params.set(CameraParameters::KEY_WHITE_BALANCE,
1882            CameraParameters::WHITE_BALANCE_AUTO);
1883
1884    camera_metadata_entry_t availableWhiteBalanceModes =
1885        staticInfo(ANDROID_CONTROL_AWB_AVAILABLE_MODES);
1886    {
1887        String8 supportedWhiteBalance;
1888        bool addComma = false;
1889        for (size_t i=0; i < availableWhiteBalanceModes.count; i++) {
1890            if (addComma) supportedWhiteBalance += ",";
1891            addComma = true;
1892            switch (availableWhiteBalanceModes.data.u8[i]) {
1893            case ANDROID_CONTROL_AWB_AUTO:
1894                supportedWhiteBalance +=
1895                    CameraParameters::WHITE_BALANCE_AUTO;
1896                break;
1897            case ANDROID_CONTROL_AWB_INCANDESCENT:
1898                supportedWhiteBalance +=
1899                    CameraParameters::WHITE_BALANCE_INCANDESCENT;
1900                break;
1901            case ANDROID_CONTROL_AWB_FLUORESCENT:
1902                supportedWhiteBalance +=
1903                    CameraParameters::WHITE_BALANCE_FLUORESCENT;
1904                break;
1905            case ANDROID_CONTROL_AWB_WARM_FLUORESCENT:
1906                supportedWhiteBalance +=
1907                    CameraParameters::WHITE_BALANCE_WARM_FLUORESCENT;
1908                break;
1909            case ANDROID_CONTROL_AWB_DAYLIGHT:
1910                supportedWhiteBalance +=
1911                    CameraParameters::WHITE_BALANCE_DAYLIGHT;
1912                break;
1913            case ANDROID_CONTROL_AWB_CLOUDY_DAYLIGHT:
1914                supportedWhiteBalance +=
1915                    CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT;
1916                break;
1917            case ANDROID_CONTROL_AWB_TWILIGHT:
1918                supportedWhiteBalance +=
1919                    CameraParameters::WHITE_BALANCE_TWILIGHT;
1920                break;
1921            case ANDROID_CONTROL_AWB_SHADE:
1922                supportedWhiteBalance +=
1923                    CameraParameters::WHITE_BALANCE_SHADE;
1924                break;
1925            // Skipping values not mappable to v1 API
1926            case ANDROID_CONTROL_AWB_OFF:
1927                addComma = false;
1928                break;
1929            default:
1930                ALOGW("%s: Camera %d: Unknown white balance value: %d",
1931                        __FUNCTION__, mCameraId,
1932                        availableWhiteBalanceModes.data.u8[i]);
1933                addComma = false;
1934                break;
1935            }
1936        }
1937        params.set(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE,
1938                supportedWhiteBalance);
1939    }
1940
1941    k.mParameters.effectMode = ANDROID_CONTROL_EFFECT_OFF;
1942    params.set(CameraParameters::KEY_EFFECT,
1943            CameraParameters::EFFECT_NONE);
1944
1945    camera_metadata_entry_t availableEffects =
1946        staticInfo(ANDROID_CONTROL_AVAILABLE_EFFECTS);
1947    if (!availableEffects.count) return NO_INIT;
1948    {
1949        String8 supportedEffects;
1950        bool addComma = false;
1951        for (size_t i=0; i < availableEffects.count; i++) {
1952            if (addComma) supportedEffects += ",";
1953            addComma = true;
1954            switch (availableEffects.data.u8[i]) {
1955                case ANDROID_CONTROL_EFFECT_OFF:
1956                    supportedEffects +=
1957                        CameraParameters::EFFECT_NONE;
1958                    break;
1959                case ANDROID_CONTROL_EFFECT_MONO:
1960                    supportedEffects +=
1961                        CameraParameters::EFFECT_MONO;
1962                    break;
1963                case ANDROID_CONTROL_EFFECT_NEGATIVE:
1964                    supportedEffects +=
1965                        CameraParameters::EFFECT_NEGATIVE;
1966                    break;
1967                case ANDROID_CONTROL_EFFECT_SOLARIZE:
1968                    supportedEffects +=
1969                        CameraParameters::EFFECT_SOLARIZE;
1970                    break;
1971                case ANDROID_CONTROL_EFFECT_SEPIA:
1972                    supportedEffects +=
1973                        CameraParameters::EFFECT_SEPIA;
1974                    break;
1975                case ANDROID_CONTROL_EFFECT_POSTERIZE:
1976                    supportedEffects +=
1977                        CameraParameters::EFFECT_POSTERIZE;
1978                    break;
1979                case ANDROID_CONTROL_EFFECT_WHITEBOARD:
1980                    supportedEffects +=
1981                        CameraParameters::EFFECT_WHITEBOARD;
1982                    break;
1983                case ANDROID_CONTROL_EFFECT_BLACKBOARD:
1984                    supportedEffects +=
1985                        CameraParameters::EFFECT_BLACKBOARD;
1986                    break;
1987                case ANDROID_CONTROL_EFFECT_AQUA:
1988                    supportedEffects +=
1989                        CameraParameters::EFFECT_AQUA;
1990                    break;
1991                default:
1992                    ALOGW("%s: Camera %d: Unknown effect value: %d",
1993                        __FUNCTION__, mCameraId, availableEffects.data.u8[i]);
1994                    addComma = false;
1995                    break;
1996            }
1997        }
1998        params.set(CameraParameters::KEY_SUPPORTED_EFFECTS, supportedEffects);
1999    }
2000
2001    k.mParameters.antibandingMode = ANDROID_CONTROL_AE_ANTIBANDING_AUTO;
2002    params.set(CameraParameters::KEY_ANTIBANDING,
2003            CameraParameters::ANTIBANDING_AUTO);
2004
2005    camera_metadata_entry_t availableAntibandingModes =
2006        staticInfo(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES);
2007    if (!availableAntibandingModes.count) return NO_INIT;
2008    {
2009        String8 supportedAntibanding;
2010        bool addComma = false;
2011        for (size_t i=0; i < availableAntibandingModes.count; i++) {
2012            if (addComma) supportedAntibanding += ",";
2013            addComma = true;
2014            switch (availableAntibandingModes.data.u8[i]) {
2015                case ANDROID_CONTROL_AE_ANTIBANDING_OFF:
2016                    supportedAntibanding +=
2017                        CameraParameters::ANTIBANDING_OFF;
2018                    break;
2019                case ANDROID_CONTROL_AE_ANTIBANDING_50HZ:
2020                    supportedAntibanding +=
2021                        CameraParameters::ANTIBANDING_50HZ;
2022                    break;
2023                case ANDROID_CONTROL_AE_ANTIBANDING_60HZ:
2024                    supportedAntibanding +=
2025                        CameraParameters::ANTIBANDING_60HZ;
2026                    break;
2027                case ANDROID_CONTROL_AE_ANTIBANDING_AUTO:
2028                    supportedAntibanding +=
2029                        CameraParameters::ANTIBANDING_AUTO;
2030                    break;
2031                default:
2032                    ALOGW("%s: Camera %d: Unknown antibanding value: %d",
2033                        __FUNCTION__, mCameraId,
2034                            availableAntibandingModes.data.u8[i]);
2035                    addComma = false;
2036                    break;
2037            }
2038        }
2039        params.set(CameraParameters::KEY_SUPPORTED_ANTIBANDING,
2040                supportedAntibanding);
2041    }
2042
2043    k.mParameters.sceneMode = ANDROID_CONTROL_OFF;
2044    params.set(CameraParameters::KEY_SCENE_MODE,
2045            CameraParameters::SCENE_MODE_AUTO);
2046
2047    camera_metadata_entry_t availableSceneModes =
2048        staticInfo(ANDROID_CONTROL_AVAILABLE_SCENE_MODES);
2049    if (!availableSceneModes.count) return NO_INIT;
2050    {
2051        String8 supportedSceneModes(CameraParameters::SCENE_MODE_AUTO);
2052        bool addComma = true;
2053        bool noSceneModes = false;
2054        for (size_t i=0; i < availableSceneModes.count; i++) {
2055            if (addComma) supportedSceneModes += ",";
2056            addComma = true;
2057            switch (availableSceneModes.data.u8[i]) {
2058                case ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED:
2059                    noSceneModes = true;
2060                    break;
2061                case ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY:
2062                    // Not in old API
2063                    addComma = false;
2064                    break;
2065                case ANDROID_CONTROL_SCENE_MODE_ACTION:
2066                    supportedSceneModes +=
2067                        CameraParameters::SCENE_MODE_ACTION;
2068                    break;
2069                case ANDROID_CONTROL_SCENE_MODE_PORTRAIT:
2070                    supportedSceneModes +=
2071                        CameraParameters::SCENE_MODE_PORTRAIT;
2072                    break;
2073                case ANDROID_CONTROL_SCENE_MODE_LANDSCAPE:
2074                    supportedSceneModes +=
2075                        CameraParameters::SCENE_MODE_LANDSCAPE;
2076                    break;
2077                case ANDROID_CONTROL_SCENE_MODE_NIGHT:
2078                    supportedSceneModes +=
2079                        CameraParameters::SCENE_MODE_NIGHT;
2080                    break;
2081                case ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT:
2082                    supportedSceneModes +=
2083                        CameraParameters::SCENE_MODE_NIGHT_PORTRAIT;
2084                    break;
2085                case ANDROID_CONTROL_SCENE_MODE_THEATRE:
2086                    supportedSceneModes +=
2087                        CameraParameters::SCENE_MODE_THEATRE;
2088                    break;
2089                case ANDROID_CONTROL_SCENE_MODE_BEACH:
2090                    supportedSceneModes +=
2091                        CameraParameters::SCENE_MODE_BEACH;
2092                    break;
2093                case ANDROID_CONTROL_SCENE_MODE_SNOW:
2094                    supportedSceneModes +=
2095                        CameraParameters::SCENE_MODE_SNOW;
2096                    break;
2097                case ANDROID_CONTROL_SCENE_MODE_SUNSET:
2098                    supportedSceneModes +=
2099                        CameraParameters::SCENE_MODE_SUNSET;
2100                    break;
2101                case ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO:
2102                    supportedSceneModes +=
2103                        CameraParameters::SCENE_MODE_STEADYPHOTO;
2104                    break;
2105                case ANDROID_CONTROL_SCENE_MODE_FIREWORKS:
2106                    supportedSceneModes +=
2107                        CameraParameters::SCENE_MODE_FIREWORKS;
2108                    break;
2109                case ANDROID_CONTROL_SCENE_MODE_SPORTS:
2110                    supportedSceneModes +=
2111                        CameraParameters::SCENE_MODE_SPORTS;
2112                    break;
2113                case ANDROID_CONTROL_SCENE_MODE_PARTY:
2114                    supportedSceneModes +=
2115                        CameraParameters::SCENE_MODE_PARTY;
2116                    break;
2117                case ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT:
2118                    supportedSceneModes +=
2119                        CameraParameters::SCENE_MODE_CANDLELIGHT;
2120                    break;
2121                case ANDROID_CONTROL_SCENE_MODE_BARCODE:
2122                    supportedSceneModes +=
2123                        CameraParameters::SCENE_MODE_BARCODE;
2124                    break;
2125                default:
2126                    ALOGW("%s: Camera %d: Unknown scene mode value: %d",
2127                        __FUNCTION__, mCameraId,
2128                            availableSceneModes.data.u8[i]);
2129                    addComma = false;
2130                    break;
2131            }
2132        }
2133        if (!noSceneModes) {
2134            params.set(CameraParameters::KEY_SUPPORTED_SCENE_MODES,
2135                    supportedSceneModes);
2136        }
2137    }
2138
2139    camera_metadata_entry_t flashAvailable =
2140        staticInfo(ANDROID_FLASH_AVAILABLE, 1, 1);
2141    if (!flashAvailable.count) return NO_INIT;
2142
2143    camera_metadata_entry_t availableAeModes =
2144        staticInfo(ANDROID_CONTROL_AE_AVAILABLE_MODES);
2145    if (!availableAeModes.count) return NO_INIT;
2146
2147    if (flashAvailable.data.u8[0]) {
2148        k.mParameters.flashMode = Parameters::FLASH_MODE_AUTO;
2149        params.set(CameraParameters::KEY_FLASH_MODE,
2150                CameraParameters::FLASH_MODE_AUTO);
2151
2152        String8 supportedFlashModes(CameraParameters::FLASH_MODE_OFF);
2153        supportedFlashModes = supportedFlashModes +
2154            "," + CameraParameters::FLASH_MODE_AUTO +
2155            "," + CameraParameters::FLASH_MODE_ON +
2156            "," + CameraParameters::FLASH_MODE_TORCH;
2157        for (size_t i=0; i < availableAeModes.count; i++) {
2158            if (availableAeModes.data.u8[i] ==
2159                    ANDROID_CONTROL_AE_ON_AUTO_FLASH_REDEYE) {
2160                supportedFlashModes = supportedFlashModes + "," +
2161                    CameraParameters::FLASH_MODE_RED_EYE;
2162                break;
2163            }
2164        }
2165        params.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES,
2166                supportedFlashModes);
2167    } else {
2168        k.mParameters.flashMode = Parameters::FLASH_MODE_OFF;
2169        params.set(CameraParameters::KEY_FLASH_MODE,
2170                CameraParameters::FLASH_MODE_OFF);
2171        params.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES,
2172                CameraParameters::FLASH_MODE_OFF);
2173    }
2174
2175    camera_metadata_entry_t minFocusDistance =
2176        staticInfo(ANDROID_LENS_MINIMUM_FOCUS_DISTANCE, 1, 1);
2177    if (!minFocusDistance.count) return NO_INIT;
2178
2179    camera_metadata_entry_t availableAfModes =
2180        staticInfo(ANDROID_CONTROL_AF_AVAILABLE_MODES);
2181    if (!availableAfModes.count) return NO_INIT;
2182
2183    if (minFocusDistance.data.f[0] == 0) {
2184        // Fixed-focus lens
2185        k.mParameters.focusMode = Parameters::FOCUS_MODE_FIXED;
2186        params.set(CameraParameters::KEY_FOCUS_MODE,
2187                CameraParameters::FOCUS_MODE_FIXED);
2188        params.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES,
2189                CameraParameters::FOCUS_MODE_FIXED);
2190    } else {
2191        k.mParameters.focusMode = Parameters::FOCUS_MODE_AUTO;
2192        params.set(CameraParameters::KEY_FOCUS_MODE,
2193                CameraParameters::FOCUS_MODE_AUTO);
2194        String8 supportedFocusModes(CameraParameters::FOCUS_MODE_FIXED);
2195        supportedFocusModes = supportedFocusModes + "," +
2196            CameraParameters::FOCUS_MODE_INFINITY;
2197        bool addComma = true;
2198
2199        for (size_t i=0; i < availableAfModes.count; i++) {
2200            if (addComma) supportedFocusModes += ",";
2201            addComma = true;
2202            switch (availableAfModes.data.u8[i]) {
2203                case ANDROID_CONTROL_AF_AUTO:
2204                    supportedFocusModes +=
2205                        CameraParameters::FOCUS_MODE_AUTO;
2206                    break;
2207                case ANDROID_CONTROL_AF_MACRO:
2208                    supportedFocusModes +=
2209                        CameraParameters::FOCUS_MODE_MACRO;
2210                    break;
2211                case ANDROID_CONTROL_AF_CONTINUOUS_VIDEO:
2212                    supportedFocusModes +=
2213                        CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO;
2214                    break;
2215                case ANDROID_CONTROL_AF_CONTINUOUS_PICTURE:
2216                    supportedFocusModes +=
2217                        CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE;
2218                    break;
2219                case ANDROID_CONTROL_AF_EDOF:
2220                    supportedFocusModes +=
2221                        CameraParameters::FOCUS_MODE_EDOF;
2222                    break;
2223                // Not supported in old API
2224                case ANDROID_CONTROL_AF_OFF:
2225                    addComma = false;
2226                    break;
2227                default:
2228                    ALOGW("%s: Camera %d: Unknown AF mode value: %d",
2229                        __FUNCTION__, mCameraId, availableAfModes.data.u8[i]);
2230                    addComma = false;
2231                    break;
2232            }
2233        }
2234        params.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES,
2235                supportedFocusModes);
2236    }
2237
2238    camera_metadata_entry_t max3aRegions =
2239        staticInfo(ANDROID_CONTROL_MAX_REGIONS, 1, 1);
2240    if (!max3aRegions.count) return NO_INIT;
2241
2242    params.set(CameraParameters::KEY_MAX_NUM_FOCUS_AREAS,
2243            max3aRegions.data.i32[0]);
2244    params.set(CameraParameters::KEY_FOCUS_AREAS,
2245            "(0,0,0,0,0)");
2246    k.mParameters.focusingAreas.clear();
2247    k.mParameters.focusingAreas.add(Parameters::Area(0,0,0,0,0));
2248
2249    camera_metadata_entry_t availableFocalLengths =
2250        staticInfo(ANDROID_LENS_AVAILABLE_FOCAL_LENGTHS);
2251    if (!availableFocalLengths.count) return NO_INIT;
2252
2253    float minFocalLength = availableFocalLengths.data.f[0];
2254    params.setFloat(CameraParameters::KEY_FOCAL_LENGTH, minFocalLength);
2255
2256    camera_metadata_entry_t sensorSize =
2257        staticInfo(ANDROID_SENSOR_PHYSICAL_SIZE, 2, 2);
2258    if (!sensorSize.count) return NO_INIT;
2259
2260    // The fields of view here assume infinity focus, maximum wide angle
2261    float horizFov = 180 / M_PI *
2262            2 * atanf(sensorSize.data.f[0] / (2 * minFocalLength));
2263    float vertFov  = 180 / M_PI *
2264            2 * atanf(sensorSize.data.f[1] / (2 * minFocalLength));
2265    params.setFloat(CameraParameters::KEY_HORIZONTAL_VIEW_ANGLE, horizFov);
2266    params.setFloat(CameraParameters::KEY_VERTICAL_VIEW_ANGLE, vertFov);
2267
2268    k.mParameters.exposureCompensation = 0;
2269    params.set(CameraParameters::KEY_EXPOSURE_COMPENSATION,
2270                k.mParameters.exposureCompensation);
2271
2272    camera_metadata_entry_t exposureCompensationRange =
2273        staticInfo(ANDROID_CONTROL_AE_EXP_COMPENSATION_RANGE, 2, 2);
2274    if (!exposureCompensationRange.count) return NO_INIT;
2275
2276    params.set(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION,
2277            exposureCompensationRange.data.i32[1]);
2278    params.set(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION,
2279            exposureCompensationRange.data.i32[0]);
2280
2281    camera_metadata_entry_t exposureCompensationStep =
2282        staticInfo(ANDROID_CONTROL_AE_EXP_COMPENSATION_STEP, 1, 1);
2283    if (!exposureCompensationStep.count) return NO_INIT;
2284
2285    params.setFloat(CameraParameters::KEY_EXPOSURE_COMPENSATION_STEP,
2286            exposureCompensationStep.data.r[0].numerator /
2287            exposureCompensationStep.data.r[0].denominator);
2288
2289    k.mParameters.autoExposureLock = false;
2290    params.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK,
2291            CameraParameters::FALSE);
2292    params.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED,
2293            CameraParameters::TRUE);
2294
2295    k.mParameters.autoWhiteBalanceLock = false;
2296    params.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK,
2297            CameraParameters::FALSE);
2298    params.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED,
2299            CameraParameters::TRUE);
2300
2301    k.mParameters.meteringAreas.add(Parameters::Area(0, 0, 0, 0, 0));
2302    params.set(CameraParameters::KEY_MAX_NUM_METERING_AREAS,
2303            max3aRegions.data.i32[0]);
2304    params.set(CameraParameters::KEY_METERING_AREAS,
2305            "(0,0,0,0,0)");
2306
2307    k.mParameters.zoom = 0;
2308    params.set(CameraParameters::KEY_ZOOM, k.mParameters.zoom);
2309    params.set(CameraParameters::KEY_MAX_ZOOM, NUM_ZOOM_STEPS - 1);
2310
2311    camera_metadata_entry_t maxDigitalZoom =
2312        staticInfo(ANDROID_SCALER_AVAILABLE_MAX_ZOOM, 1, 1);
2313    if (!maxDigitalZoom.count) return NO_INIT;
2314
2315    {
2316        String8 zoomRatios;
2317        float zoom = 1.f;
2318        float zoomIncrement = (maxDigitalZoom.data.f[0] - zoom) /
2319                (NUM_ZOOM_STEPS-1);
2320        bool addComma = false;
2321        for (size_t i=0; i < NUM_ZOOM_STEPS; i++) {
2322            if (addComma) zoomRatios += ",";
2323            addComma = true;
2324            zoomRatios += String8::format("%d", static_cast<int>(zoom * 100));
2325            zoom += zoomIncrement;
2326        }
2327        params.set(CameraParameters::KEY_ZOOM_RATIOS, zoomRatios);
2328    }
2329
2330    params.set(CameraParameters::KEY_ZOOM_SUPPORTED,
2331            CameraParameters::TRUE);
2332    params.set(CameraParameters::KEY_SMOOTH_ZOOM_SUPPORTED,
2333            CameraParameters::TRUE);
2334
2335    params.set(CameraParameters::KEY_FOCUS_DISTANCES,
2336            "Infinity,Infinity,Infinity");
2337
2338    camera_metadata_entry_t maxFacesDetected =
2339        staticInfo(ANDROID_STATS_MAX_FACE_COUNT, 1, 1);
2340    params.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_HW,
2341            maxFacesDetected.data.i32[0]);
2342    params.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_SW,
2343            0);
2344
2345    params.set(CameraParameters::KEY_VIDEO_FRAME_FORMAT,
2346            CameraParameters::PIXEL_FORMAT_ANDROID_OPAQUE);
2347
2348    params.set(CameraParameters::KEY_RECORDING_HINT,
2349            CameraParameters::FALSE);
2350
2351    params.set(CameraParameters::KEY_VIDEO_SNAPSHOT_SUPPORTED,
2352            CameraParameters::TRUE);
2353
2354    params.set(CameraParameters::KEY_VIDEO_STABILIZATION,
2355            CameraParameters::FALSE);
2356
2357    camera_metadata_entry_t availableVideoStabilizationModes =
2358        staticInfo(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES);
2359    if (!availableVideoStabilizationModes.count) return NO_INIT;
2360
2361    if (availableVideoStabilizationModes.count > 1) {
2362        params.set(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED,
2363                CameraParameters::TRUE);
2364    } else {
2365        params.set(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED,
2366                CameraParameters::FALSE);
2367    }
2368
2369    // Always use metadata mode for recording
2370    k.mParameters.storeMetadataInBuffers = true;
2371
2372    k.mParameters.paramsFlattened = params.flatten();
2373
2374    return OK;
2375}
2376
2377status_t Camera2Client::updatePreviewStream(const Parameters &params) {
2378    ATRACE_CALL();
2379    status_t res;
2380
2381    if (mPreviewStreamId != NO_STREAM) {
2382        // Check if stream parameters have to change
2383        uint32_t currentWidth, currentHeight;
2384        res = mDevice->getStreamInfo(mPreviewStreamId,
2385                &currentWidth, &currentHeight, 0);
2386        if (res != OK) {
2387            ALOGE("%s: Camera %d: Error querying preview stream info: "
2388                    "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
2389            return res;
2390        }
2391        if (currentWidth != (uint32_t)params.previewWidth ||
2392                currentHeight != (uint32_t)params.previewHeight) {
2393            ALOGV("%s: Camera %d: Preview size switch: %d x %d -> %d x %d",
2394                    __FUNCTION__, mCameraId, currentWidth, currentHeight,
2395                    params.previewWidth, params.previewHeight);
2396            res = mDevice->waitUntilDrained();
2397            if (res != OK) {
2398                ALOGE("%s: Camera %d: Error waiting for preview to drain: "
2399                        "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
2400                return res;
2401            }
2402            res = mDevice->deleteStream(mPreviewStreamId);
2403            if (res != OK) {
2404                ALOGE("%s: Camera %d: Unable to delete old output stream "
2405                        "for preview: %s (%d)", __FUNCTION__, mCameraId,
2406                        strerror(-res), res);
2407                return res;
2408            }
2409            mPreviewStreamId = NO_STREAM;
2410        }
2411    }
2412
2413    if (mPreviewStreamId == NO_STREAM) {
2414        res = mDevice->createStream(mPreviewWindow,
2415                params.previewWidth, params.previewHeight,
2416                CAMERA2_HAL_PIXEL_FORMAT_OPAQUE, 0,
2417                &mPreviewStreamId);
2418        if (res != OK) {
2419            ALOGE("%s: Camera %d: Unable to create preview stream: %s (%d)",
2420                    __FUNCTION__, mCameraId, strerror(-res), res);
2421            return res;
2422        }
2423    }
2424
2425    res = mDevice->setStreamTransform(mPreviewStreamId,
2426            params.previewTransform);
2427    if (res != OK) {
2428        ALOGE("%s: Camera %d: Unable to set preview stream transform: "
2429                "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
2430        return res;
2431    }
2432
2433    return OK;
2434}
2435
2436status_t Camera2Client::updatePreviewRequest(const Parameters &params) {
2437    ATRACE_CALL();
2438    status_t res;
2439    if (mPreviewRequest == NULL) {
2440        res = mDevice->createDefaultRequest(CAMERA2_TEMPLATE_PREVIEW,
2441                &mPreviewRequest);
2442        if (res != OK) {
2443            ALOGE("%s: Camera %d: Unable to create default preview request: "
2444                    "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
2445            return res;
2446        }
2447    }
2448
2449    res = updateRequestCommon(mPreviewRequest, params);
2450    if (res != OK) {
2451        ALOGE("%s: Camera %d: Unable to update common entries of preview "
2452                "request: %s (%d)", __FUNCTION__, mCameraId,
2453                strerror(-res), res);
2454        return res;
2455    }
2456
2457    return OK;
2458}
2459
2460status_t Camera2Client::updateCaptureStream(const Parameters &params) {
2461    ATRACE_CALL();
2462    status_t res;
2463    // Find out buffer size for JPEG
2464    camera_metadata_entry_t maxJpegSize =
2465            staticInfo(ANDROID_JPEG_MAX_SIZE);
2466    if (maxJpegSize.count == 0) {
2467        ALOGE("%s: Camera %d: Can't find ANDROID_JPEG_MAX_SIZE!",
2468                __FUNCTION__, mCameraId);
2469        return INVALID_OPERATION;
2470    }
2471
2472    if (mCaptureConsumer == 0) {
2473        // Create CPU buffer queue endpoint
2474        mCaptureConsumer = new CpuConsumer(1);
2475        mCaptureConsumer->setFrameAvailableListener(new CaptureWaiter(this));
2476        mCaptureConsumer->setName(String8("Camera2Client::CaptureConsumer"));
2477        mCaptureWindow = new SurfaceTextureClient(
2478            mCaptureConsumer->getProducerInterface());
2479        // Create memory for API consumption
2480        mCaptureHeap = new Camera2Heap(maxJpegSize.data.i32[0], 1,
2481                                       "Camera2Client::CaptureHeap");
2482        if (mCaptureHeap->mHeap->getSize() == 0) {
2483            ALOGE("%s: Camera %d: Unable to allocate memory for capture",
2484                    __FUNCTION__, mCameraId);
2485            return NO_MEMORY;
2486        }
2487    }
2488
2489    if (mCaptureStreamId != NO_STREAM) {
2490        // Check if stream parameters have to change
2491        uint32_t currentWidth, currentHeight;
2492        res = mDevice->getStreamInfo(mCaptureStreamId,
2493                &currentWidth, &currentHeight, 0);
2494        if (res != OK) {
2495            ALOGE("%s: Camera %d: Error querying capture output stream info: "
2496                    "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
2497            return res;
2498        }
2499        if (currentWidth != (uint32_t)params.pictureWidth ||
2500                currentHeight != (uint32_t)params.pictureHeight) {
2501            res = mDevice->deleteStream(mCaptureStreamId);
2502            if (res != OK) {
2503                ALOGE("%s: Camera %d: Unable to delete old output stream "
2504                        "for capture: %s (%d)", __FUNCTION__, mCameraId,
2505                        strerror(-res), res);
2506                return res;
2507            }
2508            mCaptureStreamId = NO_STREAM;
2509        }
2510    }
2511
2512    if (mCaptureStreamId == NO_STREAM) {
2513        // Create stream for HAL production
2514        res = mDevice->createStream(mCaptureWindow,
2515                params.pictureWidth, params.pictureHeight,
2516                HAL_PIXEL_FORMAT_BLOB, maxJpegSize.data.i32[0],
2517                &mCaptureStreamId);
2518        if (res != OK) {
2519            ALOGE("%s: Camera %d: Can't create output stream for capture: "
2520                    "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
2521            return res;
2522        }
2523
2524    }
2525    return OK;
2526}
2527
2528status_t Camera2Client::updateCaptureRequest(const Parameters &params) {
2529    ATRACE_CALL();
2530    status_t res;
2531    if (mCaptureRequest == NULL) {
2532        res = mDevice->createDefaultRequest(CAMERA2_TEMPLATE_STILL_CAPTURE,
2533                &mCaptureRequest);
2534        if (res != OK) {
2535            ALOGE("%s: Camera %d: Unable to create default still image request:"
2536                    " %s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
2537            return res;
2538        }
2539    }
2540
2541    res = updateRequestCommon(mCaptureRequest, params);
2542    if (res != OK) {
2543        ALOGE("%s: Camera %d: Unable to update common entries of capture "
2544                "request: %s (%d)", __FUNCTION__, mCameraId,
2545                strerror(-res), res);
2546        return res;
2547    }
2548
2549    res = updateEntry(mCaptureRequest,
2550            ANDROID_JPEG_THUMBNAIL_SIZE,
2551            params.jpegThumbSize, 2);
2552    if (res != OK) return res;
2553    res = updateEntry(mCaptureRequest,
2554            ANDROID_JPEG_THUMBNAIL_QUALITY,
2555            &params.jpegThumbQuality, 1);
2556    if (res != OK) return res;
2557    res = updateEntry(mCaptureRequest,
2558            ANDROID_JPEG_QUALITY,
2559            &params.jpegQuality, 1);
2560    if (res != OK) return res;
2561    res = updateEntry(mCaptureRequest,
2562            ANDROID_JPEG_ORIENTATION,
2563            &params.jpegRotation, 1);
2564    if (res != OK) return res;
2565
2566    if (params.gpsEnabled) {
2567        res = updateEntry(mCaptureRequest,
2568                ANDROID_JPEG_GPS_COORDINATES,
2569                params.gpsCoordinates, 3);
2570        if (res != OK) return res;
2571        res = updateEntry(mCaptureRequest,
2572                ANDROID_JPEG_GPS_TIMESTAMP,
2573                &params.gpsTimestamp, 1);
2574        if (res != OK) return res;
2575        res = updateEntry(mCaptureRequest,
2576                ANDROID_JPEG_GPS_PROCESSING_METHOD,
2577                params.gpsProcessingMethod.string(),
2578                params.gpsProcessingMethod.size());
2579        if (res != OK) return res;
2580    } else {
2581        res = deleteEntry(mCaptureRequest,
2582                ANDROID_JPEG_GPS_COORDINATES);
2583        if (res != OK) return res;
2584        res = deleteEntry(mCaptureRequest,
2585                ANDROID_JPEG_GPS_TIMESTAMP);
2586        if (res != OK) return res;
2587        res = deleteEntry(mCaptureRequest,
2588                ANDROID_JPEG_GPS_PROCESSING_METHOD);
2589        if (res != OK) return res;
2590    }
2591
2592    return OK;
2593}
2594
2595status_t Camera2Client::updateRecordingRequest(const Parameters &params) {
2596    ATRACE_CALL();
2597    status_t res;
2598    if (mRecordingRequest == NULL) {
2599        res = mDevice->createDefaultRequest(CAMERA2_TEMPLATE_VIDEO_RECORD,
2600                &mRecordingRequest);
2601        if (res != OK) {
2602            ALOGE("%s: Camera %d: Unable to create default recording request:"
2603                    " %s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
2604            return res;
2605        }
2606    }
2607
2608    res = updateRequestCommon(mRecordingRequest, params);
2609    if (res != OK) {
2610        ALOGE("%s: Camera %d: Unable to update common entries of recording "
2611                "request: %s (%d)", __FUNCTION__, mCameraId,
2612                strerror(-res), res);
2613        return res;
2614    }
2615
2616    return OK;
2617}
2618
2619status_t Camera2Client::updateRecordingStream(const Parameters &params) {
2620    status_t res;
2621
2622    if (mRecordingConsumer == 0) {
2623        // Create CPU buffer queue endpoint
2624        mRecordingConsumer = new MediaConsumer(kRecordingHeapCount);
2625        mRecordingConsumer->setFrameAvailableListener(new RecordingWaiter(this));
2626        mRecordingConsumer->setName(String8("Camera2Client::RecordingConsumer"));
2627        mRecordingWindow = new SurfaceTextureClient(
2628            mRecordingConsumer->getProducerInterface());
2629        // Allocate memory later, since we don't know buffer size until receipt
2630    }
2631
2632    if (mRecordingStreamId != NO_STREAM) {
2633        // Check if stream parameters have to change
2634        uint32_t currentWidth, currentHeight;
2635        res = mDevice->getStreamInfo(mRecordingStreamId,
2636                &currentWidth, &currentHeight, 0);
2637        if (res != OK) {
2638            ALOGE("%s: Camera %d: Error querying recording output stream info: "
2639                    "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
2640            return res;
2641        }
2642        if (currentWidth != (uint32_t)params.videoWidth ||
2643                currentHeight != (uint32_t)params.videoHeight) {
2644            // TODO: Should wait to be sure previous recording has finished
2645            res = mDevice->deleteStream(mRecordingStreamId);
2646            if (res != OK) {
2647                ALOGE("%s: Camera %d: Unable to delete old output stream "
2648                        "for recording: %s (%d)", __FUNCTION__, mCameraId,
2649                        strerror(-res), res);
2650                return res;
2651            }
2652            mRecordingStreamId = NO_STREAM;
2653        }
2654    }
2655
2656    if (mRecordingStreamId == NO_STREAM) {
2657        res = mDevice->createStream(mRecordingWindow,
2658                params.videoWidth, params.videoHeight,
2659                CAMERA2_HAL_PIXEL_FORMAT_OPAQUE, 0, &mRecordingStreamId);
2660        if (res != OK) {
2661            ALOGE("%s: Camera %d: Can't create output stream for recording: "
2662                    "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
2663            return res;
2664        }
2665    }
2666
2667    return OK;
2668}
2669
2670status_t Camera2Client::updateRequestCommon(camera_metadata_t *request,
2671        const Parameters &params) {
2672    ATRACE_CALL();
2673    status_t res;
2674    res = updateEntry(request,
2675            ANDROID_CONTROL_AE_TARGET_FPS_RANGE, params.previewFpsRange, 2);
2676    if (res != OK) return res;
2677
2678    uint8_t wbMode = params.autoWhiteBalanceLock ?
2679            ANDROID_CONTROL_AWB_LOCKED : params.wbMode;
2680    res = updateEntry(request,
2681            ANDROID_CONTROL_AWB_MODE, &wbMode, 1);
2682    if (res != OK) return res;
2683    res = updateEntry(request,
2684            ANDROID_CONTROL_EFFECT_MODE, &params.effectMode, 1);
2685    if (res != OK) return res;
2686    res = updateEntry(request,
2687            ANDROID_CONTROL_AE_ANTIBANDING_MODE,
2688            &params.antibandingMode, 1);
2689    if (res != OK) return res;
2690
2691    uint8_t controlMode =
2692            (params.sceneMode == ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED) ?
2693            ANDROID_CONTROL_AUTO : ANDROID_CONTROL_USE_SCENE_MODE;
2694    res = updateEntry(request,
2695            ANDROID_CONTROL_MODE, &controlMode, 1);
2696    if (res != OK) return res;
2697    if (controlMode == ANDROID_CONTROL_USE_SCENE_MODE) {
2698        res = updateEntry(request,
2699                ANDROID_CONTROL_SCENE_MODE,
2700                &params.sceneMode, 1);
2701        if (res != OK) return res;
2702    }
2703
2704    uint8_t flashMode = ANDROID_FLASH_OFF;
2705    uint8_t aeMode;
2706    switch (params.flashMode) {
2707        case Parameters::FLASH_MODE_OFF:
2708            aeMode = ANDROID_CONTROL_AE_ON; break;
2709        case Parameters::FLASH_MODE_AUTO:
2710            aeMode = ANDROID_CONTROL_AE_ON_AUTO_FLASH; break;
2711        case Parameters::FLASH_MODE_ON:
2712            aeMode = ANDROID_CONTROL_AE_ON_ALWAYS_FLASH; break;
2713        case Parameters::FLASH_MODE_TORCH:
2714            aeMode = ANDROID_CONTROL_AE_ON;
2715            flashMode = ANDROID_FLASH_TORCH;
2716            break;
2717        case Parameters::FLASH_MODE_RED_EYE:
2718            aeMode = ANDROID_CONTROL_AE_ON_AUTO_FLASH_REDEYE; break;
2719        default:
2720            ALOGE("%s: Camera %d: Unknown flash mode %d", __FUNCTION__,
2721                    mCameraId, params.flashMode);
2722            return BAD_VALUE;
2723    }
2724    if (params.autoExposureLock) aeMode = ANDROID_CONTROL_AE_LOCKED;
2725
2726    res = updateEntry(request,
2727            ANDROID_FLASH_MODE, &flashMode, 1);
2728    if (res != OK) return res;
2729    res = updateEntry(request,
2730            ANDROID_CONTROL_AE_MODE, &aeMode, 1);
2731    if (res != OK) return res;
2732
2733    float focusDistance = 0; // infinity focus in diopters
2734    uint8_t focusMode;
2735    switch (params.focusMode) {
2736        case Parameters::FOCUS_MODE_AUTO:
2737        case Parameters::FOCUS_MODE_MACRO:
2738        case Parameters::FOCUS_MODE_CONTINUOUS_VIDEO:
2739        case Parameters::FOCUS_MODE_CONTINUOUS_PICTURE:
2740        case Parameters::FOCUS_MODE_EDOF:
2741            focusMode = params.focusMode;
2742            break;
2743        case Parameters::FOCUS_MODE_INFINITY:
2744        case Parameters::FOCUS_MODE_FIXED:
2745            focusMode = ANDROID_CONTROL_AF_OFF;
2746            break;
2747        default:
2748            ALOGE("%s: Camera %d: Unknown focus mode %d", __FUNCTION__,
2749                    mCameraId, params.focusMode);
2750            return BAD_VALUE;
2751    }
2752    res = updateEntry(request,
2753            ANDROID_LENS_FOCUS_DISTANCE, &focusDistance, 1);
2754    if (res != OK) return res;
2755    res = updateEntry(request,
2756            ANDROID_CONTROL_AF_MODE, &focusMode, 1);
2757    if (res != OK) return res;
2758
2759    size_t focusingAreasSize = params.focusingAreas.size() * 5;
2760    int32_t *focusingAreas = new int32_t[focusingAreasSize];
2761    for (size_t i = 0; i < focusingAreasSize; i += 5) {
2762        focusingAreas[i + 0] = params.focusingAreas[i].left;
2763        focusingAreas[i + 1] = params.focusingAreas[i].top;
2764        focusingAreas[i + 2] = params.focusingAreas[i].right;
2765        focusingAreas[i + 3] = params.focusingAreas[i].bottom;
2766        focusingAreas[i + 4] = params.focusingAreas[i].weight;
2767    }
2768    res = updateEntry(request,
2769            ANDROID_CONTROL_AF_REGIONS, focusingAreas,focusingAreasSize);
2770    if (res != OK) return res;
2771    delete[] focusingAreas;
2772
2773    res = updateEntry(request,
2774            ANDROID_CONTROL_AE_EXP_COMPENSATION,
2775            &params.exposureCompensation, 1);
2776    if (res != OK) return res;
2777
2778    size_t meteringAreasSize = params.meteringAreas.size() * 5;
2779    int32_t *meteringAreas = new int32_t[meteringAreasSize];
2780    for (size_t i = 0; i < meteringAreasSize; i += 5) {
2781        meteringAreas[i + 0] = params.meteringAreas[i].left;
2782        meteringAreas[i + 1] = params.meteringAreas[i].top;
2783        meteringAreas[i + 2] = params.meteringAreas[i].right;
2784        meteringAreas[i + 3] = params.meteringAreas[i].bottom;
2785        meteringAreas[i + 4] = params.meteringAreas[i].weight;
2786    }
2787    res = updateEntry(request,
2788            ANDROID_CONTROL_AE_REGIONS, meteringAreas, meteringAreasSize);
2789    if (res != OK) return res;
2790
2791    res = updateEntry(request,
2792            ANDROID_CONTROL_AWB_REGIONS, meteringAreas, meteringAreasSize);
2793    if (res != OK) return res;
2794    delete[] meteringAreas;
2795
2796    // Need to convert zoom index into a crop rectangle. The rectangle is
2797    // chosen to maximize its area on the sensor
2798
2799    camera_metadata_entry_t maxDigitalZoom =
2800            staticInfo(ANDROID_SCALER_AVAILABLE_MAX_ZOOM);
2801    float zoomIncrement = (maxDigitalZoom.data.f[0] - 1) /
2802            (NUM_ZOOM_STEPS-1);
2803    float zoomRatio = 1 + zoomIncrement * params.zoom;
2804
2805    camera_metadata_entry_t activePixelArraySize =
2806            staticInfo(ANDROID_SENSOR_ACTIVE_ARRAY_SIZE, 2, 2);
2807    int32_t arrayWidth = activePixelArraySize.data.i32[0];
2808    int32_t arrayHeight = activePixelArraySize.data.i32[1];
2809    float zoomLeft, zoomTop, zoomWidth, zoomHeight;
2810    if (params.previewWidth >= params.previewHeight) {
2811        zoomWidth =  arrayWidth / zoomRatio;
2812        zoomHeight = zoomWidth *
2813                params.previewHeight / params.previewWidth;
2814    } else {
2815        zoomHeight = arrayHeight / zoomRatio;
2816        zoomWidth = zoomHeight *
2817                params.previewWidth / params.previewHeight;
2818    }
2819    zoomLeft = (arrayWidth - zoomWidth) / 2;
2820    zoomTop = (arrayHeight - zoomHeight) / 2;
2821
2822    int32_t cropRegion[3] = { zoomLeft, zoomTop, zoomWidth };
2823    res = updateEntry(request,
2824            ANDROID_SCALER_CROP_REGION, cropRegion, 3);
2825    if (res != OK) return res;
2826
2827    // TODO: Decide how to map recordingHint, or whether just to ignore it
2828
2829    uint8_t vstabMode = params.videoStabilization ?
2830            ANDROID_CONTROL_VIDEO_STABILIZATION_ON :
2831            ANDROID_CONTROL_VIDEO_STABILIZATION_OFF;
2832    res = updateEntry(request,
2833            ANDROID_CONTROL_VIDEO_STABILIZATION_MODE,
2834            &vstabMode, 1);
2835    if (res != OK) return res;
2836
2837    return OK;
2838}
2839
2840status_t Camera2Client::updateEntry(camera_metadata_t *buffer,
2841        uint32_t tag, const void *data, size_t data_count) {
2842    camera_metadata_entry_t entry;
2843    status_t res;
2844    res = find_camera_metadata_entry(buffer, tag, &entry);
2845    if (res == NAME_NOT_FOUND) {
2846        res = add_camera_metadata_entry(buffer,
2847                tag, data, data_count);
2848    } else if (res == OK) {
2849        res = update_camera_metadata_entry(buffer,
2850                entry.index, data, data_count, NULL);
2851    }
2852
2853    if (res != OK) {
2854        ALOGE("%s: Unable to update metadata entry %s.%s (%x): %s (%d)",
2855                __FUNCTION__, get_camera_metadata_section_name(tag),
2856                get_camera_metadata_tag_name(tag), tag, strerror(-res), res);
2857    }
2858    return res;
2859}
2860
2861status_t Camera2Client::deleteEntry(camera_metadata_t *buffer, uint32_t tag) {
2862    camera_metadata_entry_t entry;
2863    status_t res;
2864    res = find_camera_metadata_entry(buffer, tag, &entry);
2865    if (res == NAME_NOT_FOUND) {
2866        return OK;
2867    } else if (res != OK) {
2868        ALOGE("%s: Error looking for entry %s.%s (%x): %s %d",
2869                __FUNCTION__,
2870                get_camera_metadata_section_name(tag),
2871                get_camera_metadata_tag_name(tag), tag, strerror(-res), res);
2872        return res;
2873    }
2874    res = delete_camera_metadata_entry(buffer, entry.index);
2875    if (res != OK) {
2876        ALOGE("%s: Error deleting entry %s.%s (%x): %s %d",
2877                __FUNCTION__,
2878                get_camera_metadata_section_name(tag),
2879                get_camera_metadata_tag_name(tag), tag, strerror(-res), res);
2880    }
2881    return res;
2882}
2883
2884int Camera2Client::formatStringToEnum(const char *format) {
2885    return
2886        !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV422SP) ?
2887            HAL_PIXEL_FORMAT_YCbCr_422_SP : // NV16
2888        !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV420SP) ?
2889            HAL_PIXEL_FORMAT_YCrCb_420_SP : // NV21
2890        !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV422I) ?
2891            HAL_PIXEL_FORMAT_YCbCr_422_I :  // YUY2
2892        !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV420P) ?
2893            HAL_PIXEL_FORMAT_YV12 :         // YV12
2894        !strcmp(format, CameraParameters::PIXEL_FORMAT_RGB565) ?
2895            HAL_PIXEL_FORMAT_RGB_565 :      // RGB565
2896        !strcmp(format, CameraParameters::PIXEL_FORMAT_RGBA8888) ?
2897            HAL_PIXEL_FORMAT_RGBA_8888 :    // RGB8888
2898        !strcmp(format, CameraParameters::PIXEL_FORMAT_BAYER_RGGB) ?
2899            HAL_PIXEL_FORMAT_RAW_SENSOR :   // Raw sensor data
2900        -1;
2901}
2902
2903const char* Camera2Client::formatEnumToString(int format) {
2904    const char *fmt;
2905    switch(format) {
2906        case HAL_PIXEL_FORMAT_YCbCr_422_SP: // NV16
2907            fmt = CameraParameters::PIXEL_FORMAT_YUV422SP;
2908            break;
2909        case HAL_PIXEL_FORMAT_YCrCb_420_SP: // NV21
2910            fmt = CameraParameters::PIXEL_FORMAT_YUV420SP;
2911            break;
2912        case HAL_PIXEL_FORMAT_YCbCr_422_I: // YUY2
2913            fmt = CameraParameters::PIXEL_FORMAT_YUV422I;
2914            break;
2915        case HAL_PIXEL_FORMAT_YV12:        // YV12
2916            fmt = CameraParameters::PIXEL_FORMAT_YUV420P;
2917            break;
2918        case HAL_PIXEL_FORMAT_RGB_565:     // RGB565
2919            fmt = CameraParameters::PIXEL_FORMAT_RGB565;
2920            break;
2921        case HAL_PIXEL_FORMAT_RGBA_8888:   // RGBA8888
2922            fmt = CameraParameters::PIXEL_FORMAT_RGBA8888;
2923            break;
2924        case HAL_PIXEL_FORMAT_RAW_SENSOR:
2925            ALOGW("Raw sensor preview format requested.");
2926            fmt = CameraParameters::PIXEL_FORMAT_BAYER_RGGB;
2927            break;
2928        default:
2929            ALOGE("%s: Unknown preview format: %x",
2930                    __FUNCTION__,  format);
2931            fmt = NULL;
2932            break;
2933    }
2934    return fmt;
2935}
2936
2937int Camera2Client::wbModeStringToEnum(const char *wbMode) {
2938    return
2939        !strcmp(wbMode, CameraParameters::WHITE_BALANCE_AUTO) ?
2940            ANDROID_CONTROL_AWB_AUTO :
2941        !strcmp(wbMode, CameraParameters::WHITE_BALANCE_INCANDESCENT) ?
2942            ANDROID_CONTROL_AWB_INCANDESCENT :
2943        !strcmp(wbMode, CameraParameters::WHITE_BALANCE_FLUORESCENT) ?
2944            ANDROID_CONTROL_AWB_FLUORESCENT :
2945        !strcmp(wbMode, CameraParameters::WHITE_BALANCE_WARM_FLUORESCENT) ?
2946            ANDROID_CONTROL_AWB_WARM_FLUORESCENT :
2947        !strcmp(wbMode, CameraParameters::WHITE_BALANCE_DAYLIGHT) ?
2948            ANDROID_CONTROL_AWB_DAYLIGHT :
2949        !strcmp(wbMode, CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT) ?
2950            ANDROID_CONTROL_AWB_CLOUDY_DAYLIGHT :
2951        !strcmp(wbMode, CameraParameters::WHITE_BALANCE_TWILIGHT) ?
2952            ANDROID_CONTROL_AWB_TWILIGHT :
2953        !strcmp(wbMode, CameraParameters::WHITE_BALANCE_SHADE) ?
2954            ANDROID_CONTROL_AWB_SHADE :
2955        -1;
2956}
2957
2958int Camera2Client::effectModeStringToEnum(const char *effectMode) {
2959    return
2960        !strcmp(effectMode, CameraParameters::EFFECT_NONE) ?
2961            ANDROID_CONTROL_EFFECT_OFF :
2962        !strcmp(effectMode, CameraParameters::EFFECT_MONO) ?
2963            ANDROID_CONTROL_EFFECT_MONO :
2964        !strcmp(effectMode, CameraParameters::EFFECT_NEGATIVE) ?
2965            ANDROID_CONTROL_EFFECT_NEGATIVE :
2966        !strcmp(effectMode, CameraParameters::EFFECT_SOLARIZE) ?
2967            ANDROID_CONTROL_EFFECT_SOLARIZE :
2968        !strcmp(effectMode, CameraParameters::EFFECT_SEPIA) ?
2969            ANDROID_CONTROL_EFFECT_SEPIA :
2970        !strcmp(effectMode, CameraParameters::EFFECT_POSTERIZE) ?
2971            ANDROID_CONTROL_EFFECT_POSTERIZE :
2972        !strcmp(effectMode, CameraParameters::EFFECT_WHITEBOARD) ?
2973            ANDROID_CONTROL_EFFECT_WHITEBOARD :
2974        !strcmp(effectMode, CameraParameters::EFFECT_BLACKBOARD) ?
2975            ANDROID_CONTROL_EFFECT_BLACKBOARD :
2976        !strcmp(effectMode, CameraParameters::EFFECT_AQUA) ?
2977            ANDROID_CONTROL_EFFECT_AQUA :
2978        -1;
2979}
2980
2981int Camera2Client::abModeStringToEnum(const char *abMode) {
2982    return
2983        !strcmp(abMode, CameraParameters::ANTIBANDING_AUTO) ?
2984            ANDROID_CONTROL_AE_ANTIBANDING_AUTO :
2985        !strcmp(abMode, CameraParameters::ANTIBANDING_OFF) ?
2986            ANDROID_CONTROL_AE_ANTIBANDING_OFF :
2987        !strcmp(abMode, CameraParameters::ANTIBANDING_50HZ) ?
2988            ANDROID_CONTROL_AE_ANTIBANDING_50HZ :
2989        !strcmp(abMode, CameraParameters::ANTIBANDING_60HZ) ?
2990            ANDROID_CONTROL_AE_ANTIBANDING_60HZ :
2991        -1;
2992}
2993
2994int Camera2Client::sceneModeStringToEnum(const char *sceneMode) {
2995    return
2996        !strcmp(sceneMode, CameraParameters::SCENE_MODE_AUTO) ?
2997            ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED :
2998        !strcmp(sceneMode, CameraParameters::SCENE_MODE_ACTION) ?
2999            ANDROID_CONTROL_SCENE_MODE_ACTION :
3000        !strcmp(sceneMode, CameraParameters::SCENE_MODE_PORTRAIT) ?
3001            ANDROID_CONTROL_SCENE_MODE_PORTRAIT :
3002        !strcmp(sceneMode, CameraParameters::SCENE_MODE_LANDSCAPE) ?
3003            ANDROID_CONTROL_SCENE_MODE_LANDSCAPE :
3004        !strcmp(sceneMode, CameraParameters::SCENE_MODE_NIGHT) ?
3005            ANDROID_CONTROL_SCENE_MODE_NIGHT :
3006        !strcmp(sceneMode, CameraParameters::SCENE_MODE_NIGHT_PORTRAIT) ?
3007            ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT :
3008        !strcmp(sceneMode, CameraParameters::SCENE_MODE_THEATRE) ?
3009            ANDROID_CONTROL_SCENE_MODE_THEATRE :
3010        !strcmp(sceneMode, CameraParameters::SCENE_MODE_BEACH) ?
3011            ANDROID_CONTROL_SCENE_MODE_BEACH :
3012        !strcmp(sceneMode, CameraParameters::SCENE_MODE_SNOW) ?
3013            ANDROID_CONTROL_SCENE_MODE_SNOW :
3014        !strcmp(sceneMode, CameraParameters::SCENE_MODE_SUNSET) ?
3015            ANDROID_CONTROL_SCENE_MODE_SUNSET :
3016        !strcmp(sceneMode, CameraParameters::SCENE_MODE_STEADYPHOTO) ?
3017            ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO :
3018        !strcmp(sceneMode, CameraParameters::SCENE_MODE_FIREWORKS) ?
3019            ANDROID_CONTROL_SCENE_MODE_FIREWORKS :
3020        !strcmp(sceneMode, CameraParameters::SCENE_MODE_SPORTS) ?
3021            ANDROID_CONTROL_SCENE_MODE_SPORTS :
3022        !strcmp(sceneMode, CameraParameters::SCENE_MODE_PARTY) ?
3023            ANDROID_CONTROL_SCENE_MODE_PARTY :
3024        !strcmp(sceneMode, CameraParameters::SCENE_MODE_CANDLELIGHT) ?
3025            ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT :
3026        !strcmp(sceneMode, CameraParameters::SCENE_MODE_BARCODE) ?
3027            ANDROID_CONTROL_SCENE_MODE_BARCODE:
3028        -1;
3029}
3030
3031Camera2Client::Parameters::flashMode_t Camera2Client::flashModeStringToEnum(
3032        const char *flashMode) {
3033    return
3034        !strcmp(flashMode, CameraParameters::FLASH_MODE_OFF) ?
3035            Parameters::FLASH_MODE_OFF :
3036        !strcmp(flashMode, CameraParameters::FLASH_MODE_AUTO) ?
3037            Parameters::FLASH_MODE_AUTO :
3038        !strcmp(flashMode, CameraParameters::FLASH_MODE_ON) ?
3039            Parameters::FLASH_MODE_ON :
3040        !strcmp(flashMode, CameraParameters::FLASH_MODE_RED_EYE) ?
3041            Parameters::FLASH_MODE_RED_EYE :
3042        !strcmp(flashMode, CameraParameters::FLASH_MODE_TORCH) ?
3043            Parameters::FLASH_MODE_TORCH :
3044        Parameters::FLASH_MODE_INVALID;
3045}
3046
3047Camera2Client::Parameters::focusMode_t Camera2Client::focusModeStringToEnum(
3048        const char *focusMode) {
3049    return
3050        !strcmp(focusMode, CameraParameters::FOCUS_MODE_AUTO) ?
3051            Parameters::FOCUS_MODE_AUTO :
3052        !strcmp(focusMode, CameraParameters::FOCUS_MODE_INFINITY) ?
3053            Parameters::FOCUS_MODE_INFINITY :
3054        !strcmp(focusMode, CameraParameters::FOCUS_MODE_MACRO) ?
3055            Parameters::FOCUS_MODE_MACRO :
3056        !strcmp(focusMode, CameraParameters::FOCUS_MODE_FIXED) ?
3057            Parameters::FOCUS_MODE_FIXED :
3058        !strcmp(focusMode, CameraParameters::FOCUS_MODE_EDOF) ?
3059            Parameters::FOCUS_MODE_EDOF :
3060        !strcmp(focusMode, CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO) ?
3061            Parameters::FOCUS_MODE_CONTINUOUS_VIDEO :
3062        !strcmp(focusMode, CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE) ?
3063            Parameters::FOCUS_MODE_CONTINUOUS_PICTURE :
3064        Parameters::FOCUS_MODE_INVALID;
3065}
3066
3067status_t Camera2Client::parseAreas(const char *areasCStr,
3068        Vector<Parameters::Area> *areas) {
3069    static const size_t NUM_FIELDS = 5;
3070    areas->clear();
3071    if (areasCStr == NULL) {
3072        // If no key exists, use default (0,0,0,0,0)
3073        areas->push();
3074        return OK;
3075    }
3076    String8 areasStr(areasCStr);
3077    ssize_t areaStart = areasStr.find("(", 0) + 1;
3078    while (areaStart != 0) {
3079        const char* area = areasStr.string() + areaStart;
3080        char *numEnd;
3081        int vals[NUM_FIELDS];
3082        for (size_t i = 0; i < NUM_FIELDS; i++) {
3083            errno = 0;
3084            vals[i] = strtol(area, &numEnd, 10);
3085            if (errno || numEnd == area) return BAD_VALUE;
3086            area = numEnd + 1;
3087        }
3088        areas->push(Parameters::Area(
3089            vals[0], vals[1], vals[2], vals[3], vals[4]) );
3090        areaStart = areasStr.find("(", areaStart) + 1;
3091    }
3092    return OK;
3093}
3094
3095status_t Camera2Client::validateAreas(const Vector<Parameters::Area> &areas,
3096                                      size_t maxRegions) {
3097    // Definition of valid area can be found in
3098    // include/camera/CameraParameters.h
3099    if (areas.size() == 0) return BAD_VALUE;
3100    if (areas.size() == 1) {
3101        if (areas[0].left == 0 &&
3102                areas[0].top == 0 &&
3103                areas[0].right == 0 &&
3104                areas[0].bottom == 0 &&
3105                areas[0].weight == 0) {
3106            // Single (0,0,0,0,0) entry is always valid (== driver decides)
3107            return OK;
3108        }
3109    }
3110    if (areas.size() > maxRegions) {
3111        ALOGE("%s: Too many areas requested: %d",
3112                __FUNCTION__, areas.size());
3113        return BAD_VALUE;
3114    }
3115
3116    for (Vector<Parameters::Area>::const_iterator a = areas.begin();
3117         a != areas.end(); a++) {
3118        if (a->weight < 1 || a->weight > 1000) return BAD_VALUE;
3119        if (a->left < -1000 || a->left > 1000) return BAD_VALUE;
3120        if (a->top < -1000 || a->top > 1000) return BAD_VALUE;
3121        if (a->right < -1000 || a->right > 1000) return BAD_VALUE;
3122        if (a->bottom < -1000 || a->bottom > 1000) return BAD_VALUE;
3123        if (a->left >= a->right) return BAD_VALUE;
3124        if (a->top >= a->bottom) return BAD_VALUE;
3125    }
3126    return OK;
3127}
3128
3129bool Camera2Client::boolFromString(const char *boolStr) {
3130    return !boolStr ? false :
3131        !strcmp(boolStr, CameraParameters::TRUE) ? true :
3132        false;
3133}
3134
3135int Camera2Client::degToTransform(int degrees, bool mirror) {
3136    if (!mirror) {
3137        if (degrees == 0) return 0;
3138        else if (degrees == 90) return HAL_TRANSFORM_ROT_90;
3139        else if (degrees == 180) return HAL_TRANSFORM_ROT_180;
3140        else if (degrees == 270) return HAL_TRANSFORM_ROT_270;
3141    } else {  // Do mirror (horizontal flip)
3142        if (degrees == 0) {           // FLIP_H and ROT_0
3143            return HAL_TRANSFORM_FLIP_H;
3144        } else if (degrees == 90) {   // FLIP_H and ROT_90
3145            return HAL_TRANSFORM_FLIP_H | HAL_TRANSFORM_ROT_90;
3146        } else if (degrees == 180) {  // FLIP_H and ROT_180
3147            return HAL_TRANSFORM_FLIP_V;
3148        } else if (degrees == 270) {  // FLIP_H and ROT_270
3149            return HAL_TRANSFORM_FLIP_V | HAL_TRANSFORM_ROT_90;
3150        }
3151    }
3152    ALOGE("%s: Bad input: %d", __FUNCTION__, degrees);
3153    return -1;
3154}
3155
3156} // namespace android
3157