draft

Author: Predidit

media_kit_video/windows/CMakeLists.txt

@@ -27,6 +27,7 @@ if(MEDIA_KIT_LIBS_AVAILABLE)
   add_library(
     ${PLUGIN_NAME} SHARED
     "d3d11_renderer.cc"
+    "mailbox_swap_chain.cc"
     "media_kit_video_plugin_c_api.cc"
     "media_kit_video_plugin.cc"
     "video_output_manager.cc"
@@ -46,6 +47,8 @@ if(MEDIA_KIT_LIBS_AVAILABLE)
     FLUTTER_PLUGIN_IMPL
   )
 
+  target_compile_options(${PLUGIN_NAME} PRIVATE "/utf-8")
+
   target_include_directories(
     ${PLUGIN_NAME} INTERFACE
     "${CMAKE_CURRENT_SOURCE_DIR}/include"

media_kit_video/windows/d3d11_renderer.cc

@@ -1,7 +1,7 @@
-// This file is a part of media_kit
+// This file is a part of media_kit
 // (https://github.com/media-kit/media-kit).
 //
-// Copyright © 2025 & onwards, Predidit.
+// Copyright © 2026 Predidit.
 // All rights reserved.
 // Use of this source code is governed by MIT license that can be found in the
 // LICENSE file.
@@ -13,115 +13,68 @@
 #pragma comment(lib, "dxgi.lib")
 #pragma comment(lib, "d3d11.lib")
 
-#define FAIL(message)                                           \
-  std::cout << "media_kit: D3D11Renderer: Failure: " << message \
-            << std::endl;                                       \
-  return false
-
-#define CHECK_HRESULT(message) \
-  if (FAILED(hr)) {            \
-    FAIL(message);             \
-  }
-
 int D3D11Renderer::instance_count_ = 0;
 
 D3D11Renderer::D3D11Renderer(int32_t width, int32_t height)
     : width_(width), height_(height) {
-  mutex_ = ::CreateMutex(NULL, FALSE, NULL);
   if (!CreateD3D11Device()) {
     throw std::runtime_error("Unable to create Direct3D 11 device.");
   }
-  if (!CreateTexture()) {
-    throw std::runtime_error("Unable to create Direct3D 11 texture.");
+  if (!CreateMailbox()) {
+    throw std::runtime_error("Unable to create mailbox swap chain.");
   }
   instance_count_++;
 }
 
 D3D11Renderer::~D3D11Renderer() {
-  CleanUp(true);
-  ::ReleaseMutex(mutex_);
-  ::CloseHandle(mutex_);
+  mailbox_swap_chain_.Reset();
+
+  if (d3d_11_device_context_) {
+    d3d_11_device_context_->Release();
+    d3d_11_device_context_ = nullptr;
+  }
+  if (d3d_11_device_) {
+    d3d_11_device_->Release();
+    d3d_11_device_ = nullptr;
+  }
   instance_count_--;
 }
 
 void D3D11Renderer::SetSize(int32_t width, int32_t height) {
-  if (width == width_ && height == height_) {
-    return;
-  }
+  if (width == width_ && height == height_) return;
   width_ = width;
   height_ = height;
-  
-  // Release the old texture reference
-  if (shared_texture_) {
-    shared_texture_->Release();
-    shared_texture_ = nullptr;
-  }
-  
-  // Resize the swap chain (this will resize the back buffer)
-  if (swap_chain_) {
-    auto hr = swap_chain_->ResizeBuffers(1, width_, height_,
-                                        DXGI_FORMAT_B8G8R8A8_UNORM, 0);
+  if (mailbox_swap_chain_) {
+    const HRESULT hr = mailbox_swap_chain_->Resize(width_, height_);
     if (FAILED(hr)) {
-      std::cout << "media_kit: D3D11Renderer: Failed to resize swap chain"
-                << std::endl;
-      return;
+      std::cout << "media_kit: D3D11Renderer: Mailbox resize failed (hr=0x"
+                << std::hex << hr << std::dec << ")" << std::endl;
     }
   }
-  
-  // Recreate the shared texture with the new size
-  CreateTexture();
 }
 
-void D3D11Renderer::CopyTexture() {
-  ::WaitForSingleObject(mutex_, INFINITE);
-  
-  // With native DXGI rendering, mpv renders directly to the swap chain's back buffer.
-  // We need to copy the back buffer to our shared texture for Flutter.
-  if (d3d_11_device_context_ != nullptr && swap_chain_ != nullptr && shared_texture_) {
-    // Get the back buffer from the swap chain
-    Microsoft::WRL::ComPtr<ID3D11Texture2D> back_buffer;
-    auto hr = swap_chain_->GetBuffer(0, __uuidof(ID3D11Texture2D),
-                                     (void**)&back_buffer);
-    if (SUCCEEDED(hr) && back_buffer) {
-      // Copy from back buffer to shared texture
-      d3d_11_device_context_->CopyResource(shared_texture_.Get(), back_buffer.Get());
-      d3d_11_device_context_->Flush();
-    }
+void D3D11Renderer::ProducerCommit() {
+  if (mailbox_swap_chain_) {
+    mailbox_swap_chain_->ProducerCommit();
   }
-  
-  ::ReleaseMutex(mutex_);
 }
 
-void D3D11Renderer::CleanUp(bool release_device) {
-  // Release texture
-  if (shared_texture_) {
-    shared_texture_->Release();
-    shared_texture_ = nullptr;
-  }
-
-  // Release swap chain
-  if (swap_chain_) {
-    swap_chain_->Release();
-    swap_chain_ = nullptr;
+HANDLE D3D11Renderer::ConsumerAcquire() {
+  if (mailbox_swap_chain_) {
+    return mailbox_swap_chain_->ConsumerAcquire();
   }
+  return nullptr;
+}
 
-  // Release device and context if the instance is being destroyed
-  if (release_device) {
-    if (d3d_11_device_context_) {
-      d3d_11_device_context_->Release();
-      d3d_11_device_context_ = nullptr;
-    }
-    if (d3d_11_device_) {
-      d3d_11_device_->Release();
-      d3d_11_device_ = nullptr;
-    }
+HANDLE D3D11Renderer::ReadHandleSnapshot() const {
+  if (mailbox_swap_chain_) {
+    return mailbox_swap_chain_->ReadHandleSnapshot();
   }
+  return nullptr;
 }
 
 bool D3D11Renderer::CreateD3D11Device() {
-  if (d3d_11_device_ != nullptr) {
-    return true;  // Already created
-  }
+  if (d3d_11_device_) return true;
 
   const D3D_FEATURE_LEVEL feature_levels[] = {
       D3D_FEATURE_LEVEL_11_1,
@@ -134,9 +87,7 @@ bool D3D11Renderer::CreateD3D11Device() {
   IDXGIAdapter* adapter = nullptr;
   D3D_DRIVER_TYPE driver_type = D3D_DRIVER_TYPE_UNKNOWN;
 
-  // Automatically selecting adapter on Windows 10 RTM or greater
   if (Utils::IsWindows10RTMOrGreater()) {
-    adapter = nullptr;
     driver_type = D3D_DRIVER_TYPE_HARDWARE;
   } else {
     IDXGIFactory* dxgi = nullptr;
@@ -147,74 +98,45 @@ bool D3D11Renderer::CreateD3D11Device() {
     }
   }
 
-  // Create swap chain descriptor for offscreen rendering
-  DXGI_SWAP_CHAIN_DESC swap_chain_desc = {};
-  swap_chain_desc.BufferDesc.Width = width_;
-  swap_chain_desc.BufferDesc.Height = height_;
-  swap_chain_desc.BufferDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
-  swap_chain_desc.BufferDesc.RefreshRate.Numerator = 0;
-  swap_chain_desc.BufferDesc.RefreshRate.Denominator = 1;
-  swap_chain_desc.SampleDesc.Count = 1;
-  swap_chain_desc.SampleDesc.Quality = 0;
-  swap_chain_desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
-  swap_chain_desc.BufferCount = 1;
-  // Use desktop window for offscreen rendering
-  swap_chain_desc.OutputWindow = ::GetDesktopWindow();
-  swap_chain_desc.Windowed = TRUE;
-  swap_chain_desc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
-
-  auto hr = ::D3D11CreateDeviceAndSwapChain(
-      adapter, driver_type, 0, 0, feature_levels,
-      sizeof(feature_levels) / sizeof(D3D_FEATURE_LEVEL), D3D11_SDK_VERSION,
-      &swap_chain_desc, &swap_chain_,
-      &d3d_11_device_, nullptr, &d3d_11_device_context_);
-
-  CHECK_HRESULT("D3D11CreateDeviceAndSwapChain");
-
-  Microsoft::WRL::ComPtr<IDXGIDevice> dxgi_device = nullptr;
-  auto dxgi_device_success = d3d_11_device_->QueryInterface(
-      __uuidof(IDXGIDevice), (void**)&dxgi_device);
-  if (SUCCEEDED(dxgi_device_success) && dxgi_device != nullptr) {
-    dxgi_device->SetGPUThreadPriority(5);  // Must be in interval [-7, 7]
+  const HRESULT hr = ::D3D11CreateDevice(
+      adapter, driver_type, nullptr,
+      D3D11_CREATE_DEVICE_BGRA_SUPPORT,
+      feature_levels, static_cast<UINT>(std::size(feature_levels)),
+      D3D11_SDK_VERSION, &d3d_11_device_, nullptr, &d3d_11_device_context_);
+
+  if (adapter) adapter->Release();
+
+  if (FAILED(hr)) {
+    std::cout << "media_kit: D3D11Renderer: D3D11CreateDevice failed (hr=0x"
+              << std::hex << hr << std::dec << ")" << std::endl;
+    return false;
   }
 
-  auto level = d3d_11_device_->GetFeatureLevel();
+  Microsoft::WRL::ComPtr<IDXGIDevice> dxgi_device;
+  if (SUCCEEDED(d3d_11_device_->QueryInterface(__uuidof(IDXGIDevice),
+                                               (void**)&dxgi_device)) &&
+      dxgi_device) {
+    dxgi_device->SetGPUThreadPriority(5);
+  }
+
+  const auto level = d3d_11_device_->GetFeatureLevel();
   std::cout << "media_kit: D3D11Renderer: Direct3D Feature Level: "
-            << (((unsigned)level) >> 12) << "_"
-            << ((((unsigned)level) >> 8) & 0xf) << std::endl;
+            << (static_cast<unsigned>(level) >> 12) << "_"
+            << ((static_cast<unsigned>(level) >> 8) & 0xfu) << std::endl;
 
   return true;
 }
 
-bool D3D11Renderer::CreateTexture() {
-  // Create a separate shared texture for Flutter
-  // (The swap chain back buffer cannot be shared directly with Flutter)
-  D3D11_TEXTURE2D_DESC texture_desc = {0};
-  texture_desc.Width = width_;
-  texture_desc.Height = height_;
-  texture_desc.MipLevels = 1;
-  texture_desc.ArraySize = 1;
-  texture_desc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
-  texture_desc.SampleDesc.Count = 1;
-  texture_desc.SampleDesc.Quality = 0;
-  texture_desc.Usage = D3D11_USAGE_DEFAULT;
-  texture_desc.BindFlags = D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE;
-  texture_desc.CPUAccessFlags = 0;
-  texture_desc.MiscFlags = D3D11_RESOURCE_MISC_SHARED;
-
-  auto hr = d3d_11_device_->CreateTexture2D(&texture_desc, nullptr,
-                                            &shared_texture_);
-  CHECK_HRESULT("ID3D11Device::CreateTexture2D");
-
-  Microsoft::WRL::ComPtr<IDXGIResource> resource;
-  hr = shared_texture_.As(&resource);
-  CHECK_HRESULT("ID3D11Texture2D::As<IDXGIResource>");
-
-  // Retrieve the shared HANDLE for interop with Flutter
-  hr = resource->GetSharedHandle(&handle_);
-  CHECK_HRESULT("IDXGIResource::GetSharedHandle");
-
-  shared_texture_->AddRef();
-
+bool D3D11Renderer::CreateMailbox() {
+  MailboxSwapChain* raw = nullptr;
+  const HRESULT hr =
+      MailboxSwapChain::Create(d3d_11_device_, width_, height_, &raw);
+  if (FAILED(hr)) {
+    std::cout << "media_kit: D3D11Renderer: MailboxSwapChain::Create failed "
+                 "(hr=0x"
+              << std::hex << hr << std::dec << ")" << std::endl;
+    return false;
+  }
+  mailbox_swap_chain_.Attach(raw);
   return true;
-}
+}

media_kit_video/windows/d3d11_renderer.h

@@ -1,7 +1,7 @@
 // This file is a part of media_kit
 // (https://github.com/media-kit/media-kit).
 //
-// Copyright © 2025 & onwards, Predidit.
+// Copyright © Predidit.
 // All rights reserved.
 // Use of this source code is governed by MIT license that can be found in the
 // LICENSE file.
@@ -15,55 +15,66 @@
 #include <wrl.h>
 
 #include <cstdint>
-#include <functional>
 #include <iostream>
 
+#include "mailbox_swap_chain.h"
 #include "utils.h"
 
-// |D3D11Renderer| provides an abstraction around Direct3D 11 for video
-// rendering with libmpv's native DXGI support.
-// This replaces the previous ANGLE-based implementation with a simpler,
-// more efficient approach using mpv's built-in D3D11 renderer.
-
+// D3D11Renderer creates a D3D11 device and owns a MailboxSwapChain that
+// implements the lock-free triple-buffer mailbox between the libmpv rendering
+// thread (producer) and Flutter's render thread (consumer).
+//
+// The MailboxSwapChain is passed directly to mpv as the IDXGISwapChain* in
+// mpv_dxgi_init_params.  mpv calls GetBuffer(0, ...) to obtain a render
+// target, renders into it, and flushes.  The plugin then calls
+// ProducerCommit() to atomically publish the frame.  Flutter's
+// GpuSurfaceTexture callback calls ConsumerAcquire() to receive the DXGI
+// shared HANDLE of the newest complete frame — with no copy and no OS lock.
 class D3D11Renderer {
  public:
-  const int32_t width() const { return width_; }
-  const int32_t height() const { return height_; }
-  const HANDLE handle() const { return handle_; }
+  int32_t width() const { return width_; }
+  int32_t height() const { return height_; }
+
+  // Raw device pointer used by VideoOutput to populate mpv_dxgi_init_params.
   ID3D11Device* device() const { return d3d_11_device_; }
-  IDXGISwapChain* swap_chain() const { return swap_chain_; }
 
-  D3D11Renderer(int32_t width, int32_t height);
+  // IDXGISwapChain* facade backed by MailboxSwapChain.
+  // Passed to mpv as mpv_dxgi_init_params::swapchain (void*).
+  IDXGISwapChain* swap_chain() const { return mailbox_swap_chain_.Get(); }
 
+  D3D11Renderer(int32_t width, int32_t height);
   ~D3D11Renderer();
 
+  // Recreates the three mailbox slots at the new dimensions.
+  // Must be called from the producer thread only.
   void SetSize(int32_t width, int32_t height);
 
-  void CopyTexture();
+  // Called from the producer thread (mpv thread pool) after
+  // mpv_render_context_render returns.  Publishes the rendered frame.
+  void ProducerCommit();
 
- private:
-  bool CreateD3D11Device();
+  // Called from the consumer thread (Flutter GpuSurfaceTexture callback).
+  // Returns the DXGI shared HANDLE of the most recent complete frame.
+  HANDLE ConsumerAcquire();
 
-  bool CreateTexture();
+  // Returns the DXGI shared HANDLE for the current read slot without
+  // advancing mailbox state.  Used once during texture registration before
+  // the consumer thread starts.
+  HANDLE ReadHandleSnapshot() const;
 
-  void CleanUp(bool release_device);
+ private:
+  bool CreateD3D11Device();
+  bool CreateMailbox();
 
   int32_t width_ = 1;
   int32_t height_ = 1;
-  HANDLE handle_ = nullptr;
-
-  // Sync operations.
-  HANDLE mutex_ = nullptr;
 
-  // D3D 11
   ID3D11Device* d3d_11_device_ = nullptr;
   ID3D11DeviceContext* d3d_11_device_context_ = nullptr;
-  IDXGISwapChain* swap_chain_ = nullptr;
 
-  // Shared texture for Flutter rendering (created from swap chain back buffer)
-  Microsoft::WRL::ComPtr<ID3D11Texture2D> shared_texture_;
+  Microsoft::WRL::ComPtr<MailboxSwapChain> mailbox_swap_chain_;
 
   static int instance_count_;
 };
 
-#endif
+#endif  // D3D11_RENDERER_H_