Camera3Device.cpp revision 69a374897392c8bd70f441b7284f6f578c651ec9 
1/*
2 * Copyright (C) 2013 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 "Camera3-Device"
18#define ATRACE_TAG ATRACE_TAG_CAMERA
19//#define LOG_NDEBUG 0
20//#define LOG_NNDEBUG 0  // Per-frame verbose logging
21
22#ifdef LOG_NNDEBUG
23#define ALOGVV(...) ALOGV(__VA_ARGS__)
24#else
25#define ALOGVV(...) ((void)0)
26#endif
27
28// Convenience macro for transient errors
29#define CLOGE(fmt, ...) ALOGE("Camera %d: %s: " fmt, mId, __FUNCTION__, \
30            ##__VA_ARGS__)
31
32// Convenience macros for transitioning to the error state
33#define SET_ERR(fmt, ...) setErrorState(   \
34    "%s: " fmt, __FUNCTION__,              \
35    ##__VA_ARGS__)
36#define SET_ERR_L(fmt, ...) setErrorStateLocked( \
37    "%s: " fmt, __FUNCTION__,                    \
38    ##__VA_ARGS__)
39
40#include <utils/Log.h>
41#include <utils/Trace.h>
42#include <utils/Timers.h>
43
44#include "utils/CameraTraces.h"
45#include "device3/Camera3Device.h"
46#include "device3/Camera3OutputStream.h"
47#include "device3/Camera3InputStream.h"
48#include "device3/Camera3ZslStream.h"
49
50using namespace android::camera3;
51
52namespace android {
53
54Camera3Device::Camera3Device(int id):
55        mId(id),
56        mHal3Device(NULL),
57        mStatus(STATUS_UNINITIALIZED),
58        mUsePartialResultQuirk(false),
59        mNextResultFrameNumber(0),
60        mNextShutterFrameNumber(0),
61        mListener(NULL)
62{
63    ATRACE_CALL();
64    camera3_callback_ops::notify = &sNotify;
65    camera3_callback_ops::process_capture_result = &sProcessCaptureResult;
66    ALOGV("%s: Created device for camera %d", __FUNCTION__, id);
67}
68
69Camera3Device::~Camera3Device()
70{
71    ATRACE_CALL();
72    ALOGV("%s: Tearing down for camera id %d", __FUNCTION__, mId);
73    disconnect();
74}
75
76int Camera3Device::getId() const {
77    return mId;
78}
79
80/**
81 * CameraDeviceBase interface
82 */
83
84status_t Camera3Device::initialize(camera_module_t *module)
85{
86    ATRACE_CALL();
87    Mutex::Autolock il(mInterfaceLock);
88    Mutex::Autolock l(mLock);
89
90    ALOGV("%s: Initializing device for camera %d", __FUNCTION__, mId);
91    if (mStatus != STATUS_UNINITIALIZED) {
92        CLOGE("Already initialized!");
93        return INVALID_OPERATION;
94    }
95
96    /** Open HAL device */
97
98    status_t res;
99    String8 deviceName = String8::format("%d", mId);
100
101    camera3_device_t *device;
102
103    ATRACE_BEGIN("camera3->open");
104    res = module->common.methods->open(&module->common, deviceName.string(),
105            reinterpret_cast<hw_device_t**>(&device));
106    ATRACE_END();
107
108    if (res != OK) {
109        SET_ERR_L("Could not open camera: %s (%d)", strerror(-res), res);
110        return res;
111    }
112
113    /** Cross-check device version */
114
115    if (device->common.version != CAMERA_DEVICE_API_VERSION_3_0) {
116        SET_ERR_L("Could not open camera: "
117                "Camera device is not version %x, reports %x instead",
118                CAMERA_DEVICE_API_VERSION_3_0,
119                device->common.version);
120        device->common.close(&device->common);
121        return BAD_VALUE;
122    }
123
124    camera_info info;
125    res = module->get_camera_info(mId, &info);
126    if (res != OK) return res;
127
128    if (info.device_version != device->common.version) {
129        SET_ERR_L("HAL reporting mismatched camera_info version (%x)"
130                " and device version (%x).",
131                device->common.version, info.device_version);
132        device->common.close(&device->common);
133        return BAD_VALUE;
134    }
135
136    /** Initialize device with callback functions */
137
138    ATRACE_BEGIN("camera3->initialize");
139    res = device->ops->initialize(device, this);
140    ATRACE_END();
141
142    if (res != OK) {
143        SET_ERR_L("Unable to initialize HAL device: %s (%d)",
144                strerror(-res), res);
145        device->common.close(&device->common);
146        return BAD_VALUE;
147    }
148
149    /** Start up status tracker thread */
150    mStatusTracker = new StatusTracker(this);
151    res = mStatusTracker->run(String8::format("C3Dev-%d-Status", mId).string());
152    if (res != OK) {
153        SET_ERR_L("Unable to start status tracking thread: %s (%d)",
154                strerror(-res), res);
155        device->common.close(&device->common);
156        mStatusTracker.clear();
157        return res;
158    }
159
160    /** Start up request queue thread */
161
162    mRequestThread = new RequestThread(this, mStatusTracker, device);
163    res = mRequestThread->run(String8::format("C3Dev-%d-ReqQueue", mId).string());
164    if (res != OK) {
165        SET_ERR_L("Unable to start request queue thread: %s (%d)",
166                strerror(-res), res);
167        device->common.close(&device->common);
168        mRequestThread.clear();
169        return res;
170    }
171
172    /** Everything is good to go */
173
174    mDeviceInfo = info.static_camera_characteristics;
175    mHal3Device = device;
176    mStatus = STATUS_UNCONFIGURED;
177    mNextStreamId = 0;
178    mNeedConfig = true;
179    mPauseStateNotify = false;
180
181    /** Check for quirks */
182
183    // Will the HAL be sending in early partial result metadata?
184    camera_metadata_entry partialResultsQuirk =
185            mDeviceInfo.find(ANDROID_QUIRKS_USE_PARTIAL_RESULT);
186    if (partialResultsQuirk.count > 0 && partialResultsQuirk.data.u8[0] == 1) {
187        mUsePartialResultQuirk = true;
188    }
189
190    return OK;
191}
192
193status_t Camera3Device::disconnect() {
194    ATRACE_CALL();
195    Mutex::Autolock il(mInterfaceLock);
196
197    ALOGV("%s: E", __FUNCTION__);
198
199    status_t res = OK;
200
201    {
202        Mutex::Autolock l(mLock);
203        if (mStatus == STATUS_UNINITIALIZED) return res;
204
205        if (mStatus == STATUS_ACTIVE ||
206                (mStatus == STATUS_ERROR && mRequestThread != NULL)) {
207            res = mRequestThread->clearRepeatingRequests();
208            if (res != OK) {
209                SET_ERR_L("Can't stop streaming");
210                // Continue to close device even in case of error
211            } else {
212                res = waitUntilStateThenRelock(/*active*/ false, kShutdownTimeout);
213                if (res != OK) {
214                    SET_ERR_L("Timeout waiting for HAL to drain");
215                    // Continue to close device even in case of error
216                }
217            }
218        }
219
220        if (mStatus == STATUS_ERROR) {
221            CLOGE("Shutting down in an error state");
222        }
223
224        if (mStatusTracker != NULL) {
225            mStatusTracker->requestExit();
226        }
227
228        if (mRequestThread != NULL) {
229            mRequestThread->requestExit();
230        }
231
232        mOutputStreams.clear();
233        mInputStream.clear();
234    }
235
236    // Joining done without holding mLock, otherwise deadlocks may ensue
237    // as the threads try to access parent state
238    if (mRequestThread != NULL && mStatus != STATUS_ERROR) {
239        // HAL may be in a bad state, so waiting for request thread
240        // (which may be stuck in the HAL processCaptureRequest call)
241        // could be dangerous.
242        mRequestThread->join();
243    }
244
245    if (mStatusTracker != NULL) {
246        mStatusTracker->join();
247    }
248
249    {
250        Mutex::Autolock l(mLock);
251
252        mRequestThread.clear();
253        mStatusTracker.clear();
254
255        if (mHal3Device != NULL) {
256            ATRACE_BEGIN("camera3->close");
257            mHal3Device->common.close(&mHal3Device->common);
258            ATRACE_END();
259            mHal3Device = NULL;
260        }
261
262        mStatus = STATUS_UNINITIALIZED;
263    }
264
265    ALOGV("%s: X", __FUNCTION__);
266    return res;
267}
268
269// For dumping/debugging only -
270// try to acquire a lock a few times, eventually give up to proceed with
271// debug/dump operations
272bool Camera3Device::tryLockSpinRightRound(Mutex& lock) {
273    bool gotLock = false;
274    for (size_t i = 0; i < kDumpLockAttempts; ++i) {
275        if (lock.tryLock() == NO_ERROR) {
276            gotLock = true;
277            break;
278        } else {
279            usleep(kDumpSleepDuration);
280        }
281    }
282    return gotLock;
283}
284
285status_t Camera3Device::dump(int fd, const Vector<String16> &args) {
286    ATRACE_CALL();
287    (void)args;
288
289    // Try to lock, but continue in case of failure (to avoid blocking in
290    // deadlocks)
291    bool gotInterfaceLock = tryLockSpinRightRound(mInterfaceLock);
292    bool gotLock = tryLockSpinRightRound(mLock);
293
294    ALOGW_IF(!gotInterfaceLock,
295            "Camera %d: %s: Unable to lock interface lock, proceeding anyway",
296            mId, __FUNCTION__);
297    ALOGW_IF(!gotLock,
298            "Camera %d: %s: Unable to lock main lock, proceeding anyway",
299            mId, __FUNCTION__);
300
301    String8 lines;
302
303    const char *status =
304            mStatus == STATUS_ERROR         ? "ERROR" :
305            mStatus == STATUS_UNINITIALIZED ? "UNINITIALIZED" :
306            mStatus == STATUS_UNCONFIGURED  ? "UNCONFIGURED" :
307            mStatus == STATUS_CONFIGURED    ? "CONFIGURED" :
308            mStatus == STATUS_ACTIVE        ? "ACTIVE" :
309            "Unknown";
310
311    lines.appendFormat("    Device status: %s\n", status);
312    if (mStatus == STATUS_ERROR) {
313        lines.appendFormat("    Error cause: %s\n", mErrorCause.string());
314    }
315    lines.appendFormat("    Stream configuration:\n");
316
317    if (mInputStream != NULL) {
318        write(fd, lines.string(), lines.size());
319        mInputStream->dump(fd, args);
320    } else {
321        lines.appendFormat("      No input stream.\n");
322        write(fd, lines.string(), lines.size());
323    }
324    for (size_t i = 0; i < mOutputStreams.size(); i++) {
325        mOutputStreams[i]->dump(fd,args);
326    }
327
328    lines = String8("    In-flight requests:\n");
329    if (mInFlightMap.size() == 0) {
330        lines.append("      None\n");
331    } else {
332        for (size_t i = 0; i < mInFlightMap.size(); i++) {
333            InFlightRequest r = mInFlightMap.valueAt(i);
334            lines.appendFormat("      Frame %d |  Timestamp: %lld, metadata"
335                    " arrived: %s, buffers left: %d\n", mInFlightMap.keyAt(i),
336                    r.captureTimestamp, r.haveResultMetadata ? "true" : "false",
337                    r.numBuffersLeft);
338        }
339    }
340    write(fd, lines.string(), lines.size());
341
342    {
343        lines = String8("    Last request sent:\n");
344        write(fd, lines.string(), lines.size());
345
346        CameraMetadata lastRequest = getLatestRequestLocked();
347        lastRequest.dump(fd, /*verbosity*/2, /*indentation*/6);
348    }
349
350    if (mHal3Device != NULL) {
351        lines = String8("    HAL device dump:\n");
352        write(fd, lines.string(), lines.size());
353        mHal3Device->ops->dump(mHal3Device, fd);
354    }
355
356    if (gotLock) mLock.unlock();
357    if (gotInterfaceLock) mInterfaceLock.unlock();
358
359    return OK;
360}
361
362const CameraMetadata& Camera3Device::info() const {
363    ALOGVV("%s: E", __FUNCTION__);
364    if (CC_UNLIKELY(mStatus == STATUS_UNINITIALIZED ||
365                    mStatus == STATUS_ERROR)) {
366        ALOGW("%s: Access to static info %s!", __FUNCTION__,
367                mStatus == STATUS_ERROR ?
368                "when in error state" : "before init");
369    }
370    return mDeviceInfo;
371}
372
373status_t Camera3Device::checkStatusOkToCaptureLocked() {
374    switch (mStatus) {
375        case STATUS_ERROR:
376            CLOGE("Device has encountered a serious error");
377            return INVALID_OPERATION;
378        case STATUS_UNINITIALIZED:
379            CLOGE("Device not initialized");
380            return INVALID_OPERATION;
381        case STATUS_UNCONFIGURED:
382        case STATUS_CONFIGURED:
383        case STATUS_ACTIVE:
384            // OK
385            break;
386        default:
387            SET_ERR_L("Unexpected status: %d", mStatus);
388            return INVALID_OPERATION;
389    }
390    return OK;
391}
392
393status_t Camera3Device::convertMetadataListToRequestListLocked(
394        const List<const CameraMetadata> &metadataList, RequestList *requestList) {
395    if (requestList == NULL) {
396        CLOGE("requestList cannot be NULL.");
397        return BAD_VALUE;
398    }
399
400    for (List<const CameraMetadata>::const_iterator it = metadataList.begin();
401            it != metadataList.end(); ++it) {
402        sp<CaptureRequest> newRequest = setUpRequestLocked(*it);
403        if (newRequest == 0) {
404            CLOGE("Can't create capture request");
405            return BAD_VALUE;
406        }
407        requestList->push_back(newRequest);
408    }
409    return OK;
410}
411
412status_t Camera3Device::capture(CameraMetadata &request) {
413    ATRACE_CALL();
414    status_t res;
415    Mutex::Autolock il(mInterfaceLock);
416    Mutex::Autolock l(mLock);
417
418    // TODO: take ownership of the request
419
420    switch (mStatus) {
421        case STATUS_ERROR:
422            CLOGE("Device has encountered a serious error");
423            return INVALID_OPERATION;
424        case STATUS_UNINITIALIZED:
425            CLOGE("Device not initialized");
426            return INVALID_OPERATION;
427        case STATUS_UNCONFIGURED:
428            // May be lazily configuring streams, will check during setup
429        case STATUS_CONFIGURED:
430        case STATUS_ACTIVE:
431            // OK
432            break;
433        default:
434            SET_ERR_L("Unexpected status: %d", mStatus);
435            return INVALID_OPERATION;
436    }
437
438    sp<CaptureRequest> newRequest = setUpRequestLocked(request);
439    if (newRequest == NULL) {
440        CLOGE("Can't create capture request");
441        return BAD_VALUE;
442    }
443
444    res = mRequestThread->queueRequest(newRequest);
445    if (res == OK) {
446        waitUntilStateThenRelock(/*active*/ true, kActiveTimeout);
447        if (res != OK) {
448            SET_ERR_L("Can't transition to active in %f seconds!",
449                    kActiveTimeout/1e9);
450        }
451        ALOGV("Camera %d: Capture request enqueued", mId);
452    } else {
453        CLOGE("Cannot queue request. Impossible."); // queueRequest always returns OK.
454        return BAD_VALUE;
455    }
456    return res;
457}
458
459status_t Camera3Device::submitRequestsHelper(
460        const List<const CameraMetadata> &requests, bool repeating) {
461    ATRACE_CALL();
462    Mutex::Autolock il(mInterfaceLock);
463    Mutex::Autolock l(mLock);
464
465    status_t res = checkStatusOkToCaptureLocked();
466    if (res != OK) {
467        // error logged by previous call
468        return res;
469    }
470
471    RequestList requestList;
472
473    res = convertMetadataListToRequestListLocked(requests, /*out*/&requestList);
474    if (res != OK) {
475        // error logged by previous call
476        return res;
477    }
478
479    if (repeating) {
480        res = mRequestThread->setRepeatingRequests(requestList);
481    } else {
482        res = mRequestThread->queueRequestList(requestList);
483    }
484
485    if (res == OK) {
486        waitUntilStateThenRelock(/*active*/true, kActiveTimeout);
487        if (res != OK) {
488            SET_ERR_L("Can't transition to active in %f seconds!",
489                    kActiveTimeout/1e9);
490        }
491        ALOGV("Camera %d: Capture request enqueued", mId);
492    } else {
493        CLOGE("Cannot queue request. Impossible.");
494        return BAD_VALUE;
495    }
496
497    return res;
498}
499
500status_t Camera3Device::captureList(const List<const CameraMetadata> &requests) {
501    ATRACE_CALL();
502
503    return submitRequestsHelper(requests, /*repeating*/false);
504}
505
506status_t Camera3Device::setStreamingRequest(const CameraMetadata &request) {
507    ATRACE_CALL();
508    status_t res;
509    Mutex::Autolock il(mInterfaceLock);
510    Mutex::Autolock l(mLock);
511
512    switch (mStatus) {
513        case STATUS_ERROR:
514            CLOGE("Device has encountered a serious error");
515            return INVALID_OPERATION;
516        case STATUS_UNINITIALIZED:
517            CLOGE("Device not initialized");
518            return INVALID_OPERATION;
519        case STATUS_UNCONFIGURED:
520            // May be lazily configuring streams, will check during setup
521        case STATUS_CONFIGURED:
522        case STATUS_ACTIVE:
523            // OK
524            break;
525        default:
526            SET_ERR_L("Unexpected status: %d", mStatus);
527            return INVALID_OPERATION;
528    }
529
530    sp<CaptureRequest> newRepeatingRequest = setUpRequestLocked(request);
531    if (newRepeatingRequest == NULL) {
532        CLOGE("Can't create repeating request");
533        return BAD_VALUE;
534    }
535
536    RequestList newRepeatingRequests;
537    newRepeatingRequests.push_back(newRepeatingRequest);
538
539    res = mRequestThread->setRepeatingRequests(newRepeatingRequests);
540    if (res == OK) {
541        waitUntilStateThenRelock(/*active*/ true, kActiveTimeout);
542        if (res != OK) {
543            SET_ERR_L("Can't transition to active in %f seconds!",
544                    kActiveTimeout/1e9);
545        }
546        ALOGV("Camera %d: Repeating request set", mId);
547    }
548    return res;
549}
550
551status_t Camera3Device::setStreamingRequestList(const List<const CameraMetadata> &requests) {
552    ATRACE_CALL();
553
554    return submitRequestsHelper(requests, /*repeating*/true);
555}
556
557sp<Camera3Device::CaptureRequest> Camera3Device::setUpRequestLocked(
558        const CameraMetadata &request) {
559    status_t res;
560
561    if (mStatus == STATUS_UNCONFIGURED || mNeedConfig) {
562        res = configureStreamsLocked();
563        if (res != OK) {
564            SET_ERR_L("Can't set up streams: %s (%d)", strerror(-res), res);
565            return NULL;
566        }
567        if (mStatus == STATUS_UNCONFIGURED) {
568            CLOGE("No streams configured");
569            return NULL;
570        }
571    }
572
573    sp<CaptureRequest> newRequest = createCaptureRequest(request);
574    return newRequest;
575}
576
577status_t Camera3Device::clearStreamingRequest() {
578    ATRACE_CALL();
579    Mutex::Autolock il(mInterfaceLock);
580    Mutex::Autolock l(mLock);
581
582    switch (mStatus) {
583        case STATUS_ERROR:
584            CLOGE("Device has encountered a serious error");
585            return INVALID_OPERATION;
586        case STATUS_UNINITIALIZED:
587            CLOGE("Device not initialized");
588            return INVALID_OPERATION;
589        case STATUS_UNCONFIGURED:
590        case STATUS_CONFIGURED:
591        case STATUS_ACTIVE:
592            // OK
593            break;
594        default:
595            SET_ERR_L("Unexpected status: %d", mStatus);
596            return INVALID_OPERATION;
597    }
598    ALOGV("Camera %d: Clearing repeating request", mId);
599    return mRequestThread->clearRepeatingRequests();
600}
601
602status_t Camera3Device::waitUntilRequestReceived(int32_t requestId, nsecs_t timeout) {
603    ATRACE_CALL();
604    Mutex::Autolock il(mInterfaceLock);
605
606    return mRequestThread->waitUntilRequestProcessed(requestId, timeout);
607}
608
609status_t Camera3Device::createInputStream(
610        uint32_t width, uint32_t height, int format, int *id) {
611    ATRACE_CALL();
612    Mutex::Autolock il(mInterfaceLock);
613    Mutex::Autolock l(mLock);
614    ALOGV("Camera %d: Creating new input stream %d: %d x %d, format %d",
615            mId, mNextStreamId, width, height, format);
616
617    status_t res;
618    bool wasActive = false;
619
620    switch (mStatus) {
621        case STATUS_ERROR:
622            ALOGE("%s: Device has encountered a serious error", __FUNCTION__);
623            return INVALID_OPERATION;
624        case STATUS_UNINITIALIZED:
625            ALOGE("%s: Device not initialized", __FUNCTION__);
626            return INVALID_OPERATION;
627        case STATUS_UNCONFIGURED:
628        case STATUS_CONFIGURED:
629            // OK
630            break;
631        case STATUS_ACTIVE:
632            ALOGV("%s: Stopping activity to reconfigure streams", __FUNCTION__);
633            res = internalPauseAndWaitLocked();
634            if (res != OK) {
635                SET_ERR_L("Can't pause captures to reconfigure streams!");
636                return res;
637            }
638            wasActive = true;
639            break;
640        default:
641            SET_ERR_L("%s: Unexpected status: %d", mStatus);
642            return INVALID_OPERATION;
643    }
644    assert(mStatus != STATUS_ACTIVE);
645
646    if (mInputStream != 0) {
647        ALOGE("%s: Cannot create more than 1 input stream", __FUNCTION__);
648        return INVALID_OPERATION;
649    }
650
651    sp<Camera3InputStream> newStream = new Camera3InputStream(mNextStreamId,
652                width, height, format);
653    newStream->setStatusTracker(mStatusTracker);
654
655    mInputStream = newStream;
656
657    *id = mNextStreamId++;
658
659    // Continue captures if active at start
660    if (wasActive) {
661        ALOGV("%s: Restarting activity to reconfigure streams", __FUNCTION__);
662        res = configureStreamsLocked();
663        if (res != OK) {
664            ALOGE("%s: Can't reconfigure device for new stream %d: %s (%d)",
665                    __FUNCTION__, mNextStreamId, strerror(-res), res);
666            return res;
667        }
668        internalResumeLocked();
669    }
670
671    ALOGV("Camera %d: Created input stream", mId);
672    return OK;
673}
674
675
676status_t Camera3Device::createZslStream(
677            uint32_t width, uint32_t height,
678            int depth,
679            /*out*/
680            int *id,
681            sp<Camera3ZslStream>* zslStream) {
682    ATRACE_CALL();
683    Mutex::Autolock il(mInterfaceLock);
684    Mutex::Autolock l(mLock);
685    ALOGV("Camera %d: Creating ZSL stream %d: %d x %d, depth %d",
686            mId, mNextStreamId, width, height, depth);
687
688    status_t res;
689    bool wasActive = false;
690
691    switch (mStatus) {
692        case STATUS_ERROR:
693            ALOGE("%s: Device has encountered a serious error", __FUNCTION__);
694            return INVALID_OPERATION;
695        case STATUS_UNINITIALIZED:
696            ALOGE("%s: Device not initialized", __FUNCTION__);
697            return INVALID_OPERATION;
698        case STATUS_UNCONFIGURED:
699        case STATUS_CONFIGURED:
700            // OK
701            break;
702        case STATUS_ACTIVE:
703            ALOGV("%s: Stopping activity to reconfigure streams", __FUNCTION__);
704            res = internalPauseAndWaitLocked();
705            if (res != OK) {
706                SET_ERR_L("Can't pause captures to reconfigure streams!");
707                return res;
708            }
709            wasActive = true;
710            break;
711        default:
712            SET_ERR_L("Unexpected status: %d", mStatus);
713            return INVALID_OPERATION;
714    }
715    assert(mStatus != STATUS_ACTIVE);
716
717    if (mInputStream != 0) {
718        ALOGE("%s: Cannot create more than 1 input stream", __FUNCTION__);
719        return INVALID_OPERATION;
720    }
721
722    sp<Camera3ZslStream> newStream = new Camera3ZslStream(mNextStreamId,
723                width, height, depth);
724    newStream->setStatusTracker(mStatusTracker);
725
726    res = mOutputStreams.add(mNextStreamId, newStream);
727    if (res < 0) {
728        ALOGE("%s: Can't add new stream to set: %s (%d)",
729                __FUNCTION__, strerror(-res), res);
730        return res;
731    }
732    mInputStream = newStream;
733
734    *id = mNextStreamId++;
735    *zslStream = newStream;
736
737    // Continue captures if active at start
738    if (wasActive) {
739        ALOGV("%s: Restarting activity to reconfigure streams", __FUNCTION__);
740        res = configureStreamsLocked();
741        if (res != OK) {
742            ALOGE("%s: Can't reconfigure device for new stream %d: %s (%d)",
743                    __FUNCTION__, mNextStreamId, strerror(-res), res);
744            return res;
745        }
746        internalResumeLocked();
747    }
748
749    ALOGV("Camera %d: Created ZSL stream", mId);
750    return OK;
751}
752
753status_t Camera3Device::createStream(sp<ANativeWindow> consumer,
754        uint32_t width, uint32_t height, int format, size_t size, int *id) {
755    ATRACE_CALL();
756    Mutex::Autolock il(mInterfaceLock);
757    Mutex::Autolock l(mLock);
758    ALOGV("Camera %d: Creating new stream %d: %d x %d, format %d, size %d",
759            mId, mNextStreamId, width, height, format, size);
760
761    status_t res;
762    bool wasActive = false;
763
764    switch (mStatus) {
765        case STATUS_ERROR:
766            CLOGE("Device has encountered a serious error");
767            return INVALID_OPERATION;
768        case STATUS_UNINITIALIZED:
769            CLOGE("Device not initialized");
770            return INVALID_OPERATION;
771        case STATUS_UNCONFIGURED:
772        case STATUS_CONFIGURED:
773            // OK
774            break;
775        case STATUS_ACTIVE:
776            ALOGV("%s: Stopping activity to reconfigure streams", __FUNCTION__);
777            res = internalPauseAndWaitLocked();
778            if (res != OK) {
779                SET_ERR_L("Can't pause captures to reconfigure streams!");
780                return res;
781            }
782            wasActive = true;
783            break;
784        default:
785            SET_ERR_L("Unexpected status: %d", mStatus);
786            return INVALID_OPERATION;
787    }
788    assert(mStatus != STATUS_ACTIVE);
789
790    sp<Camera3OutputStream> newStream;
791    if (format == HAL_PIXEL_FORMAT_BLOB) {
792        newStream = new Camera3OutputStream(mNextStreamId, consumer,
793                width, height, size, format);
794    } else {
795        newStream = new Camera3OutputStream(mNextStreamId, consumer,
796                width, height, format);
797    }
798    newStream->setStatusTracker(mStatusTracker);
799
800    res = mOutputStreams.add(mNextStreamId, newStream);
801    if (res < 0) {
802        SET_ERR_L("Can't add new stream to set: %s (%d)", strerror(-res), res);
803        return res;
804    }
805
806    *id = mNextStreamId++;
807    mNeedConfig = true;
808
809    // Continue captures if active at start
810    if (wasActive) {
811        ALOGV("%s: Restarting activity to reconfigure streams", __FUNCTION__);
812        res = configureStreamsLocked();
813        if (res != OK) {
814            CLOGE("Can't reconfigure device for new stream %d: %s (%d)",
815                    mNextStreamId, strerror(-res), res);
816            return res;
817        }
818        internalResumeLocked();
819    }
820    ALOGV("Camera %d: Created new stream", mId);
821    return OK;
822}
823
824status_t Camera3Device::createReprocessStreamFromStream(int outputId, int *id) {
825    ATRACE_CALL();
826    (void)outputId; (void)id;
827
828    CLOGE("Unimplemented");
829    return INVALID_OPERATION;
830}
831
832
833status_t Camera3Device::getStreamInfo(int id,
834        uint32_t *width, uint32_t *height, uint32_t *format) {
835    ATRACE_CALL();
836    Mutex::Autolock il(mInterfaceLock);
837    Mutex::Autolock l(mLock);
838
839    switch (mStatus) {
840        case STATUS_ERROR:
841            CLOGE("Device has encountered a serious error");
842            return INVALID_OPERATION;
843        case STATUS_UNINITIALIZED:
844            CLOGE("Device not initialized!");
845            return INVALID_OPERATION;
846        case STATUS_UNCONFIGURED:
847        case STATUS_CONFIGURED:
848        case STATUS_ACTIVE:
849            // OK
850            break;
851        default:
852            SET_ERR_L("Unexpected status: %d", mStatus);
853            return INVALID_OPERATION;
854    }
855
856    ssize_t idx = mOutputStreams.indexOfKey(id);
857    if (idx == NAME_NOT_FOUND) {
858        CLOGE("Stream %d is unknown", id);
859        return idx;
860    }
861
862    if (width) *width  = mOutputStreams[idx]->getWidth();
863    if (height) *height = mOutputStreams[idx]->getHeight();
864    if (format) *format = mOutputStreams[idx]->getFormat();
865
866    return OK;
867}
868
869status_t Camera3Device::setStreamTransform(int id,
870        int transform) {
871    ATRACE_CALL();
872    Mutex::Autolock il(mInterfaceLock);
873    Mutex::Autolock l(mLock);
874
875    switch (mStatus) {
876        case STATUS_ERROR:
877            CLOGE("Device has encountered a serious error");
878            return INVALID_OPERATION;
879        case STATUS_UNINITIALIZED:
880            CLOGE("Device not initialized");
881            return INVALID_OPERATION;
882        case STATUS_UNCONFIGURED:
883        case STATUS_CONFIGURED:
884        case STATUS_ACTIVE:
885            // OK
886            break;
887        default:
888            SET_ERR_L("Unexpected status: %d", mStatus);
889            return INVALID_OPERATION;
890    }
891
892    ssize_t idx = mOutputStreams.indexOfKey(id);
893    if (idx == NAME_NOT_FOUND) {
894        CLOGE("Stream %d does not exist",
895                id);
896        return BAD_VALUE;
897    }
898
899    return mOutputStreams.editValueAt(idx)->setTransform(transform);
900}
901
902status_t Camera3Device::deleteStream(int id) {
903    ATRACE_CALL();
904    Mutex::Autolock il(mInterfaceLock);
905    Mutex::Autolock l(mLock);
906    status_t res;
907
908    ALOGV("%s: Camera %d: Deleting stream %d", __FUNCTION__, mId, id);
909
910    // CameraDevice semantics require device to already be idle before
911    // deleteStream is called, unlike for createStream.
912    if (mStatus == STATUS_ACTIVE) {
913        ALOGV("%s: Camera %d: Device not idle", __FUNCTION__, mId);
914        return -EBUSY;
915    }
916
917    sp<Camera3StreamInterface> deletedStream;
918    ssize_t outputStreamIdx = mOutputStreams.indexOfKey(id);
919    if (mInputStream != NULL && id == mInputStream->getId()) {
920        deletedStream = mInputStream;
921        mInputStream.clear();
922    } else {
923        if (outputStreamIdx == NAME_NOT_FOUND) {
924            CLOGE("Stream %d does not exist", id);
925            return BAD_VALUE;
926        }
927    }
928
929    // Delete output stream or the output part of a bi-directional stream.
930    if (outputStreamIdx != NAME_NOT_FOUND) {
931        deletedStream = mOutputStreams.editValueAt(outputStreamIdx);
932        mOutputStreams.removeItem(id);
933    }
934
935    // Free up the stream endpoint so that it can be used by some other stream
936    res = deletedStream->disconnect();
937    if (res != OK) {
938        SET_ERR_L("Can't disconnect deleted stream %d", id);
939        // fall through since we want to still list the stream as deleted.
940    }
941    mDeletedStreams.add(deletedStream);
942    mNeedConfig = true;
943
944    return res;
945}
946
947status_t Camera3Device::deleteReprocessStream(int id) {
948    ATRACE_CALL();
949    (void)id;
950
951    CLOGE("Unimplemented");
952    return INVALID_OPERATION;
953}
954
955
956status_t Camera3Device::createDefaultRequest(int templateId,
957        CameraMetadata *request) {
958    ATRACE_CALL();
959    ALOGV("%s: for template %d", __FUNCTION__, templateId);
960    Mutex::Autolock il(mInterfaceLock);
961    Mutex::Autolock l(mLock);
962
963    switch (mStatus) {
964        case STATUS_ERROR:
965            CLOGE("Device has encountered a serious error");
966            return INVALID_OPERATION;
967        case STATUS_UNINITIALIZED:
968            CLOGE("Device is not initialized!");
969            return INVALID_OPERATION;
970        case STATUS_UNCONFIGURED:
971        case STATUS_CONFIGURED:
972        case STATUS_ACTIVE:
973            // OK
974            break;
975        default:
976            SET_ERR_L("Unexpected status: %d", mStatus);
977            return INVALID_OPERATION;
978    }
979
980    const camera_metadata_t *rawRequest;
981    ATRACE_BEGIN("camera3->construct_default_request_settings");
982    rawRequest = mHal3Device->ops->construct_default_request_settings(
983        mHal3Device, templateId);
984    ATRACE_END();
985    if (rawRequest == NULL) {
986        SET_ERR_L("HAL is unable to construct default settings for template %d",
987                templateId);
988        return DEAD_OBJECT;
989    }
990    *request = rawRequest;
991
992    return OK;
993}
994
995status_t Camera3Device::waitUntilDrained() {
996    ATRACE_CALL();
997    Mutex::Autolock il(mInterfaceLock);
998    Mutex::Autolock l(mLock);
999
1000    return waitUntilDrainedLocked();
1001}
1002
1003status_t Camera3Device::waitUntilDrainedLocked() {
1004    switch (mStatus) {
1005        case STATUS_UNINITIALIZED:
1006        case STATUS_UNCONFIGURED:
1007            ALOGV("%s: Already idle", __FUNCTION__);
1008            return OK;
1009        case STATUS_CONFIGURED:
1010            // To avoid race conditions, check with tracker to be sure
1011        case STATUS_ERROR:
1012        case STATUS_ACTIVE:
1013            // Need to verify shut down
1014            break;
1015        default:
1016            SET_ERR_L("Unexpected status: %d",mStatus);
1017            return INVALID_OPERATION;
1018    }
1019
1020    ALOGV("%s: Camera %d: Waiting until idle", __FUNCTION__, mId);
1021    status_t res = waitUntilStateThenRelock(/*active*/ false, kShutdownTimeout);
1022    return res;
1023}
1024
1025// Pause to reconfigure
1026status_t Camera3Device::internalPauseAndWaitLocked() {
1027    mRequestThread->setPaused(true);
1028    mPauseStateNotify = true;
1029
1030    ALOGV("%s: Camera %d: Internal wait until idle", __FUNCTION__, mId);
1031    status_t res = waitUntilStateThenRelock(/*active*/ false, kShutdownTimeout);
1032    if (res != OK) {
1033        SET_ERR_L("Can't idle device in %f seconds!",
1034                kShutdownTimeout/1e9);
1035    }
1036
1037    return res;
1038}
1039
1040// Resume after internalPauseAndWaitLocked
1041status_t Camera3Device::internalResumeLocked() {
1042    status_t res;
1043
1044    mRequestThread->setPaused(false);
1045
1046    res = waitUntilStateThenRelock(/*active*/ true, kActiveTimeout);
1047    if (res != OK) {
1048        SET_ERR_L("Can't transition to active in %f seconds!",
1049                kActiveTimeout/1e9);
1050    }
1051    mPauseStateNotify = false;
1052    return OK;
1053}
1054
1055status_t Camera3Device::waitUntilStateThenRelock(bool active,
1056        nsecs_t timeout) {
1057    status_t res = OK;
1058    if (active == (mStatus == STATUS_ACTIVE)) {
1059        // Desired state already reached
1060        return res;
1061    }
1062
1063    bool stateSeen = false;
1064    do {
1065        mRecentStatusUpdates.clear();
1066
1067        res = mStatusChanged.waitRelative(mLock, timeout);
1068        if (res != OK) break;
1069
1070        // Check state change history during wait
1071        for (size_t i = 0; i < mRecentStatusUpdates.size(); i++) {
1072            if (active == (mRecentStatusUpdates[i] == STATUS_ACTIVE) ) {
1073                stateSeen = true;
1074                break;
1075            }
1076        }
1077    } while (!stateSeen);
1078
1079    return res;
1080}
1081
1082
1083status_t Camera3Device::setNotifyCallback(NotificationListener *listener) {
1084    ATRACE_CALL();
1085    Mutex::Autolock l(mOutputLock);
1086
1087    if (listener != NULL && mListener != NULL) {
1088        ALOGW("%s: Replacing old callback listener", __FUNCTION__);
1089    }
1090    mListener = listener;
1091
1092    return OK;
1093}
1094
1095bool Camera3Device::willNotify3A() {
1096    return false;
1097}
1098
1099status_t Camera3Device::waitForNextFrame(nsecs_t timeout) {
1100    status_t res;
1101    Mutex::Autolock l(mOutputLock);
1102
1103    while (mResultQueue.empty()) {
1104        res = mResultSignal.waitRelative(mOutputLock, timeout);
1105        if (res == TIMED_OUT) {
1106            return res;
1107        } else if (res != OK) {
1108            ALOGW("%s: Camera %d: No frame in %lld ns: %s (%d)",
1109                    __FUNCTION__, mId, timeout, strerror(-res), res);
1110            return res;
1111        }
1112    }
1113    return OK;
1114}
1115
1116status_t Camera3Device::getNextFrame(CameraMetadata *frame) {
1117    ATRACE_CALL();
1118    Mutex::Autolock l(mOutputLock);
1119
1120    if (mResultQueue.empty()) {
1121        return NOT_ENOUGH_DATA;
1122    }
1123
1124    CameraMetadata &result = *(mResultQueue.begin());
1125    frame->acquire(result);
1126    mResultQueue.erase(mResultQueue.begin());
1127
1128    return OK;
1129}
1130
1131status_t Camera3Device::triggerAutofocus(uint32_t id) {
1132    ATRACE_CALL();
1133    Mutex::Autolock il(mInterfaceLock);
1134
1135    ALOGV("%s: Triggering autofocus, id %d", __FUNCTION__, id);
1136    // Mix-in this trigger into the next request and only the next request.
1137    RequestTrigger trigger[] = {
1138        {
1139            ANDROID_CONTROL_AF_TRIGGER,
1140            ANDROID_CONTROL_AF_TRIGGER_START
1141        },
1142        {
1143            ANDROID_CONTROL_AF_TRIGGER_ID,
1144            static_cast<int32_t>(id)
1145        },
1146    };
1147
1148    return mRequestThread->queueTrigger(trigger,
1149                                        sizeof(trigger)/sizeof(trigger[0]));
1150}
1151
1152status_t Camera3Device::triggerCancelAutofocus(uint32_t id) {
1153    ATRACE_CALL();
1154    Mutex::Autolock il(mInterfaceLock);
1155
1156    ALOGV("%s: Triggering cancel autofocus, id %d", __FUNCTION__, id);
1157    // Mix-in this trigger into the next request and only the next request.
1158    RequestTrigger trigger[] = {
1159        {
1160            ANDROID_CONTROL_AF_TRIGGER,
1161            ANDROID_CONTROL_AF_TRIGGER_CANCEL
1162        },
1163        {
1164            ANDROID_CONTROL_AF_TRIGGER_ID,
1165            static_cast<int32_t>(id)
1166        },
1167    };
1168
1169    return mRequestThread->queueTrigger(trigger,
1170                                        sizeof(trigger)/sizeof(trigger[0]));
1171}
1172
1173status_t Camera3Device::triggerPrecaptureMetering(uint32_t id) {
1174    ATRACE_CALL();
1175    Mutex::Autolock il(mInterfaceLock);
1176
1177    ALOGV("%s: Triggering precapture metering, id %d", __FUNCTION__, id);
1178    // Mix-in this trigger into the next request and only the next request.
1179    RequestTrigger trigger[] = {
1180        {
1181            ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER,
1182            ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_START
1183        },
1184        {
1185            ANDROID_CONTROL_AE_PRECAPTURE_ID,
1186            static_cast<int32_t>(id)
1187        },
1188    };
1189
1190    return mRequestThread->queueTrigger(trigger,
1191                                        sizeof(trigger)/sizeof(trigger[0]));
1192}
1193
1194status_t Camera3Device::pushReprocessBuffer(int reprocessStreamId,
1195        buffer_handle_t *buffer, wp<BufferReleasedListener> listener) {
1196    ATRACE_CALL();
1197    (void)reprocessStreamId; (void)buffer; (void)listener;
1198
1199    CLOGE("Unimplemented");
1200    return INVALID_OPERATION;
1201}
1202
1203status_t Camera3Device::flush() {
1204    ATRACE_CALL();
1205    ALOGV("%s: Camera %d: Flushing all requests", __FUNCTION__, mId);
1206    Mutex::Autolock il(mInterfaceLock);
1207    Mutex::Autolock l(mLock);
1208
1209    mRequestThread->clear();
1210    status_t res;
1211    if (mHal3Device->common.version >= CAMERA_DEVICE_API_VERSION_3_1) {
1212        res = mHal3Device->ops->flush(mHal3Device);
1213    } else {
1214        res = waitUntilDrainedLocked();
1215    }
1216
1217    return res;
1218}
1219
1220/**
1221 * Methods called by subclasses
1222 */
1223
1224void Camera3Device::notifyStatus(bool idle) {
1225    {
1226        // Need mLock to safely update state and synchronize to current
1227        // state of methods in flight.
1228        Mutex::Autolock l(mLock);
1229        // We can get various system-idle notices from the status tracker
1230        // while starting up. Only care about them if we've actually sent
1231        // in some requests recently.
1232        if (mStatus != STATUS_ACTIVE && mStatus != STATUS_CONFIGURED) {
1233            return;
1234        }
1235        ALOGV("%s: Camera %d: Now %s", __FUNCTION__, mId,
1236                idle ? "idle" : "active");
1237        mStatus = idle ? STATUS_CONFIGURED : STATUS_ACTIVE;
1238        mRecentStatusUpdates.add(mStatus);
1239        mStatusChanged.signal();
1240
1241        // Skip notifying listener if we're doing some user-transparent
1242        // state changes
1243        if (mPauseStateNotify) return;
1244    }
1245    NotificationListener *listener;
1246    {
1247        Mutex::Autolock l(mOutputLock);
1248        listener = mListener;
1249    }
1250    if (idle && listener != NULL) {
1251        listener->notifyIdle();
1252    }
1253}
1254
1255/**
1256 * Camera3Device private methods
1257 */
1258
1259sp<Camera3Device::CaptureRequest> Camera3Device::createCaptureRequest(
1260        const CameraMetadata &request) {
1261    ATRACE_CALL();
1262    status_t res;
1263
1264    sp<CaptureRequest> newRequest = new CaptureRequest;
1265    newRequest->mSettings = request;
1266
1267    camera_metadata_entry_t inputStreams =
1268            newRequest->mSettings.find(ANDROID_REQUEST_INPUT_STREAMS);
1269    if (inputStreams.count > 0) {
1270        if (mInputStream == NULL ||
1271                mInputStream->getId() != inputStreams.data.i32[0]) {
1272            CLOGE("Request references unknown input stream %d",
1273                    inputStreams.data.u8[0]);
1274            return NULL;
1275        }
1276        // Lazy completion of stream configuration (allocation/registration)
1277        // on first use
1278        if (mInputStream->isConfiguring()) {
1279            res = mInputStream->finishConfiguration(mHal3Device);
1280            if (res != OK) {
1281                SET_ERR_L("Unable to finish configuring input stream %d:"
1282                        " %s (%d)",
1283                        mInputStream->getId(), strerror(-res), res);
1284                return NULL;
1285            }
1286        }
1287
1288        newRequest->mInputStream = mInputStream;
1289        newRequest->mSettings.erase(ANDROID_REQUEST_INPUT_STREAMS);
1290    }
1291
1292    camera_metadata_entry_t streams =
1293            newRequest->mSettings.find(ANDROID_REQUEST_OUTPUT_STREAMS);
1294    if (streams.count == 0) {
1295        CLOGE("Zero output streams specified!");
1296        return NULL;
1297    }
1298
1299    for (size_t i = 0; i < streams.count; i++) {
1300        int idx = mOutputStreams.indexOfKey(streams.data.i32[i]);
1301        if (idx == NAME_NOT_FOUND) {
1302            CLOGE("Request references unknown stream %d",
1303                    streams.data.u8[i]);
1304            return NULL;
1305        }
1306        sp<Camera3OutputStreamInterface> stream =
1307                mOutputStreams.editValueAt(idx);
1308
1309        // Lazy completion of stream configuration (allocation/registration)
1310        // on first use
1311        if (stream->isConfiguring()) {
1312            res = stream->finishConfiguration(mHal3Device);
1313            if (res != OK) {
1314                SET_ERR_L("Unable to finish configuring stream %d: %s (%d)",
1315                        stream->getId(), strerror(-res), res);
1316                return NULL;
1317            }
1318        }
1319
1320        newRequest->mOutputStreams.push(stream);
1321    }
1322    newRequest->mSettings.erase(ANDROID_REQUEST_OUTPUT_STREAMS);
1323
1324    return newRequest;
1325}
1326
1327status_t Camera3Device::configureStreamsLocked() {
1328    ATRACE_CALL();
1329    status_t res;
1330
1331    if (mStatus != STATUS_UNCONFIGURED && mStatus != STATUS_CONFIGURED) {
1332        CLOGE("Not idle");
1333        return INVALID_OPERATION;
1334    }
1335
1336    if (!mNeedConfig) {
1337        ALOGV("%s: Skipping config, no stream changes", __FUNCTION__);
1338        return OK;
1339    }
1340
1341    // Start configuring the streams
1342    ALOGV("%s: Camera %d: Starting stream configuration", __FUNCTION__, mId);
1343
1344    camera3_stream_configuration config;
1345
1346    config.num_streams = (mInputStream != NULL) + mOutputStreams.size();
1347
1348    Vector<camera3_stream_t*> streams;
1349    streams.setCapacity(config.num_streams);
1350
1351    if (mInputStream != NULL) {
1352        camera3_stream_t *inputStream;
1353        inputStream = mInputStream->startConfiguration();
1354        if (inputStream == NULL) {
1355            SET_ERR_L("Can't start input stream configuration");
1356            return INVALID_OPERATION;
1357        }
1358        streams.add(inputStream);
1359    }
1360
1361    for (size_t i = 0; i < mOutputStreams.size(); i++) {
1362
1363        // Don't configure bidi streams twice, nor add them twice to the list
1364        if (mOutputStreams[i].get() ==
1365            static_cast<Camera3StreamInterface*>(mInputStream.get())) {
1366
1367            config.num_streams--;
1368            continue;
1369        }
1370
1371        camera3_stream_t *outputStream;
1372        outputStream = mOutputStreams.editValueAt(i)->startConfiguration();
1373        if (outputStream == NULL) {
1374            SET_ERR_L("Can't start output stream configuration");
1375            return INVALID_OPERATION;
1376        }
1377        streams.add(outputStream);
1378    }
1379
1380    config.streams = streams.editArray();
1381
1382    // Do the HAL configuration; will potentially touch stream
1383    // max_buffers, usage, priv fields.
1384    ATRACE_BEGIN("camera3->configure_streams");
1385    res = mHal3Device->ops->configure_streams(mHal3Device, &config);
1386    ATRACE_END();
1387
1388    if (res != OK) {
1389        SET_ERR_L("Unable to configure streams with HAL: %s (%d)",
1390                strerror(-res), res);
1391        return res;
1392    }
1393
1394    // Finish all stream configuration immediately.
1395    // TODO: Try to relax this later back to lazy completion, which should be
1396    // faster
1397
1398    if (mInputStream != NULL && mInputStream->isConfiguring()) {
1399        res = mInputStream->finishConfiguration(mHal3Device);
1400        if (res != OK) {
1401            SET_ERR_L("Can't finish configuring input stream %d: %s (%d)",
1402                    mInputStream->getId(), strerror(-res), res);
1403            return res;
1404        }
1405    }
1406
1407    for (size_t i = 0; i < mOutputStreams.size(); i++) {
1408        sp<Camera3OutputStreamInterface> outputStream =
1409            mOutputStreams.editValueAt(i);
1410        if (outputStream->isConfiguring()) {
1411            res = outputStream->finishConfiguration(mHal3Device);
1412            if (res != OK) {
1413                SET_ERR_L("Can't finish configuring output stream %d: %s (%d)",
1414                        outputStream->getId(), strerror(-res), res);
1415                return res;
1416            }
1417        }
1418    }
1419
1420    // Request thread needs to know to avoid using repeat-last-settings protocol
1421    // across configure_streams() calls
1422    mRequestThread->configurationComplete();
1423
1424    // Update device state
1425
1426    mNeedConfig = false;
1427
1428    if (config.num_streams > 0) {
1429        mStatus = STATUS_CONFIGURED;
1430    } else {
1431        mStatus = STATUS_UNCONFIGURED;
1432    }
1433
1434    ALOGV("%s: Camera %d: Stream configuration complete", __FUNCTION__, mId);
1435
1436    return OK;
1437}
1438
1439void Camera3Device::setErrorState(const char *fmt, ...) {
1440    Mutex::Autolock l(mLock);
1441    va_list args;
1442    va_start(args, fmt);
1443
1444    setErrorStateLockedV(fmt, args);
1445
1446    va_end(args);
1447}
1448
1449void Camera3Device::setErrorStateV(const char *fmt, va_list args) {
1450    Mutex::Autolock l(mLock);
1451    setErrorStateLockedV(fmt, args);
1452}
1453
1454void Camera3Device::setErrorStateLocked(const char *fmt, ...) {
1455    va_list args;
1456    va_start(args, fmt);
1457
1458    setErrorStateLockedV(fmt, args);
1459
1460    va_end(args);
1461}
1462
1463void Camera3Device::setErrorStateLockedV(const char *fmt, va_list args) {
1464    // Print out all error messages to log
1465    String8 errorCause = String8::formatV(fmt, args);
1466    ALOGE("Camera %d: %s", mId, errorCause.string());
1467
1468    // But only do error state transition steps for the first error
1469    if (mStatus == STATUS_ERROR || mStatus == STATUS_UNINITIALIZED) return;
1470
1471    // Save stack trace. View by dumping it later.
1472    CameraTraces::saveTrace();
1473    // TODO: consider adding errorCause and client pid/procname
1474
1475    mErrorCause = errorCause;
1476
1477    mRequestThread->setPaused(true);
1478    mStatus = STATUS_ERROR;
1479}
1480
1481/**
1482 * In-flight request management
1483 */
1484
1485status_t Camera3Device::registerInFlight(int32_t frameNumber,
1486        int32_t requestId, int32_t numBuffers) {
1487    ATRACE_CALL();
1488    Mutex::Autolock l(mInFlightLock);
1489
1490    ssize_t res;
1491    res = mInFlightMap.add(frameNumber, InFlightRequest(requestId, numBuffers));
1492    if (res < 0) return res;
1493
1494    return OK;
1495}
1496
1497/**
1498 * QUIRK(partial results)
1499 * Check if all 3A fields are ready, and send off a partial 3A-only result
1500 * to the output frame queue
1501 */
1502bool Camera3Device::processPartial3AQuirk(
1503        int32_t frameNumber, int32_t requestId,
1504        const CameraMetadata& partial) {
1505
1506    // Check if all 3A states are present
1507    // The full list of fields is
1508    //   android.control.afMode
1509    //   android.control.awbMode
1510    //   android.control.aeState
1511    //   android.control.awbState
1512    //   android.control.afState
1513    //   android.control.afTriggerID
1514    //   android.control.aePrecaptureID
1515    // TODO: Add android.control.aeMode
1516
1517    bool gotAllStates = true;
1518
1519    uint8_t afMode;
1520    uint8_t awbMode;
1521    uint8_t aeState;
1522    uint8_t afState;
1523    uint8_t awbState;
1524    int32_t afTriggerId;
1525    int32_t aeTriggerId;
1526
1527    gotAllStates &= get3AResult(partial, ANDROID_CONTROL_AF_MODE,
1528        &afMode, frameNumber);
1529
1530    gotAllStates &= get3AResult(partial, ANDROID_CONTROL_AWB_MODE,
1531        &awbMode, frameNumber);
1532
1533    gotAllStates &= get3AResult(partial, ANDROID_CONTROL_AE_STATE,
1534        &aeState, frameNumber);
1535
1536    gotAllStates &= get3AResult(partial, ANDROID_CONTROL_AF_STATE,
1537        &afState, frameNumber);
1538
1539    gotAllStates &= get3AResult(partial, ANDROID_CONTROL_AWB_STATE,
1540        &awbState, frameNumber);
1541
1542    gotAllStates &= get3AResult(partial, ANDROID_CONTROL_AF_TRIGGER_ID,
1543        &afTriggerId, frameNumber);
1544
1545    gotAllStates &= get3AResult(partial, ANDROID_CONTROL_AE_PRECAPTURE_ID,
1546        &aeTriggerId, frameNumber);
1547
1548    if (!gotAllStates) return false;
1549
1550    ALOGVV("%s: Camera %d: Frame %d, Request ID %d: AF mode %d, AWB mode %d, "
1551        "AF state %d, AE state %d, AWB state %d, "
1552        "AF trigger %d, AE precapture trigger %d",
1553        __FUNCTION__, mId, frameNumber, requestId,
1554        afMode, awbMode,
1555        afState, aeState, awbState,
1556        afTriggerId, aeTriggerId);
1557
1558    // Got all states, so construct a minimal result to send
1559    // In addition to the above fields, this means adding in
1560    //   android.request.frameCount
1561    //   android.request.requestId
1562    //   android.quirks.partialResult
1563
1564    const size_t kMinimal3AResultEntries = 10;
1565
1566    Mutex::Autolock l(mOutputLock);
1567
1568    CameraMetadata& min3AResult =
1569            *mResultQueue.insert(
1570                mResultQueue.end(),
1571                CameraMetadata(kMinimal3AResultEntries, /*dataCapacity*/ 0));
1572
1573    if (!insert3AResult(min3AResult, ANDROID_REQUEST_FRAME_COUNT,
1574            &frameNumber, frameNumber)) {
1575        return false;
1576    }
1577
1578    if (!insert3AResult(min3AResult, ANDROID_REQUEST_ID,
1579            &requestId, frameNumber)) {
1580        return false;
1581    }
1582
1583    static const uint8_t partialResult = ANDROID_QUIRKS_PARTIAL_RESULT_PARTIAL;
1584    if (!insert3AResult(min3AResult, ANDROID_QUIRKS_PARTIAL_RESULT,
1585            &partialResult, frameNumber)) {
1586        return false;
1587    }
1588
1589    if (!insert3AResult(min3AResult, ANDROID_CONTROL_AF_MODE,
1590            &afMode, frameNumber)) {
1591        return false;
1592    }
1593
1594    if (!insert3AResult(min3AResult, ANDROID_CONTROL_AWB_MODE,
1595            &awbMode, frameNumber)) {
1596        return false;
1597    }
1598
1599    if (!insert3AResult(min3AResult, ANDROID_CONTROL_AE_STATE,
1600            &aeState, frameNumber)) {
1601        return false;
1602    }
1603
1604    if (!insert3AResult(min3AResult, ANDROID_CONTROL_AF_STATE,
1605            &afState, frameNumber)) {
1606        return false;
1607    }
1608
1609    if (!insert3AResult(min3AResult, ANDROID_CONTROL_AWB_STATE,
1610            &awbState, frameNumber)) {
1611        return false;
1612    }
1613
1614    if (!insert3AResult(min3AResult, ANDROID_CONTROL_AF_TRIGGER_ID,
1615            &afTriggerId, frameNumber)) {
1616        return false;
1617    }
1618
1619    if (!insert3AResult(min3AResult, ANDROID_CONTROL_AE_PRECAPTURE_ID,
1620            &aeTriggerId, frameNumber)) {
1621        return false;
1622    }
1623
1624    mResultSignal.signal();
1625
1626    return true;
1627}
1628
1629template<typename T>
1630bool Camera3Device::get3AResult(const CameraMetadata& result, int32_t tag,
1631        T* value, int32_t frameNumber) {
1632    (void) frameNumber;
1633
1634    camera_metadata_ro_entry_t entry;
1635
1636    entry = result.find(tag);
1637    if (entry.count == 0) {
1638        ALOGVV("%s: Camera %d: Frame %d: No %s provided by HAL!", __FUNCTION__,
1639            mId, frameNumber, get_camera_metadata_tag_name(tag));
1640        return false;
1641    }
1642
1643    if (sizeof(T) == sizeof(uint8_t)) {
1644        *value = entry.data.u8[0];
1645    } else if (sizeof(T) == sizeof(int32_t)) {
1646        *value = entry.data.i32[0];
1647    } else {
1648        ALOGE("%s: Unexpected type", __FUNCTION__);
1649        return false;
1650    }
1651    return true;
1652}
1653
1654template<typename T>
1655bool Camera3Device::insert3AResult(CameraMetadata& result, int32_t tag,
1656        const T* value, int32_t frameNumber) {
1657    if (result.update(tag, value, 1) != NO_ERROR) {
1658        mResultQueue.erase(--mResultQueue.end(), mResultQueue.end());
1659        SET_ERR("Frame %d: Failed to set %s in partial metadata",
1660                frameNumber, get_camera_metadata_tag_name(tag));
1661        return false;
1662    }
1663    return true;
1664}
1665
1666/**
1667 * Camera HAL device callback methods
1668 */
1669
1670void Camera3Device::processCaptureResult(const camera3_capture_result *result) {
1671    ATRACE_CALL();
1672
1673    status_t res;
1674
1675    uint32_t frameNumber = result->frame_number;
1676    if (result->result == NULL && result->num_output_buffers == 0) {
1677        SET_ERR("No result data provided by HAL for frame %d",
1678                frameNumber);
1679        return;
1680    }
1681    bool partialResultQuirk = false;
1682    CameraMetadata collectedQuirkResult;
1683
1684    // Get capture timestamp from list of in-flight requests, where it was added
1685    // by the shutter notification for this frame. Then update the in-flight
1686    // status and remove the in-flight entry if all result data has been
1687    // received.
1688    nsecs_t timestamp = 0;
1689    {
1690        Mutex::Autolock l(mInFlightLock);
1691        ssize_t idx = mInFlightMap.indexOfKey(frameNumber);
1692        if (idx == NAME_NOT_FOUND) {
1693            SET_ERR("Unknown frame number for capture result: %d",
1694                    frameNumber);
1695            return;
1696        }
1697        InFlightRequest &request = mInFlightMap.editValueAt(idx);
1698
1699        // Check if this result carries only partial metadata
1700        if (mUsePartialResultQuirk && result->result != NULL) {
1701            camera_metadata_ro_entry_t partialResultEntry;
1702            res = find_camera_metadata_ro_entry(result->result,
1703                    ANDROID_QUIRKS_PARTIAL_RESULT, &partialResultEntry);
1704            if (res != NAME_NOT_FOUND &&
1705                    partialResultEntry.count > 0 &&
1706                    partialResultEntry.data.u8[0] ==
1707                    ANDROID_QUIRKS_PARTIAL_RESULT_PARTIAL) {
1708                // A partial result. Flag this as such, and collect this
1709                // set of metadata into the in-flight entry.
1710                partialResultQuirk = true;
1711                request.partialResultQuirk.collectedResult.append(
1712                    result->result);
1713                request.partialResultQuirk.collectedResult.erase(
1714                    ANDROID_QUIRKS_PARTIAL_RESULT);
1715                // Fire off a 3A-only result if possible
1716                if (!request.partialResultQuirk.haveSent3A) {
1717                    request.partialResultQuirk.haveSent3A =
1718                            processPartial3AQuirk(frameNumber,
1719                                    request.requestId,
1720                                    request.partialResultQuirk.collectedResult);
1721                }
1722            }
1723        }
1724
1725        timestamp = request.captureTimestamp;
1726        /**
1727         * One of the following must happen before it's legal to call process_capture_result,
1728         * unless partial metadata is being provided:
1729         * - CAMERA3_MSG_SHUTTER (expected during normal operation)
1730         * - CAMERA3_MSG_ERROR (expected during flush)
1731         */
1732        if (request.requestStatus == OK && timestamp == 0 && !partialResultQuirk) {
1733            SET_ERR("Called before shutter notify for frame %d",
1734                    frameNumber);
1735            return;
1736        }
1737
1738        // Did we get the (final) result metadata for this capture?
1739        if (result->result != NULL && !partialResultQuirk) {
1740            if (request.haveResultMetadata) {
1741                SET_ERR("Called multiple times with metadata for frame %d",
1742                        frameNumber);
1743                return;
1744            }
1745            if (mUsePartialResultQuirk &&
1746                    !request.partialResultQuirk.collectedResult.isEmpty()) {
1747                collectedQuirkResult.acquire(
1748                    request.partialResultQuirk.collectedResult);
1749            }
1750            request.haveResultMetadata = true;
1751        }
1752
1753        request.numBuffersLeft -= result->num_output_buffers;
1754
1755        if (request.numBuffersLeft < 0) {
1756            SET_ERR("Too many buffers returned for frame %d",
1757                    frameNumber);
1758            return;
1759        }
1760
1761        // Check if everything has arrived for this result (buffers and metadata), remove it from
1762        // InFlightMap if both arrived or HAL reports error for this request (i.e. during flush).
1763        if ((request.requestStatus != OK) ||
1764                (request.haveResultMetadata && request.numBuffersLeft == 0)) {
1765            ATRACE_ASYNC_END("frame capture", frameNumber);
1766            mInFlightMap.removeItemsAt(idx, 1);
1767        }
1768
1769        // Sanity check - if we have too many in-flight frames, something has
1770        // likely gone wrong
1771        if (mInFlightMap.size() > kInFlightWarnLimit) {
1772            CLOGE("In-flight list too large: %d", mInFlightMap.size());
1773        }
1774
1775    }
1776
1777    // Process the result metadata, if provided
1778    bool gotResult = false;
1779    if (result->result != NULL && !partialResultQuirk) {
1780        Mutex::Autolock l(mOutputLock);
1781
1782        gotResult = true;
1783
1784        if (frameNumber != mNextResultFrameNumber) {
1785            SET_ERR("Out-of-order capture result metadata submitted! "
1786                    "(got frame number %d, expecting %d)",
1787                    frameNumber, mNextResultFrameNumber);
1788            return;
1789        }
1790        mNextResultFrameNumber++;
1791
1792        CameraMetadata captureResult;
1793        captureResult = result->result;
1794
1795        if (captureResult.update(ANDROID_REQUEST_FRAME_COUNT,
1796                        (int32_t*)&frameNumber, 1) != OK) {
1797            SET_ERR("Failed to set frame# in metadata (%d)",
1798                    frameNumber);
1799            gotResult = false;
1800        } else {
1801            ALOGVV("%s: Camera %d: Set frame# in metadata (%d)",
1802                    __FUNCTION__, mId, frameNumber);
1803        }
1804
1805        // Append any previous partials to form a complete result
1806        if (mUsePartialResultQuirk && !collectedQuirkResult.isEmpty()) {
1807            captureResult.append(collectedQuirkResult);
1808        }
1809
1810        captureResult.sort();
1811
1812        // Check that there's a timestamp in the result metadata
1813
1814        camera_metadata_entry entry =
1815                captureResult.find(ANDROID_SENSOR_TIMESTAMP);
1816        if (entry.count == 0) {
1817            SET_ERR("No timestamp provided by HAL for frame %d!",
1818                    frameNumber);
1819            gotResult = false;
1820        } else if (timestamp != entry.data.i64[0]) {
1821            SET_ERR("Timestamp mismatch between shutter notify and result"
1822                    " metadata for frame %d (%lld vs %lld respectively)",
1823                    frameNumber, timestamp, entry.data.i64[0]);
1824            gotResult = false;
1825        }
1826
1827        if (gotResult) {
1828            // Valid result, insert into queue
1829            CameraMetadata& queuedResult =
1830                *mResultQueue.insert(mResultQueue.end(), CameraMetadata());
1831            queuedResult.swap(captureResult);
1832        }
1833    } // scope for mOutputLock
1834
1835    // Return completed buffers to their streams with the timestamp
1836
1837    for (size_t i = 0; i < result->num_output_buffers; i++) {
1838        Camera3Stream *stream =
1839                Camera3Stream::cast(result->output_buffers[i].stream);
1840        res = stream->returnBuffer(result->output_buffers[i], timestamp);
1841        // Note: stream may be deallocated at this point, if this buffer was the
1842        // last reference to it.
1843        if (res != OK) {
1844            ALOGE("Can't return buffer %d for frame %d to its stream: "
1845                    " %s (%d)", i, frameNumber, strerror(-res), res);
1846        }
1847    }
1848
1849    // Finally, signal any waiters for new frames
1850
1851    if (gotResult) {
1852        mResultSignal.signal();
1853    }
1854
1855}
1856
1857
1858
1859void Camera3Device::notify(const camera3_notify_msg *msg) {
1860    ATRACE_CALL();
1861    NotificationListener *listener;
1862    {
1863        Mutex::Autolock l(mOutputLock);
1864        listener = mListener;
1865    }
1866
1867    if (msg == NULL) {
1868        SET_ERR("HAL sent NULL notify message!");
1869        return;
1870    }
1871
1872    switch (msg->type) {
1873        case CAMERA3_MSG_ERROR: {
1874            int streamId = 0;
1875            if (msg->message.error.error_stream != NULL) {
1876                Camera3Stream *stream =
1877                        Camera3Stream::cast(
1878                                  msg->message.error.error_stream);
1879                streamId = stream->getId();
1880            }
1881            ALOGV("Camera %d: %s: HAL error, frame %d, stream %d: %d",
1882                    mId, __FUNCTION__, msg->message.error.frame_number,
1883                    streamId, msg->message.error.error_code);
1884
1885            // Set request error status for the request in the in-flight tracking
1886            {
1887                Mutex::Autolock l(mInFlightLock);
1888                ssize_t idx = mInFlightMap.indexOfKey(msg->message.error.frame_number);
1889                if (idx >= 0) {
1890                    mInFlightMap.editValueAt(idx).requestStatus = msg->message.error.error_code;
1891                }
1892            }
1893
1894            if (listener != NULL) {
1895                listener->notifyError(msg->message.error.error_code,
1896                        msg->message.error.frame_number, streamId);
1897            }
1898            break;
1899        }
1900        case CAMERA3_MSG_SHUTTER: {
1901            ssize_t idx;
1902            uint32_t frameNumber = msg->message.shutter.frame_number;
1903            nsecs_t timestamp = msg->message.shutter.timestamp;
1904            // Verify ordering of shutter notifications
1905            {
1906                Mutex::Autolock l(mOutputLock);
1907                if (frameNumber != mNextShutterFrameNumber) {
1908                    SET_ERR("Shutter notification out-of-order. Expected "
1909                            "notification for frame %d, got frame %d",
1910                            mNextShutterFrameNumber, frameNumber);
1911                    break;
1912                }
1913                mNextShutterFrameNumber++;
1914            }
1915
1916            int32_t requestId = -1;
1917
1918            // Set timestamp for the request in the in-flight tracking
1919            // and get the request ID to send upstream
1920            {
1921                Mutex::Autolock l(mInFlightLock);
1922                idx = mInFlightMap.indexOfKey(frameNumber);
1923                if (idx >= 0) {
1924                    InFlightRequest &r = mInFlightMap.editValueAt(idx);
1925                    r.captureTimestamp = timestamp;
1926                    requestId = r.requestId;
1927                }
1928            }
1929            if (idx < 0) {
1930                SET_ERR("Shutter notification for non-existent frame number %d",
1931                        frameNumber);
1932                break;
1933            }
1934            ALOGVV("Camera %d: %s: Shutter fired for frame %d (id %d) at %lld",
1935                    mId, __FUNCTION__, frameNumber, requestId, timestamp);
1936            // Call listener, if any
1937            if (listener != NULL) {
1938                listener->notifyShutter(requestId, timestamp);
1939            }
1940            break;
1941        }
1942        default:
1943            SET_ERR("Unknown notify message from HAL: %d",
1944                    msg->type);
1945    }
1946}
1947
1948CameraMetadata Camera3Device::getLatestRequestLocked() {
1949    ALOGV("%s", __FUNCTION__);
1950
1951    CameraMetadata retVal;
1952
1953    if (mRequestThread != NULL) {
1954        retVal = mRequestThread->getLatestRequest();
1955    }
1956
1957    return retVal;
1958}
1959
1960/**
1961 * RequestThread inner class methods
1962 */
1963
1964Camera3Device::RequestThread::RequestThread(wp<Camera3Device> parent,
1965        sp<StatusTracker> statusTracker,
1966        camera3_device_t *hal3Device) :
1967        Thread(false),
1968        mParent(parent),
1969        mStatusTracker(statusTracker),
1970        mHal3Device(hal3Device),
1971        mId(getId(parent)),
1972        mReconfigured(false),
1973        mDoPause(false),
1974        mPaused(true),
1975        mFrameNumber(0),
1976        mLatestRequestId(NAME_NOT_FOUND) {
1977    mStatusId = statusTracker->addComponent();
1978}
1979
1980void Camera3Device::RequestThread::configurationComplete() {
1981    Mutex::Autolock l(mRequestLock);
1982    mReconfigured = true;
1983}
1984
1985status_t Camera3Device::RequestThread::queueRequest(
1986         sp<CaptureRequest> request) {
1987    Mutex::Autolock l(mRequestLock);
1988    mRequestQueue.push_back(request);
1989
1990    unpauseForNewRequests();
1991
1992    return OK;
1993}
1994
1995status_t Camera3Device::RequestThread::queueRequestList(
1996        List<sp<CaptureRequest> > &requests) {
1997    Mutex::Autolock l(mRequestLock);
1998    for (List<sp<CaptureRequest> >::iterator it = requests.begin(); it != requests.end();
1999            ++it) {
2000        mRequestQueue.push_back(*it);
2001    }
2002
2003    unpauseForNewRequests();
2004
2005    return OK;
2006}
2007
2008
2009status_t Camera3Device::RequestThread::queueTrigger(
2010        RequestTrigger trigger[],
2011        size_t count) {
2012
2013    Mutex::Autolock l(mTriggerMutex);
2014    status_t ret;
2015
2016    for (size_t i = 0; i < count; ++i) {
2017        ret = queueTriggerLocked(trigger[i]);
2018
2019        if (ret != OK) {
2020            return ret;
2021        }
2022    }
2023
2024    return OK;
2025}
2026
2027int Camera3Device::RequestThread::getId(const wp<Camera3Device> &device) {
2028    sp<Camera3Device> d = device.promote();
2029    if (d != NULL) return d->mId;
2030    return 0;
2031}
2032
2033status_t Camera3Device::RequestThread::queueTriggerLocked(
2034        RequestTrigger trigger) {
2035
2036    uint32_t tag = trigger.metadataTag;
2037    ssize_t index = mTriggerMap.indexOfKey(tag);
2038
2039    switch (trigger.getTagType()) {
2040        case TYPE_BYTE:
2041        // fall-through
2042        case TYPE_INT32:
2043            break;
2044        default:
2045            ALOGE("%s: Type not supported: 0x%x", __FUNCTION__,
2046                    trigger.getTagType());
2047            return INVALID_OPERATION;
2048    }
2049
2050    /**
2051     * Collect only the latest trigger, since we only have 1 field
2052     * in the request settings per trigger tag, and can't send more than 1
2053     * trigger per request.
2054     */
2055    if (index != NAME_NOT_FOUND) {
2056        mTriggerMap.editValueAt(index) = trigger;
2057    } else {
2058        mTriggerMap.add(tag, trigger);
2059    }
2060
2061    return OK;
2062}
2063
2064status_t Camera3Device::RequestThread::setRepeatingRequests(
2065        const RequestList &requests) {
2066    Mutex::Autolock l(mRequestLock);
2067    mRepeatingRequests.clear();
2068    mRepeatingRequests.insert(mRepeatingRequests.begin(),
2069            requests.begin(), requests.end());
2070
2071    unpauseForNewRequests();
2072
2073    return OK;
2074}
2075
2076status_t Camera3Device::RequestThread::clearRepeatingRequests() {
2077    Mutex::Autolock l(mRequestLock);
2078    mRepeatingRequests.clear();
2079    return OK;
2080}
2081
2082status_t Camera3Device::RequestThread::clear() {
2083    Mutex::Autolock l(mRequestLock);
2084    mRepeatingRequests.clear();
2085    mRequestQueue.clear();
2086    mTriggerMap.clear();
2087    return OK;
2088}
2089
2090void Camera3Device::RequestThread::setPaused(bool paused) {
2091    Mutex::Autolock l(mPauseLock);
2092    mDoPause = paused;
2093    mDoPauseSignal.signal();
2094}
2095
2096status_t Camera3Device::RequestThread::waitUntilRequestProcessed(
2097        int32_t requestId, nsecs_t timeout) {
2098    Mutex::Autolock l(mLatestRequestMutex);
2099    status_t res;
2100    while (mLatestRequestId != requestId) {
2101        nsecs_t startTime = systemTime();
2102
2103        res = mLatestRequestSignal.waitRelative(mLatestRequestMutex, timeout);
2104        if (res != OK) return res;
2105
2106        timeout -= (systemTime() - startTime);
2107    }
2108
2109    return OK;
2110}
2111
2112void Camera3Device::RequestThread::requestExit() {
2113    // Call parent to set up shutdown
2114    Thread::requestExit();
2115    // The exit from any possible waits
2116    mDoPauseSignal.signal();
2117    mRequestSignal.signal();
2118}
2119
2120bool Camera3Device::RequestThread::threadLoop() {
2121
2122    status_t res;
2123
2124    // Handle paused state.
2125    if (waitIfPaused()) {
2126        return true;
2127    }
2128
2129    // Get work to do
2130
2131    sp<CaptureRequest> nextRequest = waitForNextRequest();
2132    if (nextRequest == NULL) {
2133        return true;
2134    }
2135
2136    // Create request to HAL
2137    camera3_capture_request_t request = camera3_capture_request_t();
2138    Vector<camera3_stream_buffer_t> outputBuffers;
2139
2140    // Get the request ID, if any
2141    int requestId;
2142    camera_metadata_entry_t requestIdEntry =
2143            nextRequest->mSettings.find(ANDROID_REQUEST_ID);
2144    if (requestIdEntry.count > 0) {
2145        requestId = requestIdEntry.data.i32[0];
2146    } else {
2147        ALOGW("%s: Did not have android.request.id set in the request",
2148                __FUNCTION__);
2149        requestId = NAME_NOT_FOUND;
2150    }
2151
2152    // Insert any queued triggers (before metadata is locked)
2153    int32_t triggerCount;
2154    res = insertTriggers(nextRequest);
2155    if (res < 0) {
2156        SET_ERR("RequestThread: Unable to insert triggers "
2157                "(capture request %d, HAL device: %s (%d)",
2158                (mFrameNumber+1), strerror(-res), res);
2159        cleanUpFailedRequest(request, nextRequest, outputBuffers);
2160        return false;
2161    }
2162    triggerCount = res;
2163
2164    bool triggersMixedIn = (triggerCount > 0 || mPrevTriggers > 0);
2165
2166    // If the request is the same as last, or we had triggers last time
2167    if (mPrevRequest != nextRequest || triggersMixedIn) {
2168        /**
2169         * HAL workaround:
2170         * Insert a dummy trigger ID if a trigger is set but no trigger ID is
2171         */
2172        res = addDummyTriggerIds(nextRequest);
2173        if (res != OK) {
2174            SET_ERR("RequestThread: Unable to insert dummy trigger IDs "
2175                    "(capture request %d, HAL device: %s (%d)",
2176                    (mFrameNumber+1), strerror(-res), res);
2177            cleanUpFailedRequest(request, nextRequest, outputBuffers);
2178            return false;
2179        }
2180
2181        /**
2182         * The request should be presorted so accesses in HAL
2183         *   are O(logn). Sidenote, sorting a sorted metadata is nop.
2184         */
2185        nextRequest->mSettings.sort();
2186        request.settings = nextRequest->mSettings.getAndLock();
2187        mPrevRequest = nextRequest;
2188        ALOGVV("%s: Request settings are NEW", __FUNCTION__);
2189
2190        IF_ALOGV() {
2191            camera_metadata_ro_entry_t e = camera_metadata_ro_entry_t();
2192            find_camera_metadata_ro_entry(
2193                    request.settings,
2194                    ANDROID_CONTROL_AF_TRIGGER,
2195                    &e
2196            );
2197            if (e.count > 0) {
2198                ALOGV("%s: Request (frame num %d) had AF trigger 0x%x",
2199                      __FUNCTION__,
2200                      mFrameNumber+1,
2201                      e.data.u8[0]);
2202            }
2203        }
2204    } else {
2205        // leave request.settings NULL to indicate 'reuse latest given'
2206        ALOGVV("%s: Request settings are REUSED",
2207               __FUNCTION__);
2208    }
2209
2210    camera3_stream_buffer_t inputBuffer;
2211
2212    // Fill in buffers
2213
2214    if (nextRequest->mInputStream != NULL) {
2215        request.input_buffer = &inputBuffer;
2216        res = nextRequest->mInputStream->getInputBuffer(&inputBuffer);
2217        if (res != OK) {
2218            ALOGE("RequestThread: Can't get input buffer, skipping request:"
2219                    " %s (%d)", strerror(-res), res);
2220            cleanUpFailedRequest(request, nextRequest, outputBuffers);
2221            return true;
2222        }
2223    } else {
2224        request.input_buffer = NULL;
2225    }
2226
2227    outputBuffers.insertAt(camera3_stream_buffer_t(), 0,
2228            nextRequest->mOutputStreams.size());
2229    request.output_buffers = outputBuffers.array();
2230    for (size_t i = 0; i < nextRequest->mOutputStreams.size(); i++) {
2231        res = nextRequest->mOutputStreams.editItemAt(i)->
2232                getBuffer(&outputBuffers.editItemAt(i));
2233        if (res != OK) {
2234            ALOGE("RequestThread: Can't get output buffer, skipping request:"
2235                    " %s (%d)", strerror(-res), res);
2236            cleanUpFailedRequest(request, nextRequest, outputBuffers);
2237            return true;
2238        }
2239        request.num_output_buffers++;
2240    }
2241
2242    request.frame_number = mFrameNumber++;
2243
2244    // Log request in the in-flight queue
2245    sp<Camera3Device> parent = mParent.promote();
2246    if (parent == NULL) {
2247        CLOGE("RequestThread: Parent is gone");
2248        cleanUpFailedRequest(request, nextRequest, outputBuffers);
2249        return false;
2250    }
2251
2252    res = parent->registerInFlight(request.frame_number, requestId,
2253            request.num_output_buffers);
2254    if (res != OK) {
2255        SET_ERR("RequestThread: Unable to register new in-flight request:"
2256                " %s (%d)", strerror(-res), res);
2257        cleanUpFailedRequest(request, nextRequest, outputBuffers);
2258        return false;
2259    }
2260
2261    // Inform waitUntilRequestProcessed thread of a new request ID
2262    {
2263        Mutex::Autolock al(mLatestRequestMutex);
2264
2265        mLatestRequestId = requestId;
2266        mLatestRequestSignal.signal();
2267    }
2268
2269    // Submit request and block until ready for next one
2270    ATRACE_ASYNC_BEGIN("frame capture", request.frame_number);
2271    ATRACE_BEGIN("camera3->process_capture_request");
2272    res = mHal3Device->ops->process_capture_request(mHal3Device, &request);
2273    ATRACE_END();
2274
2275    if (res != OK) {
2276        SET_ERR("RequestThread: Unable to submit capture request %d to HAL"
2277                " device: %s (%d)", request.frame_number, strerror(-res), res);
2278        cleanUpFailedRequest(request, nextRequest, outputBuffers);
2279        return false;
2280    }
2281
2282    // Update the latest request sent to HAL
2283    if (request.settings != NULL) { // Don't update them if they were unchanged
2284        Mutex::Autolock al(mLatestRequestMutex);
2285
2286        camera_metadata_t* cloned = clone_camera_metadata(request.settings);
2287        mLatestRequest.acquire(cloned);
2288    }
2289
2290    if (request.settings != NULL) {
2291        nextRequest->mSettings.unlock(request.settings);
2292    }
2293
2294    // Remove any previously queued triggers (after unlock)
2295    res = removeTriggers(mPrevRequest);
2296    if (res != OK) {
2297        SET_ERR("RequestThread: Unable to remove triggers "
2298              "(capture request %d, HAL device: %s (%d)",
2299              request.frame_number, strerror(-res), res);
2300        return false;
2301    }
2302    mPrevTriggers = triggerCount;
2303
2304    // Return input buffer back to framework
2305    if (request.input_buffer != NULL) {
2306        Camera3Stream *stream =
2307            Camera3Stream::cast(request.input_buffer->stream);
2308        res = stream->returnInputBuffer(*(request.input_buffer));
2309        // Note: stream may be deallocated at this point, if this buffer was the
2310        // last reference to it.
2311        if (res != OK) {
2312            ALOGE("%s: RequestThread: Can't return input buffer for frame %d to"
2313                    "  its stream:%s (%d)",  __FUNCTION__,
2314                    request.frame_number, strerror(-res), res);
2315            // TODO: Report error upstream
2316        }
2317    }
2318
2319    return true;
2320}
2321
2322CameraMetadata Camera3Device::RequestThread::getLatestRequest() const {
2323    Mutex::Autolock al(mLatestRequestMutex);
2324
2325    ALOGV("RequestThread::%s", __FUNCTION__);
2326
2327    return mLatestRequest;
2328}
2329
2330void Camera3Device::RequestThread::cleanUpFailedRequest(
2331        camera3_capture_request_t &request,
2332        sp<CaptureRequest> &nextRequest,
2333        Vector<camera3_stream_buffer_t> &outputBuffers) {
2334
2335    if (request.settings != NULL) {
2336        nextRequest->mSettings.unlock(request.settings);
2337    }
2338    if (request.input_buffer != NULL) {
2339        request.input_buffer->status = CAMERA3_BUFFER_STATUS_ERROR;
2340        nextRequest->mInputStream->returnInputBuffer(*(request.input_buffer));
2341    }
2342    for (size_t i = 0; i < request.num_output_buffers; i++) {
2343        outputBuffers.editItemAt(i).status = CAMERA3_BUFFER_STATUS_ERROR;
2344        nextRequest->mOutputStreams.editItemAt(i)->returnBuffer(
2345            outputBuffers[i], 0);
2346    }
2347}
2348
2349sp<Camera3Device::CaptureRequest>
2350        Camera3Device::RequestThread::waitForNextRequest() {
2351    status_t res;
2352    sp<CaptureRequest> nextRequest;
2353
2354    // Optimized a bit for the simple steady-state case (single repeating
2355    // request), to avoid putting that request in the queue temporarily.
2356    Mutex::Autolock l(mRequestLock);
2357
2358    while (mRequestQueue.empty()) {
2359        if (!mRepeatingRequests.empty()) {
2360            // Always atomically enqueue all requests in a repeating request
2361            // list. Guarantees a complete in-sequence set of captures to
2362            // application.
2363            const RequestList &requests = mRepeatingRequests;
2364            RequestList::const_iterator firstRequest =
2365                    requests.begin();
2366            nextRequest = *firstRequest;
2367            mRequestQueue.insert(mRequestQueue.end(),
2368                    ++firstRequest,
2369                    requests.end());
2370            // No need to wait any longer
2371            break;
2372        }
2373
2374        res = mRequestSignal.waitRelative(mRequestLock, kRequestTimeout);
2375
2376        if ((mRequestQueue.empty() && mRepeatingRequests.empty()) ||
2377                exitPending()) {
2378            Mutex::Autolock pl(mPauseLock);
2379            if (mPaused == false) {
2380                ALOGV("%s: RequestThread: Going idle", __FUNCTION__);
2381                mPaused = true;
2382                // Let the tracker know
2383                sp<StatusTracker> statusTracker = mStatusTracker.promote();
2384                if (statusTracker != 0) {
2385                    statusTracker->markComponentIdle(mStatusId, Fence::NO_FENCE);
2386                }
2387            }
2388            // Stop waiting for now and let thread management happen
2389            return NULL;
2390        }
2391    }
2392
2393    if (nextRequest == NULL) {
2394        // Don't have a repeating request already in hand, so queue
2395        // must have an entry now.
2396        RequestList::iterator firstRequest =
2397                mRequestQueue.begin();
2398        nextRequest = *firstRequest;
2399        mRequestQueue.erase(firstRequest);
2400    }
2401
2402    // In case we've been unpaused by setPaused clearing mDoPause, need to
2403    // update internal pause state (capture/setRepeatingRequest unpause
2404    // directly).
2405    Mutex::Autolock pl(mPauseLock);
2406    if (mPaused) {
2407        ALOGV("%s: RequestThread: Unpaused", __FUNCTION__);
2408        sp<StatusTracker> statusTracker = mStatusTracker.promote();
2409        if (statusTracker != 0) {
2410            statusTracker->markComponentActive(mStatusId);
2411        }
2412    }
2413    mPaused = false;
2414
2415    // Check if we've reconfigured since last time, and reset the preview
2416    // request if so. Can't use 'NULL request == repeat' across configure calls.
2417    if (mReconfigured) {
2418        mPrevRequest.clear();
2419        mReconfigured = false;
2420    }
2421
2422    return nextRequest;
2423}
2424
2425bool Camera3Device::RequestThread::waitIfPaused() {
2426    status_t res;
2427    Mutex::Autolock l(mPauseLock);
2428    while (mDoPause) {
2429        if (mPaused == false) {
2430            mPaused = true;
2431            ALOGV("%s: RequestThread: Paused", __FUNCTION__);
2432            // Let the tracker know
2433            sp<StatusTracker> statusTracker = mStatusTracker.promote();
2434            if (statusTracker != 0) {
2435                statusTracker->markComponentIdle(mStatusId, Fence::NO_FENCE);
2436            }
2437        }
2438
2439        res = mDoPauseSignal.waitRelative(mPauseLock, kRequestTimeout);
2440        if (res == TIMED_OUT || exitPending()) {
2441            return true;
2442        }
2443    }
2444    // We don't set mPaused to false here, because waitForNextRequest needs
2445    // to further manage the paused state in case of starvation.
2446    return false;
2447}
2448
2449void Camera3Device::RequestThread::unpauseForNewRequests() {
2450    // With work to do, mark thread as unpaused.
2451    // If paused by request (setPaused), don't resume, to avoid
2452    // extra signaling/waiting overhead to waitUntilPaused
2453    mRequestSignal.signal();
2454    Mutex::Autolock p(mPauseLock);
2455    if (!mDoPause) {
2456        ALOGV("%s: RequestThread: Going active", __FUNCTION__);
2457        if (mPaused) {
2458            sp<StatusTracker> statusTracker = mStatusTracker.promote();
2459            if (statusTracker != 0) {
2460                statusTracker->markComponentActive(mStatusId);
2461            }
2462        }
2463        mPaused = false;
2464    }
2465}
2466
2467void Camera3Device::RequestThread::setErrorState(const char *fmt, ...) {
2468    sp<Camera3Device> parent = mParent.promote();
2469    if (parent != NULL) {
2470        va_list args;
2471        va_start(args, fmt);
2472
2473        parent->setErrorStateV(fmt, args);
2474
2475        va_end(args);
2476    }
2477}
2478
2479status_t Camera3Device::RequestThread::insertTriggers(
2480        const sp<CaptureRequest> &request) {
2481
2482    Mutex::Autolock al(mTriggerMutex);
2483
2484    CameraMetadata &metadata = request->mSettings;
2485    size_t count = mTriggerMap.size();
2486
2487    for (size_t i = 0; i < count; ++i) {
2488        RequestTrigger trigger = mTriggerMap.valueAt(i);
2489
2490        uint32_t tag = trigger.metadataTag;
2491        camera_metadata_entry entry = metadata.find(tag);
2492
2493        if (entry.count > 0) {
2494            /**
2495             * Already has an entry for this trigger in the request.
2496             * Rewrite it with our requested trigger value.
2497             */
2498            RequestTrigger oldTrigger = trigger;
2499
2500            oldTrigger.entryValue = entry.data.u8[0];
2501
2502            mTriggerReplacedMap.add(tag, oldTrigger);
2503        } else {
2504            /**
2505             * More typical, no trigger entry, so we just add it
2506             */
2507            mTriggerRemovedMap.add(tag, trigger);
2508        }
2509
2510        status_t res;
2511
2512        switch (trigger.getTagType()) {
2513            case TYPE_BYTE: {
2514                uint8_t entryValue = static_cast<uint8_t>(trigger.entryValue);
2515                res = metadata.update(tag,
2516                                      &entryValue,
2517                                      /*count*/1);
2518                break;
2519            }
2520            case TYPE_INT32:
2521                res = metadata.update(tag,
2522                                      &trigger.entryValue,
2523                                      /*count*/1);
2524                break;
2525            default:
2526                ALOGE("%s: Type not supported: 0x%x",
2527                      __FUNCTION__,
2528                      trigger.getTagType());
2529                return INVALID_OPERATION;
2530        }
2531
2532        if (res != OK) {
2533            ALOGE("%s: Failed to update request metadata with trigger tag %s"
2534                  ", value %d", __FUNCTION__, trigger.getTagName(),
2535                  trigger.entryValue);
2536            return res;
2537        }
2538
2539        ALOGV("%s: Mixed in trigger %s, value %d", __FUNCTION__,
2540              trigger.getTagName(),
2541              trigger.entryValue);
2542    }
2543
2544    mTriggerMap.clear();
2545
2546    return count;
2547}
2548
2549status_t Camera3Device::RequestThread::removeTriggers(
2550        const sp<CaptureRequest> &request) {
2551    Mutex::Autolock al(mTriggerMutex);
2552
2553    CameraMetadata &metadata = request->mSettings;
2554
2555    /**
2556     * Replace all old entries with their old values.
2557     */
2558    for (size_t i = 0; i < mTriggerReplacedMap.size(); ++i) {
2559        RequestTrigger trigger = mTriggerReplacedMap.valueAt(i);
2560
2561        status_t res;
2562
2563        uint32_t tag = trigger.metadataTag;
2564        switch (trigger.getTagType()) {
2565            case TYPE_BYTE: {
2566                uint8_t entryValue = static_cast<uint8_t>(trigger.entryValue);
2567                res = metadata.update(tag,
2568                                      &entryValue,
2569                                      /*count*/1);
2570                break;
2571            }
2572            case TYPE_INT32:
2573                res = metadata.update(tag,
2574                                      &trigger.entryValue,
2575                                      /*count*/1);
2576                break;
2577            default:
2578                ALOGE("%s: Type not supported: 0x%x",
2579                      __FUNCTION__,
2580                      trigger.getTagType());
2581                return INVALID_OPERATION;
2582        }
2583
2584        if (res != OK) {
2585            ALOGE("%s: Failed to restore request metadata with trigger tag %s"
2586                  ", trigger value %d", __FUNCTION__,
2587                  trigger.getTagName(), trigger.entryValue);
2588            return res;
2589        }
2590    }
2591    mTriggerReplacedMap.clear();
2592
2593    /**
2594     * Remove all new entries.
2595     */
2596    for (size_t i = 0; i < mTriggerRemovedMap.size(); ++i) {
2597        RequestTrigger trigger = mTriggerRemovedMap.valueAt(i);
2598        status_t res = metadata.erase(trigger.metadataTag);
2599
2600        if (res != OK) {
2601            ALOGE("%s: Failed to erase metadata with trigger tag %s"
2602                  ", trigger value %d", __FUNCTION__,
2603                  trigger.getTagName(), trigger.entryValue);
2604            return res;
2605        }
2606    }
2607    mTriggerRemovedMap.clear();
2608
2609    return OK;
2610}
2611
2612status_t Camera3Device::RequestThread::addDummyTriggerIds(
2613        const sp<CaptureRequest> &request) {
2614    // Trigger ID 0 has special meaning in the HAL2 spec, so avoid it here
2615    static const int32_t dummyTriggerId = 1;
2616    status_t res;
2617
2618    CameraMetadata &metadata = request->mSettings;
2619
2620    // If AF trigger is active, insert a dummy AF trigger ID if none already
2621    // exists
2622    camera_metadata_entry afTrigger = metadata.find(ANDROID_CONTROL_AF_TRIGGER);
2623    camera_metadata_entry afId = metadata.find(ANDROID_CONTROL_AF_TRIGGER_ID);
2624    if (afTrigger.count > 0 &&
2625            afTrigger.data.u8[0] != ANDROID_CONTROL_AF_TRIGGER_IDLE &&
2626            afId.count == 0) {
2627        res = metadata.update(ANDROID_CONTROL_AF_TRIGGER_ID, &dummyTriggerId, 1);
2628        if (res != OK) return res;
2629    }
2630
2631    // If AE precapture trigger is active, insert a dummy precapture trigger ID
2632    // if none already exists
2633    camera_metadata_entry pcTrigger =
2634            metadata.find(ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER);
2635    camera_metadata_entry pcId = metadata.find(ANDROID_CONTROL_AE_PRECAPTURE_ID);
2636    if (pcTrigger.count > 0 &&
2637            pcTrigger.data.u8[0] != ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_IDLE &&
2638            pcId.count == 0) {
2639        res = metadata.update(ANDROID_CONTROL_AE_PRECAPTURE_ID,
2640                &dummyTriggerId, 1);
2641        if (res != OK) return res;
2642    }
2643
2644    return OK;
2645}
2646
2647
2648/**
2649 * Static callback forwarding methods from HAL to instance
2650 */
2651
2652void Camera3Device::sProcessCaptureResult(const camera3_callback_ops *cb,
2653        const camera3_capture_result *result) {
2654    Camera3Device *d =
2655            const_cast<Camera3Device*>(static_cast<const Camera3Device*>(cb));
2656    d->processCaptureResult(result);
2657}
2658
2659void Camera3Device::sNotify(const camera3_callback_ops *cb,
2660        const camera3_notify_msg *msg) {
2661    Camera3Device *d =
2662            const_cast<Camera3Device*>(static_cast<const Camera3Device*>(cb));
2663    d->notify(msg);
2664}
2665
2666}; // namespace android
2667