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