graphics/composer/2.2/vts/functional/VtsHalGraphicsComposerV2_2TargetTest.cpp

   1 /*
   2  * Copyright (C) 2018 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 #define LOG_TAG "graphics_composer_hidl_hal_test@2.2"
  18
  19 #include <VtsHalHidlTargetTestBase.h>
  20 #include <android-base/logging.h>
  21 #include <android/hardware/graphics/mapper/2.1/IMapper.h>
  22 #include <composer-vts/2.1/GraphicsComposerCallback.h>
  23 #include <composer-vts/2.1/TestCommandReader.h>
  24 #include <composer-vts/2.2/ComposerVts.h>
  25 #include <mapper-vts/2.1/MapperVts.h>
  26
  27 namespace android {
  28 namespace hardware {
  29 namespace graphics {
  30 namespace composer {
  31 namespace V2_2 {
  32 namespace vts {
  33 namespace {
  34
  35 using android::hardware::graphics::common::V1_0::BufferUsage;
  36 using android::hardware::graphics::common::V1_0::ColorTransform;
  37 using android::hardware::graphics::common::V1_0::Transform;
  38 using android::hardware::graphics::common::V1_1::ColorMode;
  39 using android::hardware::graphics::common::V1_1::Dataspace;
  40 using android::hardware::graphics::common::V1_1::PixelFormat;
  41 using android::hardware::graphics::common::V1_1::RenderIntent;
  42 using android::hardware::graphics::composer::V2_2::IComposerClient;
  43 using android::hardware::graphics::mapper::V2_1::IMapper;
  44 using android::hardware::graphics::mapper::V2_1::vts::Gralloc;
  45 using GrallocError = android::hardware::graphics::mapper::V2_0::Error;
  46
  47 // Test environment for graphics.composer
  48 class GraphicsComposerHidlEnvironment : public ::testing::VtsHalHidlTargetTestEnvBase {
  49    public:
  50     // get the test environment singleton
  51     static GraphicsComposerHidlEnvironment* Instance() {
  52         static GraphicsComposerHidlEnvironment* instance = new GraphicsComposerHidlEnvironment;
  53         return instance;
  54     }
  55
  56     virtual void registerTestServices() override { registerTestService<IComposer>(); }
  57
  58    private:
  59     GraphicsComposerHidlEnvironment() {}
  60
  61     GTEST_DISALLOW_COPY_AND_ASSIGN_(GraphicsComposerHidlEnvironment);
  62 };
  63
  64 class GraphicsComposerHidlTest : public ::testing::VtsHalHidlTargetTestBase {
  65    protected:
  66     void SetUp() override {
  67         ASSERT_NO_FATAL_FAILURE(
  68             mComposer = std::make_unique<Composer_v2_2>(
  69                 GraphicsComposerHidlEnvironment::Instance()->getServiceName<IComposer>()));
  70         ASSERT_NO_FATAL_FAILURE(mComposerClient = mComposer->createClient_v2_2());
  71
  72         mComposerCallback = new V2_1::vts::GraphicsComposerCallback;
  73         mComposerClient->registerCallback(mComposerCallback);
  74
  75         // assume the first display is primary and is never removed
  76         mPrimaryDisplay = waitForFirstDisplay();
  77
  78         // explicitly disable vsync
  79         mComposerClient->setVsyncEnabled(mPrimaryDisplay, false);
  80         mComposerCallback->setVsyncAllowed(false);
  81
  82         mComposerClient->getRaw()->getReadbackBufferAttributes(
  83             mPrimaryDisplay, [&](const auto& tmpError, const auto&, const auto&) {
  84                 mHasReadbackBuffer = tmpError == Error::NONE;
  85             });
  86     }
  87
  88     void TearDown() override {
  89         if (mComposerCallback != nullptr) {
  90             EXPECT_EQ(0, mComposerCallback->getInvalidHotplugCount());
  91             EXPECT_EQ(0, mComposerCallback->getInvalidRefreshCount());
  92             EXPECT_EQ(0, mComposerCallback->getInvalidVsyncCount());
  93         }
  94     }
  95
  96     // use the slot count usually set by SF
  97     static constexpr uint32_t kBufferSlotCount = 64;
  98
  99     std::unique_ptr<Composer_v2_2> mComposer;
 100     std::unique_ptr<ComposerClient_v2_2> mComposerClient;
 101     sp<V2_1::vts::GraphicsComposerCallback> mComposerCallback;
 102     // the first display and is assumed never to be removed
 103     Display mPrimaryDisplay;
 104     bool mHasReadbackBuffer;
 105
 106    private:
 107     Display waitForFirstDisplay() {
 108         while (true) {
 109             std::vector<Display> displays = mComposerCallback->getDisplays();
 110             if (displays.empty()) {
 111                 usleep(5 * 1000);
 112                 continue;
 113             }
 114
 115             return displays[0];
 116         }
 117     }
 118 };
 119
 120 // Tests for IComposerClient::Command.
 121 class GraphicsComposerHidlCommandTest : public GraphicsComposerHidlTest {
 122    protected:
 123     void SetUp() override {
 124         ASSERT_NO_FATAL_FAILURE(GraphicsComposerHidlTest::SetUp());
 125
 126         ASSERT_NO_FATAL_FAILURE(mGralloc = std::make_unique<Gralloc>());
 127
 128         mWriter = std::make_unique<V2_2::CommandWriterBase>(1024);
 129         mReader = std::make_unique<V2_1::vts::TestCommandReader>();
 130     }
 131
 132     void TearDown() override { ASSERT_NO_FATAL_FAILURE(GraphicsComposerHidlTest::TearDown()); }
 133
 134     const native_handle_t* allocate() {
 135         IMapper::BufferDescriptorInfo info{};
 136         info.width = 64;
 137         info.height = 64;
 138         info.layerCount = 1;
 139         info.format = PixelFormat::RGBA_8888;
 140         info.usage =
 141             static_cast<uint64_t>(BufferUsage::CPU_WRITE_OFTEN | BufferUsage::CPU_READ_OFTEN);
 142
 143         return mGralloc->allocate(info);
 144     }
 145
 146     void execute() { mComposerClient->execute_v2_2(mReader.get(), mWriter.get()); }
 147
 148     std::unique_ptr<V2_2::CommandWriterBase> mWriter;
 149     std::unique_ptr<V2_1::vts::TestCommandReader> mReader;
 150
 151    private:
 152     std::unique_ptr<Gralloc> mGralloc;
 153 };
 154
 155 /**
 156  * Test IComposerClient::Command::SET_LAYER_PER_FRAME_METADATA.
 157  */
 158 TEST_F(GraphicsComposerHidlCommandTest, SET_LAYER_PER_FRAME_METADATA) {
 159     Layer layer;
 160     ASSERT_NO_FATAL_FAILURE(layer =
 161                                 mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
 162
 163     mWriter->selectDisplay(mPrimaryDisplay);
 164     mWriter->selectLayer(layer);
 165
 166     /**
 167      * DISPLAY_P3 is a color space that uses the DCI_P3 primaries,
 168      * the D65 white point and the SRGB transfer functions.
 169      * Rendering Intent: Colorimetric
 170      * Primaries:
 171      *                  x       y
 172      *  green           0.265   0.690
 173      *  blue            0.150   0.060
 174      *  red             0.680   0.320
 175      *  white (D65)     0.3127  0.3290
 176      */
 177
 178     std::vector<IComposerClient::PerFrameMetadata> hidlMetadata;
 179     hidlMetadata.push_back({IComposerClient::PerFrameMetadataKey::DISPLAY_RED_PRIMARY_X, 0.680});
 180     hidlMetadata.push_back({IComposerClient::PerFrameMetadataKey::DISPLAY_RED_PRIMARY_Y, 0.320});
 181     hidlMetadata.push_back({IComposerClient::PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_X, 0.265});
 182     hidlMetadata.push_back({IComposerClient::PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_Y, 0.690});
 183     hidlMetadata.push_back({IComposerClient::PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_X, 0.150});
 184     hidlMetadata.push_back({IComposerClient::PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_Y, 0.060});
 185     hidlMetadata.push_back({IComposerClient::PerFrameMetadataKey::WHITE_POINT_X, 0.3127});
 186     hidlMetadata.push_back({IComposerClient::PerFrameMetadataKey::WHITE_POINT_Y, 0.3290});
 187     hidlMetadata.push_back({IComposerClient::PerFrameMetadataKey::MAX_LUMINANCE, 100.0});
 188     hidlMetadata.push_back({IComposerClient::PerFrameMetadataKey::MIN_LUMINANCE, 0.1});
 189     hidlMetadata.push_back({IComposerClient::PerFrameMetadataKey::MAX_CONTENT_LIGHT_LEVEL, 78.0});
 190     hidlMetadata.push_back(
 191         {IComposerClient::PerFrameMetadataKey::MAX_FRAME_AVERAGE_LIGHT_LEVEL, 62.0});
 192     mWriter->setLayerPerFrameMetadata(hidlMetadata);
 193     execute();
 194 }
 195
 196 /**
 197  * Test IComposerClient::getPerFrameMetadataKeys.
 198  */
 199 TEST_F(GraphicsComposerHidlTest, GetPerFrameMetadataKeys) {
 200     mComposerClient->getPerFrameMetadataKeys(mPrimaryDisplay);
 201 }
 202
 203 /**
 204  * Test IComposerClient::createVirtualDisplay_2_2 and
 205  * IComposerClient::destroyVirtualDisplay.
 206  *
 207  * Test that virtual displays can be created and has the correct display type.
 208  */
 209 TEST_F(GraphicsComposerHidlTest, CreateVirtualDisplay_2_2) {
 210     if (mComposerClient->getMaxVirtualDisplayCount() == 0) {
 211         GTEST_SUCCEED() << "no virtual display support";
 212         return;
 213     }
 214
 215     Display display;
 216     PixelFormat format;
 217     ASSERT_NO_FATAL_FAILURE(
 218         display = mComposerClient->createVirtualDisplay_2_2(
 219             64, 64, PixelFormat::IMPLEMENTATION_DEFINED, kBufferSlotCount, &format));
 220
 221     // test display type
 222     IComposerClient::DisplayType type = mComposerClient->getDisplayType(display);
 223     EXPECT_EQ(IComposerClient::DisplayType::VIRTUAL, type);
 224
 225     mComposerClient->destroyVirtualDisplay(display);
 226 }
 227
 228 /**
 229  * Test IComposerClient::getClientTargetSupport_2_2.
 230  *
 231  * Test that IComposerClient::getClientTargetSupport returns true for the
 232  * required client targets.
 233  */
 234 TEST_F(GraphicsComposerHidlTest, GetClientTargetSupport_2_2) {
 235     std::vector<Config> configs = mComposerClient->getDisplayConfigs(mPrimaryDisplay);
 236     for (auto config : configs) {
 237         int32_t width = mComposerClient->getDisplayAttribute(mPrimaryDisplay, config,
 238                                                              IComposerClient::Attribute::WIDTH);
 239         int32_t height = mComposerClient->getDisplayAttribute(mPrimaryDisplay, config,
 240                                                               IComposerClient::Attribute::HEIGHT);
 241         ASSERT_LT(0, width);
 242         ASSERT_LT(0, height);
 243
 244         mComposerClient->setActiveConfig(mPrimaryDisplay, config);
 245
 246         ASSERT_TRUE(mComposerClient->getClientTargetSupport_2_2(
 247             mPrimaryDisplay, width, height, PixelFormat::RGBA_8888, Dataspace::UNKNOWN));
 248     }
 249 }
 250
 251 /**
 252  * Test IComposerClient::setPowerMode_2_2.
 253  */
 254 TEST_F(GraphicsComposerHidlTest, setPowerMode_2_2) {
 255     std::vector<IComposerClient::PowerMode> modes;
 256     modes.push_back(IComposerClient::PowerMode::OFF);
 257     modes.push_back(IComposerClient::PowerMode::ON_SUSPEND);
 258     modes.push_back(IComposerClient::PowerMode::ON);
 259
 260     for (auto mode : modes) {
 261         mComposerClient->setPowerMode_2_2(mPrimaryDisplay, mode);
 262     }
 263 }
 264
 265 TEST_F(GraphicsComposerHidlTest, setReadbackBuffer) {
 266     if (!mHasReadbackBuffer) {
 267         return;
 268     }
 269
 270     PixelFormat pixelFormat;
 271     Dataspace dataspace;
 272     mComposerClient->getReadbackBufferAttributes(mPrimaryDisplay, &pixelFormat, &dataspace);
 273     ASSERT_LT(static_cast<PixelFormat>(0), pixelFormat);
 274     ASSERT_NE(Dataspace::UNKNOWN, dataspace);
 275
 276     IMapper::BufferDescriptorInfo info{};
 277     Config config = mComposerClient->getActiveConfig(mPrimaryDisplay);
 278     info.width = mComposerClient->getDisplayAttribute(mPrimaryDisplay, config,
 279                                                       IComposerClient::Attribute::WIDTH);
 280     info.height = mComposerClient->getDisplayAttribute(mPrimaryDisplay, config,
 281                                                        IComposerClient::Attribute::HEIGHT);
 282     info.layerCount = 1;
 283     info.format = pixelFormat;
 284     // BufferUsage::COMPOSER_OUTPUT is missing
 285     info.usage = static_cast<uint64_t>(BufferUsage::COMPOSER_OVERLAY | BufferUsage::CPU_READ_OFTEN);
 286
 287     std::unique_ptr<Gralloc> gralloc;
 288     const native_handle_t* buffer;
 289     ASSERT_NO_FATAL_FAILURE(gralloc = std::make_unique<Gralloc>());
 290     ASSERT_NO_FATAL_FAILURE(buffer = gralloc->allocate(info));
 291
 292     mComposerClient->setReadbackBuffer(mPrimaryDisplay, buffer, -1);
 293 }
 294
 295 TEST_F(GraphicsComposerHidlTest, getReadbackBufferFenceInactive) {
 296     if (!mHasReadbackBuffer) {
 297         return;
 298     }
 299
 300     mComposerClient->getRaw()->getReadbackBufferFence(
 301         mPrimaryDisplay, [&](const auto& tmpError, const auto&) {
 302             ASSERT_EQ(Error::UNSUPPORTED, tmpError) << "readback buffer is active";
 303         });
 304 }
 305
 306 /**
 307  * Test IComposerClient::Command::SET_LAYER_FLOAT_COLOR.
 308  */
 309 TEST_F(GraphicsComposerHidlCommandTest, SET_LAYER_FLOAT_COLOR) {
 310     V2_1::Layer layer;
 311     ASSERT_NO_FATAL_FAILURE(layer =
 312                                 mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
 313
 314     mWriter->selectDisplay(mPrimaryDisplay);
 315     mWriter->selectLayer(layer);
 316     mWriter->setLayerFloatColor(IComposerClient::FloatColor{1.0, 1.0, 1.0, 1.0});
 317     mWriter->setLayerFloatColor(IComposerClient::FloatColor{0.0, 0.0, 0.0, 0.0});
 318 }
 319
 320 /**
 321  * Test IComposerClient::getDataspaceSaturationMatrix.
 322  */
 323 TEST_F(GraphicsComposerHidlTest, getDataspaceSaturationMatrix) {
 324     auto matrix = mComposerClient->getDataspaceSaturationMatrix(Dataspace::SRGB_LINEAR);
 325     // the last row is known
 326     ASSERT_EQ(0.0f, matrix[12]);
 327     ASSERT_EQ(0.0f, matrix[13]);
 328     ASSERT_EQ(0.0f, matrix[14]);
 329     ASSERT_EQ(1.0f, matrix[15]);
 330 }
 331
 332 /**
 333  * Test IComposerClient::getColorMode_2_2.
 334  */
 335 TEST_F(GraphicsComposerHidlTest, GetColorMode_2_2) {
 336     std::vector<ColorMode> modes = mComposerClient->getColorModes(mPrimaryDisplay);
 337
 338     auto nativeMode = std::find(modes.cbegin(), modes.cend(), ColorMode::NATIVE);
 339     EXPECT_NE(modes.cend(), nativeMode);
 340 }
 341
 342 /**
 343  * Test IComposerClient::getRenderIntent.
 344  */
 345 TEST_F(GraphicsComposerHidlTest, GetRenderIntent) {
 346     std::vector<ColorMode> modes = mComposerClient->getColorModes(mPrimaryDisplay);
 347     for (auto mode : modes) {
 348         std::vector<RenderIntent> intents =
 349             mComposerClient->getRenderIntents(mPrimaryDisplay, mode);
 350
 351         bool isHdr;
 352         switch (mode) {
 353             case ColorMode::BT2100_PQ:
 354             case ColorMode::BT2100_HLG:
 355                 isHdr = true;
 356                 break;
 357             default:
 358                 isHdr = false;
 359                 break;
 360         }
 361         RenderIntent requiredIntent =
 362             isHdr ? RenderIntent::TONE_MAP_COLORIMETRIC : RenderIntent::COLORIMETRIC;
 363
 364         auto iter = std::find(intents.cbegin(), intents.cend(), requiredIntent);
 365         EXPECT_NE(intents.cend(), iter);
 366     }
 367 }
 368
 369 /**
 370  * Test IComposerClient::setColorMode_2_2.
 371  */
 372 TEST_F(GraphicsComposerHidlTest, SetColorMode_2_2) {
 373     std::vector<ColorMode> modes = mComposerClient->getColorModes(mPrimaryDisplay);
 374     for (auto mode : modes) {
 375         std::vector<RenderIntent> intents =
 376             mComposerClient->getRenderIntents(mPrimaryDisplay, mode);
 377         for (auto intent : intents) {
 378             mComposerClient->setColorMode(mPrimaryDisplay, mode, intent);
 379         }
 380     }
 381 }
 382
 383 }  // namespace
 384 }  // namespace vts
 385 }  // namespace V2_2
 386 }  // namespace composer
 387 }  // namespace graphics
 388 }  // namespace hardware
 389 }  // namespace android
 390
 391 int main(int argc, char** argv) {
 392     using android::hardware::graphics::composer::V2_2::vts::GraphicsComposerHidlEnvironment;
 393     ::testing::AddGlobalTestEnvironment(GraphicsComposerHidlEnvironment::Instance());
 394     ::testing::InitGoogleTest(&argc, argv);
 395     GraphicsComposerHidlEnvironment::Instance()->init(&argc, argv);
 396     int status = RUN_ALL_TESTS();
 397     return status;
 398 }