2 * Copyright (C) 2012 The Android Open Source Project
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
17 // Utility classes for camera2 HAL testing
19 #define LOG_TAG "Camera2_test_utils"
22 #include "utils/Log.h"
23 #include "camera2_utils.h"
34 MetadataQueue::MetadataQueue():
41 camera2_request_queue_src_ops::dequeue_request = consumer_dequeue;
42 camera2_request_queue_src_ops::request_count = consumer_buffer_count;
43 camera2_request_queue_src_ops::free_request = consumer_free;
45 camera2_frame_queue_dst_ops::dequeue_frame = producer_dequeue;
46 camera2_frame_queue_dst_ops::cancel_frame = producer_cancel;
47 camera2_frame_queue_dst_ops::enqueue_frame = producer_enqueue;
50 MetadataQueue::~MetadataQueue() {
51 freeBuffers(mEntries.begin(), mEntries.end());
52 freeBuffers(mStreamSlot.begin(), mStreamSlot.end());
55 // Interface to camera2 HAL as consumer (input requests/reprocessing)
56 const camera2_request_queue_src_ops_t* MetadataQueue::getToConsumerInterface() {
57 return static_cast<camera2_request_queue_src_ops_t*>(this);
60 void MetadataQueue::setFromConsumerInterface(camera2_device_t *d) {
64 const camera2_frame_queue_dst_ops_t* MetadataQueue::getToProducerInterface() {
65 return static_cast<camera2_frame_queue_dst_ops_t*>(this);
69 status_t MetadataQueue::enqueue(camera_metadata_t *buf) {
70 Mutex::Autolock l(mMutex);
73 mEntries.push_back(buf);
76 if (mSignalConsumer && mDevice != NULL) {
77 mSignalConsumer = false;
80 ALOGV("%s: Signaling consumer", __FUNCTION__);
81 mDevice->ops->notify_request_queue_not_empty(mDevice);
87 int MetadataQueue::getBufferCount() {
88 Mutex::Autolock l(mMutex);
89 if (mStreamSlotCount > 0) {
90 return CAMERA2_REQUEST_QUEUE_IS_BOTTOMLESS;
95 status_t MetadataQueue::dequeue(camera_metadata_t **buf, bool incrementCount) {
96 Mutex::Autolock l(mMutex);
99 if (mStreamSlotCount == 0) {
100 ALOGV("%s: Empty", __FUNCTION__);
102 mSignalConsumer = true;
105 ALOGV("%s: Streaming %d frames to queue", __FUNCTION__,
108 for (List<camera_metadata_t*>::iterator slotEntry = mStreamSlot.begin();
109 slotEntry != mStreamSlot.end();
111 size_t entries = get_camera_metadata_entry_count(*slotEntry);
112 size_t dataBytes = get_camera_metadata_data_count(*slotEntry);
114 camera_metadata_t *copy = allocate_camera_metadata(entries, dataBytes);
115 append_camera_metadata(copy, *slotEntry);
116 mEntries.push_back(copy);
118 mCount = mStreamSlotCount;
120 ALOGV("MetadataQueue: deque (%d buffers)", mCount);
121 camera_metadata_t *b = *(mEntries.begin());
122 mEntries.erase(mEntries.begin());
124 if (incrementCount) {
125 add_camera_metadata_entry(b,
126 ANDROID_REQUEST_FRAME_COUNT,
127 (void**)&mFrameCount, 1);
137 status_t MetadataQueue::waitForBuffer(nsecs_t timeout) {
138 Mutex::Autolock l(mMutex);
140 while (mCount == 0) {
141 res = notEmpty.waitRelative(mMutex,timeout);
142 if (res != OK) return res;
147 status_t MetadataQueue::setStreamSlot(camera_metadata_t *buf) {
149 freeBuffers(mStreamSlot.begin(), mStreamSlot.end());
150 mStreamSlotCount = 0;
153 if (mStreamSlotCount > 1) {
154 List<camera_metadata_t*>::iterator deleter = ++mStreamSlot.begin();
155 freeBuffers(++mStreamSlot.begin(), mStreamSlot.end());
156 mStreamSlotCount = 1;
158 if (mStreamSlotCount == 1) {
159 free_camera_metadata( *(mStreamSlot.begin()) );
160 *(mStreamSlot.begin()) = buf;
162 mStreamSlot.push_front(buf);
163 mStreamSlotCount = 1;
168 status_t MetadataQueue::setStreamSlot(const List<camera_metadata_t*> &bufs) {
169 if (mStreamSlotCount > 0) {
170 freeBuffers(mStreamSlot.begin(), mStreamSlot.end());
173 mStreamSlotCount = mStreamSlot.size();
178 status_t MetadataQueue::freeBuffers(List<camera_metadata_t*>::iterator start,
179 List<camera_metadata_t*>::iterator end) {
180 while (start != end) {
181 free_camera_metadata(*start);
182 start = mStreamSlot.erase(start);
187 MetadataQueue* MetadataQueue::getInstance(
188 const camera2_request_queue_src_ops_t *q) {
189 const MetadataQueue* cmq = static_cast<const MetadataQueue*>(q);
190 return const_cast<MetadataQueue*>(cmq);
193 MetadataQueue* MetadataQueue::getInstance(
194 const camera2_frame_queue_dst_ops_t *q) {
195 const MetadataQueue* cmq = static_cast<const MetadataQueue*>(q);
196 return const_cast<MetadataQueue*>(cmq);
199 int MetadataQueue::consumer_buffer_count(
200 const camera2_request_queue_src_ops_t *q) {
201 MetadataQueue *queue = getInstance(q);
202 return queue->getBufferCount();
205 int MetadataQueue::consumer_dequeue(const camera2_request_queue_src_ops_t *q,
206 camera_metadata_t **buffer) {
207 MetadataQueue *queue = getInstance(q);
208 return queue->dequeue(buffer, true);
211 int MetadataQueue::consumer_free(const camera2_request_queue_src_ops_t *q,
212 camera_metadata_t *old_buffer) {
213 free_camera_metadata(old_buffer);
217 int MetadataQueue::producer_dequeue(const camera2_frame_queue_dst_ops_t *q,
218 size_t entries, size_t bytes,
219 camera_metadata_t **buffer) {
220 camera_metadata_t *new_buffer =
221 allocate_camera_metadata(entries, bytes);
222 if (new_buffer == NULL) return NO_MEMORY;
223 *buffer = new_buffer;
227 int MetadataQueue::producer_cancel(const camera2_frame_queue_dst_ops_t *q,
228 camera_metadata_t *old_buffer) {
229 free_camera_metadata(old_buffer);
233 int MetadataQueue::producer_enqueue(const camera2_frame_queue_dst_ops_t *q,
234 camera_metadata_t *filled_buffer) {
235 MetadataQueue *queue = getInstance(q);
236 return queue->enqueue(filled_buffer);
243 NotifierListener::NotifierListener() {
246 status_t NotifierListener::getNotificationsFrom(camera2_device *dev) {
247 if (!dev) return BAD_VALUE;
249 err = dev->ops->set_notify_callback(dev,
250 notify_callback_dispatch,
255 status_t NotifierListener::getNextNotification(int32_t *msg_type,
259 Mutex::Autolock l(mMutex);
260 if (mNotifications.size() == 0) return BAD_VALUE;
261 return getNextNotificationLocked(msg_type, ext1, ext2, ext3);
264 status_t NotifierListener::waitForNotification(int32_t *msg_type,
268 Mutex::Autolock l(mMutex);
269 while (mNotifications.size() == 0) {
270 mNewNotification.wait(mMutex);
272 return getNextNotificationLocked(msg_type, ext1, ext2, ext3);
275 int NotifierListener::numNotifications() {
276 Mutex::Autolock l(mMutex);
277 return mNotifications.size();
280 status_t NotifierListener::getNextNotificationLocked(int32_t *msg_type,
284 *msg_type = mNotifications.begin()->msg_type;
285 *ext1 = mNotifications.begin()->ext1;
286 *ext2 = mNotifications.begin()->ext2;
287 *ext3 = mNotifications.begin()->ext3;
288 mNotifications.erase(mNotifications.begin());
292 void NotifierListener::onNotify(int32_t msg_type,
296 Mutex::Autolock l(mMutex);
297 mNotifications.push_back(Notification(msg_type, ext1, ext2, ext3));
298 mNewNotification.signal();
301 void NotifierListener::notify_callback_dispatch(int32_t msg_type,
306 NotifierListener *me = reinterpret_cast<NotifierListener*>(user);
307 me->onNotify(msg_type, ext1, ext2, ext3);
315 #define container_of(ptr, type, member) \
316 (type *)((char*)(ptr) - offsetof(type, member))
319 StreamAdapter::StreamAdapter(sp<IGraphicBufferProducer> consumer):
320 mState(UNINITIALIZED), mDevice(NULL),
322 mWidth(0), mHeight(0), mFormat(0)
324 mConsumerInterface = new Surface(consumer);
325 camera2_stream_ops::dequeue_buffer = dequeue_buffer;
326 camera2_stream_ops::enqueue_buffer = enqueue_buffer;
327 camera2_stream_ops::cancel_buffer = cancel_buffer;
328 camera2_stream_ops::set_crop = set_crop;
331 StreamAdapter::~StreamAdapter() {
335 status_t StreamAdapter::connectToDevice(camera2_device_t *d,
336 uint32_t width, uint32_t height, int format) {
337 if (mState != UNINITIALIZED) return INVALID_OPERATION;
339 ALOGE("%s: Null device passed to stream adapter", __FUNCTION__);
349 // Allocate device-side stream interface
352 uint32_t formatActual; // ignored
354 uint32_t maxBuffers = 2;
355 res = d->ops->allocate_stream(d,
356 mWidth, mHeight, mFormat, getStreamOps(),
357 &id, &formatActual, &usage, &maxBuffers);
359 ALOGE("%s: Device stream allocation failed: %s (%d)",
360 __FUNCTION__, strerror(-res), res);
361 mState = UNINITIALIZED;
368 mMaxProducerBuffers = maxBuffers;
370 // Configure consumer-side ANativeWindow interface
372 res = native_window_api_connect(mConsumerInterface.get(),
373 NATIVE_WINDOW_API_CAMERA);
375 ALOGE("%s: Unable to connect to native window for stream %d",
381 res = native_window_set_usage(mConsumerInterface.get(), mUsage);
383 ALOGE("%s: Unable to configure usage %08x for stream %d",
384 __FUNCTION__, mUsage, mId);
389 res = native_window_set_buffers_geometry(mConsumerInterface.get(),
390 mWidth, mHeight, mFormat);
392 ALOGE("%s: Unable to configure buffer geometry"
393 " %d x %d, format 0x%x for stream %d",
394 __FUNCTION__, mWidth, mHeight, mFormat, mId);
399 int maxConsumerBuffers;
400 res = mConsumerInterface->query(mConsumerInterface.get(),
401 NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, &maxConsumerBuffers);
403 ALOGE("%s: Unable to query consumer undequeued"
404 " buffer count for stream %d", __FUNCTION__, mId);
408 mMaxConsumerBuffers = maxConsumerBuffers;
410 ALOGV("%s: Producer wants %d buffers, consumer wants %d", __FUNCTION__,
411 mMaxProducerBuffers, mMaxConsumerBuffers);
413 int totalBuffers = mMaxConsumerBuffers + mMaxProducerBuffers;
415 res = native_window_set_buffer_count(mConsumerInterface.get(),
418 ALOGE("%s: Unable to set buffer count for stream %d",
424 // Register allocated buffers with HAL device
425 buffer_handle_t *buffers = new buffer_handle_t[totalBuffers];
426 ANativeWindowBuffer **anwBuffers = new ANativeWindowBuffer*[totalBuffers];
428 for (; bufferIdx < totalBuffers; bufferIdx++) {
429 res = native_window_dequeue_buffer_and_wait(mConsumerInterface.get(),
430 &anwBuffers[bufferIdx]);
432 ALOGE("%s: Unable to dequeue buffer %d for initial registration for"
433 "stream %d", __FUNCTION__, bufferIdx, mId);
437 buffers[bufferIdx] = anwBuffers[bufferIdx]->handle;
440 res = mDevice->ops->register_stream_buffers(mDevice,
445 ALOGE("%s: Unable to register buffers with HAL device for stream %d",
453 for (int i = 0; i < bufferIdx; i++) {
454 res = mConsumerInterface->cancelBuffer(mConsumerInterface.get(),
463 status_t StreamAdapter::disconnect() {
465 if (mState >= ALLOCATED) {
466 res = mDevice->ops->release_stream(mDevice, mId);
468 ALOGE("%s: Unable to release stream %d",
473 if (mState >= CONNECTED) {
474 res = native_window_api_disconnect(mConsumerInterface.get(),
475 NATIVE_WINDOW_API_CAMERA);
477 ALOGE("%s: Unable to disconnect stream %d from native window",
483 mState = DISCONNECTED;
487 int StreamAdapter::getId() {
491 const camera2_stream_ops *StreamAdapter::getStreamOps() {
492 return static_cast<camera2_stream_ops *>(this);
495 ANativeWindow* StreamAdapter::toANW(const camera2_stream_ops_t *w) {
496 return static_cast<const StreamAdapter*>(w)->mConsumerInterface.get();
499 int StreamAdapter::dequeue_buffer(const camera2_stream_ops_t *w,
500 buffer_handle_t** buffer) {
502 int state = static_cast<const StreamAdapter*>(w)->mState;
503 if (state != ACTIVE) {
504 ALOGE("%s: Called when in bad state: %d", __FUNCTION__, state);
505 return INVALID_OPERATION;
508 ANativeWindow *a = toANW(w);
509 ANativeWindowBuffer* anb;
510 res = native_window_dequeue_buffer_and_wait(a, &anb);
511 if (res != OK) return res;
513 *buffer = &(anb->handle);
518 int StreamAdapter::enqueue_buffer(const camera2_stream_ops_t* w,
520 buffer_handle_t* buffer) {
521 int state = static_cast<const StreamAdapter*>(w)->mState;
522 if (state != ACTIVE) {
523 ALOGE("%s: Called when in bad state: %d", __FUNCTION__, state);
524 return INVALID_OPERATION;
526 ANativeWindow *a = toANW(w);
528 err = native_window_set_buffers_timestamp(a, timestamp);
529 if (err != OK) return err;
530 return a->queueBuffer(a,
531 container_of(buffer, ANativeWindowBuffer, handle), -1);
534 int StreamAdapter::cancel_buffer(const camera2_stream_ops_t* w,
535 buffer_handle_t* buffer) {
536 int state = static_cast<const StreamAdapter*>(w)->mState;
537 if (state != ACTIVE) {
538 ALOGE("%s: Called when in bad state: %d", __FUNCTION__, state);
539 return INVALID_OPERATION;
541 ANativeWindow *a = toANW(w);
542 return a->cancelBuffer(a,
543 container_of(buffer, ANativeWindowBuffer, handle), -1);
546 int StreamAdapter::set_crop(const camera2_stream_ops_t* w,
547 int left, int top, int right, int bottom) {
548 int state = static_cast<const StreamAdapter*>(w)->mState;
549 if (state != ACTIVE) {
550 ALOGE("%s: Called when in bad state: %d", __FUNCTION__, state);
551 return INVALID_OPERATION;
553 ANativeWindow *a = toANW(w);
554 android_native_rect_t crop = { left, top, right, bottom };
555 return native_window_set_crop(a, &crop);
562 FrameWaiter::FrameWaiter():
566 status_t FrameWaiter::waitForFrame(nsecs_t timeout) {
568 Mutex::Autolock lock(mMutex);
569 while (mPendingFrames == 0) {
570 res = mCondition.waitRelative(mMutex, timeout);
571 if (res != OK) return res;
577 void FrameWaiter::onFrameAvailable() {
578 Mutex::Autolock lock(mMutex);
583 int HWModuleHelpers::closeModule(hw_module_t* module) {
590 status = dlclose(module->dso);
592 char const *err_str = dlerror();
593 ALOGE("%s dlclose failed, error: %s", __func__, err_str ?: "unknown");
600 } // namespace camera2
601 } // namespace android