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