Move video encode accelerator IPC messages to GPU IO thread

media/gpu/media_foundation_video_encode_accelerator_win.cc

 // Copyright 2016 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 "media/gpu/media_foundation_video_encode_accelerator_win.h"
 
 #pragma warning(push)
 #pragma warning(disable : 4800)  // Disable warning for added padding.
 
 #include <codecapi.h>
 #include <mferror.h>
 #include <mftransform.h>
 
 #include <iterator>
 #include <utility>
 #include <vector>
 
-#include "base/threading/sequenced_task_runner_handle.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "base/win/scoped_co_mem.h"
 #include "base/win/scoped_variant.h"
 #include "base/win/windows_version.h"
 #include "media/base/win/mf_helpers.h"
 #include "media/base/win/mf_initializer.h"
 #include "third_party/libyuv/include/libyuv.h"
 
 using base::win::ScopedComPtr;
 using media::mf::MediaBufferScopedPointer;
@@ skipping 45 matching lines @@
       : id(id), shm(std::move(shm)), size(size) {}
   const int32_t id;
   const std::unique_ptr<base::SharedMemory> shm;
   const size_t size;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(BitstreamBufferRef);
 };
 
 MediaFoundationVideoEncodeAccelerator::MediaFoundationVideoEncodeAccelerator()
-    : client_task_runner_(base::SequencedTaskRunnerHandle::Get()),
+    : main_client_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       encoder_thread_("MFEncoderThread"),
       encoder_task_weak_factory_(this) {}
 
 MediaFoundationVideoEncodeAccelerator::
     ~MediaFoundationVideoEncodeAccelerator() {
   DVLOG(3) << __func__;
-  DCHECK(sequence_checker_.CalledOnValidSequence());
+  DCHECK(main_client_task_runner_->BelongsToCurrentThread());
 
   DCHECK(!encoder_thread_.IsRunning());
   DCHECK(!encoder_task_weak_factory_.HasWeakPtrs());
 }
 
 VideoEncodeAccelerator::SupportedProfiles
 MediaFoundationVideoEncodeAccelerator::GetSupportedProfiles() {
   TRACE_EVENT0("gpu,startup",
                "MediaFoundationVideoEncodeAccelerator::GetSupportedProfiles");
   DVLOG(3) << __func__;
-  DCHECK(sequence_checker_.CalledOnValidSequence());
+  DCHECK(main_client_task_runner_->BelongsToCurrentThread());
 
   SupportedProfiles profiles;
 
   target_bitrate_ = kDefaultTargetBitrate;
   frame_rate_ = kMaxFrameRateNumerator / kMaxFrameRateDenominator;
   input_visible_size_ = gfx::Size(kMaxResolutionWidth, kMaxResolutionHeight);
   if (!CreateHardwareEncoderMFT() || !SetEncoderModes() ||
       !InitializeInputOutputSamples()) {
     ReleaseEncoderResources();
     DVLOG(1)
@@ skipping 16 matching lines @@
 bool MediaFoundationVideoEncodeAccelerator::Initialize(
     VideoPixelFormat format,
     const gfx::Size& input_visible_size,
     VideoCodecProfile output_profile,
     uint32_t initial_bitrate,
     Client* client) {
   DVLOG(3) << __func__ << ": input_format=" << VideoPixelFormatToString(format)
            << ", input_visible_size=" << input_visible_size.ToString()
            << ", output_profile=" << output_profile
            << ", initial_bitrate=" << initial_bitrate;
-  DCHECK(sequence_checker_.CalledOnValidSequence());
+  DCHECK(main_client_task_runner_->BelongsToCurrentThread());
 
   if (PIXEL_FORMAT_I420 != format) {
     DLOG(ERROR) << "Input format not supported= "
                 << VideoPixelFormatToString(format);
     return false;
   }
 
   if (H264PROFILE_BASELINE != output_profile) {
     DLOG(ERROR) << "Output profile not supported= " << output_profile;
     return false;
   }
 
   encoder_thread_.init_com_with_mta(false);
   if (!encoder_thread_.Start()) {
     DLOG(ERROR) << "Failed spawning encoder thread.";
     return false;
   }
   encoder_thread_task_runner_ = encoder_thread_.task_runner();
 
   if (!CreateHardwareEncoderMFT()) {
     DLOG(ERROR) << "Failed creating a hardware encoder MFT.";
     return false;
   }
 
-  client_ptr_factory_.reset(new base::WeakPtrFactory<Client>(client));
-  client_ = client_ptr_factory_->GetWeakPtr();
+  main_client_weak_factory_.reset(new base::WeakPtrFactory<Client>(client));
+  main_client_ = main_client_weak_factory_->GetWeakPtr();
   input_visible_size_ = input_visible_size;
   frame_rate_ = kMaxFrameRateNumerator / kMaxFrameRateDenominator;
   target_bitrate_ = initial_bitrate;
   bitstream_buffer_size_ = input_visible_size.GetArea();
   u_plane_offset_ =
       VideoFrame::PlaneSize(PIXEL_FORMAT_I420, VideoFrame::kYPlane,
                             input_visible_size_)
           .GetArea();
   v_plane_offset_ =
       u_plane_offset_ +
@@ skipping 13 matching lines @@
   }
   input_sample_.Attach(mf::CreateEmptySampleWithBuffer(
       VideoFrame::AllocationSize(PIXEL_FORMAT_I420, input_visible_size_), 2));
   output_sample_.Attach(mf::CreateEmptySampleWithBuffer(
       bitstream_buffer_size_ * kOutputSampleBufferSizeRatio, 2));
 
   HRESULT hr =
       encoder_->ProcessMessage(MFT_MESSAGE_NOTIFY_BEGIN_STREAMING, NULL);
   RETURN_ON_HR_FAILURE(hr, "Couldn't set ProcessMessage", false);
 
-  client_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&Client::RequireBitstreamBuffers, client_, kNumInputBuffers,
-                 input_visible_size_, bitstream_buffer_size_));
+  // Pin all client callbacks to the main task runner initially. It can be
+  // reassigned by TryToSetupEncodeOnSeparateThread().
+  if (!encode_client_task_runner_) {
+    encode_client_task_runner_ = main_client_task_runner_;
+    encode_client_ = main_client_;
+  }
+
+  main_client_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&Client::RequireBitstreamBuffers, main_client_,
+                            kNumInputBuffers, input_visible_size_,
+                            bitstream_buffer_size_));
   return SUCCEEDED(hr);
 }
 
 void MediaFoundationVideoEncodeAccelerator::Encode(
     const scoped_refptr<VideoFrame>& frame,
     bool force_keyframe) {
   DVLOG(3) << __func__;
-  DCHECK(sequence_checker_.CalledOnValidSequence());
+  DCHECK(encode_client_task_runner_->BelongsToCurrentThread());
 
   encoder_thread_task_runner_->PostTask(
       FROM_HERE, base::Bind(&MediaFoundationVideoEncodeAccelerator::EncodeTask,
                             encoder_task_weak_factory_.GetWeakPtr(), frame,
                             force_keyframe));
 }
 
 void MediaFoundationVideoEncodeAccelerator::UseOutputBitstreamBuffer(
     const BitstreamBuffer& buffer) {
   DVLOG(3) << __func__ << ": buffer size=" << buffer.size();
-  DCHECK(sequence_checker_.CalledOnValidSequence());
+  DCHECK(encode_client_task_runner_->BelongsToCurrentThread());
 
   if (buffer.size() < bitstream_buffer_size_) {
     DLOG(ERROR) << "Output BitstreamBuffer isn't big enough: " << buffer.size()
                 << " vs. " << bitstream_buffer_size_;
-    client_->NotifyError(kInvalidArgumentError);
+    NotifyError(kInvalidArgumentError);
     return;
   }
 
   std::unique_ptr<base::SharedMemory> shm(
       new base::SharedMemory(buffer.handle(), false));
   if (!shm->Map(buffer.size())) {
     DLOG(ERROR) << "Failed mapping shared memory.";
-    client_->NotifyError(kPlatformFailureError);
+    NotifyError(kPlatformFailureError);
     return;
   }
 
   std::unique_ptr<BitstreamBufferRef> buffer_ref(
       new BitstreamBufferRef(buffer.id(), std::move(shm), buffer.size()));
   encoder_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(
           &MediaFoundationVideoEncodeAccelerator::UseOutputBitstreamBufferTask,
           encoder_task_weak_factory_.GetWeakPtr(), base::Passed(&buffer_ref)));
 }
 
 void MediaFoundationVideoEncodeAccelerator::RequestEncodingParametersChange(
     uint32_t bitrate,
     uint32_t framerate) {
   DVLOG(3) << __func__ << ": bitrate=" << bitrate
            << ": framerate=" << framerate;
-  DCHECK(sequence_checker_.CalledOnValidSequence());
+  DCHECK(encode_client_task_runner_->BelongsToCurrentThread());
 
   encoder_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&MediaFoundationVideoEncodeAccelerator::
                      RequestEncodingParametersChangeTask,
                  encoder_task_weak_factory_.GetWeakPtr(), bitrate, framerate));
 }
 
 void MediaFoundationVideoEncodeAccelerator::Destroy() {
   DVLOG(3) << __func__;
-  DCHECK(sequence_checker_.CalledOnValidSequence());
+  DCHECK(main_client_task_runner_->BelongsToCurrentThread());
 
   // Cancel all callbacks.
-  client_ptr_factory_.reset();
+  main_client_weak_factory_.reset();
 
   if (encoder_thread_.IsRunning()) {
     encoder_thread_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&MediaFoundationVideoEncodeAccelerator::DestroyTask,
                    encoder_task_weak_factory_.GetWeakPtr()));
     encoder_thread_.Stop();
   }
 
   delete this;
 }
 
+bool MediaFoundationVideoEncodeAccelerator::TryToSetupEncodeOnSeparateThread(
+    const base::WeakPtr<Client>& encode_client,
+    const scoped_refptr<base::SingleThreadTaskRunner>& encode_task_runner) {
+  DVLOG(3) << __func__;
+  DCHECK(main_client_task_runner_->BelongsToCurrentThread());
+  encode_client_ = encode_client;
+  encode_client_task_runner_ = encode_task_runner;
+  return true;
+}
+
 // static
 void MediaFoundationVideoEncodeAccelerator::PreSandboxInitialization() {
   for (const wchar_t* mfdll : kMediaFoundationVideoEncoderDLLs)
     ::LoadLibrary(mfdll);
 }
 
 bool MediaFoundationVideoEncodeAccelerator::CreateHardwareEncoderMFT() {
   DVLOG(3) << __func__;
-  DCHECK(sequence_checker_.CalledOnValidSequence());
+  DCHECK(main_client_task_runner_->BelongsToCurrentThread());
 
   if (base::win::GetVersion() < base::win::VERSION_WIN8) {
     DVLOG(ERROR) << "Windows versions earlier than 8 are not supported.";
     return false;
   }
 
   for (const wchar_t* mfdll : kMediaFoundationVideoEncoderDLLs) {
     if (!::GetModuleHandle(mfdll)) {
       DVLOG(ERROR) << mfdll << " is required for encoding";
       return false;
@@ skipping 16 matching lines @@
                        &output_info, NULL, &CLSIDs, &count);
   RETURN_ON_HR_FAILURE(hr, "Couldn't enumerate hardware encoder", false);
   RETURN_ON_FAILURE((count > 0), "No HW encoder found", false);
   DVLOG(3) << "HW encoder(s) found: " << count;
   hr = encoder_.CreateInstance(CLSIDs[0]);
   RETURN_ON_HR_FAILURE(hr, "Couldn't activate hardware encoder", false);
   return true;
 }
 
 bool MediaFoundationVideoEncodeAccelerator::InitializeInputOutputSamples() {
-  DCHECK(sequence_checker_.CalledOnValidSequence());
+  DCHECK(main_client_task_runner_->BelongsToCurrentThread());
 
   // Initialize output parameters.
   HRESULT hr = MFCreateMediaType(imf_output_media_type_.Receive());
   RETURN_ON_HR_FAILURE(hr, "Couldn't create media type", false);
   hr = imf_output_media_type_->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Video);
   RETURN_ON_HR_FAILURE(hr, "Couldn't set media type", false);
   hr = imf_output_media_type_->SetGUID(MF_MT_SUBTYPE, MFVideoFormat_H264);
   RETURN_ON_HR_FAILURE(hr, "Couldn't set video format", false);
   hr = imf_output_media_type_->SetUINT32(MF_MT_AVG_BITRATE, target_bitrate_);
   RETURN_ON_HR_FAILURE(hr, "Couldn't set bitrate", false);
@@ skipping 30 matching lines @@
   hr = imf_input_media_type_->SetUINT32(MF_MT_INTERLACE_MODE,
                                         MFVideoInterlace_Progressive);
   RETURN_ON_HR_FAILURE(hr, "Couldn't set interlace mode", false);
   hr = encoder_->SetInputType(0, imf_input_media_type_.get(), 0);
   RETURN_ON_HR_FAILURE(hr, "Couldn't set input media type", false);
 
   return SUCCEEDED(hr);
 }
 
 bool MediaFoundationVideoEncodeAccelerator::SetEncoderModes() {
-  DCHECK(sequence_checker_.CalledOnValidSequence());
+  DCHECK(main_client_task_runner_->BelongsToCurrentThread());
 
   HRESULT hr = encoder_.QueryInterface(IID_ICodecAPI, codec_api_.ReceiveVoid());
   RETURN_ON_HR_FAILURE(hr, "Couldn't get ICodecAPI", false);
   VARIANT var;
   var.vt = VT_UI4;
   var.ulVal = eAVEncCommonRateControlMode_CBR;
   hr = codec_api_->SetValue(&CODECAPI_AVEncCommonRateControlMode, &var);
   RETURN_ON_HR_FAILURE(hr, "Couldn't set CommonRateControlMode", false);
   var.ulVal = target_bitrate_;
   hr = codec_api_->SetValue(&CODECAPI_AVEncCommonMeanBitRate, &var);
   RETURN_ON_HR_FAILURE(hr, "Couldn't set bitrate", false);
   var.ulVal = eAVEncAdaptiveMode_FrameRate;
   hr = codec_api_->SetValue(&CODECAPI_AVEncAdaptiveMode, &var);
   RETURN_ON_HR_FAILURE(hr, "Couldn't set FrameRate", false);
   var.vt = VT_BOOL;
   var.boolVal = VARIANT_TRUE;
   hr = codec_api_->SetValue(&CODECAPI_AVLowLatencyMode, &var);
   RETURN_ON_HR_FAILURE(hr, "Couldn't set LowLatencyMode", false);
   return SUCCEEDED(hr);
 }
 
 void MediaFoundationVideoEncodeAccelerator::NotifyError(
     VideoEncodeAccelerator::Error error) {
   DCHECK(encoder_thread_task_runner_->BelongsToCurrentThread());
-  client_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&Client::NotifyError, client_, error));
+  main_client_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&Client::NotifyError, main_client_, error));
 }
 
 void MediaFoundationVideoEncodeAccelerator::EncodeTask(
     scoped_refptr<VideoFrame> frame,
     bool force_keyframe) {
   DVLOG(3) << __func__;
   DCHECK(encoder_thread_task_runner_->BelongsToCurrentThread());
 
   base::win::ScopedComPtr<IMFMediaBuffer> input_buffer;
   input_sample_->GetBufferByIndex(0, input_buffer.Receive());
@@ skipping 96 matching lines @@
 
   std::unique_ptr<MediaFoundationVideoEncodeAccelerator::BitstreamBufferRef>
       buffer_ref = std::move(bitstream_buffer_queue_.front());
   bitstream_buffer_queue_.pop_front();
 
   {
     MediaBufferScopedPointer scoped_buffer(output_buffer.get());
     memcpy(buffer_ref->shm->memory(), scoped_buffer.get(), size);
   }
 
-  client_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&Client::BitstreamBufferReady, client_,
+  encode_client_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&Client::BitstreamBufferReady, encode_client_,
                             buffer_ref->id, size, keyframe, timestamp));
 
   // Keep calling ProcessOutput recursively until MF_E_TRANSFORM_NEED_MORE_INPUT
   // is returned to flush out all the output.
   ProcessOutput();
 }
 
 void MediaFoundationVideoEncodeAccelerator::UseOutputBitstreamBufferTask(
     std::unique_ptr<BitstreamBufferRef> buffer_ref) {
   DVLOG(3) << __func__;
@@ skipping 13 matching lines @@
 
 void MediaFoundationVideoEncodeAccelerator::ReturnBitstreamBuffer(
     std::unique_ptr<EncodeOutput> encode_output,
     std::unique_ptr<MediaFoundationVideoEncodeAccelerator::BitstreamBufferRef>
         buffer_ref) {
   DVLOG(3) << __func__;
   DCHECK(encoder_thread_task_runner_->BelongsToCurrentThread());
 
   memcpy(buffer_ref->shm->memory(), encode_output->memory(),
          encode_output->size());
-  client_task_runner_->PostTask(
+  encode_client_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&Client::BitstreamBufferReady, client_, buffer_ref->id,
+      base::Bind(&Client::BitstreamBufferReady, encode_client_, buffer_ref->id,
                  encode_output->size(), encode_output->keyframe,
                  encode_output->capture_timestamp));
 }
 
 void MediaFoundationVideoEncodeAccelerator::RequestEncodingParametersChangeTask(
     uint32_t bitrate,
     uint32_t framerate) {
   DVLOG(3) << __func__;
   DCHECK(encoder_thread_task_runner_->BelongsToCurrentThread());
 
@@ skipping 26 matching lines @@
 void MediaFoundationVideoEncodeAccelerator::ReleaseEncoderResources() {
   encoder_.Release();
   codec_api_.Release();
   imf_input_media_type_.Release();
   imf_output_media_type_.Release();
   input_sample_.Release();
   output_sample_.Release();
 }
 
 }  // namespace content