media/gpu: Make VulkanImageProcessor Async

Refactor the VulkanImageProcessor to process frames asynchronously. Note
that this no longer obeys the ImageProcessor API, but this will make the
VulkanImageProcessor more suitable for integration with Viz.

Bug: b:251458823
Test: Tested by running ImageProcessorBackendTest.VulkanDetileScaleTest
on Cherry.

Change-Id: Ie2dce3034e2b1c5e657f721d37d8bb47af9ffcc7
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/5014556
Reviewed-by: Vasiliy Telezhnikov <vasilyt@chromium.org>
Commit-Queue: Justin Green <greenjustin@google.com>
Reviewed-by: Jeffrey Kardatzke <jkardatzke@google.com>
Cr-Commit-Position: refs/heads/main@{#1223136}

media/gpu/chromeos/BUILD.gn

@@ -90,8 +90,8 @@ source_set("common") {
     "vda_video_frame_pool.cc",
     "vda_video_frame_pool.h",
     "video_decoder_pipeline.h",
-    "vulkan_image_processor_backend.cc",
-    "vulkan_image_processor_backend.h",
+    "vulkan_image_processor.cc",
+    "vulkan_image_processor.h",
   ]
 
   # TODO(crbug.com/1012587): Merge :fourcc to :common.

media/gpu/chromeos/image_processor_test.cc

@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 #include <sys/mman.h>
+#include <sys/poll.h>
 #include <memory>
 #include <string>
 #include <tuple>
@@ -19,6 +20,7 @@
 #include "base/test/test_suite.h"
 #include "build/build_config.h"
 #include "build/chromeos_buildflags.h"
+#include "gpu/command_buffer/common/mailbox.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_frame_layout.h"
 #include "media/base/video_types.h"
@@ -28,7 +30,7 @@
 #include "media/gpu/chromeos/image_processor_backend.h"
 #include "media/gpu/chromeos/image_processor_factory.h"
 #include "media/gpu/chromeos/platform_video_frame_utils.h"
-#include "media/gpu/chromeos/vulkan_image_processor_backend.h"
+#include "media/gpu/chromeos/vulkan_image_processor.h"
 #include "media/gpu/test/image.h"
 #include "media/gpu/test/image_processor/image_processor_client.h"
 #include "media/gpu/test/video_frame_file_writer.h"
@@ -718,41 +720,37 @@ TEST(ImageProcessorBackendTest, VulkanDetileScaleTest) {
       test::CreateVideoFrameLayout(input_image.PixelFormat(), coded_size);
   auto output_layout = test::CreateVideoFrameLayout(
       output_fourcc.ToVideoPixelFormat(), output_size);
-  ImageProcessor::PortConfig input_config(
-      Fourcc(Fourcc::MM21), coded_size, input_layout->planes(), visible_rect,
-      {VideoFrame::STORAGE_GPU_MEMORY_BUFFER});
-  ImageProcessor::PortConfig output_config(
-      output_fourcc, output_size, output_layout->planes(), output_visible_rect,
-      {VideoFrame::STORAGE_GPU_MEMORY_BUFFER});
-  base::RunLoop run_loop;
-  base::RepeatingClosure quit_closure = run_loop.QuitClosure();
-  bool image_processor_error = false;
-  auto client_task_runner = base::SequencedTaskRunner::GetCurrentDefault();
-  ImageProcessor::ErrorCB error_cb = base::BindRepeating(
-      [](scoped_refptr<base::SequencedTaskRunner> client_task_runner,
-         base::RepeatingClosure quit_closure, bool* image_processor_error) {
-        CHECK(client_task_runner->RunsTasksInCurrentSequence());
-        *image_processor_error = true;
-        quit_closure.Run();
+  auto in_gmb = CreateGpuMemoryBufferHandle(mm21_frame.get());
+  auto out_gmb = CreateGpuMemoryBufferHandle(vulkan_output_frame.get());
+  gpu::Mailbox input_mailbox = gpu::Mailbox::GenerateForSharedImage();
+  gpu::Mailbox output_mailbox = gpu::Mailbox::GenerateForSharedImage();
+
+  VulkanImageProcessor::BackingCB input_backing_cb = base::BindRepeating(
+      [](gpu::Mailbox expected_mailbox_, gfx::GpuMemoryBufferHandle* in_gmb_,
+         gpu::Mailbox& mailbox) {
+        assert(mailbox == expected_mailbox_);
+        return std::move(*in_gmb_);
       },
-      client_task_runner, quit_closure, &image_processor_error);
-  auto vulkan_image_processor = VulkanImageProcessorBackend::Create(
-      input_config, output_config, ImageProcessorBackend::OutputMode::IMPORT,
-      error_cb);
+      input_mailbox, &in_gmb);
+  VulkanImageProcessor::ReleaseCB in_release_cb =
+      base::BindOnce([](gpu::Mailbox& mailbox) {});
+  VulkanImageProcessor::BackingCB output_backing_cb = base::BindRepeating(
+      [](gpu::Mailbox expected_mailbox_, gfx::GpuMemoryBufferHandle* out_gmb_,
+         gpu::Mailbox& mailbox) {
+        assert(mailbox == expected_mailbox_);
+        return std::move(*out_gmb_);
+      },
+      output_mailbox, &out_gmb);
+  auto vulkan_image_processor =
+      VulkanImageProcessor::Create(input_backing_cb, output_backing_cb);
   ASSERT_TRUE(vulkan_image_processor);
 
-  ImageProcessor::FrameReadyCB vulkan_callback = base::BindOnce(
-      [](scoped_refptr<base::SequencedTaskRunner> client_task_runner,
-         base::RepeatingClosure quit_closure,
-         scoped_refptr<VideoFrame>* output_frame,
-         scoped_refptr<VideoFrame> frame) {
-        CHECK(client_task_runner->RunsTasksInCurrentSequence());
-        quit_closure.Run();
-      },
-      client_task_runner, quit_closure, &vulkan_output_frame);
-  vulkan_image_processor->Process(mm21_frame, vulkan_output_frame,
-                                  std::move(vulkan_callback));
-  run_loop.Run();
+  gpu::SemaphoreHandle done_semaphore = vulkan_image_processor->Process(
+      input_mailbox, coded_size, visible_rect.size(), std::move(in_release_cb),
+      output_mailbox, output_size, output_visible_rect.size(), absl::nullopt);
+
+  struct pollfd poll_request = {done_semaphore.TakeHandle().get(), -0x7FFF, 0};
+  poll(&poll_request, 1, 1000);
 
   // Replicate this operation using LibYUV. Note that we don't use the image
   // processor since we need to do a very specific conversion and scale