[video_player] Apply new texture release callback

packages/video_player/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 2.3.2
+
+* Apply texture common release callback.
+
 ## 2.3.1
 
 * Show first frame after player is prepared.

packages/video_player/README.md

@@ -29,7 +29,7 @@ This package is not an _endorsed_ implementation of `video_player`. Therefore, y
 ```yaml
 dependencies:
   video_player: ^2.2.6
-  video_player_tizen: ^2.3.1
+  video_player_tizen: ^2.3.2
 ```
 
 Then you can import `video_player` in your Dart code:

packages/video_player/pubspec.yaml

@@ -3,7 +3,7 @@ description: Flutter plugin for displaying inline video with other Flutter
   widgets on Tizen.
 homepage: https://github.com/flutter-tizen/plugins
 repository: https://github.com/flutter-tizen/plugins/tree/master/packages/video_player
-version: 2.3.1
+version: 2.3.2
 
 flutter:
   plugin:

packages/video_player/tizen/src/video_player.cc

@@ -49,51 +49,38 @@ static std::string StateToString(player_state_e state) {
   return ret;
 }
 
-bool VideoPlayer::IsValidMediaPacket(media_packet_h media_packet) {
-  tbm_surface_h surface;
-  int ret = media_packet_get_tbm_surface(media_packet, &surface);
-  if (ret != MEDIA_PACKET_ERROR_NONE) {
-    LOG_ERROR("get tbm surface failed, error: %d", ret);
-    return false;
+void VideoPlayer::ReleaseMediaPacket(void *data) {
+  VideoPlayer *player = (VideoPlayer *)data;
+  std::lock_guard<std::mutex> lock(player->mutex_);
+  if (player->current_media_packet_) {
+    media_packet_destroy(player->current_media_packet_);
+    player->current_media_packet_ = nullptr;
   }
-  return true;
 }
 
 FlutterDesktopGpuBuffer *VideoPlayer::ObtainGpuBuffer(size_t width,
                                                       size_t height) {
   std::lock_guard<std::mutex> lock(mutex_);
-  if (prepared_media_packet_ && !IsValidMediaPacket(prepared_media_packet_)) {
-    media_packet_destroy(prepared_media_packet_);
-    prepared_media_packet_ = nullptr;
+  if (!current_media_packet_) {
+    LOG_ERROR("No vaild media packet");
+    return nullptr;
   }
-  if (current_media_packet_ && !IsValidMediaPacket(current_media_packet_)) {
+  tbm_surface_h surface;
+  int ret = media_packet_get_tbm_surface(current_media_packet_, &surface);
+  if (ret != MEDIA_PACKET_ERROR_NONE || surface == nullptr) {
+    LOG_ERROR("get tbm surface failed, error: %d", ret);
     media_packet_destroy(current_media_packet_);
     current_media_packet_ = nullptr;
-  }
-  if (!prepared_media_packet_ && !current_media_packet_) {
-    LOG_ERROR("No vaild media packet");
     return nullptr;
   }
-  if (prepared_media_packet_ && !current_media_packet_) {
-    current_media_packet_ = prepared_media_packet_;
-    prepared_media_packet_ = nullptr;
-  }
-  tbm_surface_h surface;
-  media_packet_get_tbm_surface(current_media_packet_, &surface);
   flutter_desktop_gpu_buffer_->buffer = surface;
   flutter_desktop_gpu_buffer_->width = width;
   flutter_desktop_gpu_buffer_->height = height;
+  flutter_desktop_gpu_buffer_->release_context = this;
+  flutter_desktop_gpu_buffer_->release_callback = ReleaseMediaPacket;
   return flutter_desktop_gpu_buffer_.get();
 }
 
-void VideoPlayer::Destruct(void *buffer) {
-  std::lock_guard<std::mutex> lock(mutex_);
-  if (current_media_packet_) {
-    media_packet_destroy(current_media_packet_);
-    current_media_packet_ = nullptr;
-  }
-}
-
 VideoPlayer::VideoPlayer(flutter::PluginRegistrar *plugin_registrar,
                          flutter::TextureRegistrar *texture_registrar,
                          const std::string &uri, VideoPlayerOptions &options) {
@@ -105,8 +92,7 @@ VideoPlayer::VideoPlayer(flutter::PluginRegistrar *plugin_registrar,
           [this](size_t width,
                  size_t height) -> const FlutterDesktopGpuBuffer * {
             return this->ObtainGpuBuffer(width, height);
-          },
-          [this](void *buffer) -> void { this->Destruct(buffer); }));
+          }));
   flutter_desktop_gpu_buffer_ = std::make_unique<FlutterDesktopGpuBuffer>();
 
   LOG_INFO("[VideoPlayer] register texture");
@@ -338,11 +324,6 @@ void VideoPlayer::dispose() {
     current_media_packet_ = nullptr;
   }
 
-  if (prepared_media_packet_) {
-    media_packet_destroy(prepared_media_packet_);
-    prepared_media_packet_ = nullptr;
-  }
-
   if (texture_registrar_) {
     texture_registrar_->UnregisterTexture(texture_id_);
     texture_registrar_ = nullptr;
@@ -557,12 +538,11 @@ void VideoPlayer::onErrorOccurred(int code, void *data) {
 void VideoPlayer::onVideoFrameDecoded(media_packet_h packet, void *data) {
   VideoPlayer *player = (VideoPlayer *)data;
   std::lock_guard<std::mutex> lock(player->mutex_);
-  if (player->prepared_media_packet_) {
-    LOG_INFO("prepared packet not null, store new");
-    media_packet_destroy(player->prepared_media_packet_);
-    player->prepared_media_packet_ = packet;
+  if (player->current_media_packet_) {
+    LOG_INFO("current media packet not null");
+    media_packet_destroy(packet);
     return;
   }
-  player->prepared_media_packet_ = packet;
+  player->current_media_packet_ = packet;
   player->texture_registrar_->MarkTextureFrameAvailable(player->texture_id_);
 }

packages/video_player/tizen/src/video_player.h

@@ -41,8 +41,7 @@ class VideoPlayer {
   void sendBufferingUpdate(int position);  // milliseconds
   void sendBufferingEnd();
   FlutterDesktopGpuBuffer *ObtainGpuBuffer(size_t width, size_t height);
-  void Destruct(void *buffer);
-  bool IsValidMediaPacket(media_packet_h media_packet);
+  static void ReleaseMediaPacket(void *packet);
 
   static void onPrepared(void *data);
   static void onBuffering(int percent, void *data);
@@ -63,7 +62,6 @@ class VideoPlayer {
   std::unique_ptr<FlutterDesktopGpuBuffer> flutter_desktop_gpu_buffer_;
   std::mutex mutex_;
   SeekCompletedCb on_seek_completed_;
-  media_packet_h prepared_media_packet_ = nullptr;
   media_packet_h current_media_packet_ = nullptr;
 };