[TTVD] Add basic test for TTvdVideoDecoder

This change is preparation to implement tests for
TTvdVideoDecoder class. Some classes could not be mocked
before this patch, so there are few changes in creation
process.
There is currently single test to check whole test framework
and there should be no functional change at all.

Bug: https://jira-eu.sec.samsung.net/browse/VDGAME-441
Change-Id: If971b40e6e9588371c7d22ac7a389876686c460c
Signed-off-by: Jakub Gajownik <j.gajownik2@samsung.com>

diff --git a/media/filters/tizen/ttvd_video_decoder.cc b/media/filters/tizen/ttvd_video_decoder.cc
index 6ef0ce67d894449bbed58b9a4bc3853fbef7d75d..85a81a41c25eb7ba108949447f2fdfa0fd680e4d 100644 (file)
--- a/media/filters/tizen/ttvd_video_decoder.cc
+++ b/media/filters/tizen/ttvd_video_decoder.cc
@@ -19,7 +19,8 @@
 namespace media {
 
 TTvdVideoDecoder::TTvdVideoDecoder(
-    base::RepeatingCallback<gpu::CommandBufferStub*()> get_command_buffer_cb,
+    base::RepeatingCallback<scoped_refptr<CommandBufferHelper>()>
+        get_command_buffer_cb,
     scoped_refptr<base::SingleThreadTaskRunner> gpu_task_runner,
     base::RepeatingCallback<std::unique_ptr<DecoderFacadeVideo>(
         const gpu::GpuDriverBugWorkarounds*)> get_video_facade_cb,
@@ -165,8 +166,7 @@ void TTvdVideoDecoder::OnStateChange(suspend_resume::State new_state) {
 
 // Private methods
 void TTvdVideoDecoder::InitializeOnGpuThread() {
-  command_buffer_helper_ =
-      CommandBufferHelper::Create(get_command_buffer_cb_.Run());
+  command_buffer_helper_ = get_command_buffer_cb_.Run();
   TIZEN_MEDIA_LOG(VERBOSE) << "Command buffer created";
   command_buffer_created_.Signal();
 }
@@ -176,4 +176,9 @@ scoped_refptr<CommandBufferHelper> TTvdVideoDecoder::GetCommandBufferHelper() {
   return command_buffer_helper_;
 }
 
+scoped_refptr<CommandBufferHelper> CommandBufferHelperFromStub(
+    base::RepeatingCallback<gpu::CommandBufferStub*()> get_command_buffer_cb) {
+  return CommandBufferHelper::Create(get_command_buffer_cb.Run());
+}
+
 }  // namespace media

diff --git a/media/filters/tizen/ttvd_video_decoder.h b/media/filters/tizen/ttvd_video_decoder.h
index 178b5cee4d67fda78b2cca57ded4a8c417568264..39e48af1875c14a0a5166ae8c08f8c330189d4bd 100644 (file)
--- a/media/filters/tizen/ttvd_video_decoder.h
+++ b/media/filters/tizen/ttvd_video_decoder.h
@@ -10,7 +10,6 @@
 #include "base/threading/sequence_bound.h"
 #include "base/threading/thread.h"
 #include "gpu/config/gpu_driver_bug_workarounds.h"
-#include "gpu/ipc/service/command_buffer_stub.h"
 #include "media/base/cdm_context.h"
 #include "media/base/supported_video_decoder_config.h"
 #include "media/base/video_decoder.h"
@@ -26,7 +25,8 @@ class MEDIA_EXPORT TTvdVideoDecoder
       public suspend_resume::SuspendResumeClient {
  public:
   TTvdVideoDecoder(
-      base::RepeatingCallback<gpu::CommandBufferStub*()> get_command_buffer_cb,
+      base::RepeatingCallback<scoped_refptr<CommandBufferHelper>()>
+          get_command_buffer_cb,
       scoped_refptr<base::SingleThreadTaskRunner> gpu_task_runner,
       base::RepeatingCallback<std::unique_ptr<DecoderFacadeVideo>(
           const gpu::GpuDriverBugWorkarounds*)> get_video_facade_cb,
@@ -76,7 +76,8 @@ class MEDIA_EXPORT TTvdVideoDecoder
       const gpu::GpuDriverBugWorkarounds*)>
       get_video_facade_cb_;
 
-  base::RepeatingCallback<gpu::CommandBufferStub*()> get_command_buffer_cb_;
+  base::RepeatingCallback<scoped_refptr<CommandBufferHelper>()>
+      get_command_buffer_cb_;
   scoped_refptr<CommandBufferHelper> command_buffer_helper_;
   base::WaitableEvent command_buffer_created_;
 
@@ -86,6 +87,9 @@ class MEDIA_EXPORT TTvdVideoDecoder
   scoped_refptr<base::SingleThreadTaskRunner> gpu_task_runner_;
 };
 
+scoped_refptr<CommandBufferHelper> CommandBufferHelperFromStub(
+    base::RepeatingCallback<gpu::CommandBufferStub*()> get_command_buffer_cb);
+
 }  // namespace media
 
 #endif  // MEDIA_FILTERS_TIZEN_TTVD_VIDEO_DECODER_H_

diff --git a/media/filters/tizen/ttvd_video_decoder_impl.cc b/media/filters/tizen/ttvd_video_decoder_impl.cc
index f5a320d679de1d67536878efa0c6435b1039de4d..000929aa28cf556b567ad40ad36de9204dcff302 100644 (file)
--- a/media/filters/tizen/ttvd_video_decoder_impl.cc
+++ b/media/filters/tizen/ttvd_video_decoder_impl.cc
@@ -51,9 +51,43 @@ namespace media {
 namespace {
 scoped_refptr<gfx::TizenPlaneCollectionManager>
 GetTizenPlaneCollectionManager() {
-  return reinterpret_cast<ui::EflSurfaceFactory*>(
-             ui::OzonePlatform::GetInstance()->GetSurfaceFactoryOzone())
-      ->PlaneCollectionManager();
+  auto* ozone_platform = ui::OzonePlatform::GetInstance();
+  if (!ozone_platform) {
+    return nullptr;
+  }
+
+  auto* surface_factory = reinterpret_cast<ui::EflSurfaceFactory*>(
+      ozone_platform->GetSurfaceFactoryOzone());
+  if (!surface_factory) {
+    return nullptr;
+  }
+  return surface_factory->PlaneCollectionManager();
+}
+
+scoped_refptr<ui::OutputSurfaceManager> GetOutputSurfaceManager(
+    const ui::RenderingWorkarounds& rendering_workarounds) {
+  auto* ozone_platform = ui::OzonePlatform::GetInstance();
+  if (!ozone_platform) {
+    return nullptr;
+  }
+
+  auto* surface_factory = reinterpret_cast<ui::EflSurfaceFactory*>(
+      ozone_platform->GetSurfaceFactoryOzone());
+  if (!surface_factory) {
+    return nullptr;
+  }
+  return surface_factory->GetOutputSurfaceManager(rendering_workarounds);
+}
+
+scoped_refptr<ui::OutputSurfaceManager> GetOrCreateOutputSurfaceManager(
+    const gpu::GpuDriverBugWorkarounds& gpu_workarounds) {
+  const auto rendering_workarounds =
+      ui::ConvertToRenderingWorkarounds(gpu_workarounds);
+  auto result = GetOutputSurfaceManager(rendering_workarounds);
+  if (result) {
+    return result;
+  }
+  return base::MakeRefCounted<ui::OutputSurfaceManager>(rendering_workarounds);
 }
 
 // Maximum number of decoded frames that should be alive.
@@ -138,26 +172,28 @@ TTvdVideoDecoderImpl::TTvdVideoDecoderImpl(
           base::BindOnce(
               [](scoped_refptr<DecodedCollectionOnGpu> plane_collection,
                  base::WaitableEvent* event, base::UnguessableToken* result) {
-                auto token =
-                    GetTizenPlaneCollectionManager()->RegisterCollection(
-                        plane_collection);
-                plane_collection->SetToken(token);
-                *result = token;
+                auto plane_collection_manager =
+                    GetTizenPlaneCollectionManager();
+                if (plane_collection_manager) {
+                  auto token = plane_collection_manager->RegisterCollection(
+                      plane_collection);
+                  plane_collection->SetToken(token);
+                  *result = token;
+                }
                 event->Signal();
               },
               plane_collection_, &event, &collection_token_))) {
     event.Wait();
   }
 
-  output_surface_manager_ =
-      reinterpret_cast<ui::EflSurfaceFactory*>(
-          ui::OzonePlatform::GetInstance()->GetSurfaceFactoryOzone())
-          ->GetOutputSurfaceManager(
-              ui::ConvertToRenderingWorkarounds(workarounds_));
+  output_surface_manager_ = GetOrCreateOutputSurfaceManager(workarounds_);
 }
 
 DecodedCollectionOnGpu::~DecodedCollectionOnGpu() {
-  GetTizenPlaneCollectionManager()->RemoveCollection(token_);
+  auto plane_collection_manager = GetTizenPlaneCollectionManager();
+  if (plane_collection_manager) {
+    plane_collection_manager->RemoveCollection(token_);
+  }
 }
 
 TTvdVideoDecoderImpl::~TTvdVideoDecoderImpl() {

diff --git a/media/filters/tizen/ttvd_video_decoder_test.cc b/media/filters/tizen/ttvd_video_decoder_test.cc
new file mode 100644 (file)
index 0000000..448e6ea
--- /dev/null
+++ b/media/filters/tizen/ttvd_video_decoder_test.cc
@@ -0,0 +1,88 @@
+// Copyright 2024 Samsung Electronics Inc. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "media/filters/tizen/ttvd_video_decoder.h"
+
+#include "absl/types/optional.h"
+#include "base/threading/thread.h"
+#include "base/tizen/provider_callbacks_helper.h"
+#include "base/tizen/resource_manager.h"
+#include "media/filters/tizen/decoder_promotion.h"
+#include "media/filters/tizen/media_video_codec.h"
+#include "media/gpu/test/fake_command_buffer_helper.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace media {
+
+class FakeResourceManager : public base::ResourceManager {
+ public:
+  FakeResourceManager() = default;
+  ~FakeResourceManager() = default;
+
+  FakeResourceManager(const FakeResourceManager&) = delete;
+  FakeResourceManager& operator=(const FakeResourceManager&) = delete;
+
+  absl::optional<base::AllocatedResource> AllocateResource(
+      int /* category */,
+      int /* category_option */,
+      ReleaseCB release_cb) override {
+    release_cb_ = std::move(release_cb);
+    return base::AllocatedResource(CreateTokenForTesting(0, base::DoNothing()),
+                                   "testing", 0);
+  }
+
+  bool CanAllocate(int, int) override { return true; }
+  bool SetPriority(int) override { return true; }
+  bool IsCategorySupported(int) override { return true; }
+  bool HasUHDVideoDecoder() override { return true; }
+  void ReleaseDevice() {
+    auto token_cb = release_cb_.Run();
+    base::IgnoreResult(std::move(token_cb).Run());
+  }
+
+  int GetJpegCategoryId(const char* /* codec_name */,
+                        int /* h_size */) override {
+    return 1;
+  }
+  int GetCapableVideoCategoryId(
+      const char* /* codec_name */,
+      int /* color_depth */,
+      int /* width */,
+      int /* height */,
+      int /* framerate */,
+      int /* sampling_format */,
+      base::PreferTexturingSupport /* prefer_texturing_support */) override {
+    return 1;
+  }
+
+ private:
+  ReleaseCB release_cb_;
+};
+
+TEST(TTvdVideoDecoderTest, CreateWithEmptyFacade) {
+  FakeResourceManager fake_resource_manager;
+  DecoderPromotion* decoder_promotion = DecoderPromotion::GetInstance();
+  decoder_promotion->SetResourceManagerForTesting(&fake_resource_manager);
+
+  base::Thread gpu_thread("gpu_thread");
+  ASSERT_TRUE(gpu_thread.StartAndWaitForTesting());
+
+  gpu::GpuDriverBugWorkarounds gpu_workarounds;
+  TTvdVideoDecoder video_decoder(
+      base::BindRepeating(
+          [](scoped_refptr<base::SingleThreadTaskRunner> task_runner)
+              -> scoped_refptr<CommandBufferHelper> {
+            return base::MakeRefCounted<FakeCommandBufferHelper>(task_runner);
+          },
+          gpu_thread.task_runner()),
+      gpu_thread.task_runner(),
+      base::BindRepeating(
+          [](const gpu::GpuDriverBugWorkarounds*)
+              -> std::unique_ptr<DecoderFacadeVideo> { return nullptr; }),
+      gpu_workarounds);
+
+  gpu_thread.FlushForTesting();
+}
+
+}  // namespace media

diff --git a/media/gpu/BUILD.gn b/media/gpu/BUILD.gn
index 58f82023b128879e5e84784afe4f06a41b0c2fd5..5c0a5f2252110d870af078cde6fa8d9f3363e3fc 100644 (file)
--- a/media/gpu/BUILD.gn
+++ b/media/gpu/BUILD.gn
@@ -584,7 +584,10 @@ source_set("android_video_decode_accelerator_unittests") {
 }
 
 static_library("test_support") {
-  visibility = [ "//media/gpu/*" ]
+  visibility = [
+    "//media/gpu/*",
+    "//tizen_src/chromium_impl/media/test/*",
+  ]
   testonly = true
   sources = [
     "test/fake_command_buffer_helper.cc",

diff --git a/media/mojo/services/gpu_mojo_media_client_tizen.cc b/media/mojo/services/gpu_mojo_media_client_tizen.cc
index 15525b46e7c6b2d1e320a4b8668fe8e9dffc656c..9a60b4707e2a249c2492ca5847ef844e33139b07 100644 (file)
--- a/media/mojo/services/gpu_mojo_media_client_tizen.cc
+++ b/media/mojo/services/gpu_mojo_media_client_tizen.cc
@@ -20,8 +20,10 @@ namespace media {
 std::unique_ptr<VideoDecoder> CreatePlatformVideoDecoder(
     VideoDecoderTraits& traits) {
   return std::make_unique<TTvdVideoDecoder>(
-      traits.get_command_buffer_stub_cb, traits.gpu_task_runner,
-      base::BindRepeating(&CreateDecoderFacadeVideo), *traits.gpu_workarounds);
+      base::BindRepeating(&CommandBufferHelperFromStub,
+                          traits.get_command_buffer_stub_cb),
+      traits.gpu_task_runner, base::BindRepeating(&CreateDecoderFacadeVideo),
+      *traits.gpu_workarounds);
 }
 
 absl::optional<SupportedVideoDecoderConfigs>

diff --git a/tizen_src/chromium_impl/media/test/BUILD.gn b/tizen_src/chromium_impl/media/test/BUILD.gn
index 844298e2393e2cb2ca3460ffed30775f87002e9a..1faa5649943a0448e90b4a9730beeda81327421d 100644 (file)
--- a/tizen_src/chromium_impl/media/test/BUILD.gn
+++ b/tizen_src/chromium_impl/media/test/BUILD.gn
@@ -17,6 +17,8 @@ test("tizen_media_unittests") {
     "//base",
     "//base/test:test_support",
     "//media/",
+    "//media/gpu:test_support",
+    "//media/parsers",
     "//media/test:run_all_unittests",
     "//testing/gmock:gmock",
     "//testing/gtest:gtest",
@@ -25,6 +27,7 @@ test("tizen_media_unittests") {
   sources = [
     "//media/filters/tizen/decoder_promotion_test.cc",
     "//media/filters/tizen/lazy_frame_ranges_test.cc",
+    "//media/filters/tizen/ttvd_video_decoder_test.cc",
   ]
 
   if (tizen_tv_upstream_multimedia_omx || tizen_tv_upstream_multimedia_omx_ppi) {