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