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