/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "ExternalTexture.h"

#include "Colorspaces.h"
#include "ImageContainer.h"
#include "mozilla/Assertions.h"
#include "mozilla/ErrorResult.h"
#include "mozilla/dom/HTMLVideoElement.h"
#include "mozilla/dom/VideoFrame.h"
#include "mozilla/dom/WebGPUBinding.h"
#include "mozilla/gfx/Logging.h"
#include "mozilla/gfx/Types.h"
#include "mozilla/layers/ImageDataSerializer.h"
#include "mozilla/layers/LayersSurfaces.h"
#include "mozilla/layers/TextureHost.h"
#include "mozilla/layers/VideoBridgeParent.h"
#include "mozilla/webgpu/Queue.h"
#include "mozilla/webgpu/Utility.h"
#include "mozilla/webgpu/WebGPUChild.h"
#include "mozilla/webgpu/WebGPUParent.h"
#include "nsLayoutUtils.h"
#include "nsPrintfCString.h"

#ifdef XP_WIN
#  include "mozilla/layers/CompositeProcessD3D11FencesHolderMap.h"
#  include "mozilla/layers/GpuProcessD3D11TextureMap.h"
#  include "mozilla/layers/TextureD3D11.h"
#endif
#ifdef XP_MACOSX
#  include "mozilla/gfx/MacIOSurface.h"
#  include "mozilla/layers/MacIOSurfaceTextureHostOGL.h"
#endif

namespace mozilla::webgpu {

NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_WEAK_PTR(ExternalTexture, mParent)
GPU_IMPL_JS_WRAP(ExternalTexture)

ExternalTexture::ExternalTexture(Device* const aParent, RawId aId,
                                 RefPtr<ExternalTextureSourceClient> aSource)
    : ObjectBase(aParent->GetChild(), aId,
                 ffi::wgpu_client_drop_external_texture),
      ChildOf(aParent),
      mSource(aSource) {}

ExternalTexture::~ExternalTexture() = default;

/* static */ already_AddRefed<ExternalTexture> ExternalTexture::Create(
    Device* const aParent, const nsString& aLabel,
    const RefPtr<ExternalTextureSourceClient>& aSource,
    dom::PredefinedColorSpace aColorSpace) {
  const webgpu::StringHelper label(aLabel);
  const ffi::WGPUPredefinedColorSpace colorSpace =
      ConvertPredefinedColorSpace(aColorSpace);
  const ffi::WGPUExternalTextureDescriptor desc = {
      .label = label.Get(),
      .source = aSource ? aSource->GetId() : 0,
      .color_space = colorSpace,
  };

  const RawId id = ffi::wgpu_client_create_external_texture(
      aParent->GetClient(), aParent->GetId(), &desc);

  RefPtr<ExternalTexture> externalTexture =
      new ExternalTexture(aParent, id, aSource);
  externalTexture->SetLabel(aLabel);

  return externalTexture.forget();
}

void ExternalTexture::Expire() {
  mIsExpired = true;
  MaybeDestroy();
}

void ExternalTexture::Unexpire() {
  MOZ_ASSERT(!mIsDestroyed);
  MOZ_ASSERT(mSource);
  mIsExpired = false;
}

void ExternalTexture::OnSubmit(uint64_t aSubmissionIndex) {
  mLastSubmittedIndex = aSubmissionIndex;
}

void ExternalTexture::OnSubmittedWorkDone(uint64_t aSubmissionIndex) {
  mLastSubmittedWorkDoneIndex = aSubmissionIndex;
  MaybeDestroy();
}

void ExternalTexture::MaybeDestroy() {
  if (!mIsDestroyed && mIsExpired &&
      mLastSubmittedWorkDoneIndex >= mLastSubmittedIndex) {
    mIsDestroyed = true;
    mSource = nullptr;
    // We could be cleverer and keep the external texture alive until its
    // source is destroyed and there's no chance we could want to reuse the
    // external texture. But that would complicate the logic and perhaps not
    // even gain all that much, as typically attempts to reuse the external
    // texture will occur before the previously submitted work is done, so will
    // be successful anyway.
    ffi::wgpu_client_destroy_external_texture(GetClient(), GetId());
  }
}

RefPtr<ExternalTexture> ExternalTextureCache::GetOrCreate(
    Device* aDevice, const dom::GPUExternalTextureDescriptor& aDesc,
    ErrorResult& aRv) {
  const RefPtr<ExternalTextureSourceClient> source =
      GetOrCreateSource(aDevice, aDesc.mSource, aRv);

  if (source) {
    return source->GetOrCreateExternalTexture(aDevice, aDesc);
  }

  // Create external texture with a null source to indicate error state.
  return ExternalTexture::Create(aDevice, aDesc.mLabel, nullptr,
                                 aDesc.mColorSpace);
}

RefPtr<ExternalTextureSourceClient> ExternalTextureCache::GetOrCreateSource(
    Device* aDevice, const dom::OwningHTMLVideoElementOrVideoFrame& aSource,
    ErrorResult& aRv) {
  RefPtr<layers::Image> image;
  switch (aSource.GetType()) {
    case dom::OwningHTMLVideoElementOrVideoFrame::Type::eHTMLVideoElement:
      image = aSource.GetAsHTMLVideoElement()->GetCurrentImage();
      break;
    case dom::OwningHTMLVideoElementOrVideoFrame::Type::eVideoFrame:
      image = aSource.GetAsVideoFrame()->GetImage();
      break;
  }

  typename decltype(mSources)::AddPtr p;
  if (image) {
    p = mSources.lookupForAdd(image->GetSerial());
    if (p) {
      const RefPtr<ExternalTextureSourceClient> source = p->value();
      MOZ_ASSERT(source->mImage == image);
      return source;
    }
  }

  // If we didn't find an image above we know this is going to fail, but call
  // it anyway so that we can keep all our error handling in one place.
  const RefPtr<ExternalTextureSourceClient> source =
      ExternalTextureSourceClient::Create(aDevice, this, aSource, aRv);
  if (source) {
    // If creating the source succeeded, we must have found an image, which
    // means we must have a valid AddPtr from above.
    // An OOM error in add() just means we don't get to cache the source, but we
    // can still proceed.
    (void)mSources.add(p, source->mImage->GetSerial(), source);
  }
  return source;
}

void ExternalTextureCache::RemoveSource(
    const ExternalTextureSourceClient* aSource) {
  mSources.remove(aSource->mImage->GetSerial());
}

ExternalTextureSourceClient::ExternalTextureSourceClient(
    WebGPUChild* aChild, RawId aId, ExternalTextureCache* aCache,
    const RefPtr<layers::Image>& aImage,
    const std::array<RawId, 3>& aTextureIds,
    const std::array<RawId, 3>& aViewIds)
    : ObjectBase(aChild, aId, ffi::wgpu_client_drop_external_texture_source),
      mImage(aImage),
      mTextureIds(std::move(aTextureIds)),
      mViewIds(std::move(aViewIds)),
      mCache(aCache) {
  MOZ_RELEASE_ASSERT(aId);
}

ExternalTextureSourceClient::~ExternalTextureSourceClient() {
  if (mCache) {
    mCache->RemoveSource(this);
  }

  // Call destroy() in addition to drop() to ensure the plane textures are
  // destroyed immediately. Otherwise they will remain alive until any external
  // textures/bind groups referencing them are garbage collected, which can
  // quickly result in excessive memory usage.
  ffi::wgpu_client_destroy_external_texture_source(GetClient(), GetId());
  // Usually we'd just drop() the textures and views, which would in turn free
  // their IDs. However, we don't know which IDs were used by the host to
  // actually create textures and views with. Therefore the host side is
  // responsible for dropping the textures and views that it actually created,
  // but the client side must free all of the IDs that were made.
  for (const auto id : mViewIds) {
    wgpu_client_free_texture_view_id(GetClient(), id);
  }
  for (const auto id : mTextureIds) {
    wgpu_client_free_texture_id(GetClient(), id);
  }
}

/* static */ already_AddRefed<ExternalTextureSourceClient>
ExternalTextureSourceClient::Create(
    Device* aDevice, ExternalTextureCache* aCache,
    const dom::OwningHTMLVideoElementOrVideoFrame& aSource, ErrorResult& aRv) {
  // Obtain the layers::Image from the HTMLVideoElement or VideoFrame. We use
  // nsLayoutUtils::SurfaceFrom*() instead of directly fetching the image, as it
  // helps with the security checks below. It also helpfully determines the
  // (coded) size, intrinsic size, and crop rect fields for us. Passing
  // SFE_ALLOW_UNCROPPED_UNSCALED ensures it does not create a source surface,
  // as we are able to handle the cropping and scaling ourself.
  const uint32_t flags = nsLayoutUtils::SFE_ALLOW_UNCROPPED_UNSCALED;
  SurfaceFromElementResult sfeResult;
  VideoRotation rotation;
  switch (aSource.GetType()) {
    case dom::OwningHTMLVideoElementOrVideoFrame::Type::eHTMLVideoElement: {
      const auto& videoElement = aSource.GetAsHTMLVideoElement();
      sfeResult = nsLayoutUtils::SurfaceFromElement(videoElement.get(), flags);
      rotation = videoElement->RotationDegrees();
    } break;
    case dom::OwningHTMLVideoElementOrVideoFrame::Type::eVideoFrame: {
      const auto& videoFrame = aSource.GetAsVideoFrame();
      sfeResult = nsLayoutUtils::SurfaceFromVideoFrame(videoFrame.get(), flags);
      rotation = VideoRotation::kDegree_0;
    } break;
  }

  // If source is not origin-clean, throw a SecurityError and return.
  // https://www.w3.org/TR/webgpu/#dom-gpudevice-importexternaltexture
  if (!sfeResult.mCORSUsed) {
    const nsIGlobalObject* const global = aDevice->GetOwnerGlobal();
    nsIPrincipal* const dstPrincipal =
        global ? global->PrincipalOrNull() : nullptr;
    if (!sfeResult.mPrincipal || !dstPrincipal ||
        !dstPrincipal->Subsumes(sfeResult.mPrincipal)) {
      aRv.ThrowSecurityError("Cross-origin elements require CORS!");
      return nullptr;
    }
  }
  if (sfeResult.mIsWriteOnly) {
    aRv.ThrowSecurityError("Write only source data not supported!");
    return nullptr;
  }

  const auto child = aDevice->GetChild();

  // Let usability be ? check the usability of the image argument(source).
  // If usability is not good:
  //   1. Generate a validation error.
  //   2. Return an invalidated GPUExternalTexture.
  // https://www.w3.org/TR/webgpu/#dom-gpudevice-importexternaltexture
  const RefPtr<layers::Image> image = sfeResult.mLayersImage;
  if (!image) {
    ffi::wgpu_report_validation_error(child->GetClient(), aDevice->GetId(),
                                      "Video source's usability is bad");
    return nullptr;
  }

  layers::SurfaceDescriptor sd;
  const nsresult rv = image->BuildSurfaceDescriptorGPUVideoOrBuffer(
      sd, layers::Image::BuildSdbFlags::Default, Nothing(),
      [&](uint32_t aBufferSize) {
        ipc::Shmem buffer;
        if (!child->AllocShmem(aBufferSize, &buffer)) {
          return layers::MemoryOrShmem();
        }
        return layers::MemoryOrShmem(std::move(buffer));
      },
      [&](layers::MemoryOrShmem&& aBuffer) {
        child->DeallocShmem(aBuffer.get_Shmem());
      });
  if (NS_FAILED(rv)) {
    gfxCriticalErrorOnce() << "BuildSurfaceDescriptorGPUVideoOrBuffer failed";
    ffi::wgpu_report_internal_error(
        child->GetClient(), aDevice->GetId(),
        "BuildSurfaceDescriptorGPUVideoOrBuffer failed");
    return nullptr;
  }

  const auto sourceId =
      ffi::wgpu_client_make_external_texture_source_id(child->GetClient());
  // We don't know how many textures or views the host side will need, so make
  // enough IDs for up to 3 of each.
  const std::array<RawId, 3> textureIds{
      ffi::wgpu_client_make_texture_id(child->GetClient()),
      ffi::wgpu_client_make_texture_id(child->GetClient()),
      ffi::wgpu_client_make_texture_id(child->GetClient()),
  };
  const std::array<RawId, 3> viewIds{
      ffi::wgpu_client_make_texture_view_id(child->GetClient()),
      ffi::wgpu_client_make_texture_view_id(child->GetClient()),
      ffi::wgpu_client_make_texture_view_id(child->GetClient()),
  };

  // The actual size of the surface (possibly including non-visible padding).
  // This has not been adjusted for any rotation.
  const gfx::IntSize codedSize = sfeResult.mSize;
  // The crop rectangle to be displayed, defaulting to the full surface if not
  // provided. This is relative to the coded size, and again has not been
  // adjusted for any rotation.
  const gfx::IntRect cropRect =
      sfeResult.mCropRect.valueOr(gfx::IntRect({}, codedSize));
  // The size the surface is intended to be rendered at. We use this for the
  // external texture descriptor's size field which will be the size reported
  // to web content, eg via WGSL's `textureDimensions()` builtin. This has had
  // rotation taken into account.
  const gfx::IntSize intrinsicSize = sfeResult.mIntrinsicSize;

  // Calculate the sample transform, starting with the rotation. As only 90
  // degree increments are supported, we hard-code the values to avoid
  // expensive trig and to keep the numbers precise. If/when we support flips
  // we'd handle that here too.
  gfx::Matrix sampleTransform;
  switch (rotation) {
    case VideoRotation::kDegree_0:
      break;
    case VideoRotation::kDegree_90:
      sampleTransform = gfx::Matrix(0.0, -1.0, 1.0, 0.0, 0.0, 1.0);
      break;
    case VideoRotation::kDegree_180:
      sampleTransform = gfx::Matrix(-1.0, 0.0, 0.0, -1.0, 1.0, 1.0);
      break;
    case VideoRotation::kDegree_270:
      sampleTransform = gfx::Matrix(0.0, 1.0, -1.0, 0.0, 1.0, 0.0);
      break;
  }

  // Scale and translate to account for the crop rect. We need to ensure that
  // the normalized coordinates (0,0)..(1,1) map to the crop rect rather than
  // the coded size. We must therefore normalize the crop rect by dividing by
  // the coded size, then scale and translate the transform based on the
  // normalized crop rect. We apply these transformations pre-rotation as the
  // crop rect itself is expressed pre-rotation. Note the intrinsic size is
  // irrelevant here as we are dealing with normalized coordinates.
  gfx::Rect normalizedCropRect = gfx::Rect(cropRect);
  normalizedCropRect.Scale(1.0 / static_cast<float>(codedSize.width),
                           1.0 / static_cast<float>(codedSize.height));
  sampleTransform.PreTranslate(normalizedCropRect.x, normalizedCropRect.y);
  sampleTransform.PreScale(normalizedCropRect.Width(),
                           normalizedCropRect.Height());

  // Derive the load transform from the sample transform. Texture loads accept
  // unnormalized texel coordinates ranging from (0,0) to the intrinsic size
  // minus one, i.e. based on the size the external texture reports itself as
  // to web content. We need to map these to our rotated crop rect, and the end
  // result must be texel coordinates based on the actual texture size. This
  // can be achieved by first normalizing the coordinates by dividing by the
  // intrinsic size minus one, then applying the sample transformation, then
  // unnormalizing the transformed coordinates by multiplying by the actual
  // texture size minus one.
  gfx::Matrix loadTransform = sampleTransform;
  loadTransform.PreScale(
      1.0 / static_cast<float>(std::max(intrinsicSize.width - 1, 1)),
      1.0 / static_cast<float>(std::max(intrinsicSize.height - 1, 1)));
  loadTransform.PostScale(static_cast<float>(codedSize.width - 1),
                          static_cast<float>(codedSize.height - 1));

  const ExternalTextureSourceDescriptor sourceDesc = {
      .mTextureIds = textureIds,
      .mViewIds = viewIds,
      .mSurfaceDescriptor = std::move(sd),
      .mSize = intrinsicSize,
      .mSampleTransform = {sampleTransform._11, sampleTransform._12,
                           sampleTransform._21, sampleTransform._22,
                           sampleTransform._31, sampleTransform._32},
      .mLoadTransform = {loadTransform._11, loadTransform._12,
                         loadTransform._21, loadTransform._22,
                         loadTransform._31, loadTransform._32},
  };

  // We use a separate IPDL message than Messages() so that IPDL can handle the
  // SurfaceDescriptor (de)serialization for us. We must therefore flush any
  // queued messages first so that they are processed in the correct order.
  child->FlushQueuedMessages();
  child->SendCreateExternalTextureSource(
      aDevice->GetId(), aDevice->GetQueue()->GetId(), sourceId, sourceDesc);

  RefPtr<ExternalTextureSourceClient> source = new ExternalTextureSourceClient(
      child, sourceId, aCache, image, textureIds, viewIds);
  return source.forget();
}

RefPtr<ExternalTexture> ExternalTextureSourceClient::GetOrCreateExternalTexture(
    Device* aDevice, const dom::GPUExternalTextureDescriptor& aDesc) {
  auto p = mExternalTextures.lookupForAdd(aDesc.mColorSpace);
  if (p) {
    if (auto* const externalTexture = p->value().get()) {
      if (!externalTexture->IsDestroyed()) {
        externalTexture->Unexpire();
        return externalTexture;
      }
    }
  }

  const RefPtr<ExternalTexture> externalTexture =
      ExternalTexture::Create(aDevice, aDesc.mLabel, this, aDesc.mColorSpace);

  if (externalTexture) {
    if (p) {
      p->value() = externalTexture;
    } else {
      // OOM error in add() just means we don't get to cache the external
      // texture, but we can still proceed.
      (void)mExternalTextures.add(p, aDesc.mColorSpace, externalTexture);
    }
  }

  return externalTexture;
}

ExternalTextureSourceHost::ExternalTextureSourceHost(
    Span<const RawId> aTextureIds, Span<const RawId> aViewIds,
    gfx::IntSize aSize, gfx::SurfaceFormat aFormat,
    gfx::YUVRangedColorSpace aColorSpace,
    const std::array<float, 6>& aSampleTransform,
    const std::array<float, 6>& aLoadTransform)
    : mSize(aSize),
      mFormat(aFormat),
      mColorSpace(aColorSpace),
      mSampleTransform(aSampleTransform),
      mLoadTransform(aLoadTransform) {
  mTextureIds.AppendElements(aTextureIds);
  mViewIds.AppendElements(aViewIds);
}

/* static */ ExternalTextureSourceHost ExternalTextureSourceHost::Create(
    WebGPUParent* aParent, RawId aDeviceId, RawId aQueueId,
    const ExternalTextureSourceDescriptor& aDesc) {
  const auto& sd = aDesc.mSurfaceDescriptor;
  switch (sd.type()) {
    case layers::SurfaceDescriptor::TSurfaceDescriptorBuffer: {
      const layers::SurfaceDescriptorBuffer& bufferDesc =
          sd.get_SurfaceDescriptorBuffer();
      ipc::Shmem& bufferShmem = bufferDesc.data().get_Shmem();
      auto source =
          CreateFromBufferDesc(aParent, aDeviceId, aQueueId, aDesc,
                               bufferDesc.desc(), bufferShmem.Range<uint8_t>());
      aParent->DeallocShmem(bufferShmem);
      return source;
    } break;

    case layers::SurfaceDescriptor::TSurfaceDescriptorGPUVideo: {
      const layers::SurfaceDescriptorGPUVideo& gpuVideoDesc =
          sd.get_SurfaceDescriptorGPUVideo();
      const layers::SurfaceDescriptorRemoteDecoder& remoteDecoderDesc =
          gpuVideoDesc.get_SurfaceDescriptorRemoteDecoder();

      const auto videoBridge =
          layers::VideoBridgeParent::GetSingleton(remoteDecoderDesc.source());
      if (!videoBridge) {
        gfxCriticalErrorOnce() << "Failed to get VideoBridge";
        aParent->ReportError(aDeviceId, dom::GPUErrorFilter::Internal,
                             "Failed to get VideoBridge"_ns);
        return CreateError();
      }
      const RefPtr<layers::TextureHost> textureHost =
          videoBridge->LookupTexture(aParent->mContentId,
                                     remoteDecoderDesc.handle());
      if (!textureHost) {
        gfxCriticalErrorOnce() << "Failed to lookup remote decoder texture";
        aParent->ReportError(aDeviceId, dom::GPUErrorFilter::Internal,
                             "Failed to lookup remote decoder texture"_ns);
        return CreateError();
      }

      if (const auto* bufferHost = textureHost->AsBufferTextureHost()) {
        return CreateFromBufferDesc(
            aParent, aDeviceId, aQueueId, aDesc,
            bufferHost->GetBufferDescriptor(),
            Span(bufferHost->GetBuffer(), bufferHost->GetBufferSize()));
      } else if (const auto* dxgiHost = textureHost->AsDXGITextureHostD3D11()) {
        return CreateFromDXGITextureHost(aParent, aDeviceId, aQueueId, aDesc,
                                         dxgiHost);
      } else if (const auto* dxgiYCbCrHost =
                     textureHost->AsDXGIYCbCrTextureHostD3D11()) {
        return CreateFromDXGIYCbCrTextureHost(aParent, aDeviceId, aQueueId,
                                              aDesc, dxgiYCbCrHost);
      } else if (const auto* ioSurfHost =
                     textureHost->AsMacIOSurfaceTextureHost()) {
        return CreateFromMacIOSurfaceTextureHost(aParent, aDeviceId, aDesc,
                                                 ioSurfHost);
      } else {
        gfxCriticalErrorOnce()
            << "Unexpected SurfaceDescriptorGPUVideo TextureHost type";
        aParent->ReportError(
            aDeviceId, dom::GPUErrorFilter::Internal,
            "Unexpected SurfaceDescriptorGPUVideo TextureHost type"_ns);
        return CreateError();
      }
    } break;
    default:
      gfxCriticalErrorOnce()
          << "Unexpected SurfaceDescriptor type: " << sd.type();
      aParent->ReportError(
          aDeviceId, dom::GPUErrorFilter::Internal,
          nsPrintfCString("Unexpected SurfaceDescriptor type: %d", sd.type()));
      return CreateError();
  }
  return CreateError();
}

/* static */ ExternalTextureSourceHost
ExternalTextureSourceHost::CreateFromBufferDesc(
    WebGPUParent* aParent, RawId aDeviceId, RawId aQueueId,
    const ExternalTextureSourceDescriptor& aDesc,
    const layers::BufferDescriptor& aBufferDesc, Span<uint8_t> aBuffer) {
  const gfx::SurfaceFormat format =
      layers::ImageDataSerializer::FormatFromBufferDescriptor(aBufferDesc);
  // Creates a texture and view for a single plane, and writes the provided data
  // to the texture.
  auto createPlane = [aParent, aDeviceId, aQueueId](
                         RawId texId, RawId viewId,
                         ffi::WGPUTextureFormat format, gfx::IntSize size,
                         Span<uint8_t> buffer, uint32_t stride) {
    const ffi::WGPUTextureDescriptor textureDesc{
        .size =
            ffi::WGPUExtent3d{
                .width = static_cast<uint32_t>(size.width),
                .height = static_cast<uint32_t>(size.height),
                .depth_or_array_layers = 1,
            },
        .mip_level_count = 1,
        .sample_count = 1,
        .dimension = ffi::WGPUTextureDimension_D2,
        .format = format,
        .usage = WGPUTextureUsages_TEXTURE_BINDING | WGPUTextureUsages_COPY_DST,
        .view_formats = {},
    };

    {
      ErrorBuffer error;
      ffi::wgpu_server_device_create_texture(
          aParent->GetContext(), aDeviceId, texId, &textureDesc, error.ToFFI());
      // Since we have full control over the creation of this texture, any
      // validation error we encounter should be treated as an internal error.
      error.CoerceValidationToInternal();
      aParent->ForwardError(error);
    }

    const ffi::WGPUTexelCopyTextureInfo dest{
        .texture = texId,
        .mip_level = 0,
        .origin = {},
        .aspect = ffi::WGPUTextureAspect_All,
    };

    const ffi::WGPUTexelCopyBufferLayout layout{
        .offset = 0,
        .bytes_per_row = &stride,
        .rows_per_image = nullptr,
    };
    const Span<uint8_t> slice = buffer.to(size.height * stride);
    const ffi::WGPUFfiSlice_u8 data{
        .data = slice.data(),
        .length = slice.size(),
    };
    {
      ErrorBuffer error;
      ffi::wgpu_server_queue_write_texture(aParent->GetContext(), aDeviceId,
                                           aQueueId, &dest, data, &layout,
                                           &textureDesc.size, error.ToFFI());
      error.CoerceValidationToInternal();
      aParent->ForwardError(error);
    }

    const ffi::WGPUTextureViewDescriptor viewDesc{};
    {
      ErrorBuffer error;
      ffi::wgpu_server_texture_create_view(aParent->GetContext(), aDeviceId,
                                           texId, viewId, &viewDesc,
                                           error.ToFFI());
      error.CoerceValidationToInternal();
      aParent->ForwardError(error);
    }
  };

  AutoTArray<RawId, 3> usedTextureIds;
  AutoTArray<RawId, 3> usedViewIds;
  gfx::YUVRangedColorSpace colorSpace;
  switch (aBufferDesc.type()) {
    case layers::BufferDescriptor::TRGBDescriptor: {
      const layers::RGBDescriptor& rgbDesc = aBufferDesc.get_RGBDescriptor();
      ffi::WGPUTextureFormat planeFormat;
      switch (rgbDesc.format()) {
        case gfx::SurfaceFormat::B8G8R8A8:
        case gfx::SurfaceFormat::B8G8R8X8:
          planeFormat = {ffi::WGPUTextureFormat_Bgra8Unorm};
          break;
        case gfx::SurfaceFormat::R8G8B8A8:
        case gfx::SurfaceFormat::R8G8B8X8:
          planeFormat = {ffi::WGPUTextureFormat_Rgba8Unorm};
          break;
        default:
          gfxCriticalErrorOnce()
              << "Unexpected RGBDescriptor format: " << rgbDesc.format();
          aParent->ReportError(
              aDeviceId, dom::GPUErrorFilter::Internal,
              nsPrintfCString("Unexpected RGBDescriptor format: %s",
                              mozilla::ToString(rgbDesc.format()).c_str()));
          return CreateError();
      }
      createPlane(aDesc.mTextureIds[0], aDesc.mViewIds[0], planeFormat,
                  rgbDesc.size(), aBuffer,
                  layers::ImageDataSerializer::GetRGBStride(rgbDesc));
      usedTextureIds.AppendElement(aDesc.mTextureIds[0]);
      usedViewIds.AppendElement(aDesc.mViewIds[0]);
      colorSpace = gfx::YUVRangedColorSpace::GbrIdentity;
    } break;
    case layers::BufferDescriptor::TYCbCrDescriptor: {
      const layers::YCbCrDescriptor& yCbCrDesc =
          aBufferDesc.get_YCbCrDescriptor();
      const gfx::IntSize ySize =
          layers::ImageDataSerializer::SizeFromBufferDescriptor(aBufferDesc);
      const gfx::IntSize cbCrSize =
          layers::ImageDataSerializer::GetCroppedCbCrSize(aBufferDesc);

      ffi::WGPUTextureFormat planeFormat;
      switch (yCbCrDesc.colorDepth()) {
        case gfx::ColorDepth::COLOR_8:
          planeFormat = {ffi::WGPUTextureFormat_R8Unorm};
          break;
        case gfx::ColorDepth::COLOR_10:
        case gfx::ColorDepth::COLOR_12:
        case gfx::ColorDepth::COLOR_16:
          gfxCriticalNoteOnce << "Unsupported color depth: "
                              << yCbCrDesc.colorDepth();
          aParent->ReportError(
              aDeviceId, dom::GPUErrorFilter::Internal,
              nsPrintfCString(
                  "Unsupported color depth: %s",
                  mozilla::ToString(yCbCrDesc.colorDepth()).c_str()));
          return CreateError();
      }

      createPlane(aDesc.mTextureIds[0], aDesc.mViewIds[0], planeFormat, ySize,
                  aBuffer.from(yCbCrDesc.yOffset()), yCbCrDesc.yStride());
      createPlane(aDesc.mTextureIds[1], aDesc.mViewIds[1], planeFormat,
                  cbCrSize, aBuffer.from(yCbCrDesc.cbOffset()),
                  yCbCrDesc.cbCrStride());
      createPlane(aDesc.mTextureIds[2], aDesc.mViewIds[2], planeFormat,
                  cbCrSize, aBuffer.from(yCbCrDesc.crOffset()),
                  yCbCrDesc.cbCrStride());
      usedTextureIds.AppendElements(aDesc.mTextureIds.data(),
                                    aDesc.mTextureIds.size());
      usedViewIds.AppendElements(aDesc.mViewIds.data(), aDesc.mViewIds.size());
      colorSpace = gfx::ToYUVRangedColorSpace(yCbCrDesc.yUVColorSpace(),
                                              yCbCrDesc.colorRange());
    } break;
    case layers::BufferDescriptor::T__None: {
      gfxCriticalErrorOnce() << "Invalid BufferDescriptor";
      aParent->ReportError(aDeviceId, dom::GPUErrorFilter::Internal,
                           "Invalid BufferDescriptor"_ns);
      return CreateError();
    } break;
  }

  return ExternalTextureSourceHost(usedTextureIds, usedViewIds, aDesc.mSize,
                                   format, colorSpace, aDesc.mSampleTransform,
                                   aDesc.mLoadTransform);
}

/* static */ ExternalTextureSourceHost
ExternalTextureSourceHost::CreateError() {
  return ExternalTextureSourceHost(
      {}, {}, gfx::IntSize(0, 0), gfx::SurfaceFormat::R8G8B8A8,
      gfx::YUVRangedColorSpace::GbrIdentity, {}, {});
}

/* static */ ExternalTextureSourceHost
ExternalTextureSourceHost::CreateFromDXGITextureHost(
    WebGPUParent* aParent, RawId aDeviceId, RawId aQueueId,
    const ExternalTextureSourceDescriptor& aDesc,
    const layers::DXGITextureHostD3D11* aTextureHost) {
#ifdef XP_WIN
  Maybe<HANDLE> handle;
  if (aTextureHost->mGpuProcessTextureId) {
    auto* textureMap = layers::GpuProcessD3D11TextureMap::Get();
    if (textureMap) {
      handle =
          textureMap->GetSharedHandle(aTextureHost->mGpuProcessTextureId.ref());
    }
  } else if (aTextureHost->mHandle) {
    handle.emplace(aTextureHost->mHandle->GetHandle());
  }

  if (!handle) {
    gfxCriticalErrorOnce() << "Failed to obtain D3D texture handle";
    aParent->ReportError(aDeviceId, dom::GPUErrorFilter::Internal,
                         "Failed to obtain D3D texture handle"_ns);
    return CreateError();
  }

  const gfx::YUVRangedColorSpace colorSpace = gfx::ToYUVRangedColorSpace(
      gfx::ToYUVColorSpace(aTextureHost->mColorSpace),
      aTextureHost->mColorRange);

  ffi::WGPUTextureFormat textureFormat;
  AutoTArray<std::pair<ffi::WGPUTextureFormat, ffi::WGPUTextureAspect>, 2>
      viewFormatAndAspects;
  switch (aTextureHost->mFormat) {
    case gfx::SurfaceFormat::R8G8B8A8:
    case gfx::SurfaceFormat::R8G8B8X8:
      textureFormat = {ffi::WGPUTextureFormat_Rgba8Unorm};
      viewFormatAndAspects.AppendElement(
          std::make_pair(textureFormat, ffi::WGPUTextureAspect_All));
      break;
    case gfx::SurfaceFormat::B8G8R8A8:
    case gfx::SurfaceFormat::B8G8R8X8:
      textureFormat = {ffi::WGPUTextureFormat_Bgra8Unorm};
      viewFormatAndAspects.AppendElement(
          std::make_pair(textureFormat, ffi::WGPUTextureAspect_All));
      break;
    case gfx::SurfaceFormat::NV12:
      textureFormat = {ffi::WGPUTextureFormat_NV12};
      viewFormatAndAspects.AppendElement(
          std::make_pair(ffi::WGPUTextureFormat{ffi::WGPUTextureFormat_R8Unorm},
                         ffi::WGPUTextureAspect_Plane0));
      viewFormatAndAspects.AppendElement(std::make_pair(
          ffi::WGPUTextureFormat{ffi::WGPUTextureFormat_Rg8Unorm},
          ffi::WGPUTextureAspect_Plane1));
      break;
    case gfx::SurfaceFormat::P010:
      textureFormat = {ffi::WGPUTextureFormat_P010};
      viewFormatAndAspects.AppendElement(std::make_pair(
          ffi::WGPUTextureFormat{ffi::WGPUTextureFormat_R16Unorm},
          ffi::WGPUTextureAspect_Plane0));
      viewFormatAndAspects.AppendElement(std::make_pair(
          ffi::WGPUTextureFormat{ffi::WGPUTextureFormat_Rg16Unorm},
          ffi::WGPUTextureAspect_Plane1));
      break;
    default:
      gfxCriticalNoteOnce << "Unsupported surface format: "
                          << aTextureHost->mFormat;
      aParent->ReportError(
          aDeviceId, dom::GPUErrorFilter::Internal,
          nsPrintfCString("Unsupported surface format: %s",
                          mozilla::ToString(aTextureHost->mFormat).c_str()));
      return CreateError();
  }

  AutoTArray<RawId, 1> usedTextureIds = {aDesc.mTextureIds[0]};
  AutoTArray<RawId, 2> usedViewIds;

  const ffi::WGPUTextureDescriptor textureDesc{
      .size =
          ffi::WGPUExtent3d{
              .width = static_cast<uint32_t>(aTextureHost->mSize.width),
              .height = static_cast<uint32_t>(aTextureHost->mSize.height),
              .depth_or_array_layers = 1,
          },
      .mip_level_count = 1,
      .sample_count = 1,
      .dimension = ffi::WGPUTextureDimension_D2,
      .format = textureFormat,
      .usage = WGPUTextureUsages_TEXTURE_BINDING,
      .view_formats = {},
  };
  {
    ErrorBuffer error;
    ffi::wgpu_server_device_import_texture_from_shared_handle(
        aParent->GetContext(), aDeviceId, usedTextureIds[0], &textureDesc,
        *handle, error.ToFFI());
    // From here on there's no need to return early with `CreateError()` in
    // case of an error, as an error creating a texture or view will be
    // propagated to any views or external textures created from them.
    // Since we have full control over the creation of this texture, any
    // validation error we encounter should be treated as an internal error.
    error.CoerceValidationToInternal();
    aParent->ForwardError(error);
  }

  for (size_t i = 0; i < viewFormatAndAspects.Length(); i++) {
    auto [format, aspect] = viewFormatAndAspects[i];
    ffi::WGPUTextureViewDescriptor viewDesc{
        .format = &format,
        .aspect = aspect,
    };
    {
      ErrorBuffer error;
      ffi::wgpu_server_texture_create_view(aParent->GetContext(), aDeviceId,
                                           usedTextureIds[0], aDesc.mViewIds[i],
                                           &viewDesc, error.ToFFI());
      error.CoerceValidationToInternal();
      aParent->ForwardError(error);
    }
    usedViewIds.AppendElement(aDesc.mViewIds[i]);
  }
  ExternalTextureSourceHost source(
      usedTextureIds, usedViewIds, aDesc.mSize, aTextureHost->mFormat,
      colorSpace, aDesc.mSampleTransform, aDesc.mLoadTransform);
  source.mFenceId = aTextureHost->mFencesHolderId;
  return source;
#else
  MOZ_CRASH();
#endif
}

/* static */ ExternalTextureSourceHost
ExternalTextureSourceHost::CreateFromDXGIYCbCrTextureHost(
    WebGPUParent* aParent, RawId aDeviceId, RawId aQueueId,
    const ExternalTextureSourceDescriptor& aDesc,
    const layers::DXGIYCbCrTextureHostD3D11* aTextureHost) {
#ifdef XP_WIN
  const gfx::YUVRangedColorSpace colorSpace = gfx::ToYUVRangedColorSpace(
      aTextureHost->mYUVColorSpace, aTextureHost->mColorRange);

  ffi::WGPUTextureFormat planeFormat;
  switch (aTextureHost->mColorDepth) {
    case gfx::ColorDepth::COLOR_8:
      planeFormat = {ffi::WGPUTextureFormat_R8Unorm};
      break;
    case gfx::ColorDepth::COLOR_10:
    case gfx::ColorDepth::COLOR_12:
    case gfx::ColorDepth::COLOR_16:
      gfxCriticalNoteOnce << "Unsupported color depth: "
                          << aTextureHost->mColorDepth;
      aParent->ReportError(
          aDeviceId, dom::GPUErrorFilter::Internal,
          nsPrintfCString(
              "Unsupported color depth: %s",
              mozilla::ToString(aTextureHost->mColorDepth).c_str()));
      return CreateError();
  }

  for (int i = 0; i < 3; i++) {
    {
      const auto size = i == 0 ? aTextureHost->mSizeY : aTextureHost->mSizeCbCr;
      const ffi::WGPUTextureDescriptor textureDesc{
          .size =
              ffi::WGPUExtent3d{
                  .width = static_cast<uint32_t>(size.width),
                  .height = static_cast<uint32_t>(size.height),
                  .depth_or_array_layers = 1,
              },
          .mip_level_count = 1,
          .sample_count = 1,
          .dimension = ffi::WGPUTextureDimension_D2,
          .format = planeFormat,
          .usage = WGPUTextureUsages_TEXTURE_BINDING,
          .view_formats = {},
      };
      ErrorBuffer error;
      ffi::wgpu_server_device_import_texture_from_shared_handle(
          aParent->GetContext(), aDeviceId, aDesc.mTextureIds[i], &textureDesc,
          aTextureHost->mHandles[i]->GetHandle(), error.ToFFI());
      // From here on there's no need to return early with `CreateError()` in
      // case of an error, as an error creating a texture or view will be
      // propagated to any views or external textures created from them.
      // Since we have full control over the creation of this texture, any
      // validation error we encounter should be treated as an internal error.
      error.CoerceValidationToInternal();
      aParent->ForwardError(error);
    }
    {
      ffi::WGPUTextureViewDescriptor viewDesc{};
      ErrorBuffer error;
      ffi::wgpu_server_texture_create_view(
          aParent->GetContext(), aDeviceId, aDesc.mTextureIds[i],
          aDesc.mViewIds[i], &viewDesc, error.ToFFI());
      error.CoerceValidationToInternal();
      aParent->ForwardError(error);
    }
  }

  ExternalTextureSourceHost source(
      aDesc.mTextureIds, aDesc.mViewIds, aDesc.mSize, aTextureHost->GetFormat(),
      colorSpace, aDesc.mSampleTransform, aDesc.mLoadTransform);
  source.mFenceId = Some(aTextureHost->mFencesHolderId);
  return source;
#else
  MOZ_CRASH();
#endif
}

/* static */ ExternalTextureSourceHost
ExternalTextureSourceHost::CreateFromMacIOSurfaceTextureHost(
    WebGPUParent* aParent, RawId aDeviceId,
    const ExternalTextureSourceDescriptor& aDesc,
    const layers::MacIOSurfaceTextureHostOGL* aTextureHost) {
#ifdef XP_MACOSX
  const RefPtr<MacIOSurface> ioSurface = aTextureHost->mSurface;
  if (!ioSurface) {
    gfxCriticalErrorOnce() << "Failed to lookup MacIOSurface";
    aParent->ReportError(aDeviceId, dom::GPUErrorFilter::Internal,
                         "Failed to lookup MacIOSurface"_ns);

    return CreateError();
  }

  // mGpuFence should be null. It is only required to synchronize GPU reads
  // from an IOSurface following GPU writes, e.g. when an IOSurface is used for
  // WebGPU presentation. In our case the IOSurface has been written to from
  // the CPU or obtained from a CVPixelBuffer, and no additional synchronization
  // is required.
  MOZ_ASSERT(!aTextureHost->mGpuFence);

  const gfx::SurfaceFormat format = ioSurface->GetFormat();
  const gfx::YUVRangedColorSpace colorSpace = gfx::ToYUVRangedColorSpace(
      ioSurface->GetYUVColorSpace(), ioSurface->GetColorRange());

  auto planeSize = [ioSurface](auto plane) {
    return ffi::WGPUExtent3d{
        .width = static_cast<uint32_t>(ioSurface->GetDevicePixelWidth(plane)),
        .height = static_cast<uint32_t>(ioSurface->GetDevicePixelHeight(plane)),
        .depth_or_array_layers = 1,
    };
  };
  auto yuvPlaneFormat =
      [ioSurface](auto numComponents) -> ffi::WGPUTextureFormat {
    switch (numComponents) {
      case 1:
        switch (ioSurface->GetColorDepth()) {
          case gfx::ColorDepth::COLOR_8:
            return {ffi::WGPUTextureFormat_R8Unorm};
          case gfx::ColorDepth::COLOR_10:
          case gfx::ColorDepth::COLOR_12:
          case gfx::ColorDepth::COLOR_16:
            return {ffi::WGPUTextureFormat_R16Unorm};
        }
      case 2:
        switch (ioSurface->GetColorDepth()) {
          case gfx::ColorDepth::COLOR_8:
            return {ffi::WGPUTextureFormat_Rg8Unorm};
          case gfx::ColorDepth::COLOR_10:
          case gfx::ColorDepth::COLOR_12:
          case gfx::ColorDepth::COLOR_16:
            return {ffi::WGPUTextureFormat_Rg16Unorm};
        }
      default:
        MOZ_CRASH("Invalid numComponents");
    }
  };

  AutoTArray<ffi::WGPUTextureDescriptor, 2> textureDescs;
  switch (format) {
    case gfx::SurfaceFormat::R8G8B8A8:
    case gfx::SurfaceFormat::R8G8B8X8:
      textureDescs.AppendElement(ffi::WGPUTextureDescriptor{
          .size = planeSize(0),
          .mip_level_count = 1,
          .sample_count = 1,
          .dimension = ffi::WGPUTextureDimension_D2,
          .format = {ffi::WGPUTextureFormat_Rgba8Unorm},
          .usage = WGPUTextureUsages_TEXTURE_BINDING,
          .view_formats = {},
      });
      break;
    case gfx::SurfaceFormat::B8G8R8A8:
    case gfx::SurfaceFormat::B8G8R8X8:
      textureDescs.AppendElement(ffi::WGPUTextureDescriptor{
          .size = planeSize(0),
          .mip_level_count = 1,
          .sample_count = 1,
          .dimension = ffi::WGPUTextureDimension_D2,
          .format = {ffi::WGPUTextureFormat_Bgra8Unorm},
          .usage = WGPUTextureUsages_TEXTURE_BINDING,
          .view_formats = {},
      });
      break;
    case gfx::SurfaceFormat::NV12:
    case gfx::SurfaceFormat::P010: {
      textureDescs.AppendElement(ffi::WGPUTextureDescriptor{
          .size = planeSize(0),
          .mip_level_count = 1,
          .sample_count = 1,
          .dimension = ffi::WGPUTextureDimension_D2,
          .format = yuvPlaneFormat(1),
          .usage = WGPUTextureUsages_TEXTURE_BINDING,
          .view_formats = {},
      });
      textureDescs.AppendElement(ffi::WGPUTextureDescriptor{
          .size = planeSize(1),
          .mip_level_count = 1,
          .sample_count = 1,
          .dimension = ffi::WGPUTextureDimension_D2,
          .format = yuvPlaneFormat(2),
          .usage = WGPUTextureUsages_TEXTURE_BINDING,
          .view_formats = {},
      });
    } break;
    default:
      gfxCriticalErrorOnce() << "Unsupported IOSurface format: " << format;
      aParent->ReportError(aDeviceId, dom::GPUErrorFilter::Internal,
                           nsPrintfCString("Unsupported IOSurface format: %s",
                                           mozilla::ToString(format).c_str()));
      return CreateError();
  }

  AutoTArray<RawId, 2> usedTextureIds;
  AutoTArray<RawId, 2> usedViewIds;
  for (size_t i = 0; i < textureDescs.Length(); i++) {
    usedTextureIds.AppendElement(aDesc.mTextureIds[i]);
    usedViewIds.AppendElement(aDesc.mViewIds[i]);
    {
      ErrorBuffer error;
      ffi::wgpu_server_device_import_texture_from_iosurface(
          aParent->GetContext(), aDeviceId, aDesc.mTextureIds[i],
          &textureDescs[i], ioSurface->GetIOSurfaceID(), i, error.ToFFI());
      // From here on there's no need to return early with `CreateError()` in
      // case of an error, as an error creating a texture or view will be
      // propagated to any views or external textures created from them.
      // Since we have full control over the creation of this texture, any
      // validation error we encounter should be treated as an internal error.
      error.CoerceValidationToInternal();
      aParent->ForwardError(error);
    }
    ffi::WGPUTextureViewDescriptor viewDesc{};
    {
      ErrorBuffer error;
      ffi::wgpu_server_texture_create_view(
          aParent->GetContext(), aDeviceId, aDesc.mTextureIds[i],
          aDesc.mViewIds[i], &viewDesc, error.ToFFI());
      error.CoerceValidationToInternal();
      aParent->ForwardError(error);
    }
  }
  return ExternalTextureSourceHost(usedTextureIds, usedViewIds, aDesc.mSize,
                                   format, colorSpace, aDesc.mSampleTransform,
                                   aDesc.mLoadTransform);
#else
  MOZ_CRASH();
#endif
}

static color::ColorspaceTransform GetColorSpaceTransform(
    gfx::YUVRangedColorSpace aSrcColorSpace,
    ffi::WGPUPredefinedColorSpace aDestColorSpace) {
  const bool rec709GammaAsSrgb =
      StaticPrefs::gfx_color_management_rec709_gamma_as_srgb();
  const bool rec2020GammaAsRec709 =
      StaticPrefs::gfx_color_management_rec2020_gamma_as_rec709();

  color::ColorspaceDesc srcColorSpace;
  switch (aSrcColorSpace) {
    case gfx::YUVRangedColorSpace::BT601_Narrow:
      srcColorSpace = {
          .chrom = color::Chromaticities::Rec601_525_Ntsc(),
          .tf = rec709GammaAsSrgb ? color::PiecewiseGammaDesc::Srgb()
                                  : color::PiecewiseGammaDesc::Rec709(),
          .yuv =
              color::YuvDesc{
                  .yCoeffs = color::YuvLumaCoeffs::Rec601(),
                  .ycbcr = color::YcbcrDesc::Narrow8(),
              },
      };
      break;
    case gfx::YUVRangedColorSpace::BT601_Full:
      srcColorSpace = {
          .chrom = color::Chromaticities::Rec601_525_Ntsc(),
          .tf = rec709GammaAsSrgb ? color::PiecewiseGammaDesc::Srgb()
                                  : color::PiecewiseGammaDesc::Rec709(),
          .yuv =
              color::YuvDesc{
                  .yCoeffs = color::YuvLumaCoeffs::Rec601(),
                  .ycbcr = color::YcbcrDesc::Full8(),
              },
      };
      break;
    case gfx::YUVRangedColorSpace::BT709_Narrow:
      srcColorSpace = {
          .chrom = color::Chromaticities::Rec709(),
          .tf = rec709GammaAsSrgb ? color::PiecewiseGammaDesc::Srgb()
                                  : color::PiecewiseGammaDesc::Rec709(),
          .yuv =
              color::YuvDesc{
                  .yCoeffs = color::YuvLumaCoeffs::Rec709(),
                  .ycbcr = color::YcbcrDesc::Narrow8(),
              },
      };
      break;
    case gfx::YUVRangedColorSpace::BT709_Full:
      srcColorSpace = {
          .chrom = color::Chromaticities::Rec709(),
          .tf = rec709GammaAsSrgb ? color::PiecewiseGammaDesc::Srgb()
                                  : color::PiecewiseGammaDesc::Rec709(),
          .yuv =
              color::YuvDesc{
                  .yCoeffs = color::YuvLumaCoeffs::Rec709(),
                  .ycbcr = color::YcbcrDesc::Full8(),
              },
      };
      break;
    case gfx::YUVRangedColorSpace::BT2020_Narrow:
      srcColorSpace = {
          .chrom = color::Chromaticities::Rec2020(),
          .tf = rec2020GammaAsRec709 && rec709GammaAsSrgb
                    ? color::PiecewiseGammaDesc::Srgb()
                    : (rec2020GammaAsRec709
                           ? color::PiecewiseGammaDesc::Rec709()
                           : color::PiecewiseGammaDesc::Rec2020_12bit()),
          .yuv =
              color::YuvDesc{
                  .yCoeffs = color::YuvLumaCoeffs::Rec2020(),
                  .ycbcr = color::YcbcrDesc::Narrow8(),
              },
      };
      break;
    case gfx::YUVRangedColorSpace::BT2020_Full:
      srcColorSpace = {
          .chrom = color::Chromaticities::Rec2020(),
          .tf = rec2020GammaAsRec709 && rec709GammaAsSrgb
                    ? color::PiecewiseGammaDesc::Srgb()
                    : (rec2020GammaAsRec709
                           ? color::PiecewiseGammaDesc::Rec709()
                           : color::PiecewiseGammaDesc::Rec2020_12bit()),
          .yuv =
              color::YuvDesc{
                  .yCoeffs = color::YuvLumaCoeffs::Rec2020(),
                  .ycbcr = color::YcbcrDesc::Full8(),
              },
      };
      break;
    case gfx::YUVRangedColorSpace::GbrIdentity:
      srcColorSpace = {
          .chrom = color::Chromaticities::Rec709(),
          .tf = color::PiecewiseGammaDesc::Rec709(),
          .yuv =
              color::YuvDesc{
                  .yCoeffs = color::YuvLumaCoeffs::Gbr(),
                  .ycbcr = color::YcbcrDesc::Full8(),
              },
      };
      break;
  }

  color::ColorspaceDesc destColorSpace{};
  switch (aDestColorSpace) {
    case ffi::WGPUPredefinedColorSpace_Srgb:
      destColorSpace = {.chrom = color::Chromaticities::Srgb(),
                        .tf = color::PiecewiseGammaDesc::Srgb()};
      break;
    case ffi::WGPUPredefinedColorSpace_DisplayP3:
      destColorSpace = {.chrom = color::Chromaticities::DisplayP3(),
                        .tf = color::PiecewiseGammaDesc::DisplayP3()};
      break;
    case ffi::WGPUPredefinedColorSpace_Sentinel:
      MOZ_CRASH("Invalid WGPUPredefinedColorSpace");
  }

  return color::ColorspaceTransform::Create(srcColorSpace, destColorSpace);
}

static ffi::WGPUExternalTextureFormat MapFormat(gfx::SurfaceFormat aFormat) {
  switch (aFormat) {
    case gfx::SurfaceFormat::B8G8R8A8:
    case gfx::SurfaceFormat::B8G8R8X8:
    case gfx::SurfaceFormat::R8G8B8A8:
    case gfx::SurfaceFormat::R8G8B8X8:
      return ffi::WGPUExternalTextureFormat_Rgba;
    case gfx::SurfaceFormat::YUV420:
      return ffi::WGPUExternalTextureFormat_Yu12;
    case gfx::SurfaceFormat::NV12:
    case gfx::SurfaceFormat::P010:
      return ffi::WGPUExternalTextureFormat_Nv12;
    default:
      MOZ_CRASH("Unexpected SurfaceFormat");
  }
}

static ffi::WGPUExternalTextureTransferFunction MapTransferFunction(
    std::optional<color::PiecewiseGammaDesc> aTf) {
  if (aTf) {
    return ffi::WGPUExternalTextureTransferFunction{
        .a = aTf->a,
        .b = aTf->b,
        .g = aTf->g,
        .k = aTf->k,
    };
  } else {
    return ffi::WGPUExternalTextureTransferFunction{
        .a = 1.0,
        .b = 1.0,
        .g = 1.0,
        .k = 1.0,
    };
  }
}

ffi::WGPUExternalTextureDescriptorFromSource
ExternalTextureSourceHost::GetExternalTextureDescriptor(
    ffi::WGPUPredefinedColorSpace aDestColorSpace) const {
  ffi::WGPUExternalTextureDescriptorFromSource desc;

  desc.planes = ffi::WGPUFfiSlice_TextureViewId{
      .data = mViewIds.Elements(),
      .length = mViewIds.Length(),
  };
  desc.width = static_cast<uint32_t>(mSize.width);
  desc.height = static_cast<uint32_t>(mSize.height);
  desc.format = MapFormat(mFormat);

  auto colorSpaceTransform =
      GetColorSpaceTransform(mColorSpace, aDestColorSpace);
  // Makes a generator for a color::mat that yields its components in
  // column-major order
  auto make_column_major_generator = [](auto mat) {
    return [i = 0, mat]() mutable {
      auto val = mat.at(i / mat.y_rows, i % mat.y_rows);
      i++;
      return val;
    };
  };
  std::generate(
      std::begin(desc.yuv_conversion_matrix),
      std::end(desc.yuv_conversion_matrix),
      make_column_major_generator(colorSpaceTransform.srcRgbTfFromSrc));
  std::generate(
      std::begin(desc.gamut_conversion_matrix),
      std::end(desc.gamut_conversion_matrix),
      make_column_major_generator(colorSpaceTransform.dstRgbLinFromSrcRgbLin));
  desc.src_transfer_function = MapTransferFunction(colorSpaceTransform.srcTf);
  desc.dst_transfer_function = MapTransferFunction(colorSpaceTransform.dstTf);
  std::copy(mSampleTransform.begin(), mSampleTransform.end(),
            desc.sample_transform);
  std::copy(mLoadTransform.begin(), mLoadTransform.end(), desc.load_transform);

  return desc;
}

bool ExternalTextureSourceHost::OnBeforeQueueSubmit(WebGPUParent* aParent,
                                                    RawId aDeviceId,
                                                    RawId aQueueId) {
#if defined(XP_WIN)
  // Wait on the write fence provided by the decoder, if any, to ensure we don't
  // read from the texture before writes have completed.
  if (mFenceId) {
    const auto* fencesMap = layers::CompositeProcessD3D11FencesHolderMap::Get();
    if (!fencesMap) {
      gfxCriticalErrorOnce()
          << "CompositeProcessD3D11FencesHolderMap is not initialized";
      aParent->ReportError(
          aDeviceId, dom::GPUErrorFilter::Internal,
          "CompositeProcessD3D11FencesHolderMap is not initialized"_ns);
      return false;
    }
    auto [fenceHandle, fenceValue] =
        fencesMap->GetWriteFenceHandleAndValue(*mFenceId);
    if (fenceHandle) {
      const bool success =
          ffi::wgpu_server_device_wait_fence_from_shared_handle(
              aParent->GetContext(), aDeviceId, aQueueId,
              fenceHandle->GetHandle(), fenceValue);
      if (success) {
        // No need to wait next time
        mFenceId.reset();
      } else {
        gfxCriticalErrorOnce() << "Failed to wait on write fence";
        aParent->ReportError(aDeviceId, dom::GPUErrorFilter::Internal,
                             "Failed to wait on write fence"_ns);
        return false;
      }
    }
  }
  return true;
#else
  return true;
#endif
}

}  // namespace mozilla::webgpu