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