Camera2Client.cpp revision 609acc0c96bc2aedd42246862b537e045f5184b6 
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 "Camera2Client.h"
30
31#define ALOG1(...) ALOGD_IF(gLogLevel >= 1, __VA_ARGS__);
32#define ALOG2(...) ALOGD_IF(gLogLevel >= 2, __VA_ARGS__);
33
34namespace android {
35
36using namespace camera2;
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        mSharedCameraClient(cameraClient),
56        mParameters(cameraId, cameraFacing),
57        mPreviewStreamId(NO_STREAM),
58        mRecordingStreamId(NO_STREAM),
59        mRecordingHeapCount(kDefaultRecordingHeapCount)
60{
61    ATRACE_CALL();
62    ALOGI("Camera %d: Opened", cameraId);
63
64    mDevice = new Camera2Device(cameraId);
65
66    SharedParameters::Lock l(mParameters);
67    l.mParameters.state = Parameters::DISCONNECTED;
68
69    char value[PROPERTY_VALUE_MAX];
70    property_get("camera.zsl_mode", value, "0");
71    if (!strcmp(value,"1")) {
72        ALOGI("Camera %d: Enabling ZSL mode", cameraId);
73        l.mParameters.zslMode = true;
74    } else {
75        l.mParameters.zslMode = false;
76    }
77}
78
79status_t Camera2Client::checkPid(const char* checkLocation) const {
80    int callingPid = getCallingPid();
81    if (callingPid == mClientPid) return NO_ERROR;
82
83    ALOGE("%s: attempt to use a locked camera from a different process"
84            " (old pid %d, new pid %d)", checkLocation, mClientPid, callingPid);
85    return PERMISSION_DENIED;
86}
87
88status_t Camera2Client::initialize(camera_module_t *module)
89{
90    ATRACE_CALL();
91    ALOGV("%s: Initializing client for camera %d", __FUNCTION__, mCameraId);
92    status_t res;
93
94    res = mDevice->initialize(module);
95    if (res != OK) {
96        ALOGE("%s: Camera %d: unable to initialize device: %s (%d)",
97                __FUNCTION__, mCameraId, strerror(-res), res);
98        return NO_INIT;
99    }
100
101    res = mDevice->setNotifyCallback(this);
102
103    SharedParameters::Lock l(mParameters);
104
105    res = l.mParameters.initialize(&(mDevice->info()));
106    if (res != OK) {
107        ALOGE("%s: Camera %d: unable to build defaults: %s (%d)",
108                __FUNCTION__, mCameraId, strerror(-res), res);
109        return NO_INIT;
110    }
111
112    String8 threadName;
113
114    mFrameProcessor = new FrameProcessor(this);
115    threadName = String8::format("Camera2Client[%d]::FrameProcessor",
116            mCameraId);
117    mFrameProcessor->run(threadName.string());
118
119    mCaptureSequencer = new CaptureSequencer(this);
120    threadName = String8::format("Camera2Client[%d]::CaptureSequencer",
121            mCameraId);
122    mCaptureSequencer->run(threadName.string());
123
124    mJpegProcessor = new JpegProcessor(this, mCaptureSequencer);
125    threadName = String8::format("Camera2Client[%d]::JpegProcessor",
126            mCameraId);
127    mJpegProcessor->run(threadName.string());
128
129    mZslProcessor = new ZslProcessor(this, mCaptureSequencer);
130    threadName = String8::format("Camera2Client[%d]::ZslProcessor",
131            mCameraId);
132    mZslProcessor->run(threadName.string());
133
134    mCallbackProcessor = new CallbackProcessor(this);
135    threadName = String8::format("Camera2Client[%d]::CallbackProcessor",
136            mCameraId);
137    mCallbackProcessor->run(threadName.string());
138
139    if (gLogLevel >= 1) {
140        ALOGD("%s: Default parameters converted from camera %d:", __FUNCTION__,
141              mCameraId);
142        ALOGD("%s", l.mParameters.paramsFlattened.string());
143    }
144
145    return OK;
146}
147
148Camera2Client::~Camera2Client() {
149    ATRACE_CALL();
150    ALOGV("Camera %d: Shutting down", mCameraId);
151
152    mDestructionStarted = true;
153
154    // Rewrite mClientPid to allow shutdown by CameraService
155    mClientPid = getCallingPid();
156    disconnect();
157
158    mFrameProcessor->requestExit();
159    ALOGI("Camera %d: Closed", mCameraId);
160}
161
162status_t Camera2Client::dump(int fd, const Vector<String16>& args) {
163    String8 result;
164    result.appendFormat("Client2[%d] (%p) PID: %d, dump:\n",
165            mCameraId,
166            getCameraClient()->asBinder().get(),
167            mClientPid);
168    result.append("  State: ");
169#define CASE_APPEND_ENUM(x) case x: result.append(#x "\n"); break;
170
171    const Parameters& p = mParameters.unsafeAccess();
172
173    result.append(Parameters::getStateName(p.state));
174
175    result.append("\n  Current parameters:\n");
176    result.appendFormat("    Preview size: %d x %d\n",
177            p.previewWidth, p.previewHeight);
178    result.appendFormat("    Preview FPS range: %d - %d\n",
179            p.previewFpsRange[0], p.previewFpsRange[1]);
180    result.appendFormat("    Preview HAL pixel format: 0x%x\n",
181            p.previewFormat);
182    result.appendFormat("    Preview transform: %x\n",
183            p.previewTransform);
184    result.appendFormat("    Picture size: %d x %d\n",
185            p.pictureWidth, p.pictureHeight);
186    result.appendFormat("    Jpeg thumbnail size: %d x %d\n",
187            p.jpegThumbSize[0], p.jpegThumbSize[1]);
188    result.appendFormat("    Jpeg quality: %d, thumbnail quality: %d\n",
189            p.jpegQuality, p.jpegThumbQuality);
190    result.appendFormat("    Jpeg rotation: %d\n", p.jpegRotation);
191    result.appendFormat("    GPS tags %s\n",
192            p.gpsEnabled ? "enabled" : "disabled");
193    if (p.gpsEnabled) {
194        result.appendFormat("    GPS lat x long x alt: %f x %f x %f\n",
195                p.gpsCoordinates[0], p.gpsCoordinates[1],
196                p.gpsCoordinates[2]);
197        result.appendFormat("    GPS timestamp: %lld\n",
198                p.gpsTimestamp);
199        result.appendFormat("    GPS processing method: %s\n",
200                p.gpsProcessingMethod.string());
201    }
202
203    result.append("    White balance mode: ");
204    switch (p.wbMode) {
205        CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_AUTO)
206        CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_INCANDESCENT)
207        CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_FLUORESCENT)
208        CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_WARM_FLUORESCENT)
209        CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_DAYLIGHT)
210        CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_CLOUDY_DAYLIGHT)
211        CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_TWILIGHT)
212        CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_SHADE)
213        default: result.append("UNKNOWN\n");
214    }
215
216    result.append("    Effect mode: ");
217    switch (p.effectMode) {
218        CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_OFF)
219        CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MONO)
220        CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_NEGATIVE)
221        CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_SOLARIZE)
222        CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_SEPIA)
223        CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_POSTERIZE)
224        CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_WHITEBOARD)
225        CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_BLACKBOARD)
226        CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_AQUA)
227        default: result.append("UNKNOWN\n");
228    }
229
230    result.append("    Antibanding mode: ");
231    switch (p.antibandingMode) {
232        CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_AUTO)
233        CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_OFF)
234        CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_50HZ)
235        CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_60HZ)
236        default: result.append("UNKNOWN\n");
237    }
238
239    result.append("    Scene mode: ");
240    switch (p.sceneMode) {
241        case ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED:
242            result.append("AUTO\n"); break;
243        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_ACTION)
244        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_PORTRAIT)
245        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_LANDSCAPE)
246        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_NIGHT)
247        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT)
248        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_THEATRE)
249        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_BEACH)
250        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SNOW)
251        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SUNSET)
252        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO)
253        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_FIREWORKS)
254        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SPORTS)
255        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_PARTY)
256        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT)
257        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_BARCODE)
258        default: result.append("UNKNOWN\n");
259    }
260
261    result.append("    Flash mode: ");
262    switch (p.flashMode) {
263        CASE_APPEND_ENUM(Parameters::FLASH_MODE_OFF)
264        CASE_APPEND_ENUM(Parameters::FLASH_MODE_AUTO)
265        CASE_APPEND_ENUM(Parameters::FLASH_MODE_ON)
266        CASE_APPEND_ENUM(Parameters::FLASH_MODE_TORCH)
267        CASE_APPEND_ENUM(Parameters::FLASH_MODE_RED_EYE)
268        CASE_APPEND_ENUM(Parameters::FLASH_MODE_INVALID)
269        default: result.append("UNKNOWN\n");
270    }
271
272    result.append("    Focus mode: ");
273    switch (p.focusMode) {
274        CASE_APPEND_ENUM(Parameters::FOCUS_MODE_AUTO)
275        CASE_APPEND_ENUM(Parameters::FOCUS_MODE_MACRO)
276        CASE_APPEND_ENUM(Parameters::FOCUS_MODE_CONTINUOUS_VIDEO)
277        CASE_APPEND_ENUM(Parameters::FOCUS_MODE_CONTINUOUS_PICTURE)
278        CASE_APPEND_ENUM(Parameters::FOCUS_MODE_EDOF)
279        CASE_APPEND_ENUM(Parameters::FOCUS_MODE_INFINITY)
280        CASE_APPEND_ENUM(Parameters::FOCUS_MODE_FIXED)
281        CASE_APPEND_ENUM(Parameters::FOCUS_MODE_INVALID)
282        default: result.append("UNKNOWN\n");
283    }
284
285    result.append("    Focusing areas:\n");
286    for (size_t i = 0; i < p.focusingAreas.size(); i++) {
287        result.appendFormat("      [ (%d, %d, %d, %d), weight %d ]\n",
288                p.focusingAreas[i].left,
289                p.focusingAreas[i].top,
290                p.focusingAreas[i].right,
291                p.focusingAreas[i].bottom,
292                p.focusingAreas[i].weight);
293    }
294
295    result.appendFormat("    Exposure compensation index: %d\n",
296            p.exposureCompensation);
297
298    result.appendFormat("    AE lock %s, AWB lock %s\n",
299            p.autoExposureLock ? "enabled" : "disabled",
300            p.autoWhiteBalanceLock ? "enabled" : "disabled" );
301
302    result.appendFormat("    Metering areas:\n");
303    for (size_t i = 0; i < p.meteringAreas.size(); i++) {
304        result.appendFormat("      [ (%d, %d, %d, %d), weight %d ]\n",
305                p.meteringAreas[i].left,
306                p.meteringAreas[i].top,
307                p.meteringAreas[i].right,
308                p.meteringAreas[i].bottom,
309                p.meteringAreas[i].weight);
310    }
311
312    result.appendFormat("    Zoom index: %d\n", p.zoom);
313    result.appendFormat("    Video size: %d x %d\n", p.videoWidth,
314            p.videoHeight);
315
316    result.appendFormat("    Recording hint is %s\n",
317            p.recordingHint ? "set" : "not set");
318
319    result.appendFormat("    Video stabilization is %s\n",
320            p.videoStabilization ? "enabled" : "disabled");
321
322    result.append("  Current streams:\n");
323    result.appendFormat("    Preview stream ID: %d\n",
324            getPreviewStreamId());
325    result.appendFormat("    Capture stream ID: %d\n",
326            getCaptureStreamId());
327    result.appendFormat("    Recording stream ID: %d\n",
328            getRecordingStreamId());
329
330    result.append("  Current requests:\n");
331    if (mPreviewRequest.entryCount() != 0) {
332        result.append("    Preview request:\n");
333        write(fd, result.string(), result.size());
334        mPreviewRequest.dump(fd, 2, 6);
335    } else {
336        result.append("    Preview request: undefined\n");
337        write(fd, result.string(), result.size());
338    }
339
340    if (mRecordingRequest.entryCount() != 0) {
341        result = "    Recording request:\n";
342        write(fd, result.string(), result.size());
343        mRecordingRequest.dump(fd, 2, 6);
344    } else {
345        result = "    Recording request: undefined\n";
346        write(fd, result.string(), result.size());
347    }
348
349    mCaptureSequencer->dump(fd, args);
350
351    mFrameProcessor->dump(fd, args);
352
353    result = "  Device dump:\n";
354    write(fd, result.string(), result.size());
355
356    status_t res = mDevice->dump(fd, args);
357    if (res != OK) {
358        result = String8::format("   Error dumping device: %s (%d)",
359                strerror(-res), res);
360        write(fd, result.string(), result.size());
361    }
362
363#undef CASE_APPEND_ENUM
364    return NO_ERROR;
365}
366
367// ICamera interface
368
369void Camera2Client::disconnect() {
370    ATRACE_CALL();
371    ALOGV("%s: E", __FUNCTION__);
372    Mutex::Autolock icl(mICameraLock);
373    status_t res;
374    if ( (res = checkPid(__FUNCTION__) ) != OK) return;
375
376    if (mDevice == 0) return;
377
378    stopPreviewL();
379
380    if (mPreviewStreamId != NO_STREAM) {
381        mDevice->deleteStream(mPreviewStreamId);
382        mPreviewStreamId = NO_STREAM;
383    }
384
385    mJpegProcessor->deleteStream();
386
387    if (mRecordingStreamId != NO_STREAM) {
388        mDevice->deleteStream(mRecordingStreamId);
389        mRecordingStreamId = NO_STREAM;
390    }
391
392    mCallbackProcessor->deleteStream();
393
394    mDevice.clear();
395    SharedParameters::Lock l(mParameters);
396    l.mParameters.state = Parameters::DISCONNECTED;
397
398    CameraService::Client::disconnect();
399}
400
401status_t Camera2Client::connect(const sp<ICameraClient>& client) {
402    ATRACE_CALL();
403    ALOGV("%s: E", __FUNCTION__);
404    Mutex::Autolock icl(mICameraLock);
405
406    if (mClientPid != 0 && getCallingPid() != mClientPid) {
407        ALOGE("%s: Camera %d: Connection attempt from pid %d; "
408                "current locked to pid %d", __FUNCTION__,
409                mCameraId, getCallingPid(), mClientPid);
410        return BAD_VALUE;
411    }
412
413    mClientPid = getCallingPid();
414
415    mCameraClient = client;
416    mSharedCameraClient = client;
417
418    SharedParameters::Lock l(mParameters);
419    l.mParameters.state = Parameters::STOPPED;
420
421    return OK;
422}
423
424status_t Camera2Client::lock() {
425    ATRACE_CALL();
426    ALOGV("%s: E", __FUNCTION__);
427    Mutex::Autolock icl(mICameraLock);
428    ALOGV("%s: Camera %d: Lock call from pid %d; current client pid %d",
429            __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
430
431    if (mClientPid == 0) {
432        mClientPid = getCallingPid();
433        return OK;
434    }
435
436    if (mClientPid != getCallingPid()) {
437        ALOGE("%s: Camera %d: Lock call from pid %d; currently locked to pid %d",
438                __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
439        return EBUSY;
440    }
441
442    return OK;
443}
444
445status_t Camera2Client::unlock() {
446    ATRACE_CALL();
447    ALOGV("%s: E", __FUNCTION__);
448    Mutex::Autolock icl(mICameraLock);
449    ALOGV("%s: Camera %d: Unlock call from pid %d; current client pid %d",
450            __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
451
452    // TODO: Check for uninterruptable conditions
453
454    if (mClientPid == getCallingPid()) {
455        mClientPid = 0;
456        mCameraClient.clear();
457        mSharedCameraClient.clear();
458        return OK;
459    }
460
461    ALOGE("%s: Camera %d: Unlock call from pid %d; currently locked to pid %d",
462            __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
463    return EBUSY;
464}
465
466status_t Camera2Client::setPreviewDisplay(
467        const sp<Surface>& surface) {
468    ATRACE_CALL();
469    ALOGV("%s: E", __FUNCTION__);
470    Mutex::Autolock icl(mICameraLock);
471    status_t res;
472    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
473
474    sp<IBinder> binder;
475    sp<ANativeWindow> window;
476    if (surface != 0) {
477        binder = surface->asBinder();
478        window = surface;
479    }
480
481    return setPreviewWindowL(binder,window);
482}
483
484status_t Camera2Client::setPreviewTexture(
485        const sp<ISurfaceTexture>& surfaceTexture) {
486    ATRACE_CALL();
487    ALOGV("%s: E", __FUNCTION__);
488    Mutex::Autolock icl(mICameraLock);
489    status_t res;
490    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
491
492    sp<IBinder> binder;
493    sp<ANativeWindow> window;
494    if (surfaceTexture != 0) {
495        binder = surfaceTexture->asBinder();
496        window = new SurfaceTextureClient(surfaceTexture);
497    }
498    return setPreviewWindowL(binder, window);
499}
500
501status_t Camera2Client::setPreviewWindowL(const sp<IBinder>& binder,
502        sp<ANativeWindow> window) {
503    ATRACE_CALL();
504    status_t res;
505
506    if (binder == mPreviewSurface) {
507        ALOGV("%s: Camera %d: New window is same as old window",
508                __FUNCTION__, mCameraId);
509        return NO_ERROR;
510    }
511
512    SharedParameters::Lock l(mParameters);
513    switch (l.mParameters.state) {
514        case Parameters::DISCONNECTED:
515        case Parameters::RECORD:
516        case Parameters::STILL_CAPTURE:
517        case Parameters::VIDEO_SNAPSHOT:
518            ALOGE("%s: Camera %d: Cannot set preview display while in state %s",
519                    __FUNCTION__, mCameraId,
520                    Parameters::getStateName(l.mParameters.state));
521            return INVALID_OPERATION;
522        case Parameters::STOPPED:
523        case Parameters::WAITING_FOR_PREVIEW_WINDOW:
524            // OK
525            break;
526        case Parameters::PREVIEW:
527            // Already running preview - need to stop and create a new stream
528            // TODO: Optimize this so that we don't wait for old stream to drain
529            // before spinning up new stream
530            mDevice->clearStreamingRequest();
531            l.mParameters.state = Parameters::WAITING_FOR_PREVIEW_WINDOW;
532            break;
533    }
534
535    if (mPreviewStreamId != NO_STREAM) {
536        res = mDevice->waitUntilDrained();
537        if (res != OK) {
538            ALOGE("%s: Error waiting for preview to drain: %s (%d)",
539                    __FUNCTION__, strerror(-res), res);
540            return res;
541        }
542        res = mDevice->deleteStream(mPreviewStreamId);
543        if (res != OK) {
544            ALOGE("%s: Unable to delete old preview stream: %s (%d)",
545                    __FUNCTION__, strerror(-res), res);
546            return res;
547        }
548        mPreviewStreamId = NO_STREAM;
549    }
550
551    mPreviewSurface = binder;
552    mPreviewWindow = window;
553
554    if (l.mParameters.state == Parameters::WAITING_FOR_PREVIEW_WINDOW) {
555        return startPreviewL(l.mParameters, false);
556    }
557
558    return OK;
559}
560
561void Camera2Client::setPreviewCallbackFlag(int flag) {
562    ATRACE_CALL();
563    ALOGV("%s: Camera %d: Flag 0x%x", __FUNCTION__, mCameraId, flag);
564    Mutex::Autolock icl(mICameraLock);
565    status_t res;
566    if ( checkPid(__FUNCTION__) != OK) return;
567
568    SharedParameters::Lock l(mParameters);
569    setPreviewCallbackFlagL(l.mParameters, flag);
570}
571
572void Camera2Client::setPreviewCallbackFlagL(Parameters &params, int flag) {
573    status_t res = OK;
574    if (flag & CAMERA_FRAME_CALLBACK_FLAG_ONE_SHOT_MASK) {
575        ALOGV("%s: setting oneshot", __FUNCTION__);
576        params.previewCallbackOneShot = true;
577    }
578    if (params.previewCallbackFlags != (uint32_t)flag) {
579        params.previewCallbackFlags = flag;
580        switch(params.state) {
581        case Parameters::PREVIEW:
582            res = startPreviewL(params, true);
583            break;
584        case Parameters::RECORD:
585        case Parameters::VIDEO_SNAPSHOT:
586            res = startRecordingL(params, true);
587            break;
588        default:
589            break;
590        }
591        if (res != OK) {
592            ALOGE("%s: Camera %d: Unable to refresh request in state %s",
593                    __FUNCTION__, mCameraId,
594                    Parameters::getStateName(params.state));
595        }
596    }
597
598}
599
600status_t Camera2Client::startPreview() {
601    ATRACE_CALL();
602    ALOGV("%s: E", __FUNCTION__);
603    Mutex::Autolock icl(mICameraLock);
604    status_t res;
605    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
606    SharedParameters::Lock l(mParameters);
607    return startPreviewL(l.mParameters, false);
608}
609
610status_t Camera2Client::startPreviewL(Parameters &params, bool restart) {
611    ATRACE_CALL();
612    status_t res;
613    if (params.state >= Parameters::PREVIEW && !restart) {
614        ALOGE("%s: Can't start preview in state %s",
615                __FUNCTION__,
616                Parameters::getStateName(params.state));
617        return INVALID_OPERATION;
618    }
619
620    if (mPreviewWindow == 0) {
621        params.state = Parameters::WAITING_FOR_PREVIEW_WINDOW;
622        return OK;
623    }
624    params.state = Parameters::STOPPED;
625
626    res = updatePreviewStream(params);
627    if (res != OK) {
628        ALOGE("%s: Camera %d: Unable to update preview stream: %s (%d)",
629                __FUNCTION__, mCameraId, strerror(-res), res);
630        return res;
631    }
632    bool callbacksEnabled = params.previewCallbackFlags &
633        CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK;
634    if (callbacksEnabled) {
635        res = mCallbackProcessor->updateStream(params);
636        if (res != OK) {
637            ALOGE("%s: Camera %d: Unable to update callback stream: %s (%d)",
638                    __FUNCTION__, mCameraId, strerror(-res), res);
639            return res;
640        }
641    }
642    if (params.zslMode) {
643        res = mZslProcessor->updateStream(params);
644        if (res != OK) {
645            ALOGE("%s: Camera %d: Unable to update ZSL stream: %s (%d)",
646                    __FUNCTION__, mCameraId, strerror(-res), res);
647            return res;
648        }
649    }
650
651    if (mPreviewRequest.entryCount() == 0) {
652        res = updatePreviewRequest(params);
653        if (res != OK) {
654            ALOGE("%s: Camera %d: Unable to create preview request: %s (%d)",
655                    __FUNCTION__, mCameraId, strerror(-res), res);
656            return res;
657        }
658    }
659
660    Vector<uint8_t> outputStreams;
661    outputStreams.push(getPreviewStreamId());
662
663    if (callbacksEnabled) {
664        outputStreams.push(getCallbackStreamId());
665    }
666    if (params.zslMode) {
667        outputStreams.push(getZslStreamId());
668    }
669
670    res = mPreviewRequest.update(
671        ANDROID_REQUEST_OUTPUT_STREAMS,
672        outputStreams);
673
674    if (res != OK) {
675        ALOGE("%s: Camera %d: Unable to set up preview request: %s (%d)",
676                __FUNCTION__, mCameraId, strerror(-res), res);
677        return res;
678    }
679    res = mPreviewRequest.sort();
680    if (res != OK) {
681        ALOGE("%s: Camera %d: Error sorting preview request: %s (%d)",
682                __FUNCTION__, mCameraId, strerror(-res), res);
683        return res;
684    }
685
686    res = mDevice->setStreamingRequest(mPreviewRequest);
687    if (res != OK) {
688        ALOGE("%s: Camera %d: Unable to set preview request to start preview: "
689                "%s (%d)",
690                __FUNCTION__, mCameraId, strerror(-res), res);
691        return res;
692    }
693    params.state = Parameters::PREVIEW;
694
695    return OK;
696}
697
698void Camera2Client::stopPreview() {
699    ATRACE_CALL();
700    ALOGV("%s: E", __FUNCTION__);
701    Mutex::Autolock icl(mICameraLock);
702    status_t res;
703    if ( (res = checkPid(__FUNCTION__) ) != OK) return;
704    stopPreviewL();
705}
706
707void Camera2Client::stopPreviewL() {
708    ATRACE_CALL();
709    Parameters::State state;
710    {
711        SharedParameters::Lock l(mParameters);
712        state = l.mParameters.state;
713    }
714
715    switch (state) {
716        case Parameters::DISCONNECTED:
717            ALOGE("%s: Camera %d: Call before initialized",
718                    __FUNCTION__, mCameraId);
719            break;
720        case Parameters::STOPPED:
721            break;
722        case Parameters::STILL_CAPTURE:
723            ALOGE("%s: Camera %d: Cannot stop preview during still capture.",
724                    __FUNCTION__, mCameraId);
725            break;
726        case Parameters::RECORD:
727            // no break - identical to preview
728        case Parameters::PREVIEW:
729            mDevice->clearStreamingRequest();
730            mDevice->waitUntilDrained();
731            // no break
732        case Parameters::WAITING_FOR_PREVIEW_WINDOW: {
733            SharedParameters::Lock l(mParameters);
734            l.mParameters.state = Parameters::STOPPED;
735            commandStopFaceDetectionL(l.mParameters);
736            break;
737        }
738        default:
739            ALOGE("%s: Camera %d: Unknown state %d", __FUNCTION__, mCameraId,
740                    state);
741    }
742}
743
744bool Camera2Client::previewEnabled() {
745    ATRACE_CALL();
746    Mutex::Autolock icl(mICameraLock);
747    status_t res;
748    if ( (res = checkPid(__FUNCTION__) ) != OK) return false;
749
750    SharedParameters::Lock l(mParameters);
751    return l.mParameters.state == Parameters::PREVIEW;
752}
753
754status_t Camera2Client::storeMetaDataInBuffers(bool enabled) {
755    ATRACE_CALL();
756    Mutex::Autolock icl(mICameraLock);
757    status_t res;
758    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
759
760    SharedParameters::Lock l(mParameters);
761    switch (l.mParameters.state) {
762        case Parameters::RECORD:
763        case Parameters::VIDEO_SNAPSHOT:
764            ALOGE("%s: Camera %d: Can't be called in state %s",
765                    __FUNCTION__, mCameraId,
766                    Parameters::getStateName(l.mParameters.state));
767            return INVALID_OPERATION;
768        default:
769            // OK
770            break;
771    }
772
773    l.mParameters.storeMetadataInBuffers = enabled;
774
775    return OK;
776}
777
778status_t Camera2Client::startRecording() {
779    ATRACE_CALL();
780    ALOGV("%s: E", __FUNCTION__);
781    Mutex::Autolock icl(mICameraLock);
782    status_t res;
783    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
784    SharedParameters::Lock l(mParameters);
785
786    return startRecordingL(l.mParameters, false);
787}
788
789status_t Camera2Client::startRecordingL(Parameters &params, bool restart) {
790    status_t res;
791    switch (params.state) {
792        case Parameters::STOPPED:
793            res = startPreviewL(params, false);
794            if (res != OK) return res;
795            break;
796        case Parameters::PREVIEW:
797            // Ready to go
798            break;
799        case Parameters::RECORD:
800        case Parameters::VIDEO_SNAPSHOT:
801            // OK to call this when recording is already on, just skip unless
802            // we're looking to restart
803            if (!restart) return OK;
804            break;
805        default:
806            ALOGE("%s: Camera %d: Can't start recording in state %s",
807                    __FUNCTION__, mCameraId,
808                    Parameters::getStateName(params.state));
809            return INVALID_OPERATION;
810    };
811
812    if (!params.storeMetadataInBuffers) {
813        ALOGE("%s: Camera %d: Recording only supported in metadata mode, but "
814                "non-metadata recording mode requested!", __FUNCTION__,
815                mCameraId);
816        return INVALID_OPERATION;
817    }
818
819    mCameraService->playSound(CameraService::SOUND_RECORDING);
820
821    res = updateRecordingStream(params);
822    if (res != OK) {
823        ALOGE("%s: Camera %d: Unable to update recording stream: %s (%d)",
824                __FUNCTION__, mCameraId, strerror(-res), res);
825        return res;
826    }
827    bool callbacksEnabled = params.previewCallbackFlags &
828        CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK;
829    if (callbacksEnabled) {
830        res = mCallbackProcessor->updateStream(params);
831        if (res != OK) {
832            ALOGE("%s: Camera %d: Unable to update callback stream: %s (%d)",
833                    __FUNCTION__, mCameraId, strerror(-res), res);
834            return res;
835        }
836    }
837
838    if (mRecordingRequest.entryCount() == 0) {
839        res = updateRecordingRequest(params);
840        if (res != OK) {
841            ALOGE("%s: Camera %d: Unable to create recording request: %s (%d)",
842                    __FUNCTION__, mCameraId, strerror(-res), res);
843            return res;
844        }
845    }
846
847    if (callbacksEnabled) {
848        uint8_t outputStreams[3] ={
849            getPreviewStreamId(),
850            getRecordingStreamId(),
851            getCallbackStreamId()
852        };
853        res = mRecordingRequest.update(
854                ANDROID_REQUEST_OUTPUT_STREAMS,
855                outputStreams, 3);
856    } else {
857        uint8_t outputStreams[2] = {
858            getPreviewStreamId(),
859            getRecordingStreamId()
860        };
861        res = mRecordingRequest.update(
862                ANDROID_REQUEST_OUTPUT_STREAMS,
863                outputStreams, 2);
864    }
865    if (res != OK) {
866        ALOGE("%s: Camera %d: Unable to set up recording request: %s (%d)",
867                __FUNCTION__, mCameraId, strerror(-res), res);
868        return res;
869    }
870    res = mRecordingRequest.sort();
871    if (res != OK) {
872        ALOGE("%s: Camera %d: Error sorting recording request: %s (%d)",
873                __FUNCTION__, mCameraId, strerror(-res), res);
874        return res;
875    }
876
877    res = mDevice->setStreamingRequest(mRecordingRequest);
878    if (res != OK) {
879        ALOGE("%s: Camera %d: Unable to set recording request to start "
880                "recording: %s (%d)", __FUNCTION__, mCameraId,
881                strerror(-res), res);
882        return res;
883    }
884    if (params.state < Parameters::RECORD) {
885        params.state = Parameters::RECORD;
886    }
887
888    return OK;
889}
890
891void Camera2Client::stopRecording() {
892    ATRACE_CALL();
893    ALOGV("%s: E", __FUNCTION__);
894    Mutex::Autolock icl(mICameraLock);
895    SharedParameters::Lock l(mParameters);
896
897    status_t res;
898    if ( (res = checkPid(__FUNCTION__) ) != OK) return;
899
900    switch (l.mParameters.state) {
901        case Parameters::RECORD:
902            // OK to stop
903            break;
904        case Parameters::STOPPED:
905        case Parameters::PREVIEW:
906        case Parameters::STILL_CAPTURE:
907        case Parameters::VIDEO_SNAPSHOT:
908        default:
909            ALOGE("%s: Camera %d: Can't stop recording in state %s",
910                    __FUNCTION__, mCameraId,
911                    Parameters::getStateName(l.mParameters.state));
912            return;
913    };
914
915    mCameraService->playSound(CameraService::SOUND_RECORDING);
916
917    // Back to preview. Since record can only be reached through preview,
918    // all preview stream setup should be up to date.
919    res = mDevice->setStreamingRequest(mPreviewRequest);
920    if (res != OK) {
921        ALOGE("%s: Camera %d: Unable to switch back to preview request: "
922                "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
923        return;
924    }
925
926    // TODO: Should recording heap be freed? Can't do it yet since requests
927    // could still be in flight.
928
929    l.mParameters.state = Parameters::PREVIEW;
930}
931
932bool Camera2Client::recordingEnabled() {
933    ATRACE_CALL();
934    Mutex::Autolock icl(mICameraLock);
935
936    if ( checkPid(__FUNCTION__) != OK) return false;
937
938    return recordingEnabledL();
939}
940
941bool Camera2Client::recordingEnabledL() {
942    ATRACE_CALL();
943    SharedParameters::Lock l(mParameters);
944
945    return (l.mParameters.state == Parameters::RECORD
946            || l.mParameters.state == Parameters::VIDEO_SNAPSHOT);
947}
948
949void Camera2Client::releaseRecordingFrame(const sp<IMemory>& mem) {
950    ATRACE_CALL();
951    Mutex::Autolock icl(mICameraLock);
952    status_t res;
953    if ( checkPid(__FUNCTION__) != OK) return;
954
955    SharedParameters::Lock l(mParameters);
956
957    // Make sure this is for the current heap
958    ssize_t offset;
959    size_t size;
960    sp<IMemoryHeap> heap = mem->getMemory(&offset, &size);
961    if (heap->getHeapID() != mRecordingHeap->mHeap->getHeapID()) {
962        ALOGW("%s: Camera %d: Mismatched heap ID, ignoring release "
963                "(got %x, expected %x)", __FUNCTION__, mCameraId,
964                heap->getHeapID(), mRecordingHeap->mHeap->getHeapID());
965        return;
966    }
967    uint8_t *data = (uint8_t*)heap->getBase() + offset;
968    uint32_t type = *(uint32_t*)data;
969    if (type != kMetadataBufferTypeGrallocSource) {
970        ALOGE("%s: Camera %d: Recording frame type invalid (got %x, expected %x)",
971                __FUNCTION__, mCameraId, type, kMetadataBufferTypeGrallocSource);
972        return;
973    }
974
975    // Release the buffer back to the recording queue
976
977    buffer_handle_t imgHandle = *(buffer_handle_t*)(data + 4);
978
979    size_t itemIndex;
980    for (itemIndex = 0; itemIndex < mRecordingBuffers.size(); itemIndex++) {
981        const BufferItemConsumer::BufferItem item = mRecordingBuffers[itemIndex];
982        if (item.mBuf != BufferItemConsumer::INVALID_BUFFER_SLOT &&
983                item.mGraphicBuffer->handle == imgHandle) {
984            break;
985        }
986    }
987    if (itemIndex == mRecordingBuffers.size()) {
988        ALOGE("%s: Camera %d: Can't find buffer_handle_t %p in list of "
989                "outstanding buffers", __FUNCTION__, mCameraId, imgHandle);
990        return;
991    }
992
993    ALOGV("%s: Camera %d: Freeing buffer_handle_t %p", __FUNCTION__, mCameraId,
994            imgHandle);
995
996    res = mRecordingConsumer->releaseBuffer(mRecordingBuffers[itemIndex]);
997    if (res != OK) {
998        ALOGE("%s: Camera %d: Unable to free recording frame (buffer_handle_t: %p):"
999                "%s (%d)",
1000                __FUNCTION__, mCameraId, imgHandle, strerror(-res), res);
1001        return;
1002    }
1003    mRecordingBuffers.replaceAt(itemIndex);
1004
1005    mRecordingHeapFree++;
1006}
1007
1008status_t Camera2Client::autoFocus() {
1009    ATRACE_CALL();
1010    Mutex::Autolock icl(mICameraLock);
1011    status_t res;
1012    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1013
1014    int triggerId;
1015    {
1016        SharedParameters::Lock l(mParameters);
1017        l.mParameters.currentAfTriggerId = ++l.mParameters.afTriggerCounter;
1018        triggerId = l.mParameters.currentAfTriggerId;
1019    }
1020
1021    mDevice->triggerAutofocus(triggerId);
1022
1023    return OK;
1024}
1025
1026status_t Camera2Client::cancelAutoFocus() {
1027    ATRACE_CALL();
1028    Mutex::Autolock icl(mICameraLock);
1029    status_t res;
1030    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1031
1032    int triggerId;
1033    {
1034        SharedParameters::Lock l(mParameters);
1035        triggerId = ++l.mParameters.afTriggerCounter;
1036    }
1037
1038    mDevice->triggerCancelAutofocus(triggerId);
1039
1040    return OK;
1041}
1042
1043status_t Camera2Client::takePicture(int msgType) {
1044    ATRACE_CALL();
1045    Mutex::Autolock icl(mICameraLock);
1046    status_t res;
1047    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1048
1049    SharedParameters::Lock l(mParameters);
1050    switch (l.mParameters.state) {
1051        case Parameters::DISCONNECTED:
1052        case Parameters::STOPPED:
1053        case Parameters::WAITING_FOR_PREVIEW_WINDOW:
1054            ALOGE("%s: Camera %d: Cannot take picture without preview enabled",
1055                    __FUNCTION__, mCameraId);
1056            return INVALID_OPERATION;
1057        case Parameters::PREVIEW:
1058            // Good to go for takePicture
1059            res = commandStopFaceDetectionL(l.mParameters);
1060            if (res != OK) {
1061                ALOGE("%s: Camera %d: Unable to stop face detection for still capture",
1062                        __FUNCTION__, mCameraId);
1063                return res;
1064            }
1065            l.mParameters.state = Parameters::STILL_CAPTURE;
1066            break;
1067        case Parameters::RECORD:
1068            // Good to go for video snapshot
1069            l.mParameters.state = Parameters::VIDEO_SNAPSHOT;
1070            break;
1071        case Parameters::STILL_CAPTURE:
1072        case Parameters::VIDEO_SNAPSHOT:
1073            ALOGE("%s: Camera %d: Already taking a picture",
1074                    __FUNCTION__, mCameraId);
1075            return INVALID_OPERATION;
1076    }
1077
1078    ALOGV("%s: Camera %d: Starting picture capture", __FUNCTION__, mCameraId);
1079
1080    res = mJpegProcessor->updateStream(l.mParameters);
1081    if (res != OK) {
1082        ALOGE("%s: Camera %d: Can't set up still image stream: %s (%d)",
1083                __FUNCTION__, mCameraId, strerror(-res), res);
1084        return res;
1085    }
1086
1087    res = mCaptureSequencer->startCapture();
1088    if (res != OK) {
1089        ALOGE("%s: Camera %d: Unable to start capture: %s (%d)",
1090                __FUNCTION__, mCameraId, strerror(-res), res);
1091    }
1092
1093    return res;
1094}
1095
1096status_t Camera2Client::setParameters(const String8& params) {
1097    ATRACE_CALL();
1098    ALOGV("%s: E", __FUNCTION__);
1099    Mutex::Autolock icl(mICameraLock);
1100    status_t res;
1101    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1102
1103    SharedParameters::Lock l(mParameters);
1104
1105    res = l.mParameters.set(params);
1106    if (res != OK) return res;
1107
1108    res = updateRequests(l.mParameters);
1109
1110    return res;
1111}
1112
1113String8 Camera2Client::getParameters() const {
1114    ATRACE_CALL();
1115    Mutex::Autolock icl(mICameraLock);
1116    if ( checkPid(__FUNCTION__) != OK) return String8();
1117
1118    SharedParameters::ReadLock l(mParameters);
1119
1120    // TODO: Deal with focus distances
1121    return l.mParameters.paramsFlattened;
1122}
1123
1124status_t Camera2Client::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) {
1125    ATRACE_CALL();
1126    Mutex::Autolock icl(mICameraLock);
1127    status_t res;
1128    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1129
1130    ALOGV("%s: Camera %d: Command %d (%d, %d)", __FUNCTION__, mCameraId,
1131            cmd, arg1, arg2);
1132
1133    switch (cmd) {
1134        case CAMERA_CMD_START_SMOOTH_ZOOM:
1135            return commandStartSmoothZoomL();
1136        case CAMERA_CMD_STOP_SMOOTH_ZOOM:
1137            return commandStopSmoothZoomL();
1138        case CAMERA_CMD_SET_DISPLAY_ORIENTATION:
1139            return commandSetDisplayOrientationL(arg1);
1140        case CAMERA_CMD_ENABLE_SHUTTER_SOUND:
1141            return commandEnableShutterSoundL(arg1 == 1);
1142        case CAMERA_CMD_PLAY_RECORDING_SOUND:
1143            return commandPlayRecordingSoundL();
1144        case CAMERA_CMD_START_FACE_DETECTION:
1145            return commandStartFaceDetectionL(arg1);
1146        case CAMERA_CMD_STOP_FACE_DETECTION: {
1147            SharedParameters::Lock l(mParameters);
1148            return commandStopFaceDetectionL(l.mParameters);
1149        }
1150        case CAMERA_CMD_ENABLE_FOCUS_MOVE_MSG:
1151            return commandEnableFocusMoveMsgL(arg1 == 1);
1152        case CAMERA_CMD_PING:
1153            return commandPingL();
1154        case CAMERA_CMD_SET_VIDEO_BUFFER_COUNT:
1155            return commandSetVideoBufferCountL(arg1);
1156        default:
1157            ALOGE("%s: Unknown command %d (arguments %d, %d)",
1158                    __FUNCTION__, cmd, arg1, arg2);
1159            return BAD_VALUE;
1160    }
1161}
1162
1163status_t Camera2Client::commandStartSmoothZoomL() {
1164    ALOGE("%s: Unimplemented!", __FUNCTION__);
1165    return OK;
1166}
1167
1168status_t Camera2Client::commandStopSmoothZoomL() {
1169    ALOGE("%s: Unimplemented!", __FUNCTION__);
1170    return OK;
1171}
1172
1173status_t Camera2Client::commandSetDisplayOrientationL(int degrees) {
1174    int transform = Parameters::degToTransform(degrees,
1175            mCameraFacing == CAMERA_FACING_FRONT);
1176    if (transform == -1) {
1177        ALOGE("%s: Camera %d: Error setting %d as display orientation value",
1178                __FUNCTION__, mCameraId, degrees);
1179        return BAD_VALUE;
1180    }
1181    SharedParameters::Lock l(mParameters);
1182    if (transform != l.mParameters.previewTransform &&
1183            mPreviewStreamId != NO_STREAM) {
1184        mDevice->setStreamTransform(mPreviewStreamId, transform);
1185    }
1186    l.mParameters.previewTransform = transform;
1187    return OK;
1188}
1189
1190status_t Camera2Client::commandEnableShutterSoundL(bool enable) {
1191    SharedParameters::Lock l(mParameters);
1192    if (enable) {
1193        l.mParameters.playShutterSound = true;
1194        return OK;
1195    }
1196
1197    // Disabling shutter sound may not be allowed. In that case only
1198    // allow the mediaserver process to disable the sound.
1199    char value[PROPERTY_VALUE_MAX];
1200    property_get("ro.camera.sound.forced", value, "0");
1201    if (strncmp(value, "0", 2) != 0) {
1202        // Disabling shutter sound is not allowed. Deny if the current
1203        // process is not mediaserver.
1204        if (getCallingPid() != getpid()) {
1205            ALOGE("Failed to disable shutter sound. Permission denied (pid %d)",
1206                    getCallingPid());
1207            return PERMISSION_DENIED;
1208        }
1209    }
1210
1211    l.mParameters.playShutterSound = false;
1212    return OK;
1213}
1214
1215status_t Camera2Client::commandPlayRecordingSoundL() {
1216    mCameraService->playSound(CameraService::SOUND_RECORDING);
1217    return OK;
1218}
1219
1220status_t Camera2Client::commandStartFaceDetectionL(int type) {
1221    ALOGV("%s: Camera %d: Starting face detection",
1222          __FUNCTION__, mCameraId);
1223    status_t res;
1224    SharedParameters::Lock l(mParameters);
1225    switch (l.mParameters.state) {
1226        case Parameters::DISCONNECTED:
1227        case Parameters::STOPPED:
1228        case Parameters::WAITING_FOR_PREVIEW_WINDOW:
1229        case Parameters::STILL_CAPTURE:
1230            ALOGE("%s: Camera %d: Cannot start face detection without preview active",
1231                    __FUNCTION__, mCameraId);
1232            return INVALID_OPERATION;
1233        case Parameters::PREVIEW:
1234        case Parameters::RECORD:
1235        case Parameters::VIDEO_SNAPSHOT:
1236            // Good to go for starting face detect
1237            break;
1238    }
1239    // Ignoring type
1240    if (l.mParameters.fastInfo.bestFaceDetectMode ==
1241            ANDROID_STATS_FACE_DETECTION_OFF) {
1242        ALOGE("%s: Camera %d: Face detection not supported",
1243                __FUNCTION__, mCameraId);
1244        return INVALID_OPERATION;
1245    }
1246    if (l.mParameters.enableFaceDetect) return OK;
1247
1248    l.mParameters.enableFaceDetect = true;
1249
1250    res = updateRequests(l.mParameters);
1251
1252    return res;
1253}
1254
1255status_t Camera2Client::commandStopFaceDetectionL(Parameters &params) {
1256    status_t res = OK;
1257    ALOGV("%s: Camera %d: Stopping face detection",
1258          __FUNCTION__, mCameraId);
1259
1260    if (!params.enableFaceDetect) return OK;
1261
1262    params.enableFaceDetect = false;
1263
1264    if (params.state == Parameters::PREVIEW
1265            || params.state == Parameters::RECORD
1266            || params.state == Parameters::VIDEO_SNAPSHOT) {
1267        res = updateRequests(params);
1268    }
1269
1270    return res;
1271}
1272
1273status_t Camera2Client::commandEnableFocusMoveMsgL(bool enable) {
1274    SharedParameters::Lock l(mParameters);
1275    l.mParameters.enableFocusMoveMessages = enable;
1276
1277    return OK;
1278}
1279
1280status_t Camera2Client::commandPingL() {
1281    // Always ping back if access is proper and device is alive
1282    SharedParameters::Lock l(mParameters);
1283    if (l.mParameters.state != Parameters::DISCONNECTED) {
1284        return OK;
1285    } else {
1286        return NO_INIT;
1287    }
1288}
1289
1290status_t Camera2Client::commandSetVideoBufferCountL(size_t count) {
1291    if (recordingEnabledL()) {
1292        ALOGE("%s: Camera %d: Error setting video buffer count after "
1293                "recording was started", __FUNCTION__, mCameraId);
1294        return INVALID_OPERATION;
1295    }
1296
1297    // 32 is the current upper limit on the video buffer count for BufferQueue
1298    if (count > 32) {
1299        ALOGE("%s: Camera %d: Error setting %d as video buffer count value",
1300                __FUNCTION__, mCameraId, count);
1301        return BAD_VALUE;
1302    }
1303
1304    // Need to reallocate memory for heap
1305    if (mRecordingHeapCount != count) {
1306        if  (mRecordingHeap != 0) {
1307            mRecordingHeap.clear();
1308            mRecordingHeap = NULL;
1309        }
1310        mRecordingHeapCount = count;
1311    }
1312
1313    return OK;
1314}
1315
1316/** Device-related methods */
1317
1318void Camera2Client::notifyError(int errorCode, int arg1, int arg2) {
1319    ALOGE("Error condition %d reported by HAL, arguments %d, %d", errorCode, arg1, arg2);
1320}
1321
1322void Camera2Client::notifyShutter(int frameNumber, nsecs_t timestamp) {
1323    ALOGV("%s: Shutter notification for frame %d at time %lld", __FUNCTION__,
1324            frameNumber, timestamp);
1325}
1326
1327void Camera2Client::notifyAutoFocus(uint8_t newState, int triggerId) {
1328    ALOGV("%s: Autofocus state now %d, last trigger %d",
1329            __FUNCTION__, newState, triggerId);
1330    bool sendCompletedMessage = false;
1331    bool sendMovingMessage = false;
1332
1333    bool success = false;
1334    bool afInMotion = false;
1335    {
1336        SharedParameters::Lock l(mParameters);
1337        switch (l.mParameters.focusMode) {
1338            case Parameters::FOCUS_MODE_AUTO:
1339            case Parameters::FOCUS_MODE_MACRO:
1340                // Don't send notifications upstream if they're not for the current AF
1341                // trigger. For example, if cancel was called in between, or if we
1342                // already sent a notification about this AF call.
1343                if (triggerId != l.mParameters.currentAfTriggerId) break;
1344                switch (newState) {
1345                    case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED:
1346                        success = true;
1347                        // no break
1348                    case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED:
1349                        sendCompletedMessage = true;
1350                        l.mParameters.currentAfTriggerId = -1;
1351                        break;
1352                    case ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN:
1353                        // Just starting focusing, ignore
1354                        break;
1355                    case ANDROID_CONTROL_AF_STATE_INACTIVE:
1356                    case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN:
1357                    case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED:
1358                    default:
1359                        // Unexpected in AUTO/MACRO mode
1360                        ALOGE("%s: Unexpected AF state transition in AUTO/MACRO mode: %d",
1361                                __FUNCTION__, newState);
1362                        break;
1363                }
1364                break;
1365            case Parameters::FOCUS_MODE_CONTINUOUS_VIDEO:
1366            case Parameters::FOCUS_MODE_CONTINUOUS_PICTURE:
1367                switch (newState) {
1368                    case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED:
1369                        success = true;
1370                        // no break
1371                    case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED:
1372                        // Don't send notifications upstream if they're not for
1373                        // the current AF trigger. For example, if cancel was
1374                        // called in between, or if we already sent a
1375                        // notification about this AF call.
1376                        // Send both a 'AF done' callback and a 'AF move' callback
1377                        if (triggerId != l.mParameters.currentAfTriggerId) break;
1378                        sendCompletedMessage = true;
1379                        afInMotion = false;
1380                        if (l.mParameters.enableFocusMoveMessages &&
1381                                l.mParameters.afInMotion) {
1382                            sendMovingMessage = true;
1383                        }
1384                        l.mParameters.currentAfTriggerId = -1;
1385                        break;
1386                    case ANDROID_CONTROL_AF_STATE_INACTIVE:
1387                        // Cancel was called, or we switched state; care if
1388                        // currently moving
1389                        afInMotion = false;
1390                        if (l.mParameters.enableFocusMoveMessages &&
1391                                l.mParameters.afInMotion) {
1392                            sendMovingMessage = true;
1393                        }
1394                        break;
1395                    case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN:
1396                        // Start passive scan, inform upstream
1397                        afInMotion = true;
1398                        // no break
1399                    case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED:
1400                        // Stop passive scan, inform upstream
1401                        if (l.mParameters.enableFocusMoveMessages) {
1402                            sendMovingMessage = true;
1403                        }
1404                        break;
1405                }
1406                l.mParameters.afInMotion = afInMotion;
1407                break;
1408            case Parameters::FOCUS_MODE_EDOF:
1409            case Parameters::FOCUS_MODE_INFINITY:
1410            case Parameters::FOCUS_MODE_FIXED:
1411            default:
1412                if (newState != ANDROID_CONTROL_AF_STATE_INACTIVE) {
1413                    ALOGE("%s: Unexpected AF state change %d "
1414                            "(ID %d) in focus mode %d",
1415                          __FUNCTION__, newState, triggerId,
1416                            l.mParameters.focusMode);
1417                }
1418        }
1419    }
1420    if (sendMovingMessage) {
1421        SharedCameraClient::Lock l(mSharedCameraClient);
1422        if (l.mCameraClient != 0) {
1423            l.mCameraClient->notifyCallback(CAMERA_MSG_FOCUS_MOVE,
1424                    afInMotion ? 1 : 0, 0);
1425        }
1426    }
1427    if (sendCompletedMessage) {
1428        SharedCameraClient::Lock l(mSharedCameraClient);
1429        if (l.mCameraClient != 0) {
1430            l.mCameraClient->notifyCallback(CAMERA_MSG_FOCUS,
1431                    success ? 1 : 0, 0);
1432        }
1433    }
1434}
1435
1436void Camera2Client::notifyAutoExposure(uint8_t newState, int triggerId) {
1437    ALOGV("%s: Autoexposure state now %d, last trigger %d",
1438            __FUNCTION__, newState, triggerId);
1439    mCaptureSequencer->notifyAutoExposure(newState, triggerId);
1440}
1441
1442void Camera2Client::notifyAutoWhitebalance(uint8_t newState, int triggerId) {
1443    ALOGV("%s: Auto-whitebalance state now %d, last trigger %d",
1444            __FUNCTION__, newState, triggerId);
1445}
1446
1447int Camera2Client::getCameraId() const {
1448    return mCameraId;
1449}
1450
1451const sp<Camera2Device>& Camera2Client::getCameraDevice() {
1452    return mDevice;
1453}
1454
1455const sp<CameraService>& Camera2Client::getCameraService() {
1456    return mCameraService;
1457}
1458
1459camera2::SharedParameters& Camera2Client::getParameters() {
1460    return mParameters;
1461}
1462
1463int Camera2Client::getPreviewStreamId() const {
1464    return mPreviewStreamId;
1465}
1466
1467int Camera2Client::getCaptureStreamId() const {
1468    return mJpegProcessor->getStreamId();
1469}
1470
1471int Camera2Client::getCallbackStreamId() const {
1472    return mCallbackProcessor->getStreamId();
1473}
1474
1475int Camera2Client::getRecordingStreamId() const {
1476    return mRecordingStreamId;
1477}
1478
1479int Camera2Client::getZslStreamId() const {
1480    return mZslProcessor->getStreamId();
1481}
1482
1483status_t Camera2Client::registerFrameListener(int32_t id,
1484        wp<camera2::FrameProcessor::FilteredListener> listener) {
1485    return mFrameProcessor->registerListener(id, listener);
1486}
1487
1488status_t Camera2Client::removeFrameListener(int32_t id) {
1489    return mFrameProcessor->removeListener(id);
1490}
1491
1492Camera2Client::SharedCameraClient::Lock::Lock(SharedCameraClient &client):
1493        mCameraClient(client.mCameraClient),
1494        mSharedClient(client) {
1495    mSharedClient.mCameraClientLock.lock();
1496}
1497
1498Camera2Client::SharedCameraClient::Lock::~Lock() {
1499    mSharedClient.mCameraClientLock.unlock();
1500}
1501
1502Camera2Client::SharedCameraClient::SharedCameraClient(const sp<ICameraClient>&client):
1503        mCameraClient(client) {
1504}
1505
1506Camera2Client::SharedCameraClient& Camera2Client::SharedCameraClient::operator=(
1507        const sp<ICameraClient>&client) {
1508    Mutex::Autolock l(mCameraClientLock);
1509    mCameraClient = client;
1510    return *this;
1511}
1512
1513void Camera2Client::SharedCameraClient::clear() {
1514    Mutex::Autolock l(mCameraClientLock);
1515    mCameraClient.clear();
1516}
1517
1518const int32_t Camera2Client::kPreviewRequestId;
1519const int32_t Camera2Client::kRecordRequestId;
1520const int32_t Camera2Client::kFirstCaptureRequestId;
1521
1522void Camera2Client::onRecordingFrameAvailable() {
1523    ATRACE_CALL();
1524    status_t res;
1525    sp<Camera2Heap> recordingHeap;
1526    size_t heapIdx = 0;
1527    nsecs_t timestamp;
1528    {
1529        SharedParameters::Lock l(mParameters);
1530
1531        BufferItemConsumer::BufferItem imgBuffer;
1532        res = mRecordingConsumer->acquireBuffer(&imgBuffer);
1533        if (res != OK) {
1534            ALOGE("%s: Camera %d: Error receiving recording buffer: %s (%d)",
1535                    __FUNCTION__, mCameraId, strerror(-res), res);
1536            return;
1537        }
1538        timestamp = imgBuffer.mTimestamp;
1539
1540        mRecordingFrameCount++;
1541        ALOGV("OnRecordingFrame: Frame %d", mRecordingFrameCount);
1542
1543        // TODO: Signal errors here upstream
1544        if (l.mParameters.state != Parameters::RECORD &&
1545                l.mParameters.state != Parameters::VIDEO_SNAPSHOT) {
1546            ALOGV("%s: Camera %d: Discarding recording image buffers received after "
1547                    "recording done",
1548                    __FUNCTION__, mCameraId);
1549            mRecordingConsumer->releaseBuffer(imgBuffer);
1550            return;
1551        }
1552
1553        if (mRecordingHeap == 0) {
1554            const size_t bufferSize = 4 + sizeof(buffer_handle_t);
1555            ALOGV("%s: Camera %d: Creating recording heap with %d buffers of "
1556                    "size %d bytes", __FUNCTION__, mCameraId,
1557                    mRecordingHeapCount, bufferSize);
1558
1559            mRecordingHeap = new Camera2Heap(bufferSize, mRecordingHeapCount,
1560                    "Camera2Client::RecordingHeap");
1561            if (mRecordingHeap->mHeap->getSize() == 0) {
1562                ALOGE("%s: Camera %d: Unable to allocate memory for recording",
1563                        __FUNCTION__, mCameraId);
1564                mRecordingConsumer->releaseBuffer(imgBuffer);
1565                return;
1566            }
1567            for (size_t i = 0; i < mRecordingBuffers.size(); i++) {
1568                if (mRecordingBuffers[i].mBuf !=
1569                        BufferItemConsumer::INVALID_BUFFER_SLOT) {
1570                    ALOGE("%s: Camera %d: Non-empty recording buffers list!",
1571                            __FUNCTION__, mCameraId);
1572                }
1573            }
1574            mRecordingBuffers.clear();
1575            mRecordingBuffers.setCapacity(mRecordingHeapCount);
1576            mRecordingBuffers.insertAt(0, mRecordingHeapCount);
1577
1578            mRecordingHeapHead = 0;
1579            mRecordingHeapFree = mRecordingHeapCount;
1580        }
1581
1582        if ( mRecordingHeapFree == 0) {
1583            ALOGE("%s: Camera %d: No free recording buffers, dropping frame",
1584                    __FUNCTION__, mCameraId);
1585            mRecordingConsumer->releaseBuffer(imgBuffer);
1586            return;
1587        }
1588
1589        heapIdx = mRecordingHeapHead;
1590        mRecordingHeapHead = (mRecordingHeapHead + 1) % mRecordingHeapCount;
1591        mRecordingHeapFree--;
1592
1593        ALOGV("%s: Camera %d: Timestamp %lld",
1594                __FUNCTION__, mCameraId, timestamp);
1595
1596        ssize_t offset;
1597        size_t size;
1598        sp<IMemoryHeap> heap =
1599                mRecordingHeap->mBuffers[heapIdx]->getMemory(&offset,
1600                        &size);
1601
1602        uint8_t *data = (uint8_t*)heap->getBase() + offset;
1603        uint32_t type = kMetadataBufferTypeGrallocSource;
1604        *((uint32_t*)data) = type;
1605        *((buffer_handle_t*)(data + 4)) = imgBuffer.mGraphicBuffer->handle;
1606        ALOGV("%s: Camera %d: Sending out buffer_handle_t %p",
1607                __FUNCTION__, mCameraId, imgBuffer.mGraphicBuffer->handle);
1608        mRecordingBuffers.replaceAt(imgBuffer, heapIdx);
1609        recordingHeap = mRecordingHeap;
1610    }
1611
1612    // Call outside locked parameters to allow re-entrancy from notification
1613    SharedCameraClient::Lock l(mSharedCameraClient);
1614    if (l.mCameraClient != 0) {
1615        l.mCameraClient->dataCallbackTimestamp(timestamp,
1616                CAMERA_MSG_VIDEO_FRAME,
1617                recordingHeap->mBuffers[heapIdx]);
1618    }
1619}
1620
1621/** Utility methods */
1622
1623status_t Camera2Client::updateRequests(const Parameters &params) {
1624    status_t res;
1625
1626    res = updatePreviewRequest(params);
1627    if (res != OK) {
1628        ALOGE("%s: Camera %d: Unable to update preview request: %s (%d)",
1629                __FUNCTION__, mCameraId, strerror(-res), res);
1630        return res;
1631    }
1632    res = updateRecordingRequest(params);
1633    if (res != OK) {
1634        ALOGE("%s: Camera %d: Unable to update recording request: %s (%d)",
1635                __FUNCTION__, mCameraId, strerror(-res), res);
1636        return res;
1637    }
1638
1639    if (params.state == Parameters::PREVIEW) {
1640        res = mDevice->setStreamingRequest(mPreviewRequest);
1641        if (res != OK) {
1642            ALOGE("%s: Camera %d: Error streaming new preview request: %s (%d)",
1643                    __FUNCTION__, mCameraId, strerror(-res), res);
1644            return res;
1645        }
1646    } else if (params.state == Parameters::RECORD ||
1647            params.state == Parameters::VIDEO_SNAPSHOT) {
1648        res = mDevice->setStreamingRequest(mRecordingRequest);
1649        if (res != OK) {
1650            ALOGE("%s: Camera %d: Error streaming new record request: %s (%d)",
1651                    __FUNCTION__, mCameraId, strerror(-res), res);
1652            return res;
1653        }
1654    }
1655    return res;
1656}
1657
1658status_t Camera2Client::updatePreviewStream(const Parameters &params) {
1659    ATRACE_CALL();
1660    status_t res;
1661
1662    if (mPreviewStreamId != NO_STREAM) {
1663        // Check if stream parameters have to change
1664        uint32_t currentWidth, currentHeight;
1665        res = mDevice->getStreamInfo(mPreviewStreamId,
1666                &currentWidth, &currentHeight, 0);
1667        if (res != OK) {
1668            ALOGE("%s: Camera %d: Error querying preview stream info: "
1669                    "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
1670            return res;
1671        }
1672        if (currentWidth != (uint32_t)params.previewWidth ||
1673                currentHeight != (uint32_t)params.previewHeight) {
1674            ALOGV("%s: Camera %d: Preview size switch: %d x %d -> %d x %d",
1675                    __FUNCTION__, mCameraId, currentWidth, currentHeight,
1676                    params.previewWidth, params.previewHeight);
1677            res = mDevice->waitUntilDrained();
1678            if (res != OK) {
1679                ALOGE("%s: Camera %d: Error waiting for preview to drain: "
1680                        "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
1681                return res;
1682            }
1683            res = mDevice->deleteStream(mPreviewStreamId);
1684            if (res != OK) {
1685                ALOGE("%s: Camera %d: Unable to delete old output stream "
1686                        "for preview: %s (%d)", __FUNCTION__, mCameraId,
1687                        strerror(-res), res);
1688                return res;
1689            }
1690            mPreviewStreamId = NO_STREAM;
1691        }
1692    }
1693
1694    if (mPreviewStreamId == NO_STREAM) {
1695        res = mDevice->createStream(mPreviewWindow,
1696                params.previewWidth, params.previewHeight,
1697                CAMERA2_HAL_PIXEL_FORMAT_OPAQUE, 0,
1698                &mPreviewStreamId);
1699        if (res != OK) {
1700            ALOGE("%s: Camera %d: Unable to create preview stream: %s (%d)",
1701                    __FUNCTION__, mCameraId, strerror(-res), res);
1702            return res;
1703        }
1704    }
1705
1706    res = mDevice->setStreamTransform(mPreviewStreamId,
1707            params.previewTransform);
1708    if (res != OK) {
1709        ALOGE("%s: Camera %d: Unable to set preview stream transform: "
1710                "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
1711        return res;
1712    }
1713
1714    return OK;
1715}
1716
1717status_t Camera2Client::updatePreviewRequest(const Parameters &params) {
1718    ATRACE_CALL();
1719    status_t res;
1720    if (mPreviewRequest.entryCount() == 0) {
1721        res = mDevice->createDefaultRequest(CAMERA2_TEMPLATE_PREVIEW,
1722                &mPreviewRequest);
1723        if (res != OK) {
1724            ALOGE("%s: Camera %d: Unable to create default preview request: "
1725                    "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
1726            return res;
1727        }
1728    }
1729
1730    res = params.updateRequest(&mPreviewRequest);
1731    if (res != OK) {
1732        ALOGE("%s: Camera %d: Unable to update common entries of preview "
1733                "request: %s (%d)", __FUNCTION__, mCameraId,
1734                strerror(-res), res);
1735        return res;
1736    }
1737
1738    res = mPreviewRequest.update(ANDROID_REQUEST_ID,
1739            &kPreviewRequestId, 1);
1740
1741    return OK;
1742}
1743
1744status_t Camera2Client::updateRecordingRequest(const Parameters &params) {
1745    ATRACE_CALL();
1746    status_t res;
1747    if (mRecordingRequest.entryCount() == 0) {
1748        res = mDevice->createDefaultRequest(CAMERA2_TEMPLATE_VIDEO_RECORD,
1749                &mRecordingRequest);
1750        if (res != OK) {
1751            ALOGE("%s: Camera %d: Unable to create default recording request:"
1752                    " %s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
1753            return res;
1754        }
1755    }
1756
1757    res = params.updateRequest(&mRecordingRequest);
1758    if (res != OK) {
1759        ALOGE("%s: Camera %d: Unable to update common entries of recording "
1760                "request: %s (%d)", __FUNCTION__, mCameraId,
1761                strerror(-res), res);
1762        return res;
1763    }
1764
1765    return OK;
1766}
1767
1768status_t Camera2Client::updateRecordingStream(const Parameters &params) {
1769    status_t res;
1770
1771    if (mRecordingConsumer == 0) {
1772        // Create CPU buffer queue endpoint. We need one more buffer here so that we can
1773        // always acquire and free a buffer when the heap is full; otherwise the consumer
1774        // will have buffers in flight we'll never clear out.
1775        mRecordingConsumer = new BufferItemConsumer(
1776                GRALLOC_USAGE_HW_VIDEO_ENCODER,
1777                mRecordingHeapCount + 1,
1778                true);
1779        mRecordingConsumer->setFrameAvailableListener(new RecordingWaiter(this));
1780        mRecordingConsumer->setName(String8("Camera2Client::RecordingConsumer"));
1781        mRecordingWindow = new SurfaceTextureClient(
1782            mRecordingConsumer->getProducerInterface());
1783        // Allocate memory later, since we don't know buffer size until receipt
1784    }
1785
1786    if (mRecordingStreamId != NO_STREAM) {
1787        // Check if stream parameters have to change
1788        uint32_t currentWidth, currentHeight;
1789        res = mDevice->getStreamInfo(mRecordingStreamId,
1790                &currentWidth, &currentHeight, 0);
1791        if (res != OK) {
1792            ALOGE("%s: Camera %d: Error querying recording output stream info: "
1793                    "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
1794            return res;
1795        }
1796        if (currentWidth != (uint32_t)params.videoWidth ||
1797                currentHeight != (uint32_t)params.videoHeight) {
1798            // TODO: Should wait to be sure previous recording has finished
1799            res = mDevice->deleteStream(mRecordingStreamId);
1800            if (res != OK) {
1801                ALOGE("%s: Camera %d: Unable to delete old output stream "
1802                        "for recording: %s (%d)", __FUNCTION__, mCameraId,
1803                        strerror(-res), res);
1804                return res;
1805            }
1806            mRecordingStreamId = NO_STREAM;
1807        }
1808    }
1809
1810    if (mRecordingStreamId == NO_STREAM) {
1811        mRecordingFrameCount = 0;
1812        res = mDevice->createStream(mRecordingWindow,
1813                params.videoWidth, params.videoHeight,
1814                CAMERA2_HAL_PIXEL_FORMAT_OPAQUE, 0, &mRecordingStreamId);
1815        if (res != OK) {
1816            ALOGE("%s: Camera %d: Can't create output stream for recording: "
1817                    "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
1818            return res;
1819        }
1820    }
1821
1822    return OK;
1823}
1824
1825size_t Camera2Client::calculateBufferSize(int width, int height,
1826        int format, int stride) {
1827    switch (format) {
1828        case HAL_PIXEL_FORMAT_YCbCr_422_SP: // NV16
1829            return width * height * 2;
1830        case HAL_PIXEL_FORMAT_YCrCb_420_SP: // NV21
1831            return width * height * 3 / 2;
1832        case HAL_PIXEL_FORMAT_YCbCr_422_I: // YUY2
1833            return width * height * 2;
1834        case HAL_PIXEL_FORMAT_YV12: {      // YV12
1835            size_t ySize = stride * height;
1836            size_t uvStride = (stride / 2 + 0xF) & ~0xF;
1837            size_t uvSize = uvStride * height / 2;
1838            return ySize + uvSize * 2;
1839        }
1840        case HAL_PIXEL_FORMAT_RGB_565:
1841            return width * height * 2;
1842        case HAL_PIXEL_FORMAT_RGBA_8888:
1843            return width * height * 4;
1844        case HAL_PIXEL_FORMAT_RAW_SENSOR:
1845            return width * height * 2;
1846        default:
1847            ALOGE("%s: Unknown preview format: %x",
1848                    __FUNCTION__,  format);
1849            return 0;
1850    }
1851}
1852
1853} // namespace android
1854