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 #ifndef ANDROID_SERVERS_CAMERA3_STREAM_INTERFACE_H 18 #define ANDROID_SERVERS_CAMERA3_STREAM_INTERFACE_H 19 20 #include <utils/RefBase.h> 21 #include "Camera3StreamBufferListener.h" 22 #include "Camera3StreamBufferFreedListener.h" 23 24 struct camera3_stream_buffer; 25 26 namespace android { 27 28 namespace camera3 { 29 30 enum { 31 /** 32 * This stream set ID indicates that the set ID is invalid, and this stream doesn't intend to 33 * share buffers with any other stream. It is illegal to register this kind of stream to 34 * Camera3BufferManager. 35 */ 36 CAMERA3_STREAM_SET_ID_INVALID = -1, 37 38 /** 39 * Invalid output stream ID. 40 */ 41 CAMERA3_STREAM_ID_INVALID = -1, 42 }; 43 44 class StatusTracker; 45 46 /** 47 * An interface for managing a single stream of input and/or output data from 48 * the camera device. 49 */ 50 class Camera3StreamInterface : public virtual RefBase { 51 public: 52 53 enum { 54 ALLOCATE_PIPELINE_MAX = 0, // Allocate max buffers used by a given surface 55 }; 56 57 /** 58 * Get the stream's ID 59 */ 60 virtual int getId() const = 0; 61 62 /** 63 * Get the output stream set id. 64 */ 65 virtual int getStreamSetId() const = 0; 66 67 /** 68 * Get the stream's dimensions and format 69 */ 70 virtual uint32_t getWidth() const = 0; 71 virtual uint32_t getHeight() const = 0; 72 virtual int getFormat() const = 0; 73 virtual android_dataspace getDataSpace() const = 0; 74 75 /** 76 * Get a HAL3 handle for the stream, without starting stream configuration. 77 */ 78 virtual camera3_stream* asHalStream() = 0; 79 80 /** 81 * Start the stream configuration process. Returns a handle to the stream's 82 * information to be passed into the HAL device's configure_streams call. 83 * 84 * Until finishConfiguration() is called, no other methods on the stream may 85 * be called. The usage and max_buffers fields of camera3_stream may be 86 * modified between start/finishConfiguration, but may not be changed after 87 * that. The priv field of camera3_stream may be modified at any time after 88 * startConfiguration. 89 * 90 * Returns NULL in case of error starting configuration. 91 */ 92 virtual camera3_stream* startConfiguration() = 0; 93 94 /** 95 * Check if the stream is mid-configuration (start has been called, but not 96 * finish). Used for lazy completion of configuration. 97 */ 98 virtual bool isConfiguring() const = 0; 99 100 /** 101 * Completes the stream configuration process. During this call, the stream 102 * may call the device's register_stream_buffers() method. The stream 103 * information structure returned by startConfiguration() may no longer be 104 * modified after this call, but can still be read until the destruction of 105 * the stream. 106 * 107 * Returns: 108 * OK on a successful configuration 109 * NO_INIT in case of a serious error from the HAL device 110 * NO_MEMORY in case of an error registering buffers 111 * INVALID_OPERATION in case connecting to the consumer failed 112 */ 113 virtual status_t finishConfiguration() = 0; 114 115 /** 116 * Cancels the stream configuration process. This returns the stream to the 117 * initial state, allowing it to be configured again later. 118 * This is done if the HAL rejects the proposed combined stream configuration 119 */ 120 virtual status_t cancelConfiguration() = 0; 121 122 /** 123 * Determine whether the stream has already become in-use (has received 124 * a valid filled buffer), which determines if a stream can still have 125 * prepareNextBuffer called on it. 126 */ 127 virtual bool isUnpreparable() = 0; 128 129 /** 130 * Start stream preparation. May only be called in the CONFIGURED state, 131 * when no valid buffers have yet been returned to this stream. Prepares 132 * up to maxCount buffers, or the maximum number of buffers needed by the 133 * pipeline if maxCount is ALLOCATE_PIPELINE_MAX. 134 * 135 * If no prepartion is necessary, returns OK and does not transition to 136 * PREPARING state. Otherwise, returns NOT_ENOUGH_DATA and transitions 137 * to PREPARING. 138 * 139 * Returns: 140 * OK if no more buffers need to be preallocated 141 * NOT_ENOUGH_DATA if calls to prepareNextBuffer are needed to finish 142 * buffer pre-allocation, and transitions to the PREPARING state. 143 * NO_INIT in case of a serious error from the HAL device 144 * INVALID_OPERATION if called when not in CONFIGURED state, or a 145 * valid buffer has already been returned to this stream. 146 */ 147 virtual status_t startPrepare(int maxCount) = 0; 148 149 /** 150 * Check if the stream is mid-preparing. 151 */ 152 virtual bool isPreparing() const = 0; 153 154 /** 155 * Continue stream buffer preparation by allocating the next 156 * buffer for this stream. May only be called in the PREPARED state. 157 * 158 * Returns OK and transitions to the CONFIGURED state if all buffers 159 * are allocated after the call concludes. Otherwise returns NOT_ENOUGH_DATA. 160 * 161 * Returns: 162 * OK if no more buffers need to be preallocated, and transitions 163 * to the CONFIGURED state. 164 * NOT_ENOUGH_DATA if more calls to prepareNextBuffer are needed to finish 165 * buffer pre-allocation. 166 * NO_INIT in case of a serious error from the HAL device 167 * INVALID_OPERATION if called when not in CONFIGURED state, or a 168 * valid buffer has already been returned to this stream. 169 */ 170 virtual status_t prepareNextBuffer() = 0; 171 172 /** 173 * Cancel stream preparation early. In case allocation needs to be 174 * stopped, this method transitions the stream back to the CONFIGURED state. 175 * Buffers that have been allocated with prepareNextBuffer remain that way, 176 * but a later use of prepareNextBuffer will require just as many 177 * calls as if the earlier prepare attempt had not existed. 178 * 179 * Returns: 180 * OK if cancellation succeeded, and transitions to the CONFIGURED state 181 * INVALID_OPERATION if not in the PREPARING state 182 * NO_INIT in case of a serious error from the HAL device 183 */ 184 virtual status_t cancelPrepare() = 0; 185 186 /** 187 * Tear down memory for this stream. This frees all unused gralloc buffers 188 * allocated for this stream, but leaves it ready for operation afterward. 189 * 190 * May only be called in the CONFIGURED state, and keeps the stream in 191 * the CONFIGURED state. 192 * 193 * Returns: 194 * OK if teardown succeeded. 195 * INVALID_OPERATION if not in the CONFIGURED state 196 * NO_INIT in case of a serious error from the HAL device 197 */ 198 virtual status_t tearDown() = 0; 199 200 /** 201 * Fill in the camera3_stream_buffer with the next valid buffer for this 202 * stream, to hand over to the HAL. 203 * 204 * Multiple surfaces could share the same HAL stream, but a request may 205 * be only for a subset of surfaces. In this case, the 206 * Camera3StreamInterface object needs the surface ID information to acquire 207 * buffers for those surfaces. For the case of single surface for a HAL 208 * stream, surface_ids parameter has no effect. 209 * 210 * This method may only be called once finishConfiguration has been called. 211 * For bidirectional streams, this method applies to the output-side 212 * buffers. 213 * 214 */ 215 virtual status_t getBuffer(camera3_stream_buffer *buffer, 216 const std::vector<size_t>& surface_ids = std::vector<size_t>()) = 0; 217 218 /** 219 * Return a buffer to the stream after use by the HAL. 220 * 221 * This method may only be called for buffers provided by getBuffer(). 222 * For bidirectional streams, this method applies to the output-side buffers 223 */ 224 virtual status_t returnBuffer(const camera3_stream_buffer &buffer, 225 nsecs_t timestamp) = 0; 226 227 /** 228 * Fill in the camera3_stream_buffer with the next valid buffer for this 229 * stream, to hand over to the HAL. 230 * 231 * This method may only be called once finishConfiguration has been called. 232 * For bidirectional streams, this method applies to the input-side 233 * buffers. 234 * 235 */ 236 virtual status_t getInputBuffer(camera3_stream_buffer *buffer) = 0; 237 238 /** 239 * Return a buffer to the stream after use by the HAL. 240 * 241 * This method may only be called for buffers provided by getBuffer(). 242 * For bidirectional streams, this method applies to the input-side buffers 243 */ 244 virtual status_t returnInputBuffer(const camera3_stream_buffer &buffer) = 0; 245 246 /** 247 * Get the buffer producer of the input buffer queue. 248 * 249 * This method only applies to input streams. 250 */ 251 virtual status_t getInputBufferProducer(sp<IGraphicBufferProducer> *producer) = 0; 252 253 /** 254 * Whether any of the stream's buffers are currently in use by the HAL, 255 * including buffers that have been returned but not yet had their 256 * release fence signaled. 257 */ 258 virtual bool hasOutstandingBuffers() const = 0; 259 260 enum { 261 TIMEOUT_NEVER = -1 262 }; 263 264 /** 265 * Set the state tracker to use for signaling idle transitions. 266 */ 267 virtual status_t setStatusTracker(sp<StatusTracker> statusTracker) = 0; 268 269 /** 270 * Disconnect stream from its non-HAL endpoint. After this, 271 * start/finishConfiguration must be called before the stream can be used 272 * again. This cannot be called if the stream has outstanding dequeued 273 * buffers. 274 */ 275 virtual status_t disconnect() = 0; 276 277 /** 278 * Return if the buffer queue of the stream is abandoned. 279 */ 280 virtual bool isAbandoned() const = 0; 281 282 /** 283 * Debug dump of the stream's state. 284 */ 285 virtual void dump(int fd, const Vector<String16> &args) const = 0; 286 287 virtual void addBufferListener( 288 wp<Camera3StreamBufferListener> listener) = 0; 289 virtual void removeBufferListener( 290 const sp<Camera3StreamBufferListener>& listener) = 0; 291 292 /** 293 * Setting listner will remove previous listener (if exists) 294 * Only allow set listener during stream configuration because stream is guaranteed to be IDLE 295 * at this state, so setBufferFreedListener won't collide with onBufferFreed callbacks. 296 * Client is responsible to keep the listener object alive throughout the lifecycle of this 297 * Camera3Stream. 298 */ 299 virtual void setBufferFreedListener(Camera3StreamBufferFreedListener* listener) = 0; 300 }; 301 302 } // namespace camera3 303 304 } // namespace android 305 306 #endif 307