[camera] Apply new external texture APIs (#119)

Signed-off-by: Boram Bae <[email protected]>

Author: bbrto21

packages/camera/CHANGELOG.md

@@ -1,3 +1,7 @@
 ## 0.1.0
 
-* Initial release.
+* Initial release.
+
+## 0.2.0
+
+* Apply new external texture APIs

packages/camera/README.md

@@ -26,7 +26,7 @@ This package is not an _endorsed_ implementation of `camera`. Therefore, you hav
 ```yaml
 dependencies:
   camera: ^0.8.1
-  camera_tizen: ^0.1.0
+  camera_tizen: ^0.2.0
 ```
 
 Then you can import `camera` in your Dart code:

packages/camera/pubspec.yaml

@@ -1,7 +1,7 @@
 name: camera_tizen
 description: Tizen implementation of the camera plugin
 homepage: https://github.com/flutter-tizen/plugins
-version: 0.1.0
+version: 0.2.0
 
 dependencies:
   flutter:

packages/camera/tizen/src/camera_device.cc

@@ -253,12 +253,10 @@ CameraDevice::CameraDevice() {
 }
 
 CameraDevice::CameraDevice(flutter::PluginRegistrar *registrar,
-                           FlutterTextureRegistrar *texture_registrar,
                            CameraDeviceType type,
                            ResolutionPreset resolution_preset,
                            bool enable_audio)
     : registrar_(registrar),
-      texture_registrar_(texture_registrar),
       type_(type),
       resolution_preset_(resolution_preset),
       enable_audio_(enable_audio) {
@@ -326,7 +324,39 @@ CameraDevice::CameraDevice(flutter::PluginRegistrar *registrar,
   SetResolutionPreset(resolution_preset_);
 
   // Init channels
-  texture_id_ = FlutterRegisterExternalTexture(texture_registrar_);
+  texture_variant_ =
+      std::make_unique<flutter::TextureVariant>(flutter::GpuBufferTexture(
+          [this](size_t width,
+                 size_t height) -> const FlutterDesktopGpuBuffer * {
+            std::lock_guard<std::mutex> lock(mutex_);
+            if (packet_ == nullptr) {
+              return nullptr;
+            }
+            tbm_surface_h surface;
+            int ret = media_packet_get_tbm_surface(packet_, &surface);
+            if (ret != MEDIA_PACKET_ERROR_NONE) {
+              LOG_ERROR("media_packet_get_tbm_surface failed, error: %d", ret);
+              media_packet_destroy(packet_);
+              packet_ = nullptr;
+              return nullptr;
+            }
+
+            flutter_desktop_gpu_buffer_->buffer = surface;
+            flutter_desktop_gpu_buffer_->width = width;
+            flutter_desktop_gpu_buffer_->height = height;
+            return flutter_desktop_gpu_buffer_.get();
+          },
+          [this](void *buffer) -> void {
+            std::lock_guard<std::mutex> lock(mutex_);
+            if (packet_) {
+              media_packet_destroy(packet_);
+              packet_ = nullptr;
+            }
+          }));
+  texture_id_ =
+      registrar_->texture_registrar()->RegisterTexture(texture_variant_.get());
+  flutter_desktop_gpu_buffer_ = std::make_unique<FlutterDesktopGpuBuffer>();
+
   LOG_DEBUG("texture_id_[%ld]", texture_id_);
   camera_method_channel_ =
       std::make_unique<CameraMethodChannel>(registrar_, texture_id_);
@@ -397,9 +427,8 @@ void CameraDevice::Dispose() {
     orientation_manager_->Stop();
   }
 
-  if (texture_registrar_) {
-    FlutterUnregisterExternalTexture(texture_registrar_, texture_id_);
-    texture_registrar_ = nullptr;
+  if (texture_id_ != 0) {
+    registrar_->texture_registrar()->UnregisterTexture(texture_id_);
   }
 }
 
@@ -921,25 +950,15 @@ void CameraDevice::Open(
   }
 
   if (!SetCameraMediaPacketPreviewCb([](media_packet_h pkt, void *data) {
-        tbm_surface_h surface = nullptr;
-        int error = media_packet_get_tbm_surface(pkt, &surface);
-        LOG_ERROR_IF(error != MEDIA_PACKET_ERROR_NONE,
-                     "media_packet_get_tbm_surface fail - error[%d]: %s", error,
-                     get_error_message(error));
-
-        if (error == 0) {
-          auto camera_device = static_cast<CameraDevice *>(data);
-          FlutterMarkExternalTextureFrameAvailable(
-              camera_device->GetTextureRegistrar(),
-              camera_device->GetTextureId(), surface);
-        }
-
-        // destroy packet
-        if (pkt) {
-          error = media_packet_destroy(pkt);
-          LOG_ERROR_IF(error != MEDIA_PACKET_ERROR_NONE,
-                       "media_packet_destroy fail - error[%d]: %s", error,
-                       get_error_message(error));
+        auto self = static_cast<CameraDevice *>(data);
+        std::lock_guard<std::mutex> lock(self->mutex_);
+        media_packet_h unused_packet = self->packet_;
+        self->packet_ = pkt;
+        if (unused_packet != nullptr) {
+          media_packet_destroy(unused_packet);
+        } else {
+          self->registrar_->texture_registrar()->MarkTextureFrameAvailable(
+              self->texture_id_);
         }
       })) {
     result->Error(kCameraDeviceError, "Failed to set media callback");

packages/camera/tizen/src/camera_device.h

@@ -9,9 +9,10 @@
 #include <flutter/encodable_value.h>
 #include <flutter/method_result.h>
 #include <flutter/plugin_registrar.h>
-#include <flutter_tizen_texture_registrar.h>
 #include <recorder.h>
 
+#include <mutex>
+
 #include "camera_method_channel.h"
 #include "device_method_channel.h"
 #include "orientation_manager.h"
@@ -207,16 +208,13 @@ class CameraDevice {
   static flutter::EncodableValue GetAvailableCameras();
 
   CameraDevice();
-  CameraDevice(flutter::PluginRegistrar *registrar,
-               FlutterTextureRegistrar *texture_registrar,
-               CameraDeviceType typem, ResolutionPreset resolution_preset,
-               bool enable_audio);
+  CameraDevice(flutter::PluginRegistrar *registrar, CameraDeviceType typem,
+               ResolutionPreset resolution_preset, bool enable_audio);
   ~CameraDevice();
 
   void ChangeCameraDeviceType(CameraDeviceType type);
   void Dispose();
   Size GetRecommendedPreviewResolution();
-  FlutterTextureRegistrar *GetTextureRegistrar() { return texture_registrar_; }
   long GetTextureId() { return texture_id_; }
   double GetMaxExposureOffset();
   double GetMinExposureOffset();
@@ -325,7 +323,10 @@ class CameraDevice {
 
   long texture_id_{0};
   flutter::PluginRegistrar *registrar_{nullptr};
-  FlutterTextureRegistrar *texture_registrar_{nullptr};
+  std::unique_ptr<flutter::TextureVariant> texture_variant_;
+  std::unique_ptr<FlutterDesktopGpuBuffer> flutter_desktop_gpu_buffer_;
+  media_packet_h packet_{nullptr};
+  std::mutex mutex_;
 
   std::unique_ptr<CameraMethodChannel> camera_method_channel_;
   std::unique_ptr<DeviceMethodChannel> device_method_channel_;

packages/camera/tizen/src/camera_plugin.cc

@@ -7,7 +7,6 @@
 #include <flutter/method_channel.h>
 #include <flutter/plugin_registrar.h>
 #include <flutter/standard_method_codec.h>
-#include <flutter_tizen_texture_registrar.h>
 
 #include <map>
 #include <memory>
@@ -36,16 +35,13 @@ bool GetValueFromEncodableMap(flutter::EncodableMap &map, std::string key,
 
 class CameraPlugin : public flutter::Plugin {
  public:
-  static void RegisterWithRegistrar(
-      flutter::PluginRegistrar *registrar,
-      FlutterTextureRegistrar *texture_registrar) {
+  static void RegisterWithRegistrar(flutter::PluginRegistrar *registrar) {
     auto camera_channel =
         std::make_unique<flutter::MethodChannel<flutter::EncodableValue>>(
             registrar->messenger(), CAMERA_CHANNEL_NAME,
             &flutter::StandardMethodCodec::GetInstance());
 
-    auto camera_plugin =
-        std::make_unique<CameraPlugin>(registrar, texture_registrar);
+    auto camera_plugin = std::make_unique<CameraPlugin>(registrar);
 
     camera_channel->SetMethodCallHandler(
         [plugin_pointer = camera_plugin.get()](const auto &call, auto result) {
@@ -55,9 +51,7 @@ class CameraPlugin : public flutter::Plugin {
     registrar->AddPlugin(std::move(camera_plugin));
   }
 
-  CameraPlugin(flutter::PluginRegistrar *registrar,
-               FlutterTextureRegistrar *texture_registrar)
-      : registrar_(registrar), texture_registrar_(texture_registrar) {}
+  CameraPlugin(flutter::PluginRegistrar *registrar) : registrar_(registrar) {}
 
   virtual ~CameraPlugin() {}
 
@@ -334,8 +328,8 @@ class CameraPlugin : public flutter::Plugin {
     ResolutionPreset resolution_preset = ResolutionPreset::kLow;
     StringToResolutionPreset(preset, resolution_preset);
 
-    camera_ = std::make_unique<CameraDevice>(
-        registrar_, texture_registrar_, type, resolution_preset, enable_audio);
+    camera_ = std::make_unique<CameraDevice>(registrar_, type,
+                                             resolution_preset, enable_audio);
 
     flutter::EncodableMap ret;
     ret[flutter::EncodableValue("cameraId")] =
@@ -344,7 +338,6 @@ class CameraPlugin : public flutter::Plugin {
   }
 
   flutter::PluginRegistrar *registrar_{nullptr};
-  FlutterTextureRegistrar *texture_registrar_{nullptr};
   std::unique_ptr<CameraDevice> camera_;
   PermissionManager pmm_;
 };
@@ -353,6 +346,5 @@ void CameraPluginRegisterWithRegistrar(
     FlutterDesktopPluginRegistrarRef registrar) {
   CameraPlugin::RegisterWithRegistrar(
       flutter::PluginRegistrarManager::GetInstance()
-          ->GetRegistrar<flutter::PluginRegistrar>(registrar),
-      FlutterPluginRegistrarGetTexture(registrar));
+          ->GetRegistrar<flutter::PluginRegistrar>(registrar));
 }