tests/camera2/camera2_utils.cpp

   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 // Utility classes for camera2 HAL testing
  18
  19 #define LOG_TAG "Camera2_test_utils"
  20 #define LOG_NDEBUG 0
  21
  22 #include "utils/Log.h"
  23 #include "camera2_utils.h"
  24 #include <dlfcn.h>
  25
  26 namespace android {
  27 namespace camera2 {
  28 namespace tests {
  29
  30 /**
  31  * MetadataQueue
  32  */
  33
  34 MetadataQueue::MetadataQueue():
  35             mDevice(NULL),
  36             mFrameCount(0),
  37             mCount(0),
  38             mStreamSlotCount(0),
  39             mSignalConsumer(true)
  40 {
  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;
  44
  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;
  48 }
  49
  50 MetadataQueue::~MetadataQueue() {
  51     freeBuffers(mEntries.begin(), mEntries.end());
  52     freeBuffers(mStreamSlot.begin(), mStreamSlot.end());
  53 }
  54
  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);
  58 }
  59
  60 void MetadataQueue::setFromConsumerInterface(camera2_device_t *d) {
  61     mDevice = d;
  62 }
  63
  64 const camera2_frame_queue_dst_ops_t* MetadataQueue::getToProducerInterface() {
  65     return static_cast<camera2_frame_queue_dst_ops_t*>(this);
  66 }
  67
  68 // Real interfaces
  69 status_t MetadataQueue::enqueue(camera_metadata_t *buf) {
  70     Mutex::Autolock l(mMutex);
  71
  72     mCount++;
  73     mEntries.push_back(buf);
  74     notEmpty.signal();
  75
  76     if (mSignalConsumer && mDevice != NULL) {
  77         mSignalConsumer = false;
  78
  79         mMutex.unlock();
  80         ALOGV("%s: Signaling consumer", __FUNCTION__);
  81         mDevice->ops->notify_request_queue_not_empty(mDevice);
  82         mMutex.lock();
  83     }
  84     return OK;
  85 }
  86
  87 int MetadataQueue::getBufferCount() {
  88     Mutex::Autolock l(mMutex);
  89     if (mStreamSlotCount > 0) {
  90         return CAMERA2_REQUEST_QUEUE_IS_BOTTOMLESS;
  91     }
  92     return mCount;
  93 }
  94
  95 status_t MetadataQueue::dequeue(camera_metadata_t **buf, bool incrementCount) {
  96     Mutex::Autolock l(mMutex);
  97
  98     if (mCount == 0) {
  99         if (mStreamSlotCount == 0) {
 100             ALOGV("%s: Empty", __FUNCTION__);
 101             *buf = NULL;
 102             mSignalConsumer = true;
 103             return OK;
 104         }
 105         ALOGV("%s: Streaming %d frames to queue", __FUNCTION__,
 106               mStreamSlotCount);
 107
 108         for (List<camera_metadata_t*>::iterator slotEntry = mStreamSlot.begin();
 109                 slotEntry != mStreamSlot.end();
 110                 slotEntry++ ) {
 111             size_t entries = get_camera_metadata_entry_count(*slotEntry);
 112             size_t dataBytes = get_camera_metadata_data_count(*slotEntry);
 113
 114             camera_metadata_t *copy = allocate_camera_metadata(entries, dataBytes);
 115             append_camera_metadata(copy, *slotEntry);
 116             mEntries.push_back(copy);
 117         }
 118         mCount = mStreamSlotCount;
 119     }
 120     ALOGV("MetadataQueue: deque (%d buffers)", mCount);
 121     camera_metadata_t *b = *(mEntries.begin());
 122     mEntries.erase(mEntries.begin());
 123
 124     if (incrementCount) {
 125         add_camera_metadata_entry(b,
 126                 ANDROID_REQUEST_FRAME_COUNT,
 127                 (void**)&mFrameCount, 1);
 128         mFrameCount++;
 129     }
 130
 131     *buf = b;
 132     mCount--;
 133
 134     return OK;
 135 }
 136
 137 status_t MetadataQueue::waitForBuffer(nsecs_t timeout) {
 138     Mutex::Autolock l(mMutex);
 139     status_t res;
 140     while (mCount == 0) {
 141         res = notEmpty.waitRelative(mMutex,timeout);
 142         if (res != OK) return res;
 143     }
 144     return OK;
 145 }
 146
 147 status_t MetadataQueue::setStreamSlot(camera_metadata_t *buf) {
 148     if (buf == NULL) {
 149         freeBuffers(mStreamSlot.begin(), mStreamSlot.end());
 150         mStreamSlotCount = 0;
 151         return OK;
 152     }
 153     if (mStreamSlotCount > 1) {
 154         List<camera_metadata_t*>::iterator deleter = ++mStreamSlot.begin();
 155         freeBuffers(++mStreamSlot.begin(), mStreamSlot.end());
 156         mStreamSlotCount = 1;
 157     }
 158     if (mStreamSlotCount == 1) {
 159         free_camera_metadata( *(mStreamSlot.begin()) );
 160         *(mStreamSlot.begin()) = buf;
 161     } else {
 162         mStreamSlot.push_front(buf);
 163         mStreamSlotCount = 1;
 164     }
 165     return OK;
 166 }
 167
 168 status_t MetadataQueue::setStreamSlot(const List<camera_metadata_t*> &bufs) {
 169     if (mStreamSlotCount > 0) {
 170         freeBuffers(mStreamSlot.begin(), mStreamSlot.end());
 171     }
 172     mStreamSlot = bufs;
 173     mStreamSlotCount = mStreamSlot.size();
 174
 175     return OK;
 176 }
 177
 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);
 183     }
 184     return OK;
 185 }
 186
 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);
 191 }
 192
 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);
 197 }
 198
 199 int MetadataQueue::consumer_buffer_count(
 200         const camera2_request_queue_src_ops_t *q) {
 201     MetadataQueue *queue = getInstance(q);
 202     return queue->getBufferCount();
 203 }
 204
 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);
 209 }
 210
 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);
 214     return OK;
 215 }
 216
 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;
 224         return OK;
 225 }
 226
 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);
 230     return OK;
 231 }
 232
 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);
 237 }
 238
 239 /**
 240  * NotifierListener
 241  */
 242
 243 NotifierListener::NotifierListener() {
 244 }
 245
 246 status_t NotifierListener::getNotificationsFrom(camera2_device *dev) {
 247     if (!dev) return BAD_VALUE;
 248     status_t err;
 249     err = dev->ops->set_notify_callback(dev,
 250             notify_callback_dispatch,
 251             (void*)this);
 252     return err;
 253 }
 254
 255 status_t NotifierListener::getNextNotification(int32_t *msg_type,
 256         int32_t *ext1,
 257         int32_t *ext2,
 258         int32_t *ext3) {
 259     Mutex::Autolock l(mMutex);
 260     if (mNotifications.size() == 0) return BAD_VALUE;
 261     return getNextNotificationLocked(msg_type, ext1, ext2, ext3);
 262 }
 263
 264 status_t NotifierListener::waitForNotification(int32_t *msg_type,
 265         int32_t *ext1,
 266         int32_t *ext2,
 267         int32_t *ext3) {
 268     Mutex::Autolock l(mMutex);
 269     while (mNotifications.size() == 0) {
 270         mNewNotification.wait(mMutex);
 271     }
 272     return getNextNotificationLocked(msg_type, ext1, ext2, ext3);
 273 }
 274
 275 int NotifierListener::numNotifications() {
 276     Mutex::Autolock l(mMutex);
 277     return mNotifications.size();
 278 }
 279
 280 status_t NotifierListener::getNextNotificationLocked(int32_t *msg_type,
 281         int32_t *ext1,
 282         int32_t *ext2,
 283         int32_t *ext3) {
 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());
 289     return OK;
 290 }
 291
 292 void NotifierListener::onNotify(int32_t msg_type,
 293         int32_t ext1,
 294         int32_t ext2,
 295         int32_t ext3) {
 296     Mutex::Autolock l(mMutex);
 297     mNotifications.push_back(Notification(msg_type, ext1, ext2, ext3));
 298     mNewNotification.signal();
 299 }
 300
 301 void NotifierListener::notify_callback_dispatch(int32_t msg_type,
 302         int32_t ext1,
 303         int32_t ext2,
 304         int32_t ext3,
 305         void *user) {
 306     NotifierListener *me = reinterpret_cast<NotifierListener*>(user);
 307     me->onNotify(msg_type, ext1, ext2, ext3);
 308 }
 309
 310 /**
 311  * StreamAdapter
 312  */
 313
 314 #ifndef container_of
 315 #define container_of(ptr, type, member) \
 316     (type *)((char*)(ptr) - offsetof(type, member))
 317 #endif
 318
 319 StreamAdapter::StreamAdapter(sp<IGraphicBufferProducer> consumer):
 320         mState(UNINITIALIZED), mDevice(NULL),
 321         mId(-1),
 322         mWidth(0), mHeight(0), mFormat(0)
 323 {
 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;
 329 }
 330
 331 StreamAdapter::~StreamAdapter() {
 332     disconnect();
 333 }
 334
 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;
 338     if (d == NULL) {
 339         ALOGE("%s: Null device passed to stream adapter", __FUNCTION__);
 340         return BAD_VALUE;
 341     }
 342
 343     status_t res;
 344
 345     mWidth = width;
 346     mHeight = height;
 347     mFormat = format;
 348
 349     // Allocate device-side stream interface
 350
 351     uint32_t id;
 352     uint32_t formatActual; // ignored
 353     uint32_t usage;
 354     uint32_t maxBuffers = 2;
 355     res = d->ops->allocate_stream(d,
 356             mWidth, mHeight, mFormat, getStreamOps(),
 357             &id, &formatActual, &usage, &maxBuffers);
 358     if (res != OK) {
 359         ALOGE("%s: Device stream allocation failed: %s (%d)",
 360                 __FUNCTION__, strerror(-res), res);
 361         mState = UNINITIALIZED;
 362         return res;
 363     }
 364     mDevice = d;
 365
 366     mId = id;
 367     mUsage = usage;
 368     mMaxProducerBuffers = maxBuffers;
 369
 370     // Configure consumer-side ANativeWindow interface
 371
 372     res = native_window_api_connect(mConsumerInterface.get(),
 373             NATIVE_WINDOW_API_CAMERA);
 374     if (res != OK) {
 375         ALOGE("%s: Unable to connect to native window for stream %d",
 376                 __FUNCTION__, mId);
 377         mState = ALLOCATED;
 378         return res;
 379     }
 380
 381     res = native_window_set_usage(mConsumerInterface.get(), mUsage);
 382     if (res != OK) {
 383         ALOGE("%s: Unable to configure usage %08x for stream %d",
 384                 __FUNCTION__, mUsage, mId);
 385         mState = CONNECTED;
 386         return res;
 387     }
 388
 389     res = native_window_set_buffers_geometry(mConsumerInterface.get(),
 390             mWidth, mHeight, mFormat);
 391     if (res != OK) {
 392         ALOGE("%s: Unable to configure buffer geometry"
 393                 " %d x %d, format 0x%x for stream %d",
 394                 __FUNCTION__, mWidth, mHeight, mFormat, mId);
 395         mState = CONNECTED;
 396         return res;
 397     }
 398
 399     int maxConsumerBuffers;
 400     res = mConsumerInterface->query(mConsumerInterface.get(),
 401             NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, &maxConsumerBuffers);
 402     if (res != OK) {
 403         ALOGE("%s: Unable to query consumer undequeued"
 404                 " buffer count for stream %d", __FUNCTION__, mId);
 405         mState = CONNECTED;
 406         return res;
 407     }
 408     mMaxConsumerBuffers = maxConsumerBuffers;
 409
 410     ALOGV("%s: Producer wants %d buffers, consumer wants %d", __FUNCTION__,
 411             mMaxProducerBuffers, mMaxConsumerBuffers);
 412
 413     int totalBuffers = mMaxConsumerBuffers + mMaxProducerBuffers;
 414
 415     res = native_window_set_buffer_count(mConsumerInterface.get(),
 416             totalBuffers);
 417     if (res != OK) {
 418         ALOGE("%s: Unable to set buffer count for stream %d",
 419                 __FUNCTION__, mId);
 420         mState = CONNECTED;
 421         return res;
 422     }
 423
 424     // Register allocated buffers with HAL device
 425     buffer_handle_t *buffers = new buffer_handle_t[totalBuffers];
 426     ANativeWindowBuffer **anwBuffers = new ANativeWindowBuffer*[totalBuffers];
 427     int bufferIdx = 0;
 428     for (; bufferIdx < totalBuffers; bufferIdx++) {
 429         res = native_window_dequeue_buffer_and_wait(mConsumerInterface.get(),
 430                 &anwBuffers[bufferIdx]);
 431         if (res != OK) {
 432             ALOGE("%s: Unable to dequeue buffer %d for initial registration for"
 433                     "stream %d", __FUNCTION__, bufferIdx, mId);
 434             mState = CONNECTED;
 435             goto cleanUpBuffers;
 436         }
 437         buffers[bufferIdx] = anwBuffers[bufferIdx]->handle;
 438     }
 439
 440     res = mDevice->ops->register_stream_buffers(mDevice,
 441             mId,
 442             totalBuffers,
 443             buffers);
 444     if (res != OK) {
 445         ALOGE("%s: Unable to register buffers with HAL device for stream %d",
 446                 __FUNCTION__, mId);
 447         mState = CONNECTED;
 448     } else {
 449         mState = ACTIVE;
 450     }
 451
 452 cleanUpBuffers:
 453     for (int i = 0; i < bufferIdx; i++) {
 454         res = mConsumerInterface->cancelBuffer(mConsumerInterface.get(),
 455                 anwBuffers[i], -1);
 456     }
 457     delete anwBuffers;
 458     delete buffers;
 459
 460     return res;
 461 }
 462
 463 status_t StreamAdapter::disconnect() {
 464     status_t res;
 465     if (mState >= ALLOCATED) {
 466         res = mDevice->ops->release_stream(mDevice, mId);
 467         if (res != OK) {
 468             ALOGE("%s: Unable to release stream %d",
 469                     __FUNCTION__, mId);
 470             return res;
 471         }
 472     }
 473     if (mState >= CONNECTED) {
 474         res = native_window_api_disconnect(mConsumerInterface.get(),
 475                 NATIVE_WINDOW_API_CAMERA);
 476         if (res != OK) {
 477             ALOGE("%s: Unable to disconnect stream %d from native window",
 478                     __FUNCTION__, mId);
 479             return res;
 480         }
 481     }
 482     mId = -1;
 483     mState = DISCONNECTED;
 484     return OK;
 485 }
 486
 487 int StreamAdapter::getId() {
 488     return mId;
 489 }
 490
 491 const camera2_stream_ops *StreamAdapter::getStreamOps() {
 492     return static_cast<camera2_stream_ops *>(this);
 493 }
 494
 495 ANativeWindow* StreamAdapter::toANW(const camera2_stream_ops_t *w) {
 496     return static_cast<const StreamAdapter*>(w)->mConsumerInterface.get();
 497 }
 498
 499 int StreamAdapter::dequeue_buffer(const camera2_stream_ops_t *w,
 500         buffer_handle_t** buffer) {
 501     int res;
 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;
 506     }
 507
 508     ANativeWindow *a = toANW(w);
 509     ANativeWindowBuffer* anb;
 510     res = native_window_dequeue_buffer_and_wait(a, &anb);
 511     if (res != OK) return res;
 512
 513     *buffer = &(anb->handle);
 514
 515     return res;
 516 }
 517
 518 int StreamAdapter::enqueue_buffer(const camera2_stream_ops_t* w,
 519         int64_t timestamp,
 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;
 525     }
 526     ANativeWindow *a = toANW(w);
 527     status_t err;
 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);
 532 }
 533
 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;
 540     }
 541     ANativeWindow *a = toANW(w);
 542     return a->cancelBuffer(a,
 543             container_of(buffer, ANativeWindowBuffer, handle), -1);
 544 }
 545
 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;
 552     }
 553     ANativeWindow *a = toANW(w);
 554     android_native_rect_t crop = { left, top, right, bottom };
 555     return native_window_set_crop(a, &crop);
 556 }
 557
 558 /**
 559  * FrameWaiter
 560  */
 561
 562 FrameWaiter::FrameWaiter():
 563         mPendingFrames(0) {
 564 }
 565
 566 status_t FrameWaiter::waitForFrame(nsecs_t timeout) {
 567     status_t res;
 568     Mutex::Autolock lock(mMutex);
 569     while (mPendingFrames == 0) {
 570         res = mCondition.waitRelative(mMutex, timeout);
 571         if (res != OK) return res;
 572     }
 573     mPendingFrames--;
 574     return OK;
 575 }
 576
 577 void FrameWaiter::onFrameAvailable(const BufferItem& /* item */) {
 578     Mutex::Autolock lock(mMutex);
 579     mPendingFrames++;
 580     mCondition.signal();
 581 }
 582
 583 int HWModuleHelpers::closeModule(hw_module_t* module) {
 584     int status;
 585
 586     if (!module) {
 587         return -EINVAL;
 588     }
 589
 590     status = dlclose(module->dso);
 591     if (status != 0) {
 592         char const *err_str = dlerror();
 593         ALOGE("%s dlclose failed, error: %s", __func__, err_str ?: "unknown");
 594     }
 595
 596     return status;
 597 }
 598
 599 } // namespace tests
 600 } // namespace camera2
 601 } // namespace android