[windows] Separate VideoOutlet class & clean texture usage

Author: alexmercerind

windows/CMakeLists.txt

@@ -39,7 +39,8 @@ endif()
 
 # dart_vlc.dll
 add_library("${PLUGIN_NAME}" SHARED
-  "dart_vlc.cc"
+  "dart_vlc_plugin.cpp"
+  "video_outlet.cpp"
 )
 
 apply_standard_settings("${PLUGIN_NAME}")

windows/dart_vlc.cc

@@ -0,0 +1,104 @@
+/*
+ * dart_vlc: A media playback library for Dart & Flutter. Based on libVLC &
+ * libVLC++.
+ *
+ * Hitesh Kumar Saini
+ * https://github.com/alexmercerind
+ * saini123hitesh@gmail.com; alexmercerind@gmail.com
+ *
+ * GNU Lesser General Public License v2.1
+ */
+
+#include <unordered_map>
+#include "include/dart_vlc/dart_vlc_plugin.h"
+#include "native/dart_vlc.cpp"
+#include "video_outlet.hpp"
+
+namespace {
+
+class DartVlcPlugin : public flutter::Plugin {
+ public:
+  static void RegisterWithRegistrar(flutter::PluginRegistrarWindows* registrar);
+
+  flutter::MethodChannel<flutter::EncodableValue>* channel() const {
+    return channel_.get();
+  }
+
+  DartVlcPlugin(
+      std::unique_ptr<flutter::MethodChannel<flutter::EncodableValue>> channel,
+      flutter::TextureRegistrar* texture_registrar);
+
+  virtual ~DartVlcPlugin();
+
+ private:
+  void HandleMethodCall(
+      const flutter::MethodCall<flutter::EncodableValue>& method_call,
+      std::unique_ptr<flutter::MethodResult<flutter::EncodableValue>> result);
+
+  flutter::TextureRegistrar* texture_registrar_;
+  std::unique_ptr<flutter::MethodChannel<flutter::EncodableValue>> channel_;
+  std::unordered_map<int, std::unique_ptr<VideoOutlet>> outlets_;
+};
+
+void DartVlcPlugin::RegisterWithRegistrar(
+    flutter::PluginRegistrarWindows* registrar) {
+  auto plugin = std::make_unique<DartVlcPlugin>(
+      std::make_unique<flutter::MethodChannel<flutter::EncodableValue>>(
+          registrar->messenger(), "dart_vlc",
+          &flutter::StandardMethodCodec::GetInstance()),
+      registrar->texture_registrar());
+  plugin->channel()->SetMethodCallHandler([plugin_pointer = plugin.get()](
+      const auto& call, auto result) {
+    plugin_pointer->HandleMethodCall(call, std::move(result));
+  });
+  registrar->AddPlugin(std::move(plugin));
+}
+
+DartVlcPlugin::DartVlcPlugin(
+    std::unique_ptr<flutter::MethodChannel<flutter::EncodableValue>> channel,
+    flutter::TextureRegistrar* texture_registrar)
+    : channel_(std::move(channel)), texture_registrar_(texture_registrar) {}
+
+DartVlcPlugin::~DartVlcPlugin() {}
+
+void DartVlcPlugin::HandleMethodCall(
+    const flutter::MethodCall<flutter::EncodableValue>& method_call,
+    std::unique_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
+  if (method_call.method_name() == "PlayerRegisterTexture") {
+    flutter::EncodableMap arguments =
+        std::get<flutter::EncodableMap>(*method_call.arguments());
+    int32_t player_id =
+        std::get<int>(arguments[flutter::EncodableValue("playerId")]);
+    if (outlets_.find(player_id) == outlets_.end()) {
+      outlets_[player_id] = std::make_unique<VideoOutlet>(texture_registrar_);
+      Player* player = g_players->Get(player_id);
+      player->OnVideo(
+          [=](uint8_t* frame, int32_t width, int32_t height) -> void {
+            outlets_[player_id]->OnVideo(frame, width, height);
+          });
+      return result->Success(
+          flutter::EncodableValue(outlets_[player_id]->texture_id()));
+    }
+    result->Error("-1", "Texture was already registered.");
+  } else if (method_call.method_name() == "PlayerUnregisterTexture") {
+    flutter::EncodableMap arguments =
+        std::get<flutter::EncodableMap>(*method_call.arguments());
+    int player_id =
+        std::get<int>(arguments[flutter::EncodableValue("playerId")]);
+    if (outlets_.find(player_id) == outlets_.end()) {
+      return result->Error("-2", "Texture was not found.");
+    }
+    outlets_.erase(player_id);
+    result->Success(flutter::EncodableValue(nullptr));
+  } else {
+    result->NotImplemented();
+  }
+}
+}  // namespace
+
+void DartVlcPluginRegisterWithRegistrar(
+    FlutterDesktopPluginRegistrarRef registrar) {
+  DartVlcPlugin::RegisterWithRegistrar(
+      flutter::PluginRegistrarManager::GetInstance()
+          ->GetRegistrar<flutter::PluginRegistrarWindows>(registrar));
+}

windows/dart_vlc_plugin.cpp

@@ -0,0 +1,24 @@
+#include "video_outlet.hpp"
+
+VideoOutlet::VideoOutlet(flutter::TextureRegistrar* texture_registrar)
+    : texture_registrar_(texture_registrar) {
+  texture_ =
+      std::make_unique<flutter::TextureVariant>(flutter::PixelBufferTexture(
+          [=](size_t width, size_t height) -> const FlutterDesktopPixelBuffer* {
+            const std::lock_guard<std::mutex> lock(mutex_);
+            return &flutter_pixel_buffer_;
+          }));
+  texture_id_ = texture_registrar_->RegisterTexture(texture_.get());
+}
+
+void VideoOutlet::OnVideo(uint8_t* buffer, int32_t width, int32_t height) {
+  const std::lock_guard<std::mutex> lock(mutex_);
+  flutter_pixel_buffer_.buffer = buffer;
+  flutter_pixel_buffer_.width = width;
+  flutter_pixel_buffer_.height = height;
+  texture_registrar_->MarkTextureFrameAvailable(texture_id_);
+}
+
+VideoOutlet::~VideoOutlet() {
+  texture_registrar_->UnregisterTexture(texture_id_);
+}

windows/video_outlet.cpp

@@ -0,0 +1,22 @@
+#include <mutex>
+#include <flutter/method_channel.h>
+#include <flutter/plugin_registrar_windows.h>
+#include <flutter/standard_method_codec.h>
+
+class VideoOutlet {
+ public:
+  VideoOutlet(flutter::TextureRegistrar* texture_registrar);
+
+  int32_t texture_id() const { return texture_id_; }
+
+  void OnVideo(uint8_t* buffer, int32_t width, int32_t height);
+
+  ~VideoOutlet();
+
+ private:
+  FlutterDesktopPixelBuffer flutter_pixel_buffer_;
+  flutter::TextureRegistrar* texture_registrar_ = nullptr;
+  std::unique_ptr<flutter::TextureVariant> texture_ = nullptr;
+  int32_t texture_id_;
+  mutable std::mutex mutex_;
+};