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