tests/camera2/CameraStreamFixture.h

   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_HAL_CAMERA2_TESTS_STREAM_FIXTURE__
  18 #define __ANDROID_HAL_CAMERA2_TESTS_STREAM_FIXTURE__
  19
  20 #include <gtest/gtest.h>
  21 #include <iostream>
  22 #include <fstream>
  23
  24 #include <gui/CpuConsumer.h>
  25 #include <gui/Surface.h>
  26 #include <utils/Condition.h>
  27 #include <utils/Mutex.h>
  28 #include <system/camera_metadata.h>
  29
  30 #include "CameraModuleFixture.h"
  31 #include "TestExtensions.h"
  32
  33 #define ALIGN(x, mask) ( ((x) + (mask) - 1) & ~((mask) - 1) )
  34
  35 namespace android {
  36 namespace camera2 {
  37 namespace tests {
  38
  39 // Format specifier for picking the best format for CPU reading the given device
  40 // version
  41 #define CAMERA_STREAM_AUTO_CPU_FORMAT (-1)
  42
  43 struct CameraStreamParams;
  44
  45 void PrintTo(const CameraStreamParams& p, ::std::ostream* os);
  46
  47 struct CameraStreamParams {
  48     int mFormat;
  49     int mHeapCount;
  50
  51 };
  52
  53 inline ::std::ostream& operator<<(::std::ostream& os, const CameraStreamParams &p) {
  54     PrintTo(p, &os);
  55     return os;
  56 }
  57
  58 inline void PrintTo(const CameraStreamParams& p, ::std::ostream* os) {
  59     char fmt[100];
  60     camera_metadata_enum_snprint(
  61         ANDROID_SCALER_AVAILABLE_FORMATS, p.mFormat, fmt, sizeof(fmt));
  62
  63     *os <<  "{ ";
  64     *os <<  "Format: 0x"  << std::hex << p.mFormat    << ", ";
  65     *os <<  "Format name: " << fmt << ", ";
  66     *os <<  "HeapCount: " <<             p.mHeapCount;
  67     *os << " }";
  68 }
  69
  70 class CameraStreamFixture
  71     : public CameraModuleFixture</*InfoQuirk*/true> {
  72
  73 public:
  74     CameraStreamFixture(CameraStreamParams p)
  75     : CameraModuleFixture(TestSettings::DeviceId()) {
  76         TEST_EXTENSION_FORKING_CONSTRUCTOR;
  77
  78         mParam = p;
  79
  80         SetUp();
  81     }
  82
  83     ~CameraStreamFixture() {
  84         TEST_EXTENSION_FORKING_DESTRUCTOR;
  85
  86         TearDown();
  87     }
  88
  89 private:
  90
  91     void SetUp() {
  92         TEST_EXTENSION_FORKING_SET_UP;
  93
  94         CameraModuleFixture::SetUp();
  95
  96         sp<CameraDeviceBase> device = mDevice;
  97
  98         /* use an arbitrary w,h */
  99         if (getDeviceVersion() < CAMERA_DEVICE_API_VERSION_3_2) {
 100             const int tag = ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES;
 101
 102             const CameraMetadata& staticInfo = device->info();
 103             camera_metadata_ro_entry entry = staticInfo.find(tag);
 104             ASSERT_NE(0u, entry.count)
 105                 << "Missing tag android.scaler.availableProcessedSizes";
 106
 107             ASSERT_LE(2u, entry.count);
 108             /* this seems like it would always be the smallest w,h
 109                but we actually make no contract that it's sorted asc */
 110             mWidth = entry.data.i32[0];
 111             mHeight = entry.data.i32[1];
 112         } else {
 113             buildOutputResolutions();
 114             const int32_t *implDefResolutions;
 115             size_t   implDefResolutionsCount;
 116
 117             int format = HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED;
 118
 119             getResolutionList(format,
 120                     &implDefResolutions, &implDefResolutionsCount);
 121             ASSERT_NE(0u, implDefResolutionsCount)
 122                 << "Missing implementation defined sizes";
 123             mWidth = implDefResolutions[0];
 124             mHeight = implDefResolutions[1];
 125         }
 126     }
 127     void TearDown() {
 128         TEST_EXTENSION_FORKING_TEAR_DOWN;
 129
 130         // important: shut down HAL before releasing streams
 131         CameraModuleFixture::TearDown();
 132
 133         deleteOutputResolutions();
 134         mNativeWindow.clear();
 135         mCpuConsumer.clear();
 136         mFrameListener.clear();
 137     }
 138
 139 protected:
 140
 141     int64_t getMinFrameDurationFor(int32_t format, int32_t width, int32_t height) {
 142         int64_t minFrameDuration = -1L;
 143         const int tag = ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS;
 144         sp<CameraDeviceBase> device = mDevice;
 145         const CameraMetadata& staticInfo = device->info();
 146         camera_metadata_ro_entry_t availableMinDurations = staticInfo.find(tag);
 147         for (uint32_t i = 0; i < availableMinDurations.count; i += 4) {
 148             if (format == availableMinDurations.data.i64[i] &&
 149                     width == availableMinDurations.data.i64[i + 1] &&
 150                     height == availableMinDurations.data.i64[i + 2]) {
 151                 minFrameDuration = availableMinDurations.data.i64[i + 3];
 152                 break;
 153             }
 154         }
 155         return minFrameDuration;
 156     }
 157
 158     void buildOutputResolutions() {
 159         if (getDeviceVersion() < CAMERA_DEVICE_API_VERSION_3_2) {
 160             return;
 161         }
 162         if (mOutputResolutions.isEmpty()) {
 163             const int tag = ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS;
 164             const CameraMetadata& staticInfo = mDevice->info();
 165             camera_metadata_ro_entry_t availableStrmConfigs = staticInfo.find(tag);
 166             ASSERT_EQ(0u, availableStrmConfigs.count % 4);
 167             for (uint32_t i = 0; i < availableStrmConfigs.count; i += 4) {
 168                 int32_t format = availableStrmConfigs.data.i32[i];
 169                 int32_t width = availableStrmConfigs.data.i32[i + 1];
 170                 int32_t height = availableStrmConfigs.data.i32[i + 2];
 171                 int32_t inOrOut = availableStrmConfigs.data.i32[i + 3];
 172                 if (inOrOut == ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT) {
 173                     int index = mOutputResolutions.indexOfKey(format);
 174                     if (index < 0) {
 175                         index = mOutputResolutions.add(format, new Vector<int32_t>());
 176                         ASSERT_TRUE(index >= 0);
 177                     }
 178                     Vector<int32_t> *resolutions = mOutputResolutions.editValueAt(index);
 179                     resolutions->add(width);
 180                     resolutions->add(height);
 181                 }
 182             }
 183         }
 184     }
 185
 186     void getResolutionList(int32_t format,
 187             const int32_t **list,
 188             size_t *count) {
 189         status_t res;
 190         ALOGV("Getting resolutions for format %x", format);
 191         if (getDeviceVersion() < CAMERA_DEVICE_API_VERSION_3_2) {
 192             return;
 193         }
 194         int index = mOutputResolutions.indexOfKey(format);
 195         ASSERT_TRUE(index >= 0);
 196         Vector<int32_t>* resolutions = mOutputResolutions.valueAt(index);
 197         *list = resolutions->array();
 198         *count = resolutions->size();
 199     }
 200
 201     void deleteOutputResolutions() {
 202         for (uint32_t i = 0; i < mOutputResolutions.size(); i++) {
 203             Vector<int32_t>* resolutions = mOutputResolutions.editValueAt(i);
 204             delete resolutions;
 205         }
 206         mOutputResolutions.clear();
 207     }
 208
 209     struct FrameListener : public ConsumerBase::FrameAvailableListener {
 210
 211         FrameListener() {
 212             mPendingFrames = 0;
 213         }
 214
 215         // CpuConsumer::FrameAvailableListener implementation
 216         virtual void onFrameAvailable(const BufferItem& /* item */) {
 217             ALOGV("Frame now available (start)");
 218
 219             Mutex::Autolock lock(mMutex);
 220             mPendingFrames++;
 221             mCondition.signal();
 222
 223             ALOGV("Frame now available (end)");
 224         }
 225
 226         status_t waitForFrame(nsecs_t timeout) {
 227             status_t res;
 228             Mutex::Autolock lock(mMutex);
 229             while (mPendingFrames == 0) {
 230                 res = mCondition.waitRelative(mMutex, timeout);
 231                 if (res != OK) return res;
 232             }
 233             mPendingFrames--;
 234             return OK;
 235         }
 236
 237     private:
 238         Mutex mMutex;
 239         Condition mCondition;
 240         int mPendingFrames;
 241     };
 242
 243     void CreateStream() {
 244         sp<CameraDeviceBase> device = mDevice;
 245         CameraStreamParams p = mParam;
 246
 247         sp<IGraphicBufferProducer> producer;
 248         sp<IGraphicBufferConsumer> consumer;
 249         BufferQueue::createBufferQueue(&producer, &consumer);
 250         mCpuConsumer = new CpuConsumer(consumer, p.mHeapCount);
 251         mCpuConsumer->setName(String8("CameraStreamTest::mCpuConsumer"));
 252
 253         mNativeWindow = new Surface(producer);
 254
 255         int format = MapAutoFormat(p.mFormat);
 256
 257         ASSERT_EQ(OK,
 258             device->createStream(mNativeWindow,
 259                 mWidth, mHeight, format,
 260                 &mStreamId));
 261
 262         ASSERT_NE(-1, mStreamId);
 263
 264         // do not make 'this' a FrameListener or the lifetime policy will clash
 265         mFrameListener = new FrameListener();
 266         mCpuConsumer->setFrameAvailableListener(mFrameListener);
 267     }
 268
 269     void DeleteStream() {
 270         ASSERT_EQ(OK, mDevice->deleteStream(mStreamId));
 271     }
 272
 273     int MapAutoFormat(int format) {
 274         if (format == CAMERA_STREAM_AUTO_CPU_FORMAT) {
 275             if (getDeviceVersion() >= CAMERA_DEVICE_API_VERSION_3_0) {
 276                 format = HAL_PIXEL_FORMAT_YCbCr_420_888;
 277             } else {
 278                 format = HAL_PIXEL_FORMAT_YCrCb_420_SP;
 279             }
 280         }
 281         return format;
 282     }
 283
 284     void DumpYuvToFile(const String8 &fileName, const CpuConsumer::LockedBuffer &img) {
 285         uint8_t *dataCb, *dataCr;
 286         uint32_t stride;
 287         uint32_t chromaStride;
 288         uint32_t chromaStep;
 289
 290         switch (img.format) {
 291             case HAL_PIXEL_FORMAT_YCbCr_420_888:
 292                 stride = img.stride;
 293                 chromaStride = img.chromaStride;
 294                 chromaStep = img.chromaStep;
 295                 dataCb = img.dataCb;
 296                 dataCr = img.dataCr;
 297                 break;
 298             case HAL_PIXEL_FORMAT_YCrCb_420_SP:
 299                 stride = img.width;
 300                 chromaStride = img.width;
 301                 chromaStep = 2;
 302                 dataCr = img.data + img.width * img.height;
 303                 dataCb = dataCr + 1;
 304                 break;
 305             case HAL_PIXEL_FORMAT_YV12:
 306                 stride = img.stride;
 307                 chromaStride = ALIGN(img.width / 2, 16);
 308                 chromaStep = 1;
 309                 dataCr = img.data + img.stride * img.height;
 310                 dataCb = dataCr + chromaStride * img.height/2;
 311                 break;
 312             default:
 313                 ALOGE("Unknown format %d, not dumping", img.format);
 314                 return;
 315         }
 316
 317         // Write Y
 318         FILE *yuvFile = fopen(fileName.string(), "w");
 319
 320         size_t bytes;
 321
 322         for (size_t y = 0; y < img.height; ++y) {
 323             bytes = fwrite(
 324                 reinterpret_cast<const char*>(img.data + stride * y),
 325                 1, img.width, yuvFile);
 326             if (bytes != img.width) {
 327                 ALOGE("Unable to write to file %s", fileName.string());
 328                 fclose(yuvFile);
 329                 return;
 330             }
 331         }
 332
 333         // Write Cb/Cr
 334         uint8_t *src = dataCb;
 335         for (int c = 0; c < 2; ++c) {
 336             for (size_t y = 0; y < img.height / 2; ++y) {
 337                 uint8_t *px = src + y * chromaStride;
 338                 if (chromaStep != 1) {
 339                     for (size_t x = 0; x < img.width / 2; ++x) {
 340                         fputc(*px, yuvFile);
 341                         px += chromaStep;
 342                     }
 343                 } else {
 344                     bytes = fwrite(reinterpret_cast<const char*>(px),
 345                             1, img.width / 2, yuvFile);
 346                     if (bytes != img.width / 2) {
 347                         ALOGE("Unable to write to file %s", fileName.string());
 348                         fclose(yuvFile);
 349                         return;
 350                     }
 351                 }
 352             }
 353             src = dataCr;
 354         }
 355         fclose(yuvFile);
 356     }
 357
 358     int mWidth;
 359     int mHeight;
 360
 361     int mStreamId;
 362
 363     android::sp<FrameListener>       mFrameListener;
 364     android::sp<CpuConsumer>         mCpuConsumer;
 365     android::sp<ANativeWindow>       mNativeWindow;
 366     KeyedVector<int32_t, Vector<int32_t>* > mOutputResolutions;
 367
 368 private:
 369     CameraStreamParams mParam;
 370 };
 371
 372 }
 373 }
 374 }
 375
 376 #endif