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