libs/vr/libdvr/tests/dvr_display-test.cpp - platform/frameworks/native - Git at Google


            
            #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);
	}