Camera2Client.cpp revision 4865c526e681366481b0ab242ffa1ead57bb02cc 
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        l.mParameters.currentAfTriggerId = ++l.mParameters.afTriggerCounter;
960        triggerId = l.mParameters.currentAfTriggerId;
961    }
962    syncWithDevice();
963
964    mDevice->triggerAutofocus(triggerId);
965
966    return OK;
967}
968
969status_t Camera2Client::cancelAutoFocus() {
970    ATRACE_CALL();
971    Mutex::Autolock icl(mICameraLock);
972    ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
973    status_t res;
974    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
975
976    int triggerId;
977    {
978        SharedParameters::Lock l(mParameters);
979        triggerId = ++l.mParameters.afTriggerCounter;
980    }
981    syncWithDevice();
982
983    mDevice->triggerCancelAutofocus(triggerId);
984
985    return OK;
986}
987
988status_t Camera2Client::takePicture(int msgType) {
989    ATRACE_CALL();
990    Mutex::Autolock icl(mICameraLock);
991    status_t res;
992    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
993
994    SharedParameters::Lock l(mParameters);
995    switch (l.mParameters.state) {
996        case Parameters::DISCONNECTED:
997        case Parameters::STOPPED:
998        case Parameters::WAITING_FOR_PREVIEW_WINDOW:
999            ALOGE("%s: Camera %d: Cannot take picture without preview enabled",
1000                    __FUNCTION__, mCameraId);
1001            return INVALID_OPERATION;
1002        case Parameters::PREVIEW:
1003            // Good to go for takePicture
1004            res = commandStopFaceDetectionL(l.mParameters);
1005            if (res != OK) {
1006                ALOGE("%s: Camera %d: Unable to stop face detection for still capture",
1007                        __FUNCTION__, mCameraId);
1008                return res;
1009            }
1010            l.mParameters.state = Parameters::STILL_CAPTURE;
1011            break;
1012        case Parameters::RECORD:
1013            // Good to go for video snapshot
1014            l.mParameters.state = Parameters::VIDEO_SNAPSHOT;
1015            break;
1016        case Parameters::STILL_CAPTURE:
1017        case Parameters::VIDEO_SNAPSHOT:
1018            ALOGE("%s: Camera %d: Already taking a picture",
1019                    __FUNCTION__, mCameraId);
1020            return INVALID_OPERATION;
1021    }
1022
1023    ALOGV("%s: Camera %d: Starting picture capture", __FUNCTION__, mCameraId);
1024
1025    res = mJpegProcessor->updateStream(l.mParameters);
1026    if (res != OK) {
1027        ALOGE("%s: Camera %d: Can't set up still image stream: %s (%d)",
1028                __FUNCTION__, mCameraId, strerror(-res), res);
1029        return res;
1030    }
1031
1032    // Need HAL to have correct settings before (possibly) triggering precapture
1033    syncWithDevice();
1034
1035    res = mCaptureSequencer->startCapture();
1036    if (res != OK) {
1037        ALOGE("%s: Camera %d: Unable to start capture: %s (%d)",
1038                __FUNCTION__, mCameraId, strerror(-res), res);
1039    }
1040
1041    return res;
1042}
1043
1044status_t Camera2Client::setParameters(const String8& params) {
1045    ATRACE_CALL();
1046    ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
1047    Mutex::Autolock icl(mICameraLock);
1048    status_t res;
1049    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1050
1051    SharedParameters::Lock l(mParameters);
1052
1053    res = l.mParameters.set(params);
1054    if (res != OK) return res;
1055
1056    res = updateRequests(l.mParameters);
1057
1058    return res;
1059}
1060
1061String8 Camera2Client::getParameters() const {
1062    ATRACE_CALL();
1063    ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
1064    Mutex::Autolock icl(mICameraLock);
1065    if ( checkPid(__FUNCTION__) != OK) return String8();
1066
1067    SharedParameters::ReadLock l(mParameters);
1068
1069    return l.mParameters.get();
1070}
1071
1072status_t Camera2Client::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) {
1073    ATRACE_CALL();
1074    Mutex::Autolock icl(mICameraLock);
1075    status_t res;
1076    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1077
1078    ALOGV("%s: Camera %d: Command %d (%d, %d)", __FUNCTION__, mCameraId,
1079            cmd, arg1, arg2);
1080
1081    switch (cmd) {
1082        case CAMERA_CMD_START_SMOOTH_ZOOM:
1083            return commandStartSmoothZoomL();
1084        case CAMERA_CMD_STOP_SMOOTH_ZOOM:
1085            return commandStopSmoothZoomL();
1086        case CAMERA_CMD_SET_DISPLAY_ORIENTATION:
1087            return commandSetDisplayOrientationL(arg1);
1088        case CAMERA_CMD_ENABLE_SHUTTER_SOUND:
1089            return commandEnableShutterSoundL(arg1 == 1);
1090        case CAMERA_CMD_PLAY_RECORDING_SOUND:
1091            return commandPlayRecordingSoundL();
1092        case CAMERA_CMD_START_FACE_DETECTION:
1093            return commandStartFaceDetectionL(arg1);
1094        case CAMERA_CMD_STOP_FACE_DETECTION: {
1095            SharedParameters::Lock l(mParameters);
1096            return commandStopFaceDetectionL(l.mParameters);
1097        }
1098        case CAMERA_CMD_ENABLE_FOCUS_MOVE_MSG:
1099            return commandEnableFocusMoveMsgL(arg1 == 1);
1100        case CAMERA_CMD_PING:
1101            return commandPingL();
1102        case CAMERA_CMD_SET_VIDEO_BUFFER_COUNT:
1103            return commandSetVideoBufferCountL(arg1);
1104        default:
1105            ALOGE("%s: Unknown command %d (arguments %d, %d)",
1106                    __FUNCTION__, cmd, arg1, arg2);
1107            return BAD_VALUE;
1108    }
1109}
1110
1111status_t Camera2Client::commandStartSmoothZoomL() {
1112    ALOGE("%s: Unimplemented!", __FUNCTION__);
1113    return OK;
1114}
1115
1116status_t Camera2Client::commandStopSmoothZoomL() {
1117    ALOGE("%s: Unimplemented!", __FUNCTION__);
1118    return OK;
1119}
1120
1121status_t Camera2Client::commandSetDisplayOrientationL(int degrees) {
1122    int transform = Parameters::degToTransform(degrees,
1123            mCameraFacing == CAMERA_FACING_FRONT);
1124    if (transform == -1) {
1125        ALOGE("%s: Camera %d: Error setting %d as display orientation value",
1126                __FUNCTION__, mCameraId, degrees);
1127        return BAD_VALUE;
1128    }
1129    SharedParameters::Lock l(mParameters);
1130    if (transform != l.mParameters.previewTransform &&
1131            getPreviewStreamId() != NO_STREAM) {
1132        mDevice->setStreamTransform(getPreviewStreamId(), transform);
1133    }
1134    l.mParameters.previewTransform = transform;
1135    return OK;
1136}
1137
1138status_t Camera2Client::commandEnableShutterSoundL(bool enable) {
1139    SharedParameters::Lock l(mParameters);
1140    if (enable) {
1141        l.mParameters.playShutterSound = true;
1142        return OK;
1143    }
1144
1145    // Disabling shutter sound may not be allowed. In that case only
1146    // allow the mediaserver process to disable the sound.
1147    char value[PROPERTY_VALUE_MAX];
1148    property_get("ro.camera.sound.forced", value, "0");
1149    if (strncmp(value, "0", 2) != 0) {
1150        // Disabling shutter sound is not allowed. Deny if the current
1151        // process is not mediaserver.
1152        if (getCallingPid() != getpid()) {
1153            ALOGE("Failed to disable shutter sound. Permission denied (pid %d)",
1154                    getCallingPid());
1155            return PERMISSION_DENIED;
1156        }
1157    }
1158
1159    l.mParameters.playShutterSound = false;
1160    return OK;
1161}
1162
1163status_t Camera2Client::commandPlayRecordingSoundL() {
1164    mCameraService->playSound(CameraService::SOUND_RECORDING);
1165    return OK;
1166}
1167
1168status_t Camera2Client::commandStartFaceDetectionL(int type) {
1169    ALOGV("%s: Camera %d: Starting face detection",
1170          __FUNCTION__, mCameraId);
1171    status_t res;
1172    SharedParameters::Lock l(mParameters);
1173    switch (l.mParameters.state) {
1174        case Parameters::DISCONNECTED:
1175        case Parameters::STOPPED:
1176        case Parameters::WAITING_FOR_PREVIEW_WINDOW:
1177        case Parameters::STILL_CAPTURE:
1178            ALOGE("%s: Camera %d: Cannot start face detection without preview active",
1179                    __FUNCTION__, mCameraId);
1180            return INVALID_OPERATION;
1181        case Parameters::PREVIEW:
1182        case Parameters::RECORD:
1183        case Parameters::VIDEO_SNAPSHOT:
1184            // Good to go for starting face detect
1185            break;
1186    }
1187    // Ignoring type
1188    if (l.mParameters.fastInfo.bestFaceDetectMode ==
1189            ANDROID_STATS_FACE_DETECTION_OFF) {
1190        ALOGE("%s: Camera %d: Face detection not supported",
1191                __FUNCTION__, mCameraId);
1192        return INVALID_OPERATION;
1193    }
1194    if (l.mParameters.enableFaceDetect) return OK;
1195
1196    l.mParameters.enableFaceDetect = true;
1197
1198    res = updateRequests(l.mParameters);
1199
1200    return res;
1201}
1202
1203status_t Camera2Client::commandStopFaceDetectionL(Parameters &params) {
1204    status_t res = OK;
1205    ALOGV("%s: Camera %d: Stopping face detection",
1206          __FUNCTION__, mCameraId);
1207
1208    if (!params.enableFaceDetect) return OK;
1209
1210    params.enableFaceDetect = false;
1211
1212    if (params.state == Parameters::PREVIEW
1213            || params.state == Parameters::RECORD
1214            || params.state == Parameters::VIDEO_SNAPSHOT) {
1215        res = updateRequests(params);
1216    }
1217
1218    return res;
1219}
1220
1221status_t Camera2Client::commandEnableFocusMoveMsgL(bool enable) {
1222    SharedParameters::Lock l(mParameters);
1223    l.mParameters.enableFocusMoveMessages = enable;
1224
1225    return OK;
1226}
1227
1228status_t Camera2Client::commandPingL() {
1229    // Always ping back if access is proper and device is alive
1230    SharedParameters::Lock l(mParameters);
1231    if (l.mParameters.state != Parameters::DISCONNECTED) {
1232        return OK;
1233    } else {
1234        return NO_INIT;
1235    }
1236}
1237
1238status_t Camera2Client::commandSetVideoBufferCountL(size_t count) {
1239    if (recordingEnabledL()) {
1240        ALOGE("%s: Camera %d: Error setting video buffer count after "
1241                "recording was started", __FUNCTION__, mCameraId);
1242        return INVALID_OPERATION;
1243    }
1244
1245    return mStreamingProcessor->setRecordingBufferCount(count);
1246}
1247
1248/** Device-related methods */
1249
1250void Camera2Client::notifyError(int errorCode, int arg1, int arg2) {
1251    ALOGE("Error condition %d reported by HAL, arguments %d, %d", errorCode, arg1, arg2);
1252}
1253
1254void Camera2Client::notifyShutter(int frameNumber, nsecs_t timestamp) {
1255    ALOGV("%s: Shutter notification for frame %d at time %lld", __FUNCTION__,
1256            frameNumber, timestamp);
1257}
1258
1259void Camera2Client::notifyAutoFocus(uint8_t newState, int triggerId) {
1260    ALOGV("%s: Autofocus state now %d, last trigger %d",
1261            __FUNCTION__, newState, triggerId);
1262    bool sendCompletedMessage = false;
1263    bool sendMovingMessage = false;
1264
1265    bool success = false;
1266    bool afInMotion = false;
1267    {
1268        SharedParameters::Lock l(mParameters);
1269        switch (l.mParameters.focusMode) {
1270            case Parameters::FOCUS_MODE_AUTO:
1271            case Parameters::FOCUS_MODE_MACRO:
1272                // Don't send notifications upstream if they're not for the current AF
1273                // trigger. For example, if cancel was called in between, or if we
1274                // already sent a notification about this AF call.
1275                if (triggerId != l.mParameters.currentAfTriggerId) break;
1276                switch (newState) {
1277                    case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED:
1278                        success = true;
1279                        // no break
1280                    case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED:
1281                        sendCompletedMessage = true;
1282                        l.mParameters.currentAfTriggerId = -1;
1283                        break;
1284                    case ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN:
1285                        // Just starting focusing, ignore
1286                        break;
1287                    case ANDROID_CONTROL_AF_STATE_INACTIVE:
1288                    case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN:
1289                    case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED:
1290                    default:
1291                        // Unexpected in AUTO/MACRO mode
1292                        ALOGE("%s: Unexpected AF state transition in AUTO/MACRO mode: %d",
1293                                __FUNCTION__, newState);
1294                        break;
1295                }
1296                break;
1297            case Parameters::FOCUS_MODE_CONTINUOUS_VIDEO:
1298            case Parameters::FOCUS_MODE_CONTINUOUS_PICTURE:
1299                switch (newState) {
1300                    case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED:
1301                        success = true;
1302                        // no break
1303                    case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED:
1304                        // Don't send notifications upstream if they're not for
1305                        // the current AF trigger. For example, if cancel was
1306                        // called in between, or if we already sent a
1307                        // notification about this AF call.
1308                        // Send both a 'AF done' callback and a 'AF move' callback
1309                        if (triggerId != l.mParameters.currentAfTriggerId) break;
1310                        sendCompletedMessage = true;
1311                        afInMotion = false;
1312                        if (l.mParameters.enableFocusMoveMessages &&
1313                                l.mParameters.afInMotion) {
1314                            sendMovingMessage = true;
1315                        }
1316                        l.mParameters.currentAfTriggerId = -1;
1317                        break;
1318                    case ANDROID_CONTROL_AF_STATE_INACTIVE:
1319                        // Cancel was called, or we switched state; care if
1320                        // currently moving
1321                        afInMotion = false;
1322                        if (l.mParameters.enableFocusMoveMessages &&
1323                                l.mParameters.afInMotion) {
1324                            sendMovingMessage = true;
1325                        }
1326                        break;
1327                    case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN:
1328                        // Start passive scan, inform upstream
1329                        afInMotion = true;
1330                        // no break
1331                    case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED:
1332                        // Stop passive scan, inform upstream
1333                        if (l.mParameters.enableFocusMoveMessages) {
1334                            sendMovingMessage = true;
1335                        }
1336                        break;
1337                }
1338                l.mParameters.afInMotion = afInMotion;
1339                break;
1340            case Parameters::FOCUS_MODE_EDOF:
1341            case Parameters::FOCUS_MODE_INFINITY:
1342            case Parameters::FOCUS_MODE_FIXED:
1343            default:
1344                if (newState != ANDROID_CONTROL_AF_STATE_INACTIVE) {
1345                    ALOGE("%s: Unexpected AF state change %d "
1346                            "(ID %d) in focus mode %d",
1347                          __FUNCTION__, newState, triggerId,
1348                            l.mParameters.focusMode);
1349                }
1350        }
1351    }
1352    if (sendMovingMessage) {
1353        SharedCameraClient::Lock l(mSharedCameraClient);
1354        if (l.mCameraClient != 0) {
1355            l.mCameraClient->notifyCallback(CAMERA_MSG_FOCUS_MOVE,
1356                    afInMotion ? 1 : 0, 0);
1357        }
1358    }
1359    if (sendCompletedMessage) {
1360        SharedCameraClient::Lock l(mSharedCameraClient);
1361        if (l.mCameraClient != 0) {
1362            l.mCameraClient->notifyCallback(CAMERA_MSG_FOCUS,
1363                    success ? 1 : 0, 0);
1364        }
1365    }
1366}
1367
1368void Camera2Client::notifyAutoExposure(uint8_t newState, int triggerId) {
1369    ALOGV("%s: Autoexposure state now %d, last trigger %d",
1370            __FUNCTION__, newState, triggerId);
1371    mCaptureSequencer->notifyAutoExposure(newState, triggerId);
1372}
1373
1374void Camera2Client::notifyAutoWhitebalance(uint8_t newState, int triggerId) {
1375    ALOGV("%s: Auto-whitebalance state now %d, last trigger %d",
1376            __FUNCTION__, newState, triggerId);
1377}
1378
1379int Camera2Client::getCameraId() const {
1380    return mCameraId;
1381}
1382
1383const sp<Camera2Device>& Camera2Client::getCameraDevice() {
1384    return mDevice;
1385}
1386
1387const sp<CameraService>& Camera2Client::getCameraService() {
1388    return mCameraService;
1389}
1390
1391camera2::SharedParameters& Camera2Client::getParameters() {
1392    return mParameters;
1393}
1394
1395int Camera2Client::getPreviewStreamId() const {
1396    return mStreamingProcessor->getPreviewStreamId();
1397}
1398
1399int Camera2Client::getCaptureStreamId() const {
1400    return mJpegProcessor->getStreamId();
1401}
1402
1403int Camera2Client::getCallbackStreamId() const {
1404    return mCallbackProcessor->getStreamId();
1405}
1406
1407int Camera2Client::getRecordingStreamId() const {
1408    return mStreamingProcessor->getRecordingStreamId();
1409}
1410
1411int Camera2Client::getZslStreamId() const {
1412    return mZslProcessor->getStreamId();
1413}
1414
1415status_t Camera2Client::registerFrameListener(int32_t minId, int32_t maxId,
1416        wp<camera2::FrameProcessor::FilteredListener> listener) {
1417    return mFrameProcessor->registerListener(minId, maxId, listener);
1418}
1419
1420status_t Camera2Client::removeFrameListener(int32_t minId, int32_t maxId,
1421        wp<camera2::FrameProcessor::FilteredListener> listener) {
1422    return mFrameProcessor->removeListener(minId, maxId, listener);
1423}
1424
1425status_t Camera2Client::stopStream() {
1426    return mStreamingProcessor->stopStream();
1427}
1428
1429Camera2Client::SharedCameraClient::Lock::Lock(SharedCameraClient &client):
1430        mCameraClient(client.mCameraClient),
1431        mSharedClient(client) {
1432    mSharedClient.mCameraClientLock.lock();
1433}
1434
1435Camera2Client::SharedCameraClient::Lock::~Lock() {
1436    mSharedClient.mCameraClientLock.unlock();
1437}
1438
1439Camera2Client::SharedCameraClient::SharedCameraClient(const sp<ICameraClient>&client):
1440        mCameraClient(client) {
1441}
1442
1443Camera2Client::SharedCameraClient& Camera2Client::SharedCameraClient::operator=(
1444        const sp<ICameraClient>&client) {
1445    Mutex::Autolock l(mCameraClientLock);
1446    mCameraClient = client;
1447    return *this;
1448}
1449
1450void Camera2Client::SharedCameraClient::clear() {
1451    Mutex::Autolock l(mCameraClientLock);
1452    mCameraClient.clear();
1453}
1454
1455const int32_t Camera2Client::kPreviewRequestIdStart;
1456const int32_t Camera2Client::kPreviewRequestIdEnd;
1457const int32_t Camera2Client::kRecordingRequestIdStart;
1458const int32_t Camera2Client::kRecordingRequestIdEnd;
1459const int32_t Camera2Client::kCaptureRequestIdStart;
1460const int32_t Camera2Client::kCaptureRequestIdEnd;
1461
1462/** Utility methods */
1463
1464status_t Camera2Client::updateRequests(Parameters &params) {
1465    status_t res;
1466
1467    ALOGV("%s: Camera %d: state = %d", __FUNCTION__, getCameraId(), params.state);
1468
1469    res = mStreamingProcessor->incrementStreamingIds();
1470    if (res != OK) {
1471        ALOGE("%s: Camera %d: Unable to increment request IDs: %s (%d)",
1472                __FUNCTION__, mCameraId, strerror(-res), res);
1473        return res;
1474    }
1475
1476    res = mStreamingProcessor->updatePreviewRequest(params);
1477    if (res != OK) {
1478        ALOGE("%s: Camera %d: Unable to update preview request: %s (%d)",
1479                __FUNCTION__, mCameraId, strerror(-res), res);
1480        return res;
1481    }
1482    res = mStreamingProcessor->updateRecordingRequest(params);
1483    if (res != OK) {
1484        ALOGE("%s: Camera %d: Unable to update recording request: %s (%d)",
1485                __FUNCTION__, mCameraId, strerror(-res), res);
1486        return res;
1487    }
1488
1489    if (params.state == Parameters::PREVIEW) {
1490        res = startPreviewL(params, true);
1491        if (res != OK) {
1492            ALOGE("%s: Camera %d: Error streaming new preview request: %s (%d)",
1493                    __FUNCTION__, mCameraId, strerror(-res), res);
1494            return res;
1495        }
1496    } else if (params.state == Parameters::RECORD ||
1497            params.state == Parameters::VIDEO_SNAPSHOT) {
1498        res = startRecordingL(params, true);
1499        if (res != OK) {
1500            ALOGE("%s: Camera %d: Error streaming new record request: %s (%d)",
1501                    __FUNCTION__, mCameraId, strerror(-res), res);
1502            return res;
1503        }
1504    }
1505    return res;
1506}
1507
1508
1509size_t Camera2Client::calculateBufferSize(int width, int height,
1510        int format, int stride) {
1511    switch (format) {
1512        case HAL_PIXEL_FORMAT_YCbCr_422_SP: // NV16
1513            return width * height * 2;
1514        case HAL_PIXEL_FORMAT_YCrCb_420_SP: // NV21
1515            return width * height * 3 / 2;
1516        case HAL_PIXEL_FORMAT_YCbCr_422_I: // YUY2
1517            return width * height * 2;
1518        case HAL_PIXEL_FORMAT_YV12: {      // YV12
1519            size_t ySize = stride * height;
1520            size_t uvStride = (stride / 2 + 0xF) & ~0xF;
1521            size_t uvSize = uvStride * height / 2;
1522            return ySize + uvSize * 2;
1523        }
1524        case HAL_PIXEL_FORMAT_RGB_565:
1525            return width * height * 2;
1526        case HAL_PIXEL_FORMAT_RGBA_8888:
1527            return width * height * 4;
1528        case HAL_PIXEL_FORMAT_RAW_SENSOR:
1529            return width * height * 2;
1530        default:
1531            ALOGE("%s: Unknown preview format: %x",
1532                    __FUNCTION__,  format);
1533            return 0;
1534    }
1535}
1536
1537status_t Camera2Client::syncWithDevice() {
1538    ATRACE_CALL();
1539    const nsecs_t kMaxSyncTimeout = 100000000; // 100 ms
1540    status_t res;
1541
1542    int32_t activeRequestId = mStreamingProcessor->getActiveRequestId();
1543    if (activeRequestId == 0) return OK;
1544
1545    res = mDevice->waitUntilRequestReceived(activeRequestId, kMaxSyncTimeout);
1546    if (res == TIMED_OUT) {
1547        ALOGE("%s: Camera %d: Timed out waiting sync with HAL",
1548                __FUNCTION__, mCameraId);
1549    } else if (res != OK) {
1550        ALOGE("%s: Camera %d: Error while waiting to sync with HAL",
1551                __FUNCTION__, mCameraId);
1552    }
1553    return res;
1554}
1555
1556} // namespace android
1557