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