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

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 339 matching lines @@
 
   base::win::ScopedCoMem<CLSID> CLSIDs;
   uint32_t count = 0;
   HRESULT hr = MFTEnum(MFT_CATEGORY_VIDEO_ENCODER, flags, &input_info,
                        &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_ON_FAILURE((encoder_.get() != nullptr),
+  RETURN_ON_FAILURE((encoder_.Get() != nullptr),
                     "No HW encoder instance created", false);
   return true;
 }
 
 bool MediaFoundationVideoEncodeAccelerator::InitializeInputOutputSamples() {
   DCHECK(main_client_task_runner_->BelongsToCurrentThread());
 
   DWORD input_count = 0;
   DWORD output_count = 0;
   HRESULT hr = encoder_->GetStreamCount(&input_count, &output_count);
@@ skipping 21 matching lines @@
 
   // Initialize output parameters.
   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);
-  hr = MFSetAttributeRatio(imf_output_media_type_.get(), MF_MT_FRAME_RATE,
+  hr = MFSetAttributeRatio(imf_output_media_type_.Get(), MF_MT_FRAME_RATE,
                            frame_rate_, 1);
   RETURN_ON_HR_FAILURE(hr, "Couldn't set frame rate", false);
-  hr = MFSetAttributeSize(imf_output_media_type_.get(), MF_MT_FRAME_SIZE,
+  hr = MFSetAttributeSize(imf_output_media_type_.Get(), MF_MT_FRAME_SIZE,
                           input_visible_size_.width(),
                           input_visible_size_.height());
   RETURN_ON_HR_FAILURE(hr, "Couldn't set frame size", false);
   hr = imf_output_media_type_->SetUINT32(MF_MT_INTERLACE_MODE,
                                          MFVideoInterlace_Progressive);
   RETURN_ON_HR_FAILURE(hr, "Couldn't set interlace mode", false);
   hr = imf_output_media_type_->SetUINT32(MF_MT_MPEG2_PROFILE,
                                          eAVEncH264VProfile_Base);
   RETURN_ON_HR_FAILURE(hr, "Couldn't set codec profile", false);
-  hr = encoder_->SetOutputType(output_stream_id_, imf_output_media_type_.get(),
+  hr = encoder_->SetOutputType(output_stream_id_, imf_output_media_type_.Get(),
                                0);
   RETURN_ON_HR_FAILURE(hr, "Couldn't set output media type", false);
 
   // Initialize input parameters.
   hr = MFCreateMediaType(imf_input_media_type_.Receive());
   RETURN_ON_HR_FAILURE(hr, "Couldn't create media type", false);
   hr = imf_input_media_type_->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Video);
   RETURN_ON_HR_FAILURE(hr, "Couldn't set media type", false);
   hr = imf_input_media_type_->SetGUID(MF_MT_SUBTYPE, MFVideoFormat_YV12);
   RETURN_ON_HR_FAILURE(hr, "Couldn't set video format", false);
-  hr = MFSetAttributeRatio(imf_input_media_type_.get(), MF_MT_FRAME_RATE,
+  hr = MFSetAttributeRatio(imf_input_media_type_.Get(), MF_MT_FRAME_RATE,
                            frame_rate_, 1);
   RETURN_ON_HR_FAILURE(hr, "Couldn't set frame rate", false);
-  hr = MFSetAttributeSize(imf_input_media_type_.get(), MF_MT_FRAME_SIZE,
+  hr = MFSetAttributeSize(imf_input_media_type_.Get(), MF_MT_FRAME_SIZE,
                           input_visible_size_.width(),
                           input_visible_size_.height());
   RETURN_ON_HR_FAILURE(hr, "Couldn't set frame size", false);
   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(input_stream_id_, imf_input_media_type_.get(), 0);
+  hr = encoder_->SetInputType(input_stream_id_, 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(main_client_task_runner_->BelongsToCurrentThread());
-  RETURN_ON_FAILURE((encoder_.get() != nullptr),
+  RETURN_ON_FAILURE((encoder_.Get() != nullptr),
                     "No HW encoder instance created", false);
 
   HRESULT hr = encoder_.QueryInterface(codec_api_.Receive());
   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_Resolution;
   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);
 }
 
 bool MediaFoundationVideoEncodeAccelerator::IsResolutionSupported(
     const gfx::Size& resolution) {
   DCHECK(main_client_task_runner_->BelongsToCurrentThread());
   DCHECK(encoder_);
 
   HRESULT hr =
-      MFSetAttributeSize(imf_output_media_type_.get(), MF_MT_FRAME_SIZE,
+      MFSetAttributeSize(imf_output_media_type_.Get(), MF_MT_FRAME_SIZE,
                          resolution.width(), resolution.height());
   RETURN_ON_HR_FAILURE(hr, "Couldn't set frame size", false);
-  hr = encoder_->SetOutputType(output_stream_id_, imf_output_media_type_.get(),
+  hr = encoder_->SetOutputType(output_stream_id_, imf_output_media_type_.Get(),
                                0);
   RETURN_ON_HR_FAILURE(hr, "Couldn't set output media type", false);
 
-  hr = MFSetAttributeSize(imf_input_media_type_.get(), MF_MT_FRAME_SIZE,
+  hr = MFSetAttributeSize(imf_input_media_type_.Get(), MF_MT_FRAME_SIZE,
                           resolution.width(), resolution.height());
   RETURN_ON_HR_FAILURE(hr, "Couldn't set frame size", false);
-  hr = encoder_->SetInputType(input_stream_id_, imf_input_media_type_.get(), 0);
+  hr = encoder_->SetInputType(input_stream_id_, imf_input_media_type_.Get(), 0);
   RETURN_ON_HR_FAILURE(hr, "Couldn't set input media type", false);
 
   return true;
 }
 
 void MediaFoundationVideoEncodeAccelerator::NotifyError(
     VideoEncodeAccelerator::Error error) {
   DCHECK(encoder_thread_task_runner_->BelongsToCurrentThread());
   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());
 
   {
-    MediaBufferScopedPointer scoped_buffer(input_buffer.get());
+    MediaBufferScopedPointer scoped_buffer(input_buffer.Get());
     DCHECK(scoped_buffer.get());
     libyuv::I420Copy(frame->visible_data(VideoFrame::kYPlane),
                      frame->stride(VideoFrame::kYPlane),
                      frame->visible_data(VideoFrame::kVPlane),
                      frame->stride(VideoFrame::kVPlane),
                      frame->visible_data(VideoFrame::kUPlane),
                      frame->stride(VideoFrame::kUPlane), scoped_buffer.get(),
                      frame->stride(VideoFrame::kYPlane),
                      scoped_buffer.get() + u_plane_offset_,
                      frame->stride(VideoFrame::kUPlane),
                      scoped_buffer.get() + v_plane_offset_,
                      frame->stride(VideoFrame::kVPlane),
                      input_visible_size_.width(), input_visible_size_.height());
   }
 
   input_sample_->SetSampleTime(frame->timestamp().InMicroseconds() *
                                kOneMicrosecondInMFSampleTimeUnits);
   UINT64 sample_duration = 1;
   HRESULT hr =
       MFFrameRateToAverageTimePerFrame(frame_rate_, 1, &sample_duration);
   RETURN_ON_HR_FAILURE(hr, "Couldn't calculate sample duration", );
   input_sample_->SetSampleDuration(sample_duration);
 
   // Release frame after input is copied.
   frame = nullptr;
 
-  hr = encoder_->ProcessInput(input_stream_id_, input_sample_.get(), 0);
+  hr = encoder_->ProcessInput(input_stream_id_, input_sample_.Get(), 0);
   // According to MSDN, if encoder returns MF_E_NOTACCEPTING, we need to try
   // processing the output. This error indicates that encoder does not accept
   // any more input data.
   if (hr == MF_E_NOTACCEPTING) {
     DVLOG(3) << "MF_E_NOTACCEPTING";
     ProcessOutput();
-    hr = encoder_->ProcessInput(input_stream_id_, input_sample_.get(), 0);
+    hr = encoder_->ProcessInput(input_stream_id_, input_sample_.Get(), 0);
     if (!SUCCEEDED(hr)) {
       NotifyError(kPlatformFailureError);
       RETURN_ON_HR_FAILURE(hr, "Couldn't encode", );
     }
   } else if (!SUCCEEDED(hr)) {
     NotifyError(kPlatformFailureError);
     RETURN_ON_HR_FAILURE(hr, "Couldn't encode", );
   }
   DVLOG(3) << "Sent for encode " << hr;
 
   ProcessOutput();
 }
 
 void MediaFoundationVideoEncodeAccelerator::ProcessOutput() {
   DVLOG(3) << __func__;
   DCHECK(encoder_thread_task_runner_->BelongsToCurrentThread());
 
   DWORD output_status = 0;
   HRESULT hr = encoder_->GetOutputStatus(&output_status);
   RETURN_ON_HR_FAILURE(hr, "Couldn't get output status", );
   if (output_status != MFT_OUTPUT_STATUS_SAMPLE_READY) {
     DVLOG(3) << "Output isnt ready";
     return;
   }
 
   MFT_OUTPUT_DATA_BUFFER output_data_buffer = {0};
   output_data_buffer.dwStreamID = 0;
   output_data_buffer.dwStatus = 0;
   output_data_buffer.pEvents = NULL;
-  output_data_buffer.pSample = output_sample_.get();
+  output_data_buffer.pSample = output_sample_.Get();
   DWORD status = 0;
   hr = encoder_->ProcessOutput(output_stream_id_, 1, &output_data_buffer,
                                &status);
   if (hr == MF_E_TRANSFORM_NEED_MORE_INPUT) {
     DVLOG(3) << "MF_E_TRANSFORM_NEED_MORE_INPUT" << status;
     return;
   }
   RETURN_ON_HR_FAILURE(hr, "Couldn't get encoded data", );
   DVLOG(3) << "Got encoded data " << hr;
 
   base::win::ScopedComPtr<IMFMediaBuffer> output_buffer;
   hr = output_sample_->GetBufferByIndex(0, output_buffer.Receive());
   RETURN_ON_HR_FAILURE(hr, "Couldn't get buffer by index", );
   DWORD size = 0;
   hr = output_buffer->GetCurrentLength(&size);
   RETURN_ON_HR_FAILURE(hr, "Couldn't get buffer length", );
 
   base::TimeDelta timestamp;
   LONGLONG sample_time;
   hr = output_sample_->GetSampleTime(&sample_time);
   if (SUCCEEDED(hr)) {
     timestamp = base::TimeDelta::FromMicroseconds(
         sample_time / kOneMicrosecondInMFSampleTimeUnits);
   }
 
   const bool keyframe = MFGetAttributeUINT32(
-      output_sample_.get(), MFSampleExtension_CleanPoint, false);
+      output_sample_.Get(), MFSampleExtension_CleanPoint, false);
   DVLOG(3) << "We HAVE encoded data with size:" << size << " keyframe "
            << keyframe;
 
   if (bitstream_buffer_queue_.empty()) {
     DVLOG(3) << "No bitstream buffers.";
     // We need to copy the output so that encoding can continue.
     std::unique_ptr<EncodeOutput> encode_output(
         new EncodeOutput(size, keyframe, timestamp));
     {
-      MediaBufferScopedPointer scoped_buffer(output_buffer.get());
+      MediaBufferScopedPointer scoped_buffer(output_buffer.Get());
       memcpy(encode_output->memory(), scoped_buffer.get(), size);
     }
     encoder_output_queue_.push_back(std::move(encode_output));
     return;
   }
 
   std::unique_ptr<MediaFoundationVideoEncodeAccelerator::BitstreamBufferRef>
       buffer_ref = std::move(bitstream_buffer_queue_.front());
   bitstream_buffer_queue_.pop_front();
 
   {
-    MediaBufferScopedPointer scoped_buffer(output_buffer.get());
+    MediaBufferScopedPointer scoped_buffer(output_buffer.Get());
     memcpy(buffer_ref->shm->memory(), scoped_buffer.get(), size);
   }
 
   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();
@@ skipping 66 matching lines @@
 void MediaFoundationVideoEncodeAccelerator::ReleaseEncoderResources() {
   encoder_.Reset();
   codec_api_.Reset();
   imf_input_media_type_.Reset();
   imf_output_media_type_.Reset();
   input_sample_.Reset();
   output_sample_.Reset();
 }
 
 }  // namespace content