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