Eino-Ville Talvala | fd58f1a | 2013-03-06 16:20:06 -0800 | [diff] [blame] | 1 | /* |
Shuzhen Wang | c28189a | 2017-11-27 23:05:10 -0800 | [diff] [blame] | 2 | * Copyright (C) 2013-2018 The Android Open Source Project |
Eino-Ville Talvala | fd58f1a | 2013-03-06 16:20:06 -0800 | [diff] [blame] | 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 | #ifndef ANDROID_SERVERS_CAMERA3_OUTPUT_STREAM_H |
| 18 | #define ANDROID_SERVERS_CAMERA3_OUTPUT_STREAM_H |
| 19 | |
Yin-Chia Yeh | 14ef48d | 2020-02-10 15:06:37 -0800 | [diff] [blame] | 20 | #include <mutex> |
Eino-Ville Talvala | fd58f1a | 2013-03-06 16:20:06 -0800 | [diff] [blame] | 21 | #include <utils/RefBase.h> |
Zhijun He | 125684a | 2015-12-26 15:07:30 -0800 | [diff] [blame] | 22 | #include <gui/IProducerListener.h> |
Eino-Ville Talvala | fd58f1a | 2013-03-06 16:20:06 -0800 | [diff] [blame] | 23 | #include <gui/Surface.h> |
Shuzhen Wang | 00abbeb | 2022-02-25 17:14:42 -0800 | [diff] [blame^] | 24 | #include <gui/DisplayEventReceiver.h> |
Eino-Ville Talvala | fd58f1a | 2013-03-06 16:20:06 -0800 | [diff] [blame] | 25 | |
Shuzhen Wang | 686f644 | 2017-06-20 16:16:04 -0700 | [diff] [blame] | 26 | #include "utils/LatencyHistogram.h" |
Eino-Ville Talvala | fd58f1a | 2013-03-06 16:20:06 -0800 | [diff] [blame] | 27 | #include "Camera3Stream.h" |
Igor Murashkin | e3a9f96 | 2013-05-08 18:03:15 -0700 | [diff] [blame] | 28 | #include "Camera3IOStreamBase.h" |
Igor Murashkin | 2fba584 | 2013-04-22 14:03:54 -0700 | [diff] [blame] | 29 | #include "Camera3OutputStreamInterface.h" |
Zhijun He | 125684a | 2015-12-26 15:07:30 -0800 | [diff] [blame] | 30 | #include "Camera3BufferManager.h" |
Eino-Ville Talvala | fd58f1a | 2013-03-06 16:20:06 -0800 | [diff] [blame] | 31 | |
| 32 | namespace android { |
| 33 | |
| 34 | namespace camera3 { |
| 35 | |
Zhijun He | 125684a | 2015-12-26 15:07:30 -0800 | [diff] [blame] | 36 | class Camera3BufferManager; |
| 37 | |
| 38 | /** |
| 39 | * Stream info structure that holds the necessary stream info for buffer manager to use for |
| 40 | * buffer allocation and management. |
| 41 | */ |
| 42 | struct StreamInfo { |
| 43 | int streamId; |
| 44 | int streamSetId; |
| 45 | uint32_t width; |
| 46 | uint32_t height; |
| 47 | uint32_t format; |
| 48 | android_dataspace dataSpace; |
Emilian Peev | 050f5dc | 2017-05-18 14:43:56 +0100 | [diff] [blame] | 49 | uint64_t combinedUsage; |
Zhijun He | 125684a | 2015-12-26 15:07:30 -0800 | [diff] [blame] | 50 | size_t totalBufferCount; |
| 51 | bool isConfigured; |
Shuzhen Wang | 83bff12 | 2020-11-20 15:51:39 -0800 | [diff] [blame] | 52 | bool isMultiRes; |
Chih-Hung Hsieh | d19d994 | 2016-08-29 14:21:14 -0700 | [diff] [blame] | 53 | explicit StreamInfo(int id = CAMERA3_STREAM_ID_INVALID, |
Zhijun He | 125684a | 2015-12-26 15:07:30 -0800 | [diff] [blame] | 54 | int setId = CAMERA3_STREAM_SET_ID_INVALID, |
| 55 | uint32_t w = 0, |
| 56 | uint32_t h = 0, |
| 57 | uint32_t fmt = 0, |
| 58 | android_dataspace ds = HAL_DATASPACE_UNKNOWN, |
Emilian Peev | 050f5dc | 2017-05-18 14:43:56 +0100 | [diff] [blame] | 59 | uint64_t usage = 0, |
Zhijun He | 125684a | 2015-12-26 15:07:30 -0800 | [diff] [blame] | 60 | size_t bufferCount = 0, |
Shuzhen Wang | 83bff12 | 2020-11-20 15:51:39 -0800 | [diff] [blame] | 61 | bool configured = false, |
| 62 | bool multiRes = false) : |
Zhijun He | 125684a | 2015-12-26 15:07:30 -0800 | [diff] [blame] | 63 | streamId(id), |
| 64 | streamSetId(setId), |
| 65 | width(w), |
| 66 | height(h), |
| 67 | format(fmt), |
| 68 | dataSpace(ds), |
| 69 | combinedUsage(usage), |
| 70 | totalBufferCount(bufferCount), |
Shuzhen Wang | 83bff12 | 2020-11-20 15:51:39 -0800 | [diff] [blame] | 71 | isConfigured(configured), |
| 72 | isMultiRes(multiRes) {} |
Zhijun He | 125684a | 2015-12-26 15:07:30 -0800 | [diff] [blame] | 73 | }; |
| 74 | |
Eino-Ville Talvala | fd58f1a | 2013-03-06 16:20:06 -0800 | [diff] [blame] | 75 | /** |
| 76 | * A class for managing a single stream of output data from the camera device. |
| 77 | */ |
Igor Murashkin | 2fba584 | 2013-04-22 14:03:54 -0700 | [diff] [blame] | 78 | class Camera3OutputStream : |
Igor Murashkin | e3a9f96 | 2013-05-08 18:03:15 -0700 | [diff] [blame] | 79 | public Camera3IOStreamBase, |
Igor Murashkin | 2fba584 | 2013-04-22 14:03:54 -0700 | [diff] [blame] | 80 | public Camera3OutputStreamInterface { |
Eino-Ville Talvala | fd58f1a | 2013-03-06 16:20:06 -0800 | [diff] [blame] | 81 | public: |
| 82 | /** |
| 83 | * Set up a stream for formats that have 2 dimensions, such as RAW and YUV. |
Zhijun He | 125684a | 2015-12-26 15:07:30 -0800 | [diff] [blame] | 84 | * A valid stream set id needs to be set to support buffer sharing between multiple |
| 85 | * streams. |
Eino-Ville Talvala | fd58f1a | 2013-03-06 16:20:06 -0800 | [diff] [blame] | 86 | */ |
Eino-Ville Talvala | 727d172 | 2015-06-09 13:44:19 -0700 | [diff] [blame] | 87 | Camera3OutputStream(int id, sp<Surface> consumer, |
Eino-Ville Talvala | 3d82c0d | 2015-02-23 15:19:19 -0800 | [diff] [blame] | 88 | uint32_t width, uint32_t height, int format, |
Emilian Peev | f481670 | 2020-04-03 15:44:51 -0700 | [diff] [blame] | 89 | android_dataspace dataSpace, camera_stream_rotation_t rotation, |
Shuzhen Wang | c28189a | 2017-11-27 23:05:10 -0800 | [diff] [blame] | 90 | nsecs_t timestampOffset, const String8& physicalCameraId, |
Jayant Chowdhary | 13f9b2f | 2020-12-02 22:46:15 -0800 | [diff] [blame] | 91 | const std::unordered_set<int32_t> &sensorPixelModesUsed, |
Emilian Peev | 2295df7 | 2021-11-12 18:14:10 -0800 | [diff] [blame] | 92 | int setId = CAMERA3_STREAM_SET_ID_INVALID, bool isMultiResolution = false, |
Emilian Peev | c81a759 | 2022-02-14 17:38:18 -0800 | [diff] [blame] | 93 | int64_t dynamicProfile = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD, |
Shuzhen Wang | 8ed1e87 | 2022-03-08 16:34:33 -0800 | [diff] [blame] | 94 | int64_t streamUseCase = ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_DEFAULT, |
Shuzhen Wang | e420892 | 2022-02-01 16:52:48 -0800 | [diff] [blame] | 95 | bool deviceTimeBaseIsRealtime = false, |
Shuzhen Wang | 610d7b8 | 2022-02-08 14:37:22 -0800 | [diff] [blame] | 96 | int timestampBase = OutputConfiguration::TIMESTAMP_BASE_DEFAULT, |
| 97 | int mirrorMode = OutputConfiguration::MIRROR_MODE_AUTO); |
Eino-Ville Talvala | fd58f1a | 2013-03-06 16:20:06 -0800 | [diff] [blame] | 98 | /** |
| 99 | * Set up a stream for formats that have a variable buffer size for the same |
| 100 | * dimensions, such as compressed JPEG. |
Zhijun He | 125684a | 2015-12-26 15:07:30 -0800 | [diff] [blame] | 101 | * A valid stream set id needs to be set to support buffer sharing between multiple |
| 102 | * streams. |
Eino-Ville Talvala | fd58f1a | 2013-03-06 16:20:06 -0800 | [diff] [blame] | 103 | */ |
Eino-Ville Talvala | 727d172 | 2015-06-09 13:44:19 -0700 | [diff] [blame] | 104 | Camera3OutputStream(int id, sp<Surface> consumer, |
Eino-Ville Talvala | 3d82c0d | 2015-02-23 15:19:19 -0800 | [diff] [blame] | 105 | uint32_t width, uint32_t height, size_t maxSize, int format, |
Emilian Peev | f481670 | 2020-04-03 15:44:51 -0700 | [diff] [blame] | 106 | android_dataspace dataSpace, camera_stream_rotation_t rotation, |
Shuzhen Wang | c28189a | 2017-11-27 23:05:10 -0800 | [diff] [blame] | 107 | nsecs_t timestampOffset, const String8& physicalCameraId, |
Jayant Chowdhary | 13f9b2f | 2020-12-02 22:46:15 -0800 | [diff] [blame] | 108 | const std::unordered_set<int32_t> &sensorPixelModesUsed, |
Emilian Peev | 2295df7 | 2021-11-12 18:14:10 -0800 | [diff] [blame] | 109 | int setId = CAMERA3_STREAM_SET_ID_INVALID, bool isMultiResolution = false, |
Emilian Peev | c81a759 | 2022-02-14 17:38:18 -0800 | [diff] [blame] | 110 | int64_t dynamicProfile = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD, |
Shuzhen Wang | 8ed1e87 | 2022-03-08 16:34:33 -0800 | [diff] [blame] | 111 | int64_t streamUseCase = ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_DEFAULT, |
Shuzhen Wang | e420892 | 2022-02-01 16:52:48 -0800 | [diff] [blame] | 112 | bool deviceTimeBaseIsRealtime = false, |
Shuzhen Wang | 610d7b8 | 2022-02-08 14:37:22 -0800 | [diff] [blame] | 113 | int timestampBase = OutputConfiguration::TIMESTAMP_BASE_DEFAULT, |
| 114 | int mirrorMode = OutputConfiguration::MIRROR_MODE_AUTO); |
Zhijun He | 5d677d1 | 2016-05-29 16:52:39 -0700 | [diff] [blame] | 115 | /** |
| 116 | * Set up a stream with deferred consumer for formats that have 2 dimensions, such as |
| 117 | * RAW and YUV. The consumer must be set before using this stream for output. A valid |
| 118 | * stream set id needs to be set to support buffer sharing between multiple streams. |
| 119 | */ |
| 120 | Camera3OutputStream(int id, uint32_t width, uint32_t height, int format, |
Emilian Peev | 050f5dc | 2017-05-18 14:43:56 +0100 | [diff] [blame] | 121 | uint64_t consumerUsage, android_dataspace dataSpace, |
Emilian Peev | f481670 | 2020-04-03 15:44:51 -0700 | [diff] [blame] | 122 | camera_stream_rotation_t rotation, nsecs_t timestampOffset, |
Shuzhen Wang | c28189a | 2017-11-27 23:05:10 -0800 | [diff] [blame] | 123 | const String8& physicalCameraId, |
Jayant Chowdhary | 13f9b2f | 2020-12-02 22:46:15 -0800 | [diff] [blame] | 124 | const std::unordered_set<int32_t> &sensorPixelModesUsed, |
Emilian Peev | 2295df7 | 2021-11-12 18:14:10 -0800 | [diff] [blame] | 125 | int setId = CAMERA3_STREAM_SET_ID_INVALID, bool isMultiResolution = false, |
Emilian Peev | c81a759 | 2022-02-14 17:38:18 -0800 | [diff] [blame] | 126 | int64_t dynamicProfile = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD, |
Shuzhen Wang | 8ed1e87 | 2022-03-08 16:34:33 -0800 | [diff] [blame] | 127 | int64_t streamUseCase = ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_DEFAULT, |
Shuzhen Wang | e420892 | 2022-02-01 16:52:48 -0800 | [diff] [blame] | 128 | bool deviceTimeBaseIsRealtime = false, |
Shuzhen Wang | 610d7b8 | 2022-02-08 14:37:22 -0800 | [diff] [blame] | 129 | int timestampBase = OutputConfiguration::TIMESTAMP_BASE_DEFAULT, |
| 130 | int mirrorMode = OutputConfiguration::MIRROR_MODE_AUTO); |
Zhijun He | 5d677d1 | 2016-05-29 16:52:39 -0700 | [diff] [blame] | 131 | |
Eino-Ville Talvala | fd58f1a | 2013-03-06 16:20:06 -0800 | [diff] [blame] | 132 | virtual ~Camera3OutputStream(); |
| 133 | |
| 134 | /** |
| 135 | * Camera3Stream interface |
| 136 | */ |
| 137 | |
Eino-Ville Talvala | fd58f1a | 2013-03-06 16:20:06 -0800 | [diff] [blame] | 138 | virtual void dump(int fd, const Vector<String16> &args) const; |
| 139 | |
| 140 | /** |
| 141 | * Set the transform on the output stream; one of the |
| 142 | * HAL_TRANSFORM_* / NATIVE_WINDOW_TRANSFORM_* constants. |
| 143 | */ |
Shuzhen Wang | 610d7b8 | 2022-02-08 14:37:22 -0800 | [diff] [blame] | 144 | status_t setTransform(int transform, bool mayChangeMirror); |
Eino-Ville Talvala | fd58f1a | 2013-03-06 16:20:06 -0800 | [diff] [blame] | 145 | |
Chien-Yu Chen | 85a6455 | 2015-08-28 15:46:12 -0700 | [diff] [blame] | 146 | /** |
| 147 | * Return if this output stream is for video encoding. |
| 148 | */ |
| 149 | bool isVideoStream() const; |
Shuzhen Wang | 13a6963 | 2016-01-26 09:51:07 -0800 | [diff] [blame] | 150 | /** |
| 151 | * Return if this output stream is consumed by hardware composer. |
| 152 | */ |
| 153 | bool isConsumedByHWComposer() const; |
Chien-Yu Chen | 85a6455 | 2015-08-28 15:46:12 -0700 | [diff] [blame] | 154 | |
Zhijun He | 5d677d1 | 2016-05-29 16:52:39 -0700 | [diff] [blame] | 155 | /** |
Zhijun He | f0645c1 | 2016-08-02 00:58:11 -0700 | [diff] [blame] | 156 | * Return if this output stream is consumed by hardware texture. |
| 157 | */ |
| 158 | bool isConsumedByHWTexture() const; |
| 159 | |
| 160 | /** |
Zhijun He | 5d677d1 | 2016-05-29 16:52:39 -0700 | [diff] [blame] | 161 | * Return if the consumer configuration of this stream is deferred. |
| 162 | */ |
Shuzhen Wang | 0129d52 | 2016-10-30 22:43:41 -0700 | [diff] [blame] | 163 | virtual bool isConsumerConfigurationDeferred(size_t surface_id) const; |
Zhijun He | 5d677d1 | 2016-05-29 16:52:39 -0700 | [diff] [blame] | 164 | |
| 165 | /** |
Shuzhen Wang | 758c215 | 2017-01-10 18:26:18 -0800 | [diff] [blame] | 166 | * Set the consumer surfaces to the output stream. |
Zhijun He | 5d677d1 | 2016-05-29 16:52:39 -0700 | [diff] [blame] | 167 | */ |
Shuzhen Wang | 758c215 | 2017-01-10 18:26:18 -0800 | [diff] [blame] | 168 | virtual status_t setConsumers(const std::vector<sp<Surface>>& consumers); |
Zhijun He | 5d677d1 | 2016-05-29 16:52:39 -0700 | [diff] [blame] | 169 | |
Shuzhen Wang | 0160ddd | 2019-08-15 09:11:56 -0700 | [diff] [blame] | 170 | class BufferProducerListener : public SurfaceListener { |
Zhijun He | 125684a | 2015-12-26 15:07:30 -0800 | [diff] [blame] | 171 | public: |
Shuzhen Wang | 0160ddd | 2019-08-15 09:11:56 -0700 | [diff] [blame] | 172 | BufferProducerListener(wp<Camera3OutputStream> parent, bool needsReleaseNotify) |
| 173 | : mParent(parent), mNeedsReleaseNotify(needsReleaseNotify) {} |
Zhijun He | 125684a | 2015-12-26 15:07:30 -0800 | [diff] [blame] | 174 | |
Shuzhen Wang | 0160ddd | 2019-08-15 09:11:56 -0700 | [diff] [blame] | 175 | /** |
| 176 | * Implementation of IProducerListener, used to notify this stream that the consumer |
| 177 | * has returned a buffer and it is ready to return to Camera3BufferManager for reuse. |
| 178 | */ |
| 179 | virtual void onBufferReleased(); |
| 180 | virtual bool needsReleaseNotify() { return mNeedsReleaseNotify; } |
| 181 | virtual void onBuffersDiscarded(const std::vector<sp<GraphicBuffer>>& buffers); |
Zhijun He | 125684a | 2015-12-26 15:07:30 -0800 | [diff] [blame] | 182 | |
| 183 | private: |
Shuzhen Wang | 0160ddd | 2019-08-15 09:11:56 -0700 | [diff] [blame] | 184 | wp<Camera3OutputStream> mParent; |
| 185 | bool mNeedsReleaseNotify; |
Zhijun He | 125684a | 2015-12-26 15:07:30 -0800 | [diff] [blame] | 186 | }; |
| 187 | |
Eino-Ville Talvala | 77c1a35 | 2016-06-13 12:32:43 -0700 | [diff] [blame] | 188 | virtual status_t detachBuffer(sp<GraphicBuffer>* buffer, int* fenceFd); |
| 189 | |
Shuzhen Wang | bee0f0a | 2017-01-24 14:51:37 -0800 | [diff] [blame] | 190 | /** |
| 191 | * Notify that the buffer is being released to the buffer queue instead of |
| 192 | * being queued to the consumer. |
| 193 | */ |
| 194 | virtual status_t notifyBufferReleased(ANativeWindowBuffer *anwBuffer); |
Shuzhen Wang | 0129d52 | 2016-10-30 22:43:41 -0700 | [diff] [blame] | 195 | |
Zhijun He | 125684a | 2015-12-26 15:07:30 -0800 | [diff] [blame] | 196 | /** |
Chien-Yu Chen | a936ac2 | 2017-10-23 15:59:49 -0700 | [diff] [blame] | 197 | * Drop buffers if dropping is true. If dropping is false, do not drop buffers. |
| 198 | */ |
| 199 | virtual status_t dropBuffers(bool dropping) override; |
| 200 | |
| 201 | /** |
Shuzhen Wang | 5c22c15 | 2017-12-31 17:12:25 -0800 | [diff] [blame] | 202 | * Query the physical camera id for the output stream. |
| 203 | */ |
| 204 | virtual const String8& getPhysicalCameraId() const override; |
| 205 | |
| 206 | /** |
Zhijun He | 125684a | 2015-12-26 15:07:30 -0800 | [diff] [blame] | 207 | * Set the graphic buffer manager to get/return the stream buffers. |
| 208 | * |
| 209 | * It is only legal to call this method when stream is in STATE_CONSTRUCTED state. |
| 210 | */ |
| 211 | status_t setBufferManager(sp<Camera3BufferManager> bufferManager); |
| 212 | |
Emilian Peev | 40ead60 | 2017-09-26 15:46:36 +0100 | [diff] [blame] | 213 | /** |
| 214 | * Query the ouput surface id. |
| 215 | */ |
| 216 | virtual ssize_t getSurfaceId(const sp<Surface> &/*surface*/) { return 0; } |
| 217 | |
Yin-Chia Yeh | 58b1b4e | 2018-10-15 12:18:36 -0700 | [diff] [blame] | 218 | virtual status_t getUniqueSurfaceIds(const std::vector<size_t>&, |
| 219 | /*out*/std::vector<size_t>*) { return INVALID_OPERATION; }; |
| 220 | |
Emilian Peev | 40ead60 | 2017-09-26 15:46:36 +0100 | [diff] [blame] | 221 | /** |
| 222 | * Update the stream output surfaces. |
| 223 | */ |
| 224 | virtual status_t updateStream(const std::vector<sp<Surface>> &outputSurfaces, |
| 225 | const std::vector<OutputStreamInfo> &outputInfo, |
| 226 | const std::vector<size_t> &removedSurfaceIds, |
| 227 | KeyedVector<sp<Surface>, size_t> *outputMap/*out*/); |
| 228 | |
Emilian Peev | 35ae826 | 2018-11-08 13:11:32 +0000 | [diff] [blame] | 229 | /** |
Yin-Chia Yeh | 14ef48d | 2020-02-10 15:06:37 -0800 | [diff] [blame] | 230 | * Set the batch size for buffer operations. The output stream will request |
| 231 | * buffers from buffer queue on a batch basis. Currently only video streams |
| 232 | * are allowed to set the batch size. Also if the stream is managed by |
| 233 | * buffer manager (Surface group in Java API) then batching is also not |
| 234 | * supported. Changing batch size on the fly while there is already batched |
| 235 | * buffers in the stream is also not supported. |
| 236 | * If the batch size is larger than the max dequeue count set |
| 237 | * by the camera HAL, the batch size will be set to the max dequeue count |
| 238 | * instead. |
| 239 | */ |
| 240 | virtual status_t setBatchSize(size_t batchSize = 1) override; |
| 241 | |
| 242 | /** |
Shuzhen Wang | 00abbeb | 2022-02-25 17:14:42 -0800 | [diff] [blame^] | 243 | * Notify the stream on change of min frame durations. |
| 244 | */ |
| 245 | virtual void onMinDurationChanged(nsecs_t duration) override; |
| 246 | |
| 247 | /** |
Emilian Peev | 35ae826 | 2018-11-08 13:11:32 +0000 | [diff] [blame] | 248 | * Apply ZSL related consumer usage quirk. |
| 249 | */ |
| 250 | static void applyZSLUsageQuirk(int format, uint64_t *consumerUsage /*inout*/); |
| 251 | |
Shuzhen Wang | abbcb6b | 2020-12-09 22:32:44 -0800 | [diff] [blame] | 252 | void setImageDumpMask(int mask) { mImageDumpMask = mask; } |
| 253 | |
Igor Murashkin | e3a9f96 | 2013-05-08 18:03:15 -0700 | [diff] [blame] | 254 | protected: |
Emilian Peev | f481670 | 2020-04-03 15:44:51 -0700 | [diff] [blame] | 255 | Camera3OutputStream(int id, camera_stream_type_t type, |
Eino-Ville Talvala | 3d82c0d | 2015-02-23 15:19:19 -0800 | [diff] [blame] | 256 | uint32_t width, uint32_t height, int format, |
Emilian Peev | f481670 | 2020-04-03 15:44:51 -0700 | [diff] [blame] | 257 | android_dataspace dataSpace, camera_stream_rotation_t rotation, |
Shuzhen Wang | c28189a | 2017-11-27 23:05:10 -0800 | [diff] [blame] | 258 | const String8& physicalCameraId, |
Jayant Chowdhary | 13f9b2f | 2020-12-02 22:46:15 -0800 | [diff] [blame] | 259 | const std::unordered_set<int32_t> &sensorPixelModesUsed, |
Emilian Peev | 050f5dc | 2017-05-18 14:43:56 +0100 | [diff] [blame] | 260 | uint64_t consumerUsage = 0, nsecs_t timestampOffset = 0, |
Emilian Peev | 2295df7 | 2021-11-12 18:14:10 -0800 | [diff] [blame] | 261 | int setId = CAMERA3_STREAM_SET_ID_INVALID, bool isMultiResolution = false, |
Emilian Peev | c81a759 | 2022-02-14 17:38:18 -0800 | [diff] [blame] | 262 | int64_t dynamicProfile = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD, |
Shuzhen Wang | 8ed1e87 | 2022-03-08 16:34:33 -0800 | [diff] [blame] | 263 | int64_t streamUseCase = ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_DEFAULT, |
Shuzhen Wang | e420892 | 2022-02-01 16:52:48 -0800 | [diff] [blame] | 264 | bool deviceTimeBaseIsRealtime = false, |
Shuzhen Wang | 610d7b8 | 2022-02-08 14:37:22 -0800 | [diff] [blame] | 265 | int timestampBase = OutputConfiguration::TIMESTAMP_BASE_DEFAULT, |
| 266 | int mirrorMode = OutputConfiguration::MIRROR_MODE_AUTO); |
Igor Murashkin | e3a9f96 | 2013-05-08 18:03:15 -0700 | [diff] [blame] | 267 | |
Zhijun He | 124ccf4 | 2013-05-22 14:01:30 -0700 | [diff] [blame] | 268 | /** |
| 269 | * Note that we release the lock briefly in this function |
| 270 | */ |
Igor Murashkin | e3a9f96 | 2013-05-08 18:03:15 -0700 | [diff] [blame] | 271 | virtual status_t returnBufferCheckedLocked( |
Emilian Peev | f481670 | 2020-04-03 15:44:51 -0700 | [diff] [blame] | 272 | const camera_stream_buffer &buffer, |
Igor Murashkin | e3a9f96 | 2013-05-08 18:03:15 -0700 | [diff] [blame] | 273 | nsecs_t timestamp, |
Shuzhen Wang | 90708ea | 2021-11-04 11:40:49 -0700 | [diff] [blame] | 274 | nsecs_t readoutTimestamp, |
Igor Murashkin | e3a9f96 | 2013-05-08 18:03:15 -0700 | [diff] [blame] | 275 | bool output, |
Emilian Peev | 5104fe9 | 2021-10-21 14:27:09 -0700 | [diff] [blame] | 276 | int32_t transform, |
Yin-Chia Yeh | 58b1b4e | 2018-10-15 12:18:36 -0700 | [diff] [blame] | 277 | const std::vector<size_t>& surface_ids, |
Igor Murashkin | e3a9f96 | 2013-05-08 18:03:15 -0700 | [diff] [blame] | 278 | /*out*/ |
| 279 | sp<Fence> *releaseFenceOut); |
| 280 | |
Zhijun He | 0a21051 | 2014-07-24 13:45:15 -0700 | [diff] [blame] | 281 | virtual status_t disconnectLocked(); |
| 282 | |
Emilian Peev | 050f5dc | 2017-05-18 14:43:56 +0100 | [diff] [blame] | 283 | status_t getEndpointUsageForSurface(uint64_t *usage, |
Shuzhen Wang | 0129d52 | 2016-10-30 22:43:41 -0700 | [diff] [blame] | 284 | const sp<Surface>& surface) const; |
Shuzhen Wang | 00abbeb | 2022-02-25 17:14:42 -0800 | [diff] [blame^] | 285 | status_t configureConsumerQueueLocked(bool allowDisplaySync); |
Shuzhen Wang | 0129d52 | 2016-10-30 22:43:41 -0700 | [diff] [blame] | 286 | |
| 287 | // Consumer as the output of camera HAL |
Eino-Ville Talvala | 727d172 | 2015-06-09 13:44:19 -0700 | [diff] [blame] | 288 | sp<Surface> mConsumer; |
Zhijun He | 5d677d1 | 2016-05-29 16:52:39 -0700 | [diff] [blame] | 289 | |
Emilian Peev | 050f5dc | 2017-05-18 14:43:56 +0100 | [diff] [blame] | 290 | uint64_t getPresetConsumerUsage() const { return mConsumerUsage; } |
Zhijun He | f0645c1 | 2016-08-02 00:58:11 -0700 | [diff] [blame] | 291 | |
| 292 | static const nsecs_t kDequeueBufferTimeout = 1000000000; // 1 sec |
| 293 | |
Shuzhen Wang | bee0f0a | 2017-01-24 14:51:37 -0800 | [diff] [blame] | 294 | status_t getBufferLockedCommon(ANativeWindowBuffer** anb, int* fenceFd); |
| 295 | |
| 296 | |
Shuzhen Wang | 0129d52 | 2016-10-30 22:43:41 -0700 | [diff] [blame] | 297 | private: |
| 298 | |
Eino-Ville Talvala | fd58f1a | 2013-03-06 16:20:06 -0800 | [diff] [blame] | 299 | int mTransform; |
Eino-Ville Talvala | fd58f1a | 2013-03-06 16:20:06 -0800 | [diff] [blame] | 300 | |
Igor Murashkin | e3a9f96 | 2013-05-08 18:03:15 -0700 | [diff] [blame] | 301 | virtual status_t setTransformLocked(int transform); |
Eino-Ville Talvala | fd58f1a | 2013-03-06 16:20:06 -0800 | [diff] [blame] | 302 | |
Ruchit Sharma | e0711f2 | 2014-08-18 13:48:24 -0400 | [diff] [blame] | 303 | bool mTraceFirstBuffer; |
| 304 | |
Eino-Ville Talvala | 727d172 | 2015-06-09 13:44:19 -0700 | [diff] [blame] | 305 | // Name of Surface consumer |
| 306 | String8 mConsumerName; |
| 307 | |
Eino-Ville Talvala | fd58f1a | 2013-03-06 16:20:06 -0800 | [diff] [blame] | 308 | /** |
Zhijun He | 125684a | 2015-12-26 15:07:30 -0800 | [diff] [blame] | 309 | * GraphicBuffer manager this stream is registered to. Used to replace the buffer |
| 310 | * allocation/deallocation role of BufferQueue. |
| 311 | */ |
| 312 | sp<Camera3BufferManager> mBufferManager; |
| 313 | |
| 314 | /** |
Shuzhen Wang | 0160ddd | 2019-08-15 09:11:56 -0700 | [diff] [blame] | 315 | * Buffer producer listener, used to handle notification when a buffer is released |
| 316 | * from consumer side, or a set of buffers are discarded by the consumer. |
Zhijun He | 125684a | 2015-12-26 15:07:30 -0800 | [diff] [blame] | 317 | */ |
Shuzhen Wang | 0160ddd | 2019-08-15 09:11:56 -0700 | [diff] [blame] | 318 | sp<BufferProducerListener> mBufferProducerListener; |
Zhijun He | 125684a | 2015-12-26 15:07:30 -0800 | [diff] [blame] | 319 | |
| 320 | /** |
| 321 | * Flag indicating if the buffer manager is used to allocate the stream buffers |
| 322 | */ |
| 323 | bool mUseBufferManager; |
Shuzhen Wang | c28dccc | 2016-02-11 23:48:46 -0800 | [diff] [blame] | 324 | |
| 325 | /** |
Shuzhen Wang | e420892 | 2022-02-01 16:52:48 -0800 | [diff] [blame] | 326 | * Offset used to override camera HAL produced timestamps |
| 327 | * |
| 328 | * The offset is first initialized to bootTime - monotonicTime in |
| 329 | * constructor, and may later be updated based on the client's timestampBase |
| 330 | * setting. |
Shuzhen Wang | c28dccc | 2016-02-11 23:48:46 -0800 | [diff] [blame] | 331 | */ |
| 332 | nsecs_t mTimestampOffset; |
| 333 | |
Zhijun He | 125684a | 2015-12-26 15:07:30 -0800 | [diff] [blame] | 334 | /** |
Zhijun He | 5d677d1 | 2016-05-29 16:52:39 -0700 | [diff] [blame] | 335 | * Consumer end point usage flag set by the constructor for the deferred |
| 336 | * consumer case. |
| 337 | */ |
Emilian Peev | 050f5dc | 2017-05-18 14:43:56 +0100 | [diff] [blame] | 338 | uint64_t mConsumerUsage; |
Zhijun He | 5d677d1 | 2016-05-29 16:52:39 -0700 | [diff] [blame] | 339 | |
Chien-Yu Chen | a936ac2 | 2017-10-23 15:59:49 -0700 | [diff] [blame] | 340 | // Whether to drop valid buffers. |
| 341 | bool mDropBuffers; |
| 342 | |
Yin-Chia Yeh | 14ef48d | 2020-02-10 15:06:37 -0800 | [diff] [blame] | 343 | |
Yin-Chia Yeh | 14ef48d | 2020-02-10 15:06:37 -0800 | [diff] [blame] | 344 | |
| 345 | // The batch size for buffer operation |
Shuzhen Wang | c762946 | 2021-07-12 15:02:58 -0700 | [diff] [blame] | 346 | std::atomic_size_t mBatchSize = 1; |
Yin-Chia Yeh | 14ef48d | 2020-02-10 15:06:37 -0800 | [diff] [blame] | 347 | |
Shuzhen Wang | c762946 | 2021-07-12 15:02:58 -0700 | [diff] [blame] | 348 | // Protecting batch states below, must be acquired after mLock |
| 349 | std::mutex mBatchLock; |
Yin-Chia Yeh | 14ef48d | 2020-02-10 15:06:37 -0800 | [diff] [blame] | 350 | // Prefetched buffers (ready to be handed to client) |
| 351 | std::vector<Surface::BatchBuffer> mBatchedBuffers; |
Yin-Chia Yeh | 14ef48d | 2020-02-10 15:06:37 -0800 | [diff] [blame] | 352 | // ---- End of mBatchLock protected scope ---- |
| 353 | |
Shuzhen Wang | 610d7b8 | 2022-02-08 14:37:22 -0800 | [diff] [blame] | 354 | const int mMirrorMode; |
| 355 | |
Zhijun He | 5d677d1 | 2016-05-29 16:52:39 -0700 | [diff] [blame] | 356 | /** |
Eino-Ville Talvala | fd58f1a | 2013-03-06 16:20:06 -0800 | [diff] [blame] | 357 | * Internal Camera3Stream interface |
| 358 | */ |
Emilian Peev | f481670 | 2020-04-03 15:44:51 -0700 | [diff] [blame] | 359 | virtual status_t getBufferLocked(camera_stream_buffer *buffer, |
Shuzhen Wang | bee0f0a | 2017-01-24 14:51:37 -0800 | [diff] [blame] | 360 | const std::vector<size_t>& surface_ids); |
| 361 | |
Yin-Chia Yeh | 14ef48d | 2020-02-10 15:06:37 -0800 | [diff] [blame] | 362 | virtual status_t getBuffersLocked(/*out*/std::vector<OutstandingBuffer>* buffers) override; |
| 363 | |
Eino-Ville Talvala | fd58f1a | 2013-03-06 16:20:06 -0800 | [diff] [blame] | 364 | virtual status_t returnBufferLocked( |
Emilian Peev | f481670 | 2020-04-03 15:44:51 -0700 | [diff] [blame] | 365 | const camera_stream_buffer &buffer, |
Shuzhen Wang | 90708ea | 2021-11-04 11:40:49 -0700 | [diff] [blame] | 366 | nsecs_t timestamp, nsecs_t readoutTimestamp, |
| 367 | int32_t transform, const std::vector<size_t>& surface_ids); |
Eino-Ville Talvala | fd58f1a | 2013-03-06 16:20:06 -0800 | [diff] [blame] | 368 | |
Shuzhen Wang | bee0f0a | 2017-01-24 14:51:37 -0800 | [diff] [blame] | 369 | virtual status_t queueBufferToConsumer(sp<ANativeWindow>& consumer, |
Yin-Chia Yeh | 58b1b4e | 2018-10-15 12:18:36 -0700 | [diff] [blame] | 370 | ANativeWindowBuffer* buffer, int anwReleaseFence, |
| 371 | const std::vector<size_t>& surface_ids); |
Shuzhen Wang | bee0f0a | 2017-01-24 14:51:37 -0800 | [diff] [blame] | 372 | |
Eino-Ville Talvala | fd58f1a | 2013-03-06 16:20:06 -0800 | [diff] [blame] | 373 | virtual status_t configureQueueLocked(); |
Eino-Ville Talvala | b2f5b19 | 2013-07-30 14:36:03 -0700 | [diff] [blame] | 374 | |
Emilian Peev | 050f5dc | 2017-05-18 14:43:56 +0100 | [diff] [blame] | 375 | virtual status_t getEndpointUsage(uint64_t *usage) const; |
Eino-Ville Talvala | b2f5b19 | 2013-07-30 14:36:03 -0700 | [diff] [blame] | 376 | |
Yin-Chia Yeh | 89954d9 | 2017-05-21 17:28:53 -0700 | [diff] [blame] | 377 | /** |
| 378 | * Private methods |
| 379 | */ |
Yin-Chia Yeh | 017d49c | 2017-03-31 19:11:00 -0700 | [diff] [blame] | 380 | void onBuffersRemovedLocked(const std::vector<sp<GraphicBuffer>>&); |
Yin-Chia Yeh | 89954d9 | 2017-05-21 17:28:53 -0700 | [diff] [blame] | 381 | status_t detachBufferLocked(sp<GraphicBuffer>* buffer, int* fenceFd); |
Yin-Chia Yeh | bf1b8b9 | 2019-03-06 14:56:08 -0800 | [diff] [blame] | 382 | // Call this after each dequeueBuffer/attachBuffer/detachNextBuffer call to get update on |
| 383 | // removed buffers. Set notifyBufferManager to false when the call is initiated by buffer |
| 384 | // manager so buffer manager doesn't need to be notified. |
| 385 | void checkRemovedBuffersLocked(bool notifyBufferManager = true); |
| 386 | |
| 387 | // Check return status of IGBP calls and set abandoned state accordingly |
| 388 | void checkRetAndSetAbandonedLocked(status_t res); |
Yin-Chia Yeh | 017d49c | 2017-03-31 19:11:00 -0700 | [diff] [blame] | 389 | |
Yin-Chia Yeh | a1b56c8 | 2019-03-27 15:50:39 -0700 | [diff] [blame] | 390 | // If the status indicates abandonded stream, only log when state hasn't been updated to |
| 391 | // STATE_ABANDONED |
| 392 | static bool shouldLogError(status_t res, StreamState state); |
| 393 | |
Shuzhen Wang | abbcb6b | 2020-12-09 22:32:44 -0800 | [diff] [blame] | 394 | // Dump images to disk before returning to consumer |
| 395 | void dumpImageToDisk(nsecs_t timestamp, ANativeWindowBuffer* anwBuffer, int fence); |
| 396 | |
Yin-Chia Yeh | 14ef48d | 2020-02-10 15:06:37 -0800 | [diff] [blame] | 397 | void returnPrefetchedBuffersLocked(); |
| 398 | |
Shuzhen Wang | 00abbeb | 2022-02-25 17:14:42 -0800 | [diff] [blame^] | 399 | // Synchronize camera timestamp to display, and the return value |
| 400 | // can be used as presentation timestamp |
| 401 | nsecs_t syncTimestampToDisplayLocked(nsecs_t t); |
| 402 | |
Shuzhen Wang | 686f644 | 2017-06-20 16:16:04 -0700 | [diff] [blame] | 403 | static const int32_t kDequeueLatencyBinSize = 5; // in ms |
| 404 | CameraLatencyHistogram mDequeueBufferLatency; |
| 405 | |
Shuzhen Wang | abbcb6b | 2020-12-09 22:32:44 -0800 | [diff] [blame] | 406 | int mImageDumpMask = 0; |
| 407 | |
Shuzhen Wang | 00abbeb | 2022-02-25 17:14:42 -0800 | [diff] [blame^] | 408 | nsecs_t mMinExpectedDuration = 0; |
| 409 | bool mSyncToDisplay = false; |
| 410 | DisplayEventReceiver mDisplayEventReceiver; |
| 411 | nsecs_t mLastCaptureTime = 0; |
| 412 | nsecs_t mLastPresentTime = 0; |
| 413 | nsecs_t mCaptureToPresentOffset = 0; |
| 414 | static constexpr size_t kDisplaySyncExtraBuffer = 2; |
| 415 | static constexpr nsecs_t kSpacingResetIntervalNs = 1000000000LL; // 1 second |
| 416 | static constexpr nsecs_t kTimelineThresholdNs = 1000000LL; // 1 millisecond |
Eino-Ville Talvala | fd58f1a | 2013-03-06 16:20:06 -0800 | [diff] [blame] | 417 | }; // class Camera3OutputStream |
| 418 | |
| 419 | } // namespace camera3 |
| 420 | |
| 421 | } // namespace android |
| 422 | |
| 423 | #endif |