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