1 /* 2 * Copyright (C) 2012 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_CAMERA_CAMERA2DEVICE_H 18 #define ANDROID_SERVERS_CAMERA_CAMERA2DEVICE_H 19 20 #include <utils/Condition.h> 21 #include <utils/Errors.h> 22 #include <utils/List.h> 23 #include <utils/Mutex.h> 24 25 #include "common/CameraDeviceBase.h" 26 27 namespace android { 28 29 /** 30 * CameraDevice for HAL devices with version CAMERA_DEVICE_API_VERSION_2_0 31 * 32 * TODO for camera2 API implementation: 33 * Does not produce notifyShutter / notifyIdle callbacks to NotificationListener 34 * Use waitUntilDrained for idle. 35 */ 36 class Camera2Device: public CameraDeviceBase { 37 public: 38 Camera2Device(int id); 39 40 virtual ~Camera2Device(); 41 42 /** 43 * CameraDevice interface 44 */ 45 virtual int getId() const; 46 virtual status_t initialize(CameraModule *module); 47 virtual status_t disconnect(); 48 virtual status_t dump(int fd, const Vector<String16>& args); 49 virtual const CameraMetadata& info() const; 50 virtual status_t capture(CameraMetadata &request, int64_t *lastFrameNumber = NULL); 51 virtual status_t captureList(const List<const CameraMetadata> &requests, 52 int64_t *lastFrameNumber = NULL); 53 virtual status_t setStreamingRequest(const CameraMetadata &request, 54 int64_t *lastFrameNumber = NULL); 55 virtual status_t setStreamingRequestList(const List<const CameraMetadata> &requests, 56 int64_t *lastFrameNumber = NULL); 57 virtual status_t clearStreamingRequest(int64_t *lastFrameNumber = NULL); 58 virtual status_t waitUntilRequestReceived(int32_t requestId, nsecs_t timeout); 59 virtual status_t createStream(sp<Surface> consumer, 60 uint32_t width, uint32_t height, int format, 61 android_dataspace dataSpace, camera3_stream_rotation_t rotation, int *id); 62 virtual status_t createInputStream( 63 uint32_t width, uint32_t height, int format, int *id); 64 virtual status_t createReprocessStreamFromStream(int outputId, int *id); 65 virtual status_t getStreamInfo(int id, 66 uint32_t *width, uint32_t *height, 67 uint32_t *format, android_dataspace *dataSpace); 68 virtual status_t setStreamTransform(int id, int transform); 69 virtual status_t deleteStream(int id); 70 virtual status_t deleteReprocessStream(int id); 71 // No-op on HAL2 devices 72 virtual status_t configureStreams(bool isConstrainedHighSpeed = false); 73 virtual status_t getInputBufferProducer( 74 sp<IGraphicBufferProducer> *producer); 75 virtual status_t createDefaultRequest(int templateId, CameraMetadata *request); 76 virtual status_t waitUntilDrained(); 77 virtual status_t setNotifyCallback(NotificationListener *listener); 78 virtual bool willNotify3A(); 79 virtual status_t waitForNextFrame(nsecs_t timeout); 80 virtual status_t getNextResult(CaptureResult *frame); 81 virtual status_t triggerAutofocus(uint32_t id); 82 virtual status_t triggerCancelAutofocus(uint32_t id); 83 virtual status_t triggerPrecaptureMetering(uint32_t id); 84 virtual status_t pushReprocessBuffer(int reprocessStreamId, 85 buffer_handle_t *buffer, wp<BufferReleasedListener> listener); 86 // Flush implemented as just a wait 87 virtual status_t flush(int64_t *lastFrameNumber = NULL); 88 // Prepare and tearDown are no-ops 89 virtual status_t prepare(int streamId); 90 virtual status_t tearDown(int streamId); 91 virtual status_t prepare(int maxCount, int streamId); 92 93 virtual uint32_t getDeviceVersion(); 94 virtual ssize_t getJpegBufferSize(uint32_t width, uint32_t height) const; 95 96 private: 97 const int mId; 98 camera2_device_t *mHal2Device; 99 100 CameraMetadata mDeviceInfo; 101 102 uint32_t mDeviceVersion; 103 104 /** 105 * Queue class for both sending requests to a camera2 device, and for 106 * receiving frames from a camera2 device. 107 */ 108 class MetadataQueue: public camera2_request_queue_src_ops_t, 109 public camera2_frame_queue_dst_ops_t { 110 public: 111 MetadataQueue(); 112 ~MetadataQueue(); 113 114 // Interface to camera2 HAL device, either for requests (device is 115 // consumer) or for frames (device is producer) 116 const camera2_request_queue_src_ops_t* getToConsumerInterface(); 117 void setFromConsumerInterface(camera2_device_t *d); 118 119 // Connect queue consumer endpoint to a camera2 device 120 status_t setConsumerDevice(camera2_device_t *d); 121 // Connect queue producer endpoint to a camera2 device 122 status_t setProducerDevice(camera2_device_t *d); 123 124 const camera2_frame_queue_dst_ops_t* getToProducerInterface(); 125 126 // Real interfaces. On enqueue, queue takes ownership of buffer pointer 127 // On dequeue, user takes ownership of buffer pointer. 128 status_t enqueue(camera_metadata_t *buf); 129 status_t dequeue(camera_metadata_t **buf, bool incrementCount = false); 130 int getBufferCount(); 131 status_t waitForBuffer(nsecs_t timeout); 132 // Wait until a buffer with the given ID is dequeued. Will return 133 // immediately if the latest buffer dequeued has that ID. 134 status_t waitForDequeue(int32_t id, nsecs_t timeout); 135 136 // Set repeating buffer(s); if the queue is empty on a dequeue call, the 137 // queue copies the contents of the stream slot into the queue, and then 138 // dequeues the first new entry. The methods take the ownership of the 139 // metadata buffers passed in. 140 status_t setStreamSlot(camera_metadata_t *buf); 141 status_t setStreamSlot(const List<camera_metadata_t*> &bufs); 142 143 // Clear the request queue and the streaming slot 144 status_t clear(); 145 146 status_t dump(int fd, const Vector<String16>& args); 147 148 private: 149 status_t signalConsumerLocked(); 150 status_t freeBuffers(List<camera_metadata_t*>::iterator start, 151 List<camera_metadata_t*>::iterator end); 152 153 camera2_device_t *mHal2Device; 154 155 Mutex mMutex; 156 Condition notEmpty; 157 158 int mFrameCount; 159 int32_t mLatestRequestId; 160 Condition mNewRequestId; 161 162 int mCount; 163 List<camera_metadata_t*> mEntries; 164 int mStreamSlotCount; 165 List<camera_metadata_t*> mStreamSlot; 166 167 bool mSignalConsumer; 168 169 static MetadataQueue* getInstance( 170 const camera2_frame_queue_dst_ops_t *q); 171 static MetadataQueue* getInstance( 172 const camera2_request_queue_src_ops_t *q); 173 174 static int consumer_buffer_count( 175 const camera2_request_queue_src_ops_t *q); 176 177 static int consumer_dequeue(const camera2_request_queue_src_ops_t *q, 178 camera_metadata_t **buffer); 179 180 static int consumer_free(const camera2_request_queue_src_ops_t *q, 181 camera_metadata_t *old_buffer); 182 183 static int producer_dequeue(const camera2_frame_queue_dst_ops_t *q, 184 size_t entries, size_t bytes, 185 camera_metadata_t **buffer); 186 187 static int producer_cancel(const camera2_frame_queue_dst_ops_t *q, 188 camera_metadata_t *old_buffer); 189 190 static int producer_enqueue(const camera2_frame_queue_dst_ops_t *q, 191 camera_metadata_t *filled_buffer); 192 193 }; // class MetadataQueue 194 195 MetadataQueue mRequestQueue; 196 MetadataQueue mFrameQueue; 197 198 /** 199 * Adapter from an ANativeWindow interface to camera2 device stream ops. 200 * Also takes care of allocating/deallocating stream in device interface 201 */ 202 class StreamAdapter: public camera2_stream_ops, public virtual RefBase { 203 public: 204 StreamAdapter(camera2_device_t *d); 205 206 ~StreamAdapter(); 207 208 /** 209 * Create a HAL device stream of the requested size and format. 210 * 211 * If format is CAMERA2_HAL_PIXEL_FORMAT_OPAQUE, then the HAL device 212 * selects an appropriate format; it can be queried with getFormat. 213 * 214 * If format is HAL_PIXEL_FORMAT_COMPRESSED, the size parameter must 215 * be equal to the size in bytes of the buffers to allocate for the 216 * stream. For other formats, the size parameter is ignored. 217 */ 218 status_t connectToDevice(sp<ANativeWindow> consumer, 219 uint32_t width, uint32_t height, int format, size_t size); 220 221 status_t release(); 222 223 status_t setTransform(int transform); 224 225 // Get stream parameters. 226 // Only valid after a successful connectToDevice call. getId()227 int getId() const { return mId; } getWidth()228 uint32_t getWidth() const { return mWidth; } getHeight()229 uint32_t getHeight() const { return mHeight; } getFormat()230 uint32_t getFormat() const { return mFormat; } 231 232 // Dump stream information 233 status_t dump(int fd, const Vector<String16>& args); 234 235 private: 236 enum { 237 ERROR = -1, 238 RELEASED = 0, 239 ALLOCATED, 240 CONNECTED, 241 ACTIVE 242 } mState; 243 244 sp<ANativeWindow> mConsumerInterface; 245 camera2_device_t *mHal2Device; 246 247 uint32_t mId; 248 uint32_t mWidth; 249 uint32_t mHeight; 250 uint32_t mFormat; 251 size_t mSize; 252 uint32_t mUsage; 253 uint32_t mMaxProducerBuffers; 254 uint32_t mMaxConsumerBuffers; 255 uint32_t mTotalBuffers; 256 int mFormatRequested; 257 258 /** Debugging information */ 259 uint32_t mActiveBuffers; 260 uint32_t mFrameCount; 261 int64_t mLastTimestamp; 262 263 const camera2_stream_ops *getStreamOps(); 264 265 static ANativeWindow* toANW(const camera2_stream_ops_t *w); 266 267 static int dequeue_buffer(const camera2_stream_ops_t *w, 268 buffer_handle_t** buffer); 269 270 static int enqueue_buffer(const camera2_stream_ops_t* w, 271 int64_t timestamp, 272 buffer_handle_t* buffer); 273 274 static int cancel_buffer(const camera2_stream_ops_t* w, 275 buffer_handle_t* buffer); 276 277 static int set_crop(const camera2_stream_ops_t* w, 278 int left, int top, int right, int bottom); 279 }; // class StreamAdapter 280 281 typedef List<sp<StreamAdapter> > StreamList; 282 StreamList mStreams; 283 284 /** 285 * Adapter from an ANativeWindow interface to camera2 device stream ops. 286 * Also takes care of allocating/deallocating stream in device interface 287 */ 288 class ReprocessStreamAdapter: public camera2_stream_in_ops, public virtual RefBase { 289 public: 290 ReprocessStreamAdapter(camera2_device_t *d); 291 292 ~ReprocessStreamAdapter(); 293 294 /** 295 * Create a HAL device reprocess stream based on an existing output stream. 296 */ 297 status_t connectToDevice(const sp<StreamAdapter> &outputStream); 298 299 status_t release(); 300 301 /** 302 * Push buffer into stream for reprocessing. Takes ownership until it notifies 303 * that the buffer has been released 304 */ 305 status_t pushIntoStream(buffer_handle_t *handle, 306 const wp<BufferReleasedListener> &releaseListener); 307 308 /** 309 * Get stream parameters. 310 * Only valid after a successful connectToDevice call. 311 */ getId()312 int getId() const { return mId; } getWidth()313 uint32_t getWidth() const { return mWidth; } getHeight()314 uint32_t getHeight() const { return mHeight; } getFormat()315 uint32_t getFormat() const { return mFormat; } 316 317 // Dump stream information 318 status_t dump(int fd, const Vector<String16>& args); 319 320 private: 321 enum { 322 ERROR = -1, 323 RELEASED = 0, 324 ACTIVE 325 } mState; 326 327 sp<ANativeWindow> mConsumerInterface; 328 wp<StreamAdapter> mBaseStream; 329 330 struct QueueEntry { 331 buffer_handle_t *handle; 332 wp<BufferReleasedListener> releaseListener; 333 }; 334 335 List<QueueEntry> mQueue; 336 337 List<QueueEntry> mInFlightQueue; 338 339 camera2_device_t *mHal2Device; 340 341 uint32_t mId; 342 uint32_t mWidth; 343 uint32_t mHeight; 344 uint32_t mFormat; 345 346 /** Debugging information */ 347 uint32_t mActiveBuffers; 348 uint32_t mFrameCount; 349 int64_t mLastTimestamp; 350 351 const camera2_stream_in_ops *getStreamOps(); 352 353 static int acquire_buffer(const camera2_stream_in_ops_t *w, 354 buffer_handle_t** buffer); 355 356 static int release_buffer(const camera2_stream_in_ops_t* w, 357 buffer_handle_t* buffer); 358 359 }; // class ReprocessStreamAdapter 360 361 typedef List<sp<ReprocessStreamAdapter> > ReprocessStreamList; 362 ReprocessStreamList mReprocessStreams; 363 364 // Receives HAL notifications and routes them to the NotificationListener 365 static void notificationCallback(int32_t msg_type, 366 int32_t ext1, 367 int32_t ext2, 368 int32_t ext3, 369 void *user); 370 371 }; // class Camera2Device 372 373 }; // namespace android 374 375 #endif 376