Rename ScopedComPtr::get() to ScopedComPtr::Get()

media/gpu/d3d11_h264_accelerator.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/d3d11_h264_accelerator.h"
 
 #include <d3d11.h>
 #include <dxva.h>
 #include <windows.h>
 
@@ skipping 30 matching lines @@
     base::win::ScopedComPtr<ID3D11VideoDevice> video_device,
     base::win::ScopedComPtr<ID3D11Texture2D> texture,
     const GUID& decoder_guid) {
   texture_ = texture;
   D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC view_desc = {};
   view_desc.DecodeProfile = decoder_guid;
   view_desc.ViewDimension = D3D11_VDOV_DIMENSION_TEXTURE2D;
   view_desc.Texture2D.ArraySlice = (UINT)level_;
 
   HRESULT hr = video_device->CreateVideoDecoderOutputView(
-      texture.get(), &view_desc, output_view_.Receive());
+      texture.Get(), &view_desc, output_view_.Receive());
 
   CHECK(SUCCEEDED(hr));
   EGLDisplay egl_display = gl::GLSurfaceEGL::GetHardwareDisplay();
   const EGLint stream_attributes[] = {
       EGL_CONSUMER_LATENCY_USEC_KHR,
       0,
       EGL_CONSUMER_ACQUIRE_TIMEOUT_USEC_KHR,
       0,
       EGL_NONE,
   };
@@ skipping 26 matching lines @@
   };
 
   result = eglCreateStreamProducerD3DTextureNV12ANGLE(egl_display, stream_,
                                                       producer_attributes);
 
   EGLAttrib frame_attributes[] = {
       EGL_D3D_TEXTURE_SUBRESOURCE_ID_ANGLE, level_, EGL_NONE,
   };
 
   result = eglStreamPostD3DTextureNV12ANGLE(egl_display, stream_,
-                                            static_cast<void*>(texture.get()),
+                                            static_cast<void*>(texture.Get()),
                                             frame_attributes);
   RETURN_ON_FAILURE(result, "Could not post texture", false);
   result = eglStreamConsumerAcquireKHR(egl_display, stream_);
   RETURN_ON_FAILURE(result, "Could not post acquire stream", false);
   return true;
 }
 
 class D3D11H264Picture : public H264Picture {
  public:
   D3D11H264Picture(D3D11PictureBuffer* picture, size_t input_buffer_id)
@@ skipping 37 matching lines @@
     const H264DPB& dpb,
     const H264Picture::Vector& ref_pic_listp0,
     const H264Picture::Vector& ref_pic_listb0,
     const H264Picture::Vector& ref_pic_listb1,
     const scoped_refptr<H264Picture>& pic) {
   scoped_refptr<D3D11H264Picture> our_pic(
       static_cast<D3D11H264Picture*>(pic.get()));
 
   HRESULT hr;
   hr = video_context_->DecoderBeginFrame(
-      video_decoder_.get(), our_pic->picture->output_view_.get(), 0, nullptr);
+      video_decoder_.Get(), our_pic->picture->output_view_.Get(), 0, nullptr);
   CHECK(SUCCEEDED(hr));
 
   sps_ = *sps;
   for (size_t i = 0; i < 16; i++) {
     ref_frame_list_[i].bPicEntry = 0xFF;
     field_order_cnt_list_[i][0] = 0;
     field_order_cnt_list_[i][1] = 0;
     frame_num_list_[i] = 0;
   }
   used_for_reference_flags_ = 0;
@@ skipping 23 matching lines @@
   slice_info_.clear();
   RetrieveBitstreamBuffer();
   return true;
 }
 
 void D3D11H264Accelerator::RetrieveBitstreamBuffer() {
   current_offset_ = 0;
   void* buffer;
   UINT buffer_size;
   HRESULT hr = video_context_->GetDecoderBuffer(
-      video_decoder_.get(), D3D11_VIDEO_DECODER_BUFFER_BITSTREAM, &buffer_size,
+      video_decoder_.Get(), D3D11_VIDEO_DECODER_BUFFER_BITSTREAM, &buffer_size,
       &buffer);
   bitstream_buffer_bytes_ = (uint8_t*)buffer;
   bitstream_buffer_size_ = buffer_size;
   CHECK(SUCCEEDED(hr));
 }
 
 bool D3D11H264Accelerator::SubmitSlice(const H264PPS* pps,
                                        const H264SliceHeader* slice_hdr,
                                        const H264Picture::Vector& ref_pic_list0,
                                        const H264Picture::Vector& ref_pic_list1,
@@ skipping 80 matching lines @@
   // UNUSED: slice_group_change_rate
   //
   //
   //
 
   pic_param.StatusReportFeedbackNumber = 1;
 
   UINT buffer_size;
   void* buffer;
   HRESULT hr = video_context_->GetDecoderBuffer(
-      video_decoder_.get(), D3D11_VIDEO_DECODER_BUFFER_PICTURE_PARAMETERS,
+      video_decoder_.Get(), D3D11_VIDEO_DECODER_BUFFER_PICTURE_PARAMETERS,
       &buffer_size, &buffer);
   CHECK(SUCCEEDED(hr));
 
   memcpy(buffer, &pic_param, sizeof(pic_param));
   hr = video_context_->ReleaseDecoderBuffer(
-      video_decoder_.get(), D3D11_VIDEO_DECODER_BUFFER_PICTURE_PARAMETERS);
+      video_decoder_.Get(), D3D11_VIDEO_DECODER_BUFFER_PICTURE_PARAMETERS);
   CHECK(SUCCEEDED(hr));
 
   DXVA_Qmatrix_H264 iq_matrix_buf = {};
 
   if (pps->pic_scaling_matrix_present_flag) {
     for (int i = 0; i < 6; ++i) {
       for (int j = 0; j < 16; ++j)
         iq_matrix_buf.bScalingLists4x4[i][j] = pps->scaling_list4x4[i][j];
     }
 
     for (int i = 0; i < 2; ++i) {
       for (int j = 0; j < 64; ++j)
         iq_matrix_buf.bScalingLists8x8[i][j] = pps->scaling_list8x8[i][j];
     }
   } else {
     for (int i = 0; i < 6; ++i) {
       for (int j = 0; j < 16; ++j)
         iq_matrix_buf.bScalingLists4x4[i][j] = sps_.scaling_list4x4[i][j];
     }
 
     for (int i = 0; i < 2; ++i) {
       for (int j = 0; j < 64; ++j)
         iq_matrix_buf.bScalingLists8x8[i][j] = sps_.scaling_list8x8[i][j];
     }
   }
   hr = video_context_->GetDecoderBuffer(
-      video_decoder_.get(),
+      video_decoder_.Get(),
       D3D11_VIDEO_DECODER_BUFFER_INVERSE_QUANTIZATION_MATRIX, &buffer_size,
       &buffer);
   CHECK(SUCCEEDED(hr));
   memcpy(buffer, &iq_matrix_buf, sizeof(iq_matrix_buf));
   hr = video_context_->ReleaseDecoderBuffer(
-      video_decoder_.get(),
+      video_decoder_.Get(),
       D3D11_VIDEO_DECODER_BUFFER_INVERSE_QUANTIZATION_MATRIX);
 
   // Ideally all slices in a frame are put in the same bitstream buffer.
   // However the bitstream buffer may not fit all the data, so split on the
   // necessary boundaries.
 
   size_t out_bitstream_size = size + 3;
 
   size_t remaining_bitstream = out_bitstream_size;
   size_t start_location = 0;
@@ skipping 43 matching lines @@
   }
 
   return true;
 }
 
 void D3D11H264Accelerator::SubmitSliceData() {
   CHECK(slice_info_.size() > 0);
   UINT buffer_size;
   void* buffer;
   HRESULT hr = video_context_->GetDecoderBuffer(
-      video_decoder_.get(), D3D11_VIDEO_DECODER_BUFFER_SLICE_CONTROL,
+      video_decoder_.Get(), D3D11_VIDEO_DECODER_BUFFER_SLICE_CONTROL,
       &buffer_size, &buffer);
   CHECK(SUCCEEDED(hr));
   CHECK_LE(sizeof(slice_info_[0]) * slice_info_.size(), buffer_size);
   memcpy(buffer, &slice_info_[0], sizeof(slice_info_[0]) * slice_info_.size());
   hr = video_context_->ReleaseDecoderBuffer(
-      video_decoder_.get(), D3D11_VIDEO_DECODER_BUFFER_SLICE_CONTROL);
+      video_decoder_.Get(), D3D11_VIDEO_DECODER_BUFFER_SLICE_CONTROL);
 
   hr = video_context_->ReleaseDecoderBuffer(
-      video_decoder_.get(), D3D11_VIDEO_DECODER_BUFFER_BITSTREAM);
+      video_decoder_.Get(), D3D11_VIDEO_DECODER_BUFFER_BITSTREAM);
   D3D11_VIDEO_DECODER_BUFFER_DESC buffers[4] = {};
   buffers[0].BufferType = D3D11_VIDEO_DECODER_BUFFER_PICTURE_PARAMETERS;
   buffers[0].DataOffset = 0;
   buffers[0].DataSize = sizeof(DXVA_PicParams_H264);
   buffers[1].BufferType =
       D3D11_VIDEO_DECODER_BUFFER_INVERSE_QUANTIZATION_MATRIX;
   buffers[1].DataOffset = 0;
   buffers[1].DataSize = sizeof(DXVA_Qmatrix_H264);
   buffers[2].BufferType = D3D11_VIDEO_DECODER_BUFFER_SLICE_CONTROL;
   buffers[2].DataOffset = 0;
   buffers[2].DataSize = (UINT)(sizeof(slice_info_[0]) * slice_info_.size());
   buffers[3].BufferType = D3D11_VIDEO_DECODER_BUFFER_BITSTREAM;
   buffers[3].DataOffset = 0;
   buffers[3].DataSize = (UINT)current_offset_;
 
-  hr = video_context_->SubmitDecoderBuffers(video_decoder_.get(), 4, buffers);
+  hr = video_context_->SubmitDecoderBuffers(video_decoder_.Get(), 4, buffers);
   current_offset_ = 0;
   slice_info_.clear();
 }
 
 bool D3D11H264Accelerator::SubmitDecode(const scoped_refptr<H264Picture>& pic) {
   SubmitSliceData();
 
-  HRESULT hr = video_context_->DecoderEndFrame(video_decoder_.get());
+  HRESULT hr = video_context_->DecoderEndFrame(video_decoder_.Get());
   CHECK(SUCCEEDED(hr));
 
   return true;
 }
 
 bool D3D11H264Accelerator::OutputPicture(
     const scoped_refptr<H264Picture>& pic) {
   scoped_refptr<D3D11H264Picture> our_pic(
       static_cast<D3D11H264Picture*>(pic.get()));
   client_->OutputResult(our_pic->picture, our_pic->input_buffer_id_);
   return true;
 }
 
 D3D11H264Picture::~D3D11H264Picture() {
   picture->set_in_picture_use(false);
 }
 
 }  // namespace media