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