Camera2Client.cpp revision 22d58d37db6b5f48a10b3a19f69ffda09943c125 
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    return OK;
423}
424
425status_t Camera2Client::lock() {
426    ATRACE_CALL();
427    ALOGV("%s: E", __FUNCTION__);
428    Mutex::Autolock icl(mICameraLock);
429    ALOGV("%s: Camera %d: Lock call from pid %d; current client pid %d",
430            __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
431
432    if (mClientPid == 0) {
433        mClientPid = getCallingPid();
434        return OK;
435    }
436
437    if (mClientPid != getCallingPid()) {
438        ALOGE("%s: Camera %d: Lock call from pid %d; currently locked to pid %d",
439                __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
440        return EBUSY;
441    }
442
443    return OK;
444}
445
446status_t Camera2Client::unlock() {
447    ATRACE_CALL();
448    ALOGV("%s: E", __FUNCTION__);
449    Mutex::Autolock icl(mICameraLock);
450    ALOGV("%s: Camera %d: Unlock call from pid %d; current client pid %d",
451            __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
452
453    // TODO: Check for uninterruptable conditions
454
455    if (mClientPid == getCallingPid()) {
456        mClientPid = 0;
457        mCameraClient.clear();
458        mSharedCameraClient.clear();
459        return OK;
460    }
461
462    ALOGE("%s: Camera %d: Unlock call from pid %d; currently locked to pid %d",
463            __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
464    return EBUSY;
465}
466
467status_t Camera2Client::setPreviewDisplay(
468        const sp<Surface>& surface) {
469    ATRACE_CALL();
470    ALOGV("%s: E", __FUNCTION__);
471    Mutex::Autolock icl(mICameraLock);
472    status_t res;
473    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
474
475    sp<IBinder> binder;
476    sp<ANativeWindow> window;
477    if (surface != 0) {
478        binder = surface->asBinder();
479        window = surface;
480    }
481
482    return setPreviewWindowL(binder,window);
483}
484
485status_t Camera2Client::setPreviewTexture(
486        const sp<ISurfaceTexture>& surfaceTexture) {
487    ATRACE_CALL();
488    ALOGV("%s: E", __FUNCTION__);
489    Mutex::Autolock icl(mICameraLock);
490    status_t res;
491    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
492
493    sp<IBinder> binder;
494    sp<ANativeWindow> window;
495    if (surfaceTexture != 0) {
496        binder = surfaceTexture->asBinder();
497        window = new SurfaceTextureClient(surfaceTexture);
498    }
499    return setPreviewWindowL(binder, window);
500}
501
502status_t Camera2Client::setPreviewWindowL(const sp<IBinder>& binder,
503        sp<ANativeWindow> window) {
504    ATRACE_CALL();
505    status_t res;
506
507    if (binder == mPreviewSurface) {
508        ALOGV("%s: Camera %d: New window is same as old window",
509                __FUNCTION__, mCameraId);
510        return NO_ERROR;
511    }
512
513    SharedParameters::Lock l(mParameters);
514    switch (l.mParameters.state) {
515        case Parameters::DISCONNECTED:
516        case Parameters::RECORD:
517        case Parameters::STILL_CAPTURE:
518        case Parameters::VIDEO_SNAPSHOT:
519            ALOGE("%s: Camera %d: Cannot set preview display while in state %s",
520                    __FUNCTION__, mCameraId,
521                    Parameters::getStateName(l.mParameters.state));
522            return INVALID_OPERATION;
523        case Parameters::STOPPED:
524        case Parameters::WAITING_FOR_PREVIEW_WINDOW:
525            // OK
526            break;
527        case Parameters::PREVIEW:
528            // Already running preview - need to stop and create a new stream
529            // TODO: Optimize this so that we don't wait for old stream to drain
530            // before spinning up new stream
531            mDevice->clearStreamingRequest();
532            l.mParameters.state = Parameters::WAITING_FOR_PREVIEW_WINDOW;
533            break;
534    }
535
536    mPreviewSurface = binder;
537    res = mStreamingProcessor->setPreviewWindow(window);
538    if (res != OK) {
539        ALOGE("%s: Unable to set new preview window: %s (%d)",
540                __FUNCTION__, strerror(-res), res);
541        return res;
542    }
543
544    if (l.mParameters.state == Parameters::WAITING_FOR_PREVIEW_WINDOW) {
545        return startPreviewL(l.mParameters, false);
546    }
547
548    return OK;
549}
550
551void Camera2Client::setPreviewCallbackFlag(int flag) {
552    ATRACE_CALL();
553    ALOGV("%s: Camera %d: Flag 0x%x", __FUNCTION__, mCameraId, flag);
554    Mutex::Autolock icl(mICameraLock);
555    status_t res;
556    if ( checkPid(__FUNCTION__) != OK) return;
557
558    SharedParameters::Lock l(mParameters);
559    setPreviewCallbackFlagL(l.mParameters, flag);
560}
561
562void Camera2Client::setPreviewCallbackFlagL(Parameters &params, int flag) {
563    status_t res = OK;
564    if (flag & CAMERA_FRAME_CALLBACK_FLAG_ONE_SHOT_MASK) {
565        ALOGV("%s: setting oneshot", __FUNCTION__);
566        params.previewCallbackOneShot = true;
567    }
568    if (params.previewCallbackFlags != (uint32_t)flag) {
569        params.previewCallbackFlags = flag;
570        switch(params.state) {
571        case Parameters::PREVIEW:
572            res = startPreviewL(params, true);
573            break;
574        case Parameters::RECORD:
575        case Parameters::VIDEO_SNAPSHOT:
576            res = startRecordingL(params, true);
577            break;
578        default:
579            break;
580        }
581        if (res != OK) {
582            ALOGE("%s: Camera %d: Unable to refresh request in state %s",
583                    __FUNCTION__, mCameraId,
584                    Parameters::getStateName(params.state));
585        }
586    }
587
588}
589
590status_t Camera2Client::startPreview() {
591    ATRACE_CALL();
592    ALOGV("%s: E", __FUNCTION__);
593    Mutex::Autolock icl(mICameraLock);
594    status_t res;
595    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
596    SharedParameters::Lock l(mParameters);
597    return startPreviewL(l.mParameters, false);
598}
599
600status_t Camera2Client::startPreviewL(Parameters &params, bool restart) {
601    ATRACE_CALL();
602    status_t res;
603
604    ALOGV("%s: state == %d, restart = %d", __FUNCTION__, params.state, restart);
605
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
796    ALOGV("%s: state == %d, restart = %d", __FUNCTION__, params.state, restart);
797
798    switch (params.state) {
799        case Parameters::STOPPED:
800            res = startPreviewL(params, false);
801            if (res != OK) return res;
802            break;
803        case Parameters::PREVIEW:
804            // Ready to go
805            break;
806        case Parameters::RECORD:
807        case Parameters::VIDEO_SNAPSHOT:
808            // OK to call this when recording is already on, just skip unless
809            // we're looking to restart
810            if (!restart) return OK;
811            break;
812        default:
813            ALOGE("%s: Camera %d: Can't start recording in state %s",
814                    __FUNCTION__, mCameraId,
815                    Parameters::getStateName(params.state));
816            return INVALID_OPERATION;
817    };
818
819    if (!params.storeMetadataInBuffers) {
820        ALOGE("%s: Camera %d: Recording only supported in metadata mode, but "
821                "non-metadata recording mode requested!", __FUNCTION__,
822                mCameraId);
823        return INVALID_OPERATION;
824    }
825
826    if (!restart) {
827        mCameraService->playSound(CameraService::SOUND_RECORDING);
828        mStreamingProcessor->updateRecordingRequest(params);
829        if (res != OK) {
830            ALOGE("%s: Camera %d: Unable to update recording request: %s (%d)",
831                    __FUNCTION__, mCameraId, strerror(-res), res);
832            return res;
833        }
834    }
835
836    res = mStreamingProcessor->updateRecordingStream(params);
837    if (res != OK) {
838        ALOGE("%s: Camera %d: Unable to update recording stream: %s (%d)",
839                __FUNCTION__, mCameraId, strerror(-res), res);
840        return res;
841    }
842
843    Vector<uint8_t> outputStreams;
844    bool callbacksEnabled = params.previewCallbackFlags &
845        CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK;
846    if (callbacksEnabled) {
847        res = mCallbackProcessor->updateStream(params);
848        if (res != OK) {
849            ALOGE("%s: Camera %d: Unable to update callback stream: %s (%d)",
850                    __FUNCTION__, mCameraId, strerror(-res), res);
851            return res;
852        }
853        outputStreams.push(getCallbackStreamId());
854    }
855    outputStreams.push(getPreviewStreamId());
856    outputStreams.push(getRecordingStreamId());
857
858    res = mStreamingProcessor->startStream(StreamingProcessor::RECORD,
859            outputStreams);
860    if (res != OK) {
861        ALOGE("%s: Camera %d: Unable to start recording stream: %s (%d)",
862                __FUNCTION__, mCameraId, strerror(-res), res);
863        return res;
864    }
865
866    if (params.state < Parameters::RECORD) {
867        params.state = Parameters::RECORD;
868    }
869
870    return OK;
871}
872
873void Camera2Client::stopRecording() {
874    ATRACE_CALL();
875    ALOGV("%s: E", __FUNCTION__);
876    Mutex::Autolock icl(mICameraLock);
877    SharedParameters::Lock l(mParameters);
878
879    status_t res;
880    if ( (res = checkPid(__FUNCTION__) ) != OK) return;
881
882    switch (l.mParameters.state) {
883        case Parameters::RECORD:
884            // OK to stop
885            break;
886        case Parameters::STOPPED:
887        case Parameters::PREVIEW:
888        case Parameters::STILL_CAPTURE:
889        case Parameters::VIDEO_SNAPSHOT:
890        default:
891            ALOGE("%s: Camera %d: Can't stop recording in state %s",
892                    __FUNCTION__, mCameraId,
893                    Parameters::getStateName(l.mParameters.state));
894            return;
895    };
896
897    mCameraService->playSound(CameraService::SOUND_RECORDING);
898
899    res = startPreviewL(l.mParameters, true);
900    if (res != OK) {
901        ALOGE("%s: Camera %d: Unable to return to preview",
902                __FUNCTION__, mCameraId);
903    }
904}
905
906bool Camera2Client::recordingEnabled() {
907    ATRACE_CALL();
908    Mutex::Autolock icl(mICameraLock);
909
910    if ( checkPid(__FUNCTION__) != OK) return false;
911
912    return recordingEnabledL();
913}
914
915bool Camera2Client::recordingEnabledL() {
916    ATRACE_CALL();
917    SharedParameters::Lock l(mParameters);
918
919    return (l.mParameters.state == Parameters::RECORD
920            || l.mParameters.state == Parameters::VIDEO_SNAPSHOT);
921}
922
923void Camera2Client::releaseRecordingFrame(const sp<IMemory>& mem) {
924    ATRACE_CALL();
925    Mutex::Autolock icl(mICameraLock);
926    if ( checkPid(__FUNCTION__) != OK) return;
927
928    mStreamingProcessor->releaseRecordingFrame(mem);
929}
930
931status_t Camera2Client::autoFocus() {
932    ATRACE_CALL();
933    Mutex::Autolock icl(mICameraLock);
934    ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
935    status_t res;
936    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
937
938    int triggerId;
939    {
940        SharedParameters::Lock l(mParameters);
941        l.mParameters.currentAfTriggerId = ++l.mParameters.afTriggerCounter;
942        triggerId = l.mParameters.currentAfTriggerId;
943    }
944
945    mDevice->triggerAutofocus(triggerId);
946
947    return OK;
948}
949
950status_t Camera2Client::cancelAutoFocus() {
951    ATRACE_CALL();
952    Mutex::Autolock icl(mICameraLock);
953    ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
954    status_t res;
955    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
956
957    int triggerId;
958    {
959        SharedParameters::Lock l(mParameters);
960        triggerId = ++l.mParameters.afTriggerCounter;
961    }
962
963    mDevice->triggerCancelAutofocus(triggerId);
964
965    return OK;
966}
967
968status_t Camera2Client::takePicture(int msgType) {
969    ATRACE_CALL();
970    Mutex::Autolock icl(mICameraLock);
971    status_t res;
972    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
973
974    SharedParameters::Lock l(mParameters);
975    switch (l.mParameters.state) {
976        case Parameters::DISCONNECTED:
977        case Parameters::STOPPED:
978        case Parameters::WAITING_FOR_PREVIEW_WINDOW:
979            ALOGE("%s: Camera %d: Cannot take picture without preview enabled",
980                    __FUNCTION__, mCameraId);
981            return INVALID_OPERATION;
982        case Parameters::PREVIEW:
983            // Good to go for takePicture
984            res = commandStopFaceDetectionL(l.mParameters);
985            if (res != OK) {
986                ALOGE("%s: Camera %d: Unable to stop face detection for still capture",
987                        __FUNCTION__, mCameraId);
988                return res;
989            }
990            l.mParameters.state = Parameters::STILL_CAPTURE;
991            break;
992        case Parameters::RECORD:
993            // Good to go for video snapshot
994            l.mParameters.state = Parameters::VIDEO_SNAPSHOT;
995            break;
996        case Parameters::STILL_CAPTURE:
997        case Parameters::VIDEO_SNAPSHOT:
998            ALOGE("%s: Camera %d: Already taking a picture",
999                    __FUNCTION__, mCameraId);
1000            return INVALID_OPERATION;
1001    }
1002
1003    ALOGV("%s: Camera %d: Starting picture capture", __FUNCTION__, mCameraId);
1004
1005    res = mJpegProcessor->updateStream(l.mParameters);
1006    if (res != OK) {
1007        ALOGE("%s: Camera %d: Can't set up still image stream: %s (%d)",
1008                __FUNCTION__, mCameraId, strerror(-res), res);
1009        return res;
1010    }
1011
1012    res = mCaptureSequencer->startCapture();
1013    if (res != OK) {
1014        ALOGE("%s: Camera %d: Unable to start capture: %s (%d)",
1015                __FUNCTION__, mCameraId, strerror(-res), res);
1016    }
1017
1018    return res;
1019}
1020
1021status_t Camera2Client::setParameters(const String8& params) {
1022    ATRACE_CALL();
1023    ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
1024    Mutex::Autolock icl(mICameraLock);
1025    status_t res;
1026    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1027
1028    SharedParameters::Lock l(mParameters);
1029
1030    res = l.mParameters.set(params);
1031    if (res != OK) return res;
1032
1033    res = updateRequests(l.mParameters);
1034
1035    return res;
1036}
1037
1038String8 Camera2Client::getParameters() const {
1039    ATRACE_CALL();
1040    ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
1041    Mutex::Autolock icl(mICameraLock);
1042    if ( checkPid(__FUNCTION__) != OK) return String8();
1043
1044    SharedParameters::ReadLock l(mParameters);
1045
1046    return l.mParameters.get();
1047}
1048
1049status_t Camera2Client::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) {
1050    ATRACE_CALL();
1051    Mutex::Autolock icl(mICameraLock);
1052    status_t res;
1053    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1054
1055    ALOGV("%s: Camera %d: Command %d (%d, %d)", __FUNCTION__, mCameraId,
1056            cmd, arg1, arg2);
1057
1058    switch (cmd) {
1059        case CAMERA_CMD_START_SMOOTH_ZOOM:
1060            return commandStartSmoothZoomL();
1061        case CAMERA_CMD_STOP_SMOOTH_ZOOM:
1062            return commandStopSmoothZoomL();
1063        case CAMERA_CMD_SET_DISPLAY_ORIENTATION:
1064            return commandSetDisplayOrientationL(arg1);
1065        case CAMERA_CMD_ENABLE_SHUTTER_SOUND:
1066            return commandEnableShutterSoundL(arg1 == 1);
1067        case CAMERA_CMD_PLAY_RECORDING_SOUND:
1068            return commandPlayRecordingSoundL();
1069        case CAMERA_CMD_START_FACE_DETECTION:
1070            return commandStartFaceDetectionL(arg1);
1071        case CAMERA_CMD_STOP_FACE_DETECTION: {
1072            SharedParameters::Lock l(mParameters);
1073            return commandStopFaceDetectionL(l.mParameters);
1074        }
1075        case CAMERA_CMD_ENABLE_FOCUS_MOVE_MSG:
1076            return commandEnableFocusMoveMsgL(arg1 == 1);
1077        case CAMERA_CMD_PING:
1078            return commandPingL();
1079        case CAMERA_CMD_SET_VIDEO_BUFFER_COUNT:
1080            return commandSetVideoBufferCountL(arg1);
1081        default:
1082            ALOGE("%s: Unknown command %d (arguments %d, %d)",
1083                    __FUNCTION__, cmd, arg1, arg2);
1084            return BAD_VALUE;
1085    }
1086}
1087
1088status_t Camera2Client::commandStartSmoothZoomL() {
1089    ALOGE("%s: Unimplemented!", __FUNCTION__);
1090    return OK;
1091}
1092
1093status_t Camera2Client::commandStopSmoothZoomL() {
1094    ALOGE("%s: Unimplemented!", __FUNCTION__);
1095    return OK;
1096}
1097
1098status_t Camera2Client::commandSetDisplayOrientationL(int degrees) {
1099    int transform = Parameters::degToTransform(degrees,
1100            mCameraFacing == CAMERA_FACING_FRONT);
1101    if (transform == -1) {
1102        ALOGE("%s: Camera %d: Error setting %d as display orientation value",
1103                __FUNCTION__, mCameraId, degrees);
1104        return BAD_VALUE;
1105    }
1106    SharedParameters::Lock l(mParameters);
1107    if (transform != l.mParameters.previewTransform &&
1108            getPreviewStreamId() != NO_STREAM) {
1109        mDevice->setStreamTransform(getPreviewStreamId(), transform);
1110    }
1111    l.mParameters.previewTransform = transform;
1112    return OK;
1113}
1114
1115status_t Camera2Client::commandEnableShutterSoundL(bool enable) {
1116    SharedParameters::Lock l(mParameters);
1117    if (enable) {
1118        l.mParameters.playShutterSound = true;
1119        return OK;
1120    }
1121
1122    // Disabling shutter sound may not be allowed. In that case only
1123    // allow the mediaserver process to disable the sound.
1124    char value[PROPERTY_VALUE_MAX];
1125    property_get("ro.camera.sound.forced", value, "0");
1126    if (strncmp(value, "0", 2) != 0) {
1127        // Disabling shutter sound is not allowed. Deny if the current
1128        // process is not mediaserver.
1129        if (getCallingPid() != getpid()) {
1130            ALOGE("Failed to disable shutter sound. Permission denied (pid %d)",
1131                    getCallingPid());
1132            return PERMISSION_DENIED;
1133        }
1134    }
1135
1136    l.mParameters.playShutterSound = false;
1137    return OK;
1138}
1139
1140status_t Camera2Client::commandPlayRecordingSoundL() {
1141    mCameraService->playSound(CameraService::SOUND_RECORDING);
1142    return OK;
1143}
1144
1145status_t Camera2Client::commandStartFaceDetectionL(int type) {
1146    ALOGV("%s: Camera %d: Starting face detection",
1147          __FUNCTION__, mCameraId);
1148    status_t res;
1149    SharedParameters::Lock l(mParameters);
1150    switch (l.mParameters.state) {
1151        case Parameters::DISCONNECTED:
1152        case Parameters::STOPPED:
1153        case Parameters::WAITING_FOR_PREVIEW_WINDOW:
1154        case Parameters::STILL_CAPTURE:
1155            ALOGE("%s: Camera %d: Cannot start face detection without preview active",
1156                    __FUNCTION__, mCameraId);
1157            return INVALID_OPERATION;
1158        case Parameters::PREVIEW:
1159        case Parameters::RECORD:
1160        case Parameters::VIDEO_SNAPSHOT:
1161            // Good to go for starting face detect
1162            break;
1163    }
1164    // Ignoring type
1165    if (l.mParameters.fastInfo.bestFaceDetectMode ==
1166            ANDROID_STATS_FACE_DETECTION_OFF) {
1167        ALOGE("%s: Camera %d: Face detection not supported",
1168                __FUNCTION__, mCameraId);
1169        return INVALID_OPERATION;
1170    }
1171    if (l.mParameters.enableFaceDetect) return OK;
1172
1173    l.mParameters.enableFaceDetect = true;
1174
1175    res = updateRequests(l.mParameters);
1176
1177    return res;
1178}
1179
1180status_t Camera2Client::commandStopFaceDetectionL(Parameters &params) {
1181    status_t res = OK;
1182    ALOGV("%s: Camera %d: Stopping face detection",
1183          __FUNCTION__, mCameraId);
1184
1185    if (!params.enableFaceDetect) return OK;
1186
1187    params.enableFaceDetect = false;
1188
1189    if (params.state == Parameters::PREVIEW
1190            || params.state == Parameters::RECORD
1191            || params.state == Parameters::VIDEO_SNAPSHOT) {
1192        res = updateRequests(params);
1193    }
1194
1195    return res;
1196}
1197
1198status_t Camera2Client::commandEnableFocusMoveMsgL(bool enable) {
1199    SharedParameters::Lock l(mParameters);
1200    l.mParameters.enableFocusMoveMessages = enable;
1201
1202    return OK;
1203}
1204
1205status_t Camera2Client::commandPingL() {
1206    // Always ping back if access is proper and device is alive
1207    SharedParameters::Lock l(mParameters);
1208    if (l.mParameters.state != Parameters::DISCONNECTED) {
1209        return OK;
1210    } else {
1211        return NO_INIT;
1212    }
1213}
1214
1215status_t Camera2Client::commandSetVideoBufferCountL(size_t count) {
1216    if (recordingEnabledL()) {
1217        ALOGE("%s: Camera %d: Error setting video buffer count after "
1218                "recording was started", __FUNCTION__, mCameraId);
1219        return INVALID_OPERATION;
1220    }
1221
1222    return mStreamingProcessor->setRecordingBufferCount(count);
1223}
1224
1225/** Device-related methods */
1226
1227void Camera2Client::notifyError(int errorCode, int arg1, int arg2) {
1228    ALOGE("Error condition %d reported by HAL, arguments %d, %d", errorCode, arg1, arg2);
1229}
1230
1231void Camera2Client::notifyShutter(int frameNumber, nsecs_t timestamp) {
1232    ALOGV("%s: Shutter notification for frame %d at time %lld", __FUNCTION__,
1233            frameNumber, timestamp);
1234}
1235
1236void Camera2Client::notifyAutoFocus(uint8_t newState, int triggerId) {
1237    ALOGV("%s: Autofocus state now %d, last trigger %d",
1238            __FUNCTION__, newState, triggerId);
1239    bool sendCompletedMessage = false;
1240    bool sendMovingMessage = false;
1241
1242    bool success = false;
1243    bool afInMotion = false;
1244    {
1245        SharedParameters::Lock l(mParameters);
1246        switch (l.mParameters.focusMode) {
1247            case Parameters::FOCUS_MODE_AUTO:
1248            case Parameters::FOCUS_MODE_MACRO:
1249                // Don't send notifications upstream if they're not for the current AF
1250                // trigger. For example, if cancel was called in between, or if we
1251                // already sent a notification about this AF call.
1252                if (triggerId != l.mParameters.currentAfTriggerId) break;
1253                switch (newState) {
1254                    case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED:
1255                        success = true;
1256                        // no break
1257                    case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED:
1258                        sendCompletedMessage = true;
1259                        l.mParameters.currentAfTriggerId = -1;
1260                        break;
1261                    case ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN:
1262                        // Just starting focusing, ignore
1263                        break;
1264                    case ANDROID_CONTROL_AF_STATE_INACTIVE:
1265                    case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN:
1266                    case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED:
1267                    default:
1268                        // Unexpected in AUTO/MACRO mode
1269                        ALOGE("%s: Unexpected AF state transition in AUTO/MACRO mode: %d",
1270                                __FUNCTION__, newState);
1271                        break;
1272                }
1273                break;
1274            case Parameters::FOCUS_MODE_CONTINUOUS_VIDEO:
1275            case Parameters::FOCUS_MODE_CONTINUOUS_PICTURE:
1276                switch (newState) {
1277                    case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED:
1278                        success = true;
1279                        // no break
1280                    case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED:
1281                        // Don't send notifications upstream if they're not for
1282                        // the current AF trigger. For example, if cancel was
1283                        // called in between, or if we already sent a
1284                        // notification about this AF call.
1285                        // Send both a 'AF done' callback and a 'AF move' callback
1286                        if (triggerId != l.mParameters.currentAfTriggerId) break;
1287                        sendCompletedMessage = true;
1288                        afInMotion = false;
1289                        if (l.mParameters.enableFocusMoveMessages &&
1290                                l.mParameters.afInMotion) {
1291                            sendMovingMessage = true;
1292                        }
1293                        l.mParameters.currentAfTriggerId = -1;
1294                        break;
1295                    case ANDROID_CONTROL_AF_STATE_INACTIVE:
1296                        // Cancel was called, or we switched state; care if
1297                        // currently moving
1298                        afInMotion = false;
1299                        if (l.mParameters.enableFocusMoveMessages &&
1300                                l.mParameters.afInMotion) {
1301                            sendMovingMessage = true;
1302                        }
1303                        break;
1304                    case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN:
1305                        // Start passive scan, inform upstream
1306                        afInMotion = true;
1307                        // no break
1308                    case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED:
1309                        // Stop passive scan, inform upstream
1310                        if (l.mParameters.enableFocusMoveMessages) {
1311                            sendMovingMessage = true;
1312                        }
1313                        break;
1314                }
1315                l.mParameters.afInMotion = afInMotion;
1316                break;
1317            case Parameters::FOCUS_MODE_EDOF:
1318            case Parameters::FOCUS_MODE_INFINITY:
1319            case Parameters::FOCUS_MODE_FIXED:
1320            default:
1321                if (newState != ANDROID_CONTROL_AF_STATE_INACTIVE) {
1322                    ALOGE("%s: Unexpected AF state change %d "
1323                            "(ID %d) in focus mode %d",
1324                          __FUNCTION__, newState, triggerId,
1325                            l.mParameters.focusMode);
1326                }
1327        }
1328    }
1329    if (sendMovingMessage) {
1330        SharedCameraClient::Lock l(mSharedCameraClient);
1331        if (l.mCameraClient != 0) {
1332            l.mCameraClient->notifyCallback(CAMERA_MSG_FOCUS_MOVE,
1333                    afInMotion ? 1 : 0, 0);
1334        }
1335    }
1336    if (sendCompletedMessage) {
1337        SharedCameraClient::Lock l(mSharedCameraClient);
1338        if (l.mCameraClient != 0) {
1339            l.mCameraClient->notifyCallback(CAMERA_MSG_FOCUS,
1340                    success ? 1 : 0, 0);
1341        }
1342    }
1343}
1344
1345void Camera2Client::notifyAutoExposure(uint8_t newState, int triggerId) {
1346    ALOGV("%s: Autoexposure state now %d, last trigger %d",
1347            __FUNCTION__, newState, triggerId);
1348    mCaptureSequencer->notifyAutoExposure(newState, triggerId);
1349}
1350
1351void Camera2Client::notifyAutoWhitebalance(uint8_t newState, int triggerId) {
1352    ALOGV("%s: Auto-whitebalance state now %d, last trigger %d",
1353            __FUNCTION__, newState, triggerId);
1354}
1355
1356int Camera2Client::getCameraId() const {
1357    return mCameraId;
1358}
1359
1360const sp<Camera2Device>& Camera2Client::getCameraDevice() {
1361    return mDevice;
1362}
1363
1364const sp<CameraService>& Camera2Client::getCameraService() {
1365    return mCameraService;
1366}
1367
1368camera2::SharedParameters& Camera2Client::getParameters() {
1369    return mParameters;
1370}
1371
1372int Camera2Client::getPreviewStreamId() const {
1373    return mStreamingProcessor->getPreviewStreamId();
1374}
1375
1376int Camera2Client::getCaptureStreamId() const {
1377    return mJpegProcessor->getStreamId();
1378}
1379
1380int Camera2Client::getCallbackStreamId() const {
1381    return mCallbackProcessor->getStreamId();
1382}
1383
1384int Camera2Client::getRecordingStreamId() const {
1385    return mStreamingProcessor->getRecordingStreamId();
1386}
1387
1388int Camera2Client::getZslStreamId() const {
1389    return mZslProcessor->getStreamId();
1390}
1391
1392status_t Camera2Client::registerFrameListener(int32_t id,
1393        wp<camera2::FrameProcessor::FilteredListener> listener) {
1394    return mFrameProcessor->registerListener(id, listener);
1395}
1396
1397status_t Camera2Client::removeFrameListener(int32_t id) {
1398    return mFrameProcessor->removeListener(id);
1399}
1400
1401Camera2Client::SharedCameraClient::Lock::Lock(SharedCameraClient &client):
1402        mCameraClient(client.mCameraClient),
1403        mSharedClient(client) {
1404    mSharedClient.mCameraClientLock.lock();
1405}
1406
1407Camera2Client::SharedCameraClient::Lock::~Lock() {
1408    mSharedClient.mCameraClientLock.unlock();
1409}
1410
1411Camera2Client::SharedCameraClient::SharedCameraClient(const sp<ICameraClient>&client):
1412        mCameraClient(client) {
1413}
1414
1415Camera2Client::SharedCameraClient& Camera2Client::SharedCameraClient::operator=(
1416        const sp<ICameraClient>&client) {
1417    Mutex::Autolock l(mCameraClientLock);
1418    mCameraClient = client;
1419    return *this;
1420}
1421
1422void Camera2Client::SharedCameraClient::clear() {
1423    Mutex::Autolock l(mCameraClientLock);
1424    mCameraClient.clear();
1425}
1426
1427const int32_t Camera2Client::kPreviewRequestId;
1428const int32_t Camera2Client::kRecordRequestId;
1429const int32_t Camera2Client::kFirstCaptureRequestId;
1430
1431/** Utility methods */
1432
1433status_t Camera2Client::updateRequests(Parameters &params) {
1434    status_t res;
1435
1436    ALOGV("%s: Camera %d: state = %d", __FUNCTION__, getCameraId(), params.state);
1437
1438    res = mStreamingProcessor->updatePreviewRequest(params);
1439    if (res != OK) {
1440        ALOGE("%s: Camera %d: Unable to update preview request: %s (%d)",
1441                __FUNCTION__, mCameraId, strerror(-res), res);
1442        return res;
1443    }
1444    res = mStreamingProcessor->updateRecordingRequest(params);
1445    if (res != OK) {
1446        ALOGE("%s: Camera %d: Unable to update recording request: %s (%d)",
1447                __FUNCTION__, mCameraId, strerror(-res), res);
1448        return res;
1449    }
1450
1451    if (params.state == Parameters::PREVIEW) {
1452        res = startPreviewL(params, true);
1453        if (res != OK) {
1454            ALOGE("%s: Camera %d: Error streaming new preview request: %s (%d)",
1455                    __FUNCTION__, mCameraId, strerror(-res), res);
1456            return res;
1457        }
1458    } else if (params.state == Parameters::RECORD ||
1459            params.state == Parameters::VIDEO_SNAPSHOT) {
1460        res = startRecordingL(params, true);
1461        if (res != OK) {
1462            ALOGE("%s: Camera %d: Error streaming new record request: %s (%d)",
1463                    __FUNCTION__, mCameraId, strerror(-res), res);
1464            return res;
1465        }
1466    }
1467    return res;
1468}
1469
1470
1471size_t Camera2Client::calculateBufferSize(int width, int height,
1472        int format, int stride) {
1473    switch (format) {
1474        case HAL_PIXEL_FORMAT_YCbCr_422_SP: // NV16
1475            return width * height * 2;
1476        case HAL_PIXEL_FORMAT_YCrCb_420_SP: // NV21
1477            return width * height * 3 / 2;
1478        case HAL_PIXEL_FORMAT_YCbCr_422_I: // YUY2
1479            return width * height * 2;
1480        case HAL_PIXEL_FORMAT_YV12: {      // YV12
1481            size_t ySize = stride * height;
1482            size_t uvStride = (stride / 2 + 0xF) & ~0xF;
1483            size_t uvSize = uvStride * height / 2;
1484            return ySize + uvSize * 2;
1485        }
1486        case HAL_PIXEL_FORMAT_RGB_565:
1487            return width * height * 2;
1488        case HAL_PIXEL_FORMAT_RGBA_8888:
1489            return width * height * 4;
1490        case HAL_PIXEL_FORMAT_RAW_SENSOR:
1491            return width * height * 2;
1492        default:
1493            ALOGE("%s: Unknown preview format: %x",
1494                    __FUNCTION__,  format);
1495            return 0;
1496    }
1497}
1498
1499} // namespace android
1500