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