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