Camera2Client.cpp revision c03792041b9dd6f7f54abd6c82bd6c755a336cd8 
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    // TODO: Check for uninterruptable conditions
458
459    if (mClientPid == getCallingPid()) {
460        mClientPid = 0;
461        mCameraClient.clear();
462        mSharedCameraClient.clear();
463        return OK;
464    }
465
466    ALOGE("%s: Camera %d: Unlock call from pid %d; currently locked to pid %d",
467            __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
468    return EBUSY;
469}
470
471status_t Camera2Client::setPreviewDisplay(
472        const sp<Surface>& surface) {
473    ATRACE_CALL();
474    ALOGV("%s: E", __FUNCTION__);
475    Mutex::Autolock icl(mICameraLock);
476    status_t res;
477    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
478
479    sp<IBinder> binder;
480    sp<ANativeWindow> window;
481    if (surface != 0) {
482        binder = surface->asBinder();
483        window = surface;
484    }
485
486    return setPreviewWindowL(binder,window);
487}
488
489status_t Camera2Client::setPreviewTexture(
490        const sp<ISurfaceTexture>& surfaceTexture) {
491    ATRACE_CALL();
492    ALOGV("%s: E", __FUNCTION__);
493    Mutex::Autolock icl(mICameraLock);
494    status_t res;
495    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
496
497    sp<IBinder> binder;
498    sp<ANativeWindow> window;
499    if (surfaceTexture != 0) {
500        binder = surfaceTexture->asBinder();
501        window = new SurfaceTextureClient(surfaceTexture);
502    }
503    return setPreviewWindowL(binder, window);
504}
505
506status_t Camera2Client::setPreviewWindowL(const sp<IBinder>& binder,
507        sp<ANativeWindow> window) {
508    ATRACE_CALL();
509    status_t res;
510
511    if (binder == mPreviewSurface) {
512        ALOGV("%s: Camera %d: New window is same as old window",
513                __FUNCTION__, mCameraId);
514        return NO_ERROR;
515    }
516
517    SharedParameters::Lock l(mParameters);
518    switch (l.mParameters.state) {
519        case Parameters::DISCONNECTED:
520        case Parameters::RECORD:
521        case Parameters::STILL_CAPTURE:
522        case Parameters::VIDEO_SNAPSHOT:
523            ALOGE("%s: Camera %d: Cannot set preview display while in state %s",
524                    __FUNCTION__, mCameraId,
525                    Parameters::getStateName(l.mParameters.state));
526            return INVALID_OPERATION;
527        case Parameters::STOPPED:
528        case Parameters::WAITING_FOR_PREVIEW_WINDOW:
529            // OK
530            break;
531        case Parameters::PREVIEW:
532            // Already running preview - need to stop and create a new stream
533            // TODO: Optimize this so that we don't wait for old stream to drain
534            // before spinning up new stream
535            mStreamingProcessor->stopStream();
536            l.mParameters.state = Parameters::WAITING_FOR_PREVIEW_WINDOW;
537            break;
538    }
539
540    mPreviewSurface = binder;
541    res = mStreamingProcessor->setPreviewWindow(window);
542    if (res != OK) {
543        ALOGE("%s: Unable to set new preview window: %s (%d)",
544                __FUNCTION__, strerror(-res), res);
545        return res;
546    }
547
548    if (l.mParameters.state == Parameters::WAITING_FOR_PREVIEW_WINDOW) {
549        return startPreviewL(l.mParameters, false);
550    }
551
552    return OK;
553}
554
555void Camera2Client::setPreviewCallbackFlag(int flag) {
556    ATRACE_CALL();
557    ALOGV("%s: Camera %d: Flag 0x%x", __FUNCTION__, mCameraId, flag);
558    Mutex::Autolock icl(mICameraLock);
559    status_t res;
560    if ( checkPid(__FUNCTION__) != OK) return;
561
562    SharedParameters::Lock l(mParameters);
563    setPreviewCallbackFlagL(l.mParameters, flag);
564}
565
566void Camera2Client::setPreviewCallbackFlagL(Parameters &params, int flag) {
567    status_t res = OK;
568    if (flag & CAMERA_FRAME_CALLBACK_FLAG_ONE_SHOT_MASK) {
569        ALOGV("%s: setting oneshot", __FUNCTION__);
570        params.previewCallbackOneShot = true;
571    }
572    if (params.previewCallbackFlags != (uint32_t)flag) {
573        params.previewCallbackFlags = flag;
574        switch(params.state) {
575        case Parameters::PREVIEW:
576            res = startPreviewL(params, true);
577            break;
578        case Parameters::RECORD:
579        case Parameters::VIDEO_SNAPSHOT:
580            res = startRecordingL(params, true);
581            break;
582        default:
583            break;
584        }
585        if (res != OK) {
586            ALOGE("%s: Camera %d: Unable to refresh request in state %s",
587                    __FUNCTION__, mCameraId,
588                    Parameters::getStateName(params.state));
589        }
590    }
591
592}
593
594status_t Camera2Client::startPreview() {
595    ATRACE_CALL();
596    ALOGV("%s: E", __FUNCTION__);
597    Mutex::Autolock icl(mICameraLock);
598    status_t res;
599    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
600    SharedParameters::Lock l(mParameters);
601    return startPreviewL(l.mParameters, false);
602}
603
604status_t Camera2Client::startPreviewL(Parameters &params, bool restart) {
605    ATRACE_CALL();
606    status_t res;
607
608    ALOGV("%s: state == %d, restart = %d", __FUNCTION__, params.state, restart);
609
610    if (params.state == Parameters::PREVIEW && !restart) {
611        // Succeed attempt to re-enter preview state
612        ALOGI("%s: Not starting preview; already in preview state.",
613              __FUNCTION__);
614        return OK;
615    }
616    if (params.state > Parameters::PREVIEW && !restart) {
617        ALOGE("%s: Can't start preview in state %s",
618                __FUNCTION__,
619                Parameters::getStateName(params.state));
620        return INVALID_OPERATION;
621    }
622
623    if (!mStreamingProcessor->haveValidPreviewWindow()) {
624        params.state = Parameters::WAITING_FOR_PREVIEW_WINDOW;
625        return OK;
626    }
627    params.state = Parameters::STOPPED;
628
629    res = mStreamingProcessor->updatePreviewStream(params);
630    if (res != OK) {
631        ALOGE("%s: Camera %d: Unable to update preview stream: %s (%d)",
632                __FUNCTION__, mCameraId, strerror(-res), res);
633        return res;
634    }
635
636    Vector<uint8_t> outputStreams;
637    bool callbacksEnabled = params.previewCallbackFlags &
638        CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK;
639    if (callbacksEnabled) {
640        res = mCallbackProcessor->updateStream(params);
641        if (res != OK) {
642            ALOGE("%s: Camera %d: Unable to update callback stream: %s (%d)",
643                    __FUNCTION__, mCameraId, strerror(-res), res);
644            return res;
645        }
646        outputStreams.push(getCallbackStreamId());
647    }
648    if (params.zslMode && !params.recordingHint) {
649        res = mZslProcessor->updateStream(params);
650        if (res != OK) {
651            ALOGE("%s: Camera %d: Unable to update ZSL stream: %s (%d)",
652                    __FUNCTION__, mCameraId, strerror(-res), res);
653            return res;
654        }
655        outputStreams.push(getZslStreamId());
656    }
657
658    outputStreams.push(getPreviewStreamId());
659
660    if (!params.recordingHint) {
661        if (!restart) {
662            res = mStreamingProcessor->updatePreviewRequest(params);
663            if (res != OK) {
664                ALOGE("%s: Camera %d: Can't set up preview request: "
665                        "%s (%d)", __FUNCTION__, mCameraId,
666                        strerror(-res), res);
667                return res;
668            }
669        }
670        res = mStreamingProcessor->startStream(StreamingProcessor::PREVIEW,
671                outputStreams);
672    } else {
673        // With recording hint set, we're going to be operating under the
674        // assumption that the user will record video. To optimize recording
675        // startup time, create the necessary output streams for recording and
676        // video snapshot now if they don't already exist.
677        res = mJpegProcessor->updateStream(params);
678        if (res != OK) {
679            ALOGE("%s: Camera %d: Can't pre-configure still image "
680                    "stream: %s (%d)",
681                    __FUNCTION__, mCameraId, strerror(-res), res);
682            return res;
683        }
684
685        if (!restart) {
686            res = mStreamingProcessor->updateRecordingRequest(params);
687            if (res != OK) {
688                ALOGE("%s: Camera %d: Can't set up preview request with "
689                        "record hint: %s (%d)", __FUNCTION__, mCameraId,
690                        strerror(-res), res);
691                return res;
692            }
693        }
694        res = mStreamingProcessor->startStream(StreamingProcessor::RECORD,
695                outputStreams);
696    }
697    if (res != OK) {
698        ALOGE("%s: Camera %d: Unable to start streaming preview: %s (%d)",
699                __FUNCTION__, mCameraId, strerror(-res), res);
700        return res;
701    }
702
703    params.state = Parameters::PREVIEW;
704    return OK;
705}
706
707void Camera2Client::stopPreview() {
708    ATRACE_CALL();
709    ALOGV("%s: E", __FUNCTION__);
710    Mutex::Autolock icl(mICameraLock);
711    status_t res;
712    if ( (res = checkPid(__FUNCTION__) ) != OK) return;
713    stopPreviewL();
714}
715
716void Camera2Client::stopPreviewL() {
717    ATRACE_CALL();
718    status_t res;
719    const nsecs_t kStopCaptureTimeout = 3000000000LL; // 3 seconds
720    Parameters::State state;
721    {
722        SharedParameters::Lock l(mParameters);
723        state = l.mParameters.state;
724    }
725
726    switch (state) {
727        case Parameters::DISCONNECTED:
728            ALOGE("%s: Camera %d: Call before initialized",
729                    __FUNCTION__, mCameraId);
730            break;
731        case Parameters::STOPPED:
732        case Parameters::VIDEO_SNAPSHOT:
733        case Parameters::STILL_CAPTURE:
734            mCaptureSequencer->waitUntilIdle(kStopCaptureTimeout);
735            // no break
736        case Parameters::RECORD:
737        case Parameters::PREVIEW:
738            mStreamingProcessor->stopStream();
739            res = mDevice->waitUntilDrained();
740            if (res != OK) {
741                ALOGE("%s: Camera %d: Waiting to stop streaming failed: %s (%d)",
742                        __FUNCTION__, mCameraId, strerror(-res), res);
743            }
744            // no break
745        case Parameters::WAITING_FOR_PREVIEW_WINDOW: {
746            SharedParameters::Lock l(mParameters);
747            l.mParameters.state = Parameters::STOPPED;
748            commandStopFaceDetectionL(l.mParameters);
749            break;
750        }
751        default:
752            ALOGE("%s: Camera %d: Unknown state %d", __FUNCTION__, mCameraId,
753                    state);
754    }
755}
756
757bool Camera2Client::previewEnabled() {
758    ATRACE_CALL();
759    Mutex::Autolock icl(mICameraLock);
760    status_t res;
761    if ( (res = checkPid(__FUNCTION__) ) != OK) return false;
762
763    SharedParameters::Lock l(mParameters);
764    return l.mParameters.state == Parameters::PREVIEW;
765}
766
767status_t Camera2Client::storeMetaDataInBuffers(bool enabled) {
768    ATRACE_CALL();
769    Mutex::Autolock icl(mICameraLock);
770    status_t res;
771    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
772
773    SharedParameters::Lock l(mParameters);
774    switch (l.mParameters.state) {
775        case Parameters::RECORD:
776        case Parameters::VIDEO_SNAPSHOT:
777            ALOGE("%s: Camera %d: Can't be called in state %s",
778                    __FUNCTION__, mCameraId,
779                    Parameters::getStateName(l.mParameters.state));
780            return INVALID_OPERATION;
781        default:
782            // OK
783            break;
784    }
785
786    l.mParameters.storeMetadataInBuffers = enabled;
787
788    return OK;
789}
790
791status_t Camera2Client::startRecording() {
792    ATRACE_CALL();
793    ALOGV("%s: E", __FUNCTION__);
794    Mutex::Autolock icl(mICameraLock);
795    status_t res;
796    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
797    SharedParameters::Lock l(mParameters);
798
799    return startRecordingL(l.mParameters, false);
800}
801
802status_t Camera2Client::startRecordingL(Parameters &params, bool restart) {
803    status_t res;
804
805    ALOGV("%s: state == %d, restart = %d", __FUNCTION__, params.state, restart);
806
807    switch (params.state) {
808        case Parameters::STOPPED:
809            res = startPreviewL(params, false);
810            if (res != OK) return res;
811            break;
812        case Parameters::PREVIEW:
813            // Ready to go
814            break;
815        case Parameters::RECORD:
816        case Parameters::VIDEO_SNAPSHOT:
817            // OK to call this when recording is already on, just skip unless
818            // we're looking to restart
819            if (!restart) return OK;
820            break;
821        default:
822            ALOGE("%s: Camera %d: Can't start recording in state %s",
823                    __FUNCTION__, mCameraId,
824                    Parameters::getStateName(params.state));
825            return INVALID_OPERATION;
826    };
827
828    if (!params.storeMetadataInBuffers) {
829        ALOGE("%s: Camera %d: Recording only supported in metadata mode, but "
830                "non-metadata recording mode requested!", __FUNCTION__,
831                mCameraId);
832        return INVALID_OPERATION;
833    }
834
835    if (!restart) {
836        mCameraService->playSound(CameraService::SOUND_RECORDING);
837        mStreamingProcessor->updateRecordingRequest(params);
838        if (res != OK) {
839            ALOGE("%s: Camera %d: Unable to update recording request: %s (%d)",
840                    __FUNCTION__, mCameraId, strerror(-res), res);
841            return res;
842        }
843    }
844
845    res = mStreamingProcessor->updateRecordingStream(params);
846    if (res != OK) {
847        ALOGE("%s: Camera %d: Unable to update recording stream: %s (%d)",
848                __FUNCTION__, mCameraId, strerror(-res), res);
849        return res;
850    }
851
852    Vector<uint8_t> outputStreams;
853    bool callbacksEnabled = params.previewCallbackFlags &
854        CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK;
855    if (callbacksEnabled) {
856        res = mCallbackProcessor->updateStream(params);
857        if (res != OK) {
858            ALOGE("%s: Camera %d: Unable to update callback stream: %s (%d)",
859                    __FUNCTION__, mCameraId, strerror(-res), res);
860            return res;
861        }
862        outputStreams.push(getCallbackStreamId());
863    }
864    outputStreams.push(getPreviewStreamId());
865    outputStreams.push(getRecordingStreamId());
866
867    res = mStreamingProcessor->startStream(StreamingProcessor::RECORD,
868            outputStreams);
869    if (res != OK) {
870        ALOGE("%s: Camera %d: Unable to start recording stream: %s (%d)",
871                __FUNCTION__, mCameraId, strerror(-res), res);
872        return res;
873    }
874
875    if (params.state < Parameters::RECORD) {
876        params.state = Parameters::RECORD;
877    }
878
879    return OK;
880}
881
882void Camera2Client::stopRecording() {
883    ATRACE_CALL();
884    ALOGV("%s: E", __FUNCTION__);
885    Mutex::Autolock icl(mICameraLock);
886    SharedParameters::Lock l(mParameters);
887
888    status_t res;
889    if ( (res = checkPid(__FUNCTION__) ) != OK) return;
890
891    switch (l.mParameters.state) {
892        case Parameters::RECORD:
893            // OK to stop
894            break;
895        case Parameters::STOPPED:
896        case Parameters::PREVIEW:
897        case Parameters::STILL_CAPTURE:
898        case Parameters::VIDEO_SNAPSHOT:
899        default:
900            ALOGE("%s: Camera %d: Can't stop recording in state %s",
901                    __FUNCTION__, mCameraId,
902                    Parameters::getStateName(l.mParameters.state));
903            return;
904    };
905
906    mCameraService->playSound(CameraService::SOUND_RECORDING);
907
908    res = startPreviewL(l.mParameters, true);
909    if (res != OK) {
910        ALOGE("%s: Camera %d: Unable to return to preview",
911                __FUNCTION__, mCameraId);
912    }
913}
914
915bool Camera2Client::recordingEnabled() {
916    ATRACE_CALL();
917    Mutex::Autolock icl(mICameraLock);
918
919    if ( checkPid(__FUNCTION__) != OK) return false;
920
921    return recordingEnabledL();
922}
923
924bool Camera2Client::recordingEnabledL() {
925    ATRACE_CALL();
926    SharedParameters::Lock l(mParameters);
927
928    return (l.mParameters.state == Parameters::RECORD
929            || l.mParameters.state == Parameters::VIDEO_SNAPSHOT);
930}
931
932void Camera2Client::releaseRecordingFrame(const sp<IMemory>& mem) {
933    ATRACE_CALL();
934    Mutex::Autolock icl(mICameraLock);
935    if ( checkPid(__FUNCTION__) != OK) return;
936
937    mStreamingProcessor->releaseRecordingFrame(mem);
938}
939
940status_t Camera2Client::autoFocus() {
941    ATRACE_CALL();
942    Mutex::Autolock icl(mICameraLock);
943    ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
944    status_t res;
945    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
946
947    int triggerId;
948    {
949        SharedParameters::Lock l(mParameters);
950        if (l.mParameters.state < Parameters::PREVIEW) {
951            return INVALID_OPERATION;
952        }
953
954        /**
955          * If the camera does not support auto-focus, it is a no-op and
956          * onAutoFocus(boolean, Camera) callback will be called immediately
957          * with a fake value of success set to true.
958          */
959        if (l.mParameters.focusMode == Parameters::FOCUS_MODE_FIXED) {
960            SharedCameraClient::Lock l(mSharedCameraClient);
961            if (l.mCameraClient != 0) {
962                l.mCameraClient->notifyCallback(CAMERA_MSG_FOCUS,
963                    /*success*/1, 0);
964            }
965
966            return OK;
967        }
968
969        if (l.mParameters.quirks.triggerAfWithAuto &&
970                l.mParameters.sceneMode != ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED &&
971                l.mParameters.focusMode != Parameters::FOCUS_MODE_AUTO) {
972            ALOGV("%s: Quirk: Switching from focusMode %d to AUTO",
973                    __FUNCTION__, l.mParameters.focusMode);
974            l.mParameters.shadowFocusMode = l.mParameters.focusMode;
975            l.mParameters.focusMode = Parameters::FOCUS_MODE_AUTO;
976            updateRequests(l.mParameters);
977        }
978
979        l.mParameters.currentAfTriggerId = ++l.mParameters.afTriggerCounter;
980        triggerId = l.mParameters.currentAfTriggerId;
981    }
982    syncWithDevice();
983
984    mDevice->triggerAutofocus(triggerId);
985
986    return OK;
987}
988
989status_t Camera2Client::cancelAutoFocus() {
990    ATRACE_CALL();
991    Mutex::Autolock icl(mICameraLock);
992    ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
993    status_t res;
994    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
995
996    int triggerId;
997    {
998        SharedParameters::Lock l(mParameters);
999        triggerId = ++l.mParameters.afTriggerCounter;
1000
1001        // When using triggerAfWithAuto quirk, may need to reset focus mode to
1002        // the real state at this point.
1003        if (l.mParameters.shadowFocusMode != Parameters::FOCUS_MODE_INVALID) {
1004            ALOGV("%s: Quirk: Restoring focus mode to %d", __FUNCTION__,
1005                    l.mParameters.shadowFocusMode);
1006            l.mParameters.focusMode = l.mParameters.shadowFocusMode;
1007            l.mParameters.shadowFocusMode = Parameters::FOCUS_MODE_INVALID;
1008            updateRequests(l.mParameters);
1009        }
1010    }
1011    syncWithDevice();
1012
1013    mDevice->triggerCancelAutofocus(triggerId);
1014
1015    return OK;
1016}
1017
1018status_t Camera2Client::takePicture(int msgType) {
1019    ATRACE_CALL();
1020    Mutex::Autolock icl(mICameraLock);
1021    status_t res;
1022    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1023
1024    SharedParameters::Lock l(mParameters);
1025    switch (l.mParameters.state) {
1026        case Parameters::DISCONNECTED:
1027        case Parameters::STOPPED:
1028        case Parameters::WAITING_FOR_PREVIEW_WINDOW:
1029            ALOGE("%s: Camera %d: Cannot take picture without preview enabled",
1030                    __FUNCTION__, mCameraId);
1031            return INVALID_OPERATION;
1032        case Parameters::PREVIEW:
1033            // Good to go for takePicture
1034            res = commandStopFaceDetectionL(l.mParameters);
1035            if (res != OK) {
1036                ALOGE("%s: Camera %d: Unable to stop face detection for still capture",
1037                        __FUNCTION__, mCameraId);
1038                return res;
1039            }
1040            l.mParameters.state = Parameters::STILL_CAPTURE;
1041            break;
1042        case Parameters::RECORD:
1043            // Good to go for video snapshot
1044            l.mParameters.state = Parameters::VIDEO_SNAPSHOT;
1045            break;
1046        case Parameters::STILL_CAPTURE:
1047        case Parameters::VIDEO_SNAPSHOT:
1048            ALOGE("%s: Camera %d: Already taking a picture",
1049                    __FUNCTION__, mCameraId);
1050            return INVALID_OPERATION;
1051    }
1052
1053    ALOGV("%s: Camera %d: Starting picture capture", __FUNCTION__, mCameraId);
1054
1055    res = mJpegProcessor->updateStream(l.mParameters);
1056    if (res != OK) {
1057        ALOGE("%s: Camera %d: Can't set up still image stream: %s (%d)",
1058                __FUNCTION__, mCameraId, strerror(-res), res);
1059        return res;
1060    }
1061
1062    // Need HAL to have correct settings before (possibly) triggering precapture
1063    syncWithDevice();
1064
1065    res = mCaptureSequencer->startCapture();
1066    if (res != OK) {
1067        ALOGE("%s: Camera %d: Unable to start capture: %s (%d)",
1068                __FUNCTION__, mCameraId, strerror(-res), res);
1069    }
1070
1071    return res;
1072}
1073
1074status_t Camera2Client::setParameters(const String8& params) {
1075    ATRACE_CALL();
1076    ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
1077    Mutex::Autolock icl(mICameraLock);
1078    status_t res;
1079    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1080
1081    SharedParameters::Lock l(mParameters);
1082
1083    res = l.mParameters.set(params);
1084    if (res != OK) return res;
1085
1086    res = updateRequests(l.mParameters);
1087
1088    return res;
1089}
1090
1091String8 Camera2Client::getParameters() const {
1092    ATRACE_CALL();
1093    ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
1094    Mutex::Autolock icl(mICameraLock);
1095    if ( checkPid(__FUNCTION__) != OK) return String8();
1096
1097    SharedParameters::ReadLock l(mParameters);
1098
1099    return l.mParameters.get();
1100}
1101
1102status_t Camera2Client::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) {
1103    ATRACE_CALL();
1104    Mutex::Autolock icl(mICameraLock);
1105    status_t res;
1106    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1107
1108    ALOGV("%s: Camera %d: Command %d (%d, %d)", __FUNCTION__, mCameraId,
1109            cmd, arg1, arg2);
1110
1111    switch (cmd) {
1112        case CAMERA_CMD_START_SMOOTH_ZOOM:
1113            return commandStartSmoothZoomL();
1114        case CAMERA_CMD_STOP_SMOOTH_ZOOM:
1115            return commandStopSmoothZoomL();
1116        case CAMERA_CMD_SET_DISPLAY_ORIENTATION:
1117            return commandSetDisplayOrientationL(arg1);
1118        case CAMERA_CMD_ENABLE_SHUTTER_SOUND:
1119            return commandEnableShutterSoundL(arg1 == 1);
1120        case CAMERA_CMD_PLAY_RECORDING_SOUND:
1121            return commandPlayRecordingSoundL();
1122        case CAMERA_CMD_START_FACE_DETECTION:
1123            return commandStartFaceDetectionL(arg1);
1124        case CAMERA_CMD_STOP_FACE_DETECTION: {
1125            SharedParameters::Lock l(mParameters);
1126            return commandStopFaceDetectionL(l.mParameters);
1127        }
1128        case CAMERA_CMD_ENABLE_FOCUS_MOVE_MSG:
1129            return commandEnableFocusMoveMsgL(arg1 == 1);
1130        case CAMERA_CMD_PING:
1131            return commandPingL();
1132        case CAMERA_CMD_SET_VIDEO_BUFFER_COUNT:
1133            return commandSetVideoBufferCountL(arg1);
1134        default:
1135            ALOGE("%s: Unknown command %d (arguments %d, %d)",
1136                    __FUNCTION__, cmd, arg1, arg2);
1137            return BAD_VALUE;
1138    }
1139}
1140
1141status_t Camera2Client::commandStartSmoothZoomL() {
1142    ALOGE("%s: Unimplemented!", __FUNCTION__);
1143    return OK;
1144}
1145
1146status_t Camera2Client::commandStopSmoothZoomL() {
1147    ALOGE("%s: Unimplemented!", __FUNCTION__);
1148    return OK;
1149}
1150
1151status_t Camera2Client::commandSetDisplayOrientationL(int degrees) {
1152    int transform = Parameters::degToTransform(degrees,
1153            mCameraFacing == CAMERA_FACING_FRONT);
1154    if (transform == -1) {
1155        ALOGE("%s: Camera %d: Error setting %d as display orientation value",
1156                __FUNCTION__, mCameraId, degrees);
1157        return BAD_VALUE;
1158    }
1159    SharedParameters::Lock l(mParameters);
1160    if (transform != l.mParameters.previewTransform &&
1161            getPreviewStreamId() != NO_STREAM) {
1162        mDevice->setStreamTransform(getPreviewStreamId(), transform);
1163    }
1164    l.mParameters.previewTransform = transform;
1165    return OK;
1166}
1167
1168status_t Camera2Client::commandEnableShutterSoundL(bool enable) {
1169    SharedParameters::Lock l(mParameters);
1170    if (enable) {
1171        l.mParameters.playShutterSound = true;
1172        return OK;
1173    }
1174
1175    // Disabling shutter sound may not be allowed. In that case only
1176    // allow the mediaserver process to disable the sound.
1177    char value[PROPERTY_VALUE_MAX];
1178    property_get("ro.camera.sound.forced", value, "0");
1179    if (strncmp(value, "0", 2) != 0) {
1180        // Disabling shutter sound is not allowed. Deny if the current
1181        // process is not mediaserver.
1182        if (getCallingPid() != getpid()) {
1183            ALOGE("Failed to disable shutter sound. Permission denied (pid %d)",
1184                    getCallingPid());
1185            return PERMISSION_DENIED;
1186        }
1187    }
1188
1189    l.mParameters.playShutterSound = false;
1190    return OK;
1191}
1192
1193status_t Camera2Client::commandPlayRecordingSoundL() {
1194    mCameraService->playSound(CameraService::SOUND_RECORDING);
1195    return OK;
1196}
1197
1198status_t Camera2Client::commandStartFaceDetectionL(int type) {
1199    ALOGV("%s: Camera %d: Starting face detection",
1200          __FUNCTION__, mCameraId);
1201    status_t res;
1202    SharedParameters::Lock l(mParameters);
1203    switch (l.mParameters.state) {
1204        case Parameters::DISCONNECTED:
1205        case Parameters::STOPPED:
1206        case Parameters::WAITING_FOR_PREVIEW_WINDOW:
1207        case Parameters::STILL_CAPTURE:
1208            ALOGE("%s: Camera %d: Cannot start face detection without preview active",
1209                    __FUNCTION__, mCameraId);
1210            return INVALID_OPERATION;
1211        case Parameters::PREVIEW:
1212        case Parameters::RECORD:
1213        case Parameters::VIDEO_SNAPSHOT:
1214            // Good to go for starting face detect
1215            break;
1216    }
1217    // Ignoring type
1218    if (l.mParameters.fastInfo.bestFaceDetectMode ==
1219            ANDROID_STATS_FACE_DETECTION_OFF) {
1220        ALOGE("%s: Camera %d: Face detection not supported",
1221                __FUNCTION__, mCameraId);
1222        return INVALID_OPERATION;
1223    }
1224    if (l.mParameters.enableFaceDetect) return OK;
1225
1226    l.mParameters.enableFaceDetect = true;
1227
1228    res = updateRequests(l.mParameters);
1229
1230    return res;
1231}
1232
1233status_t Camera2Client::commandStopFaceDetectionL(Parameters &params) {
1234    status_t res = OK;
1235    ALOGV("%s: Camera %d: Stopping face detection",
1236          __FUNCTION__, mCameraId);
1237
1238    if (!params.enableFaceDetect) return OK;
1239
1240    params.enableFaceDetect = false;
1241
1242    if (params.state == Parameters::PREVIEW
1243            || params.state == Parameters::RECORD
1244            || params.state == Parameters::VIDEO_SNAPSHOT) {
1245        res = updateRequests(params);
1246    }
1247
1248    return res;
1249}
1250
1251status_t Camera2Client::commandEnableFocusMoveMsgL(bool enable) {
1252    SharedParameters::Lock l(mParameters);
1253    l.mParameters.enableFocusMoveMessages = enable;
1254
1255    return OK;
1256}
1257
1258status_t Camera2Client::commandPingL() {
1259    // Always ping back if access is proper and device is alive
1260    SharedParameters::Lock l(mParameters);
1261    if (l.mParameters.state != Parameters::DISCONNECTED) {
1262        return OK;
1263    } else {
1264        return NO_INIT;
1265    }
1266}
1267
1268status_t Camera2Client::commandSetVideoBufferCountL(size_t count) {
1269    if (recordingEnabledL()) {
1270        ALOGE("%s: Camera %d: Error setting video buffer count after "
1271                "recording was started", __FUNCTION__, mCameraId);
1272        return INVALID_OPERATION;
1273    }
1274
1275    return mStreamingProcessor->setRecordingBufferCount(count);
1276}
1277
1278/** Device-related methods */
1279
1280void Camera2Client::notifyError(int errorCode, int arg1, int arg2) {
1281    ALOGE("Error condition %d reported by HAL, arguments %d, %d", errorCode, arg1, arg2);
1282}
1283
1284void Camera2Client::notifyShutter(int frameNumber, nsecs_t timestamp) {
1285    ALOGV("%s: Shutter notification for frame %d at time %lld", __FUNCTION__,
1286            frameNumber, timestamp);
1287}
1288
1289void Camera2Client::notifyAutoFocus(uint8_t newState, int triggerId) {
1290    ALOGV("%s: Autofocus state now %d, last trigger %d",
1291            __FUNCTION__, newState, triggerId);
1292    bool sendCompletedMessage = false;
1293    bool sendMovingMessage = false;
1294
1295    bool success = false;
1296    bool afInMotion = false;
1297    {
1298        SharedParameters::Lock l(mParameters);
1299        switch (l.mParameters.focusMode) {
1300            case Parameters::FOCUS_MODE_AUTO:
1301            case Parameters::FOCUS_MODE_MACRO:
1302                // Don't send notifications upstream if they're not for the current AF
1303                // trigger. For example, if cancel was called in between, or if we
1304                // already sent a notification about this AF call.
1305                if (triggerId != l.mParameters.currentAfTriggerId) break;
1306                switch (newState) {
1307                    case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED:
1308                        success = true;
1309                        // no break
1310                    case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED:
1311                        sendCompletedMessage = true;
1312                        l.mParameters.currentAfTriggerId = -1;
1313                        break;
1314                    case ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN:
1315                        // Just starting focusing, ignore
1316                        break;
1317                    case ANDROID_CONTROL_AF_STATE_INACTIVE:
1318                    case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN:
1319                    case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED:
1320                    default:
1321                        // Unexpected in AUTO/MACRO mode
1322                        ALOGE("%s: Unexpected AF state transition in AUTO/MACRO mode: %d",
1323                                __FUNCTION__, newState);
1324                        break;
1325                }
1326                break;
1327            case Parameters::FOCUS_MODE_CONTINUOUS_VIDEO:
1328            case Parameters::FOCUS_MODE_CONTINUOUS_PICTURE:
1329                switch (newState) {
1330                    case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED:
1331                        success = true;
1332                        // no break
1333                    case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED:
1334                        // Don't send notifications upstream if they're not for
1335                        // the current AF trigger. For example, if cancel was
1336                        // called in between, or if we already sent a
1337                        // notification about this AF call.
1338                        // Send both a 'AF done' callback and a 'AF move' callback
1339                        if (triggerId != l.mParameters.currentAfTriggerId) break;
1340                        sendCompletedMessage = true;
1341                        afInMotion = false;
1342                        if (l.mParameters.enableFocusMoveMessages &&
1343                                l.mParameters.afInMotion) {
1344                            sendMovingMessage = true;
1345                        }
1346                        l.mParameters.currentAfTriggerId = -1;
1347                        break;
1348                    case ANDROID_CONTROL_AF_STATE_INACTIVE:
1349                        // Cancel was called, or we switched state; care if
1350                        // currently moving
1351                        afInMotion = false;
1352                        if (l.mParameters.enableFocusMoveMessages &&
1353                                l.mParameters.afInMotion) {
1354                            sendMovingMessage = true;
1355                        }
1356                        break;
1357                    case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN:
1358                        // Start passive scan, inform upstream
1359                        afInMotion = true;
1360                        // no break
1361                    case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED:
1362                        // Stop passive scan, inform upstream
1363                        if (l.mParameters.enableFocusMoveMessages) {
1364                            sendMovingMessage = true;
1365                        }
1366                        break;
1367                }
1368                l.mParameters.afInMotion = afInMotion;
1369                break;
1370            case Parameters::FOCUS_MODE_EDOF:
1371            case Parameters::FOCUS_MODE_INFINITY:
1372            case Parameters::FOCUS_MODE_FIXED:
1373            default:
1374                if (newState != ANDROID_CONTROL_AF_STATE_INACTIVE) {
1375                    ALOGE("%s: Unexpected AF state change %d "
1376                            "(ID %d) in focus mode %d",
1377                          __FUNCTION__, newState, triggerId,
1378                            l.mParameters.focusMode);
1379                }
1380        }
1381    }
1382    if (sendMovingMessage) {
1383        SharedCameraClient::Lock l(mSharedCameraClient);
1384        if (l.mCameraClient != 0) {
1385            l.mCameraClient->notifyCallback(CAMERA_MSG_FOCUS_MOVE,
1386                    afInMotion ? 1 : 0, 0);
1387        }
1388    }
1389    if (sendCompletedMessage) {
1390        SharedCameraClient::Lock l(mSharedCameraClient);
1391        if (l.mCameraClient != 0) {
1392            l.mCameraClient->notifyCallback(CAMERA_MSG_FOCUS,
1393                    success ? 1 : 0, 0);
1394        }
1395    }
1396}
1397
1398void Camera2Client::notifyAutoExposure(uint8_t newState, int triggerId) {
1399    ALOGV("%s: Autoexposure state now %d, last trigger %d",
1400            __FUNCTION__, newState, triggerId);
1401    mCaptureSequencer->notifyAutoExposure(newState, triggerId);
1402}
1403
1404void Camera2Client::notifyAutoWhitebalance(uint8_t newState, int triggerId) {
1405    ALOGV("%s: Auto-whitebalance state now %d, last trigger %d",
1406            __FUNCTION__, newState, triggerId);
1407}
1408
1409int Camera2Client::getCameraId() const {
1410    return mCameraId;
1411}
1412
1413const sp<Camera2Device>& Camera2Client::getCameraDevice() {
1414    return mDevice;
1415}
1416
1417const sp<CameraService>& Camera2Client::getCameraService() {
1418    return mCameraService;
1419}
1420
1421camera2::SharedParameters& Camera2Client::getParameters() {
1422    return mParameters;
1423}
1424
1425int Camera2Client::getPreviewStreamId() const {
1426    return mStreamingProcessor->getPreviewStreamId();
1427}
1428
1429int Camera2Client::getCaptureStreamId() const {
1430    return mJpegProcessor->getStreamId();
1431}
1432
1433int Camera2Client::getCallbackStreamId() const {
1434    return mCallbackProcessor->getStreamId();
1435}
1436
1437int Camera2Client::getRecordingStreamId() const {
1438    return mStreamingProcessor->getRecordingStreamId();
1439}
1440
1441int Camera2Client::getZslStreamId() const {
1442    return mZslProcessor->getStreamId();
1443}
1444
1445status_t Camera2Client::registerFrameListener(int32_t minId, int32_t maxId,
1446        wp<camera2::FrameProcessor::FilteredListener> listener) {
1447    return mFrameProcessor->registerListener(minId, maxId, listener);
1448}
1449
1450status_t Camera2Client::removeFrameListener(int32_t minId, int32_t maxId,
1451        wp<camera2::FrameProcessor::FilteredListener> listener) {
1452    return mFrameProcessor->removeListener(minId, maxId, listener);
1453}
1454
1455status_t Camera2Client::stopStream() {
1456    return mStreamingProcessor->stopStream();
1457}
1458
1459Camera2Client::SharedCameraClient::Lock::Lock(SharedCameraClient &client):
1460        mCameraClient(client.mCameraClient),
1461        mSharedClient(client) {
1462    mSharedClient.mCameraClientLock.lock();
1463}
1464
1465Camera2Client::SharedCameraClient::Lock::~Lock() {
1466    mSharedClient.mCameraClientLock.unlock();
1467}
1468
1469Camera2Client::SharedCameraClient::SharedCameraClient(const sp<ICameraClient>&client):
1470        mCameraClient(client) {
1471}
1472
1473Camera2Client::SharedCameraClient& Camera2Client::SharedCameraClient::operator=(
1474        const sp<ICameraClient>&client) {
1475    Mutex::Autolock l(mCameraClientLock);
1476    mCameraClient = client;
1477    return *this;
1478}
1479
1480void Camera2Client::SharedCameraClient::clear() {
1481    Mutex::Autolock l(mCameraClientLock);
1482    mCameraClient.clear();
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 = 100000000; // 100 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} // namespace android
1587