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