Move video encode accelerator IPC messages to GPU IO thread

media/gpu/video_encode_accelerator_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <inttypes.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <memory>
 #include <queue>
 #include <string>
 #include <utility>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/bits.h"
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/macros.h"
 #include "base/memory/aligned_memory.h"
 #include "base/memory/scoped_vector.h"
+#include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/process/process_handle.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_checker.h"
@@ skipping 805 matching lines @@
             bool force_bitrate,
             bool test_perf,
             bool mid_stream_bitrate_switch,
             bool mid_stream_framerate_switch,
             bool verify_output,
             bool verify_output_timestamp);
   ~VEAClient() override;
   void CreateEncoder();
   void DestroyEncoder();
 
+  void TryToSetupEncodeOnSeperateThread();
+  void DestroyEncodeOnSeperateThread();
+
   // VideoDecodeAccelerator::Client implementation.
   void RequireBitstreamBuffers(unsigned int input_count,
                                const gfx::Size& input_coded_size,
                                size_t output_buffer_size) override;
   void BitstreamBufferReady(int32_t bitstream_buffer_id,
                             size_t payload_size,
                             bool key_frame,
                             base::TimeDelta timestamp) override;
   void NotifyError(VideoEncodeAccelerator::Error error) override;
 
  private:
+  void BitstreamBufferReadyOnMainThread(int32_t bitstream_buffer_id,
+                                        size_t payload_size,
+                                        bool key_frame,
+                                        base::TimeDelta timestamp);
   bool has_encoder() { return encoder_.get(); }
 
   // Return the number of encoded frames per second.
   double frames_per_second();
 
   std::unique_ptr<VideoEncodeAccelerator> CreateFakeVEA();
   std::unique_ptr<VideoEncodeAccelerator> CreateV4L2VEA();
   std::unique_ptr<VideoEncodeAccelerator> CreateVaapiVEA();
   std::unique_ptr<VideoEncodeAccelerator> CreateVTVEA();
   std::unique_ptr<VideoEncodeAccelerator> CreateMFVEA();
@@ skipping 170 matching lines @@
   unsigned int requested_subsequent_framerate_;
 
   // The timer used to feed the encoder with the input frames.
   std::unique_ptr<base::RepeatingTimer> input_timer_;
 
   // The timestamps for each frame in the order of CreateFrame() invocation.
   std::queue<base::TimeDelta> frame_timestamps_;
 
   // The last timestamp popped from |frame_timestamps_|.
   base::TimeDelta previous_timestamp_;
+
+  // Dummy thread used to redirect encode tasks, represents GPU IO thread.
+  base::Thread io_thread_;
+
+  // Task runner on which |encoder_| is created.
+  scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner_;
+
+  // Task runner used for posting encode tasks. If
+  // TryToSetupEncodeOnSeperateThread() is true, |io_thread|'s task runner is
+  // used, otherwise |main_thread_task_runner_|.
+  scoped_refptr<base::SingleThreadTaskRunner> encode_task_runner_;
+
+  // Weak factory used for posting tasks on |encode_task_runner_|.
+  std::unique_ptr<base::WeakPtrFactory<VideoEncodeAccelerator>>
+      encoder_weak_factory_;
+
+  // Weak factory used for TryToSetupEncodeOnSeperateThread().
+  base::WeakPtrFactory<VEAClient> client_weak_factory_for_io_;
 };
 
 VEAClient::VEAClient(TestStream* test_stream,
                      ClientStateNotification<ClientState>* note,
                      bool save_to_file,
                      unsigned int keyframe_period,
                      bool force_bitrate,
                      bool test_perf,
                      bool mid_stream_bitrate_switch,
                      bool mid_stream_framerate_switch,
@@ skipping 18 matching lines @@
       force_bitrate_(force_bitrate),
       current_requested_bitrate_(0),
       current_framerate_(0),
       encoded_stream_size_since_last_check_(0),
       test_perf_(test_perf),
       verify_output_(verify_output),
       verify_output_timestamp_(verify_output_timestamp),
       requested_bitrate_(0),
       requested_framerate_(0),
       requested_subsequent_bitrate_(0),
-      requested_subsequent_framerate_(0) {
+      requested_subsequent_framerate_(0),
+      io_thread_("IOThread"),
+      client_weak_factory_for_io_(this) {
   if (keyframe_period_)
     LOG_ASSERT(kMaxKeyframeDelay < keyframe_period_);
 
   // Fake encoder produces an invalid stream, so skip validating it.
   if (!g_fake_encoder) {
     stream_validator_ = StreamValidator::Create(
         test_stream_->requested_profile,
         base::Bind(&VEAClient::HandleEncodedFrame, base::Unretained(this)));
     CHECK(stream_validator_);
   }
@@ skipping 62 matching lines @@
   MediaFoundationVideoEncodeAccelerator::PreSandboxInitialization();
   encoder.reset(new MediaFoundationVideoEncodeAccelerator());
 #endif
   return encoder;
 }
 
 void VEAClient::CreateEncoder() {
   DCHECK(thread_checker_.CalledOnValidThread());
   LOG_ASSERT(!has_encoder());
 
+  main_thread_task_runner_ = base::ThreadTaskRunnerHandle::Get();
+  encode_task_runner_ = main_thread_task_runner_;
+
   std::unique_ptr<VideoEncodeAccelerator> encoders[] = {
       CreateFakeVEA(), CreateV4L2VEA(), CreateVaapiVEA(), CreateVTVEA(),
       CreateMFVEA()};
 
   DVLOG(1) << "Profile: " << test_stream_->requested_profile
            << ", initial bitrate: " << requested_bitrate_;
 
   for (size_t i = 0; i < arraysize(encoders); ++i) {
     if (!encoders[i])
       continue;
     encoder_ = std::move(encoders[i]);
     SetState(CS_ENCODER_SET);
     if (encoder_->Initialize(kInputFormat, test_stream_->visible_size,
                              test_stream_->requested_profile,
                              requested_bitrate_, this)) {
+      encoder_weak_factory_.reset(
+          new base::WeakPtrFactory<VideoEncodeAccelerator>(encoder_.get()));
+      TryToSetupEncodeOnSeperateThread();
       SetStreamParameters(requested_bitrate_, requested_framerate_);
       SetState(CS_INITIALIZED);
 
       if (verify_output_ && !g_fake_encoder)
         quality_validator_.reset(new VideoFrameQualityValidator(
             test_stream_->requested_profile,
             base::Bind(&VEAClient::DecodeCompleted, base::Unretained(this)),
             base::Bind(&VEAClient::DecodeFailed, base::Unretained(this))));
       return;
     }
   }
   encoder_.reset();
   LOG(ERROR) << "VideoEncodeAccelerator::Initialize() failed";
   SetState(CS_ERROR);
 }
 
 void VEAClient::DecodeCompleted() {
   SetState(CS_VALIDATED);
 }
 
+void VEAClient::TryToSetupEncodeOnSeperateThread() {
+  // Start dummy thread if not started already.
+  if (!io_thread_.IsRunning())
+    ASSERT_TRUE(io_thread_.Start());
+
+  if (!encoder_->TryToSetupEncodeOnSeparateThread(
+          client_weak_factory_for_io_.GetWeakPtr(), io_thread_.task_runner())) {
+    io_thread_.Stop();
+    return;
+  }
+
+  encode_task_runner_ = io_thread_.task_runner();
+}
+
 void VEAClient::DecodeFailed() {
   SetState(CS_ERROR);
 }
 
 void VEAClient::DestroyEncoder() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!has_encoder())
     return;
+
+  if (io_thread_.IsRunning()) {
+    encode_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&VEAClient::DestroyEncodeOnSeperateThread,
+                              client_weak_factory_for_io_.GetWeakPtr()));
+    io_thread_.Stop();
+  } else {
+    DestroyEncodeOnSeperateThread();
+  }
+
   // Clear the objects that should be destroyed on the same thread as creation.
   encoder_.reset();
   input_timer_.reset();
   quality_validator_.reset();
 }
 
+void VEAClient::DestroyEncodeOnSeperateThread() {
+  encoder_weak_factory_->InvalidateWeakPtrs();
+  // |client_weak_factory_for_io_| is used only when
+  // TryToSetupEncodeOnSeperateThread() returns true, in order to have weak
+  // pointers to use when posting tasks on |io_thread_|. It is safe to
+  // invalidate here because |encode_task_runner_| points to |io_thread_| in
+  // this case. If not, it is safe to invalidate it on
+  // |main_thread_task_runner_| as no weak pointers are used.
+  client_weak_factory_for_io_.InvalidateWeakPtrs();
+}
+
 void VEAClient::UpdateTestStreamData(bool mid_stream_bitrate_switch,
                                      bool mid_stream_framerate_switch) {
   // Use defaults for bitrate/framerate if they are not provided.
   if (test_stream_->requested_bitrate == 0)
     requested_bitrate_ = kDefaultBitrate;
   else
     requested_bitrate_ = test_stream_->requested_bitrate;
 
   if (test_stream_->requested_framerate == 0)
     requested_framerate_ = kDefaultFramerate;
@@ skipping 100 matching lines @@
     EXPECT_EQ(frame_timestamps_.front(), timestamp);
     previous_timestamp_ = frame_timestamps_.front();
     frame_timestamps_.pop();
   }
 }
 
 void VEAClient::BitstreamBufferReady(int32_t bitstream_buffer_id,
                                      size_t payload_size,
                                      bool key_frame,
                                      base::TimeDelta timestamp) {
+  ASSERT_TRUE(encode_task_runner_->BelongsToCurrentThread());
+  main_thread_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&VEAClient::BitstreamBufferReadyOnMainThread,
+                            base::Unretained(this), bitstream_buffer_id,
+                            payload_size, key_frame, timestamp));
+}
+
+void VEAClient::NotifyError(VideoEncodeAccelerator::Error error) {
   DCHECK(thread_checker_.CalledOnValidThread());
+  SetState(CS_ERROR);
+}
+
+void VEAClient::BitstreamBufferReadyOnMainThread(int32_t bitstream_buffer_id,
+                                                 size_t payload_size,
+                                                 bool key_frame,
+                                                 base::TimeDelta timestamp) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
   ASSERT_LE(payload_size, output_buffer_size_);
 
   IdToSHM::iterator it = output_buffers_at_client_.find(bitstream_buffer_id);
   ASSERT_NE(it, output_buffers_at_client_.end());
   base::SharedMemory* shm = it->second;
   output_buffers_at_client_.erase(it);
 
   if (state_ == CS_FINISHED || state_ == CS_VALIDATED)
     return;
 
@@ skipping 31 matching lines @@
           base::checked_cast<int>(payload_size)));
     }
   }
 
   EXPECT_EQ(key_frame, seen_keyframe_in_this_buffer_);
   seen_keyframe_in_this_buffer_ = false;
 
   FeedEncoderWithOutput(shm);
 }
 
-void VEAClient::NotifyError(VideoEncodeAccelerator::Error error) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  SetState(CS_ERROR);
-}
-
 void VEAClient::SetState(ClientState new_state) {
   DVLOG(4) << "Changing state " << state_ << "->" << new_state;
   note_->Notify(new_state);
   state_ = new_state;
 }
 
 void VEAClient::SetStreamParameters(unsigned int bitrate,
                                     unsigned int framerate) {
   current_requested_bitrate_ = bitrate;
   current_framerate_ = framerate;
   LOG_ASSERT(current_requested_bitrate_ > 0UL);
   LOG_ASSERT(current_framerate_ > 0UL);
-  encoder_->RequestEncodingParametersChange(current_requested_bitrate_,
-                                            current_framerate_);
+  encode_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&VideoEncodeAccelerator::RequestEncodingParametersChange,
+                 encoder_weak_factory_->GetWeakPtr(), bitrate, framerate));
   DVLOG(1) << "Switched parameters to " << current_requested_bitrate_
            << " bps @ " << current_framerate_ << " FPS";
 }
 
 void VEAClient::InputNoLongerNeededCallback(int32_t input_id) {
   std::set<int32_t>::iterator it = inputs_at_client_.find(input_id);
   ASSERT_NE(it, inputs_at_client_.end());
   inputs_at_client_.erase(it);
   if (!g_env->run_at_fps())
     FeedEncoderWithOneInput();
@@ skipping 78 matching lines @@
   }
 
   if (input_id == 0) {
     first_frame_start_time_ = base::TimeTicks::Now();
   }
 
   if (g_env->needs_encode_latency()) {
     LOG_ASSERT(input_id == static_cast<int32_t>(encode_start_time_.size()));
     encode_start_time_.push_back(base::TimeTicks::Now());
   }
-  encoder_->Encode(video_frame, force_keyframe);
+
+  encode_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&VideoEncodeAccelerator::Encode,
+                            encoder_weak_factory_->GetWeakPtr(), video_frame,
+                            force_keyframe));
 }
 
 void VEAClient::FeedEncoderWithOutput(base::SharedMemory* shm) {
   if (!has_encoder())
     return;
 
   if (state_ != CS_ENCODING)
     return;
 
   base::SharedMemoryHandle dup_handle;
   LOG_ASSERT(shm->ShareToProcess(base::GetCurrentProcessHandle(), &dup_handle));
 
   BitstreamBuffer bitstream_buffer(next_output_buffer_id_++, dup_handle,
                                    output_buffer_size_);
   LOG_ASSERT(output_buffers_at_client_
                  .insert(std::make_pair(bitstream_buffer.id(), shm))
                  .second);
-  encoder_->UseOutputBitstreamBuffer(bitstream_buffer);
+
+  encode_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&VideoEncodeAccelerator::UseOutputBitstreamBuffer,
+                 encoder_weak_factory_->GetWeakPtr(), bitstream_buffer));
 }
 
 bool VEAClient::HandleEncodedFrame(bool keyframe) {
   // This would be a bug in the test, which should not ignore false
   // return value from this method.
   LOG_ASSERT(num_encoded_frames_ <= num_frames_to_encode_);
 
   last_frame_ready_time_ = base::TimeTicks::Now();
 
   if (g_env->needs_encode_latency()) {
@@ skipping 404 matching lines @@
 
   media::g_env =
       reinterpret_cast<media::VideoEncodeAcceleratorTestEnvironment*>(
           testing::AddGlobalTestEnvironment(
               new media::VideoEncodeAcceleratorTestEnvironment(
                   std::move(test_stream_data), log_path, run_at_fps,
                   needs_encode_latency, verify_all_output)));
 
   return RUN_ALL_TESTS();
 }