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