fix: render error

AgoraIO-Extensions · May 8, 2021 · f409099 · f409099
1 parent 02f034e
commit f409099
Show file tree

Hide file tree

Showing 19 changed files with 410 additions and 397 deletions.
diff --git a/windows/CMakeLists.txt b/windows/CMakeLists.txt
@@ -16,11 +16,11 @@ set_target_properties(${PLUGIN_NAME} PROPERTIES
 target_compile_definitions(${PLUGIN_NAME} PRIVATE FLUTTER_PLUGIN_IMPL)
 target_include_directories(${PLUGIN_NAME} INTERFACE
   "${CMAKE_CURRENT_SOURCE_DIR}/include")
-target_link_libraries(${PLUGIN_NAME} PRIVATE flutter flutter_wrapper_plugin ${CMAKE_CURRENT_SOURCE_DIR}/third_party/iris/iris.lib)
+target_link_libraries(${PLUGIN_NAME} PRIVATE flutter flutter_wrapper_plugin ${CMAKE_CURRENT_SOURCE_DIR}/third_party/iris/iris-rtc.lib)
 
 # List of absolute paths to libraries that should be bundled with the plugin
 set(agora_rtc_engine_bundled_libraries
-  "${CMAKE_CURRENT_SOURCE_DIR}/third_party/iris/iris.dll"
+  "${CMAKE_CURRENT_SOURCE_DIR}/third_party/iris/iris-rtc.dll"
   "${CMAKE_CURRENT_SOURCE_DIR}/third_party/rtc/agora_rtc_sdk.dll"
   "${CMAKE_CURRENT_SOURCE_DIR}/third_party/rtc/av1.dll"
   "${CMAKE_CURRENT_SOURCE_DIR}/third_party/rtc/libagora_ai_denoise_extension.dll"

diff --git a/windows/agora_rtc_engine_plugin.cc b/windows/agora_rtc_engine_plugin.cc
@@ -16,11 +16,11 @@
 #include <sstream>
 
 #include "include/agora_rtc_engine/agora_texture_view_factory.h"
-#include "include/iris/iris_engine.h"
-#include "include/iris/iris_renderer.h"
+#include "include/iris/iris_rtc_engine.h"
+#include "include/iris/iris_rtc_renderer.h"
 
 namespace {
-using namespace agora::iris;
+using namespace agora::iris::rtc;
 
 class AgoraRtcEnginePlugin : public flutter::Plugin {
 public:
@@ -37,7 +37,7 @@ class AgoraRtcEnginePlugin : public flutter::Plugin {
       std::unique_ptr<flutter::MethodResult<flutter::EncodableValue>> result);
 
 private:
-  std::unique_ptr<IrisEngine> engine_;
+  std::unique_ptr<IrisRtcEngine> engine_;
   std::unique_ptr<AgoraTextureViewFactory> factory_;
 };
 
@@ -60,9 +60,9 @@ void AgoraRtcEnginePlugin::RegisterWithRegistrar(
 }
 
 AgoraRtcEnginePlugin::AgoraRtcEnginePlugin(flutter::PluginRegistrar *registrar)
-    : engine_(new IrisEngine),
-      factory_(new AgoraTextureViewFactory(
-          registrar, engine_->iris_raw_data()->iris_renderer())) {}
+    : engine_(new IrisRtcEngine),
+      factory_(new AgoraTextureViewFactory(registrar,
+                                           engine_->raw_data()->renderer())) {}
 
 AgoraRtcEnginePlugin::~AgoraRtcEnginePlugin() {}
 

diff --git a/windows/agora_texture_view_factory.cc b/windows/agora_texture_view_factory.cc
@@ -2,17 +2,17 @@
 
 #include <functional>
 
-#include "include/iris/iris_raw_data.h"
+#include "include/iris/iris_rtc_raw_data.h"
 
 using namespace flutter;
-using namespace agora::iris;
+using namespace agora::iris::rtc;
 
 TextureRenderer::TextureRenderer(AgoraTextureViewFactory *factory)
     : factory_(factory),
       texture_(PixelBufferTexture(std::bind(&TextureRenderer::CopyPixelBuffer,
                                             this, std::placeholders::_1,
                                             std::placeholders::_2))),
-      uid_(0), pixel_buffer_(nullptr) {
+      uid_(0), pixel_buffer_(new FlutterDesktopPixelBuffer{nullptr, 0, 0}) {
   texture_id_ = factory_->registrar()->RegisterTexture(&texture_);
   auto channel = std::make_unique<MethodChannel<EncodableValue>>(
       factory_->messenger(),
@@ -48,7 +48,8 @@ void TextureRenderer::HandleMethodCall(
     auto arguments = std::get<flutter::EncodableMap>(*method_call.arguments());
     auto data = std::get<flutter::EncodableMap>(
         arguments[flutter::EncodableValue("data")]);
-    auto uid = (unsigned int)std::get<int32_t>(data[flutter::EncodableValue("uid")]);
+    auto uid =
+        (unsigned int)std::get<int32_t>(data[flutter::EncodableValue("uid")]);
     auto channel_id =
         std::get_if<std::string>(&data[flutter::EncodableValue("channelId")]);
     if (uid_ != uid) {
@@ -57,12 +58,11 @@ void TextureRenderer::HandleMethodCall(
     uid_ = uid;
     if (channel_id) {
       channel_id_ = channel_id->c_str();
-    }
-    else {
+    } else {
       channel_id_ = "";
     }
-    IrisRendererCacheConfig config(IrisVideoFrameObserver::kFrameTypeRGBA,
-                                   this);
+    IrisRtcRendererCacheConfig config(IrisRtcVideoFrameObserver::kFrameTypeRGBA,
+                                      this);
     factory_->renderer()->EnableVideoFrameCache(config, uid_,
                                                 channel_id_.c_str());
     result->Success();
@@ -73,30 +73,30 @@ void TextureRenderer::HandleMethodCall(
 }
 
 void TextureRenderer::OnVideoFrameReceived(
-    const IrisVideoFrameObserver::VideoFrame &video_frame, bool resize) {
-  if (pixel_buffer_) {
+    const IrisRtcVideoFrameObserver::VideoFrame &video_frame, bool resize) {
+  std::lock_guard<std::mutex> lock_guard(mutex_);
+  if (pixel_buffer_->width != video_frame.width ||
+      pixel_buffer_->height != video_frame.height) {
     if (pixel_buffer_->buffer) {
       delete[] pixel_buffer_->buffer;
     }
-    delete pixel_buffer_;
-    pixel_buffer_ = nullptr;
+    pixel_buffer_->buffer = new uint8_t[video_frame.y_buffer_length];
   }
-  pixel_buffer_ = new FlutterDesktopPixelBuffer;
-  auto buffer = new uint8_t[video_frame.y_buffer_length];
-  memcpy(buffer, video_frame.y_buffer, video_frame.y_buffer_length);
-  pixel_buffer_->buffer = buffer;
+  memcpy((void *)pixel_buffer_->buffer, video_frame.y_buffer,
+         video_frame.y_buffer_length);
   pixel_buffer_->width = video_frame.width;
   pixel_buffer_->height = video_frame.height;
   factory_->registrar()->MarkTextureFrameAvailable(texture_id_);
 }
 
 const FlutterDesktopPixelBuffer *
 TextureRenderer::CopyPixelBuffer(size_t width, size_t height) {
+  std::lock_guard<std::mutex> lock_guard(mutex_);
   return pixel_buffer_;
 }
 
 AgoraTextureViewFactory::AgoraTextureViewFactory(PluginRegistrar *registrar,
-                                                 IrisRenderer *iris_renderer)
+                                                 IrisRtcRenderer *iris_renderer)
     : messenger_(registrar->messenger()),
       registrar_(registrar->texture_registrar()), renderer_(iris_renderer) {}
 
@@ -106,12 +106,12 @@ BinaryMessenger *AgoraTextureViewFactory::messenger() { return messenger_; }
 
 TextureRegistrar *AgoraTextureViewFactory::registrar() { return registrar_; }
 
-IrisRenderer *AgoraTextureViewFactory::renderer() { return renderer_; }
+IrisRtcRenderer *AgoraTextureViewFactory::renderer() { return renderer_; }
 
 int64_t AgoraTextureViewFactory::CreateTextureRenderer() {
   std::unique_ptr<TextureRenderer> texture(new TextureRenderer(this));
-  IrisRendererCacheConfig config(IrisVideoFrameObserver::kFrameTypeRGBA,
-                                 texture.get());
+  IrisRtcRendererCacheConfig config(IrisRtcVideoFrameObserver::kFrameTypeRGBA,
+                                    texture.get());
   renderer_->EnableVideoFrameCache(config, 0);
   int64_t texture_id = texture->texture_id();
   renderers_[texture_id] = std::move(texture);

diff --git a/windows/include/agora_rtc_engine/agora_texture_view_factory.h b/windows/include/agora_rtc_engine/agora_texture_view_factory.h
@@ -6,12 +6,13 @@
 #include <flutter/standard_method_codec.h>
 #include <flutter/texture_registrar.h>
 #include <map>
+#include <mutex>
 
-#include "include/iris/iris_renderer.h"
+#include "include/iris/iris_rtc_renderer.h"
 
 class AgoraTextureViewFactory;
 
-class TextureRenderer : public agora::iris::IrisRendererDelegate {
+class TextureRenderer : public agora::iris::rtc::IrisRtcRendererDelegate {
 public:
   TextureRenderer(AgoraTextureViewFactory *factory);
   ~TextureRenderer();
@@ -20,7 +21,8 @@ class TextureRenderer : public agora::iris::IrisRendererDelegate {
 
   // 通过 IrisRendererDelegate 继承
   virtual void OnVideoFrameReceived(
-      const agora::iris::IrisVideoFrameObserver::VideoFrame &video_frame,
+      const agora::iris::rtc::IrisRtcVideoFrameObserver::VideoFrame
+          &video_frame,
       bool resize) override;
 
 private:
@@ -37,20 +39,21 @@ class TextureRenderer : public agora::iris::IrisRendererDelegate {
   std::unique_ptr<flutter::MethodCall<flutter::EncodableValue>> channel_;
   unsigned int uid_;
   std::string channel_id_;
+  std::mutex mutex_;
   FlutterDesktopPixelBuffer *pixel_buffer_;
 };
 
 class AgoraTextureViewFactory {
 public:
   AgoraTextureViewFactory(flutter::PluginRegistrar *registrar,
-                          agora::iris::IrisRenderer *renderer);
+                          agora::iris::rtc::IrisRtcRenderer *renderer);
   ~AgoraTextureViewFactory();
 
   flutter::BinaryMessenger *messenger();
 
   flutter::TextureRegistrar *registrar();
 
-  agora::iris::IrisRenderer *renderer();
+  agora::iris::rtc::IrisRtcRenderer *renderer();
 
   int64_t CreateTextureRenderer();
 
@@ -59,7 +62,7 @@ class AgoraTextureViewFactory {
 private:
   flutter::BinaryMessenger *messenger_;
   flutter::TextureRegistrar *registrar_;
-  agora::iris::IrisRenderer *renderer_;
+  agora::iris::rtc::IrisRtcRenderer *renderer_;
   std::map<int64_t, std::unique_ptr<TextureRenderer>> renderers_;
 };
 

diff --git a/windows/include/iris/iris_c_api.h b/windows/include/iris/iris_c_api.h
diff --git a/windows/include/iris/iris_channel.h b/windows/include/iris/iris_channel.h
diff --git a/windows/include/iris/iris_device_manager.h b/windows/include/iris/iris_device_manager.h