Camera3Device.cpp revision d46a6b9fd8b2a4f9098757384711e2cd03a91651 
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 <inttypes.h>
41
42#include <utils/Log.h>
43#include <utils/Trace.h>
44#include <utils/Timers.h>
45
46#include "utils/CameraTraces.h"
47#include "device3/Camera3Device.h"
48#include "device3/Camera3OutputStream.h"
49#include "device3/Camera3InputStream.h"
50#include "device3/Camera3ZslStream.h"
51#include "device3/Camera3DummyStream.h"
52#include "CameraService.h"
53
54using namespace android::camera3;
55
56namespace android {
57
58Camera3Device::Camera3Device(int id):
59        mId(id),
60        mHal3Device(NULL),
61        mStatus(STATUS_UNINITIALIZED),
62        mUsePartialResult(false),
63        mNumPartialResults(1),
64        mNextResultFrameNumber(0),
65        mNextReprocessResultFrameNumber(0),
66        mNextShutterFrameNumber(0),
67        mListener(NULL)
68{
69    ATRACE_CALL();
70    camera3_callback_ops::notify = &sNotify;
71    camera3_callback_ops::process_capture_result = &sProcessCaptureResult;
72    ALOGV("%s: Created device for camera %d", __FUNCTION__, id);
73}
74
75Camera3Device::~Camera3Device()
76{
77    ATRACE_CALL();
78    ALOGV("%s: Tearing down for camera id %d", __FUNCTION__, mId);
79    disconnect();
80}
81
82int Camera3Device::getId() const {
83    return mId;
84}
85
86/**
87 * CameraDeviceBase interface
88 */
89
90status_t Camera3Device::initialize(CameraModule *module)
91{
92    ATRACE_CALL();
93    Mutex::Autolock il(mInterfaceLock);
94    Mutex::Autolock l(mLock);
95
96    ALOGV("%s: Initializing device for camera %d", __FUNCTION__, mId);
97    if (mStatus != STATUS_UNINITIALIZED) {
98        CLOGE("Already initialized!");
99        return INVALID_OPERATION;
100    }
101
102    /** Open HAL device */
103
104    status_t res;
105    String8 deviceName = String8::format("%d", mId);
106
107    camera3_device_t *device;
108
109    ATRACE_BEGIN("camera3->open");
110    res = module->open(deviceName.string(),
111            reinterpret_cast<hw_device_t**>(&device));
112    ATRACE_END();
113
114    if (res != OK) {
115        SET_ERR_L("Could not open camera: %s (%d)", strerror(-res), res);
116        return res;
117    }
118
119    /** Cross-check device version */
120    if (device->common.version < CAMERA_DEVICE_API_VERSION_3_0) {
121        SET_ERR_L("Could not open camera: "
122                "Camera device should be at least %x, reports %x instead",
123                CAMERA_DEVICE_API_VERSION_3_0,
124                device->common.version);
125        device->common.close(&device->common);
126        return BAD_VALUE;
127    }
128
129    camera_info info;
130    res = CameraService::filterGetInfoErrorCode(module->getCameraInfo(
131        mId, &info));
132    if (res != OK) return res;
133
134    if (info.device_version != device->common.version) {
135        SET_ERR_L("HAL reporting mismatched camera_info version (%x)"
136                " and device version (%x).",
137                info.device_version, device->common.version);
138        device->common.close(&device->common);
139        return BAD_VALUE;
140    }
141
142    /** Initialize device with callback functions */
143
144    ATRACE_BEGIN("camera3->initialize");
145    res = device->ops->initialize(device, this);
146    ATRACE_END();
147
148    if (res != OK) {
149        SET_ERR_L("Unable to initialize HAL device: %s (%d)",
150                strerror(-res), res);
151        device->common.close(&device->common);
152        return BAD_VALUE;
153    }
154
155    /** Start up status tracker thread */
156    mStatusTracker = new StatusTracker(this);
157    res = mStatusTracker->run(String8::format("C3Dev-%d-Status", mId).string());
158    if (res != OK) {
159        SET_ERR_L("Unable to start status tracking thread: %s (%d)",
160                strerror(-res), res);
161        device->common.close(&device->common);
162        mStatusTracker.clear();
163        return res;
164    }
165
166    /** Start up request queue thread */
167
168    mRequestThread = new RequestThread(this, mStatusTracker, device);
169    res = mRequestThread->run(String8::format("C3Dev-%d-ReqQueue", mId).string());
170    if (res != OK) {
171        SET_ERR_L("Unable to start request queue thread: %s (%d)",
172                strerror(-res), res);
173        device->common.close(&device->common);
174        mRequestThread.clear();
175        return res;
176    }
177
178    mPreparerThread = new PreparerThread();
179
180    /** Everything is good to go */
181
182    mDeviceVersion = device->common.version;
183    mDeviceInfo = info.static_camera_characteristics;
184    mHal3Device = device;
185    mStatus = STATUS_UNCONFIGURED;
186    mNextStreamId = 0;
187    mDummyStreamId = NO_STREAM;
188    mNeedConfig = true;
189    mPauseStateNotify = false;
190
191    // Will the HAL be sending in early partial result metadata?
192    if (mDeviceVersion >= CAMERA_DEVICE_API_VERSION_3_2) {
193        camera_metadata_entry partialResultsCount =
194                mDeviceInfo.find(ANDROID_REQUEST_PARTIAL_RESULT_COUNT);
195        if (partialResultsCount.count > 0) {
196            mNumPartialResults = partialResultsCount.data.i32[0];
197            mUsePartialResult = (mNumPartialResults > 1);
198        }
199    } else {
200        camera_metadata_entry partialResultsQuirk =
201                mDeviceInfo.find(ANDROID_QUIRKS_USE_PARTIAL_RESULT);
202        if (partialResultsQuirk.count > 0 && partialResultsQuirk.data.u8[0] == 1) {
203            mUsePartialResult = true;
204        }
205    }
206
207    camera_metadata_entry configs =
208            mDeviceInfo.find(ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS);
209    for (uint32_t i = 0; i < configs.count; i += 4) {
210        if (configs.data.i32[i] == HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED &&
211                configs.data.i32[i + 3] ==
212                ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_INPUT) {
213            mSupportedOpaqueInputSizes.add(Size(configs.data.i32[i + 1],
214                    configs.data.i32[i + 2]));
215        }
216    }
217
218    return OK;
219}
220
221status_t Camera3Device::disconnect() {
222    ATRACE_CALL();
223    Mutex::Autolock il(mInterfaceLock);
224
225    ALOGV("%s: E", __FUNCTION__);
226
227    status_t res = OK;
228
229    {
230        Mutex::Autolock l(mLock);
231        if (mStatus == STATUS_UNINITIALIZED) return res;
232
233        if (mStatus == STATUS_ACTIVE ||
234                (mStatus == STATUS_ERROR && mRequestThread != NULL)) {
235            res = mRequestThread->clearRepeatingRequests();
236            if (res != OK) {
237                SET_ERR_L("Can't stop streaming");
238                // Continue to close device even in case of error
239            } else {
240                res = waitUntilStateThenRelock(/*active*/ false, kShutdownTimeout);
241                if (res != OK) {
242                    SET_ERR_L("Timeout waiting for HAL to drain");
243                    // Continue to close device even in case of error
244                }
245            }
246        }
247
248        if (mStatus == STATUS_ERROR) {
249            CLOGE("Shutting down in an error state");
250        }
251
252        if (mStatusTracker != NULL) {
253            mStatusTracker->requestExit();
254        }
255
256        if (mRequestThread != NULL) {
257            mRequestThread->requestExit();
258        }
259
260        mOutputStreams.clear();
261        mInputStream.clear();
262    }
263
264    // Joining done without holding mLock, otherwise deadlocks may ensue
265    // as the threads try to access parent state
266    if (mRequestThread != NULL && mStatus != STATUS_ERROR) {
267        // HAL may be in a bad state, so waiting for request thread
268        // (which may be stuck in the HAL processCaptureRequest call)
269        // could be dangerous.
270        mRequestThread->join();
271    }
272
273    if (mStatusTracker != NULL) {
274        mStatusTracker->join();
275    }
276
277    {
278        Mutex::Autolock l(mLock);
279
280        mRequestThread.clear();
281        mStatusTracker.clear();
282
283        if (mHal3Device != NULL) {
284            ATRACE_BEGIN("camera3->close");
285            mHal3Device->common.close(&mHal3Device->common);
286            ATRACE_END();
287            mHal3Device = NULL;
288        }
289
290        mStatus = STATUS_UNINITIALIZED;
291    }
292
293    ALOGV("%s: X", __FUNCTION__);
294    return res;
295}
296
297// For dumping/debugging only -
298// try to acquire a lock a few times, eventually give up to proceed with
299// debug/dump operations
300bool Camera3Device::tryLockSpinRightRound(Mutex& lock) {
301    bool gotLock = false;
302    for (size_t i = 0; i < kDumpLockAttempts; ++i) {
303        if (lock.tryLock() == NO_ERROR) {
304            gotLock = true;
305            break;
306        } else {
307            usleep(kDumpSleepDuration);
308        }
309    }
310    return gotLock;
311}
312
313Camera3Device::Size Camera3Device::getMaxJpegResolution() const {
314    int32_t maxJpegWidth = 0, maxJpegHeight = 0;
315    if (mDeviceVersion >= CAMERA_DEVICE_API_VERSION_3_2) {
316        const int STREAM_CONFIGURATION_SIZE = 4;
317        const int STREAM_FORMAT_OFFSET = 0;
318        const int STREAM_WIDTH_OFFSET = 1;
319        const int STREAM_HEIGHT_OFFSET = 2;
320        const int STREAM_IS_INPUT_OFFSET = 3;
321        camera_metadata_ro_entry_t availableStreamConfigs =
322                mDeviceInfo.find(ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS);
323        if (availableStreamConfigs.count == 0 ||
324                availableStreamConfigs.count % STREAM_CONFIGURATION_SIZE != 0) {
325            return Size(0, 0);
326        }
327
328        // Get max jpeg size (area-wise).
329        for (size_t i=0; i < availableStreamConfigs.count; i+= STREAM_CONFIGURATION_SIZE) {
330            int32_t format = availableStreamConfigs.data.i32[i + STREAM_FORMAT_OFFSET];
331            int32_t width = availableStreamConfigs.data.i32[i + STREAM_WIDTH_OFFSET];
332            int32_t height = availableStreamConfigs.data.i32[i + STREAM_HEIGHT_OFFSET];
333            int32_t isInput = availableStreamConfigs.data.i32[i + STREAM_IS_INPUT_OFFSET];
334            if (isInput == ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT
335                    && format == HAL_PIXEL_FORMAT_BLOB &&
336                    (width * height > maxJpegWidth * maxJpegHeight)) {
337                maxJpegWidth = width;
338                maxJpegHeight = height;
339            }
340        }
341    } else {
342        camera_metadata_ro_entry availableJpegSizes =
343                mDeviceInfo.find(ANDROID_SCALER_AVAILABLE_JPEG_SIZES);
344        if (availableJpegSizes.count == 0 || availableJpegSizes.count % 2 != 0) {
345            return Size(0, 0);
346        }
347
348        // Get max jpeg size (area-wise).
349        for (size_t i = 0; i < availableJpegSizes.count; i += 2) {
350            if ((availableJpegSizes.data.i32[i] * availableJpegSizes.data.i32[i + 1])
351                    > (maxJpegWidth * maxJpegHeight)) {
352                maxJpegWidth = availableJpegSizes.data.i32[i];
353                maxJpegHeight = availableJpegSizes.data.i32[i + 1];
354            }
355        }
356    }
357    return Size(maxJpegWidth, maxJpegHeight);
358}
359
360ssize_t Camera3Device::getJpegBufferSize(uint32_t width, uint32_t height) const {
361    // Get max jpeg size (area-wise).
362    Size maxJpegResolution = getMaxJpegResolution();
363    if (maxJpegResolution.width == 0) {
364        ALOGE("%s: Camera %d: Can't find find valid available jpeg sizes in static metadata!",
365                __FUNCTION__, mId);
366        return BAD_VALUE;
367    }
368
369    // Get max jpeg buffer size
370    ssize_t maxJpegBufferSize = 0;
371    camera_metadata_ro_entry jpegBufMaxSize = mDeviceInfo.find(ANDROID_JPEG_MAX_SIZE);
372    if (jpegBufMaxSize.count == 0) {
373        ALOGE("%s: Camera %d: Can't find maximum JPEG size in static metadata!", __FUNCTION__, mId);
374        return BAD_VALUE;
375    }
376    maxJpegBufferSize = jpegBufMaxSize.data.i32[0];
377    assert(kMinJpegBufferSize < maxJpegBufferSize);
378
379    // Calculate final jpeg buffer size for the given resolution.
380    float scaleFactor = ((float) (width * height)) /
381            (maxJpegResolution.width * maxJpegResolution.height);
382    ssize_t jpegBufferSize = scaleFactor * (maxJpegBufferSize - kMinJpegBufferSize) +
383            kMinJpegBufferSize;
384    if (jpegBufferSize > maxJpegBufferSize) {
385        jpegBufferSize = maxJpegBufferSize;
386    }
387
388    return jpegBufferSize;
389}
390
391status_t Camera3Device::dump(int fd, const Vector<String16> &args) {
392    ATRACE_CALL();
393    (void)args;
394
395    // Try to lock, but continue in case of failure (to avoid blocking in
396    // deadlocks)
397    bool gotInterfaceLock = tryLockSpinRightRound(mInterfaceLock);
398    bool gotLock = tryLockSpinRightRound(mLock);
399
400    ALOGW_IF(!gotInterfaceLock,
401            "Camera %d: %s: Unable to lock interface lock, proceeding anyway",
402            mId, __FUNCTION__);
403    ALOGW_IF(!gotLock,
404            "Camera %d: %s: Unable to lock main lock, proceeding anyway",
405            mId, __FUNCTION__);
406
407    String8 lines;
408
409    const char *status =
410            mStatus == STATUS_ERROR         ? "ERROR" :
411            mStatus == STATUS_UNINITIALIZED ? "UNINITIALIZED" :
412            mStatus == STATUS_UNCONFIGURED  ? "UNCONFIGURED" :
413            mStatus == STATUS_CONFIGURED    ? "CONFIGURED" :
414            mStatus == STATUS_ACTIVE        ? "ACTIVE" :
415            "Unknown";
416
417    lines.appendFormat("    Device status: %s\n", status);
418    if (mStatus == STATUS_ERROR) {
419        lines.appendFormat("    Error cause: %s\n", mErrorCause.string());
420    }
421    lines.appendFormat("    Stream configuration:\n");
422    lines.appendFormat("    Operation mode: %s \n", mIsConstrainedHighSpeedConfiguration ?
423            "CONSTAINED HIGH SPEED VIDEO" : "NORMAL");
424
425    if (mInputStream != NULL) {
426        write(fd, lines.string(), lines.size());
427        mInputStream->dump(fd, args);
428    } else {
429        lines.appendFormat("      No input stream.\n");
430        write(fd, lines.string(), lines.size());
431    }
432    for (size_t i = 0; i < mOutputStreams.size(); i++) {
433        mOutputStreams[i]->dump(fd,args);
434    }
435
436    lines = String8("    In-flight requests:\n");
437    if (mInFlightMap.size() == 0) {
438        lines.append("      None\n");
439    } else {
440        for (size_t i = 0; i < mInFlightMap.size(); i++) {
441            InFlightRequest r = mInFlightMap.valueAt(i);
442            lines.appendFormat("      Frame %d |  Timestamp: %" PRId64 ", metadata"
443                    " arrived: %s, buffers left: %d\n", mInFlightMap.keyAt(i),
444                    r.shutterTimestamp, r.haveResultMetadata ? "true" : "false",
445                    r.numBuffersLeft);
446        }
447    }
448    write(fd, lines.string(), lines.size());
449
450    {
451        lines = String8("    Last request sent:\n");
452        write(fd, lines.string(), lines.size());
453
454        CameraMetadata lastRequest = getLatestRequestLocked();
455        lastRequest.dump(fd, /*verbosity*/2, /*indentation*/6);
456    }
457
458    if (mHal3Device != NULL) {
459        lines = String8("    HAL device dump:\n");
460        write(fd, lines.string(), lines.size());
461        mHal3Device->ops->dump(mHal3Device, fd);
462    }
463
464    if (gotLock) mLock.unlock();
465    if (gotInterfaceLock) mInterfaceLock.unlock();
466
467    return OK;
468}
469
470const CameraMetadata& Camera3Device::info() const {
471    ALOGVV("%s: E", __FUNCTION__);
472    if (CC_UNLIKELY(mStatus == STATUS_UNINITIALIZED ||
473                    mStatus == STATUS_ERROR)) {
474        ALOGW("%s: Access to static info %s!", __FUNCTION__,
475                mStatus == STATUS_ERROR ?
476                "when in error state" : "before init");
477    }
478    return mDeviceInfo;
479}
480
481status_t Camera3Device::checkStatusOkToCaptureLocked() {
482    switch (mStatus) {
483        case STATUS_ERROR:
484            CLOGE("Device has encountered a serious error");
485            return INVALID_OPERATION;
486        case STATUS_UNINITIALIZED:
487            CLOGE("Device not initialized");
488            return INVALID_OPERATION;
489        case STATUS_UNCONFIGURED:
490        case STATUS_CONFIGURED:
491        case STATUS_ACTIVE:
492            // OK
493            break;
494        default:
495            SET_ERR_L("Unexpected status: %d", mStatus);
496            return INVALID_OPERATION;
497    }
498    return OK;
499}
500
501status_t Camera3Device::convertMetadataListToRequestListLocked(
502        const List<const CameraMetadata> &metadataList, RequestList *requestList) {
503    if (requestList == NULL) {
504        CLOGE("requestList cannot be NULL.");
505        return BAD_VALUE;
506    }
507
508    int32_t burstId = 0;
509    for (List<const CameraMetadata>::const_iterator it = metadataList.begin();
510            it != metadataList.end(); ++it) {
511        sp<CaptureRequest> newRequest = setUpRequestLocked(*it);
512        if (newRequest == 0) {
513            CLOGE("Can't create capture request");
514            return BAD_VALUE;
515        }
516
517        // Setup burst Id and request Id
518        newRequest->mResultExtras.burstId = burstId++;
519        if (it->exists(ANDROID_REQUEST_ID)) {
520            if (it->find(ANDROID_REQUEST_ID).count == 0) {
521                CLOGE("RequestID entry exists; but must not be empty in metadata");
522                return BAD_VALUE;
523            }
524            newRequest->mResultExtras.requestId = it->find(ANDROID_REQUEST_ID).data.i32[0];
525        } else {
526            CLOGE("RequestID does not exist in metadata");
527            return BAD_VALUE;
528        }
529
530        requestList->push_back(newRequest);
531
532        ALOGV("%s: requestId = %" PRId32, __FUNCTION__, newRequest->mResultExtras.requestId);
533    }
534    return OK;
535}
536
537status_t Camera3Device::capture(CameraMetadata &request, int64_t* /*lastFrameNumber*/) {
538    ATRACE_CALL();
539
540    List<const CameraMetadata> requests;
541    requests.push_back(request);
542    return captureList(requests, /*lastFrameNumber*/NULL);
543}
544
545status_t Camera3Device::submitRequestsHelper(
546        const List<const CameraMetadata> &requests, bool repeating,
547        /*out*/
548        int64_t *lastFrameNumber) {
549    ATRACE_CALL();
550    Mutex::Autolock il(mInterfaceLock);
551    Mutex::Autolock l(mLock);
552
553    status_t res = checkStatusOkToCaptureLocked();
554    if (res != OK) {
555        // error logged by previous call
556        return res;
557    }
558
559    RequestList requestList;
560
561    res = convertMetadataListToRequestListLocked(requests, /*out*/&requestList);
562    if (res != OK) {
563        // error logged by previous call
564        return res;
565    }
566
567    if (repeating) {
568        res = mRequestThread->setRepeatingRequests(requestList, lastFrameNumber);
569    } else {
570        res = mRequestThread->queueRequestList(requestList, lastFrameNumber);
571    }
572
573    if (res == OK) {
574        waitUntilStateThenRelock(/*active*/true, kActiveTimeout);
575        if (res != OK) {
576            SET_ERR_L("Can't transition to active in %f seconds!",
577                    kActiveTimeout/1e9);
578        }
579        ALOGV("Camera %d: Capture request %" PRId32 " enqueued", mId,
580              (*(requestList.begin()))->mResultExtras.requestId);
581    } else {
582        CLOGE("Cannot queue request. Impossible.");
583        return BAD_VALUE;
584    }
585
586    return res;
587}
588
589status_t Camera3Device::captureList(const List<const CameraMetadata> &requests,
590                                    int64_t *lastFrameNumber) {
591    ATRACE_CALL();
592
593    return submitRequestsHelper(requests, /*repeating*/false, lastFrameNumber);
594}
595
596status_t Camera3Device::setStreamingRequest(const CameraMetadata &request,
597                                            int64_t* /*lastFrameNumber*/) {
598    ATRACE_CALL();
599
600    List<const CameraMetadata> requests;
601    requests.push_back(request);
602    return setStreamingRequestList(requests, /*lastFrameNumber*/NULL);
603}
604
605status_t Camera3Device::setStreamingRequestList(const List<const CameraMetadata> &requests,
606                                                int64_t *lastFrameNumber) {
607    ATRACE_CALL();
608
609    return submitRequestsHelper(requests, /*repeating*/true, lastFrameNumber);
610}
611
612sp<Camera3Device::CaptureRequest> Camera3Device::setUpRequestLocked(
613        const CameraMetadata &request) {
614    status_t res;
615
616    if (mStatus == STATUS_UNCONFIGURED || mNeedConfig) {
617        res = configureStreamsLocked();
618        // Stream configuration failed due to unsupported configuration.
619        // Device back to unconfigured state. Client might try other configuraitons
620        if (res == BAD_VALUE && mStatus == STATUS_UNCONFIGURED) {
621            CLOGE("No streams configured");
622            return NULL;
623        }
624        // Stream configuration failed for other reason. Fatal.
625        if (res != OK) {
626            SET_ERR_L("Can't set up streams: %s (%d)", strerror(-res), res);
627            return NULL;
628        }
629        // Stream configuration successfully configure to empty stream configuration.
630        if (mStatus == STATUS_UNCONFIGURED) {
631            CLOGE("No streams configured");
632            return NULL;
633        }
634    }
635
636    sp<CaptureRequest> newRequest = createCaptureRequest(request);
637    return newRequest;
638}
639
640status_t Camera3Device::clearStreamingRequest(int64_t *lastFrameNumber) {
641    ATRACE_CALL();
642    Mutex::Autolock il(mInterfaceLock);
643    Mutex::Autolock l(mLock);
644
645    switch (mStatus) {
646        case STATUS_ERROR:
647            CLOGE("Device has encountered a serious error");
648            return INVALID_OPERATION;
649        case STATUS_UNINITIALIZED:
650            CLOGE("Device not initialized");
651            return INVALID_OPERATION;
652        case STATUS_UNCONFIGURED:
653        case STATUS_CONFIGURED:
654        case STATUS_ACTIVE:
655            // OK
656            break;
657        default:
658            SET_ERR_L("Unexpected status: %d", mStatus);
659            return INVALID_OPERATION;
660    }
661    ALOGV("Camera %d: Clearing repeating request", mId);
662
663    return mRequestThread->clearRepeatingRequests(lastFrameNumber);
664}
665
666status_t Camera3Device::waitUntilRequestReceived(int32_t requestId, nsecs_t timeout) {
667    ATRACE_CALL();
668    Mutex::Autolock il(mInterfaceLock);
669
670    return mRequestThread->waitUntilRequestProcessed(requestId, timeout);
671}
672
673status_t Camera3Device::createInputStream(
674        uint32_t width, uint32_t height, int format, int *id) {
675    ATRACE_CALL();
676    Mutex::Autolock il(mInterfaceLock);
677    Mutex::Autolock l(mLock);
678    ALOGV("Camera %d: Creating new input stream %d: %d x %d, format %d",
679            mId, mNextStreamId, width, height, format);
680
681    status_t res;
682    bool wasActive = false;
683
684    switch (mStatus) {
685        case STATUS_ERROR:
686            ALOGE("%s: Device has encountered a serious error", __FUNCTION__);
687            return INVALID_OPERATION;
688        case STATUS_UNINITIALIZED:
689            ALOGE("%s: Device not initialized", __FUNCTION__);
690            return INVALID_OPERATION;
691        case STATUS_UNCONFIGURED:
692        case STATUS_CONFIGURED:
693            // OK
694            break;
695        case STATUS_ACTIVE:
696            ALOGV("%s: Stopping activity to reconfigure streams", __FUNCTION__);
697            res = internalPauseAndWaitLocked();
698            if (res != OK) {
699                SET_ERR_L("Can't pause captures to reconfigure streams!");
700                return res;
701            }
702            wasActive = true;
703            break;
704        default:
705            SET_ERR_L("%s: Unexpected status: %d", mStatus);
706            return INVALID_OPERATION;
707    }
708    assert(mStatus != STATUS_ACTIVE);
709
710    if (mInputStream != 0) {
711        ALOGE("%s: Cannot create more than 1 input stream", __FUNCTION__);
712        return INVALID_OPERATION;
713    }
714
715    sp<Camera3InputStream> newStream = new Camera3InputStream(mNextStreamId,
716                width, height, format);
717    newStream->setStatusTracker(mStatusTracker);
718
719    mInputStream = newStream;
720
721    *id = mNextStreamId++;
722
723    // Continue captures if active at start
724    if (wasActive) {
725        ALOGV("%s: Restarting activity to reconfigure streams", __FUNCTION__);
726        res = configureStreamsLocked();
727        if (res != OK) {
728            ALOGE("%s: Can't reconfigure device for new stream %d: %s (%d)",
729                    __FUNCTION__, mNextStreamId, strerror(-res), res);
730            return res;
731        }
732        internalResumeLocked();
733    }
734
735    ALOGV("Camera %d: Created input stream", mId);
736    return OK;
737}
738
739
740status_t Camera3Device::createZslStream(
741            uint32_t width, uint32_t height,
742            int depth,
743            /*out*/
744            int *id,
745            sp<Camera3ZslStream>* zslStream) {
746    ATRACE_CALL();
747    Mutex::Autolock il(mInterfaceLock);
748    Mutex::Autolock l(mLock);
749    ALOGV("Camera %d: Creating ZSL stream %d: %d x %d, depth %d",
750            mId, mNextStreamId, width, height, depth);
751
752    status_t res;
753    bool wasActive = false;
754
755    switch (mStatus) {
756        case STATUS_ERROR:
757            ALOGE("%s: Device has encountered a serious error", __FUNCTION__);
758            return INVALID_OPERATION;
759        case STATUS_UNINITIALIZED:
760            ALOGE("%s: Device not initialized", __FUNCTION__);
761            return INVALID_OPERATION;
762        case STATUS_UNCONFIGURED:
763        case STATUS_CONFIGURED:
764            // OK
765            break;
766        case STATUS_ACTIVE:
767            ALOGV("%s: Stopping activity to reconfigure streams", __FUNCTION__);
768            res = internalPauseAndWaitLocked();
769            if (res != OK) {
770                SET_ERR_L("Can't pause captures to reconfigure streams!");
771                return res;
772            }
773            wasActive = true;
774            break;
775        default:
776            SET_ERR_L("Unexpected status: %d", mStatus);
777            return INVALID_OPERATION;
778    }
779    assert(mStatus != STATUS_ACTIVE);
780
781    if (mInputStream != 0) {
782        ALOGE("%s: Cannot create more than 1 input stream", __FUNCTION__);
783        return INVALID_OPERATION;
784    }
785
786    sp<Camera3ZslStream> newStream = new Camera3ZslStream(mNextStreamId,
787                width, height, depth);
788    newStream->setStatusTracker(mStatusTracker);
789
790    res = mOutputStreams.add(mNextStreamId, newStream);
791    if (res < 0) {
792        ALOGE("%s: Can't add new stream to set: %s (%d)",
793                __FUNCTION__, strerror(-res), res);
794        return res;
795    }
796    mInputStream = newStream;
797
798    mNeedConfig = true;
799
800    *id = mNextStreamId++;
801    *zslStream = newStream;
802
803    // Continue captures if active at start
804    if (wasActive) {
805        ALOGV("%s: Restarting activity to reconfigure streams", __FUNCTION__);
806        res = configureStreamsLocked();
807        if (res != OK) {
808            ALOGE("%s: Can't reconfigure device for new stream %d: %s (%d)",
809                    __FUNCTION__, mNextStreamId, strerror(-res), res);
810            return res;
811        }
812        internalResumeLocked();
813    }
814
815    ALOGV("Camera %d: Created ZSL stream", mId);
816    return OK;
817}
818
819status_t Camera3Device::createStream(sp<ANativeWindow> consumer,
820        uint32_t width, uint32_t height, int format, android_dataspace dataSpace,
821        camera3_stream_rotation_t rotation, int *id) {
822    ATRACE_CALL();
823    Mutex::Autolock il(mInterfaceLock);
824    Mutex::Autolock l(mLock);
825    ALOGV("Camera %d: Creating new stream %d: %d x %d, format %d, dataspace %d rotation %d",
826            mId, mNextStreamId, width, height, format, dataSpace, rotation);
827
828    status_t res;
829    bool wasActive = false;
830
831    switch (mStatus) {
832        case STATUS_ERROR:
833            CLOGE("Device has encountered a serious error");
834            return INVALID_OPERATION;
835        case STATUS_UNINITIALIZED:
836            CLOGE("Device not initialized");
837            return INVALID_OPERATION;
838        case STATUS_UNCONFIGURED:
839        case STATUS_CONFIGURED:
840            // OK
841            break;
842        case STATUS_ACTIVE:
843            ALOGV("%s: Stopping activity to reconfigure streams", __FUNCTION__);
844            res = internalPauseAndWaitLocked();
845            if (res != OK) {
846                SET_ERR_L("Can't pause captures to reconfigure streams!");
847                return res;
848            }
849            wasActive = true;
850            break;
851        default:
852            SET_ERR_L("Unexpected status: %d", mStatus);
853            return INVALID_OPERATION;
854    }
855    assert(mStatus != STATUS_ACTIVE);
856
857    sp<Camera3OutputStream> newStream;
858    if (format == HAL_PIXEL_FORMAT_BLOB) {
859        ssize_t jpegBufferSize = getJpegBufferSize(width, height);
860        if (jpegBufferSize <= 0) {
861            SET_ERR_L("Invalid jpeg buffer size %zd", jpegBufferSize);
862            return BAD_VALUE;
863        }
864
865        newStream = new Camera3OutputStream(mNextStreamId, consumer,
866                width, height, jpegBufferSize, format, dataSpace, rotation);
867    } else {
868        newStream = new Camera3OutputStream(mNextStreamId, consumer,
869                width, height, format, dataSpace, rotation);
870    }
871    newStream->setStatusTracker(mStatusTracker);
872
873    res = mOutputStreams.add(mNextStreamId, newStream);
874    if (res < 0) {
875        SET_ERR_L("Can't add new stream to set: %s (%d)", strerror(-res), res);
876        return res;
877    }
878
879    *id = mNextStreamId++;
880    mNeedConfig = true;
881
882    // Continue captures if active at start
883    if (wasActive) {
884        ALOGV("%s: Restarting activity to reconfigure streams", __FUNCTION__);
885        res = configureStreamsLocked();
886        if (res != OK) {
887            CLOGE("Can't reconfigure device for new stream %d: %s (%d)",
888                    mNextStreamId, strerror(-res), res);
889            return res;
890        }
891        internalResumeLocked();
892    }
893    ALOGV("Camera %d: Created new stream", mId);
894    return OK;
895}
896
897status_t Camera3Device::createReprocessStreamFromStream(int outputId, int *id) {
898    ATRACE_CALL();
899    (void)outputId; (void)id;
900
901    CLOGE("Unimplemented");
902    return INVALID_OPERATION;
903}
904
905
906status_t Camera3Device::getStreamInfo(int id,
907        uint32_t *width, uint32_t *height,
908        uint32_t *format, android_dataspace *dataSpace) {
909    ATRACE_CALL();
910    Mutex::Autolock il(mInterfaceLock);
911    Mutex::Autolock l(mLock);
912
913    switch (mStatus) {
914        case STATUS_ERROR:
915            CLOGE("Device has encountered a serious error");
916            return INVALID_OPERATION;
917        case STATUS_UNINITIALIZED:
918            CLOGE("Device not initialized!");
919            return INVALID_OPERATION;
920        case STATUS_UNCONFIGURED:
921        case STATUS_CONFIGURED:
922        case STATUS_ACTIVE:
923            // OK
924            break;
925        default:
926            SET_ERR_L("Unexpected status: %d", mStatus);
927            return INVALID_OPERATION;
928    }
929
930    ssize_t idx = mOutputStreams.indexOfKey(id);
931    if (idx == NAME_NOT_FOUND) {
932        CLOGE("Stream %d is unknown", id);
933        return idx;
934    }
935
936    if (width) *width  = mOutputStreams[idx]->getWidth();
937    if (height) *height = mOutputStreams[idx]->getHeight();
938    if (format) *format = mOutputStreams[idx]->getFormat();
939    if (dataSpace) *dataSpace = mOutputStreams[idx]->getDataSpace();
940    return OK;
941}
942
943status_t Camera3Device::setStreamTransform(int id,
944        int transform) {
945    ATRACE_CALL();
946    Mutex::Autolock il(mInterfaceLock);
947    Mutex::Autolock l(mLock);
948
949    switch (mStatus) {
950        case STATUS_ERROR:
951            CLOGE("Device has encountered a serious error");
952            return INVALID_OPERATION;
953        case STATUS_UNINITIALIZED:
954            CLOGE("Device not initialized");
955            return INVALID_OPERATION;
956        case STATUS_UNCONFIGURED:
957        case STATUS_CONFIGURED:
958        case STATUS_ACTIVE:
959            // OK
960            break;
961        default:
962            SET_ERR_L("Unexpected status: %d", mStatus);
963            return INVALID_OPERATION;
964    }
965
966    ssize_t idx = mOutputStreams.indexOfKey(id);
967    if (idx == NAME_NOT_FOUND) {
968        CLOGE("Stream %d does not exist",
969                id);
970        return BAD_VALUE;
971    }
972
973    return mOutputStreams.editValueAt(idx)->setTransform(transform);
974}
975
976status_t Camera3Device::deleteStream(int id) {
977    ATRACE_CALL();
978    Mutex::Autolock il(mInterfaceLock);
979    Mutex::Autolock l(mLock);
980    status_t res;
981
982    ALOGV("%s: Camera %d: Deleting stream %d", __FUNCTION__, mId, id);
983
984    // CameraDevice semantics require device to already be idle before
985    // deleteStream is called, unlike for createStream.
986    if (mStatus == STATUS_ACTIVE) {
987        ALOGV("%s: Camera %d: Device not idle", __FUNCTION__, mId);
988        return -EBUSY;
989    }
990
991    sp<Camera3StreamInterface> deletedStream;
992    ssize_t outputStreamIdx = mOutputStreams.indexOfKey(id);
993    if (mInputStream != NULL && id == mInputStream->getId()) {
994        deletedStream = mInputStream;
995        mInputStream.clear();
996    } else {
997        if (outputStreamIdx == NAME_NOT_FOUND) {
998            CLOGE("Stream %d does not exist", id);
999            return BAD_VALUE;
1000        }
1001    }
1002
1003    // Delete output stream or the output part of a bi-directional stream.
1004    if (outputStreamIdx != NAME_NOT_FOUND) {
1005        deletedStream = mOutputStreams.editValueAt(outputStreamIdx);
1006        mOutputStreams.removeItem(id);
1007    }
1008
1009    // Free up the stream endpoint so that it can be used by some other stream
1010    res = deletedStream->disconnect();
1011    if (res != OK) {
1012        SET_ERR_L("Can't disconnect deleted stream %d", id);
1013        // fall through since we want to still list the stream as deleted.
1014    }
1015    mDeletedStreams.add(deletedStream);
1016    mNeedConfig = true;
1017
1018    return res;
1019}
1020
1021status_t Camera3Device::deleteReprocessStream(int id) {
1022    ATRACE_CALL();
1023    (void)id;
1024
1025    CLOGE("Unimplemented");
1026    return INVALID_OPERATION;
1027}
1028
1029status_t Camera3Device::configureStreams(bool isConstrainedHighSpeed) {
1030    ATRACE_CALL();
1031    ALOGV("%s: E", __FUNCTION__);
1032
1033    Mutex::Autolock il(mInterfaceLock);
1034    Mutex::Autolock l(mLock);
1035    mIsConstrainedHighSpeedConfiguration = isConstrainedHighSpeed;
1036
1037    return configureStreamsLocked();
1038}
1039
1040status_t Camera3Device::getInputBufferProducer(
1041        sp<IGraphicBufferProducer> *producer) {
1042    Mutex::Autolock il(mInterfaceLock);
1043    Mutex::Autolock l(mLock);
1044
1045    if (producer == NULL) {
1046        return BAD_VALUE;
1047    } else if (mInputStream == NULL) {
1048        return INVALID_OPERATION;
1049    }
1050
1051    return mInputStream->getInputBufferProducer(producer);
1052}
1053
1054status_t Camera3Device::createDefaultRequest(int templateId,
1055        CameraMetadata *request) {
1056    ATRACE_CALL();
1057    ALOGV("%s: for template %d", __FUNCTION__, templateId);
1058    Mutex::Autolock il(mInterfaceLock);
1059    Mutex::Autolock l(mLock);
1060
1061    switch (mStatus) {
1062        case STATUS_ERROR:
1063            CLOGE("Device has encountered a serious error");
1064            return INVALID_OPERATION;
1065        case STATUS_UNINITIALIZED:
1066            CLOGE("Device is not initialized!");
1067            return INVALID_OPERATION;
1068        case STATUS_UNCONFIGURED:
1069        case STATUS_CONFIGURED:
1070        case STATUS_ACTIVE:
1071            // OK
1072            break;
1073        default:
1074            SET_ERR_L("Unexpected status: %d", mStatus);
1075            return INVALID_OPERATION;
1076    }
1077
1078    if (!mRequestTemplateCache[templateId].isEmpty()) {
1079        *request = mRequestTemplateCache[templateId];
1080        return OK;
1081    }
1082
1083    const camera_metadata_t *rawRequest;
1084    ATRACE_BEGIN("camera3->construct_default_request_settings");
1085    rawRequest = mHal3Device->ops->construct_default_request_settings(
1086        mHal3Device, templateId);
1087    ATRACE_END();
1088    if (rawRequest == NULL) {
1089        ALOGI("%s: template %d is not supported on this camera device",
1090              __FUNCTION__, templateId);
1091        return BAD_VALUE;
1092    }
1093    *request = rawRequest;
1094    mRequestTemplateCache[templateId] = rawRequest;
1095
1096    return OK;
1097}
1098
1099status_t Camera3Device::waitUntilDrained() {
1100    ATRACE_CALL();
1101    Mutex::Autolock il(mInterfaceLock);
1102    Mutex::Autolock l(mLock);
1103
1104    return waitUntilDrainedLocked();
1105}
1106
1107status_t Camera3Device::waitUntilDrainedLocked() {
1108    switch (mStatus) {
1109        case STATUS_UNINITIALIZED:
1110        case STATUS_UNCONFIGURED:
1111            ALOGV("%s: Already idle", __FUNCTION__);
1112            return OK;
1113        case STATUS_CONFIGURED:
1114            // To avoid race conditions, check with tracker to be sure
1115        case STATUS_ERROR:
1116        case STATUS_ACTIVE:
1117            // Need to verify shut down
1118            break;
1119        default:
1120            SET_ERR_L("Unexpected status: %d",mStatus);
1121            return INVALID_OPERATION;
1122    }
1123
1124    ALOGV("%s: Camera %d: Waiting until idle", __FUNCTION__, mId);
1125    status_t res = waitUntilStateThenRelock(/*active*/ false, kShutdownTimeout);
1126    if (res != OK) {
1127        SET_ERR_L("Error waiting for HAL to drain: %s (%d)", strerror(-res),
1128                res);
1129    }
1130    return res;
1131}
1132
1133// Pause to reconfigure
1134status_t Camera3Device::internalPauseAndWaitLocked() {
1135    mRequestThread->setPaused(true);
1136    mPauseStateNotify = true;
1137
1138    ALOGV("%s: Camera %d: Internal wait until idle", __FUNCTION__, mId);
1139    status_t res = waitUntilStateThenRelock(/*active*/ false, kShutdownTimeout);
1140    if (res != OK) {
1141        SET_ERR_L("Can't idle device in %f seconds!",
1142                kShutdownTimeout/1e9);
1143    }
1144
1145    return res;
1146}
1147
1148// Resume after internalPauseAndWaitLocked
1149status_t Camera3Device::internalResumeLocked() {
1150    status_t res;
1151
1152    mRequestThread->setPaused(false);
1153
1154    res = waitUntilStateThenRelock(/*active*/ true, kActiveTimeout);
1155    if (res != OK) {
1156        SET_ERR_L("Can't transition to active in %f seconds!",
1157                kActiveTimeout/1e9);
1158    }
1159    mPauseStateNotify = false;
1160    return OK;
1161}
1162
1163status_t Camera3Device::waitUntilStateThenRelock(bool active,
1164        nsecs_t timeout) {
1165    status_t res = OK;
1166    if (active == (mStatus == STATUS_ACTIVE)) {
1167        // Desired state already reached
1168        return res;
1169    }
1170
1171    bool stateSeen = false;
1172    do {
1173        mRecentStatusUpdates.clear();
1174
1175        res = mStatusChanged.waitRelative(mLock, timeout);
1176        if (res != OK) break;
1177
1178        // Check state change history during wait
1179        for (size_t i = 0; i < mRecentStatusUpdates.size(); i++) {
1180            if (active == (mRecentStatusUpdates[i] == STATUS_ACTIVE) ) {
1181                stateSeen = true;
1182                break;
1183            }
1184        }
1185    } while (!stateSeen);
1186
1187    return res;
1188}
1189
1190
1191status_t Camera3Device::setNotifyCallback(NotificationListener *listener) {
1192    ATRACE_CALL();
1193    Mutex::Autolock l(mOutputLock);
1194
1195    if (listener != NULL && mListener != NULL) {
1196        ALOGW("%s: Replacing old callback listener", __FUNCTION__);
1197    }
1198    mListener = listener;
1199    mRequestThread->setNotificationListener(listener);
1200    mPreparerThread->setNotificationListener(listener);
1201
1202    return OK;
1203}
1204
1205bool Camera3Device::willNotify3A() {
1206    return false;
1207}
1208
1209status_t Camera3Device::waitForNextFrame(nsecs_t timeout) {
1210    status_t res;
1211    Mutex::Autolock l(mOutputLock);
1212
1213    while (mResultQueue.empty()) {
1214        res = mResultSignal.waitRelative(mOutputLock, timeout);
1215        if (res == TIMED_OUT) {
1216            return res;
1217        } else if (res != OK) {
1218            ALOGW("%s: Camera %d: No frame in %" PRId64 " ns: %s (%d)",
1219                    __FUNCTION__, mId, timeout, strerror(-res), res);
1220            return res;
1221        }
1222    }
1223    return OK;
1224}
1225
1226status_t Camera3Device::getNextResult(CaptureResult *frame) {
1227    ATRACE_CALL();
1228    Mutex::Autolock l(mOutputLock);
1229
1230    if (mResultQueue.empty()) {
1231        return NOT_ENOUGH_DATA;
1232    }
1233
1234    if (frame == NULL) {
1235        ALOGE("%s: argument cannot be NULL", __FUNCTION__);
1236        return BAD_VALUE;
1237    }
1238
1239    CaptureResult &result = *(mResultQueue.begin());
1240    frame->mResultExtras = result.mResultExtras;
1241    frame->mMetadata.acquire(result.mMetadata);
1242    mResultQueue.erase(mResultQueue.begin());
1243
1244    return OK;
1245}
1246
1247status_t Camera3Device::triggerAutofocus(uint32_t id) {
1248    ATRACE_CALL();
1249    Mutex::Autolock il(mInterfaceLock);
1250
1251    ALOGV("%s: Triggering autofocus, id %d", __FUNCTION__, id);
1252    // Mix-in this trigger into the next request and only the next request.
1253    RequestTrigger trigger[] = {
1254        {
1255            ANDROID_CONTROL_AF_TRIGGER,
1256            ANDROID_CONTROL_AF_TRIGGER_START
1257        },
1258        {
1259            ANDROID_CONTROL_AF_TRIGGER_ID,
1260            static_cast<int32_t>(id)
1261        }
1262    };
1263
1264    return mRequestThread->queueTrigger(trigger,
1265                                        sizeof(trigger)/sizeof(trigger[0]));
1266}
1267
1268status_t Camera3Device::triggerCancelAutofocus(uint32_t id) {
1269    ATRACE_CALL();
1270    Mutex::Autolock il(mInterfaceLock);
1271
1272    ALOGV("%s: Triggering cancel autofocus, id %d", __FUNCTION__, id);
1273    // Mix-in this trigger into the next request and only the next request.
1274    RequestTrigger trigger[] = {
1275        {
1276            ANDROID_CONTROL_AF_TRIGGER,
1277            ANDROID_CONTROL_AF_TRIGGER_CANCEL
1278        },
1279        {
1280            ANDROID_CONTROL_AF_TRIGGER_ID,
1281            static_cast<int32_t>(id)
1282        }
1283    };
1284
1285    return mRequestThread->queueTrigger(trigger,
1286                                        sizeof(trigger)/sizeof(trigger[0]));
1287}
1288
1289status_t Camera3Device::triggerPrecaptureMetering(uint32_t id) {
1290    ATRACE_CALL();
1291    Mutex::Autolock il(mInterfaceLock);
1292
1293    ALOGV("%s: Triggering precapture metering, id %d", __FUNCTION__, id);
1294    // Mix-in this trigger into the next request and only the next request.
1295    RequestTrigger trigger[] = {
1296        {
1297            ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER,
1298            ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_START
1299        },
1300        {
1301            ANDROID_CONTROL_AE_PRECAPTURE_ID,
1302            static_cast<int32_t>(id)
1303        }
1304    };
1305
1306    return mRequestThread->queueTrigger(trigger,
1307                                        sizeof(trigger)/sizeof(trigger[0]));
1308}
1309
1310status_t Camera3Device::pushReprocessBuffer(int reprocessStreamId,
1311        buffer_handle_t *buffer, wp<BufferReleasedListener> listener) {
1312    ATRACE_CALL();
1313    (void)reprocessStreamId; (void)buffer; (void)listener;
1314
1315    CLOGE("Unimplemented");
1316    return INVALID_OPERATION;
1317}
1318
1319status_t Camera3Device::flush(int64_t *frameNumber) {
1320    ATRACE_CALL();
1321    ALOGV("%s: Camera %d: Flushing all requests", __FUNCTION__, mId);
1322    Mutex::Autolock il(mInterfaceLock);
1323
1324    NotificationListener* listener;
1325    {
1326        Mutex::Autolock l(mOutputLock);
1327        listener = mListener;
1328    }
1329
1330    {
1331        Mutex::Autolock l(mLock);
1332        mRequestThread->clear(listener, /*out*/frameNumber);
1333    }
1334
1335    status_t res;
1336    if (mHal3Device->common.version >= CAMERA_DEVICE_API_VERSION_3_1) {
1337        res = mHal3Device->ops->flush(mHal3Device);
1338    } else {
1339        Mutex::Autolock l(mLock);
1340        res = waitUntilDrainedLocked();
1341    }
1342
1343    return res;
1344}
1345
1346status_t Camera3Device::prepare(int streamId) {
1347    ATRACE_CALL();
1348    ALOGV("%s: Camera %d: Preparing stream %d", __FUNCTION__, mId, streamId);
1349    Mutex::Autolock il(mInterfaceLock);
1350    Mutex::Autolock l(mLock);
1351
1352    sp<Camera3StreamInterface> stream;
1353    ssize_t outputStreamIdx = mOutputStreams.indexOfKey(streamId);
1354    if (outputStreamIdx == NAME_NOT_FOUND) {
1355        CLOGE("Stream %d does not exist", streamId);
1356        return BAD_VALUE;
1357    }
1358
1359    stream = mOutputStreams.editValueAt(outputStreamIdx);
1360
1361    if (stream->isUnpreparable() || stream->hasOutstandingBuffers() ) {
1362        CLOGE("Stream %d has already been a request target", streamId);
1363        return BAD_VALUE;
1364    }
1365
1366    if (mRequestThread->isStreamPending(stream)) {
1367        CLOGE("Stream %d is already a target in a pending request", streamId);
1368        return BAD_VALUE;
1369    }
1370
1371    return mPreparerThread->prepare(stream);
1372}
1373
1374uint32_t Camera3Device::getDeviceVersion() {
1375    ATRACE_CALL();
1376    Mutex::Autolock il(mInterfaceLock);
1377    return mDeviceVersion;
1378}
1379
1380/**
1381 * Methods called by subclasses
1382 */
1383
1384void Camera3Device::notifyStatus(bool idle) {
1385    {
1386        // Need mLock to safely update state and synchronize to current
1387        // state of methods in flight.
1388        Mutex::Autolock l(mLock);
1389        // We can get various system-idle notices from the status tracker
1390        // while starting up. Only care about them if we've actually sent
1391        // in some requests recently.
1392        if (mStatus != STATUS_ACTIVE && mStatus != STATUS_CONFIGURED) {
1393            return;
1394        }
1395        ALOGV("%s: Camera %d: Now %s", __FUNCTION__, mId,
1396                idle ? "idle" : "active");
1397        mStatus = idle ? STATUS_CONFIGURED : STATUS_ACTIVE;
1398        mRecentStatusUpdates.add(mStatus);
1399        mStatusChanged.signal();
1400
1401        // Skip notifying listener if we're doing some user-transparent
1402        // state changes
1403        if (mPauseStateNotify) return;
1404    }
1405    NotificationListener *listener;
1406    {
1407        Mutex::Autolock l(mOutputLock);
1408        listener = mListener;
1409    }
1410    if (idle && listener != NULL) {
1411        listener->notifyIdle();
1412    }
1413}
1414
1415/**
1416 * Camera3Device private methods
1417 */
1418
1419sp<Camera3Device::CaptureRequest> Camera3Device::createCaptureRequest(
1420        const CameraMetadata &request) {
1421    ATRACE_CALL();
1422    status_t res;
1423
1424    sp<CaptureRequest> newRequest = new CaptureRequest;
1425    newRequest->mSettings = request;
1426
1427    camera_metadata_entry_t inputStreams =
1428            newRequest->mSettings.find(ANDROID_REQUEST_INPUT_STREAMS);
1429    if (inputStreams.count > 0) {
1430        if (mInputStream == NULL ||
1431                mInputStream->getId() != inputStreams.data.i32[0]) {
1432            CLOGE("Request references unknown input stream %d",
1433                    inputStreams.data.u8[0]);
1434            return NULL;
1435        }
1436        // Lazy completion of stream configuration (allocation/registration)
1437        // on first use
1438        if (mInputStream->isConfiguring()) {
1439            res = mInputStream->finishConfiguration(mHal3Device);
1440            if (res != OK) {
1441                SET_ERR_L("Unable to finish configuring input stream %d:"
1442                        " %s (%d)",
1443                        mInputStream->getId(), strerror(-res), res);
1444                return NULL;
1445            }
1446        }
1447        // Check if stream is being prepared
1448        if (mInputStream->isPreparing()) {
1449            CLOGE("Request references an input stream that's being prepared!");
1450            return NULL;
1451        }
1452
1453        newRequest->mInputStream = mInputStream;
1454        newRequest->mSettings.erase(ANDROID_REQUEST_INPUT_STREAMS);
1455    }
1456
1457    camera_metadata_entry_t streams =
1458            newRequest->mSettings.find(ANDROID_REQUEST_OUTPUT_STREAMS);
1459    if (streams.count == 0) {
1460        CLOGE("Zero output streams specified!");
1461        return NULL;
1462    }
1463
1464    for (size_t i = 0; i < streams.count; i++) {
1465        int idx = mOutputStreams.indexOfKey(streams.data.i32[i]);
1466        if (idx == NAME_NOT_FOUND) {
1467            CLOGE("Request references unknown stream %d",
1468                    streams.data.u8[i]);
1469            return NULL;
1470        }
1471        sp<Camera3OutputStreamInterface> stream =
1472                mOutputStreams.editValueAt(idx);
1473
1474        // Lazy completion of stream configuration (allocation/registration)
1475        // on first use
1476        if (stream->isConfiguring()) {
1477            res = stream->finishConfiguration(mHal3Device);
1478            if (res != OK) {
1479                SET_ERR_L("Unable to finish configuring stream %d: %s (%d)",
1480                        stream->getId(), strerror(-res), res);
1481                return NULL;
1482            }
1483        }
1484        // Check if stream is being prepared
1485        if (stream->isPreparing()) {
1486            CLOGE("Request references an output stream that's being prepared!");
1487            return NULL;
1488        }
1489
1490        newRequest->mOutputStreams.push(stream);
1491    }
1492    newRequest->mSettings.erase(ANDROID_REQUEST_OUTPUT_STREAMS);
1493
1494    return newRequest;
1495}
1496
1497bool Camera3Device::isOpaqueInputSizeSupported(uint32_t width, uint32_t height) {
1498    for (uint32_t i = 0; i < mSupportedOpaqueInputSizes.size(); i++) {
1499        Size size = mSupportedOpaqueInputSizes[i];
1500        if (size.width == width && size.height == height) {
1501            return true;
1502        }
1503    }
1504
1505    return false;
1506}
1507
1508status_t Camera3Device::configureStreamsLocked() {
1509    ATRACE_CALL();
1510    status_t res;
1511
1512    if (mStatus != STATUS_UNCONFIGURED && mStatus != STATUS_CONFIGURED) {
1513        CLOGE("Not idle");
1514        return INVALID_OPERATION;
1515    }
1516
1517    if (!mNeedConfig) {
1518        ALOGV("%s: Skipping config, no stream changes", __FUNCTION__);
1519        return OK;
1520    }
1521
1522    // Workaround for device HALv3.2 or older spec bug - zero streams requires
1523    // adding a dummy stream instead.
1524    // TODO: Bug: 17321404 for fixing the HAL spec and removing this workaround.
1525    if (mOutputStreams.size() == 0) {
1526        addDummyStreamLocked();
1527    } else {
1528        tryRemoveDummyStreamLocked();
1529    }
1530
1531    // Start configuring the streams
1532    ALOGV("%s: Camera %d: Starting stream configuration", __FUNCTION__, mId);
1533
1534    camera3_stream_configuration config;
1535    config.operation_mode = mIsConstrainedHighSpeedConfiguration ?
1536            CAMERA3_STREAM_CONFIGURATION_CONSTRAINED_HIGH_SPEED_MODE :
1537            CAMERA3_STREAM_CONFIGURATION_NORMAL_MODE;
1538    config.num_streams = (mInputStream != NULL) + mOutputStreams.size();
1539
1540    Vector<camera3_stream_t*> streams;
1541    streams.setCapacity(config.num_streams);
1542
1543    if (mInputStream != NULL) {
1544        camera3_stream_t *inputStream;
1545        inputStream = mInputStream->startConfiguration();
1546        if (inputStream == NULL) {
1547            SET_ERR_L("Can't start input stream configuration");
1548            return INVALID_OPERATION;
1549        }
1550        streams.add(inputStream);
1551    }
1552
1553    for (size_t i = 0; i < mOutputStreams.size(); i++) {
1554
1555        // Don't configure bidi streams twice, nor add them twice to the list
1556        if (mOutputStreams[i].get() ==
1557            static_cast<Camera3StreamInterface*>(mInputStream.get())) {
1558
1559            config.num_streams--;
1560            continue;
1561        }
1562
1563        camera3_stream_t *outputStream;
1564        outputStream = mOutputStreams.editValueAt(i)->startConfiguration();
1565        if (outputStream == NULL) {
1566            SET_ERR_L("Can't start output stream configuration");
1567            return INVALID_OPERATION;
1568        }
1569        streams.add(outputStream);
1570    }
1571
1572    config.streams = streams.editArray();
1573
1574    // Do the HAL configuration; will potentially touch stream
1575    // max_buffers, usage, priv fields.
1576    ATRACE_BEGIN("camera3->configure_streams");
1577    res = mHal3Device->ops->configure_streams(mHal3Device, &config);
1578    ATRACE_END();
1579
1580    if (res == BAD_VALUE) {
1581        // HAL rejected this set of streams as unsupported, clean up config
1582        // attempt and return to unconfigured state
1583        if (mInputStream != NULL && mInputStream->isConfiguring()) {
1584            res = mInputStream->cancelConfiguration();
1585            if (res != OK) {
1586                SET_ERR_L("Can't cancel configuring input stream %d: %s (%d)",
1587                        mInputStream->getId(), strerror(-res), res);
1588                return res;
1589            }
1590        }
1591
1592        for (size_t i = 0; i < mOutputStreams.size(); i++) {
1593            sp<Camera3OutputStreamInterface> outputStream =
1594                    mOutputStreams.editValueAt(i);
1595            if (outputStream->isConfiguring()) {
1596                res = outputStream->cancelConfiguration();
1597                if (res != OK) {
1598                    SET_ERR_L(
1599                        "Can't cancel configuring output stream %d: %s (%d)",
1600                        outputStream->getId(), strerror(-res), res);
1601                    return res;
1602                }
1603            }
1604        }
1605
1606        // Return state to that at start of call, so that future configures
1607        // properly clean things up
1608        mStatus = STATUS_UNCONFIGURED;
1609        mNeedConfig = true;
1610
1611        ALOGV("%s: Camera %d: Stream configuration failed", __FUNCTION__, mId);
1612        return BAD_VALUE;
1613    } else if (res != OK) {
1614        // Some other kind of error from configure_streams - this is not
1615        // expected
1616        SET_ERR_L("Unable to configure streams with HAL: %s (%d)",
1617                strerror(-res), res);
1618        return res;
1619    }
1620
1621    // Finish all stream configuration immediately.
1622    // TODO: Try to relax this later back to lazy completion, which should be
1623    // faster
1624
1625    if (mInputStream != NULL && mInputStream->isConfiguring()) {
1626        res = mInputStream->finishConfiguration(mHal3Device);
1627        if (res != OK) {
1628            SET_ERR_L("Can't finish configuring input stream %d: %s (%d)",
1629                    mInputStream->getId(), strerror(-res), res);
1630            return res;
1631        }
1632    }
1633
1634    for (size_t i = 0; i < mOutputStreams.size(); i++) {
1635        sp<Camera3OutputStreamInterface> outputStream =
1636            mOutputStreams.editValueAt(i);
1637        if (outputStream->isConfiguring()) {
1638            res = outputStream->finishConfiguration(mHal3Device);
1639            if (res != OK) {
1640                SET_ERR_L("Can't finish configuring output stream %d: %s (%d)",
1641                        outputStream->getId(), strerror(-res), res);
1642                return res;
1643            }
1644        }
1645    }
1646
1647    // Request thread needs to know to avoid using repeat-last-settings protocol
1648    // across configure_streams() calls
1649    mRequestThread->configurationComplete();
1650
1651    // Update device state
1652
1653    mNeedConfig = false;
1654
1655    if (mDummyStreamId == NO_STREAM) {
1656        mStatus = STATUS_CONFIGURED;
1657    } else {
1658        mStatus = STATUS_UNCONFIGURED;
1659    }
1660
1661    ALOGV("%s: Camera %d: Stream configuration complete", __FUNCTION__, mId);
1662
1663    // tear down the deleted streams after configure streams.
1664    mDeletedStreams.clear();
1665
1666    return OK;
1667}
1668
1669status_t Camera3Device::addDummyStreamLocked() {
1670    ATRACE_CALL();
1671    status_t res;
1672
1673    if (mDummyStreamId != NO_STREAM) {
1674        // Should never be adding a second dummy stream when one is already
1675        // active
1676        SET_ERR_L("%s: Camera %d: A dummy stream already exists!",
1677                __FUNCTION__, mId);
1678        return INVALID_OPERATION;
1679    }
1680
1681    ALOGV("%s: Camera %d: Adding a dummy stream", __FUNCTION__, mId);
1682
1683    sp<Camera3OutputStreamInterface> dummyStream =
1684            new Camera3DummyStream(mNextStreamId);
1685
1686    res = mOutputStreams.add(mNextStreamId, dummyStream);
1687    if (res < 0) {
1688        SET_ERR_L("Can't add dummy stream to set: %s (%d)", strerror(-res), res);
1689        return res;
1690    }
1691
1692    mDummyStreamId = mNextStreamId;
1693    mNextStreamId++;
1694
1695    return OK;
1696}
1697
1698status_t Camera3Device::tryRemoveDummyStreamLocked() {
1699    ATRACE_CALL();
1700    status_t res;
1701
1702    if (mDummyStreamId == NO_STREAM) return OK;
1703    if (mOutputStreams.size() == 1) return OK;
1704
1705    ALOGV("%s: Camera %d: Removing the dummy stream", __FUNCTION__, mId);
1706
1707    // Ok, have a dummy stream and there's at least one other output stream,
1708    // so remove the dummy
1709
1710    sp<Camera3StreamInterface> deletedStream;
1711    ssize_t outputStreamIdx = mOutputStreams.indexOfKey(mDummyStreamId);
1712    if (outputStreamIdx == NAME_NOT_FOUND) {
1713        SET_ERR_L("Dummy stream %d does not appear to exist", mDummyStreamId);
1714        return INVALID_OPERATION;
1715    }
1716
1717    deletedStream = mOutputStreams.editValueAt(outputStreamIdx);
1718    mOutputStreams.removeItemsAt(outputStreamIdx);
1719
1720    // Free up the stream endpoint so that it can be used by some other stream
1721    res = deletedStream->disconnect();
1722    if (res != OK) {
1723        SET_ERR_L("Can't disconnect deleted dummy stream %d", mDummyStreamId);
1724        // fall through since we want to still list the stream as deleted.
1725    }
1726    mDeletedStreams.add(deletedStream);
1727    mDummyStreamId = NO_STREAM;
1728
1729    return res;
1730}
1731
1732void Camera3Device::setErrorState(const char *fmt, ...) {
1733    Mutex::Autolock l(mLock);
1734    va_list args;
1735    va_start(args, fmt);
1736
1737    setErrorStateLockedV(fmt, args);
1738
1739    va_end(args);
1740}
1741
1742void Camera3Device::setErrorStateV(const char *fmt, va_list args) {
1743    Mutex::Autolock l(mLock);
1744    setErrorStateLockedV(fmt, args);
1745}
1746
1747void Camera3Device::setErrorStateLocked(const char *fmt, ...) {
1748    va_list args;
1749    va_start(args, fmt);
1750
1751    setErrorStateLockedV(fmt, args);
1752
1753    va_end(args);
1754}
1755
1756void Camera3Device::setErrorStateLockedV(const char *fmt, va_list args) {
1757    // Print out all error messages to log
1758    String8 errorCause = String8::formatV(fmt, args);
1759    ALOGE("Camera %d: %s", mId, errorCause.string());
1760
1761    // But only do error state transition steps for the first error
1762    if (mStatus == STATUS_ERROR || mStatus == STATUS_UNINITIALIZED) return;
1763
1764    mErrorCause = errorCause;
1765
1766    mRequestThread->setPaused(true);
1767    mStatus = STATUS_ERROR;
1768
1769    // Notify upstream about a device error
1770    if (mListener != NULL) {
1771        mListener->notifyError(ICameraDeviceCallbacks::ERROR_CAMERA_DEVICE,
1772                CaptureResultExtras());
1773    }
1774
1775    // Save stack trace. View by dumping it later.
1776    CameraTraces::saveTrace();
1777    // TODO: consider adding errorCause and client pid/procname
1778}
1779
1780/**
1781 * In-flight request management
1782 */
1783
1784status_t Camera3Device::registerInFlight(uint32_t frameNumber,
1785        int32_t numBuffers, CaptureResultExtras resultExtras, bool hasInput) {
1786    ATRACE_CALL();
1787    Mutex::Autolock l(mInFlightLock);
1788
1789    ssize_t res;
1790    res = mInFlightMap.add(frameNumber, InFlightRequest(numBuffers, resultExtras, hasInput));
1791    if (res < 0) return res;
1792
1793    return OK;
1794}
1795
1796/**
1797 * Check if all 3A fields are ready, and send off a partial 3A-only result
1798 * to the output frame queue
1799 */
1800bool Camera3Device::processPartial3AResult(
1801        uint32_t frameNumber,
1802        const CameraMetadata& partial, const CaptureResultExtras& resultExtras) {
1803
1804    // Check if all 3A states are present
1805    // The full list of fields is
1806    //   android.control.afMode
1807    //   android.control.awbMode
1808    //   android.control.aeState
1809    //   android.control.awbState
1810    //   android.control.afState
1811    //   android.control.afTriggerID
1812    //   android.control.aePrecaptureID
1813    // TODO: Add android.control.aeMode
1814
1815    bool gotAllStates = true;
1816
1817    uint8_t afMode;
1818    uint8_t awbMode;
1819    uint8_t aeState;
1820    uint8_t afState;
1821    uint8_t awbState;
1822
1823    gotAllStates &= get3AResult(partial, ANDROID_CONTROL_AF_MODE,
1824        &afMode, frameNumber);
1825
1826    gotAllStates &= get3AResult(partial, ANDROID_CONTROL_AWB_MODE,
1827        &awbMode, frameNumber);
1828
1829    gotAllStates &= get3AResult(partial, ANDROID_CONTROL_AE_STATE,
1830        &aeState, frameNumber);
1831
1832    gotAllStates &= get3AResult(partial, ANDROID_CONTROL_AF_STATE,
1833        &afState, frameNumber);
1834
1835    gotAllStates &= get3AResult(partial, ANDROID_CONTROL_AWB_STATE,
1836        &awbState, frameNumber);
1837
1838    if (!gotAllStates) return false;
1839
1840    ALOGVV("%s: Camera %d: Frame %d, Request ID %d: AF mode %d, AWB mode %d, "
1841        "AF state %d, AE state %d, AWB state %d, "
1842        "AF trigger %d, AE precapture trigger %d",
1843        __FUNCTION__, mId, frameNumber, resultExtras.requestId,
1844        afMode, awbMode,
1845        afState, aeState, awbState,
1846        resultExtras.afTriggerId, resultExtras.precaptureTriggerId);
1847
1848    // Got all states, so construct a minimal result to send
1849    // In addition to the above fields, this means adding in
1850    //   android.request.frameCount
1851    //   android.request.requestId
1852    //   android.quirks.partialResult (for HAL version below HAL3.2)
1853
1854    const size_t kMinimal3AResultEntries = 10;
1855
1856    Mutex::Autolock l(mOutputLock);
1857
1858    CaptureResult captureResult;
1859    captureResult.mResultExtras = resultExtras;
1860    captureResult.mMetadata = CameraMetadata(kMinimal3AResultEntries, /*dataCapacity*/ 0);
1861    // TODO: change this to sp<CaptureResult>. This will need other changes, including,
1862    // but not limited to CameraDeviceBase::getNextResult
1863    CaptureResult& min3AResult =
1864            *mResultQueue.insert(mResultQueue.end(), captureResult);
1865
1866    if (!insert3AResult(min3AResult.mMetadata, ANDROID_REQUEST_FRAME_COUNT,
1867            // TODO: This is problematic casting. Need to fix CameraMetadata.
1868            reinterpret_cast<int32_t*>(&frameNumber), frameNumber)) {
1869        return false;
1870    }
1871
1872    int32_t requestId = resultExtras.requestId;
1873    if (!insert3AResult(min3AResult.mMetadata, ANDROID_REQUEST_ID,
1874            &requestId, frameNumber)) {
1875        return false;
1876    }
1877
1878    if (mDeviceVersion < CAMERA_DEVICE_API_VERSION_3_2) {
1879        static const uint8_t partialResult = ANDROID_QUIRKS_PARTIAL_RESULT_PARTIAL;
1880        if (!insert3AResult(min3AResult.mMetadata, ANDROID_QUIRKS_PARTIAL_RESULT,
1881                &partialResult, frameNumber)) {
1882            return false;
1883        }
1884    }
1885
1886    if (!insert3AResult(min3AResult.mMetadata, ANDROID_CONTROL_AF_MODE,
1887            &afMode, frameNumber)) {
1888        return false;
1889    }
1890
1891    if (!insert3AResult(min3AResult.mMetadata, ANDROID_CONTROL_AWB_MODE,
1892            &awbMode, frameNumber)) {
1893        return false;
1894    }
1895
1896    if (!insert3AResult(min3AResult.mMetadata, ANDROID_CONTROL_AE_STATE,
1897            &aeState, frameNumber)) {
1898        return false;
1899    }
1900
1901    if (!insert3AResult(min3AResult.mMetadata, ANDROID_CONTROL_AF_STATE,
1902            &afState, frameNumber)) {
1903        return false;
1904    }
1905
1906    if (!insert3AResult(min3AResult.mMetadata, ANDROID_CONTROL_AWB_STATE,
1907            &awbState, frameNumber)) {
1908        return false;
1909    }
1910
1911    if (!insert3AResult(min3AResult.mMetadata, ANDROID_CONTROL_AF_TRIGGER_ID,
1912            &resultExtras.afTriggerId, frameNumber)) {
1913        return false;
1914    }
1915
1916    if (!insert3AResult(min3AResult.mMetadata, ANDROID_CONTROL_AE_PRECAPTURE_ID,
1917            &resultExtras.precaptureTriggerId, frameNumber)) {
1918        return false;
1919    }
1920
1921    // We only send the aggregated partial when all 3A related metadata are available
1922    // For both API1 and API2.
1923    // TODO: we probably should pass through all partials to API2 unconditionally.
1924    mResultSignal.signal();
1925
1926    return true;
1927}
1928
1929template<typename T>
1930bool Camera3Device::get3AResult(const CameraMetadata& result, int32_t tag,
1931        T* value, uint32_t frameNumber) {
1932    (void) frameNumber;
1933
1934    camera_metadata_ro_entry_t entry;
1935
1936    entry = result.find(tag);
1937    if (entry.count == 0) {
1938        ALOGVV("%s: Camera %d: Frame %d: No %s provided by HAL!", __FUNCTION__,
1939            mId, frameNumber, get_camera_metadata_tag_name(tag));
1940        return false;
1941    }
1942
1943    if (sizeof(T) == sizeof(uint8_t)) {
1944        *value = entry.data.u8[0];
1945    } else if (sizeof(T) == sizeof(int32_t)) {
1946        *value = entry.data.i32[0];
1947    } else {
1948        ALOGE("%s: Unexpected type", __FUNCTION__);
1949        return false;
1950    }
1951    return true;
1952}
1953
1954template<typename T>
1955bool Camera3Device::insert3AResult(CameraMetadata& result, int32_t tag,
1956        const T* value, uint32_t frameNumber) {
1957    if (result.update(tag, value, 1) != NO_ERROR) {
1958        mResultQueue.erase(--mResultQueue.end(), mResultQueue.end());
1959        SET_ERR("Frame %d: Failed to set %s in partial metadata",
1960                frameNumber, get_camera_metadata_tag_name(tag));
1961        return false;
1962    }
1963    return true;
1964}
1965
1966void Camera3Device::returnOutputBuffers(
1967        const camera3_stream_buffer_t *outputBuffers, size_t numBuffers,
1968        nsecs_t timestamp) {
1969    for (size_t i = 0; i < numBuffers; i++)
1970    {
1971        Camera3Stream *stream = Camera3Stream::cast(outputBuffers[i].stream);
1972        status_t res = stream->returnBuffer(outputBuffers[i], timestamp);
1973        // Note: stream may be deallocated at this point, if this buffer was
1974        // the last reference to it.
1975        if (res != OK) {
1976            ALOGE("Can't return buffer to its stream: %s (%d)",
1977                strerror(-res), res);
1978        }
1979    }
1980}
1981
1982
1983void Camera3Device::removeInFlightRequestIfReadyLocked(int idx) {
1984
1985    const InFlightRequest &request = mInFlightMap.valueAt(idx);
1986    const uint32_t frameNumber = mInFlightMap.keyAt(idx);
1987
1988    nsecs_t sensorTimestamp = request.sensorTimestamp;
1989    nsecs_t shutterTimestamp = request.shutterTimestamp;
1990
1991    // Check if it's okay to remove the request from InFlightMap:
1992    // In the case of a successful request:
1993    //      all input and output buffers, all result metadata, shutter callback
1994    //      arrived.
1995    // In the case of a unsuccessful request:
1996    //      all input and output buffers arrived.
1997    if (request.numBuffersLeft == 0 &&
1998            (request.requestStatus != OK ||
1999            (request.haveResultMetadata && shutterTimestamp != 0))) {
2000        ATRACE_ASYNC_END("frame capture", frameNumber);
2001
2002        // Sanity check - if sensor timestamp matches shutter timestamp
2003        if (request.requestStatus == OK &&
2004                sensorTimestamp != shutterTimestamp) {
2005            SET_ERR("sensor timestamp (%" PRId64
2006                ") for frame %d doesn't match shutter timestamp (%" PRId64 ")",
2007                sensorTimestamp, frameNumber, shutterTimestamp);
2008        }
2009
2010        // for an unsuccessful request, it may have pending output buffers to
2011        // return.
2012        assert(request.requestStatus != OK ||
2013               request.pendingOutputBuffers.size() == 0);
2014        returnOutputBuffers(request.pendingOutputBuffers.array(),
2015            request.pendingOutputBuffers.size(), 0);
2016
2017        mInFlightMap.removeItemsAt(idx, 1);
2018
2019        ALOGVV("%s: removed frame %d from InFlightMap", __FUNCTION__, frameNumber);
2020     }
2021
2022    // Sanity check - if we have too many in-flight frames, something has
2023    // likely gone wrong
2024    if (mInFlightMap.size() > kInFlightWarnLimit) {
2025        CLOGE("In-flight list too large: %zu", mInFlightMap.size());
2026    }
2027}
2028
2029
2030void Camera3Device::sendCaptureResult(CameraMetadata &pendingMetadata,
2031        CaptureResultExtras &resultExtras,
2032        CameraMetadata &collectedPartialResult,
2033        uint32_t frameNumber,
2034        bool reprocess) {
2035    if (pendingMetadata.isEmpty())
2036        return;
2037
2038    Mutex::Autolock l(mOutputLock);
2039
2040    // TODO: need to track errors for tighter bounds on expected frame number
2041    if (reprocess) {
2042        if (frameNumber < mNextReprocessResultFrameNumber) {
2043            SET_ERR("Out-of-order reprocess capture result metadata submitted! "
2044                "(got frame number %d, expecting %d)",
2045                frameNumber, mNextReprocessResultFrameNumber);
2046            return;
2047        }
2048        mNextReprocessResultFrameNumber = frameNumber + 1;
2049    } else {
2050        if (frameNumber < mNextResultFrameNumber) {
2051            SET_ERR("Out-of-order capture result metadata submitted! "
2052                    "(got frame number %d, expecting %d)",
2053                    frameNumber, mNextResultFrameNumber);
2054            return;
2055        }
2056        mNextResultFrameNumber = frameNumber + 1;
2057    }
2058
2059    CaptureResult captureResult;
2060    captureResult.mResultExtras = resultExtras;
2061    captureResult.mMetadata = pendingMetadata;
2062
2063    if (captureResult.mMetadata.update(ANDROID_REQUEST_FRAME_COUNT,
2064            (int32_t*)&frameNumber, 1) != OK) {
2065        SET_ERR("Failed to set frame# in metadata (%d)",
2066                frameNumber);
2067        return;
2068    } else {
2069        ALOGVV("%s: Camera %d: Set frame# in metadata (%d)",
2070                __FUNCTION__, mId, frameNumber);
2071    }
2072
2073    // Append any previous partials to form a complete result
2074    if (mUsePartialResult && !collectedPartialResult.isEmpty()) {
2075        captureResult.mMetadata.append(collectedPartialResult);
2076    }
2077
2078    captureResult.mMetadata.sort();
2079
2080    // Check that there's a timestamp in the result metadata
2081    camera_metadata_entry entry =
2082            captureResult.mMetadata.find(ANDROID_SENSOR_TIMESTAMP);
2083    if (entry.count == 0) {
2084        SET_ERR("No timestamp provided by HAL for frame %d!",
2085                frameNumber);
2086        return;
2087    }
2088
2089    // Valid result, insert into queue
2090    List<CaptureResult>::iterator queuedResult =
2091            mResultQueue.insert(mResultQueue.end(), CaptureResult(captureResult));
2092    ALOGVV("%s: result requestId = %" PRId32 ", frameNumber = %" PRId64
2093           ", burstId = %" PRId32, __FUNCTION__,
2094           queuedResult->mResultExtras.requestId,
2095           queuedResult->mResultExtras.frameNumber,
2096           queuedResult->mResultExtras.burstId);
2097
2098    mResultSignal.signal();
2099}
2100
2101/**
2102 * Camera HAL device callback methods
2103 */
2104
2105void Camera3Device::processCaptureResult(const camera3_capture_result *result) {
2106    ATRACE_CALL();
2107
2108    status_t res;
2109
2110    uint32_t frameNumber = result->frame_number;
2111    if (result->result == NULL && result->num_output_buffers == 0 &&
2112            result->input_buffer == NULL) {
2113        SET_ERR("No result data provided by HAL for frame %d",
2114                frameNumber);
2115        return;
2116    }
2117
2118    // For HAL3.2 or above, If HAL doesn't support partial, it must always set
2119    // partial_result to 1 when metadata is included in this result.
2120    if (!mUsePartialResult &&
2121            mDeviceVersion >= CAMERA_DEVICE_API_VERSION_3_2 &&
2122            result->result != NULL &&
2123            result->partial_result != 1) {
2124        SET_ERR("Result is malformed for frame %d: partial_result %u must be 1"
2125                " if partial result is not supported",
2126                frameNumber, result->partial_result);
2127        return;
2128    }
2129
2130    bool isPartialResult = false;
2131    CameraMetadata collectedPartialResult;
2132    CaptureResultExtras resultExtras;
2133    bool hasInputBufferInRequest = false;
2134
2135    // Get shutter timestamp and resultExtras from list of in-flight requests,
2136    // where it was added by the shutter notification for this frame. If the
2137    // shutter timestamp isn't received yet, append the output buffers to the
2138    // in-flight request and they will be returned when the shutter timestamp
2139    // arrives. Update the in-flight status and remove the in-flight entry if
2140    // all result data and shutter timestamp have been received.
2141    nsecs_t shutterTimestamp = 0;
2142
2143    {
2144        Mutex::Autolock l(mInFlightLock);
2145        ssize_t idx = mInFlightMap.indexOfKey(frameNumber);
2146        if (idx == NAME_NOT_FOUND) {
2147            SET_ERR("Unknown frame number for capture result: %d",
2148                    frameNumber);
2149            return;
2150        }
2151        InFlightRequest &request = mInFlightMap.editValueAt(idx);
2152        ALOGVV("%s: got InFlightRequest requestId = %" PRId32
2153                ", frameNumber = %" PRId64 ", burstId = %" PRId32
2154                ", partialResultCount = %d",
2155                __FUNCTION__, request.resultExtras.requestId,
2156                request.resultExtras.frameNumber, request.resultExtras.burstId,
2157                result->partial_result);
2158        // Always update the partial count to the latest one if it's not 0
2159        // (buffers only). When framework aggregates adjacent partial results
2160        // into one, the latest partial count will be used.
2161        if (result->partial_result != 0)
2162            request.resultExtras.partialResultCount = result->partial_result;
2163
2164        // Check if this result carries only partial metadata
2165        if (mUsePartialResult && result->result != NULL) {
2166            if (mDeviceVersion >= CAMERA_DEVICE_API_VERSION_3_2) {
2167                if (result->partial_result > mNumPartialResults || result->partial_result < 1) {
2168                    SET_ERR("Result is malformed for frame %d: partial_result %u must be  in"
2169                            " the range of [1, %d] when metadata is included in the result",
2170                            frameNumber, result->partial_result, mNumPartialResults);
2171                    return;
2172                }
2173                isPartialResult = (result->partial_result < mNumPartialResults);
2174                if (isPartialResult) {
2175                    request.partialResult.collectedResult.append(result->result);
2176                }
2177            } else {
2178                camera_metadata_ro_entry_t partialResultEntry;
2179                res = find_camera_metadata_ro_entry(result->result,
2180                        ANDROID_QUIRKS_PARTIAL_RESULT, &partialResultEntry);
2181                if (res != NAME_NOT_FOUND &&
2182                        partialResultEntry.count > 0 &&
2183                        partialResultEntry.data.u8[0] ==
2184                        ANDROID_QUIRKS_PARTIAL_RESULT_PARTIAL) {
2185                    // A partial result. Flag this as such, and collect this
2186                    // set of metadata into the in-flight entry.
2187                    isPartialResult = true;
2188                    request.partialResult.collectedResult.append(
2189                        result->result);
2190                    request.partialResult.collectedResult.erase(
2191                        ANDROID_QUIRKS_PARTIAL_RESULT);
2192                }
2193            }
2194
2195            if (isPartialResult) {
2196                // Fire off a 3A-only result if possible
2197                if (!request.partialResult.haveSent3A) {
2198                    request.partialResult.haveSent3A =
2199                            processPartial3AResult(frameNumber,
2200                                    request.partialResult.collectedResult,
2201                                    request.resultExtras);
2202                }
2203            }
2204        }
2205
2206        shutterTimestamp = request.shutterTimestamp;
2207        hasInputBufferInRequest = request.hasInputBuffer;
2208
2209        // Did we get the (final) result metadata for this capture?
2210        if (result->result != NULL && !isPartialResult) {
2211            if (request.haveResultMetadata) {
2212                SET_ERR("Called multiple times with metadata for frame %d",
2213                        frameNumber);
2214                return;
2215            }
2216            if (mUsePartialResult &&
2217                    !request.partialResult.collectedResult.isEmpty()) {
2218                collectedPartialResult.acquire(
2219                    request.partialResult.collectedResult);
2220            }
2221            request.haveResultMetadata = true;
2222        }
2223
2224        uint32_t numBuffersReturned = result->num_output_buffers;
2225        if (result->input_buffer != NULL) {
2226            if (hasInputBufferInRequest) {
2227                numBuffersReturned += 1;
2228            } else {
2229                ALOGW("%s: Input buffer should be NULL if there is no input"
2230                        " buffer sent in the request",
2231                        __FUNCTION__);
2232            }
2233        }
2234        request.numBuffersLeft -= numBuffersReturned;
2235        if (request.numBuffersLeft < 0) {
2236            SET_ERR("Too many buffers returned for frame %d",
2237                    frameNumber);
2238            return;
2239        }
2240
2241        camera_metadata_ro_entry_t entry;
2242        res = find_camera_metadata_ro_entry(result->result,
2243                ANDROID_SENSOR_TIMESTAMP, &entry);
2244        if (res == OK && entry.count == 1) {
2245            request.sensorTimestamp = entry.data.i64[0];
2246        }
2247
2248        // If shutter event isn't received yet, append the output buffers to
2249        // the in-flight request. Otherwise, return the output buffers to
2250        // streams.
2251        if (shutterTimestamp == 0) {
2252            request.pendingOutputBuffers.appendArray(result->output_buffers,
2253                result->num_output_buffers);
2254        } else {
2255            returnOutputBuffers(result->output_buffers,
2256                result->num_output_buffers, shutterTimestamp);
2257        }
2258
2259        if (result->result != NULL && !isPartialResult) {
2260            if (shutterTimestamp == 0) {
2261                request.pendingMetadata = result->result;
2262                request.partialResult.collectedResult = collectedPartialResult;
2263            } else {
2264                CameraMetadata metadata;
2265                metadata = result->result;
2266                sendCaptureResult(metadata, request.resultExtras,
2267                    collectedPartialResult, frameNumber, hasInputBufferInRequest);
2268            }
2269        }
2270
2271        removeInFlightRequestIfReadyLocked(idx);
2272    } // scope for mInFlightLock
2273
2274    if (result->input_buffer != NULL) {
2275        if (hasInputBufferInRequest) {
2276            Camera3Stream *stream =
2277                Camera3Stream::cast(result->input_buffer->stream);
2278            res = stream->returnInputBuffer(*(result->input_buffer));
2279            // Note: stream may be deallocated at this point, if this buffer was the
2280            // last reference to it.
2281            if (res != OK) {
2282                ALOGE("%s: RequestThread: Can't return input buffer for frame %d to"
2283                      "  its stream:%s (%d)",  __FUNCTION__,
2284                      frameNumber, strerror(-res), res);
2285            }
2286        } else {
2287            ALOGW("%s: Input buffer should be NULL if there is no input"
2288                    " buffer sent in the request, skipping input buffer return.",
2289                    __FUNCTION__);
2290        }
2291    }
2292}
2293
2294void Camera3Device::notify(const camera3_notify_msg *msg) {
2295    ATRACE_CALL();
2296    NotificationListener *listener;
2297    {
2298        Mutex::Autolock l(mOutputLock);
2299        listener = mListener;
2300    }
2301
2302    if (msg == NULL) {
2303        SET_ERR("HAL sent NULL notify message!");
2304        return;
2305    }
2306
2307    switch (msg->type) {
2308        case CAMERA3_MSG_ERROR: {
2309            notifyError(msg->message.error, listener);
2310            break;
2311        }
2312        case CAMERA3_MSG_SHUTTER: {
2313            notifyShutter(msg->message.shutter, listener);
2314            break;
2315        }
2316        default:
2317            SET_ERR("Unknown notify message from HAL: %d",
2318                    msg->type);
2319    }
2320}
2321
2322void Camera3Device::notifyError(const camera3_error_msg_t &msg,
2323        NotificationListener *listener) {
2324
2325    // Map camera HAL error codes to ICameraDeviceCallback error codes
2326    // Index into this with the HAL error code
2327    static const ICameraDeviceCallbacks::CameraErrorCode
2328            halErrorMap[CAMERA3_MSG_NUM_ERRORS] = {
2329        // 0 = Unused error code
2330        ICameraDeviceCallbacks::ERROR_CAMERA_INVALID_ERROR,
2331        // 1 = CAMERA3_MSG_ERROR_DEVICE
2332        ICameraDeviceCallbacks::ERROR_CAMERA_DEVICE,
2333        // 2 = CAMERA3_MSG_ERROR_REQUEST
2334        ICameraDeviceCallbacks::ERROR_CAMERA_REQUEST,
2335        // 3 = CAMERA3_MSG_ERROR_RESULT
2336        ICameraDeviceCallbacks::ERROR_CAMERA_RESULT,
2337        // 4 = CAMERA3_MSG_ERROR_BUFFER
2338        ICameraDeviceCallbacks::ERROR_CAMERA_BUFFER
2339    };
2340
2341    ICameraDeviceCallbacks::CameraErrorCode errorCode =
2342            ((msg.error_code >= 0) &&
2343                    (msg.error_code < CAMERA3_MSG_NUM_ERRORS)) ?
2344            halErrorMap[msg.error_code] :
2345            ICameraDeviceCallbacks::ERROR_CAMERA_INVALID_ERROR;
2346
2347    int streamId = 0;
2348    if (msg.error_stream != NULL) {
2349        Camera3Stream *stream =
2350                Camera3Stream::cast(msg.error_stream);
2351        streamId = stream->getId();
2352    }
2353    ALOGV("Camera %d: %s: HAL error, frame %d, stream %d: %d",
2354            mId, __FUNCTION__, msg.frame_number,
2355            streamId, msg.error_code);
2356
2357    CaptureResultExtras resultExtras;
2358    switch (errorCode) {
2359        case ICameraDeviceCallbacks::ERROR_CAMERA_DEVICE:
2360            // SET_ERR calls notifyError
2361            SET_ERR("Camera HAL reported serious device error");
2362            break;
2363        case ICameraDeviceCallbacks::ERROR_CAMERA_REQUEST:
2364        case ICameraDeviceCallbacks::ERROR_CAMERA_RESULT:
2365        case ICameraDeviceCallbacks::ERROR_CAMERA_BUFFER:
2366            {
2367                Mutex::Autolock l(mInFlightLock);
2368                ssize_t idx = mInFlightMap.indexOfKey(msg.frame_number);
2369                if (idx >= 0) {
2370                    InFlightRequest &r = mInFlightMap.editValueAt(idx);
2371                    r.requestStatus = msg.error_code;
2372                    resultExtras = r.resultExtras;
2373                } else {
2374                    resultExtras.frameNumber = msg.frame_number;
2375                    ALOGE("Camera %d: %s: cannot find in-flight request on "
2376                            "frame %" PRId64 " error", mId, __FUNCTION__,
2377                            resultExtras.frameNumber);
2378                }
2379            }
2380            if (listener != NULL) {
2381                listener->notifyError(errorCode, resultExtras);
2382            } else {
2383                ALOGE("Camera %d: %s: no listener available", mId, __FUNCTION__);
2384            }
2385            break;
2386        default:
2387            // SET_ERR calls notifyError
2388            SET_ERR("Unknown error message from HAL: %d", msg.error_code);
2389            break;
2390    }
2391}
2392
2393void Camera3Device::notifyShutter(const camera3_shutter_msg_t &msg,
2394        NotificationListener *listener) {
2395    ssize_t idx;
2396    // Verify ordering of shutter notifications
2397    {
2398        Mutex::Autolock l(mOutputLock);
2399        // TODO: need to track errors for tighter bounds on expected frame number.
2400        if (msg.frame_number < mNextShutterFrameNumber) {
2401            SET_ERR("Shutter notification out-of-order. Expected "
2402                    "notification for frame %d, got frame %d",
2403                    mNextShutterFrameNumber, msg.frame_number);
2404            return;
2405        }
2406        mNextShutterFrameNumber = msg.frame_number + 1;
2407    }
2408
2409    // Set timestamp for the request in the in-flight tracking
2410    // and get the request ID to send upstream
2411    {
2412        Mutex::Autolock l(mInFlightLock);
2413        idx = mInFlightMap.indexOfKey(msg.frame_number);
2414        if (idx >= 0) {
2415            InFlightRequest &r = mInFlightMap.editValueAt(idx);
2416
2417            ALOGVV("Camera %d: %s: Shutter fired for frame %d (id %d) at %" PRId64,
2418                    mId, __FUNCTION__,
2419                    msg.frame_number, r.resultExtras.requestId, msg.timestamp);
2420            // Call listener, if any
2421            if (listener != NULL) {
2422                listener->notifyShutter(r.resultExtras, msg.timestamp);
2423            }
2424
2425            r.shutterTimestamp = msg.timestamp;
2426
2427            // send pending result and buffers
2428            sendCaptureResult(r.pendingMetadata, r.resultExtras,
2429                r.partialResult.collectedResult, msg.frame_number,
2430                r.hasInputBuffer);
2431            returnOutputBuffers(r.pendingOutputBuffers.array(),
2432                r.pendingOutputBuffers.size(), r.shutterTimestamp);
2433            r.pendingOutputBuffers.clear();
2434
2435            removeInFlightRequestIfReadyLocked(idx);
2436        }
2437    }
2438    if (idx < 0) {
2439        SET_ERR("Shutter notification for non-existent frame number %d",
2440                msg.frame_number);
2441    }
2442}
2443
2444
2445CameraMetadata Camera3Device::getLatestRequestLocked() {
2446    ALOGV("%s", __FUNCTION__);
2447
2448    CameraMetadata retVal;
2449
2450    if (mRequestThread != NULL) {
2451        retVal = mRequestThread->getLatestRequest();
2452    }
2453
2454    return retVal;
2455}
2456
2457
2458/**
2459 * RequestThread inner class methods
2460 */
2461
2462Camera3Device::RequestThread::RequestThread(wp<Camera3Device> parent,
2463        sp<StatusTracker> statusTracker,
2464        camera3_device_t *hal3Device) :
2465        Thread(/*canCallJava*/false),
2466        mParent(parent),
2467        mStatusTracker(statusTracker),
2468        mHal3Device(hal3Device),
2469        mId(getId(parent)),
2470        mReconfigured(false),
2471        mDoPause(false),
2472        mPaused(true),
2473        mFrameNumber(0),
2474        mLatestRequestId(NAME_NOT_FOUND),
2475        mCurrentAfTriggerId(0),
2476        mCurrentPreCaptureTriggerId(0),
2477        mRepeatingLastFrameNumber(NO_IN_FLIGHT_REPEATING_FRAMES) {
2478    mStatusId = statusTracker->addComponent();
2479}
2480
2481void Camera3Device::RequestThread::setNotificationListener(
2482        NotificationListener *listener) {
2483    Mutex::Autolock l(mRequestLock);
2484    mListener = listener;
2485}
2486
2487void Camera3Device::RequestThread::configurationComplete() {
2488    Mutex::Autolock l(mRequestLock);
2489    mReconfigured = true;
2490}
2491
2492status_t Camera3Device::RequestThread::queueRequestList(
2493        List<sp<CaptureRequest> > &requests,
2494        /*out*/
2495        int64_t *lastFrameNumber) {
2496    Mutex::Autolock l(mRequestLock);
2497    for (List<sp<CaptureRequest> >::iterator it = requests.begin(); it != requests.end();
2498            ++it) {
2499        mRequestQueue.push_back(*it);
2500    }
2501
2502    if (lastFrameNumber != NULL) {
2503        *lastFrameNumber = mFrameNumber + mRequestQueue.size() - 1;
2504        ALOGV("%s: requestId %d, mFrameNumber %" PRId32 ", lastFrameNumber %" PRId64 ".",
2505              __FUNCTION__, (*(requests.begin()))->mResultExtras.requestId, mFrameNumber,
2506              *lastFrameNumber);
2507    }
2508
2509    unpauseForNewRequests();
2510
2511    return OK;
2512}
2513
2514
2515status_t Camera3Device::RequestThread::queueTrigger(
2516        RequestTrigger trigger[],
2517        size_t count) {
2518
2519    Mutex::Autolock l(mTriggerMutex);
2520    status_t ret;
2521
2522    for (size_t i = 0; i < count; ++i) {
2523        ret = queueTriggerLocked(trigger[i]);
2524
2525        if (ret != OK) {
2526            return ret;
2527        }
2528    }
2529
2530    return OK;
2531}
2532
2533int Camera3Device::RequestThread::getId(const wp<Camera3Device> &device) {
2534    sp<Camera3Device> d = device.promote();
2535    if (d != NULL) return d->mId;
2536    return 0;
2537}
2538
2539status_t Camera3Device::RequestThread::queueTriggerLocked(
2540        RequestTrigger trigger) {
2541
2542    uint32_t tag = trigger.metadataTag;
2543    ssize_t index = mTriggerMap.indexOfKey(tag);
2544
2545    switch (trigger.getTagType()) {
2546        case TYPE_BYTE:
2547        // fall-through
2548        case TYPE_INT32:
2549            break;
2550        default:
2551            ALOGE("%s: Type not supported: 0x%x", __FUNCTION__,
2552                    trigger.getTagType());
2553            return INVALID_OPERATION;
2554    }
2555
2556    /**
2557     * Collect only the latest trigger, since we only have 1 field
2558     * in the request settings per trigger tag, and can't send more than 1
2559     * trigger per request.
2560     */
2561    if (index != NAME_NOT_FOUND) {
2562        mTriggerMap.editValueAt(index) = trigger;
2563    } else {
2564        mTriggerMap.add(tag, trigger);
2565    }
2566
2567    return OK;
2568}
2569
2570status_t Camera3Device::RequestThread::setRepeatingRequests(
2571        const RequestList &requests,
2572        /*out*/
2573        int64_t *lastFrameNumber) {
2574    Mutex::Autolock l(mRequestLock);
2575    if (lastFrameNumber != NULL) {
2576        *lastFrameNumber = mRepeatingLastFrameNumber;
2577    }
2578    mRepeatingRequests.clear();
2579    mRepeatingRequests.insert(mRepeatingRequests.begin(),
2580            requests.begin(), requests.end());
2581
2582    unpauseForNewRequests();
2583
2584    mRepeatingLastFrameNumber = NO_IN_FLIGHT_REPEATING_FRAMES;
2585    return OK;
2586}
2587
2588bool Camera3Device::RequestThread::isRepeatingRequestLocked(const sp<CaptureRequest> requestIn) {
2589    if (mRepeatingRequests.empty()) {
2590        return false;
2591    }
2592    int32_t requestId = requestIn->mResultExtras.requestId;
2593    const RequestList &repeatRequests = mRepeatingRequests;
2594    // All repeating requests are guaranteed to have same id so only check first quest
2595    const sp<CaptureRequest> firstRequest = *repeatRequests.begin();
2596    return (firstRequest->mResultExtras.requestId == requestId);
2597}
2598
2599status_t Camera3Device::RequestThread::clearRepeatingRequests(/*out*/int64_t *lastFrameNumber) {
2600    Mutex::Autolock l(mRequestLock);
2601    mRepeatingRequests.clear();
2602    if (lastFrameNumber != NULL) {
2603        *lastFrameNumber = mRepeatingLastFrameNumber;
2604    }
2605    mRepeatingLastFrameNumber = NO_IN_FLIGHT_REPEATING_FRAMES;
2606    return OK;
2607}
2608
2609status_t Camera3Device::RequestThread::clear(
2610        NotificationListener *listener,
2611        /*out*/int64_t *lastFrameNumber) {
2612    Mutex::Autolock l(mRequestLock);
2613    ALOGV("RequestThread::%s:", __FUNCTION__);
2614
2615    mRepeatingRequests.clear();
2616
2617    // Send errors for all requests pending in the request queue, including
2618    // pending repeating requests
2619    if (listener != NULL) {
2620        for (RequestList::iterator it = mRequestQueue.begin();
2621                 it != mRequestQueue.end(); ++it) {
2622            // Abort the input buffers for reprocess requests.
2623            if ((*it)->mInputStream != NULL) {
2624                camera3_stream_buffer_t inputBuffer;
2625                status_t res = (*it)->mInputStream->getInputBuffer(&inputBuffer);
2626                if (res != OK) {
2627                    ALOGW("%s: %d: couldn't get input buffer while clearing the request "
2628                            "list: %s (%d)", __FUNCTION__, __LINE__, strerror(-res), res);
2629                } else {
2630                    res = (*it)->mInputStream->returnInputBuffer(inputBuffer);
2631                    if (res != OK) {
2632                        ALOGE("%s: %d: couldn't return input buffer while clearing the request "
2633                                "list: %s (%d)", __FUNCTION__, __LINE__, strerror(-res), res);
2634                    }
2635                }
2636            }
2637            // Set the frame number this request would have had, if it
2638            // had been submitted; this frame number will not be reused.
2639            // The requestId and burstId fields were set when the request was
2640            // submitted originally (in convertMetadataListToRequestListLocked)
2641            (*it)->mResultExtras.frameNumber = mFrameNumber++;
2642            listener->notifyError(ICameraDeviceCallbacks::ERROR_CAMERA_REQUEST,
2643                    (*it)->mResultExtras);
2644        }
2645    }
2646    mRequestQueue.clear();
2647    mTriggerMap.clear();
2648    if (lastFrameNumber != NULL) {
2649        *lastFrameNumber = mRepeatingLastFrameNumber;
2650    }
2651    mRepeatingLastFrameNumber = NO_IN_FLIGHT_REPEATING_FRAMES;
2652    return OK;
2653}
2654
2655void Camera3Device::RequestThread::setPaused(bool paused) {
2656    Mutex::Autolock l(mPauseLock);
2657    mDoPause = paused;
2658    mDoPauseSignal.signal();
2659}
2660
2661status_t Camera3Device::RequestThread::waitUntilRequestProcessed(
2662        int32_t requestId, nsecs_t timeout) {
2663    Mutex::Autolock l(mLatestRequestMutex);
2664    status_t res;
2665    while (mLatestRequestId != requestId) {
2666        nsecs_t startTime = systemTime();
2667
2668        res = mLatestRequestSignal.waitRelative(mLatestRequestMutex, timeout);
2669        if (res != OK) return res;
2670
2671        timeout -= (systemTime() - startTime);
2672    }
2673
2674    return OK;
2675}
2676
2677void Camera3Device::RequestThread::requestExit() {
2678    // Call parent to set up shutdown
2679    Thread::requestExit();
2680    // The exit from any possible waits
2681    mDoPauseSignal.signal();
2682    mRequestSignal.signal();
2683}
2684
2685bool Camera3Device::RequestThread::threadLoop() {
2686
2687    status_t res;
2688
2689    // Handle paused state.
2690    if (waitIfPaused()) {
2691        return true;
2692    }
2693
2694    // Get work to do
2695
2696    sp<CaptureRequest> nextRequest = waitForNextRequest();
2697    if (nextRequest == NULL) {
2698        return true;
2699    }
2700
2701    // Create request to HAL
2702    camera3_capture_request_t request = camera3_capture_request_t();
2703    request.frame_number = nextRequest->mResultExtras.frameNumber;
2704    Vector<camera3_stream_buffer_t> outputBuffers;
2705
2706    // Get the request ID, if any
2707    int requestId;
2708    camera_metadata_entry_t requestIdEntry =
2709            nextRequest->mSettings.find(ANDROID_REQUEST_ID);
2710    if (requestIdEntry.count > 0) {
2711        requestId = requestIdEntry.data.i32[0];
2712    } else {
2713        ALOGW("%s: Did not have android.request.id set in the request",
2714                __FUNCTION__);
2715        requestId = NAME_NOT_FOUND;
2716    }
2717
2718    // Insert any queued triggers (before metadata is locked)
2719    int32_t triggerCount;
2720    res = insertTriggers(nextRequest);
2721    if (res < 0) {
2722        SET_ERR("RequestThread: Unable to insert triggers "
2723                "(capture request %d, HAL device: %s (%d)",
2724                request.frame_number, strerror(-res), res);
2725        cleanUpFailedRequest(request, nextRequest, outputBuffers);
2726        return false;
2727    }
2728    triggerCount = res;
2729
2730    bool triggersMixedIn = (triggerCount > 0 || mPrevTriggers > 0);
2731
2732    // If the request is the same as last, or we had triggers last time
2733    if (mPrevRequest != nextRequest || triggersMixedIn) {
2734        /**
2735         * HAL workaround:
2736         * Insert a dummy trigger ID if a trigger is set but no trigger ID is
2737         */
2738        res = addDummyTriggerIds(nextRequest);
2739        if (res != OK) {
2740            SET_ERR("RequestThread: Unable to insert dummy trigger IDs "
2741                    "(capture request %d, HAL device: %s (%d)",
2742                    request.frame_number, strerror(-res), res);
2743            cleanUpFailedRequest(request, nextRequest, outputBuffers);
2744            return false;
2745        }
2746
2747        /**
2748         * The request should be presorted so accesses in HAL
2749         *   are O(logn). Sidenote, sorting a sorted metadata is nop.
2750         */
2751        nextRequest->mSettings.sort();
2752        request.settings = nextRequest->mSettings.getAndLock();
2753        mPrevRequest = nextRequest;
2754        ALOGVV("%s: Request settings are NEW", __FUNCTION__);
2755
2756        IF_ALOGV() {
2757            camera_metadata_ro_entry_t e = camera_metadata_ro_entry_t();
2758            find_camera_metadata_ro_entry(
2759                    request.settings,
2760                    ANDROID_CONTROL_AF_TRIGGER,
2761                    &e
2762            );
2763            if (e.count > 0) {
2764                ALOGV("%s: Request (frame num %d) had AF trigger 0x%x",
2765                      __FUNCTION__,
2766                      request.frame_number,
2767                      e.data.u8[0]);
2768            }
2769        }
2770    } else {
2771        // leave request.settings NULL to indicate 'reuse latest given'
2772        ALOGVV("%s: Request settings are REUSED",
2773               __FUNCTION__);
2774    }
2775
2776    uint32_t totalNumBuffers = 0;
2777
2778    // Fill in buffers
2779    if (nextRequest->mInputStream != NULL) {
2780        request.input_buffer = &nextRequest->mInputBuffer;
2781        totalNumBuffers += 1;
2782    } else {
2783        request.input_buffer = NULL;
2784    }
2785
2786    outputBuffers.insertAt(camera3_stream_buffer_t(), 0,
2787            nextRequest->mOutputStreams.size());
2788    request.output_buffers = outputBuffers.array();
2789    for (size_t i = 0; i < nextRequest->mOutputStreams.size(); i++) {
2790        res = nextRequest->mOutputStreams.editItemAt(i)->
2791                getBuffer(&outputBuffers.editItemAt(i));
2792        if (res != OK) {
2793            // Can't get output buffer from gralloc queue - this could be due to
2794            // abandoned queue or other consumer misbehavior, so not a fatal
2795            // error
2796            ALOGE("RequestThread: Can't get output buffer, skipping request:"
2797                    " %s (%d)", strerror(-res), res);
2798            {
2799                Mutex::Autolock l(mRequestLock);
2800                if (mListener != NULL) {
2801                    mListener->notifyError(
2802                            ICameraDeviceCallbacks::ERROR_CAMERA_REQUEST,
2803                            nextRequest->mResultExtras);
2804                }
2805            }
2806            cleanUpFailedRequest(request, nextRequest, outputBuffers);
2807            return true;
2808        }
2809        request.num_output_buffers++;
2810    }
2811    totalNumBuffers += request.num_output_buffers;
2812
2813    // Log request in the in-flight queue
2814    sp<Camera3Device> parent = mParent.promote();
2815    if (parent == NULL) {
2816        // Should not happen, and nowhere to send errors to, so just log it
2817        CLOGE("RequestThread: Parent is gone");
2818        cleanUpFailedRequest(request, nextRequest, outputBuffers);
2819        return false;
2820    }
2821
2822    res = parent->registerInFlight(request.frame_number,
2823            totalNumBuffers, nextRequest->mResultExtras,
2824            /*hasInput*/request.input_buffer != NULL);
2825    ALOGVV("%s: registered in flight requestId = %" PRId32 ", frameNumber = %" PRId64
2826           ", burstId = %" PRId32 ".",
2827            __FUNCTION__,
2828            nextRequest->mResultExtras.requestId, nextRequest->mResultExtras.frameNumber,
2829            nextRequest->mResultExtras.burstId);
2830    if (res != OK) {
2831        SET_ERR("RequestThread: Unable to register new in-flight request:"
2832                " %s (%d)", strerror(-res), res);
2833        cleanUpFailedRequest(request, nextRequest, outputBuffers);
2834        return false;
2835    }
2836
2837    // Inform waitUntilRequestProcessed thread of a new request ID
2838    {
2839        Mutex::Autolock al(mLatestRequestMutex);
2840
2841        mLatestRequestId = requestId;
2842        mLatestRequestSignal.signal();
2843    }
2844
2845    // Submit request and block until ready for next one
2846    ATRACE_ASYNC_BEGIN("frame capture", request.frame_number);
2847    ATRACE_BEGIN("camera3->process_capture_request");
2848    res = mHal3Device->ops->process_capture_request(mHal3Device, &request);
2849    ATRACE_END();
2850
2851    if (res != OK) {
2852        // Should only get a failure here for malformed requests or device-level
2853        // errors, so consider all errors fatal.  Bad metadata failures should
2854        // come through notify.
2855        SET_ERR("RequestThread: Unable to submit capture request %d to HAL"
2856                " device: %s (%d)", request.frame_number, strerror(-res), res);
2857        cleanUpFailedRequest(request, nextRequest, outputBuffers);
2858        return false;
2859    }
2860
2861    // Update the latest request sent to HAL
2862    if (request.settings != NULL) { // Don't update them if they were unchanged
2863        Mutex::Autolock al(mLatestRequestMutex);
2864
2865        camera_metadata_t* cloned = clone_camera_metadata(request.settings);
2866        mLatestRequest.acquire(cloned);
2867    }
2868
2869    if (request.settings != NULL) {
2870        nextRequest->mSettings.unlock(request.settings);
2871    }
2872
2873    // Unset as current request
2874    {
2875        Mutex::Autolock l(mRequestLock);
2876        mNextRequest.clear();
2877    }
2878
2879    // Remove any previously queued triggers (after unlock)
2880    res = removeTriggers(mPrevRequest);
2881    if (res != OK) {
2882        SET_ERR("RequestThread: Unable to remove triggers "
2883              "(capture request %d, HAL device: %s (%d)",
2884              request.frame_number, strerror(-res), res);
2885        return false;
2886    }
2887    mPrevTriggers = triggerCount;
2888
2889    return true;
2890}
2891
2892CameraMetadata Camera3Device::RequestThread::getLatestRequest() const {
2893    Mutex::Autolock al(mLatestRequestMutex);
2894
2895    ALOGV("RequestThread::%s", __FUNCTION__);
2896
2897    return mLatestRequest;
2898}
2899
2900bool Camera3Device::RequestThread::isStreamPending(
2901        sp<Camera3StreamInterface>& stream) {
2902    Mutex::Autolock l(mRequestLock);
2903
2904    if (mNextRequest != nullptr) {
2905        for (const auto& s : mNextRequest->mOutputStreams) {
2906            if (stream == s) return true;
2907        }
2908        if (stream == mNextRequest->mInputStream) return true;
2909    }
2910
2911    for (const auto& request : mRequestQueue) {
2912        for (const auto& s : request->mOutputStreams) {
2913            if (stream == s) return true;
2914        }
2915        if (stream == request->mInputStream) return true;
2916    }
2917
2918    for (const auto& request : mRepeatingRequests) {
2919        for (const auto& s : request->mOutputStreams) {
2920            if (stream == s) return true;
2921        }
2922        if (stream == request->mInputStream) return true;
2923    }
2924
2925    return false;
2926}
2927
2928void Camera3Device::RequestThread::cleanUpFailedRequest(
2929        camera3_capture_request_t &request,
2930        sp<CaptureRequest> &nextRequest,
2931        Vector<camera3_stream_buffer_t> &outputBuffers) {
2932
2933    if (request.settings != NULL) {
2934        nextRequest->mSettings.unlock(request.settings);
2935    }
2936    if (nextRequest->mInputStream != NULL) {
2937        nextRequest->mInputBuffer.status = CAMERA3_BUFFER_STATUS_ERROR;
2938        nextRequest->mInputStream->returnInputBuffer(nextRequest->mInputBuffer);
2939    }
2940    for (size_t i = 0; i < request.num_output_buffers; i++) {
2941        outputBuffers.editItemAt(i).status = CAMERA3_BUFFER_STATUS_ERROR;
2942        nextRequest->mOutputStreams.editItemAt(i)->returnBuffer(
2943            outputBuffers[i], 0);
2944    }
2945
2946    Mutex::Autolock l(mRequestLock);
2947    mNextRequest.clear();
2948}
2949
2950sp<Camera3Device::CaptureRequest>
2951        Camera3Device::RequestThread::waitForNextRequest() {
2952    status_t res;
2953    sp<CaptureRequest> nextRequest;
2954
2955    // Optimized a bit for the simple steady-state case (single repeating
2956    // request), to avoid putting that request in the queue temporarily.
2957    Mutex::Autolock l(mRequestLock);
2958
2959    while (mRequestQueue.empty()) {
2960        if (!mRepeatingRequests.empty()) {
2961            // Always atomically enqueue all requests in a repeating request
2962            // list. Guarantees a complete in-sequence set of captures to
2963            // application.
2964            const RequestList &requests = mRepeatingRequests;
2965            RequestList::const_iterator firstRequest =
2966                    requests.begin();
2967            nextRequest = *firstRequest;
2968            mRequestQueue.insert(mRequestQueue.end(),
2969                    ++firstRequest,
2970                    requests.end());
2971            // No need to wait any longer
2972
2973            mRepeatingLastFrameNumber = mFrameNumber + requests.size() - 1;
2974
2975            break;
2976        }
2977
2978        res = mRequestSignal.waitRelative(mRequestLock, kRequestTimeout);
2979
2980        if ((mRequestQueue.empty() && mRepeatingRequests.empty()) ||
2981                exitPending()) {
2982            Mutex::Autolock pl(mPauseLock);
2983            if (mPaused == false) {
2984                ALOGV("%s: RequestThread: Going idle", __FUNCTION__);
2985                mPaused = true;
2986                // Let the tracker know
2987                sp<StatusTracker> statusTracker = mStatusTracker.promote();
2988                if (statusTracker != 0) {
2989                    statusTracker->markComponentIdle(mStatusId, Fence::NO_FENCE);
2990                }
2991            }
2992            // Stop waiting for now and let thread management happen
2993            return NULL;
2994        }
2995    }
2996
2997    if (nextRequest == NULL) {
2998        // Don't have a repeating request already in hand, so queue
2999        // must have an entry now.
3000        RequestList::iterator firstRequest =
3001                mRequestQueue.begin();
3002        nextRequest = *firstRequest;
3003        mRequestQueue.erase(firstRequest);
3004    }
3005
3006    // In case we've been unpaused by setPaused clearing mDoPause, need to
3007    // update internal pause state (capture/setRepeatingRequest unpause
3008    // directly).
3009    Mutex::Autolock pl(mPauseLock);
3010    if (mPaused) {
3011        ALOGV("%s: RequestThread: Unpaused", __FUNCTION__);
3012        sp<StatusTracker> statusTracker = mStatusTracker.promote();
3013        if (statusTracker != 0) {
3014            statusTracker->markComponentActive(mStatusId);
3015        }
3016    }
3017    mPaused = false;
3018
3019    // Check if we've reconfigured since last time, and reset the preview
3020    // request if so. Can't use 'NULL request == repeat' across configure calls.
3021    if (mReconfigured) {
3022        mPrevRequest.clear();
3023        mReconfigured = false;
3024    }
3025
3026    if (nextRequest != NULL) {
3027        nextRequest->mResultExtras.frameNumber = mFrameNumber++;
3028        nextRequest->mResultExtras.afTriggerId = mCurrentAfTriggerId;
3029        nextRequest->mResultExtras.precaptureTriggerId = mCurrentPreCaptureTriggerId;
3030
3031        // Since RequestThread::clear() removes buffers from the input stream,
3032        // get the right buffer here before unlocking mRequestLock
3033        if (nextRequest->mInputStream != NULL) {
3034            res = nextRequest->mInputStream->getInputBuffer(&nextRequest->mInputBuffer);
3035            if (res != OK) {
3036                // Can't get input buffer from gralloc queue - this could be due to
3037                // disconnected queue or other producer misbehavior, so not a fatal
3038                // error
3039                ALOGE("%s: Can't get input buffer, skipping request:"
3040                        " %s (%d)", __FUNCTION__, strerror(-res), res);
3041                if (mListener != NULL) {
3042                    mListener->notifyError(
3043                            ICameraDeviceCallbacks::ERROR_CAMERA_REQUEST,
3044                            nextRequest->mResultExtras);
3045                }
3046                return NULL;
3047            }
3048        }
3049    }
3050    mNextRequest = nextRequest;
3051
3052    return nextRequest;
3053}
3054
3055bool Camera3Device::RequestThread::waitIfPaused() {
3056    status_t res;
3057    Mutex::Autolock l(mPauseLock);
3058    while (mDoPause) {
3059        if (mPaused == false) {
3060            mPaused = true;
3061            ALOGV("%s: RequestThread: Paused", __FUNCTION__);
3062            // Let the tracker know
3063            sp<StatusTracker> statusTracker = mStatusTracker.promote();
3064            if (statusTracker != 0) {
3065                statusTracker->markComponentIdle(mStatusId, Fence::NO_FENCE);
3066            }
3067        }
3068
3069        res = mDoPauseSignal.waitRelative(mPauseLock, kRequestTimeout);
3070        if (res == TIMED_OUT || exitPending()) {
3071            return true;
3072        }
3073    }
3074    // We don't set mPaused to false here, because waitForNextRequest needs
3075    // to further manage the paused state in case of starvation.
3076    return false;
3077}
3078
3079void Camera3Device::RequestThread::unpauseForNewRequests() {
3080    // With work to do, mark thread as unpaused.
3081    // If paused by request (setPaused), don't resume, to avoid
3082    // extra signaling/waiting overhead to waitUntilPaused
3083    mRequestSignal.signal();
3084    Mutex::Autolock p(mPauseLock);
3085    if (!mDoPause) {
3086        ALOGV("%s: RequestThread: Going active", __FUNCTION__);
3087        if (mPaused) {
3088            sp<StatusTracker> statusTracker = mStatusTracker.promote();
3089            if (statusTracker != 0) {
3090                statusTracker->markComponentActive(mStatusId);
3091            }
3092        }
3093        mPaused = false;
3094    }
3095}
3096
3097void Camera3Device::RequestThread::setErrorState(const char *fmt, ...) {
3098    sp<Camera3Device> parent = mParent.promote();
3099    if (parent != NULL) {
3100        va_list args;
3101        va_start(args, fmt);
3102
3103        parent->setErrorStateV(fmt, args);
3104
3105        va_end(args);
3106    }
3107}
3108
3109status_t Camera3Device::RequestThread::insertTriggers(
3110        const sp<CaptureRequest> &request) {
3111
3112    Mutex::Autolock al(mTriggerMutex);
3113
3114    sp<Camera3Device> parent = mParent.promote();
3115    if (parent == NULL) {
3116        CLOGE("RequestThread: Parent is gone");
3117        return DEAD_OBJECT;
3118    }
3119
3120    CameraMetadata &metadata = request->mSettings;
3121    size_t count = mTriggerMap.size();
3122
3123    for (size_t i = 0; i < count; ++i) {
3124        RequestTrigger trigger = mTriggerMap.valueAt(i);
3125        uint32_t tag = trigger.metadataTag;
3126
3127        if (tag == ANDROID_CONTROL_AF_TRIGGER_ID || tag == ANDROID_CONTROL_AE_PRECAPTURE_ID) {
3128            bool isAeTrigger = (trigger.metadataTag == ANDROID_CONTROL_AE_PRECAPTURE_ID);
3129            uint32_t triggerId = static_cast<uint32_t>(trigger.entryValue);
3130            if (isAeTrigger) {
3131                request->mResultExtras.precaptureTriggerId = triggerId;
3132                mCurrentPreCaptureTriggerId = triggerId;
3133            } else {
3134                request->mResultExtras.afTriggerId = triggerId;
3135                mCurrentAfTriggerId = triggerId;
3136            }
3137            if (parent->mDeviceVersion >= CAMERA_DEVICE_API_VERSION_3_2) {
3138                continue; // Trigger ID tag is deprecated since device HAL 3.2
3139            }
3140        }
3141
3142        camera_metadata_entry entry = metadata.find(tag);
3143
3144        if (entry.count > 0) {
3145            /**
3146             * Already has an entry for this trigger in the request.
3147             * Rewrite it with our requested trigger value.
3148             */
3149            RequestTrigger oldTrigger = trigger;
3150
3151            oldTrigger.entryValue = entry.data.u8[0];
3152
3153            mTriggerReplacedMap.add(tag, oldTrigger);
3154        } else {
3155            /**
3156             * More typical, no trigger entry, so we just add it
3157             */
3158            mTriggerRemovedMap.add(tag, trigger);
3159        }
3160
3161        status_t res;
3162
3163        switch (trigger.getTagType()) {
3164            case TYPE_BYTE: {
3165                uint8_t entryValue = static_cast<uint8_t>(trigger.entryValue);
3166                res = metadata.update(tag,
3167                                      &entryValue,
3168                                      /*count*/1);
3169                break;
3170            }
3171            case TYPE_INT32:
3172                res = metadata.update(tag,
3173                                      &trigger.entryValue,
3174                                      /*count*/1);
3175                break;
3176            default:
3177                ALOGE("%s: Type not supported: 0x%x",
3178                      __FUNCTION__,
3179                      trigger.getTagType());
3180                return INVALID_OPERATION;
3181        }
3182
3183        if (res != OK) {
3184            ALOGE("%s: Failed to update request metadata with trigger tag %s"
3185                  ", value %d", __FUNCTION__, trigger.getTagName(),
3186                  trigger.entryValue);
3187            return res;
3188        }
3189
3190        ALOGV("%s: Mixed in trigger %s, value %d", __FUNCTION__,
3191              trigger.getTagName(),
3192              trigger.entryValue);
3193    }
3194
3195    mTriggerMap.clear();
3196
3197    return count;
3198}
3199
3200status_t Camera3Device::RequestThread::removeTriggers(
3201        const sp<CaptureRequest> &request) {
3202    Mutex::Autolock al(mTriggerMutex);
3203
3204    CameraMetadata &metadata = request->mSettings;
3205
3206    /**
3207     * Replace all old entries with their old values.
3208     */
3209    for (size_t i = 0; i < mTriggerReplacedMap.size(); ++i) {
3210        RequestTrigger trigger = mTriggerReplacedMap.valueAt(i);
3211
3212        status_t res;
3213
3214        uint32_t tag = trigger.metadataTag;
3215        switch (trigger.getTagType()) {
3216            case TYPE_BYTE: {
3217                uint8_t entryValue = static_cast<uint8_t>(trigger.entryValue);
3218                res = metadata.update(tag,
3219                                      &entryValue,
3220                                      /*count*/1);
3221                break;
3222            }
3223            case TYPE_INT32:
3224                res = metadata.update(tag,
3225                                      &trigger.entryValue,
3226                                      /*count*/1);
3227                break;
3228            default:
3229                ALOGE("%s: Type not supported: 0x%x",
3230                      __FUNCTION__,
3231                      trigger.getTagType());
3232                return INVALID_OPERATION;
3233        }
3234
3235        if (res != OK) {
3236            ALOGE("%s: Failed to restore request metadata with trigger tag %s"
3237                  ", trigger value %d", __FUNCTION__,
3238                  trigger.getTagName(), trigger.entryValue);
3239            return res;
3240        }
3241    }
3242    mTriggerReplacedMap.clear();
3243
3244    /**
3245     * Remove all new entries.
3246     */
3247    for (size_t i = 0; i < mTriggerRemovedMap.size(); ++i) {
3248        RequestTrigger trigger = mTriggerRemovedMap.valueAt(i);
3249        status_t res = metadata.erase(trigger.metadataTag);
3250
3251        if (res != OK) {
3252            ALOGE("%s: Failed to erase metadata with trigger tag %s"
3253                  ", trigger value %d", __FUNCTION__,
3254                  trigger.getTagName(), trigger.entryValue);
3255            return res;
3256        }
3257    }
3258    mTriggerRemovedMap.clear();
3259
3260    return OK;
3261}
3262
3263status_t Camera3Device::RequestThread::addDummyTriggerIds(
3264        const sp<CaptureRequest> &request) {
3265    // Trigger ID 0 has special meaning in the HAL2 spec, so avoid it here
3266    static const int32_t dummyTriggerId = 1;
3267    status_t res;
3268
3269    CameraMetadata &metadata = request->mSettings;
3270
3271    // If AF trigger is active, insert a dummy AF trigger ID if none already
3272    // exists
3273    camera_metadata_entry afTrigger = metadata.find(ANDROID_CONTROL_AF_TRIGGER);
3274    camera_metadata_entry afId = metadata.find(ANDROID_CONTROL_AF_TRIGGER_ID);
3275    if (afTrigger.count > 0 &&
3276            afTrigger.data.u8[0] != ANDROID_CONTROL_AF_TRIGGER_IDLE &&
3277            afId.count == 0) {
3278        res = metadata.update(ANDROID_CONTROL_AF_TRIGGER_ID, &dummyTriggerId, 1);
3279        if (res != OK) return res;
3280    }
3281
3282    // If AE precapture trigger is active, insert a dummy precapture trigger ID
3283    // if none already exists
3284    camera_metadata_entry pcTrigger =
3285            metadata.find(ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER);
3286    camera_metadata_entry pcId = metadata.find(ANDROID_CONTROL_AE_PRECAPTURE_ID);
3287    if (pcTrigger.count > 0 &&
3288            pcTrigger.data.u8[0] != ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_IDLE &&
3289            pcId.count == 0) {
3290        res = metadata.update(ANDROID_CONTROL_AE_PRECAPTURE_ID,
3291                &dummyTriggerId, 1);
3292        if (res != OK) return res;
3293    }
3294
3295    return OK;
3296}
3297
3298/**
3299 * PreparerThread inner class methods
3300 */
3301
3302Camera3Device::PreparerThread::PreparerThread() :
3303        Thread(/*canCallJava*/false), mActive(false), mCancelNow(false) {
3304}
3305
3306Camera3Device::PreparerThread::~PreparerThread() {
3307    Thread::requestExitAndWait();
3308    if (mCurrentStream != nullptr) {
3309        mCurrentStream->cancelPrepare();
3310        ATRACE_ASYNC_END("stream prepare", mCurrentStream->getId());
3311        mCurrentStream.clear();
3312    }
3313    clear();
3314}
3315
3316status_t Camera3Device::PreparerThread::prepare(sp<Camera3StreamInterface>& stream) {
3317    status_t res;
3318
3319    Mutex::Autolock l(mLock);
3320
3321    res = stream->startPrepare();
3322    if (res == OK) {
3323        // No preparation needed, fire listener right off
3324        ALOGV("%s: Stream %d already prepared", __FUNCTION__, stream->getId());
3325        if (mListener) {
3326            mListener->notifyPrepared(stream->getId());
3327        }
3328        return OK;
3329    } else if (res != NOT_ENOUGH_DATA) {
3330        return res;
3331    }
3332
3333    // Need to prepare, start up thread if necessary
3334    if (!mActive) {
3335        // mRunning will change to false before the thread fully shuts down, so wait to be sure it
3336        // isn't running
3337        Thread::requestExitAndWait();
3338        res = Thread::run("C3PrepThread", PRIORITY_BACKGROUND);
3339        if (res != OK) {
3340            ALOGE("%s: Unable to start preparer stream: %d (%s)", __FUNCTION__, res, strerror(-res));
3341            if (mListener) {
3342                mListener->notifyPrepared(stream->getId());
3343            }
3344            return res;
3345        }
3346        mCancelNow = false;
3347        mActive = true;
3348        ALOGV("%s: Preparer stream started", __FUNCTION__);
3349    }
3350
3351    // queue up the work
3352    mPendingStreams.push_back(stream);
3353    ALOGV("%s: Stream %d queued for preparing", __FUNCTION__, stream->getId());
3354
3355    return OK;
3356}
3357
3358status_t Camera3Device::PreparerThread::clear() {
3359    status_t res;
3360
3361    Mutex::Autolock l(mLock);
3362
3363    for (const auto& stream : mPendingStreams) {
3364        stream->cancelPrepare();
3365    }
3366    mPendingStreams.clear();
3367    mCancelNow = true;
3368
3369    return OK;
3370}
3371
3372void Camera3Device::PreparerThread::setNotificationListener(NotificationListener *listener) {
3373    Mutex::Autolock l(mLock);
3374    mListener = listener;
3375}
3376
3377bool Camera3Device::PreparerThread::threadLoop() {
3378    status_t res;
3379    {
3380        Mutex::Autolock l(mLock);
3381        if (mCurrentStream == nullptr) {
3382            // End thread if done with work
3383            if (mPendingStreams.empty()) {
3384                ALOGV("%s: Preparer stream out of work", __FUNCTION__);
3385                // threadLoop _must not_ re-acquire mLock after it sets mActive to false; would
3386                // cause deadlock with prepare()'s requestExitAndWait triggered by !mActive.
3387                mActive = false;
3388                return false;
3389            }
3390
3391            // Get next stream to prepare
3392            auto it = mPendingStreams.begin();
3393            mCurrentStream = *it;
3394            mPendingStreams.erase(it);
3395            ATRACE_ASYNC_BEGIN("stream prepare", mCurrentStream->getId());
3396            ALOGV("%s: Preparing stream %d", __FUNCTION__, mCurrentStream->getId());
3397        } else if (mCancelNow) {
3398            mCurrentStream->cancelPrepare();
3399            ATRACE_ASYNC_END("stream prepare", mCurrentStream->getId());
3400            ALOGV("%s: Cancelling stream %d prepare", __FUNCTION__, mCurrentStream->getId());
3401            mCurrentStream.clear();
3402            mCancelNow = false;
3403            return true;
3404        }
3405    }
3406
3407    res = mCurrentStream->prepareNextBuffer();
3408    if (res == NOT_ENOUGH_DATA) return true;
3409    if (res != OK) {
3410        // Something bad happened; try to recover by cancelling prepare and
3411        // signalling listener anyway
3412        ALOGE("%s: Stream %d returned error %d (%s) during prepare", __FUNCTION__,
3413                mCurrentStream->getId(), res, strerror(-res));
3414        mCurrentStream->cancelPrepare();
3415    }
3416
3417    // This stream has finished, notify listener
3418    Mutex::Autolock l(mLock);
3419    if (mListener) {
3420        ALOGV("%s: Stream %d prepare done, signaling listener", __FUNCTION__,
3421                mCurrentStream->getId());
3422        mListener->notifyPrepared(mCurrentStream->getId());
3423    }
3424
3425    ATRACE_ASYNC_END("stream prepare", mCurrentStream->getId());
3426    mCurrentStream.clear();
3427
3428    return true;
3429}
3430
3431/**
3432 * Static callback forwarding methods from HAL to instance
3433 */
3434
3435void Camera3Device::sProcessCaptureResult(const camera3_callback_ops *cb,
3436        const camera3_capture_result *result) {
3437    Camera3Device *d =
3438            const_cast<Camera3Device*>(static_cast<const Camera3Device*>(cb));
3439    d->processCaptureResult(result);
3440}
3441
3442void Camera3Device::sNotify(const camera3_callback_ops *cb,
3443        const camera3_notify_msg *msg) {
3444    Camera3Device *d =
3445            const_cast<Camera3Device*>(static_cast<const Camera3Device*>(cb));
3446    d->notify(msg);
3447}
3448
3449}; // namespace android
3450