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