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