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