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>
@@ skipping 70 matching lines @@
 };
 
 MediaFoundationVideoEncodeAccelerator::MediaFoundationVideoEncodeAccelerator()
     : client_task_runner_(base::SequencedTaskRunnerHandle::Get()),
       encoder_thread_("MFEncoderThread"),
       encoder_task_weak_factory_(this) {}
 
 MediaFoundationVideoEncodeAccelerator::
     ~MediaFoundationVideoEncodeAccelerator() {
   DVLOG(3) << __func__;
-  DCHECK(sequence_checker_.CalledOnValidSequence());
+  DCHECK(thread_checker_.CalledOnValidThread());
 
   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(thread_checker_.CalledOnValidThread());
 
   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(thread_checker_.CalledOnValidThread());
 
   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;
@@ skipping 66 matching lines @@
 }
 
 void MediaFoundationVideoEncodeAccelerator::UseOutputBitstreamBuffer(
     const BitstreamBuffer& buffer) {
   DVLOG(3) << __func__ << ": buffer size=" << buffer.size();
   DCHECK(sequence_checker_.CalledOnValidSequence());
 
   if (buffer.size() < bitstream_buffer_size_) {
     DLOG(ERROR) << "Output BitstreamBuffer isn't big enough: " << buffer.size()
                 << " vs. " << bitstream_buffer_size_;
     client_->NotifyError(kInvalidArgumentError);

[Pawel Osciak, 2016/10/25 01:44:05]

client_ is a WeakPtr, so we should always if (client_) first, here and in other
places, if dereferencing.

[emircan, 2016/10/25 21:57:51]

Done.

     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);
     return;
   }
@@ skipping 16 matching lines @@
 
   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(thread_checker_.CalledOnValidThread());
 
   // Cancel all callbacks.
   client_ptr_factory_.reset();
+  client_.reset();

[Pawel Osciak, 2016/10/25 01:44:05]

Hm, do we need to InvalidateWeakPtrs() on factory instead?

[emircan, 2016/10/25 21:57:51]

It already gets invalidated from GPUVEA's OnWillDestroyStub sequence. I will add
a comment to explain it here. I cannot use DCHECK(!client_) though as it is on a
different thread. I added this reset to be explicit.

[Pawel Osciak, 2016/10/27 01:45:19]

In that case I feel InvalidateWeakPtrs() is more explicitly saying what we want
to do...

 
   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(thread_checker_.CalledOnValidThread());
+  client_ = encode_client;
+  client_task_runner_ = encode_task_runner;
+  sequence_checker_.DetachFromSequence();
+  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(thread_checker_.CalledOnValidThread());
 
   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(thread_checker_.CalledOnValidThread());
 
   // 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(thread_checker_.CalledOnValidThread());
 
   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);
@@ skipping 206 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