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