Camera2Client.cpp revision 98bb82d1bf7c94240956426812de6593801faad4 
1/*
2 * Copyright (C) 2012 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#define LOG_TAG "Camera2Client"
18#define ATRACE_TAG ATRACE_TAG_CAMERA
19//#define LOG_NDEBUG 0
20
21#include <utils/Log.h>
22#include <utils/Trace.h>
23
24#include <cutils/properties.h>
25#include <gui/SurfaceTextureClient.h>
26#include <gui/Surface.h>
27#include <media/hardware/MetadataBufferType.h>
28#include "camera2/Parameters.h"
29#include "Camera2Client.h"
30
31#define ALOG1(...) ALOGD_IF(gLogLevel >= 1, __VA_ARGS__);
32#define ALOG2(...) ALOGD_IF(gLogLevel >= 2, __VA_ARGS__);
33
34namespace android {
35using namespace camera2;
36
37static int getCallingPid() {
38    return IPCThreadState::self()->getCallingPid();
39}
40
41static int getCallingUid() {
42    return IPCThreadState::self()->getCallingUid();
43}
44
45// Interface used by CameraService
46
47Camera2Client::Camera2Client(const sp<CameraService>& cameraService,
48        const sp<ICameraClient>& cameraClient,
49        int cameraId,
50        int cameraFacing,
51        int clientPid):
52        Client(cameraService, cameraClient,
53                cameraId, cameraFacing, clientPid),
54        mSharedCameraClient(cameraClient),
55        mParameters(cameraId, cameraFacing),
56        mPreviewStreamId(NO_STREAM),
57        mRecordingStreamId(NO_STREAM),
58        mRecordingHeapCount(kDefaultRecordingHeapCount)
59{
60    ATRACE_CALL();
61    ALOGI("Camera %d: Opened", cameraId);
62
63    mDevice = new Camera2Device(cameraId);
64
65    SharedParameters::Lock l(mParameters);
66    l.mParameters.state = Parameters::DISCONNECTED;
67}
68
69status_t Camera2Client::checkPid(const char* checkLocation) const {
70    int callingPid = getCallingPid();
71    if (callingPid == mClientPid) return NO_ERROR;
72
73    ALOGE("%s: attempt to use a locked camera from a different process"
74            " (old pid %d, new pid %d)", checkLocation, mClientPid, callingPid);
75    return PERMISSION_DENIED;
76}
77
78status_t Camera2Client::initialize(camera_module_t *module)
79{
80    ATRACE_CALL();
81    ALOGV("%s: Initializing client for camera %d", __FUNCTION__, mCameraId);
82    status_t res;
83
84    res = mDevice->initialize(module);
85    if (res != OK) {
86        ALOGE("%s: Camera %d: unable to initialize device: %s (%d)",
87                __FUNCTION__, mCameraId, strerror(-res), res);
88        return NO_INIT;
89    }
90
91    res = mDevice->setNotifyCallback(this);
92
93    SharedParameters::Lock l(mParameters);
94
95    res = l.mParameters.initialize(&(mDevice->info()));
96    if (res != OK) {
97        ALOGE("%s: Camera %d: unable to build defaults: %s (%d)",
98                __FUNCTION__, mCameraId, strerror(-res), res);
99        return NO_INIT;
100    }
101
102    String8 threadName;
103
104    mFrameProcessor = new FrameProcessor(this);
105    threadName = String8::format("Camera2Client[%d]::FrameProcessor",
106            mCameraId);
107    mFrameProcessor->run(threadName.string());
108
109    mCaptureSequencer = new CaptureSequencer(this);
110    threadName = String8::format("Camera2Client[%d]::CaptureSequencer",
111            mCameraId);
112    mCaptureSequencer->run(threadName.string());
113
114    mJpegProcessor = new JpegProcessor(this, mCaptureSequencer);
115    threadName = String8::format("Camera2Client[%d]::JpegProcessor",
116            mCameraId);
117    mJpegProcessor->run(threadName.string());
118
119    mZslProcessor = new ZslProcessor(this, mCaptureSequencer);
120    threadName = String8::format("Camera2Client[%d]::ZslProcessor",
121            mCameraId);
122    mZslProcessor->run(threadName.string());
123
124    mCallbackProcessor = new CallbackProcessor(this);
125    threadName = String8::format("Camera2Client[%d]::CallbackProcessor",
126            mCameraId);
127    mCallbackProcessor->run(threadName.string());
128
129    if (gLogLevel >= 1) {
130        ALOGD("%s: Default parameters converted from camera %d:", __FUNCTION__,
131              mCameraId);
132        ALOGD("%s", l.mParameters.paramsFlattened.string());
133    }
134
135    return OK;
136}
137
138Camera2Client::~Camera2Client() {
139    ATRACE_CALL();
140
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        ALOGE("%s: Can't start preview in state %s",
629                __FUNCTION__,
630                Parameters::getStateName(params.state));
631        return INVALID_OPERATION;
632    }
633
634    if (mPreviewWindow == 0) {
635        params.state = Parameters::WAITING_FOR_PREVIEW_WINDOW;
636        return OK;
637    }
638    params.state = Parameters::STOPPED;
639
640    res = updatePreviewStream(params);
641    if (res != OK) {
642        ALOGE("%s: Camera %d: Unable to update preview stream: %s (%d)",
643                __FUNCTION__, mCameraId, strerror(-res), res);
644        return res;
645    }
646    bool callbacksEnabled = params.previewCallbackFlags &
647        CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK;
648    if (callbacksEnabled) {
649        res = mCallbackProcessor->updateStream(params);
650        if (res != OK) {
651            ALOGE("%s: Camera %d: Unable to update callback stream: %s (%d)",
652                    __FUNCTION__, mCameraId, strerror(-res), res);
653            return res;
654        }
655    }
656    if (params.zslMode && !params.recordingHint) {
657        res = mZslProcessor->updateStream(params);
658        if (res != OK) {
659            ALOGE("%s: Camera %d: Unable to update ZSL stream: %s (%d)",
660                    __FUNCTION__, mCameraId, strerror(-res), res);
661            return res;
662        }
663    }
664
665    CameraMetadata *request;
666    if (!params.recordingHint) {
667        if (mPreviewRequest.entryCount() == 0) {
668            res = updatePreviewRequest(params);
669            if (res != OK) {
670                ALOGE("%s: Camera %d: Unable to create preview request: %s (%d)",
671                        __FUNCTION__, mCameraId, strerror(-res), res);
672                return res;
673            }
674        }
675        request = &mPreviewRequest;
676    } else {
677        // With recording hint set, we're going to be operating under the
678        // assumption that the user will record video. To optimize recording
679        // startup time, create the necessary output streams for recording and
680        // video snapshot now if they don't already exist.
681        if (mRecordingRequest.entryCount() == 0) {
682            res = updateRecordingRequest(params);
683            if (res != OK) {
684                ALOGE("%s: Camera %d: Unable to create recording preview "
685                        "request: %s (%d)",
686                        __FUNCTION__, mCameraId, strerror(-res), res);
687                return res;
688            }
689        }
690        request = &mRecordingRequest;
691
692        // TODO: Re-enable recording stream creation/update here once issues are
693        // resolved
694
695        res = mJpegProcessor->updateStream(params);
696        if (res != OK) {
697            ALOGE("%s: Camera %d: Can't pre-configure still image "
698                    "stream: %s (%d)",
699                    __FUNCTION__, mCameraId, strerror(-res), res);
700            return res;
701        }
702    }
703
704    Vector<uint8_t> outputStreams;
705    outputStreams.push(getPreviewStreamId());
706
707    if (callbacksEnabled) {
708        outputStreams.push(getCallbackStreamId());
709    }
710    if (params.zslMode && !params.recordingHint) {
711        outputStreams.push(getZslStreamId());
712    }
713
714    res = request->update(
715        ANDROID_REQUEST_OUTPUT_STREAMS,
716        outputStreams);
717
718    if (res != OK) {
719        ALOGE("%s: Camera %d: Unable to set up preview request: %s (%d)",
720                __FUNCTION__, mCameraId, strerror(-res), res);
721        return res;
722    }
723    res = request->sort();
724    if (res != OK) {
725        ALOGE("%s: Camera %d: Error sorting preview request: %s (%d)",
726                __FUNCTION__, mCameraId, strerror(-res), res);
727        return res;
728    }
729
730    res = mDevice->setStreamingRequest(*request);
731    if (res != OK) {
732        ALOGE("%s: Camera %d: Unable to set preview request to start preview: "
733                "%s (%d)",
734                __FUNCTION__, mCameraId, strerror(-res), res);
735        return res;
736    }
737    params.state = Parameters::PREVIEW;
738
739    return OK;
740}
741
742void Camera2Client::stopPreview() {
743    ATRACE_CALL();
744    ALOGV("%s: E", __FUNCTION__);
745    Mutex::Autolock icl(mICameraLock);
746    status_t res;
747    if ( (res = checkPid(__FUNCTION__) ) != OK) return;
748    stopPreviewL();
749}
750
751void Camera2Client::stopPreviewL() {
752    ATRACE_CALL();
753    Parameters::State state;
754    {
755        SharedParameters::Lock l(mParameters);
756        state = l.mParameters.state;
757    }
758
759    switch (state) {
760        case Parameters::DISCONNECTED:
761            ALOGE("%s: Camera %d: Call before initialized",
762                    __FUNCTION__, mCameraId);
763            break;
764        case Parameters::STOPPED:
765            break;
766        case Parameters::STILL_CAPTURE:
767            ALOGE("%s: Camera %d: Cannot stop preview during still capture.",
768                    __FUNCTION__, mCameraId);
769            break;
770        case Parameters::RECORD:
771            // no break - identical to preview
772        case Parameters::PREVIEW:
773            mDevice->clearStreamingRequest();
774            mDevice->waitUntilDrained();
775            // no break
776        case Parameters::WAITING_FOR_PREVIEW_WINDOW: {
777            SharedParameters::Lock l(mParameters);
778            l.mParameters.state = Parameters::STOPPED;
779            commandStopFaceDetectionL(l.mParameters);
780            break;
781        }
782        default:
783            ALOGE("%s: Camera %d: Unknown state %d", __FUNCTION__, mCameraId,
784                    state);
785    }
786}
787
788bool Camera2Client::previewEnabled() {
789    ATRACE_CALL();
790    Mutex::Autolock icl(mICameraLock);
791    status_t res;
792    if ( (res = checkPid(__FUNCTION__) ) != OK) return false;
793
794    SharedParameters::Lock l(mParameters);
795    return l.mParameters.state == Parameters::PREVIEW;
796}
797
798status_t Camera2Client::storeMetaDataInBuffers(bool enabled) {
799    ATRACE_CALL();
800    Mutex::Autolock icl(mICameraLock);
801    status_t res;
802    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
803
804    SharedParameters::Lock l(mParameters);
805    switch (l.mParameters.state) {
806        case Parameters::RECORD:
807        case Parameters::VIDEO_SNAPSHOT:
808            ALOGE("%s: Camera %d: Can't be called in state %s",
809                    __FUNCTION__, mCameraId,
810                    Parameters::getStateName(l.mParameters.state));
811            return INVALID_OPERATION;
812        default:
813            // OK
814            break;
815    }
816
817    l.mParameters.storeMetadataInBuffers = enabled;
818
819    return OK;
820}
821
822status_t Camera2Client::startRecording() {
823    ATRACE_CALL();
824    ALOGV("%s: E", __FUNCTION__);
825    Mutex::Autolock icl(mICameraLock);
826    status_t res;
827    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
828    SharedParameters::Lock l(mParameters);
829
830    return startRecordingL(l.mParameters, false);
831}
832
833status_t Camera2Client::startRecordingL(Parameters &params, bool restart) {
834    status_t res;
835    switch (params.state) {
836        case Parameters::STOPPED:
837            res = startPreviewL(params, false);
838            if (res != OK) return res;
839            break;
840        case Parameters::PREVIEW:
841            // Ready to go
842            break;
843        case Parameters::RECORD:
844        case Parameters::VIDEO_SNAPSHOT:
845            // OK to call this when recording is already on, just skip unless
846            // we're looking to restart
847            if (!restart) return OK;
848            break;
849        default:
850            ALOGE("%s: Camera %d: Can't start recording in state %s",
851                    __FUNCTION__, mCameraId,
852                    Parameters::getStateName(params.state));
853            return INVALID_OPERATION;
854    };
855
856    if (!params.storeMetadataInBuffers) {
857        ALOGE("%s: Camera %d: Recording only supported in metadata mode, but "
858                "non-metadata recording mode requested!", __FUNCTION__,
859                mCameraId);
860        return INVALID_OPERATION;
861    }
862
863    mCameraService->playSound(CameraService::SOUND_RECORDING);
864
865    res = updateRecordingStream(params);
866    if (res != OK) {
867        ALOGE("%s: Camera %d: Unable to update recording stream: %s (%d)",
868                __FUNCTION__, mCameraId, strerror(-res), res);
869        return res;
870    }
871    bool callbacksEnabled = params.previewCallbackFlags &
872        CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK;
873    if (callbacksEnabled) {
874        res = mCallbackProcessor->updateStream(params);
875        if (res != OK) {
876            ALOGE("%s: Camera %d: Unable to update callback stream: %s (%d)",
877                    __FUNCTION__, mCameraId, strerror(-res), res);
878            return res;
879        }
880    }
881
882    if (mRecordingRequest.entryCount() == 0) {
883        res = updateRecordingRequest(params);
884        if (res != OK) {
885            ALOGE("%s: Camera %d: Unable to create recording request: %s (%d)",
886                    __FUNCTION__, mCameraId, strerror(-res), res);
887            return res;
888        }
889    }
890
891    if (callbacksEnabled) {
892        uint8_t outputStreams[3] ={
893            getPreviewStreamId(),
894            getRecordingStreamId(),
895            getCallbackStreamId()
896        };
897        res = mRecordingRequest.update(
898                ANDROID_REQUEST_OUTPUT_STREAMS,
899                outputStreams, 3);
900    } else {
901        uint8_t outputStreams[2] = {
902            getPreviewStreamId(),
903            getRecordingStreamId()
904        };
905        res = mRecordingRequest.update(
906                ANDROID_REQUEST_OUTPUT_STREAMS,
907                outputStreams, 2);
908    }
909    if (res != OK) {
910        ALOGE("%s: Camera %d: Unable to set up recording request: %s (%d)",
911                __FUNCTION__, mCameraId, strerror(-res), res);
912        return res;
913    }
914    res = mRecordingRequest.sort();
915    if (res != OK) {
916        ALOGE("%s: Camera %d: Error sorting recording request: %s (%d)",
917                __FUNCTION__, mCameraId, strerror(-res), res);
918        return res;
919    }
920
921    res = mDevice->setStreamingRequest(mRecordingRequest);
922    if (res != OK) {
923        ALOGE("%s: Camera %d: Unable to set recording request to start "
924                "recording: %s (%d)", __FUNCTION__, mCameraId,
925                strerror(-res), res);
926        return res;
927    }
928    if (params.state < Parameters::RECORD) {
929        params.state = Parameters::RECORD;
930    }
931
932    return OK;
933}
934
935void Camera2Client::stopRecording() {
936    ATRACE_CALL();
937    ALOGV("%s: E", __FUNCTION__);
938    Mutex::Autolock icl(mICameraLock);
939    SharedParameters::Lock l(mParameters);
940
941    status_t res;
942    if ( (res = checkPid(__FUNCTION__) ) != OK) return;
943
944    switch (l.mParameters.state) {
945        case Parameters::RECORD:
946            // OK to stop
947            break;
948        case Parameters::STOPPED:
949        case Parameters::PREVIEW:
950        case Parameters::STILL_CAPTURE:
951        case Parameters::VIDEO_SNAPSHOT:
952        default:
953            ALOGE("%s: Camera %d: Can't stop recording in state %s",
954                    __FUNCTION__, mCameraId,
955                    Parameters::getStateName(l.mParameters.state));
956            return;
957    };
958
959    mCameraService->playSound(CameraService::SOUND_RECORDING);
960
961    res = startPreviewL(l.mParameters, true);
962    if (res != OK) {
963        ALOGE("%s: Camera %d: Unable to return to preview",
964                __FUNCTION__, mCameraId);
965    }
966}
967
968bool Camera2Client::recordingEnabled() {
969    ATRACE_CALL();
970    Mutex::Autolock icl(mICameraLock);
971
972    if ( checkPid(__FUNCTION__) != OK) return false;
973
974    return recordingEnabledL();
975}
976
977bool Camera2Client::recordingEnabledL() {
978    ATRACE_CALL();
979    SharedParameters::Lock l(mParameters);
980
981    return (l.mParameters.state == Parameters::RECORD
982            || l.mParameters.state == Parameters::VIDEO_SNAPSHOT);
983}
984
985void Camera2Client::releaseRecordingFrame(const sp<IMemory>& mem) {
986    ATRACE_CALL();
987    Mutex::Autolock icl(mICameraLock);
988    status_t res;
989    if ( checkPid(__FUNCTION__) != OK) return;
990
991    SharedParameters::Lock l(mParameters);
992
993    // Make sure this is for the current heap
994    ssize_t offset;
995    size_t size;
996    sp<IMemoryHeap> heap = mem->getMemory(&offset, &size);
997    if (heap->getHeapID() != mRecordingHeap->mHeap->getHeapID()) {
998        ALOGW("%s: Camera %d: Mismatched heap ID, ignoring release "
999                "(got %x, expected %x)", __FUNCTION__, mCameraId,
1000                heap->getHeapID(), mRecordingHeap->mHeap->getHeapID());
1001        return;
1002    }
1003    uint8_t *data = (uint8_t*)heap->getBase() + offset;
1004    uint32_t type = *(uint32_t*)data;
1005    if (type != kMetadataBufferTypeGrallocSource) {
1006        ALOGE("%s: Camera %d: Recording frame type invalid (got %x, expected %x)",
1007                __FUNCTION__, mCameraId, type, kMetadataBufferTypeGrallocSource);
1008        return;
1009    }
1010
1011    // Release the buffer back to the recording queue
1012
1013    buffer_handle_t imgHandle = *(buffer_handle_t*)(data + 4);
1014
1015    size_t itemIndex;
1016    for (itemIndex = 0; itemIndex < mRecordingBuffers.size(); itemIndex++) {
1017        const BufferItemConsumer::BufferItem item = mRecordingBuffers[itemIndex];
1018        if (item.mBuf != BufferItemConsumer::INVALID_BUFFER_SLOT &&
1019                item.mGraphicBuffer->handle == imgHandle) {
1020            break;
1021        }
1022    }
1023    if (itemIndex == mRecordingBuffers.size()) {
1024        ALOGE("%s: Camera %d: Can't find buffer_handle_t %p in list of "
1025                "outstanding buffers", __FUNCTION__, mCameraId, imgHandle);
1026        return;
1027    }
1028
1029    ALOGV("%s: Camera %d: Freeing buffer_handle_t %p", __FUNCTION__, mCameraId,
1030            imgHandle);
1031
1032    res = mRecordingConsumer->releaseBuffer(mRecordingBuffers[itemIndex]);
1033    if (res != OK) {
1034        ALOGE("%s: Camera %d: Unable to free recording frame (buffer_handle_t: %p):"
1035                "%s (%d)",
1036                __FUNCTION__, mCameraId, imgHandle, strerror(-res), res);
1037        return;
1038    }
1039    mRecordingBuffers.replaceAt(itemIndex);
1040
1041    mRecordingHeapFree++;
1042}
1043
1044status_t Camera2Client::autoFocus() {
1045    ATRACE_CALL();
1046    Mutex::Autolock icl(mICameraLock);
1047    status_t res;
1048    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1049
1050    int triggerId;
1051    {
1052        SharedParameters::Lock l(mParameters);
1053        l.mParameters.currentAfTriggerId = ++l.mParameters.afTriggerCounter;
1054        triggerId = l.mParameters.currentAfTriggerId;
1055    }
1056
1057    mDevice->triggerAutofocus(triggerId);
1058
1059    return OK;
1060}
1061
1062status_t Camera2Client::cancelAutoFocus() {
1063    ATRACE_CALL();
1064    Mutex::Autolock icl(mICameraLock);
1065    status_t res;
1066    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1067
1068    int triggerId;
1069    {
1070        SharedParameters::Lock l(mParameters);
1071        triggerId = ++l.mParameters.afTriggerCounter;
1072    }
1073
1074    mDevice->triggerCancelAutofocus(triggerId);
1075
1076    return OK;
1077}
1078
1079status_t Camera2Client::takePicture(int msgType) {
1080    ATRACE_CALL();
1081    Mutex::Autolock icl(mICameraLock);
1082    status_t res;
1083    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1084
1085    SharedParameters::Lock l(mParameters);
1086    switch (l.mParameters.state) {
1087        case Parameters::DISCONNECTED:
1088        case Parameters::STOPPED:
1089        case Parameters::WAITING_FOR_PREVIEW_WINDOW:
1090            ALOGE("%s: Camera %d: Cannot take picture without preview enabled",
1091                    __FUNCTION__, mCameraId);
1092            return INVALID_OPERATION;
1093        case Parameters::PREVIEW:
1094            // Good to go for takePicture
1095            res = commandStopFaceDetectionL(l.mParameters);
1096            if (res != OK) {
1097                ALOGE("%s: Camera %d: Unable to stop face detection for still capture",
1098                        __FUNCTION__, mCameraId);
1099                return res;
1100            }
1101            l.mParameters.state = Parameters::STILL_CAPTURE;
1102            break;
1103        case Parameters::RECORD:
1104            // Good to go for video snapshot
1105            l.mParameters.state = Parameters::VIDEO_SNAPSHOT;
1106            break;
1107        case Parameters::STILL_CAPTURE:
1108        case Parameters::VIDEO_SNAPSHOT:
1109            ALOGE("%s: Camera %d: Already taking a picture",
1110                    __FUNCTION__, mCameraId);
1111            return INVALID_OPERATION;
1112    }
1113
1114    ALOGV("%s: Camera %d: Starting picture capture", __FUNCTION__, mCameraId);
1115
1116    res = mJpegProcessor->updateStream(l.mParameters);
1117    if (res != OK) {
1118        ALOGE("%s: Camera %d: Can't set up still image stream: %s (%d)",
1119                __FUNCTION__, mCameraId, strerror(-res), res);
1120        return res;
1121    }
1122
1123    res = mCaptureSequencer->startCapture();
1124    if (res != OK) {
1125        ALOGE("%s: Camera %d: Unable to start capture: %s (%d)",
1126                __FUNCTION__, mCameraId, strerror(-res), res);
1127    }
1128
1129    return res;
1130}
1131
1132status_t Camera2Client::setParameters(const String8& params) {
1133    ATRACE_CALL();
1134    ALOGV("%s: E", __FUNCTION__);
1135    Mutex::Autolock icl(mICameraLock);
1136    status_t res;
1137    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1138
1139    SharedParameters::Lock l(mParameters);
1140
1141    res = l.mParameters.set(params);
1142    if (res != OK) return res;
1143
1144    res = updateRequests(l.mParameters);
1145
1146    return res;
1147}
1148
1149String8 Camera2Client::getParameters() const {
1150    ATRACE_CALL();
1151    Mutex::Autolock icl(mICameraLock);
1152    if ( checkPid(__FUNCTION__) != OK) return String8();
1153
1154    SharedParameters::ReadLock l(mParameters);
1155
1156    // TODO: Deal with focus distances
1157    return l.mParameters.paramsFlattened;
1158}
1159
1160status_t Camera2Client::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) {
1161    ATRACE_CALL();
1162    Mutex::Autolock icl(mICameraLock);
1163    status_t res;
1164    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1165
1166    ALOGV("%s: Camera %d: Command %d (%d, %d)", __FUNCTION__, mCameraId,
1167            cmd, arg1, arg2);
1168
1169    switch (cmd) {
1170        case CAMERA_CMD_START_SMOOTH_ZOOM:
1171            return commandStartSmoothZoomL();
1172        case CAMERA_CMD_STOP_SMOOTH_ZOOM:
1173            return commandStopSmoothZoomL();
1174        case CAMERA_CMD_SET_DISPLAY_ORIENTATION:
1175            return commandSetDisplayOrientationL(arg1);
1176        case CAMERA_CMD_ENABLE_SHUTTER_SOUND:
1177            return commandEnableShutterSoundL(arg1 == 1);
1178        case CAMERA_CMD_PLAY_RECORDING_SOUND:
1179            return commandPlayRecordingSoundL();
1180        case CAMERA_CMD_START_FACE_DETECTION:
1181            return commandStartFaceDetectionL(arg1);
1182        case CAMERA_CMD_STOP_FACE_DETECTION: {
1183            SharedParameters::Lock l(mParameters);
1184            return commandStopFaceDetectionL(l.mParameters);
1185        }
1186        case CAMERA_CMD_ENABLE_FOCUS_MOVE_MSG:
1187            return commandEnableFocusMoveMsgL(arg1 == 1);
1188        case CAMERA_CMD_PING:
1189            return commandPingL();
1190        case CAMERA_CMD_SET_VIDEO_BUFFER_COUNT:
1191            return commandSetVideoBufferCountL(arg1);
1192        default:
1193            ALOGE("%s: Unknown command %d (arguments %d, %d)",
1194                    __FUNCTION__, cmd, arg1, arg2);
1195            return BAD_VALUE;
1196    }
1197}
1198
1199status_t Camera2Client::commandStartSmoothZoomL() {
1200    ALOGE("%s: Unimplemented!", __FUNCTION__);
1201    return OK;
1202}
1203
1204status_t Camera2Client::commandStopSmoothZoomL() {
1205    ALOGE("%s: Unimplemented!", __FUNCTION__);
1206    return OK;
1207}
1208
1209status_t Camera2Client::commandSetDisplayOrientationL(int degrees) {
1210    int transform = Parameters::degToTransform(degrees,
1211            mCameraFacing == CAMERA_FACING_FRONT);
1212    if (transform == -1) {
1213        ALOGE("%s: Camera %d: Error setting %d as display orientation value",
1214                __FUNCTION__, mCameraId, degrees);
1215        return BAD_VALUE;
1216    }
1217    SharedParameters::Lock l(mParameters);
1218    if (transform != l.mParameters.previewTransform &&
1219            mPreviewStreamId != NO_STREAM) {
1220        mDevice->setStreamTransform(mPreviewStreamId, transform);
1221    }
1222    l.mParameters.previewTransform = transform;
1223    return OK;
1224}
1225
1226status_t Camera2Client::commandEnableShutterSoundL(bool enable) {
1227    SharedParameters::Lock l(mParameters);
1228    if (enable) {
1229        l.mParameters.playShutterSound = true;
1230        return OK;
1231    }
1232
1233    // Disabling shutter sound may not be allowed. In that case only
1234    // allow the mediaserver process to disable the sound.
1235    char value[PROPERTY_VALUE_MAX];
1236    property_get("ro.camera.sound.forced", value, "0");
1237    if (strncmp(value, "0", 2) != 0) {
1238        // Disabling shutter sound is not allowed. Deny if the current
1239        // process is not mediaserver.
1240        if (getCallingPid() != getpid()) {
1241            ALOGE("Failed to disable shutter sound. Permission denied (pid %d)",
1242                    getCallingPid());
1243            return PERMISSION_DENIED;
1244        }
1245    }
1246
1247    l.mParameters.playShutterSound = false;
1248    return OK;
1249}
1250
1251status_t Camera2Client::commandPlayRecordingSoundL() {
1252    mCameraService->playSound(CameraService::SOUND_RECORDING);
1253    return OK;
1254}
1255
1256status_t Camera2Client::commandStartFaceDetectionL(int type) {
1257    ALOGV("%s: Camera %d: Starting face detection",
1258          __FUNCTION__, mCameraId);
1259    status_t res;
1260    SharedParameters::Lock l(mParameters);
1261    switch (l.mParameters.state) {
1262        case Parameters::DISCONNECTED:
1263        case Parameters::STOPPED:
1264        case Parameters::WAITING_FOR_PREVIEW_WINDOW:
1265        case Parameters::STILL_CAPTURE:
1266            ALOGE("%s: Camera %d: Cannot start face detection without preview active",
1267                    __FUNCTION__, mCameraId);
1268            return INVALID_OPERATION;
1269        case Parameters::PREVIEW:
1270        case Parameters::RECORD:
1271        case Parameters::VIDEO_SNAPSHOT:
1272            // Good to go for starting face detect
1273            break;
1274    }
1275    // Ignoring type
1276    if (l.mParameters.fastInfo.bestFaceDetectMode ==
1277            ANDROID_STATS_FACE_DETECTION_OFF) {
1278        ALOGE("%s: Camera %d: Face detection not supported",
1279                __FUNCTION__, mCameraId);
1280        return INVALID_OPERATION;
1281    }
1282    if (l.mParameters.enableFaceDetect) return OK;
1283
1284    l.mParameters.enableFaceDetect = true;
1285
1286    res = updateRequests(l.mParameters);
1287
1288    return res;
1289}
1290
1291status_t Camera2Client::commandStopFaceDetectionL(Parameters &params) {
1292    status_t res = OK;
1293    ALOGV("%s: Camera %d: Stopping face detection",
1294          __FUNCTION__, mCameraId);
1295
1296    if (!params.enableFaceDetect) return OK;
1297
1298    params.enableFaceDetect = false;
1299
1300    if (params.state == Parameters::PREVIEW
1301            || params.state == Parameters::RECORD
1302            || params.state == Parameters::VIDEO_SNAPSHOT) {
1303        res = updateRequests(params);
1304    }
1305
1306    return res;
1307}
1308
1309status_t Camera2Client::commandEnableFocusMoveMsgL(bool enable) {
1310    SharedParameters::Lock l(mParameters);
1311    l.mParameters.enableFocusMoveMessages = enable;
1312
1313    return OK;
1314}
1315
1316status_t Camera2Client::commandPingL() {
1317    // Always ping back if access is proper and device is alive
1318    SharedParameters::Lock l(mParameters);
1319    if (l.mParameters.state != Parameters::DISCONNECTED) {
1320        return OK;
1321    } else {
1322        return NO_INIT;
1323    }
1324}
1325
1326status_t Camera2Client::commandSetVideoBufferCountL(size_t count) {
1327    if (recordingEnabledL()) {
1328        ALOGE("%s: Camera %d: Error setting video buffer count after "
1329                "recording was started", __FUNCTION__, mCameraId);
1330        return INVALID_OPERATION;
1331    }
1332
1333    // 32 is the current upper limit on the video buffer count for BufferQueue
1334    if (count > 32) {
1335        ALOGE("%s: Camera %d: Error setting %d as video buffer count value",
1336                __FUNCTION__, mCameraId, count);
1337        return BAD_VALUE;
1338    }
1339
1340    // Need to reallocate memory for heap
1341    if (mRecordingHeapCount != count) {
1342        if  (mRecordingHeap != 0) {
1343            mRecordingHeap.clear();
1344            mRecordingHeap = NULL;
1345        }
1346        mRecordingHeapCount = count;
1347    }
1348
1349    return OK;
1350}
1351
1352/** Device-related methods */
1353
1354void Camera2Client::notifyError(int errorCode, int arg1, int arg2) {
1355    ALOGE("Error condition %d reported by HAL, arguments %d, %d", errorCode, arg1, arg2);
1356}
1357
1358void Camera2Client::notifyShutter(int frameNumber, nsecs_t timestamp) {
1359    ALOGV("%s: Shutter notification for frame %d at time %lld", __FUNCTION__,
1360            frameNumber, timestamp);
1361}
1362
1363void Camera2Client::notifyAutoFocus(uint8_t newState, int triggerId) {
1364    ALOGV("%s: Autofocus state now %d, last trigger %d",
1365            __FUNCTION__, newState, triggerId);
1366    bool sendCompletedMessage = false;
1367    bool sendMovingMessage = false;
1368
1369    bool success = false;
1370    bool afInMotion = false;
1371    {
1372        SharedParameters::Lock l(mParameters);
1373        switch (l.mParameters.focusMode) {
1374            case Parameters::FOCUS_MODE_AUTO:
1375            case Parameters::FOCUS_MODE_MACRO:
1376                // Don't send notifications upstream if they're not for the current AF
1377                // trigger. For example, if cancel was called in between, or if we
1378                // already sent a notification about this AF call.
1379                if (triggerId != l.mParameters.currentAfTriggerId) break;
1380                switch (newState) {
1381                    case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED:
1382                        success = true;
1383                        // no break
1384                    case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED:
1385                        sendCompletedMessage = true;
1386                        l.mParameters.currentAfTriggerId = -1;
1387                        break;
1388                    case ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN:
1389                        // Just starting focusing, ignore
1390                        break;
1391                    case ANDROID_CONTROL_AF_STATE_INACTIVE:
1392                    case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN:
1393                    case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED:
1394                    default:
1395                        // Unexpected in AUTO/MACRO mode
1396                        ALOGE("%s: Unexpected AF state transition in AUTO/MACRO mode: %d",
1397                                __FUNCTION__, newState);
1398                        break;
1399                }
1400                break;
1401            case Parameters::FOCUS_MODE_CONTINUOUS_VIDEO:
1402            case Parameters::FOCUS_MODE_CONTINUOUS_PICTURE:
1403                switch (newState) {
1404                    case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED:
1405                        success = true;
1406                        // no break
1407                    case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED:
1408                        // Don't send notifications upstream if they're not for
1409                        // the current AF trigger. For example, if cancel was
1410                        // called in between, or if we already sent a
1411                        // notification about this AF call.
1412                        // Send both a 'AF done' callback and a 'AF move' callback
1413                        if (triggerId != l.mParameters.currentAfTriggerId) break;
1414                        sendCompletedMessage = true;
1415                        afInMotion = false;
1416                        if (l.mParameters.enableFocusMoveMessages &&
1417                                l.mParameters.afInMotion) {
1418                            sendMovingMessage = true;
1419                        }
1420                        l.mParameters.currentAfTriggerId = -1;
1421                        break;
1422                    case ANDROID_CONTROL_AF_STATE_INACTIVE:
1423                        // Cancel was called, or we switched state; care if
1424                        // currently moving
1425                        afInMotion = false;
1426                        if (l.mParameters.enableFocusMoveMessages &&
1427                                l.mParameters.afInMotion) {
1428                            sendMovingMessage = true;
1429                        }
1430                        break;
1431                    case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN:
1432                        // Start passive scan, inform upstream
1433                        afInMotion = true;
1434                        // no break
1435                    case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED:
1436                        // Stop passive scan, inform upstream
1437                        if (l.mParameters.enableFocusMoveMessages) {
1438                            sendMovingMessage = true;
1439                        }
1440                        break;
1441                }
1442                l.mParameters.afInMotion = afInMotion;
1443                break;
1444            case Parameters::FOCUS_MODE_EDOF:
1445            case Parameters::FOCUS_MODE_INFINITY:
1446            case Parameters::FOCUS_MODE_FIXED:
1447            default:
1448                if (newState != ANDROID_CONTROL_AF_STATE_INACTIVE) {
1449                    ALOGE("%s: Unexpected AF state change %d "
1450                            "(ID %d) in focus mode %d",
1451                          __FUNCTION__, newState, triggerId,
1452                            l.mParameters.focusMode);
1453                }
1454        }
1455    }
1456    if (sendMovingMessage) {
1457        SharedCameraClient::Lock l(mSharedCameraClient);
1458        if (l.mCameraClient != 0) {
1459            l.mCameraClient->notifyCallback(CAMERA_MSG_FOCUS_MOVE,
1460                    afInMotion ? 1 : 0, 0);
1461        }
1462    }
1463    if (sendCompletedMessage) {
1464        SharedCameraClient::Lock l(mSharedCameraClient);
1465        if (l.mCameraClient != 0) {
1466            l.mCameraClient->notifyCallback(CAMERA_MSG_FOCUS,
1467                    success ? 1 : 0, 0);
1468        }
1469    }
1470}
1471
1472void Camera2Client::notifyAutoExposure(uint8_t newState, int triggerId) {
1473    ALOGV("%s: Autoexposure state now %d, last trigger %d",
1474            __FUNCTION__, newState, triggerId);
1475    mCaptureSequencer->notifyAutoExposure(newState, triggerId);
1476}
1477
1478void Camera2Client::notifyAutoWhitebalance(uint8_t newState, int triggerId) {
1479    ALOGV("%s: Auto-whitebalance state now %d, last trigger %d",
1480            __FUNCTION__, newState, triggerId);
1481}
1482
1483int Camera2Client::getCameraId() const {
1484    return mCameraId;
1485}
1486
1487const sp<Camera2Device>& Camera2Client::getCameraDevice() {
1488    return mDevice;
1489}
1490
1491const sp<CameraService>& Camera2Client::getCameraService() {
1492    return mCameraService;
1493}
1494
1495camera2::SharedParameters& Camera2Client::getParameters() {
1496    return mParameters;
1497}
1498
1499int Camera2Client::getPreviewStreamId() const {
1500    return mPreviewStreamId;
1501}
1502
1503int Camera2Client::getCaptureStreamId() const {
1504    return mJpegProcessor->getStreamId();
1505}
1506
1507int Camera2Client::getCallbackStreamId() const {
1508    return mCallbackProcessor->getStreamId();
1509}
1510
1511int Camera2Client::getRecordingStreamId() const {
1512    return mRecordingStreamId;
1513}
1514
1515int Camera2Client::getZslStreamId() const {
1516    return mZslProcessor->getStreamId();
1517}
1518
1519status_t Camera2Client::registerFrameListener(int32_t id,
1520        wp<camera2::FrameProcessor::FilteredListener> listener) {
1521    return mFrameProcessor->registerListener(id, listener);
1522}
1523
1524status_t Camera2Client::removeFrameListener(int32_t id) {
1525    return mFrameProcessor->removeListener(id);
1526}
1527
1528Camera2Client::SharedCameraClient::Lock::Lock(SharedCameraClient &client):
1529        mCameraClient(client.mCameraClient),
1530        mSharedClient(client) {
1531    mSharedClient.mCameraClientLock.lock();
1532}
1533
1534Camera2Client::SharedCameraClient::Lock::~Lock() {
1535    mSharedClient.mCameraClientLock.unlock();
1536}
1537
1538Camera2Client::SharedCameraClient::SharedCameraClient(const sp<ICameraClient>&client):
1539        mCameraClient(client) {
1540}
1541
1542Camera2Client::SharedCameraClient& Camera2Client::SharedCameraClient::operator=(
1543        const sp<ICameraClient>&client) {
1544    Mutex::Autolock l(mCameraClientLock);
1545    mCameraClient = client;
1546    return *this;
1547}
1548
1549void Camera2Client::SharedCameraClient::clear() {
1550    Mutex::Autolock l(mCameraClientLock);
1551    mCameraClient.clear();
1552}
1553
1554const int32_t Camera2Client::kPreviewRequestId;
1555const int32_t Camera2Client::kRecordRequestId;
1556const int32_t Camera2Client::kFirstCaptureRequestId;
1557
1558void Camera2Client::onRecordingFrameAvailable() {
1559    ATRACE_CALL();
1560    status_t res;
1561    sp<Camera2Heap> recordingHeap;
1562    size_t heapIdx = 0;
1563    nsecs_t timestamp;
1564    {
1565        SharedParameters::Lock l(mParameters);
1566
1567        BufferItemConsumer::BufferItem imgBuffer;
1568        res = mRecordingConsumer->acquireBuffer(&imgBuffer);
1569        if (res != OK) {
1570            ALOGE("%s: Camera %d: Error receiving recording buffer: %s (%d)",
1571                    __FUNCTION__, mCameraId, strerror(-res), res);
1572            return;
1573        }
1574        timestamp = imgBuffer.mTimestamp;
1575
1576        mRecordingFrameCount++;
1577        ALOGV("OnRecordingFrame: Frame %d", mRecordingFrameCount);
1578
1579        // TODO: Signal errors here upstream
1580        if (l.mParameters.state != Parameters::RECORD &&
1581                l.mParameters.state != Parameters::VIDEO_SNAPSHOT) {
1582            ALOGV("%s: Camera %d: Discarding recording image buffers received after "
1583                    "recording done",
1584                    __FUNCTION__, mCameraId);
1585            mRecordingConsumer->releaseBuffer(imgBuffer);
1586            return;
1587        }
1588
1589        if (mRecordingHeap == 0) {
1590            const size_t bufferSize = 4 + sizeof(buffer_handle_t);
1591            ALOGV("%s: Camera %d: Creating recording heap with %d buffers of "
1592                    "size %d bytes", __FUNCTION__, mCameraId,
1593                    mRecordingHeapCount, bufferSize);
1594
1595            mRecordingHeap = new Camera2Heap(bufferSize, mRecordingHeapCount,
1596                    "Camera2Client::RecordingHeap");
1597            if (mRecordingHeap->mHeap->getSize() == 0) {
1598                ALOGE("%s: Camera %d: Unable to allocate memory for recording",
1599                        __FUNCTION__, mCameraId);
1600                mRecordingConsumer->releaseBuffer(imgBuffer);
1601                return;
1602            }
1603            for (size_t i = 0; i < mRecordingBuffers.size(); i++) {
1604                if (mRecordingBuffers[i].mBuf !=
1605                        BufferItemConsumer::INVALID_BUFFER_SLOT) {
1606                    ALOGE("%s: Camera %d: Non-empty recording buffers list!",
1607                            __FUNCTION__, mCameraId);
1608                }
1609            }
1610            mRecordingBuffers.clear();
1611            mRecordingBuffers.setCapacity(mRecordingHeapCount);
1612            mRecordingBuffers.insertAt(0, mRecordingHeapCount);
1613
1614            mRecordingHeapHead = 0;
1615            mRecordingHeapFree = mRecordingHeapCount;
1616        }
1617
1618        if ( mRecordingHeapFree == 0) {
1619            ALOGE("%s: Camera %d: No free recording buffers, dropping frame",
1620                    __FUNCTION__, mCameraId);
1621            mRecordingConsumer->releaseBuffer(imgBuffer);
1622            return;
1623        }
1624
1625        heapIdx = mRecordingHeapHead;
1626        mRecordingHeapHead = (mRecordingHeapHead + 1) % mRecordingHeapCount;
1627        mRecordingHeapFree--;
1628
1629        ALOGV("%s: Camera %d: Timestamp %lld",
1630                __FUNCTION__, mCameraId, timestamp);
1631
1632        ssize_t offset;
1633        size_t size;
1634        sp<IMemoryHeap> heap =
1635                mRecordingHeap->mBuffers[heapIdx]->getMemory(&offset,
1636                        &size);
1637
1638        uint8_t *data = (uint8_t*)heap->getBase() + offset;
1639        uint32_t type = kMetadataBufferTypeGrallocSource;
1640        *((uint32_t*)data) = type;
1641        *((buffer_handle_t*)(data + 4)) = imgBuffer.mGraphicBuffer->handle;
1642        ALOGV("%s: Camera %d: Sending out buffer_handle_t %p",
1643                __FUNCTION__, mCameraId, imgBuffer.mGraphicBuffer->handle);
1644        mRecordingBuffers.replaceAt(imgBuffer, heapIdx);
1645        recordingHeap = mRecordingHeap;
1646    }
1647
1648    // Call outside locked parameters to allow re-entrancy from notification
1649    SharedCameraClient::Lock l(mSharedCameraClient);
1650    if (l.mCameraClient != 0) {
1651        l.mCameraClient->dataCallbackTimestamp(timestamp,
1652                CAMERA_MSG_VIDEO_FRAME,
1653                recordingHeap->mBuffers[heapIdx]);
1654    }
1655}
1656
1657/** Utility methods */
1658
1659status_t Camera2Client::updateRequests(Parameters &params) {
1660    status_t res;
1661
1662    res = updatePreviewRequest(params);
1663    if (res != OK) {
1664        ALOGE("%s: Camera %d: Unable to update preview request: %s (%d)",
1665                __FUNCTION__, mCameraId, strerror(-res), res);
1666        return res;
1667    }
1668    res = updateRecordingRequest(params);
1669    if (res != OK) {
1670        ALOGE("%s: Camera %d: Unable to update recording request: %s (%d)",
1671                __FUNCTION__, mCameraId, strerror(-res), res);
1672        return res;
1673    }
1674
1675    if (params.state == Parameters::PREVIEW) {
1676        res = startPreviewL(params, true);
1677        if (res != OK) {
1678            ALOGE("%s: Camera %d: Error streaming new preview request: %s (%d)",
1679                    __FUNCTION__, mCameraId, strerror(-res), res);
1680            return res;
1681        }
1682    } else if (params.state == Parameters::RECORD ||
1683            params.state == Parameters::VIDEO_SNAPSHOT) {
1684        res = mDevice->setStreamingRequest(mRecordingRequest);
1685        if (res != OK) {
1686            ALOGE("%s: Camera %d: Error streaming new record request: %s (%d)",
1687                    __FUNCTION__, mCameraId, strerror(-res), res);
1688            return res;
1689        }
1690    }
1691    return res;
1692}
1693
1694status_t Camera2Client::updatePreviewStream(const Parameters &params) {
1695    ATRACE_CALL();
1696    status_t res;
1697
1698    if (mPreviewStreamId != NO_STREAM) {
1699        // Check if stream parameters have to change
1700        uint32_t currentWidth, currentHeight;
1701        res = mDevice->getStreamInfo(mPreviewStreamId,
1702                &currentWidth, &currentHeight, 0);
1703        if (res != OK) {
1704            ALOGE("%s: Camera %d: Error querying preview stream info: "
1705                    "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
1706            return res;
1707        }
1708        if (currentWidth != (uint32_t)params.previewWidth ||
1709                currentHeight != (uint32_t)params.previewHeight) {
1710            ALOGV("%s: Camera %d: Preview size switch: %d x %d -> %d x %d",
1711                    __FUNCTION__, mCameraId, currentWidth, currentHeight,
1712                    params.previewWidth, params.previewHeight);
1713            res = mDevice->waitUntilDrained();
1714            if (res != OK) {
1715                ALOGE("%s: Camera %d: Error waiting for preview to drain: "
1716                        "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
1717                return res;
1718            }
1719            res = mDevice->deleteStream(mPreviewStreamId);
1720            if (res != OK) {
1721                ALOGE("%s: Camera %d: Unable to delete old output stream "
1722                        "for preview: %s (%d)", __FUNCTION__, mCameraId,
1723                        strerror(-res), res);
1724                return res;
1725            }
1726            mPreviewStreamId = NO_STREAM;
1727        }
1728    }
1729
1730    if (mPreviewStreamId == NO_STREAM) {
1731        res = mDevice->createStream(mPreviewWindow,
1732                params.previewWidth, params.previewHeight,
1733                CAMERA2_HAL_PIXEL_FORMAT_OPAQUE, 0,
1734                &mPreviewStreamId);
1735        if (res != OK) {
1736            ALOGE("%s: Camera %d: Unable to create preview stream: %s (%d)",
1737                    __FUNCTION__, mCameraId, strerror(-res), res);
1738            return res;
1739        }
1740    }
1741
1742    res = mDevice->setStreamTransform(mPreviewStreamId,
1743            params.previewTransform);
1744    if (res != OK) {
1745        ALOGE("%s: Camera %d: Unable to set preview stream transform: "
1746                "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
1747        return res;
1748    }
1749
1750    return OK;
1751}
1752
1753status_t Camera2Client::updatePreviewRequest(const Parameters &params) {
1754    ATRACE_CALL();
1755    status_t res;
1756    if (mPreviewRequest.entryCount() == 0) {
1757        res = mDevice->createDefaultRequest(CAMERA2_TEMPLATE_PREVIEW,
1758                &mPreviewRequest);
1759        if (res != OK) {
1760            ALOGE("%s: Camera %d: Unable to create default preview request: "
1761                    "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
1762            return res;
1763        }
1764    }
1765
1766    res = params.updateRequest(&mPreviewRequest);
1767    if (res != OK) {
1768        ALOGE("%s: Camera %d: Unable to update common entries of preview "
1769                "request: %s (%d)", __FUNCTION__, mCameraId,
1770                strerror(-res), res);
1771        return res;
1772    }
1773
1774    res = mPreviewRequest.update(ANDROID_REQUEST_ID,
1775            &kPreviewRequestId, 1);
1776
1777    return OK;
1778}
1779
1780status_t Camera2Client::updateRecordingRequest(const Parameters &params) {
1781    ATRACE_CALL();
1782    status_t res;
1783    if (mRecordingRequest.entryCount() == 0) {
1784        res = mDevice->createDefaultRequest(CAMERA2_TEMPLATE_VIDEO_RECORD,
1785                &mRecordingRequest);
1786        if (res != OK) {
1787            ALOGE("%s: Camera %d: Unable to create default recording request:"
1788                    " %s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
1789            return res;
1790        }
1791    }
1792
1793    res = params.updateRequest(&mRecordingRequest);
1794    if (res != OK) {
1795        ALOGE("%s: Camera %d: Unable to update common entries of recording "
1796                "request: %s (%d)", __FUNCTION__, mCameraId,
1797                strerror(-res), res);
1798        return res;
1799    }
1800
1801    return OK;
1802}
1803
1804status_t Camera2Client::updateRecordingStream(const Parameters &params) {
1805    status_t res;
1806
1807    if (mRecordingConsumer == 0) {
1808        // Create CPU buffer queue endpoint. We need one more buffer here so that we can
1809        // always acquire and free a buffer when the heap is full; otherwise the consumer
1810        // will have buffers in flight we'll never clear out.
1811        mRecordingConsumer = new BufferItemConsumer(
1812                GRALLOC_USAGE_HW_VIDEO_ENCODER,
1813                mRecordingHeapCount + 1,
1814                true);
1815        mRecordingConsumer->setFrameAvailableListener(new RecordingWaiter(this));
1816        mRecordingConsumer->setName(String8("Camera2Client::RecordingConsumer"));
1817        mRecordingWindow = new SurfaceTextureClient(
1818            mRecordingConsumer->getProducerInterface());
1819        // Allocate memory later, since we don't know buffer size until receipt
1820    }
1821
1822    if (mRecordingStreamId != NO_STREAM) {
1823        // Check if stream parameters have to change
1824        uint32_t currentWidth, currentHeight;
1825        res = mDevice->getStreamInfo(mRecordingStreamId,
1826                &currentWidth, &currentHeight, 0);
1827        if (res != OK) {
1828            ALOGE("%s: Camera %d: Error querying recording output stream info: "
1829                    "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
1830            return res;
1831        }
1832        if (currentWidth != (uint32_t)params.videoWidth ||
1833                currentHeight != (uint32_t)params.videoHeight) {
1834            // TODO: Should wait to be sure previous recording has finished
1835            res = mDevice->deleteStream(mRecordingStreamId);
1836            if (res != OK) {
1837                ALOGE("%s: Camera %d: Unable to delete old output stream "
1838                        "for recording: %s (%d)", __FUNCTION__, mCameraId,
1839                        strerror(-res), res);
1840                return res;
1841            }
1842            mRecordingStreamId = NO_STREAM;
1843        }
1844    }
1845
1846    if (mRecordingStreamId == NO_STREAM) {
1847        mRecordingFrameCount = 0;
1848        res = mDevice->createStream(mRecordingWindow,
1849                params.videoWidth, params.videoHeight,
1850                CAMERA2_HAL_PIXEL_FORMAT_OPAQUE, 0, &mRecordingStreamId);
1851        if (res != OK) {
1852            ALOGE("%s: Camera %d: Can't create output stream for recording: "
1853                    "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
1854            return res;
1855        }
1856    }
1857
1858    return OK;
1859}
1860
1861size_t Camera2Client::calculateBufferSize(int width, int height,
1862        int format, int stride) {
1863    switch (format) {
1864        case HAL_PIXEL_FORMAT_YCbCr_422_SP: // NV16
1865            return width * height * 2;
1866        case HAL_PIXEL_FORMAT_YCrCb_420_SP: // NV21
1867            return width * height * 3 / 2;
1868        case HAL_PIXEL_FORMAT_YCbCr_422_I: // YUY2
1869            return width * height * 2;
1870        case HAL_PIXEL_FORMAT_YV12: {      // YV12
1871            size_t ySize = stride * height;
1872            size_t uvStride = (stride / 2 + 0xF) & ~0xF;
1873            size_t uvSize = uvStride * height / 2;
1874            return ySize + uvSize * 2;
1875        }
1876        case HAL_PIXEL_FORMAT_RGB_565:
1877            return width * height * 2;
1878        case HAL_PIXEL_FORMAT_RGBA_8888:
1879            return width * height * 4;
1880        case HAL_PIXEL_FORMAT_RAW_SENSOR:
1881            return width * height * 2;
1882        default:
1883            ALOGE("%s: Unknown preview format: %x",
1884                    __FUNCTION__,  format);
1885            return 0;
1886    }
1887}
1888
1889} // namespace android
1890