libs/vr/libdvr/tests/dvr_display-test.cpp - LeafOS-Project/android_frameworks_native - Gitiles

 #include <android/hardware_buffer.h>
 #include <android/log.h>
 #include <dvr/dvr_api.h>
 #include <dvr/dvr_display_types.h>
 #include <dvr/dvr_surface.h>

 #include <gtest/gtest.h>

 #include "dvr_api_test.h"

 #define LOG_TAG "dvr_display-test"

 #ifndef ALOGD
 #define ALOGD(...) __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__)
 #endif

 class DvrDisplayTest : public DvrApiTest {
  protected:
   void SetUp() override {
     DvrApiTest::SetUp();
     int ret = api_.GetNativeDisplayMetrics(sizeof(display_metrics_),
                                            &display_metrics_);
     ASSERT_EQ(ret, 0) << "Failed to get display metrics.";
     ALOGD(
         "display_width: %d, display_height: %d, display_x_dpi: %d, "
         "display_y_dpi: %d, vsync_period_ns: %d.",
         display_metrics_.display_width, display_metrics_.display_height,
         display_metrics_.display_x_dpi, display_metrics_.display_y_dpi,
         display_metrics_.vsync_period_ns);
   }

   void TearDown() override {
     if (write_queue_ != nullptr) {
       api_.WriteBufferQueueDestroy(write_queue_);
       write_queue_ = nullptr;
     }
     if (direct_surface_ != nullptr) {
       api_.SurfaceDestroy(direct_surface_);
       direct_surface_ = nullptr;
     }
     DvrApiTest::TearDown();
   }

   /* Convert a write buffer to an android hardware buffer and fill in
    * color_textures evenly to the buffer.
    * AssertionError if the width of the buffer is not equal to the input width,
    * AssertionError if the height of the buffer is not equal to the input
    * height.
    */
   void FillWriteBuffer(DvrWriteBuffer* write_buffer,
                        const std::vector<uint32_t>& color_textures,
                        uint32_t width, uint32_t height);

   // Write buffer queue properties.
   static constexpr uint64_t kUsage = AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE |
                                      AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT |
                                      AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN;
   uint32_t kFormat = AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM;
   static constexpr size_t kMetadataSize = 0;
   static constexpr int kTimeoutMs = 1000;  // Time for getting buffer.
   uint32_t kLayerCount = 1;
   DvrWriteBufferQueue* write_queue_ = nullptr;
   DvrSurface* direct_surface_ = nullptr;

   // Device display properties.
   DvrNativeDisplayMetrics display_metrics_;
 };

 TEST_F(DvrDisplayTest, DisplayWithOneBuffer) {
   // Create a direct surface.
   std::vector<DvrSurfaceAttribute> direct_surface_attributes = {
       {.key = DVR_SURFACE_ATTRIBUTE_DIRECT,
        .value.type = DVR_SURFACE_ATTRIBUTE_TYPE_BOOL,
        .value.bool_value = true},
       {.key = DVR_SURFACE_ATTRIBUTE_Z_ORDER,
        .value.type = DVR_SURFACE_ATTRIBUTE_TYPE_INT32,
        .value.int32_value = 10},
       {.key = DVR_SURFACE_ATTRIBUTE_VISIBLE,
        .value.type = DVR_SURFACE_ATTRIBUTE_TYPE_BOOL,
        .value.bool_value = true},
   };
   int ret =
       api_.SurfaceCreate(direct_surface_attributes.data(),
                          direct_surface_attributes.size(), &direct_surface_);
   ASSERT_EQ(ret, 0) << "Failed to create direct surface.";

   // Create a buffer queue with the direct surface.
   constexpr size_t kCapacity = 1;
   uint32_t width = display_metrics_.display_width;
   uint32_t height = display_metrics_.display_height;
   ret = api_.SurfaceCreateWriteBufferQueue(
       direct_surface_, width, height, kFormat, kLayerCount, kUsage, kCapacity,
       kMetadataSize, &write_queue_);
   EXPECT_EQ(0, ret) << "Failed to create buffer queue.";
   ASSERT_NE(nullptr, write_queue_) << "Write buffer queue should not be null.";

   // Get buffer from WriteBufferQueue.
   DvrWriteBuffer* write_buffer = nullptr;
   DvrNativeBufferMetadata out_meta;
   int out_fence_fd = -1;
   ret = api_.WriteBufferQueueGainBuffer(write_queue_, kTimeoutMs, &write_buffer,
                                         &out_meta, &out_fence_fd);
   EXPECT_EQ(0, ret) << "Failed to get the buffer.";
   ASSERT_NE(nullptr, write_buffer) << "Gained buffer should not be null.";

   // Color the write buffer.
   FillWriteBuffer(write_buffer,
                   {0xff000000, 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00000000},
                   width, height);

   // Post buffer.
   int ready_fence_fd = -1;
   ret = api_.WriteBufferQueuePostBuffer(write_queue_, write_buffer, &out_meta,
                                         ready_fence_fd);
   EXPECT_EQ(0, ret) << "Failed to post the buffer.";

   sleep(5);  // For visual check on the device under test.
   // Should observe three primary colors on the screen center.
 }

 TEST_F(DvrDisplayTest, DisplayWithDoubleBuffering) {
   // Create a direct surface.
   std::vector<DvrSurfaceAttribute> direct_surface_attributes = {
       {.key = DVR_SURFACE_ATTRIBUTE_DIRECT,
        .value.type = DVR_SURFACE_ATTRIBUTE_TYPE_BOOL,
        .value.bool_value = true},
       {.key = DVR_SURFACE_ATTRIBUTE_Z_ORDER,
        .value.type = DVR_SURFACE_ATTRIBUTE_TYPE_INT32,
        .value.int32_value = 10},
       {.key = DVR_SURFACE_ATTRIBUTE_VISIBLE,
        .value.type = DVR_SURFACE_ATTRIBUTE_TYPE_BOOL,
        .value.bool_value = true},
   };
   int ret =
       api_.SurfaceCreate(direct_surface_attributes.data(),
                          direct_surface_attributes.size(), &direct_surface_);
   ASSERT_EQ(ret, 0) << "Failed to create direct surface.";

   // Create a buffer queue with the direct surface.
   constexpr size_t kCapacity = 2;
   uint32_t width = display_metrics_.display_width;
   uint32_t height = display_metrics_.display_height;
   ret = api_.SurfaceCreateWriteBufferQueue(
       direct_surface_, width, height, kFormat, kLayerCount, kUsage, kCapacity,
       kMetadataSize, &write_queue_);
   EXPECT_EQ(0, ret) << "Failed to create buffer queue.";
   ASSERT_NE(nullptr, write_queue_) << "Write buffer queue should not be null.";

   int num_display_cycles_in_5s = 5 / (display_metrics_.vsync_period_ns / 1e9);
   ALOGD("The number of display cycles: %d", num_display_cycles_in_5s);
   int bufferhub_id_prev_write_buffer = -1;
   for (int i = 0; i < num_display_cycles_in_5s; ++i) {
     // Get a buffer from the WriteBufferQueue.
     DvrWriteBuffer* write_buffer = nullptr;
     DvrNativeBufferMetadata out_meta;
     int out_fence_fd = -1;
     ret = api_.WriteBufferQueueGainBuffer(
         write_queue_, kTimeoutMs, &write_buffer, &out_meta, &out_fence_fd);
     EXPECT_EQ(0, ret) << "Failed to get the a write buffer.";
     ASSERT_NE(nullptr, write_buffer) << "The gained buffer should not be null.";

     int bufferhub_id = api_.WriteBufferGetId(write_buffer);
     ALOGD("Display cycle: %d, bufferhub id of the write buffer: %d", i,
           bufferhub_id);
     EXPECT_NE(bufferhub_id_prev_write_buffer, bufferhub_id)
         << "Double buffering should be using the two buffers in turns, not "
            "reusing the same write buffer.";
     bufferhub_id_prev_write_buffer = bufferhub_id;

     // Color the write buffer.
     if (i % 2) {
       FillWriteBuffer(write_buffer, {0xffff0000, 0xff00ff00, 0xff0000ff}, width,
                       height);
     } else {
       FillWriteBuffer(write_buffer, {0xff00ff00, 0xff0000ff, 0xffff0000}, width,
                       height);
     }

     // Post the write buffer.
     int ready_fence_fd = -1;
     ret = api_.WriteBufferQueuePostBuffer(write_queue_, write_buffer, &out_meta,
                                           ready_fence_fd);
     EXPECT_EQ(0, ret) << "Failed to post the buffer.";
   }
   // Should observe blinking screen in secondary colors
   // although it is actually displaying primary colors.
 }

 TEST_F(DvrDisplayTest, DisplayWithTwoHardwareLayers) {
   // Create the direct_surface_0 of z order 10 and direct_surface_1 of z
   // order 11.
   DvrSurface* direct_surface_0 = nullptr;
   std::vector<DvrSurfaceAttribute> direct_surface_0_attributes = {
       {.key = DVR_SURFACE_ATTRIBUTE_DIRECT,
        .value.type = DVR_SURFACE_ATTRIBUTE_TYPE_BOOL,
        .value.bool_value = true},
       {.key = DVR_SURFACE_ATTRIBUTE_Z_ORDER,
        .value.type = DVR_SURFACE_ATTRIBUTE_TYPE_INT32,
        .value.int32_value = 10},
       {.key = DVR_SURFACE_ATTRIBUTE_VISIBLE,
        .value.type = DVR_SURFACE_ATTRIBUTE_TYPE_BOOL,
        .value.bool_value = true},
   };
   int ret =
       api_.SurfaceCreate(direct_surface_0_attributes.data(),
                          direct_surface_0_attributes.size(), &direct_surface_0);
   EXPECT_EQ(ret, 0) << "Failed to create direct surface.";

   DvrSurface* direct_surface_1 = nullptr;
   std::vector<DvrSurfaceAttribute> direct_surface_1_attributes = {
       {.key = DVR_SURFACE_ATTRIBUTE_DIRECT,
        .value.type = DVR_SURFACE_ATTRIBUTE_TYPE_BOOL,
        .value.bool_value = true},
       {.key = DVR_SURFACE_ATTRIBUTE_Z_ORDER,
        .value.type = DVR_SURFACE_ATTRIBUTE_TYPE_INT32,
        .value.int32_value = 11},
       {.key = DVR_SURFACE_ATTRIBUTE_VISIBLE,
        .value.type = DVR_SURFACE_ATTRIBUTE_TYPE_BOOL,
        .value.bool_value = true},
   };
   ret =
       api_.SurfaceCreate(direct_surface_1_attributes.data(),
                          direct_surface_1_attributes.size(), &direct_surface_1);
   EXPECT_EQ(ret, 0) << "Failed to create direct surface.";

   // Create a buffer queue for each of the direct surfaces.
   constexpr size_t kCapacity = 1;
   uint32_t width = display_metrics_.display_width;
   uint32_t height = display_metrics_.display_height;

   DvrWriteBufferQueue* write_queue_0 = nullptr;
   ret = api_.SurfaceCreateWriteBufferQueue(
       direct_surface_0, width, height, kFormat, kLayerCount, kUsage, kCapacity,
       kMetadataSize, &write_queue_0);
   EXPECT_EQ(0, ret) << "Failed to create buffer queue.";
   EXPECT_NE(nullptr, write_queue_0) << "Write buffer queue should not be null.";

   DvrWriteBufferQueue* write_queue_1 = nullptr;
   ret = api_.SurfaceCreateWriteBufferQueue(
       direct_surface_1, width, height, kFormat, kLayerCount, kUsage, kCapacity,
       kMetadataSize, &write_queue_1);
   EXPECT_EQ(0, ret) << "Failed to create buffer queue.";
   EXPECT_NE(nullptr, write_queue_1) << "Write buffer queue should not be null.";

   // Get a buffer from each of the write buffer queues.
   DvrWriteBuffer* write_buffer_0 = nullptr;
   DvrNativeBufferMetadata out_meta_0;
   int out_fence_fd = -1;
   ret = api_.WriteBufferQueueGainBuffer(
       write_queue_0, kTimeoutMs, &write_buffer_0, &out_meta_0, &out_fence_fd);
   EXPECT_EQ(0, ret) << "Failed to get the buffer.";
   EXPECT_NE(nullptr, write_buffer_0) << "Gained buffer should not be null.";

   DvrWriteBuffer* write_buffer_1 = nullptr;
   DvrNativeBufferMetadata out_meta_1;
   out_fence_fd = -1;
   ret = api_.WriteBufferQueueGainBuffer(
       write_queue_1, kTimeoutMs, &write_buffer_1, &out_meta_1, &out_fence_fd);
   EXPECT_EQ(0, ret) << "Failed to get the buffer.";
   EXPECT_NE(nullptr, write_buffer_1) << "Gained buffer should not be null.";

   // Color the write buffers.
   FillWriteBuffer(write_buffer_0, {0xffff0000, 0xff00ff00, 0xff0000ff}, width,
                   height);
   FillWriteBuffer(write_buffer_1, {0x7f00ff00, 0x7f0000ff, 0x7fff0000}, width,
                   height);

   // Post buffers.
   int ready_fence_fd = -1;
   ret = api_.WriteBufferQueuePostBuffer(write_queue_0, write_buffer_0,
                                         &out_meta_0, ready_fence_fd);
   EXPECT_EQ(0, ret) << "Failed to post the buffer.";

   ready_fence_fd = -1;
   ret = api_.WriteBufferQueuePostBuffer(write_queue_1, write_buffer_1,
                                         &out_meta_1, ready_fence_fd);
   EXPECT_EQ(0, ret) << "Failed to post the buffer.";

   sleep(5);  // For visual check on the device under test.
   // Should observe three secondary colors.

   // Test finished. Clean up buffers and surfaces.
   if (write_queue_0 != nullptr) {
     api_.WriteBufferQueueDestroy(write_queue_0);
     write_queue_0 = nullptr;
   }
   if (write_queue_1 != nullptr) {
     api_.WriteBufferQueueDestroy(write_queue_1);
     write_queue_1 = nullptr;
   }
   if (direct_surface_0 != nullptr) {
     api_.SurfaceDestroy(direct_surface_0);
   }
   if (direct_surface_1 != nullptr) {
     api_.SurfaceDestroy(direct_surface_1);
   }
 }

 void DvrDisplayTest::FillWriteBuffer(
     DvrWriteBuffer* write_buffer, const std::vector<uint32_t>& color_textures,
     uint32_t width, uint32_t height) {
   uint32_t num_colors = color_textures.size();
   // Convert the first write buffer to an android hardware buffer.
   AHardwareBuffer* ah_buffer = nullptr;
   int ret = api_.WriteBufferGetAHardwareBuffer(write_buffer, &ah_buffer);
   ASSERT_EQ(0, ret) << "Failed to get a hardware buffer from the write buffer.";
   ASSERT_NE(nullptr, ah_buffer) << "AHardware buffer should not be null.";
   AHardwareBuffer_Desc ah_buffer_describe;
   AHardwareBuffer_describe(ah_buffer, &ah_buffer_describe);
   ASSERT_EQ(ah_buffer_describe.format, kFormat)
       << "The format of the android hardware buffer is wrong.";
   ASSERT_EQ(ah_buffer_describe.layers, kLayerCount)
       << "The obtained android hardware buffer should have 2 layers.";
   ASSERT_EQ(ah_buffer_describe.width, width)
       << "The obtained android hardware buffer width is wrong.";
   ASSERT_EQ(ah_buffer_describe.height, height)
       << "The obtained android hardware buffer height is wrong.";
   // Change the content of the android hardware buffer.
   void* buffer_data = nullptr;
   int32_t fence = -1;
   ret = AHardwareBuffer_lock(ah_buffer, AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN,
                              fence, nullptr, &buffer_data);
   ASSERT_EQ(0, ret) << "Failed to lock the hardware buffer.";
   ASSERT_NE(nullptr, buffer_data) << "Buffer data should not be null.";

   uint32_t num_pixels = width * height / num_colors;
   for (uint32_t color_index = 0; color_index < num_colors - 1; ++color_index) {
     uint32_t color_texture = color_textures[color_index];
     for (uint32_t i = 0; i < num_pixels; ++i) {
       memcpy(reinterpret_cast<void*>(reinterpret_cast<int64_t>(buffer_data) +
                                      (i + num_pixels * color_index) *
                                          sizeof(color_texture)),
              &color_texture, sizeof(color_texture));
     }
   }
   uint32_t color_texture = color_textures[num_colors - 1];
   uint32_t num_colored_pixels = num_pixels * (num_colors - 1);
   num_pixels = width * height - num_colored_pixels;
   for (uint32_t i = 0; i < num_pixels; ++i) {
     memcpy(reinterpret_cast<void*>(reinterpret_cast<int64_t>(buffer_data) +
                                    (i + num_colored_pixels) *
                                        sizeof(color_texture)),
            &color_texture, sizeof(color_texture));
   }
   fence = -1;
   ret = AHardwareBuffer_unlock(ah_buffer, &fence);
   EXPECT_EQ(0, ret) << "Failed to unlock the hardware buffer.";

   // Release the android hardware buffer.
   AHardwareBuffer_release(ah_buffer);
 }
	#include <android/hardware_buffer.h>
	#include <android/log.h>
	#include <dvr/dvr_api.h>
	#include <dvr/dvr_display_types.h>
	#include <dvr/dvr_surface.h>

	#include <gtest/gtest.h>

	#include "dvr_api_test.h"

	#define LOG_TAG "dvr_display-test"

	#ifndef ALOGD
	#define ALOGD(...) __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__)
	#endif

	class DvrDisplayTest : public DvrApiTest {
	protected:
	void SetUp() override {
	DvrApiTest::SetUp();
	int ret = api_.GetNativeDisplayMetrics(sizeof(display_metrics_),
	&display_metrics_);
	ASSERT_EQ(ret, 0) << "Failed to get display metrics.";
	ALOGD(
	"display_width: %d, display_height: %d, display_x_dpi: %d, "
	"display_y_dpi: %d, vsync_period_ns: %d.",
	display_metrics_.display_width, display_metrics_.display_height,
	display_metrics_.display_x_dpi, display_metrics_.display_y_dpi,
	display_metrics_.vsync_period_ns);
	}

	void TearDown() override {
	if (write_queue_ != nullptr) {
	api_.WriteBufferQueueDestroy(write_queue_);
	write_queue_ = nullptr;
	}
	if (direct_surface_ != nullptr) {
	api_.SurfaceDestroy(direct_surface_);
	direct_surface_ = nullptr;
	}
	DvrApiTest::TearDown();
	}

	/* Convert a write buffer to an android hardware buffer and fill in
	* color_textures evenly to the buffer.
	* AssertionError if the width of the buffer is not equal to the input width,
	* AssertionError if the height of the buffer is not equal to the input
	* height.
	*/
	void FillWriteBuffer(DvrWriteBuffer* write_buffer,
	const std::vector<uint32_t>& color_textures,
	uint32_t width, uint32_t height);

	// Write buffer queue properties.
	static constexpr uint64_t kUsage = AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE \|
	AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT \|
	AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN;
	uint32_t kFormat = AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM;
	static constexpr size_t kMetadataSize = 0;
	static constexpr int kTimeoutMs = 1000; // Time for getting buffer.
	uint32_t kLayerCount = 1;
	DvrWriteBufferQueue* write_queue_ = nullptr;
	DvrSurface* direct_surface_ = nullptr;

	// Device display properties.
	DvrNativeDisplayMetrics display_metrics_;
	};

	TEST_F(DvrDisplayTest, DisplayWithOneBuffer) {
	// Create a direct surface.
	std::vector<DvrSurfaceAttribute> direct_surface_attributes = {
	{.key = DVR_SURFACE_ATTRIBUTE_DIRECT,
	.value.type = DVR_SURFACE_ATTRIBUTE_TYPE_BOOL,
	.value.bool_value = true},
	{.key = DVR_SURFACE_ATTRIBUTE_Z_ORDER,
	.value.type = DVR_SURFACE_ATTRIBUTE_TYPE_INT32,
	.value.int32_value = 10},
	{.key = DVR_SURFACE_ATTRIBUTE_VISIBLE,
	.value.type = DVR_SURFACE_ATTRIBUTE_TYPE_BOOL,
	.value.bool_value = true},
	};
	int ret =
	api_.SurfaceCreate(direct_surface_attributes.data(),
	direct_surface_attributes.size(), &direct_surface_);
	ASSERT_EQ(ret, 0) << "Failed to create direct surface.";

	// Create a buffer queue with the direct surface.
	constexpr size_t kCapacity = 1;
	uint32_t width = display_metrics_.display_width;
	uint32_t height = display_metrics_.display_height;
	ret = api_.SurfaceCreateWriteBufferQueue(
	direct_surface_, width, height, kFormat, kLayerCount, kUsage, kCapacity,
	kMetadataSize, &write_queue_);
	EXPECT_EQ(0, ret) << "Failed to create buffer queue.";
	ASSERT_NE(nullptr, write_queue_) << "Write buffer queue should not be null.";

	// Get buffer from WriteBufferQueue.
	DvrWriteBuffer* write_buffer = nullptr;
	DvrNativeBufferMetadata out_meta;
	int out_fence_fd = -1;
	ret = api_.WriteBufferQueueGainBuffer(write_queue_, kTimeoutMs, &write_buffer,
	&out_meta, &out_fence_fd);
	EXPECT_EQ(0, ret) << "Failed to get the buffer.";
	ASSERT_NE(nullptr, write_buffer) << "Gained buffer should not be null.";

	// Color the write buffer.
	FillWriteBuffer(write_buffer,
	{0xff000000, 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00000000},
	width, height);

	// Post buffer.
	int ready_fence_fd = -1;
	ret = api_.WriteBufferQueuePostBuffer(write_queue_, write_buffer, &out_meta,
	ready_fence_fd);
	EXPECT_EQ(0, ret) << "Failed to post the buffer.";

	sleep(5); // For visual check on the device under test.
	// Should observe three primary colors on the screen center.
	}

	TEST_F(DvrDisplayTest, DisplayWithDoubleBuffering) {
	// Create a direct surface.
	std::vector<DvrSurfaceAttribute> direct_surface_attributes = {
	{.key = DVR_SURFACE_ATTRIBUTE_DIRECT,
	.value.type = DVR_SURFACE_ATTRIBUTE_TYPE_BOOL,
	.value.bool_value = true},
	{.key = DVR_SURFACE_ATTRIBUTE_Z_ORDER,
	.value.type = DVR_SURFACE_ATTRIBUTE_TYPE_INT32,
	.value.int32_value = 10},
	{.key = DVR_SURFACE_ATTRIBUTE_VISIBLE,
	.value.type = DVR_SURFACE_ATTRIBUTE_TYPE_BOOL,
	.value.bool_value = true},
	};
	int ret =
	api_.SurfaceCreate(direct_surface_attributes.data(),
	direct_surface_attributes.size(), &direct_surface_);
	ASSERT_EQ(ret, 0) << "Failed to create direct surface.";

	// Create a buffer queue with the direct surface.
	constexpr size_t kCapacity = 2;
	uint32_t width = display_metrics_.display_width;
	uint32_t height = display_metrics_.display_height;
	ret = api_.SurfaceCreateWriteBufferQueue(
	direct_surface_, width, height, kFormat, kLayerCount, kUsage, kCapacity,
	kMetadataSize, &write_queue_);
	EXPECT_EQ(0, ret) << "Failed to create buffer queue.";
	ASSERT_NE(nullptr, write_queue_) << "Write buffer queue should not be null.";

	int num_display_cycles_in_5s = 5 / (display_metrics_.vsync_period_ns / 1e9);
	ALOGD("The number of display cycles: %d", num_display_cycles_in_5s);
	int bufferhub_id_prev_write_buffer = -1;
	for (int i = 0; i < num_display_cycles_in_5s; ++i) {
	// Get a buffer from the WriteBufferQueue.
	DvrWriteBuffer* write_buffer = nullptr;
	DvrNativeBufferMetadata out_meta;
	int out_fence_fd = -1;
	ret = api_.WriteBufferQueueGainBuffer(
	write_queue_, kTimeoutMs, &write_buffer, &out_meta, &out_fence_fd);
	EXPECT_EQ(0, ret) << "Failed to get the a write buffer.";
	ASSERT_NE(nullptr, write_buffer) << "The gained buffer should not be null.";

	int bufferhub_id = api_.WriteBufferGetId(write_buffer);
	ALOGD("Display cycle: %d, bufferhub id of the write buffer: %d", i,
	bufferhub_id);
	EXPECT_NE(bufferhub_id_prev_write_buffer, bufferhub_id)
	<< "Double buffering should be using the two buffers in turns, not "
	"reusing the same write buffer.";
	bufferhub_id_prev_write_buffer = bufferhub_id;

	// Color the write buffer.
	if (i % 2) {
	FillWriteBuffer(write_buffer, {0xffff0000, 0xff00ff00, 0xff0000ff}, width,
	height);
	} else {
	FillWriteBuffer(write_buffer, {0xff00ff00, 0xff0000ff, 0xffff0000}, width,
	height);
	}

	// Post the write buffer.
	int ready_fence_fd = -1;
	ret = api_.WriteBufferQueuePostBuffer(write_queue_, write_buffer, &out_meta,
	ready_fence_fd);
	EXPECT_EQ(0, ret) << "Failed to post the buffer.";
	}
	// Should observe blinking screen in secondary colors
	// although it is actually displaying primary colors.
	}

	TEST_F(DvrDisplayTest, DisplayWithTwoHardwareLayers) {
	// Create the direct_surface_0 of z order 10 and direct_surface_1 of z
	// order 11.
	DvrSurface* direct_surface_0 = nullptr;
	std::vector<DvrSurfaceAttribute> direct_surface_0_attributes = {
	{.key = DVR_SURFACE_ATTRIBUTE_DIRECT,
	.value.type = DVR_SURFACE_ATTRIBUTE_TYPE_BOOL,
	.value.bool_value = true},
	{.key = DVR_SURFACE_ATTRIBUTE_Z_ORDER,
	.value.type = DVR_SURFACE_ATTRIBUTE_TYPE_INT32,
	.value.int32_value = 10},
	{.key = DVR_SURFACE_ATTRIBUTE_VISIBLE,
	.value.type = DVR_SURFACE_ATTRIBUTE_TYPE_BOOL,
	.value.bool_value = true},
	};
	int ret =
	api_.SurfaceCreate(direct_surface_0_attributes.data(),
	direct_surface_0_attributes.size(), &direct_surface_0);
	EXPECT_EQ(ret, 0) << "Failed to create direct surface.";

	DvrSurface* direct_surface_1 = nullptr;
	std::vector<DvrSurfaceAttribute> direct_surface_1_attributes = {
	{.key = DVR_SURFACE_ATTRIBUTE_DIRECT,
	.value.type = DVR_SURFACE_ATTRIBUTE_TYPE_BOOL,
	.value.bool_value = true},
	{.key = DVR_SURFACE_ATTRIBUTE_Z_ORDER,
	.value.type = DVR_SURFACE_ATTRIBUTE_TYPE_INT32,
	.value.int32_value = 11},
	{.key = DVR_SURFACE_ATTRIBUTE_VISIBLE,
	.value.type = DVR_SURFACE_ATTRIBUTE_TYPE_BOOL,
	.value.bool_value = true},
	};
	ret =
	api_.SurfaceCreate(direct_surface_1_attributes.data(),
	direct_surface_1_attributes.size(), &direct_surface_1);
	EXPECT_EQ(ret, 0) << "Failed to create direct surface.";

	// Create a buffer queue for each of the direct surfaces.
	constexpr size_t kCapacity = 1;
	uint32_t width = display_metrics_.display_width;
	uint32_t height = display_metrics_.display_height;

	DvrWriteBufferQueue* write_queue_0 = nullptr;
	ret = api_.SurfaceCreateWriteBufferQueue(
	direct_surface_0, width, height, kFormat, kLayerCount, kUsage, kCapacity,
	kMetadataSize, &write_queue_0);
	EXPECT_EQ(0, ret) << "Failed to create buffer queue.";
	EXPECT_NE(nullptr, write_queue_0) << "Write buffer queue should not be null.";

	DvrWriteBufferQueue* write_queue_1 = nullptr;
	ret = api_.SurfaceCreateWriteBufferQueue(
	direct_surface_1, width, height, kFormat, kLayerCount, kUsage, kCapacity,
	kMetadataSize, &write_queue_1);
	EXPECT_EQ(0, ret) << "Failed to create buffer queue.";
	EXPECT_NE(nullptr, write_queue_1) << "Write buffer queue should not be null.";

	// Get a buffer from each of the write buffer queues.
	DvrWriteBuffer* write_buffer_0 = nullptr;
	DvrNativeBufferMetadata out_meta_0;
	int out_fence_fd = -1;
	ret = api_.WriteBufferQueueGainBuffer(
	write_queue_0, kTimeoutMs, &write_buffer_0, &out_meta_0, &out_fence_fd);
	EXPECT_EQ(0, ret) << "Failed to get the buffer.";
	EXPECT_NE(nullptr, write_buffer_0) << "Gained buffer should not be null.";

	DvrWriteBuffer* write_buffer_1 = nullptr;
	DvrNativeBufferMetadata out_meta_1;
	out_fence_fd = -1;
	ret = api_.WriteBufferQueueGainBuffer(
	write_queue_1, kTimeoutMs, &write_buffer_1, &out_meta_1, &out_fence_fd);
	EXPECT_EQ(0, ret) << "Failed to get the buffer.";
	EXPECT_NE(nullptr, write_buffer_1) << "Gained buffer should not be null.";

	// Color the write buffers.
	FillWriteBuffer(write_buffer_0, {0xffff0000, 0xff00ff00, 0xff0000ff}, width,
	height);
	FillWriteBuffer(write_buffer_1, {0x7f00ff00, 0x7f0000ff, 0x7fff0000}, width,
	height);

	// Post buffers.
	int ready_fence_fd = -1;
	ret = api_.WriteBufferQueuePostBuffer(write_queue_0, write_buffer_0,
	&out_meta_0, ready_fence_fd);
	EXPECT_EQ(0, ret) << "Failed to post the buffer.";

	ready_fence_fd = -1;
	ret = api_.WriteBufferQueuePostBuffer(write_queue_1, write_buffer_1,
	&out_meta_1, ready_fence_fd);
	EXPECT_EQ(0, ret) << "Failed to post the buffer.";

	sleep(5); // For visual check on the device under test.
	// Should observe three secondary colors.

	// Test finished. Clean up buffers and surfaces.
	if (write_queue_0 != nullptr) {
	api_.WriteBufferQueueDestroy(write_queue_0);
	write_queue_0 = nullptr;
	}
	if (write_queue_1 != nullptr) {
	api_.WriteBufferQueueDestroy(write_queue_1);
	write_queue_1 = nullptr;
	}
	if (direct_surface_0 != nullptr) {
	api_.SurfaceDestroy(direct_surface_0);
	}
	if (direct_surface_1 != nullptr) {
	api_.SurfaceDestroy(direct_surface_1);
	}
	}

	void DvrDisplayTest::FillWriteBuffer(
	DvrWriteBuffer* write_buffer, const std::vector<uint32_t>& color_textures,
	uint32_t width, uint32_t height) {
	uint32_t num_colors = color_textures.size();
	// Convert the first write buffer to an android hardware buffer.
	AHardwareBuffer* ah_buffer = nullptr;
	int ret = api_.WriteBufferGetAHardwareBuffer(write_buffer, &ah_buffer);
	ASSERT_EQ(0, ret) << "Failed to get a hardware buffer from the write buffer.";
	ASSERT_NE(nullptr, ah_buffer) << "AHardware buffer should not be null.";
	AHardwareBuffer_Desc ah_buffer_describe;
	AHardwareBuffer_describe(ah_buffer, &ah_buffer_describe);
	ASSERT_EQ(ah_buffer_describe.format, kFormat)
	<< "The format of the android hardware buffer is wrong.";
	ASSERT_EQ(ah_buffer_describe.layers, kLayerCount)
	<< "The obtained android hardware buffer should have 2 layers.";
	ASSERT_EQ(ah_buffer_describe.width, width)
	<< "The obtained android hardware buffer width is wrong.";
	ASSERT_EQ(ah_buffer_describe.height, height)
	<< "The obtained android hardware buffer height is wrong.";
	// Change the content of the android hardware buffer.
	void* buffer_data = nullptr;
	int32_t fence = -1;
	ret = AHardwareBuffer_lock(ah_buffer, AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN,
	fence, nullptr, &buffer_data);
	ASSERT_EQ(0, ret) << "Failed to lock the hardware buffer.";
	ASSERT_NE(nullptr, buffer_data) << "Buffer data should not be null.";

	uint32_t num_pixels = width * height / num_colors;
	for (uint32_t color_index = 0; color_index < num_colors - 1; ++color_index) {
	uint32_t color_texture = color_textures[color_index];
	for (uint32_t i = 0; i < num_pixels; ++i) {
	memcpy(reinterpret_cast<void*>(reinterpret_cast<int64_t>(buffer_data) +
	(i + num_pixels * color_index) *
	sizeof(color_texture)),
	&color_texture, sizeof(color_texture));
	}
	}
	uint32_t color_texture = color_textures[num_colors - 1];
	uint32_t num_colored_pixels = num_pixels * (num_colors - 1);
	num_pixels = width * height - num_colored_pixels;
	for (uint32_t i = 0; i < num_pixels; ++i) {
	memcpy(reinterpret_cast<void*>(reinterpret_cast<int64_t>(buffer_data) +
	(i + num_colored_pixels) *
	sizeof(color_texture)),
	&color_texture, sizeof(color_texture));
	}
	fence = -1;
	ret = AHardwareBuffer_unlock(ah_buffer, &fence);
	EXPECT_EQ(0, ret) << "Failed to unlock the hardware buffer.";

	// Release the android hardware buffer.
	AHardwareBuffer_release(ah_buffer);
	}