src/dawn/tests/end2end/VideoViewsTests_gbm.cpp - dawn - Git at Google


            
            // Copyright 2021 The Dawn & Tint Authors

            
            //

            
            // Redistribution and use in source and binary forms, with or without

            
            // modification, are permitted provided that the following conditions are met:

            
            //

            
            // 1. Redistributions of source code must retain the above copyright notice, this

            
            //    list of conditions and the following disclaimer.

            
            //

            
            // 2. Redistributions in binary form must reproduce the above copyright notice,

            
            //    this list of conditions and the following disclaimer in the documentation

            
            //    and/or other materials provided with the distribution.

            
            //

            
            // 3. Neither the name of the copyright holder nor the names of its

            
            //    contributors may be used to endorse or promote products derived from

            
            //    this software without specific prior written permission.

            
            //

            
            // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

            
            // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

            
            // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

            
            // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE

            
            // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

            
            // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

            
            // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

            
            // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

            
            // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

            
            // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


            #include <fcntl.h>

            
            #include <gbm.h>


            #include <memory>

            
            #include <string>

            
            #include <utility>

            
            #include <vector>


            #include "VideoViewsTests.h"

            
            #include "dawn/common/Assert.h"

            
            #include "dawn/native/VulkanBackend.h"


            namespace dawn {

            
            namespace {


            // "linux-chromeos-rel"'s gbm.h is too old to compile, missing this change at least:

            
            // https://chromium-review.googlesource.com/c/chromiumos/platform/minigbm/+/1963001/10/gbm.h#244

            
            #ifndef MINIGBM

            
            #define GBM_BO_USE_TEXTURING (1 << 5)

            
            #define GBM_BO_USE_SW_WRITE_RARELY (1 << 12)

            
            #define GBM_BO_USE_HW_VIDEO_DECODER (1 << 13)

            
            #endif


            #ifndef DRM_FORMAT_MOD_LINEAR

            
            #define DRM_FORMAT_MOD_LINEAR 0

            
            #endif


            class PlatformTextureGbm : public VideoViewsTestBackend::PlatformTexture {

            
              public:

            
                PlatformTextureGbm(wgpu::Texture&& texture, gbm_bo* gbmBo)

            
                    : PlatformTexture(std::move(texture)), mGbmBo(gbmBo) {}

            
                ~PlatformTextureGbm() override = default;


                // TODO(chromium:1258986): Add DISJOINT vkImage support for multi-plannar formats.

            
                bool CanWrapAsWGPUTexture() override {

            
                    DAWN_ASSERT(mGbmBo != nullptr);

            
                    // Checks if all plane handles of a multi-planar gbm_bo are same.

            
                    gbm_bo_handle plane0Handle = gbm_bo_get_handle_for_plane(mGbmBo, 0);

            
                    for (int plane = 1; plane < gbm_bo_get_plane_count(mGbmBo); ++plane) {

            
                        if (gbm_bo_get_handle_for_plane(mGbmBo, plane).u32 != plane0Handle.u32) {

            
                            return false;

            
                        }

            
                    }

            
                    return true;

            
                }


                gbm_bo* GetGbmBo() { return mGbmBo; }


              private:

            
                gbm_bo* mGbmBo = nullptr;

            
            };


            class VideoViewsTestBackendGbm : public VideoViewsTestBackend {

            
              public:

            
                void OnSetUp(WGPUDevice device) override {

            
                    mWGPUDevice = device;

            
                    mGbmDevice = CreateGbmDevice();

            
                }


                void OnTearDown() override {

            
                    if (mGbmDevice != nullptr) {

            
                        gbm_device_destroy(mGbmDevice);

            
                    }

            
                    if (mRenderNodeFd >= 0) {

            
                        close(mRenderNodeFd);

            
                    }

            
                }


              private:

            
                gbm_device* CreateGbmDevice() {

            
                    // Render nodes [1] are the primary interface for communicating with the GPU on

            
                    // devices that support DRM. The actual filename of the render node is

            
                    // implementation-specific, so we must scan through all possible filenames to find

            
                    // one that we can use [2].

            
                    //

            
                    // [1] https://dri.freedesktop.org/docs/drm/gpu/drm-uapi.html#render-nodes

            
                    // [2]

            
                    // https://cs.chromium.org/chromium/src/ui/ozone/platform/wayland/gpu/drm_render_node_path_finder.cc

            
                    const uint32_t kRenderNodeStart = 128;

            
                    const uint32_t kRenderNodeEnd = kRenderNodeStart + 16;

            
                    const std::string kRenderNodeTemplate = "/dev/dri/renderD";


                    mRenderNodeFd = -1;

            
                    for (uint32_t i = kRenderNodeStart; i < kRenderNodeEnd; i++) {

            
                        std::string renderNode = kRenderNodeTemplate + std::to_string(i);

            
                        mRenderNodeFd = open(renderNode.c_str(), O_RDWR);

            
                        if (mRenderNodeFd >= 0) {

            
                            break;

            
                        }

            
                    }

            
                    DAWN_ASSERT(mRenderNodeFd > 0);


                    gbm_device* gbmDevice = gbm_create_device(mRenderNodeFd);

            
                    DAWN_ASSERT(gbmDevice != nullptr);

            
                    return gbmDevice;

            
                }


                static uint32_t GetGbmBoFormat(wgpu::TextureFormat format) {

            
                    switch (format) {

            
                        case wgpu::TextureFormat::R8BG8Biplanar420Unorm:

            
                            return GBM_FORMAT_NV12;

            
                        default:

            
                            DAWN_UNREACHABLE();

            
                    }

            
                }


                WGPUTextureFormat ToWGPUTextureFormat(wgpu::TextureFormat format) {

            
                    switch (format) {

            
                        case wgpu::TextureFormat::R8BG8Biplanar420Unorm:

            
                            return WGPUTextureFormat_R8BG8Biplanar420Unorm;

            
                        default:

            
                            DAWN_UNREACHABLE();

            
                    }

            
                }


                WGPUTextureUsage ToWGPUTextureUsage(wgpu::TextureUsage usage) {

            
                    switch (usage) {

            
                        case wgpu::TextureUsage::TextureBinding:

            
                            return WGPUTextureUsage_TextureBinding;

            
                        default:

            
                            DAWN_UNREACHABLE();

            
                    }

            
                }


                std::unique_ptr<VideoViewsTestBackend::PlatformTexture> CreateVideoTextureForTest(

            
                    wgpu::TextureFormat format,

            
                    wgpu::TextureUsage usage,

            
                    bool isCheckerboard,

            
                    bool initialized) override {

            
                    // The flags Chromium is using for the VAAPI decoder.

            
                    uint32_t flags = GBM_BO_USE_SCANOUT | GBM_BO_USE_TEXTURING | GBM_BO_USE_HW_VIDEO_DECODER;

            
                    if (initialized) {

            
                        // The flag specifically used for tests, which need to initialize the GBM buffer with

            
                        // the expected raw video data via CPU, and then sample and draw the buffer via GPU.

            
                        // With the flag added, the buffer's drm modifier will be DRM_FORMAT_MOD_LINEAR instead

            
                        // of I915_FORMAT_MOD_Y_TILED.

            
                        flags |= GBM_BO_USE_SW_WRITE_RARELY;

            
                    }

            
                    gbm_bo* gbmBo = gbm_bo_create(mGbmDevice, VideoViewsTestsBase::kYUVAImageDataWidthInTexels,

            
                                                  VideoViewsTestsBase::kYUVAImageDataHeightInTexels,

            
                                                  GetGbmBoFormat(format), flags);

            
                    if (gbmBo == nullptr) {

            
                        return nullptr;

            
                    }


                    if (initialized) {

            
                        void* mapHandle = nullptr;

            
                        uint32_t strideBytes = 0;

            
                        void* addr = gbm_bo_map(gbmBo, 0, 0, VideoViewsTestsBase::kYUVAImageDataWidthInTexels,

            
                                                VideoViewsTestsBase::kYUVAImageDataHeightInTexels,

            
                                                GBM_BO_TRANSFER_WRITE, &strideBytes, &mapHandle);

            
                        EXPECT_NE(addr, nullptr);

            
                        std::vector<uint8_t> initialData = VideoViewsTestsBase::GetTestTextureData<uint8_t>(

            
                            /*isMultiPlane*/ true, isCheckerboard,

            
                            /*hasAlpha*/ false);

            
                        uint8_t* srcBegin = initialData.data();

            
                        uint8_t* srcEnd = srcBegin + initialData.size();

            
                        uint8_t* dstBegin = static_cast<uint8_t*>(addr);

            
                        for (; srcBegin < srcEnd; srcBegin += VideoViewsTestsBase::kYUVAImageDataWidthInTexels,

            
                                                  dstBegin += strideBytes) {

            
                            std::memcpy(dstBegin, srcBegin, VideoViewsTestsBase::kYUVAImageDataWidthInTexels);

            
                        }


                        gbm_bo_unmap(gbmBo, mapHandle);

            
                    }


                    wgpu::TextureDescriptor textureDesc;

            
                    textureDesc.format = format;

            
                    textureDesc.dimension = wgpu::TextureDimension::e2D;

            
                    textureDesc.usage = usage;

            
                    textureDesc.size = {VideoViewsTestsBase::kYUVAImageDataWidthInTexels,

            
                                        VideoViewsTestsBase::kYUVAImageDataHeightInTexels, 1};


                    wgpu::DawnTextureInternalUsageDescriptor internalDesc;

            
                    internalDesc.internalUsage = wgpu::TextureUsage::CopySrc;

            
                    textureDesc.nextInChain = &internalDesc;


                    native::vulkan::ExternalImageDescriptorDmaBuf descriptor = {};

            
                    descriptor.cTextureDescriptor =

            
                        reinterpret_cast<const WGPUTextureDescriptor*>(&textureDesc);

            
                    descriptor.isInitialized = initialized;


                    descriptor.memoryFD = gbm_bo_get_fd(gbmBo);

            
                    for (int plane = 0; plane < gbm_bo_get_plane_count(gbmBo); ++plane) {

            
                        descriptor.planeLayouts[plane].stride = gbm_bo_get_stride_for_plane(gbmBo, plane);

            
                        descriptor.planeLayouts[plane].offset = gbm_bo_get_offset(gbmBo, plane);

            
                    }

            
                    descriptor.drmModifier = gbm_bo_get_modifier(gbmBo);

            
                    descriptor.waitFDs = {};


                    auto texture = std::make_unique<PlatformTextureGbm>(

            
                        native::vulkan::WrapVulkanImage(mWGPUDevice, &descriptor), gbmBo);

            
                    // The ownership of FD is only transferred in case of a success import. Otherwise cleanup

            
                    // is still needed to avoid FD leak.

            
                    if (!texture->wgpuTexture && descriptor.memoryFD >= 0) {

            
                        close(descriptor.memoryFD);

            
                    }

            
                    return texture;

            
                }


                void DestroyVideoTextureForTest(

            
                    std::unique_ptr<VideoViewsTestBackend::PlatformTexture>&& platformTexture) override {

            
                    // Exports the signal and ignores it.

            
                    native::vulkan::ExternalImageExportInfoDmaBuf exportInfo;

            
                    native::vulkan::ExportVulkanImage(platformTexture->wgpuTexture.Get(),

            
                                                      VK_IMAGE_LAYOUT_UNDEFINED, &exportInfo);

            
                    for (int fd : exportInfo.semaphoreHandles) {

            
                        ASSERT_NE(fd, -1);

            
                        close(fd);

            
                    }

            
                    gbm_bo* gbmBo = static_cast<PlatformTextureGbm*>(platformTexture.get())->GetGbmBo();

            
                    ASSERT_NE(gbmBo, nullptr);

            
                    gbm_bo_destroy(gbmBo);

            
                }


                WGPUDevice mWGPUDevice = nullptr;

            
                gbm_device* mGbmDevice = nullptr;

            
                int mRenderNodeFd = -1;

            
            };


            }  // anonymous namespace


            // static

            
            std::vector<BackendTestConfig> VideoViewsTestBackend::Backends() {

            
                return {VulkanBackend()};

            
            }


            // static

            
            std::vector<Format> VideoViewsTestBackend::Formats() {

            
                // TODO(dawn:551): Support sharing P010 video surfaces.

            
                return {wgpu::TextureFormat::R8BG8Biplanar420Unorm};

            
            }


            // static

            
            std::unique_ptr<VideoViewsTestBackend> VideoViewsTestBackend::Create() {

            
                return std::make_unique<VideoViewsTestBackendGbm>();

            
            }


            }  // namespace dawn
	// Copyright 2021 The Dawn & Tint Authors
	//
	// Redistribution and use in source and binary forms, with or without
	// modification, are permitted provided that the following conditions are met:
	//
	// 1. Redistributions of source code must retain the above copyright notice, this
	// list of conditions and the following disclaimer.
	//
	// 2. Redistributions in binary form must reproduce the above copyright notice,
	// this list of conditions and the following disclaimer in the documentation
	// and/or other materials provided with the distribution.
	//
	// 3. Neither the name of the copyright holder nor the names of its
	// contributors may be used to endorse or promote products derived from
	// this software without specific prior written permission.
	//
	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
	// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
	// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
	// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
	// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

	#include <fcntl.h>
	#include <gbm.h>

	#include <memory>
	#include <string>
	#include <utility>
	#include <vector>

	#include "VideoViewsTests.h"
	#include "dawn/common/Assert.h"
	#include "dawn/native/VulkanBackend.h"

	namespace dawn {
	namespace {

	// "linux-chromeos-rel"'s gbm.h is too old to compile, missing this change at least:
	// https://chromium-review.googlesource.com/c/chromiumos/platform/minigbm/+/1963001/10/gbm.h#244
	#ifndef MINIGBM
	#define GBM_BO_USE_TEXTURING (1 << 5)
	#define GBM_BO_USE_SW_WRITE_RARELY (1 << 12)
	#define GBM_BO_USE_HW_VIDEO_DECODER (1 << 13)
	#endif

	#ifndef DRM_FORMAT_MOD_LINEAR
	#define DRM_FORMAT_MOD_LINEAR 0
	#endif

	class PlatformTextureGbm : public VideoViewsTestBackend::PlatformTexture {
	public:
	PlatformTextureGbm(wgpu::Texture&& texture, gbm_bo* gbmBo)
	: PlatformTexture(std::move(texture)), mGbmBo(gbmBo) {}
	~PlatformTextureGbm() override = default;

	// TODO(chromium:1258986): Add DISJOINT vkImage support for multi-plannar formats.
	bool CanWrapAsWGPUTexture() override {
	DAWN_ASSERT(mGbmBo != nullptr);
	// Checks if all plane handles of a multi-planar gbm_bo are same.
	gbm_bo_handle plane0Handle = gbm_bo_get_handle_for_plane(mGbmBo, 0);
	for (int plane = 1; plane < gbm_bo_get_plane_count(mGbmBo); ++plane) {
	if (gbm_bo_get_handle_for_plane(mGbmBo, plane).u32 != plane0Handle.u32) {
	return false;
	}
	}
	return true;
	}

	gbm_bo* GetGbmBo() { return mGbmBo; }

	private:
	gbm_bo* mGbmBo = nullptr;
	};

	class VideoViewsTestBackendGbm : public VideoViewsTestBackend {
	public:
	void OnSetUp(WGPUDevice device) override {
	mWGPUDevice = device;
	mGbmDevice = CreateGbmDevice();
	}

	void OnTearDown() override {
	if (mGbmDevice != nullptr) {
	gbm_device_destroy(mGbmDevice);
	}
	if (mRenderNodeFd >= 0) {
	close(mRenderNodeFd);
	}
	}

	private:
	gbm_device* CreateGbmDevice() {
	// Render nodes [1] are the primary interface for communicating with the GPU on
	// devices that support DRM. The actual filename of the render node is
	// implementation-specific, so we must scan through all possible filenames to find
	// one that we can use [2].
	//
	// [1] https://dri.freedesktop.org/docs/drm/gpu/drm-uapi.html#render-nodes
	// [2]
	// https://cs.chromium.org/chromium/src/ui/ozone/platform/wayland/gpu/drm_render_node_path_finder.cc
	const uint32_t kRenderNodeStart = 128;
	const uint32_t kRenderNodeEnd = kRenderNodeStart + 16;
	const std::string kRenderNodeTemplate = "/dev/dri/renderD";

	mRenderNodeFd = -1;
	for (uint32_t i = kRenderNodeStart; i < kRenderNodeEnd; i++) {
	std::string renderNode = kRenderNodeTemplate + std::to_string(i);
	mRenderNodeFd = open(renderNode.c_str(), O_RDWR);
	if (mRenderNodeFd >= 0) {
	break;
	}
	}
	DAWN_ASSERT(mRenderNodeFd > 0);

	gbm_device* gbmDevice = gbm_create_device(mRenderNodeFd);
	DAWN_ASSERT(gbmDevice != nullptr);
	return gbmDevice;
	}

	static uint32_t GetGbmBoFormat(wgpu::TextureFormat format) {
	switch (format) {
	case wgpu::TextureFormat::R8BG8Biplanar420Unorm:
	return GBM_FORMAT_NV12;
	default:
	DAWN_UNREACHABLE();
	}
	}

	WGPUTextureFormat ToWGPUTextureFormat(wgpu::TextureFormat format) {
	switch (format) {
	case wgpu::TextureFormat::R8BG8Biplanar420Unorm:
	return WGPUTextureFormat_R8BG8Biplanar420Unorm;
	default:
	DAWN_UNREACHABLE();
	}
	}

	WGPUTextureUsage ToWGPUTextureUsage(wgpu::TextureUsage usage) {
	switch (usage) {
	case wgpu::TextureUsage::TextureBinding:
	return WGPUTextureUsage_TextureBinding;
	default:
	DAWN_UNREACHABLE();
	}
	}

	std::unique_ptr<VideoViewsTestBackend::PlatformTexture> CreateVideoTextureForTest(
	wgpu::TextureFormat format,
	wgpu::TextureUsage usage,
	bool isCheckerboard,
	bool initialized) override {
	// The flags Chromium is using for the VAAPI decoder.
	uint32_t flags = GBM_BO_USE_SCANOUT \| GBM_BO_USE_TEXTURING \| GBM_BO_USE_HW_VIDEO_DECODER;
	if (initialized) {
	// The flag specifically used for tests, which need to initialize the GBM buffer with
	// the expected raw video data via CPU, and then sample and draw the buffer via GPU.
	// With the flag added, the buffer's drm modifier will be DRM_FORMAT_MOD_LINEAR instead
	// of I915_FORMAT_MOD_Y_TILED.
	flags \|= GBM_BO_USE_SW_WRITE_RARELY;
	}
	gbm_bo* gbmBo = gbm_bo_create(mGbmDevice, VideoViewsTestsBase::kYUVAImageDataWidthInTexels,
	VideoViewsTestsBase::kYUVAImageDataHeightInTexels,
	GetGbmBoFormat(format), flags);
	if (gbmBo == nullptr) {
	return nullptr;
	}

	if (initialized) {
	void* mapHandle = nullptr;
	uint32_t strideBytes = 0;
	void* addr = gbm_bo_map(gbmBo, 0, 0, VideoViewsTestsBase::kYUVAImageDataWidthInTexels,
	VideoViewsTestsBase::kYUVAImageDataHeightInTexels,
	GBM_BO_TRANSFER_WRITE, &strideBytes, &mapHandle);
	EXPECT_NE(addr, nullptr);
	std::vector<uint8_t> initialData = VideoViewsTestsBase::GetTestTextureData<uint8_t>(
	/isMultiPlane/ true, isCheckerboard,
	/hasAlpha/ false);
	uint8_t* srcBegin = initialData.data();
	uint8_t* srcEnd = srcBegin + initialData.size();
	uint8_t* dstBegin = static_cast<uint8_t*>(addr);
	for (; srcBegin < srcEnd; srcBegin += VideoViewsTestsBase::kYUVAImageDataWidthInTexels,
	dstBegin += strideBytes) {
	std::memcpy(dstBegin, srcBegin, VideoViewsTestsBase::kYUVAImageDataWidthInTexels);
	}

	gbm_bo_unmap(gbmBo, mapHandle);
	}

	wgpu::TextureDescriptor textureDesc;
	textureDesc.format = format;
	textureDesc.dimension = wgpu::TextureDimension::e2D;
	textureDesc.usage = usage;
	textureDesc.size = {VideoViewsTestsBase::kYUVAImageDataWidthInTexels,
	VideoViewsTestsBase::kYUVAImageDataHeightInTexels, 1};

	wgpu::DawnTextureInternalUsageDescriptor internalDesc;
	internalDesc.internalUsage = wgpu::TextureUsage::CopySrc;
	textureDesc.nextInChain = &internalDesc;

	native::vulkan::ExternalImageDescriptorDmaBuf descriptor = {};
	descriptor.cTextureDescriptor =
	reinterpret_cast<const WGPUTextureDescriptor*>(&textureDesc);
	descriptor.isInitialized = initialized;

	descriptor.memoryFD = gbm_bo_get_fd(gbmBo);
	for (int plane = 0; plane < gbm_bo_get_plane_count(gbmBo); ++plane) {
	descriptor.planeLayouts[plane].stride = gbm_bo_get_stride_for_plane(gbmBo, plane);
	descriptor.planeLayouts[plane].offset = gbm_bo_get_offset(gbmBo, plane);
	}
	descriptor.drmModifier = gbm_bo_get_modifier(gbmBo);
	descriptor.waitFDs = {};

	auto texture = std::make_unique<PlatformTextureGbm>(
	native::vulkan::WrapVulkanImage(mWGPUDevice, &descriptor), gbmBo);
	// The ownership of FD is only transferred in case of a success import. Otherwise cleanup
	// is still needed to avoid FD leak.
	if (!texture->wgpuTexture && descriptor.memoryFD >= 0) {
	close(descriptor.memoryFD);
	}
	return texture;
	}

	void DestroyVideoTextureForTest(
	std::unique_ptr<VideoViewsTestBackend::PlatformTexture>&& platformTexture) override {
	// Exports the signal and ignores it.
	native::vulkan::ExternalImageExportInfoDmaBuf exportInfo;
	native::vulkan::ExportVulkanImage(platformTexture->wgpuTexture.Get(),
	VK_IMAGE_LAYOUT_UNDEFINED, &exportInfo);
	for (int fd : exportInfo.semaphoreHandles) {
	ASSERT_NE(fd, -1);
	close(fd);
	}
	gbm_bo* gbmBo = static_cast<PlatformTextureGbm*>(platformTexture.get())->GetGbmBo();
	ASSERT_NE(gbmBo, nullptr);
	gbm_bo_destroy(gbmBo);
	}

	WGPUDevice mWGPUDevice = nullptr;
	gbm_device* mGbmDevice = nullptr;
	int mRenderNodeFd = -1;
	};

	} // anonymous namespace

	// static
	std::vector<BackendTestConfig> VideoViewsTestBackend::Backends() {
	return {VulkanBackend()};
	}

	// static
	std::vector<Format> VideoViewsTestBackend::Formats() {
	// TODO(dawn:551): Support sharing P010 video surfaces.
	return {wgpu::TextureFormat::R8BG8Biplanar420Unorm};
	}

	// static
	std::unique_ptr<VideoViewsTestBackend> VideoViewsTestBackend::Create() {
	return std::make_unique<VideoViewsTestBackendGbm>();
	}

	} // namespace dawn