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
  83     void TearDown() override {
  84         if (mComposerCallback != nullptr) {
  85             EXPECT_EQ(0, mComposerCallback->getInvalidHotplugCount());
  86             EXPECT_EQ(0, mComposerCallback->getInvalidRefreshCount());
  87             EXPECT_EQ(0, mComposerCallback->getInvalidVsyncCount());
  88         }
  89     }
  90
  91     // use the slot count usually set by SF
  92     static constexpr uint32_t kBufferSlotCount = 64;
  93
  94     std::unique_ptr<Composer_v2_2> mComposer;
  95     std::unique_ptr<ComposerClient_v2_2> mComposerClient;
  96     sp<V2_1::vts::GraphicsComposerCallback> mComposerCallback;
  97     // the first display and is assumed never to be removed
  98     Display mPrimaryDisplay;
  99
 100    private:
 101     Display waitForFirstDisplay() {
 102         while (true) {
 103             std::vector<Display> displays = mComposerCallback->getDisplays();
 104             if (displays.empty()) {
 105                 usleep(5 * 1000);
 106                 continue;
 107             }
 108
 109             return displays[0];
 110         }
 111     }
 112 };
 113
 114 // Tests for IComposerClient::Command.
 115 class GraphicsComposerHidlCommandTest : public GraphicsComposerHidlTest {
 116    protected:
 117     void SetUp() override {
 118         ASSERT_NO_FATAL_FAILURE(GraphicsComposerHidlTest::SetUp());
 119
 120         ASSERT_NO_FATAL_FAILURE(mGralloc = std::make_unique<Gralloc>());
 121
 122         mWriter = std::make_unique<V2_2::CommandWriterBase>(1024);
 123         mReader = std::make_unique<V2_1::vts::TestCommandReader>();
 124     }
 125
 126     void TearDown() override { ASSERT_NO_FATAL_FAILURE(GraphicsComposerHidlTest::TearDown()); }
 127
 128     const native_handle_t* allocate() {
 129         IMapper::BufferDescriptorInfo info{};
 130         info.width = 64;
 131         info.height = 64;
 132         info.layerCount = 1;
 133         info.format = PixelFormat::RGBA_8888;
 134         info.usage =
 135             static_cast<uint64_t>(BufferUsage::CPU_WRITE_OFTEN | BufferUsage::CPU_READ_OFTEN);
 136
 137         return mGralloc->allocate(info);
 138     }
 139
 140     void execute() { mComposerClient->execute_v2_2(mReader.get(), mWriter.get()); }
 141
 142     std::unique_ptr<V2_2::CommandWriterBase> mWriter;
 143     std::unique_ptr<V2_1::vts::TestCommandReader> mReader;
 144
 145    private:
 146     std::unique_ptr<Gralloc> mGralloc;
 147 };
 148
 149 /**
 150  * Test IComposerClient::Command::SET_LAYER_PER_FRAME_METADATA.
 151  */
 152 TEST_F(GraphicsComposerHidlCommandTest, SET_LAYER_PER_FRAME_METADATA) {
 153     Layer layer;
 154     ASSERT_NO_FATAL_FAILURE(layer =
 155                                 mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
 156
 157     mWriter->selectDisplay(mPrimaryDisplay);
 158     mWriter->selectLayer(layer);
 159
 160     /**
 161      * DISPLAY_P3 is a color space that uses the DCI_P3 primaries,
 162      * the D65 white point and the SRGB transfer functions.
 163      * Rendering Intent: Colorimetric
 164      * Primaries:
 165      *                  x       y
 166      *  green           0.265   0.690
 167      *  blue            0.150   0.060
 168      *  red             0.680   0.320
 169      *  white (D65)     0.3127  0.3290
 170      */
 171
 172     std::vector<IComposerClient::PerFrameMetadata> hidlMetadata;
 173     hidlMetadata.push_back({IComposerClient::PerFrameMetadataKey::DISPLAY_RED_PRIMARY_X, 0.680});
 174     hidlMetadata.push_back({IComposerClient::PerFrameMetadataKey::DISPLAY_RED_PRIMARY_Y, 0.320});
 175     hidlMetadata.push_back({IComposerClient::PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_X, 0.265});
 176     hidlMetadata.push_back({IComposerClient::PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_Y, 0.690});
 177     hidlMetadata.push_back({IComposerClient::PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_X, 0.150});
 178     hidlMetadata.push_back({IComposerClient::PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_Y, 0.060});
 179     hidlMetadata.push_back({IComposerClient::PerFrameMetadataKey::WHITE_POINT_X, 0.3127});
 180     hidlMetadata.push_back({IComposerClient::PerFrameMetadataKey::WHITE_POINT_Y, 0.3290});
 181     hidlMetadata.push_back({IComposerClient::PerFrameMetadataKey::MAX_LUMINANCE, 100.0});
 182     hidlMetadata.push_back({IComposerClient::PerFrameMetadataKey::MIN_LUMINANCE, 0.1});
 183     hidlMetadata.push_back({IComposerClient::PerFrameMetadataKey::MAX_CONTENT_LIGHT_LEVEL, 78.0});
 184     hidlMetadata.push_back(
 185         {IComposerClient::PerFrameMetadataKey::MAX_FRAME_AVERAGE_LIGHT_LEVEL, 62.0});
 186     mWriter->setLayerPerFrameMetadata(hidlMetadata);
 187     execute();
 188 }
 189
 190 /**
 191  * Test IComposerClient::getPerFrameMetadataKeys.
 192  */
 193 TEST_F(GraphicsComposerHidlTest, GetPerFrameMetadataKeys) {
 194     mComposerClient->getPerFrameMetadataKeys(mPrimaryDisplay);
 195 }
 196
 197 /**
 198  * Test IComposerClient::createVirtualDisplay_2_2 and
 199  * IComposerClient::destroyVirtualDisplay.
 200  *
 201  * Test that virtual displays can be created and has the correct display type.
 202  */
 203 TEST_F(GraphicsComposerHidlTest, CreateVirtualDisplay_2_2) {
 204     if (mComposerClient->getMaxVirtualDisplayCount() == 0) {
 205         GTEST_SUCCEED() << "no virtual display support";
 206         return;
 207     }
 208
 209     Display display;
 210     PixelFormat format;
 211     ASSERT_NO_FATAL_FAILURE(
 212         display = mComposerClient->createVirtualDisplay_2_2(
 213             64, 64, PixelFormat::IMPLEMENTATION_DEFINED, kBufferSlotCount, &format));
 214
 215     // test display type
 216     IComposerClient::DisplayType type = mComposerClient->getDisplayType(display);
 217     EXPECT_EQ(IComposerClient::DisplayType::VIRTUAL, type);
 218
 219     mComposerClient->destroyVirtualDisplay(display);
 220 }
 221
 222 /**
 223  * Test IComposerClient::getClientTargetSupport_2_2.
 224  *
 225  * Test that IComposerClient::getClientTargetSupport returns true for the
 226  * required client targets.
 227  */
 228 TEST_F(GraphicsComposerHidlTest, GetClientTargetSupport_2_2) {
 229     std::vector<Config> configs = mComposerClient->getDisplayConfigs(mPrimaryDisplay);
 230     for (auto config : configs) {
 231         int32_t width = mComposerClient->getDisplayAttribute(mPrimaryDisplay, config,
 232                                                              IComposerClient::Attribute::WIDTH);
 233         int32_t height = mComposerClient->getDisplayAttribute(mPrimaryDisplay, config,
 234                                                               IComposerClient::Attribute::HEIGHT);
 235         ASSERT_LT(0, width);
 236         ASSERT_LT(0, height);
 237
 238         mComposerClient->setActiveConfig(mPrimaryDisplay, config);
 239
 240         ASSERT_TRUE(mComposerClient->getClientTargetSupport_2_2(
 241             mPrimaryDisplay, width, height, PixelFormat::RGBA_8888, Dataspace::UNKNOWN));
 242     }
 243 }
 244
 245 /**
 246  * Test IComposerClient::setPowerMode_2_2.
 247  */
 248 TEST_F(GraphicsComposerHidlTest, setPowerMode_2_2) {
 249     std::vector<IComposerClient::PowerMode> modes;
 250     modes.push_back(IComposerClient::PowerMode::OFF);
 251     modes.push_back(IComposerClient::PowerMode::ON_SUSPEND);
 252     modes.push_back(IComposerClient::PowerMode::ON);
 253
 254     for (auto mode : modes) {
 255         mComposerClient->setPowerMode_2_2(mPrimaryDisplay, mode);
 256     }
 257 }
 258
 259 TEST_F(GraphicsComposerHidlTest, setReadbackBuffer) {
 260     mComposerClient->setReadbackBuffer(mPrimaryDisplay, nullptr, -1);
 261 }
 262
 263 TEST_F(GraphicsComposerHidlTest, getReadbackBufferFence) {
 264     int32_t fence;
 265     mComposerClient->getReadbackBufferFence(mPrimaryDisplay, &fence);
 266 }
 267
 268 TEST_F(GraphicsComposerHidlTest, getReadbackBufferAttributes) {
 269     PixelFormat pixelFormat;
 270     Dataspace dataspace;
 271     mComposerClient->getReadbackBufferAttributes(mPrimaryDisplay, &pixelFormat, &dataspace);
 272 }
 273
 274 /**
 275  * Test IComposerClient::Command::SET_LAYER_FLOAT_COLOR.
 276  */
 277 TEST_F(GraphicsComposerHidlCommandTest, SET_LAYER_FLOAT_COLOR) {
 278     V2_1::Layer layer;
 279     ASSERT_NO_FATAL_FAILURE(layer =
 280                                 mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
 281
 282     mWriter->selectDisplay(mPrimaryDisplay);
 283     mWriter->selectLayer(layer);
 284     mWriter->setLayerFloatColor(IComposerClient::FloatColor{1.0, 1.0, 1.0, 1.0});
 285     mWriter->setLayerFloatColor(IComposerClient::FloatColor{0.0, 0.0, 0.0, 0.0});
 286 }
 287
 288 /**
 289  * Test IComposerClient::getDataspaceSaturationMatrix.
 290  */
 291 TEST_F(GraphicsComposerHidlTest, getDataspaceSaturationMatrix) {
 292     auto matrix = mComposerClient->getDataspaceSaturationMatrix(Dataspace::SRGB_LINEAR);
 293     // the last row is known
 294     ASSERT_EQ(0.0f, matrix[12]);
 295     ASSERT_EQ(0.0f, matrix[13]);
 296     ASSERT_EQ(0.0f, matrix[14]);
 297     ASSERT_EQ(1.0f, matrix[15]);
 298 }
 299
 300 /**
 301  * Test IComposerClient::getColorMode_2_2.
 302  */
 303 TEST_F(GraphicsComposerHidlTest, GetColorMode_2_2) {
 304     std::vector<ColorMode> modes = mComposerClient->getColorModes(mPrimaryDisplay);
 305
 306     auto nativeMode = std::find(modes.cbegin(), modes.cend(), ColorMode::NATIVE);
 307     EXPECT_NE(modes.cend(), nativeMode);
 308 }
 309
 310 /**
 311  * Test IComposerClient::getRenderIntent.
 312  */
 313 TEST_F(GraphicsComposerHidlTest, GetRenderIntent) {
 314     std::vector<ColorMode> modes = mComposerClient->getColorModes(mPrimaryDisplay);
 315     for (auto mode : modes) {
 316         std::vector<RenderIntent> intents =
 317             mComposerClient->getRenderIntents(mPrimaryDisplay, mode);
 318         auto colorimetricIntent =
 319             std::find(intents.cbegin(), intents.cend(), RenderIntent::COLORIMETRIC);
 320         EXPECT_NE(intents.cend(), colorimetricIntent);
 321     }
 322 }
 323
 324 /**
 325  * Test IComposerClient::setColorMode_2_2.
 326  */
 327 TEST_F(GraphicsComposerHidlTest, SetColorMode_2_2) {
 328     std::vector<ColorMode> modes = mComposerClient->getColorModes(mPrimaryDisplay);
 329     for (auto mode : modes) {
 330         std::vector<RenderIntent> intents =
 331             mComposerClient->getRenderIntents(mPrimaryDisplay, mode);
 332         for (auto intent : intents) {
 333             mComposerClient->setColorMode(mPrimaryDisplay, mode, intent);
 334         }
 335     }
 336 }
 337
 338 }  // namespace
 339 }  // namespace vts
 340 }  // namespace V2_2
 341 }  // namespace composer
 342 }  // namespace graphics
 343 }  // namespace hardware
 344 }  // namespace android
 345
 346 int main(int argc, char** argv) {
 347     using android::hardware::graphics::composer::V2_2::vts::GraphicsComposerHidlEnvironment;
 348     ::testing::AddGlobalTestEnvironment(GraphicsComposerHidlEnvironment::Instance());
 349     ::testing::InitGoogleTest(&argc, argv);
 350     GraphicsComposerHidlEnvironment::Instance()->init(&argc, argv);
 351     int status = RUN_ALL_TESTS();
 352     return status;
 353 }