blob: 14d07254ea220c7965958aa7c31bbeae0222bed7 [file]
// Copyright 2020 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "src/graphics/display/drivers/coordinator/layer.h"
#include <fidl/fuchsia.hardware.display.types/cpp/wire.h>
#include <fidl/fuchsia.math/cpp/wire.h>
#include <lib/driver/testing/cpp/driver_runtime.h>
#include <lib/driver/testing/cpp/scoped_global_logger.h>
#include <lib/fit/defer.h>
#include <lib/sync/cpp/completion.h>
#include <lib/zx/result.h>
#include <cstdint>
#include <format>
#include <fbl/intrusive_double_list.h>
#include <fbl/ref_ptr.h>
#include <gtest/gtest.h>
#include "src/graphics/display/drivers/coordinator/fence.h"
#include "src/graphics/display/drivers/coordinator/image-lifecycle-listener.h"
#include "src/graphics/display/drivers/coordinator/image.h"
#include "src/graphics/display/lib/api-types/cpp/alpha-mode.h"
#include "src/graphics/display/lib/api-types/cpp/color.h"
#include "src/graphics/display/lib/api-types/cpp/coordinate-transformation.h"
#include "src/graphics/display/lib/api-types/cpp/driver-image-id.h"
#include "src/graphics/display/lib/api-types/cpp/driver-layer.h"
#include "src/graphics/display/lib/api-types/cpp/event-id.h"
#include "src/graphics/display/lib/api-types/cpp/image-id.h"
#include "src/graphics/display/lib/api-types/cpp/image-metadata.h"
#include "src/graphics/display/lib/api-types/cpp/layer-id.h"
#include "src/graphics/display/lib/api-types/cpp/pixel-format.h"
#include "src/graphics/display/lib/api-types/cpp/rectangle.h"
#include "src/lib/testing/predicates/status.h"
namespace display_coordinator {
namespace {
class StubImageLifecycleListener : public ImageLifecycleListener {
public:
using ImageWillBeDestroyedChecker = fit::function<void(display::DriverImageId)>;
StubImageLifecycleListener() = default;
~StubImageLifecycleListener() = default;
StubImageLifecycleListener(const StubImageLifecycleListener&) = delete;
StubImageLifecycleListener& operator=(const StubImageLifecycleListener&) = delete;
// ImageLifecycleListener:
void ImageWillBeDestroyed(display::DriverImageId driver_image_id) override {}
};
class StubFenceListener : public FenceListener {
public:
StubFenceListener() = default;
~StubFenceListener() = default;
StubFenceListener(const StubFenceListener&) = delete;
StubFenceListener& operator=(const StubFenceListener&) = delete;
// `FenceListener`:
void OnFenceSignaled(Fence& fence) override {}
};
} // namespace
class LayerTest : public ::testing::Test {
public:
LayerTest() : fences_(&fence_listener_, driver_runtime_.GetForegroundDispatcher()->borrow()) {}
fbl::RefPtr<Image> CreateReadyImage() {
static constexpr ClientId kClientId(1);
static constexpr display::ImageMetadata kImageMetadata({
.width = kDisplayWidth,
.height = kDisplayHeight,
.tiling_type = display::ImageTilingType::kLinear,
});
display::ImageId image_id = next_image_id_;
++next_image_id_;
display::DriverImageId driver_image_id = next_driver_image_id_;
++next_driver_image_id_;
fbl::RefPtr<Image> image = fbl::AdoptRef(new Image(
&image_lifecycle_listener_, kImageMetadata, image_id, driver_image_id, nullptr, kClientId));
return image;
}
static void MakeLayerCommitted(
Layer& layer, fbl::DoublyLinkedList<LayerNode*>& committed_display_config_layer_list) {
committed_display_config_layer_list.push_front(&layer.committed_display_config_list_node_);
}
static const display::DriverLayer& GetDraftLayerConfig(const Layer& layer) {
return layer.draft_layer_config_;
}
protected:
fdf_testing::ScopedGlobalLogger logger_;
fdf_testing::DriverRuntime driver_runtime_;
static constexpr uint32_t kDisplayWidth = 1024;
static constexpr uint32_t kDisplayHeight = 600;
display::ImageId next_image_id_ = display::ImageId(1000);
display::DriverImageId next_driver_image_id_ = display::DriverImageId(2000);
StubImageLifecycleListener image_lifecycle_listener_;
StubFenceListener fence_listener_;
FenceCollection fences_;
};
TEST_F(LayerTest, PrimaryBasic) {
Layer layer(display::LayerId(1));
const display::ImageMetadata image_metadata({.width = kDisplayWidth,
.height = kDisplayHeight,
.tiling_type = display::ImageTilingType::kLinear});
const display::Rectangle display_area(
{.x = 0, .y = 0, .width = kDisplayWidth, .height = kDisplayHeight});
layer.SetPrimaryConfig(image_metadata);
layer.SetPrimaryPosition(display::CoordinateTransformation::kIdentity, display_area,
display_area);
layer.SetPrimaryAlpha(display::AlphaMode::kDisable, 0);
fbl::RefPtr<Image> image = CreateReadyImage();
layer.SetImage(image, display::kInvalidEventId);
layer.CommitChanges();
}
TEST_F(LayerTest, SetPrimaryConfigResetsPrimaryProperties) {
Layer layer(display::LayerId(1));
const display::ImageMetadata image_metadata({.width = kDisplayWidth,
.height = kDisplayHeight,
.tiling_type = display::ImageTilingType::kLinear});
const display::Rectangle image_area(
{.x = 0, .y = 0, .width = kDisplayWidth, .height = kDisplayHeight});
const display::Rectangle cropped_area(
{.x = 10, .y = 20, .width = kDisplayWidth / 2, .height = kDisplayHeight / 2});
layer.SetPrimaryConfig(image_metadata);
layer.SetPrimaryPosition(display::CoordinateTransformation::kReflectY, cropped_area,
cropped_area);
layer.SetPrimaryAlpha(display::AlphaMode::kPremultiplied, 0.25f);
// Calling `SetPrimaryConfig()` on a primary layer resets all primary layer
// properties, even if the image metadata does not change.
layer.SetPrimaryConfig(image_metadata);
const display::DriverLayer& draft = GetDraftLayerConfig(layer);
EXPECT_EQ(draft.image_metadata(), image_metadata);
EXPECT_EQ(draft.image_source(), image_area);
EXPECT_EQ(draft.display_destination(), image_area);
EXPECT_EQ(draft.image_source_transformation(), display::CoordinateTransformation::kIdentity);
EXPECT_EQ(draft.alpha_mode(), display::AlphaMode::kDisable);
EXPECT_EQ(draft.alpha_coefficient(), 1.0f);
}
TEST_F(LayerTest, SetColorConfigDoesNotInheritPrimaryProperties) {
Layer layer(display::LayerId(1));
const display::ImageMetadata image_metadata({.width = kDisplayWidth,
.height = kDisplayHeight,
.tiling_type = display::ImageTilingType::kLinear});
const display::Rectangle display_area(
{.x = 0, .y = 0, .width = kDisplayWidth, .height = kDisplayHeight});
layer.SetPrimaryConfig(image_metadata);
layer.SetPrimaryPosition(display::CoordinateTransformation::kReflectY, display_area,
display_area);
layer.SetPrimaryAlpha(display::AlphaMode::kHwMultiply, 0.02f);
// Translucent (32% opaque) black, as used by Android's dim layers.
const display::Color translucent_color({
.format = display::PixelFormat::kB8G8R8A8,
.bytes = {{0, 0, 0, 0x52, 0, 0, 0, 0}},
});
layer.SetColorConfig(translucent_color, display_area);
const display::DriverLayer& draft = GetDraftLayerConfig(layer);
EXPECT_EQ(draft.fallback_color(), translucent_color);
EXPECT_EQ(draft.display_destination(), display_area);
EXPECT_EQ(draft.image_source_transformation(), display::CoordinateTransformation::kIdentity);
EXPECT_EQ(draft.alpha_mode(), display::AlphaMode::kPremultiplied);
EXPECT_EQ(draft.alpha_coefficient(), 1.0f);
}
TEST_F(LayerTest, SetColorConfigWithOpaqueColorDisablesAlpha) {
Layer layer(display::LayerId(1));
const display::ImageMetadata image_metadata({.width = kDisplayWidth,
.height = kDisplayHeight,
.tiling_type = display::ImageTilingType::kLinear});
const display::Rectangle display_area(
{.x = 0, .y = 0, .width = kDisplayWidth, .height = kDisplayHeight});
layer.SetPrimaryConfig(image_metadata);
layer.SetPrimaryAlpha(display::AlphaMode::kPremultiplied, 0.5f);
const display::Color opaque_rgba_color({
.format = display::PixelFormat::kR8G8B8A8,
.bytes = {{0x12, 0x34, 0x56, 0xff, 0, 0, 0, 0}},
});
layer.SetColorConfig(opaque_rgba_color, display_area);
const display::DriverLayer& draft = GetDraftLayerConfig(layer);
EXPECT_EQ(draft.alpha_mode(), display::AlphaMode::kDisable);
EXPECT_EQ(draft.alpha_coefficient(), 1.0f);
}
TEST_F(LayerTest, SetColorConfigDerivesAlphaModeFromColorAlpha) {
const display::Rectangle display_area(
{.x = 0, .y = 0, .width = kDisplayWidth, .height = kDisplayHeight});
// Byte 3 holds the alpha: the whole 8-bit alpha channel, or the 2-bit alpha
// in its two most significant bits. Each alpha-carrying format has a
// translucent row, which fails if `IsOpaqueColor()` stops checking that
// format. 0xfe pins the 8-bit threshold at fully opaque, and 0xbf and 0xc0
// bracket the 2-bit one. A format without an alpha channel is opaque
// whatever byte 3 holds. `kR8G8B8`'s byte 3 is padding, so it is 0, which
// would read as transparent if the format were treated as having alpha.
struct Case {
display::PixelFormat format;
uint8_t alpha_byte;
display::AlphaMode expected_alpha_mode;
};
static constexpr Case kCases[] = {
{display::PixelFormat::kR8G8B8A8, 0x52, display::AlphaMode::kPremultiplied},
{display::PixelFormat::kR8G8B8A8, 0xff, display::AlphaMode::kDisable},
{display::PixelFormat::kB8G8R8A8, 0xff, display::AlphaMode::kDisable},
{display::PixelFormat::kB8G8R8A8, 0xfe, display::AlphaMode::kPremultiplied},
{display::PixelFormat::kR8G8B8, 0x00, display::AlphaMode::kDisable},
{display::PixelFormat::kA2R10G10B10, 0xbf, display::AlphaMode::kPremultiplied},
{display::PixelFormat::kA2R10G10B10, 0xc0, display::AlphaMode::kDisable},
{display::PixelFormat::kA2B10G10R10, 0xbf, display::AlphaMode::kPremultiplied},
{display::PixelFormat::kA2B10G10R10, 0xc0, display::AlphaMode::kDisable},
};
for (const Case& test_case : kCases) {
SCOPED_TRACE(
std::format("format {}, alpha byte {:#04x}", test_case.format, test_case.alpha_byte));
Layer layer(display::LayerId(1));
const display::Color color({
.format = test_case.format,
.bytes = {{0xff, 0xff, 0xff, test_case.alpha_byte, 0, 0, 0, 0}},
});
layer.SetColorConfig(color, display_area);
EXPECT_EQ(GetDraftLayerConfig(layer).alpha_mode(), test_case.expected_alpha_mode);
}
}
TEST_F(LayerTest, SetPrimaryConfigAfterColorConfigUsesDefaults) {
Layer layer(display::LayerId(1));
const display::Rectangle display_area(
{.x = 0, .y = 0, .width = kDisplayWidth, .height = kDisplayHeight});
const display::Color translucent_color({
.format = display::PixelFormat::kB8G8R8A8,
.bytes = {{0, 0, 0, 0x52, 0, 0, 0, 0}},
});
layer.SetColorConfig(translucent_color, display_area);
const display::ImageMetadata image_metadata({.width = kDisplayWidth,
.height = kDisplayHeight,
.tiling_type = display::ImageTilingType::kLinear});
layer.SetPrimaryConfig(image_metadata);
const display::DriverLayer& draft = GetDraftLayerConfig(layer);
EXPECT_EQ(draft.image_source(), display_area);
EXPECT_EQ(draft.display_destination(), display_area);
EXPECT_EQ(draft.image_source_transformation(), display::CoordinateTransformation::kIdentity);
EXPECT_EQ(draft.alpha_mode(), display::AlphaMode::kDisable);
EXPECT_EQ(draft.alpha_coefficient(), 1.0f);
}
TEST_F(LayerTest, CleanUpImage) {
Layer layer(display::LayerId(1));
const display::ImageMetadata image_metadata({.width = kDisplayWidth,
.height = kDisplayHeight,
.tiling_type = display::ImageTilingType::kLinear});
const display::Rectangle display_area(
{.x = 0, .y = 0, .width = kDisplayWidth, .height = kDisplayHeight});
layer.SetPrimaryConfig(image_metadata);
layer.SetPrimaryPosition(display::CoordinateTransformation::kIdentity, display_area,
display_area);
layer.SetPrimaryAlpha(display::AlphaMode::kDisable, 0);
auto displayed_image = CreateReadyImage();
layer.SetImage(displayed_image, display::kInvalidEventId);
layer.CommitChanges();
ASSERT_TRUE(layer.ResolveDraftImage(&fences_, display::ConfigStamp(1)));
zx::event event;
ASSERT_OK(zx::event::create(0, &event));
constexpr display::EventId kWaitFenceId(1);
ASSERT_OK(fences_.ImportEvent(std::move(event), kWaitFenceId));
auto fence_release = fit::defer([&] { fences_.ReleaseEvent(kWaitFenceId); });
auto waiting_image = CreateReadyImage();
layer.SetImage(waiting_image, kWaitFenceId);
ASSERT_TRUE(layer.ResolveDraftImage(&fences_, display::ConfigStamp(2)));
auto draft_image = CreateReadyImage();
layer.SetImage(draft_image, display::kInvalidEventId);
ASSERT_TRUE(layer.ActivateLatestReadyImage());
EXPECT_TRUE(layer.committed_image());
// Nothing should happen if image doesn't match.
auto not_matching_image = CreateReadyImage();
EXPECT_FALSE(layer.CleanUpImage(*not_matching_image));
EXPECT_TRUE(layer.committed_image());
// Test cleaning up a waiting image.
EXPECT_FALSE(layer.CleanUpImage(*waiting_image));
EXPECT_TRUE(layer.committed_image());
// Test cleaning up a draft image.
EXPECT_FALSE(layer.CleanUpImage(*draft_image));
EXPECT_TRUE(layer.committed_image());
// Test cleaning up the associated image.
//
// The layer is not in a display's committed configuration list. So, cleaning up
// the layer's image doesn't change the committed config.
EXPECT_FALSE(layer.CleanUpImage(*displayed_image));
EXPECT_FALSE(layer.committed_image());
}
TEST_F(LayerTest, CleanUpImage_CheckConfigChange) {
fbl::DoublyLinkedList<LayerNode*> applied_layers;
Layer layer(display::LayerId(1));
const display::ImageMetadata image_metadata({.width = kDisplayWidth,
.height = kDisplayHeight,
.tiling_type = display::ImageTilingType::kLinear});
const display::Rectangle display_area(
{.x = 0, .y = 0, .width = kDisplayWidth, .height = kDisplayHeight});
layer.SetPrimaryConfig(image_metadata);
layer.SetPrimaryPosition(display::CoordinateTransformation::kIdentity, display_area,
display_area);
layer.SetPrimaryAlpha(display::AlphaMode::kDisable, 0);
// Clean up images, which doesn't change the committed config.
{
fbl::RefPtr<Image> image = CreateReadyImage();
layer.SetImage(image, display::kInvalidEventId);
layer.CommitChanges();
ASSERT_TRUE(layer.ResolveDraftImage(&fences_, display::ConfigStamp(1)));
ASSERT_TRUE(layer.ActivateLatestReadyImage());
EXPECT_TRUE(layer.committed_image());
// The layer is not in a display's committed configuration list. So, cleaning
// up the layer's image doesn't change the committed config.
EXPECT_FALSE(layer.CleanUpImage(*image));
EXPECT_FALSE(layer.committed_image());
}
// Clean up images, which changes the committed config.
{
MakeLayerCommitted(layer, applied_layers);
fbl::RefPtr<Image> image = CreateReadyImage();
layer.SetImage(image, display::kInvalidEventId);
layer.CommitChanges();
ASSERT_TRUE(layer.ResolveDraftImage(&fences_, display::ConfigStamp(2)));
ASSERT_TRUE(layer.ActivateLatestReadyImage());
EXPECT_TRUE(layer.committed_image());
// The layer is in a display's committed configuration list. So, cleaning up
// the layer's image changes the committed config.
EXPECT_TRUE(layer.CleanUpImage(*image));
EXPECT_FALSE(layer.committed_image());
applied_layers.clear();
}
}
TEST_F(LayerTest, CleanUpAllImages) {
Layer layer(display::LayerId(1));
const display::ImageMetadata image_metadata({.width = kDisplayWidth,
.height = kDisplayHeight,
.tiling_type = display::ImageTilingType::kLinear});
const display::Rectangle display_area(
{.x = 0, .y = 0, .width = kDisplayWidth, .height = kDisplayHeight});
layer.SetPrimaryConfig(image_metadata);
layer.SetPrimaryPosition(display::CoordinateTransformation::kIdentity, display_area,
display_area);
layer.SetPrimaryAlpha(display::AlphaMode::kDisable, 0);
auto displayed_image = CreateReadyImage();
layer.SetImage(displayed_image, display::kInvalidEventId);
layer.CommitChanges();
ASSERT_TRUE(layer.ResolveDraftImage(&fences_, display::ConfigStamp(1)));
zx::event event;
ASSERT_OK(zx::event::create(0, &event));
constexpr display::EventId kWaitFenceId(1);
ASSERT_OK(fences_.ImportEvent(std::move(event), kWaitFenceId));
auto fence_release = fit::defer([&] { fences_.ReleaseEvent(kWaitFenceId); });
auto waiting_image = CreateReadyImage();
layer.SetImage(waiting_image, kWaitFenceId);
ASSERT_TRUE(layer.ResolveDraftImage(&fences_, display::ConfigStamp(2)));
auto draft_image = CreateReadyImage();
layer.SetImage(draft_image, display::kInvalidEventId);
ASSERT_TRUE(layer.ActivateLatestReadyImage());
// The layer is not in a display's committed configuration list. So, cleaning
// up the layer's image doesn't change the committed config.
EXPECT_FALSE(layer.CleanUpAllImages());
EXPECT_FALSE(layer.committed_image());
}
TEST_F(LayerTest, CleanUpAllImages_CheckConfigChange) {
fbl::DoublyLinkedList<LayerNode*> applied_layers;
Layer layer(display::LayerId(1));
const display::ImageMetadata image_metadata({.width = kDisplayWidth,
.height = kDisplayHeight,
.tiling_type = display::ImageTilingType::kLinear});
const display::Rectangle display_area(
{.x = 0, .y = 0, .width = kDisplayWidth, .height = kDisplayHeight});
layer.SetPrimaryConfig(image_metadata);
layer.SetPrimaryPosition(display::CoordinateTransformation::kIdentity, display_area,
display_area);
layer.SetPrimaryAlpha(display::AlphaMode::kDisable, 0);
// Clean up all images, which doesn't change the committed config.
{
fbl::RefPtr<Image> image = CreateReadyImage();
layer.SetImage(image, display::kInvalidEventId);
layer.CommitChanges();
ASSERT_TRUE(layer.ResolveDraftImage(&fences_, display::ConfigStamp(1)));
ASSERT_TRUE(layer.ActivateLatestReadyImage());
EXPECT_TRUE(layer.committed_image());
// The layer is not in a display's committed configuration list. So, cleaning
// up the layer's image doesn't change the committed config.
EXPECT_FALSE(layer.CleanUpAllImages());
EXPECT_FALSE(layer.committed_image());
}
// Clean up all images, which changes the committed config.
{
MakeLayerCommitted(layer, applied_layers);
fbl::RefPtr<Image> image = CreateReadyImage();
layer.SetImage(image, display::kInvalidEventId);
layer.CommitChanges();
ASSERT_TRUE(layer.ResolveDraftImage(&fences_, display::ConfigStamp(2)));
ASSERT_TRUE(layer.ActivateLatestReadyImage());
EXPECT_TRUE(layer.committed_image());
// The layer is in a display's committed configuration list. So, cleaning up
// the layer's image changes the committed config.
EXPECT_TRUE(layer.CleanUpAllImages());
EXPECT_FALSE(layer.committed_image());
applied_layers.clear();
}
}
TEST_F(LayerTest, ReuseImageInDifferentConfigs) {
Layer layer(display::LayerId(1));
const display::ImageMetadata image_metadata({.width = kDisplayWidth,
.height = kDisplayHeight,
.tiling_type = display::ImageTilingType::kLinear});
const display::Rectangle display_area(
{.x = 0, .y = 0, .width = kDisplayWidth, .height = kDisplayHeight});
layer.SetPrimaryConfig(image_metadata);
layer.SetPrimaryPosition(display::CoordinateTransformation::kIdentity, display_area,
display_area);
layer.SetPrimaryAlpha(display::AlphaMode::kDisable, 0);
fbl::RefPtr<Image> image = CreateReadyImage();
layer.SetImage(image, display::kInvalidEventId);
layer.CommitChanges();
ASSERT_TRUE(layer.ResolveDraftImage(&fences_, display::ConfigStamp(1)));
ASSERT_TRUE(layer.ActivateLatestReadyImage());
EXPECT_TRUE(layer.committed_image());
EXPECT_EQ(layer.committed_image()->id(), image->id());
layer.SetImage(image, display::kInvalidEventId);
layer.CommitChanges();
ASSERT_TRUE(layer.ResolveDraftImage(&fences_, display::ConfigStamp(2)));
ASSERT_TRUE(layer.ActivateLatestReadyImage());
EXPECT_TRUE(layer.committed_image());
EXPECT_EQ(layer.committed_image()->id(), image->id());
}
} // namespace display_coordinator