Camera2Client.cpp revision 73bbd1f1c493835f191ea2b0b72439292496b40a 
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    write(fd, result.string(), result.size());
319
320    mStreamingProcessor->dump(fd, args);
321
322    mCaptureSequencer->dump(fd, args);
323
324    mFrameProcessor->dump(fd, args);
325
326    mZslProcessor->dump(fd, args);
327
328    result = "  Device dump:\n";
329    write(fd, result.string(), result.size());
330
331    status_t res = mDevice->dump(fd, args);
332    if (res != OK) {
333        result = String8::format("   Error dumping device: %s (%d)",
334                strerror(-res), res);
335        write(fd, result.string(), result.size());
336    }
337
338#undef CASE_APPEND_ENUM
339    return NO_ERROR;
340}
341
342// ICamera interface
343
344void Camera2Client::disconnect() {
345    ATRACE_CALL();
346    Mutex::Autolock icl(mICameraLock);
347    status_t res;
348    if ( (res = checkPid(__FUNCTION__) ) != OK) return;
349
350    if (mDevice == 0) return;
351
352    ALOGV("Camera %d: Shutting down", mCameraId);
353
354    stopPreviewL();
355
356    {
357        SharedParameters::Lock l(mParameters);
358        l.mParameters.state = Parameters::DISCONNECTED;
359    }
360
361    mStreamingProcessor->deletePreviewStream();
362    mStreamingProcessor->deleteRecordingStream();
363    mJpegProcessor->deleteStream();
364    mCallbackProcessor->deleteStream();
365    mZslProcessor->deleteStream();
366
367    mFrameProcessor->requestExit();
368    mCaptureSequencer->requestExit();
369    mJpegProcessor->requestExit();
370    mZslProcessor->requestExit();
371    mCallbackProcessor->requestExit();
372
373    ALOGV("Camera %d: Waiting for threads", mCameraId);
374
375    mFrameProcessor->join();
376    mCaptureSequencer->join();
377    mJpegProcessor->join();
378    mZslProcessor->join();
379    mCallbackProcessor->join();
380
381    ALOGV("Camera %d: Disconnecting device", mCameraId);
382
383    mDevice->disconnect();
384
385    mDevice.clear();
386
387    CameraService::Client::disconnect();
388}
389
390status_t Camera2Client::connect(const sp<ICameraClient>& client) {
391    ATRACE_CALL();
392    ALOGV("%s: E", __FUNCTION__);
393    Mutex::Autolock icl(mICameraLock);
394
395    if (mClientPid != 0 && getCallingPid() != mClientPid) {
396        ALOGE("%s: Camera %d: Connection attempt from pid %d; "
397                "current locked to pid %d", __FUNCTION__,
398                mCameraId, getCallingPid(), mClientPid);
399        return BAD_VALUE;
400    }
401
402    mClientPid = getCallingPid();
403
404    mCameraClient = client;
405    mSharedCameraClient = client;
406
407    SharedParameters::Lock l(mParameters);
408    l.mParameters.state = Parameters::STOPPED;
409
410    return OK;
411}
412
413status_t Camera2Client::lock() {
414    ATRACE_CALL();
415    ALOGV("%s: E", __FUNCTION__);
416    Mutex::Autolock icl(mICameraLock);
417    ALOGV("%s: Camera %d: Lock call from pid %d; current client pid %d",
418            __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
419
420    if (mClientPid == 0) {
421        mClientPid = getCallingPid();
422        return OK;
423    }
424
425    if (mClientPid != getCallingPid()) {
426        ALOGE("%s: Camera %d: Lock call from pid %d; currently locked to pid %d",
427                __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
428        return EBUSY;
429    }
430
431    return OK;
432}
433
434status_t Camera2Client::unlock() {
435    ATRACE_CALL();
436    ALOGV("%s: E", __FUNCTION__);
437    Mutex::Autolock icl(mICameraLock);
438    ALOGV("%s: Camera %d: Unlock call from pid %d; current client pid %d",
439            __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
440
441    // TODO: Check for uninterruptable conditions
442
443    if (mClientPid == getCallingPid()) {
444        mClientPid = 0;
445        mCameraClient.clear();
446        mSharedCameraClient.clear();
447        return OK;
448    }
449
450    ALOGE("%s: Camera %d: Unlock call from pid %d; currently locked to pid %d",
451            __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
452    return EBUSY;
453}
454
455status_t Camera2Client::setPreviewDisplay(
456        const sp<Surface>& surface) {
457    ATRACE_CALL();
458    ALOGV("%s: E", __FUNCTION__);
459    Mutex::Autolock icl(mICameraLock);
460    status_t res;
461    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
462
463    sp<IBinder> binder;
464    sp<ANativeWindow> window;
465    if (surface != 0) {
466        binder = surface->asBinder();
467        window = surface;
468    }
469
470    return setPreviewWindowL(binder,window);
471}
472
473status_t Camera2Client::setPreviewTexture(
474        const sp<ISurfaceTexture>& surfaceTexture) {
475    ATRACE_CALL();
476    ALOGV("%s: E", __FUNCTION__);
477    Mutex::Autolock icl(mICameraLock);
478    status_t res;
479    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
480
481    sp<IBinder> binder;
482    sp<ANativeWindow> window;
483    if (surfaceTexture != 0) {
484        binder = surfaceTexture->asBinder();
485        window = new SurfaceTextureClient(surfaceTexture);
486    }
487    return setPreviewWindowL(binder, window);
488}
489
490status_t Camera2Client::setPreviewWindowL(const sp<IBinder>& binder,
491        sp<ANativeWindow> window) {
492    ATRACE_CALL();
493    status_t res;
494
495    if (binder == mPreviewSurface) {
496        ALOGV("%s: Camera %d: New window is same as old window",
497                __FUNCTION__, mCameraId);
498        return NO_ERROR;
499    }
500
501    SharedParameters::Lock l(mParameters);
502    switch (l.mParameters.state) {
503        case Parameters::DISCONNECTED:
504        case Parameters::RECORD:
505        case Parameters::STILL_CAPTURE:
506        case Parameters::VIDEO_SNAPSHOT:
507            ALOGE("%s: Camera %d: Cannot set preview display while in state %s",
508                    __FUNCTION__, mCameraId,
509                    Parameters::getStateName(l.mParameters.state));
510            return INVALID_OPERATION;
511        case Parameters::STOPPED:
512        case Parameters::WAITING_FOR_PREVIEW_WINDOW:
513            // OK
514            break;
515        case Parameters::PREVIEW:
516            // Already running preview - need to stop and create a new stream
517            // TODO: Optimize this so that we don't wait for old stream to drain
518            // before spinning up new stream
519            mDevice->clearStreamingRequest();
520            l.mParameters.state = Parameters::WAITING_FOR_PREVIEW_WINDOW;
521            break;
522    }
523
524    mPreviewSurface = binder;
525    res = mStreamingProcessor->setPreviewWindow(window);
526    if (res != OK) {
527        ALOGE("%s: Unable to set new preview window: %s (%d)",
528                __FUNCTION__, strerror(-res), res);
529        return res;
530    }
531
532    if (l.mParameters.state == Parameters::WAITING_FOR_PREVIEW_WINDOW) {
533        return startPreviewL(l.mParameters, false);
534    }
535
536    return OK;
537}
538
539void Camera2Client::setPreviewCallbackFlag(int flag) {
540    ATRACE_CALL();
541    ALOGV("%s: Camera %d: Flag 0x%x", __FUNCTION__, mCameraId, flag);
542    Mutex::Autolock icl(mICameraLock);
543    status_t res;
544    if ( checkPid(__FUNCTION__) != OK) return;
545
546    SharedParameters::Lock l(mParameters);
547    setPreviewCallbackFlagL(l.mParameters, flag);
548}
549
550void Camera2Client::setPreviewCallbackFlagL(Parameters &params, int flag) {
551    status_t res = OK;
552    if (flag & CAMERA_FRAME_CALLBACK_FLAG_ONE_SHOT_MASK) {
553        ALOGV("%s: setting oneshot", __FUNCTION__);
554        params.previewCallbackOneShot = true;
555    }
556    if (params.previewCallbackFlags != (uint32_t)flag) {
557        params.previewCallbackFlags = flag;
558        switch(params.state) {
559        case Parameters::PREVIEW:
560            res = startPreviewL(params, true);
561            break;
562        case Parameters::RECORD:
563        case Parameters::VIDEO_SNAPSHOT:
564            res = startRecordingL(params, true);
565            break;
566        default:
567            break;
568        }
569        if (res != OK) {
570            ALOGE("%s: Camera %d: Unable to refresh request in state %s",
571                    __FUNCTION__, mCameraId,
572                    Parameters::getStateName(params.state));
573        }
574    }
575
576}
577
578status_t Camera2Client::startPreview() {
579    ATRACE_CALL();
580    ALOGV("%s: E", __FUNCTION__);
581    Mutex::Autolock icl(mICameraLock);
582    status_t res;
583    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
584    SharedParameters::Lock l(mParameters);
585    return startPreviewL(l.mParameters, false);
586}
587
588status_t Camera2Client::startPreviewL(Parameters &params, bool restart) {
589    ATRACE_CALL();
590    status_t res;
591    if (params.state == Parameters::PREVIEW && !restart) {
592        // Succeed attempt to re-enter preview state
593        ALOGI("%s: Not starting preview; already in preview state.",
594              __FUNCTION__);
595        return OK;
596    }
597    if (params.state > Parameters::PREVIEW && !restart) {
598        ALOGE("%s: Can't start preview in state %s",
599                __FUNCTION__,
600                Parameters::getStateName(params.state));
601        return INVALID_OPERATION;
602    }
603
604    if (!mStreamingProcessor->haveValidPreviewWindow()) {
605        params.state = Parameters::WAITING_FOR_PREVIEW_WINDOW;
606        return OK;
607    }
608    params.state = Parameters::STOPPED;
609
610    res = mStreamingProcessor->updatePreviewStream(params);
611    if (res != OK) {
612        ALOGE("%s: Camera %d: Unable to update preview stream: %s (%d)",
613                __FUNCTION__, mCameraId, strerror(-res), res);
614        return res;
615    }
616
617    Vector<uint8_t> outputStreams;
618    bool callbacksEnabled = params.previewCallbackFlags &
619        CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK;
620    if (callbacksEnabled) {
621        res = mCallbackProcessor->updateStream(params);
622        if (res != OK) {
623            ALOGE("%s: Camera %d: Unable to update callback stream: %s (%d)",
624                    __FUNCTION__, mCameraId, strerror(-res), res);
625            return res;
626        }
627        outputStreams.push(getCallbackStreamId());
628    }
629    if (params.zslMode && !params.recordingHint) {
630        res = mZslProcessor->updateStream(params);
631        if (res != OK) {
632            ALOGE("%s: Camera %d: Unable to update ZSL stream: %s (%d)",
633                    __FUNCTION__, mCameraId, strerror(-res), res);
634            return res;
635        }
636        outputStreams.push(getZslStreamId());
637    }
638
639    outputStreams.push(getPreviewStreamId());
640
641    if (!params.recordingHint) {
642        if (!restart) {
643            res = mStreamingProcessor->updatePreviewRequest(params);
644            if (res != OK) {
645                ALOGE("%s: Camera %d: Can't set up preview request: "
646                        "%s (%d)", __FUNCTION__, mCameraId,
647                        strerror(-res), res);
648                return res;
649            }
650        }
651        res = mStreamingProcessor->startStream(StreamingProcessor::PREVIEW,
652                outputStreams);
653    } else {
654        // With recording hint set, we're going to be operating under the
655        // assumption that the user will record video. To optimize recording
656        // startup time, create the necessary output streams for recording and
657        // video snapshot now if they don't already exist.
658        res = mJpegProcessor->updateStream(params);
659        if (res != OK) {
660            ALOGE("%s: Camera %d: Can't pre-configure still image "
661                    "stream: %s (%d)",
662                    __FUNCTION__, mCameraId, strerror(-res), res);
663            return res;
664        }
665
666        if (!restart) {
667            res = mStreamingProcessor->updateRecordingRequest(params);
668            if (res != OK) {
669                ALOGE("%s: Camera %d: Can't set up preview request with "
670                        "record hint: %s (%d)", __FUNCTION__, mCameraId,
671                        strerror(-res), res);
672                return res;
673            }
674        }
675        res = mStreamingProcessor->startStream(StreamingProcessor::RECORD,
676                outputStreams);
677    }
678    if (res != OK) {
679        ALOGE("%s: Camera %d: Unable to start streaming preview: %s (%d)",
680                __FUNCTION__, mCameraId, strerror(-res), res);
681        return res;
682    }
683
684    params.state = Parameters::PREVIEW;
685    return OK;
686}
687
688void Camera2Client::stopPreview() {
689    ATRACE_CALL();
690    ALOGV("%s: E", __FUNCTION__);
691    Mutex::Autolock icl(mICameraLock);
692    status_t res;
693    if ( (res = checkPid(__FUNCTION__) ) != OK) return;
694    stopPreviewL();
695}
696
697void Camera2Client::stopPreviewL() {
698    ATRACE_CALL();
699    Parameters::State state;
700    {
701        SharedParameters::Lock l(mParameters);
702        state = l.mParameters.state;
703    }
704
705    switch (state) {
706        case Parameters::DISCONNECTED:
707            ALOGE("%s: Camera %d: Call before initialized",
708                    __FUNCTION__, mCameraId);
709            break;
710        case Parameters::STOPPED:
711            break;
712        case Parameters::STILL_CAPTURE:
713            ALOGE("%s: Camera %d: Cannot stop preview during still capture.",
714                    __FUNCTION__, mCameraId);
715            break;
716        case Parameters::RECORD:
717            // no break - identical to preview
718        case Parameters::PREVIEW:
719            mStreamingProcessor->stopStream();
720            // no break
721        case Parameters::WAITING_FOR_PREVIEW_WINDOW: {
722            SharedParameters::Lock l(mParameters);
723            l.mParameters.state = Parameters::STOPPED;
724            commandStopFaceDetectionL(l.mParameters);
725            break;
726        }
727        default:
728            ALOGE("%s: Camera %d: Unknown state %d", __FUNCTION__, mCameraId,
729                    state);
730    }
731}
732
733bool Camera2Client::previewEnabled() {
734    ATRACE_CALL();
735    Mutex::Autolock icl(mICameraLock);
736    status_t res;
737    if ( (res = checkPid(__FUNCTION__) ) != OK) return false;
738
739    SharedParameters::Lock l(mParameters);
740    return l.mParameters.state == Parameters::PREVIEW;
741}
742
743status_t Camera2Client::storeMetaDataInBuffers(bool enabled) {
744    ATRACE_CALL();
745    Mutex::Autolock icl(mICameraLock);
746    status_t res;
747    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
748
749    SharedParameters::Lock l(mParameters);
750    switch (l.mParameters.state) {
751        case Parameters::RECORD:
752        case Parameters::VIDEO_SNAPSHOT:
753            ALOGE("%s: Camera %d: Can't be called in state %s",
754                    __FUNCTION__, mCameraId,
755                    Parameters::getStateName(l.mParameters.state));
756            return INVALID_OPERATION;
757        default:
758            // OK
759            break;
760    }
761
762    l.mParameters.storeMetadataInBuffers = enabled;
763
764    return OK;
765}
766
767status_t Camera2Client::startRecording() {
768    ATRACE_CALL();
769    ALOGV("%s: E", __FUNCTION__);
770    Mutex::Autolock icl(mICameraLock);
771    status_t res;
772    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
773    SharedParameters::Lock l(mParameters);
774
775    return startRecordingL(l.mParameters, false);
776}
777
778status_t Camera2Client::startRecordingL(Parameters &params, bool restart) {
779    status_t res;
780    switch (params.state) {
781        case Parameters::STOPPED:
782            res = startPreviewL(params, false);
783            if (res != OK) return res;
784            break;
785        case Parameters::PREVIEW:
786            // Ready to go
787            break;
788        case Parameters::RECORD:
789        case Parameters::VIDEO_SNAPSHOT:
790            // OK to call this when recording is already on, just skip unless
791            // we're looking to restart
792            if (!restart) return OK;
793            break;
794        default:
795            ALOGE("%s: Camera %d: Can't start recording in state %s",
796                    __FUNCTION__, mCameraId,
797                    Parameters::getStateName(params.state));
798            return INVALID_OPERATION;
799    };
800
801    if (!params.storeMetadataInBuffers) {
802        ALOGE("%s: Camera %d: Recording only supported in metadata mode, but "
803                "non-metadata recording mode requested!", __FUNCTION__,
804                mCameraId);
805        return INVALID_OPERATION;
806    }
807
808    if (!restart) {
809        mCameraService->playSound(CameraService::SOUND_RECORDING);
810        mStreamingProcessor->updateRecordingRequest(params);
811        if (res != OK) {
812            ALOGE("%s: Camera %d: Unable to update recording request: %s (%d)",
813                    __FUNCTION__, mCameraId, strerror(-res), res);
814            return res;
815        }
816    }
817
818    res = mStreamingProcessor->updateRecordingStream(params);
819    if (res != OK) {
820        ALOGE("%s: Camera %d: Unable to update recording stream: %s (%d)",
821                __FUNCTION__, mCameraId, strerror(-res), res);
822        return res;
823    }
824
825    Vector<uint8_t> outputStreams;
826    bool callbacksEnabled = params.previewCallbackFlags &
827        CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK;
828    if (callbacksEnabled) {
829        res = mCallbackProcessor->updateStream(params);
830        if (res != OK) {
831            ALOGE("%s: Camera %d: Unable to update callback stream: %s (%d)",
832                    __FUNCTION__, mCameraId, strerror(-res), res);
833            return res;
834        }
835        outputStreams.push(getCallbackStreamId());
836    }
837    outputStreams.push(getPreviewStreamId());
838    outputStreams.push(getRecordingStreamId());
839
840    res = mStreamingProcessor->startStream(StreamingProcessor::RECORD,
841            outputStreams);
842    if (res != OK) {
843        ALOGE("%s: Camera %d: Unable to start recording stream: %s (%d)",
844                __FUNCTION__, mCameraId, strerror(-res), res);
845        return res;
846    }
847
848    if (params.state < Parameters::RECORD) {
849        params.state = Parameters::RECORD;
850    }
851
852    return OK;
853}
854
855void Camera2Client::stopRecording() {
856    ATRACE_CALL();
857    ALOGV("%s: E", __FUNCTION__);
858    Mutex::Autolock icl(mICameraLock);
859    SharedParameters::Lock l(mParameters);
860
861    status_t res;
862    if ( (res = checkPid(__FUNCTION__) ) != OK) return;
863
864    switch (l.mParameters.state) {
865        case Parameters::RECORD:
866            // OK to stop
867            break;
868        case Parameters::STOPPED:
869        case Parameters::PREVIEW:
870        case Parameters::STILL_CAPTURE:
871        case Parameters::VIDEO_SNAPSHOT:
872        default:
873            ALOGE("%s: Camera %d: Can't stop recording in state %s",
874                    __FUNCTION__, mCameraId,
875                    Parameters::getStateName(l.mParameters.state));
876            return;
877    };
878
879    mCameraService->playSound(CameraService::SOUND_RECORDING);
880
881    res = startPreviewL(l.mParameters, true);
882    if (res != OK) {
883        ALOGE("%s: Camera %d: Unable to return to preview",
884                __FUNCTION__, mCameraId);
885    }
886}
887
888bool Camera2Client::recordingEnabled() {
889    ATRACE_CALL();
890    Mutex::Autolock icl(mICameraLock);
891
892    if ( checkPid(__FUNCTION__) != OK) return false;
893
894    return recordingEnabledL();
895}
896
897bool Camera2Client::recordingEnabledL() {
898    ATRACE_CALL();
899    SharedParameters::Lock l(mParameters);
900
901    return (l.mParameters.state == Parameters::RECORD
902            || l.mParameters.state == Parameters::VIDEO_SNAPSHOT);
903}
904
905void Camera2Client::releaseRecordingFrame(const sp<IMemory>& mem) {
906    ATRACE_CALL();
907    Mutex::Autolock icl(mICameraLock);
908    if ( checkPid(__FUNCTION__) != OK) return;
909
910    mStreamingProcessor->releaseRecordingFrame(mem);
911}
912
913status_t Camera2Client::autoFocus() {
914    ATRACE_CALL();
915    Mutex::Autolock icl(mICameraLock);
916    status_t res;
917    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
918
919    int triggerId;
920    {
921        SharedParameters::Lock l(mParameters);
922        l.mParameters.currentAfTriggerId = ++l.mParameters.afTriggerCounter;
923        triggerId = l.mParameters.currentAfTriggerId;
924    }
925
926    mDevice->triggerAutofocus(triggerId);
927
928    return OK;
929}
930
931status_t Camera2Client::cancelAutoFocus() {
932    ATRACE_CALL();
933    Mutex::Autolock icl(mICameraLock);
934    status_t res;
935    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
936
937    int triggerId;
938    {
939        SharedParameters::Lock l(mParameters);
940        triggerId = ++l.mParameters.afTriggerCounter;
941    }
942
943    mDevice->triggerCancelAutofocus(triggerId);
944
945    return OK;
946}
947
948status_t Camera2Client::takePicture(int msgType) {
949    ATRACE_CALL();
950    Mutex::Autolock icl(mICameraLock);
951    status_t res;
952    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
953
954    SharedParameters::Lock l(mParameters);
955    switch (l.mParameters.state) {
956        case Parameters::DISCONNECTED:
957        case Parameters::STOPPED:
958        case Parameters::WAITING_FOR_PREVIEW_WINDOW:
959            ALOGE("%s: Camera %d: Cannot take picture without preview enabled",
960                    __FUNCTION__, mCameraId);
961            return INVALID_OPERATION;
962        case Parameters::PREVIEW:
963            // Good to go for takePicture
964            res = commandStopFaceDetectionL(l.mParameters);
965            if (res != OK) {
966                ALOGE("%s: Camera %d: Unable to stop face detection for still capture",
967                        __FUNCTION__, mCameraId);
968                return res;
969            }
970            l.mParameters.state = Parameters::STILL_CAPTURE;
971            break;
972        case Parameters::RECORD:
973            // Good to go for video snapshot
974            l.mParameters.state = Parameters::VIDEO_SNAPSHOT;
975            break;
976        case Parameters::STILL_CAPTURE:
977        case Parameters::VIDEO_SNAPSHOT:
978            ALOGE("%s: Camera %d: Already taking a picture",
979                    __FUNCTION__, mCameraId);
980            return INVALID_OPERATION;
981    }
982
983    ALOGV("%s: Camera %d: Starting picture capture", __FUNCTION__, mCameraId);
984
985    res = mJpegProcessor->updateStream(l.mParameters);
986    if (res != OK) {
987        ALOGE("%s: Camera %d: Can't set up still image stream: %s (%d)",
988                __FUNCTION__, mCameraId, strerror(-res), res);
989        return res;
990    }
991
992    res = mCaptureSequencer->startCapture();
993    if (res != OK) {
994        ALOGE("%s: Camera %d: Unable to start capture: %s (%d)",
995                __FUNCTION__, mCameraId, strerror(-res), res);
996    }
997
998    return res;
999}
1000
1001status_t Camera2Client::setParameters(const String8& params) {
1002    ATRACE_CALL();
1003    ALOGV("%s: E", __FUNCTION__);
1004    Mutex::Autolock icl(mICameraLock);
1005    status_t res;
1006    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1007
1008    SharedParameters::Lock l(mParameters);
1009
1010    res = l.mParameters.set(params);
1011    if (res != OK) return res;
1012
1013    res = updateRequests(l.mParameters);
1014
1015    return res;
1016}
1017
1018String8 Camera2Client::getParameters() const {
1019    ATRACE_CALL();
1020    Mutex::Autolock icl(mICameraLock);
1021    if ( checkPid(__FUNCTION__) != OK) return String8();
1022
1023    SharedParameters::ReadLock l(mParameters);
1024
1025    // TODO: Deal with focus distances
1026    return l.mParameters.paramsFlattened;
1027}
1028
1029status_t Camera2Client::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) {
1030    ATRACE_CALL();
1031    Mutex::Autolock icl(mICameraLock);
1032    status_t res;
1033    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1034
1035    ALOGV("%s: Camera %d: Command %d (%d, %d)", __FUNCTION__, mCameraId,
1036            cmd, arg1, arg2);
1037
1038    switch (cmd) {
1039        case CAMERA_CMD_START_SMOOTH_ZOOM:
1040            return commandStartSmoothZoomL();
1041        case CAMERA_CMD_STOP_SMOOTH_ZOOM:
1042            return commandStopSmoothZoomL();
1043        case CAMERA_CMD_SET_DISPLAY_ORIENTATION:
1044            return commandSetDisplayOrientationL(arg1);
1045        case CAMERA_CMD_ENABLE_SHUTTER_SOUND:
1046            return commandEnableShutterSoundL(arg1 == 1);
1047        case CAMERA_CMD_PLAY_RECORDING_SOUND:
1048            return commandPlayRecordingSoundL();
1049        case CAMERA_CMD_START_FACE_DETECTION:
1050            return commandStartFaceDetectionL(arg1);
1051        case CAMERA_CMD_STOP_FACE_DETECTION: {
1052            SharedParameters::Lock l(mParameters);
1053            return commandStopFaceDetectionL(l.mParameters);
1054        }
1055        case CAMERA_CMD_ENABLE_FOCUS_MOVE_MSG:
1056            return commandEnableFocusMoveMsgL(arg1 == 1);
1057        case CAMERA_CMD_PING:
1058            return commandPingL();
1059        case CAMERA_CMD_SET_VIDEO_BUFFER_COUNT:
1060            return commandSetVideoBufferCountL(arg1);
1061        default:
1062            ALOGE("%s: Unknown command %d (arguments %d, %d)",
1063                    __FUNCTION__, cmd, arg1, arg2);
1064            return BAD_VALUE;
1065    }
1066}
1067
1068status_t Camera2Client::commandStartSmoothZoomL() {
1069    ALOGE("%s: Unimplemented!", __FUNCTION__);
1070    return OK;
1071}
1072
1073status_t Camera2Client::commandStopSmoothZoomL() {
1074    ALOGE("%s: Unimplemented!", __FUNCTION__);
1075    return OK;
1076}
1077
1078status_t Camera2Client::commandSetDisplayOrientationL(int degrees) {
1079    int transform = Parameters::degToTransform(degrees,
1080            mCameraFacing == CAMERA_FACING_FRONT);
1081    if (transform == -1) {
1082        ALOGE("%s: Camera %d: Error setting %d as display orientation value",
1083                __FUNCTION__, mCameraId, degrees);
1084        return BAD_VALUE;
1085    }
1086    SharedParameters::Lock l(mParameters);
1087    if (transform != l.mParameters.previewTransform &&
1088            getPreviewStreamId() != NO_STREAM) {
1089        mDevice->setStreamTransform(getPreviewStreamId(), transform);
1090    }
1091    l.mParameters.previewTransform = transform;
1092    return OK;
1093}
1094
1095status_t Camera2Client::commandEnableShutterSoundL(bool enable) {
1096    SharedParameters::Lock l(mParameters);
1097    if (enable) {
1098        l.mParameters.playShutterSound = true;
1099        return OK;
1100    }
1101
1102    // Disabling shutter sound may not be allowed. In that case only
1103    // allow the mediaserver process to disable the sound.
1104    char value[PROPERTY_VALUE_MAX];
1105    property_get("ro.camera.sound.forced", value, "0");
1106    if (strncmp(value, "0", 2) != 0) {
1107        // Disabling shutter sound is not allowed. Deny if the current
1108        // process is not mediaserver.
1109        if (getCallingPid() != getpid()) {
1110            ALOGE("Failed to disable shutter sound. Permission denied (pid %d)",
1111                    getCallingPid());
1112            return PERMISSION_DENIED;
1113        }
1114    }
1115
1116    l.mParameters.playShutterSound = false;
1117    return OK;
1118}
1119
1120status_t Camera2Client::commandPlayRecordingSoundL() {
1121    mCameraService->playSound(CameraService::SOUND_RECORDING);
1122    return OK;
1123}
1124
1125status_t Camera2Client::commandStartFaceDetectionL(int type) {
1126    ALOGV("%s: Camera %d: Starting face detection",
1127          __FUNCTION__, mCameraId);
1128    status_t res;
1129    SharedParameters::Lock l(mParameters);
1130    switch (l.mParameters.state) {
1131        case Parameters::DISCONNECTED:
1132        case Parameters::STOPPED:
1133        case Parameters::WAITING_FOR_PREVIEW_WINDOW:
1134        case Parameters::STILL_CAPTURE:
1135            ALOGE("%s: Camera %d: Cannot start face detection without preview active",
1136                    __FUNCTION__, mCameraId);
1137            return INVALID_OPERATION;
1138        case Parameters::PREVIEW:
1139        case Parameters::RECORD:
1140        case Parameters::VIDEO_SNAPSHOT:
1141            // Good to go for starting face detect
1142            break;
1143    }
1144    // Ignoring type
1145    if (l.mParameters.fastInfo.bestFaceDetectMode ==
1146            ANDROID_STATS_FACE_DETECTION_OFF) {
1147        ALOGE("%s: Camera %d: Face detection not supported",
1148                __FUNCTION__, mCameraId);
1149        return INVALID_OPERATION;
1150    }
1151    if (l.mParameters.enableFaceDetect) return OK;
1152
1153    l.mParameters.enableFaceDetect = true;
1154
1155    res = updateRequests(l.mParameters);
1156
1157    return res;
1158}
1159
1160status_t Camera2Client::commandStopFaceDetectionL(Parameters &params) {
1161    status_t res = OK;
1162    ALOGV("%s: Camera %d: Stopping face detection",
1163          __FUNCTION__, mCameraId);
1164
1165    if (!params.enableFaceDetect) return OK;
1166
1167    params.enableFaceDetect = false;
1168
1169    if (params.state == Parameters::PREVIEW
1170            || params.state == Parameters::RECORD
1171            || params.state == Parameters::VIDEO_SNAPSHOT) {
1172        res = updateRequests(params);
1173    }
1174
1175    return res;
1176}
1177
1178status_t Camera2Client::commandEnableFocusMoveMsgL(bool enable) {
1179    SharedParameters::Lock l(mParameters);
1180    l.mParameters.enableFocusMoveMessages = enable;
1181
1182    return OK;
1183}
1184
1185status_t Camera2Client::commandPingL() {
1186    // Always ping back if access is proper and device is alive
1187    SharedParameters::Lock l(mParameters);
1188    if (l.mParameters.state != Parameters::DISCONNECTED) {
1189        return OK;
1190    } else {
1191        return NO_INIT;
1192    }
1193}
1194
1195status_t Camera2Client::commandSetVideoBufferCountL(size_t count) {
1196    if (recordingEnabledL()) {
1197        ALOGE("%s: Camera %d: Error setting video buffer count after "
1198                "recording was started", __FUNCTION__, mCameraId);
1199        return INVALID_OPERATION;
1200    }
1201
1202    return mStreamingProcessor->setRecordingBufferCount(count);
1203}
1204
1205/** Device-related methods */
1206
1207void Camera2Client::notifyError(int errorCode, int arg1, int arg2) {
1208    ALOGE("Error condition %d reported by HAL, arguments %d, %d", errorCode, arg1, arg2);
1209}
1210
1211void Camera2Client::notifyShutter(int frameNumber, nsecs_t timestamp) {
1212    ALOGV("%s: Shutter notification for frame %d at time %lld", __FUNCTION__,
1213            frameNumber, timestamp);
1214}
1215
1216void Camera2Client::notifyAutoFocus(uint8_t newState, int triggerId) {
1217    ALOGV("%s: Autofocus state now %d, last trigger %d",
1218            __FUNCTION__, newState, triggerId);
1219    bool sendCompletedMessage = false;
1220    bool sendMovingMessage = false;
1221
1222    bool success = false;
1223    bool afInMotion = false;
1224    {
1225        SharedParameters::Lock l(mParameters);
1226        switch (l.mParameters.focusMode) {
1227            case Parameters::FOCUS_MODE_AUTO:
1228            case Parameters::FOCUS_MODE_MACRO:
1229                // Don't send notifications upstream if they're not for the current AF
1230                // trigger. For example, if cancel was called in between, or if we
1231                // already sent a notification about this AF call.
1232                if (triggerId != l.mParameters.currentAfTriggerId) break;
1233                switch (newState) {
1234                    case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED:
1235                        success = true;
1236                        // no break
1237                    case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED:
1238                        sendCompletedMessage = true;
1239                        l.mParameters.currentAfTriggerId = -1;
1240                        break;
1241                    case ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN:
1242                        // Just starting focusing, ignore
1243                        break;
1244                    case ANDROID_CONTROL_AF_STATE_INACTIVE:
1245                    case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN:
1246                    case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED:
1247                    default:
1248                        // Unexpected in AUTO/MACRO mode
1249                        ALOGE("%s: Unexpected AF state transition in AUTO/MACRO mode: %d",
1250                                __FUNCTION__, newState);
1251                        break;
1252                }
1253                break;
1254            case Parameters::FOCUS_MODE_CONTINUOUS_VIDEO:
1255            case Parameters::FOCUS_MODE_CONTINUOUS_PICTURE:
1256                switch (newState) {
1257                    case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED:
1258                        success = true;
1259                        // no break
1260                    case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED:
1261                        // Don't send notifications upstream if they're not for
1262                        // the current AF trigger. For example, if cancel was
1263                        // called in between, or if we already sent a
1264                        // notification about this AF call.
1265                        // Send both a 'AF done' callback and a 'AF move' callback
1266                        if (triggerId != l.mParameters.currentAfTriggerId) break;
1267                        sendCompletedMessage = true;
1268                        afInMotion = false;
1269                        if (l.mParameters.enableFocusMoveMessages &&
1270                                l.mParameters.afInMotion) {
1271                            sendMovingMessage = true;
1272                        }
1273                        l.mParameters.currentAfTriggerId = -1;
1274                        break;
1275                    case ANDROID_CONTROL_AF_STATE_INACTIVE:
1276                        // Cancel was called, or we switched state; care if
1277                        // currently moving
1278                        afInMotion = false;
1279                        if (l.mParameters.enableFocusMoveMessages &&
1280                                l.mParameters.afInMotion) {
1281                            sendMovingMessage = true;
1282                        }
1283                        break;
1284                    case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN:
1285                        // Start passive scan, inform upstream
1286                        afInMotion = true;
1287                        // no break
1288                    case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED:
1289                        // Stop passive scan, inform upstream
1290                        if (l.mParameters.enableFocusMoveMessages) {
1291                            sendMovingMessage = true;
1292                        }
1293                        break;
1294                }
1295                l.mParameters.afInMotion = afInMotion;
1296                break;
1297            case Parameters::FOCUS_MODE_EDOF:
1298            case Parameters::FOCUS_MODE_INFINITY:
1299            case Parameters::FOCUS_MODE_FIXED:
1300            default:
1301                if (newState != ANDROID_CONTROL_AF_STATE_INACTIVE) {
1302                    ALOGE("%s: Unexpected AF state change %d "
1303                            "(ID %d) in focus mode %d",
1304                          __FUNCTION__, newState, triggerId,
1305                            l.mParameters.focusMode);
1306                }
1307        }
1308    }
1309    if (sendMovingMessage) {
1310        SharedCameraClient::Lock l(mSharedCameraClient);
1311        if (l.mCameraClient != 0) {
1312            l.mCameraClient->notifyCallback(CAMERA_MSG_FOCUS_MOVE,
1313                    afInMotion ? 1 : 0, 0);
1314        }
1315    }
1316    if (sendCompletedMessage) {
1317        SharedCameraClient::Lock l(mSharedCameraClient);
1318        if (l.mCameraClient != 0) {
1319            l.mCameraClient->notifyCallback(CAMERA_MSG_FOCUS,
1320                    success ? 1 : 0, 0);
1321        }
1322    }
1323}
1324
1325void Camera2Client::notifyAutoExposure(uint8_t newState, int triggerId) {
1326    ALOGV("%s: Autoexposure state now %d, last trigger %d",
1327            __FUNCTION__, newState, triggerId);
1328    mCaptureSequencer->notifyAutoExposure(newState, triggerId);
1329}
1330
1331void Camera2Client::notifyAutoWhitebalance(uint8_t newState, int triggerId) {
1332    ALOGV("%s: Auto-whitebalance state now %d, last trigger %d",
1333            __FUNCTION__, newState, triggerId);
1334}
1335
1336int Camera2Client::getCameraId() const {
1337    return mCameraId;
1338}
1339
1340const sp<Camera2Device>& Camera2Client::getCameraDevice() {
1341    return mDevice;
1342}
1343
1344const sp<CameraService>& Camera2Client::getCameraService() {
1345    return mCameraService;
1346}
1347
1348camera2::SharedParameters& Camera2Client::getParameters() {
1349    return mParameters;
1350}
1351
1352int Camera2Client::getPreviewStreamId() const {
1353    return mStreamingProcessor->getPreviewStreamId();
1354}
1355
1356int Camera2Client::getCaptureStreamId() const {
1357    return mJpegProcessor->getStreamId();
1358}
1359
1360int Camera2Client::getCallbackStreamId() const {
1361    return mCallbackProcessor->getStreamId();
1362}
1363
1364int Camera2Client::getRecordingStreamId() const {
1365    return mStreamingProcessor->getRecordingStreamId();
1366}
1367
1368int Camera2Client::getZslStreamId() const {
1369    return mZslProcessor->getStreamId();
1370}
1371
1372status_t Camera2Client::registerFrameListener(int32_t id,
1373        wp<camera2::FrameProcessor::FilteredListener> listener) {
1374    return mFrameProcessor->registerListener(id, listener);
1375}
1376
1377status_t Camera2Client::removeFrameListener(int32_t id) {
1378    return mFrameProcessor->removeListener(id);
1379}
1380
1381Camera2Client::SharedCameraClient::Lock::Lock(SharedCameraClient &client):
1382        mCameraClient(client.mCameraClient),
1383        mSharedClient(client) {
1384    mSharedClient.mCameraClientLock.lock();
1385}
1386
1387Camera2Client::SharedCameraClient::Lock::~Lock() {
1388    mSharedClient.mCameraClientLock.unlock();
1389}
1390
1391Camera2Client::SharedCameraClient::SharedCameraClient(const sp<ICameraClient>&client):
1392        mCameraClient(client) {
1393}
1394
1395Camera2Client::SharedCameraClient& Camera2Client::SharedCameraClient::operator=(
1396        const sp<ICameraClient>&client) {
1397    Mutex::Autolock l(mCameraClientLock);
1398    mCameraClient = client;
1399    return *this;
1400}
1401
1402void Camera2Client::SharedCameraClient::clear() {
1403    Mutex::Autolock l(mCameraClientLock);
1404    mCameraClient.clear();
1405}
1406
1407const int32_t Camera2Client::kPreviewRequestId;
1408const int32_t Camera2Client::kRecordRequestId;
1409const int32_t Camera2Client::kFirstCaptureRequestId;
1410
1411/** Utility methods */
1412
1413status_t Camera2Client::updateRequests(Parameters &params) {
1414    status_t res;
1415
1416    res = mStreamingProcessor->updatePreviewRequest(params);
1417    if (res != OK) {
1418        ALOGE("%s: Camera %d: Unable to update preview request: %s (%d)",
1419                __FUNCTION__, mCameraId, strerror(-res), res);
1420        return res;
1421    }
1422    res = mStreamingProcessor->updateRecordingRequest(params);
1423    if (res != OK) {
1424        ALOGE("%s: Camera %d: Unable to update recording request: %s (%d)",
1425                __FUNCTION__, mCameraId, strerror(-res), res);
1426        return res;
1427    }
1428
1429    if (params.state == Parameters::PREVIEW) {
1430        res = startPreviewL(params, true);
1431        if (res != OK) {
1432            ALOGE("%s: Camera %d: Error streaming new preview request: %s (%d)",
1433                    __FUNCTION__, mCameraId, strerror(-res), res);
1434            return res;
1435        }
1436    } else if (params.state == Parameters::RECORD ||
1437            params.state == Parameters::VIDEO_SNAPSHOT) {
1438        res = startRecordingL(params, true);
1439        if (res != OK) {
1440            ALOGE("%s: Camera %d: Error streaming new record request: %s (%d)",
1441                    __FUNCTION__, mCameraId, strerror(-res), res);
1442            return res;
1443        }
1444    }
1445    return res;
1446}
1447
1448
1449size_t Camera2Client::calculateBufferSize(int width, int height,
1450        int format, int stride) {
1451    switch (format) {
1452        case HAL_PIXEL_FORMAT_YCbCr_422_SP: // NV16
1453            return width * height * 2;
1454        case HAL_PIXEL_FORMAT_YCrCb_420_SP: // NV21
1455            return width * height * 3 / 2;
1456        case HAL_PIXEL_FORMAT_YCbCr_422_I: // YUY2
1457            return width * height * 2;
1458        case HAL_PIXEL_FORMAT_YV12: {      // YV12
1459            size_t ySize = stride * height;
1460            size_t uvStride = (stride / 2 + 0xF) & ~0xF;
1461            size_t uvSize = uvStride * height / 2;
1462            return ySize + uvSize * 2;
1463        }
1464        case HAL_PIXEL_FORMAT_RGB_565:
1465            return width * height * 2;
1466        case HAL_PIXEL_FORMAT_RGBA_8888:
1467            return width * height * 4;
1468        case HAL_PIXEL_FORMAT_RAW_SENSOR:
1469            return width * height * 2;
1470        default:
1471            ALOGE("%s: Unknown preview format: %x",
1472                    __FUNCTION__,  format);
1473            return 0;
1474    }
1475}
1476
1477} // namespace android
1478