[dxvavda] Convert more users of IMFSample* to ScopedComPtr

media/gpu/dxva_video_decode_accelerator_win.cc

 // Copyright (c) 2012 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/dxva_video_decode_accelerator_win.h"
 
 #include <memory>
 
 #if !defined(OS_WIN)
 #error This file should only be built on Windows.
@@ skipping 267 matching lines @@
   // The keyed mutex should always be released before the other thread
   // attempts to acquire it, so AcquireSync should always return immediately.
   kAcquireSyncWaitMs = 0,
 };
 
 // Creates a Media Foundation sample with one buffer containing a copy of the
 // given Annex B stream data.
 // If duration and sample time are not known, provide 0.
 // |min_size| specifies the minimum size of the buffer (might be required by
 // the decoder for input). If no alignment is required, provide 0.
-static IMFSample* CreateInputSample(const uint8_t* stream,
-                                    uint32_t size,
-                                    uint32_t min_size,
-                                    int alignment) {
+static base::win::ScopedComPtr<IMFSample> CreateInputSample(
+    const uint8_t* stream,
+    uint32_t size,
+    uint32_t min_size,
+    int alignment) {
   CHECK(stream);
   CHECK_GT(size, 0U);
   base::win::ScopedComPtr<IMFSample> sample;
-  sample.Attach(
-      mf::CreateEmptySampleWithBuffer(std::max(min_size, size), alignment));
-  RETURN_ON_FAILURE(sample.get(), "Failed to create empty sample", NULL);
+  sample = mf::CreateEmptySampleWithBuffer(std::max(min_size, size), alignment);
+  RETURN_ON_FAILURE(sample.get(), "Failed to create empty sample",
+                    base::win::ScopedComPtr<IMFSample>());
 
   base::win::ScopedComPtr<IMFMediaBuffer> buffer;
   HRESULT hr = sample->GetBufferByIndex(0, buffer.Receive());
-  RETURN_ON_HR_FAILURE(hr, "Failed to get buffer from sample", NULL);
+  RETURN_ON_HR_FAILURE(hr, "Failed to get buffer from sample",
+                       base::win::ScopedComPtr<IMFSample>());
 
   DWORD max_length = 0;
   DWORD current_length = 0;
   uint8_t* destination = NULL;
   hr = buffer->Lock(&destination, &max_length, &current_length);
-  RETURN_ON_HR_FAILURE(hr, "Failed to lock buffer", NULL);
+  RETURN_ON_HR_FAILURE(hr, "Failed to lock buffer",
+                       base::win::ScopedComPtr<IMFSample>());
 
   CHECK_EQ(current_length, 0u);
   CHECK_GE(max_length, size);
   memcpy(destination, stream, size);
 
   hr = buffer->SetCurrentLength(size);
-  RETURN_ON_HR_FAILURE(hr, "Failed to set buffer length", NULL);
+  RETURN_ON_HR_FAILURE(hr, "Failed to set buffer length",
+                       base::win::ScopedComPtr<IMFSample>());
 
   hr = buffer->Unlock();
-  RETURN_ON_HR_FAILURE(hr, "Failed to unlock buffer", NULL);
+  RETURN_ON_HR_FAILURE(hr, "Failed to unlock buffer",
+                       base::win::ScopedComPtr<IMFSample>());
 
-  return sample.Detach();
+  return sample;
 }
 
 // Helper function to create a COM object instance from a DLL. The alternative
 // is to use the CoCreateInstance API which requires the COM apartment to be
 // initialized which is not the case on the GPU main thread. We want to avoid
 // initializing COM as it may have sideeffects.
 HRESULT CreateCOMObjectFromDll(HMODULE dll,
                                const CLSID& clsid,
                                const IID& iid,
                                void** object) {
@@ skipping 129 matching lines @@
     return gfx::ColorSpace();
   // TODO(hubbe): Is using last_sps_id_ correct here?
   const H264SPS* sps = parser_->GetSPS(last_sps_id_);
   if (sps)
     return sps->GetColorSpace();
   return gfx::ColorSpace();
 }
 
 DXVAVideoDecodeAccelerator::PendingSampleInfo::PendingSampleInfo(
     int32_t buffer_id,
-    IMFSample* sample,
+    base::win::ScopedComPtr<IMFSample> sample,
     const gfx::ColorSpace& color_space)
     : input_buffer_id(buffer_id),
       picture_buffer_id(-1),
-      color_space(color_space) {
-  output_sample.Attach(sample);
-}
+      color_space(color_space),
+      output_sample(sample) {}
 
 DXVAVideoDecodeAccelerator::PendingSampleInfo::PendingSampleInfo(
     const PendingSampleInfo& other) = default;
 
 DXVAVideoDecodeAccelerator::PendingSampleInfo::~PendingSampleInfo() {}
 
 DXVAVideoDecodeAccelerator::DXVAVideoDecodeAccelerator(
     const GetGLContextCallback& get_gl_context_cb,
     const MakeGLContextCurrentCallback& make_context_current_cb,
     const BindGLImageCallback& bind_image_cb,
@@ skipping 435 matching lines @@
     if (client_)
       client_->NotifyEndOfBitstreamBuffer(bitstream_buffer.id());
     return;
   }
 
   base::win::ScopedComPtr<IMFSample> sample;
   RETURN_AND_NOTIFY_ON_FAILURE(shm.Map(bitstream_buffer.size()),
                                "Failed in base::SharedMemory::Map",
                                PLATFORM_FAILURE, );
 
-  sample.Attach(CreateInputSample(
+  sample = CreateInputSample(
       reinterpret_cast<const uint8_t*>(shm.memory()), bitstream_buffer.size(),
       std::min<uint32_t>(bitstream_buffer.size(), input_stream_info_.cbSize),
-      input_stream_info_.cbAlignment));
+      input_stream_info_.cbAlignment);
   RETURN_AND_NOTIFY_ON_FAILURE(sample.get(), "Failed to create input sample",
                                PLATFORM_FAILURE, );
 
   RETURN_AND_NOTIFY_ON_HR_FAILURE(
       sample->SetSampleTime(bitstream_buffer.id()),
       "Failed to associate input buffer id with sample", PLATFORM_FAILURE, );
 
   decoder_thread_task_runner_->PostTask(
       FROM_HERE, base::Bind(&DXVAVideoDecodeAccelerator::DecodeInternal,
                             base::Unretained(this), sample));
@@ skipping 798 matching lines @@
     g_last_process_output_time = GetCurrentQPC();
     hr = decoder_->ProcessOutput(0,  // No flags
                                  1,  // # of out streams to pull from
                                  &output_data_buffer, &status);
   }
   IMFCollection* events = output_data_buffer.pEvents;
   if (events != NULL) {
     DVLOG(1) << "Got events from ProcessOuput, but discarding";
     events->Release();
   }
+  base::win::ScopedComPtr<IMFSample> output_sample;
+  output_sample.Attach(output_data_buffer.pSample);
   if (FAILED(hr)) {
     // A stream change needs further ProcessInput calls to get back decoder
     // output which is why we need to set the state to stopped.
     if (hr == MF_E_TRANSFORM_STREAM_CHANGE) {
       if (!SetDecoderOutputMediaType(MFVideoFormat_NV12) &&
           !SetDecoderOutputMediaType(MFVideoFormat_P010)) {
         // Decoder didn't let us set NV12 output format. Not sure as to why
         // this can happen. Give up in disgust.
         NOTREACHED() << "Failed to set decoder output media type to NV12";
         SetState(kStopped);
@@ skipping 13 matching lines @@
       return;
     }
   }
   TRACE_EVENT_ASYNC_END0("gpu", "DXVAVideoDecodeAccelerator.Decoding", this);
 
   TRACE_COUNTER1("DXVA Decoding", "TotalPacketsBeforeDecode",
                  inputs_before_decode_);
 
   inputs_before_decode_ = 0;
 
-  RETURN_AND_NOTIFY_ON_FAILURE(
-      ProcessOutputSample(output_data_buffer.pSample, color_space),
-      "Failed to process output sample.", PLATFORM_FAILURE, );
+  RETURN_AND_NOTIFY_ON_FAILURE(ProcessOutputSample(output_sample, color_space),
+                               "Failed to process output sample.",
+                               PLATFORM_FAILURE, );
 }
 
 bool DXVAVideoDecodeAccelerator::ProcessOutputSample(
-    IMFSample* sample,
+    base::win::ScopedComPtr<IMFSample> sample,
     const gfx::ColorSpace& color_space) {
   RETURN_ON_FAILURE(sample, "Decode succeeded with NULL output sample", false);
 
   LONGLONG input_buffer_id = 0;
   RETURN_ON_HR_FAILURE(sample->GetSampleTime(&input_buffer_id),
                        "Failed to get input buffer id associated with sample",
                        false);
 
   {
     base::AutoLock lock(decoder_lock_);
     DCHECK(pending_output_samples_.empty());
     pending_output_samples_.push_back(
         PendingSampleInfo(input_buffer_id, sample, color_space));
   }
 
   if (pictures_requested_) {
     DVLOG(1) << "Waiting for picture slots from the client.";
     main_thread_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&DXVAVideoDecodeAccelerator::ProcessPendingSamples,
                    weak_ptr_));
     return true;
   }
 
   int width = 0;
   int height = 0;
-  if (!GetVideoFrameDimensions(sample, &width, &height)) {
+  if (!GetVideoFrameDimensions(sample.get(), &width, &height)) {
     RETURN_ON_FAILURE(false, "Failed to get D3D surface from output sample",
                       false);
   }
 
   // Go ahead and request picture buffers.
   main_thread_task_runner_->PostTask(
       FROM_HERE, base::Bind(&DXVAVideoDecodeAccelerator::RequestPictureBuffers,
                             weak_ptr_, width, height));
 
   pictures_requested_ = true;
@@ skipping 743 matching lines @@
   {
     base::AutoLock lock(decoder_lock_);
     PendingSampleInfo& sample_info = pending_output_samples_.front();
     input_sample_for_conversion = sample_info.output_sample;
   }
 
   decoder_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&DXVAVideoDecodeAccelerator::CopyTextureOnDecoderThread,
                  base::Unretained(this), dest_texture, dest_keyed_mutex,
-                 keyed_mutex_value, input_sample_for_conversion.Detach(),
+                 keyed_mutex_value, input_sample_for_conversion,
                  picture_buffer_id, input_buffer_id));
 }
 
 void DXVAVideoDecodeAccelerator::CopyTextureOnDecoderThread(
     ID3D11Texture2D* dest_texture,
     base::win::ScopedComPtr<IDXGIKeyedMutex> dest_keyed_mutex,
     uint64_t keyed_mutex_value,
-    IMFSample* video_frame,
+    base::win::ScopedComPtr<IMFSample> input_sample,
     int picture_buffer_id,
     int input_buffer_id) {
   TRACE_EVENT0("media",
                "DXVAVideoDecodeAccelerator::CopyTextureOnDecoderThread");
   DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
   HRESULT hr = E_FAIL;
 
   DCHECK(use_dx11_);
-  DCHECK(video_frame);
-
-  base::win::ScopedComPtr<IMFSample> input_sample;
-  input_sample.Attach(video_frame);
-
+  DCHECK(!!input_sample);
   DCHECK(video_format_converter_mft_.get());
 
   if (dest_keyed_mutex) {
     HRESULT hr =
         dest_keyed_mutex->AcquireSync(keyed_mutex_value, kAcquireSyncWaitMs);
     RETURN_AND_NOTIFY_ON_FAILURE(
         hr == S_OK, "D3D11 failed to acquire keyed mutex for texture.",
         PLATFORM_FAILURE, );
   }
   // The video processor MFT requires output samples to be allocated by the
@@ skipping 11 matching lines @@
   base::win::ScopedComPtr<IMFMediaBuffer> output_buffer;
   hr = MFCreateDXGISurfaceBuffer(__uuidof(ID3D11Texture2D), dest_texture, 0,
                                  FALSE, output_buffer.Receive());
   if (FAILED(hr)) {
     RETURN_AND_NOTIFY_ON_HR_FAILURE(hr, "Failed to create output sample.",
                                     PLATFORM_FAILURE, );
   }
 
   output_sample->AddBuffer(output_buffer.get());
 
-  hr = video_format_converter_mft_->ProcessInput(0, video_frame, 0);
+  hr = video_format_converter_mft_->ProcessInput(0, input_sample.get(), 0);
   if (FAILED(hr)) {
     DCHECK(false);
     RETURN_AND_NOTIFY_ON_HR_FAILURE(
         hr, "Failed to convert output sample format.", PLATFORM_FAILURE, );
   }
 
+  input_sample.Release();
+
   DWORD status = 0;
   MFT_OUTPUT_DATA_BUFFER format_converter_output = {};
   format_converter_output.pSample = output_sample.get();
   hr = video_format_converter_mft_->ProcessOutput(
       0,  // No flags
       1,  // # of out streams to pull from
       &format_converter_output, &status);
 
   if (FAILED(hr)) {
     DCHECK(false);
@@ skipping 260 matching lines @@
       base::Bind(&DXVAVideoDecodeAccelerator::DecodePendingInputBuffers,
                  base::Unretained(this)));
 }
 
 uint32_t DXVAVideoDecodeAccelerator::GetTextureTarget() const {
   bool provide_nv12_textures = share_nv12_textures_ || copy_nv12_textures_;
   return provide_nv12_textures ? GL_TEXTURE_EXTERNAL_OES : GL_TEXTURE_2D;
 }
 
 }  // namespace media