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