Include base/win/scoped_comptr.h instead of base/scoped_comptr_win.h.

media/video/mft_h264_decode_engine.cc

 // Copyright (c) 2011 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/video/mft_h264_decode_engine.h"
 
 #include <d3d9.h>
 #include <dxva2api.h>
 #include <initguid.h>
 #include <mfapi.h>
@@ skipping 13 matching lines @@
 #pragma comment(lib, "mf.lib")
 #pragma comment(lib, "mfplat.lib")
 
 using base::TimeDelta;
 
 namespace media {
 
 // Creates an empty Media Foundation sample with no buffers.
 static IMFSample* CreateEmptySample() {
   HRESULT hr;
-  ScopedComPtr<IMFSample> sample;
+  base::win::ScopedComPtr<IMFSample> sample;
   hr = MFCreateSample(sample.Receive());
   if (FAILED(hr)) {
     LOG(ERROR) << "Unable to create an empty sample";
     return NULL;
   }
   return sample.Detach();
 }
 
 // Creates a Media Foundation sample with one buffer of length |buffer_length|
 // on a |align|-byte boundary. Alignment must be a perfect power of 2 or 0.
 // If |align| is 0, then no alignment is specified.
 static IMFSample* CreateEmptySampleWithBuffer(int buffer_length, int align) {
   CHECK_GT(buffer_length, 0);
-  ScopedComPtr<IMFSample> sample;
+  base::win::ScopedComPtr<IMFSample> sample;
   sample.Attach(CreateEmptySample());
   if (!sample.get())
     return NULL;
-  ScopedComPtr<IMFMediaBuffer> buffer;
+  base::win::ScopedComPtr<IMFMediaBuffer> buffer;
   HRESULT hr;
   if (align == 0) {
     // Note that MFCreateMemoryBuffer is same as MFCreateAlignedMemoryBuffer
     // with the align argument being 0.
     hr = MFCreateMemoryBuffer(buffer_length, buffer.Receive());
   } else {
     hr = MFCreateAlignedMemoryBuffer(buffer_length,
                                      align - 1,
                                      buffer.Receive());
   }
@@ skipping 14 matching lines @@
 // 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). The times here should be given in 100ns units.
 // |alignment| specifies the buffer in the sample to be aligned. If no
 // alignment is required, provide 0 or 1.
 static IMFSample* CreateInputSample(const uint8* stream, int size,
                                     int64 timestamp, int64 duration,
                                     int min_size, int alignment) {
   CHECK(stream);
   CHECK_GT(size, 0);
-  ScopedComPtr<IMFSample> sample;
+  base::win::ScopedComPtr<IMFSample> sample;
   sample.Attach(CreateEmptySampleWithBuffer(std::max(min_size, size),
                                             alignment));
   if (!sample.get()) {
     LOG(ERROR) << "Failed to create empty buffer for input";
     return NULL;
   }
   HRESULT hr;
   if (duration > 0) {
     hr = sample->SetSampleDuration(duration);
     if (FAILED(hr)) {
       LOG(ERROR) << "Failed to set sample duration";
       return NULL;
     }
   }
   if (timestamp > 0) {
     hr = sample->SetSampleTime(timestamp);
     if (FAILED(hr)) {
       LOG(ERROR) << "Failed to set sample time";
       return NULL;
     }
   }
-  ScopedComPtr<IMFMediaBuffer> buffer;
+  base::win::ScopedComPtr<IMFMediaBuffer> buffer;
   hr = sample->GetBufferByIndex(0, buffer.Receive());
   if (FAILED(hr)) {
     LOG(ERROR) << "Failed to get buffer in sample";
     return NULL;
   }
   DWORD max_length, current_length;
   uint8* destination;
   hr = buffer->Lock(&destination, &max_length, &current_length);
   if (FAILED(hr)) {
     LOG(ERROR) << "Failed to lock buffer";
@@ skipping 123 matching lines @@
   }
 
   // Seek not implemented.
   event_handler_->OnSeekComplete();
 }
 
 void MftH264DecodeEngine::ConsumeVideoSample(scoped_refptr<Buffer> buffer) {
   if (state_ == kUninitialized) {
     LOG(ERROR) << "ConsumeVideoSample: invalid state";
   }
-  ScopedComPtr<IMFSample> sample;
+  base::win::ScopedComPtr<IMFSample> sample;
   PipelineStatistics statistics;
   if (!buffer->IsEndOfStream()) {
     sample.Attach(
         CreateInputSample(buffer->GetData(),
                           buffer->GetDataSize(),
                           buffer->GetTimestamp().InMicroseconds() * 10,
                           buffer->GetDuration().InMicroseconds() * 10,
                           input_stream_info_.cbSize,
                           input_stream_info_.cbAlignment));
     if (!sample.get()) {
@@ skipping 55 matching lines @@
   hr = MFShutdown();
   if (FAILED(hr)) {
     LOG(WARNING) << "Warning: MF failed to shutdown";
   }
   CoUninitialize();
 }
 
 bool MftH264DecodeEngine::EnableDxva() {
   IDirect3DDevice9* device = static_cast<IDirect3DDevice9*>(
       context_->GetDevice());
-  ScopedComPtr<IDirect3DDeviceManager9> device_manager;
+  base::win::ScopedComPtr<IDirect3DDeviceManager9> device_manager;
   UINT dev_manager_reset_token = 0;
   HRESULT hr = DXVA2CreateDirect3DDeviceManager9(&dev_manager_reset_token,
                                                  device_manager.Receive());
   if (FAILED(hr)) {
     LOG(ERROR) << "Couldn't create D3D Device manager";
     return false;
   }
 
   hr = device_manager->ResetDevice(device, dev_manager_reset_token);
   if (FAILED(hr)) {
@@ skipping 53 matching lines @@
       1, info_.stream_info.surface_width, info_.stream_info.surface_height,
       VideoFrame::RGBA, &output_frames_,
       NewRunnableMethod(this, &MftH264DecodeEngine::OnAllocFramesDone));
 }
 
 void MftH264DecodeEngine::OnAllocFramesDone() {
   event_handler_->OnInitializeComplete(info_);
 }
 
 bool MftH264DecodeEngine::CheckDecodeEngineDxvaSupport() {
-  ScopedComPtr<IMFAttributes> attributes;
+  base::win::ScopedComPtr<IMFAttributes> attributes;
   HRESULT hr = decode_engine_->GetAttributes(attributes.Receive());
   if (FAILED(hr)) {
     LOG(ERROR) << "Unlock: Failed to get attributes, hr = "
                << std::hex << std::showbase << hr;
     return false;
   }
 
   UINT32 dxva;
   hr = attributes->GetUINT32(MF_SA_D3D_AWARE, &dxva);
   if (FAILED(hr) || !dxva) {
     LOG(ERROR) << "Failed to get DXVA attr or decoder is not DXVA-aware, hr = "
                << std::hex << std::showbase << hr
                << " this might not be the right decoder.";
     return false;
   }
   return true;
 }
 
 bool MftH264DecodeEngine::SetDecodeEngineMediaTypes() {
   if (!SetDecodeEngineInputMediaType())
     return false;
   return SetDecodeEngineOutputMediaType(
       ConvertVideoFrameFormatToGuid(info_.stream_info.surface_format));
 }
 
 bool MftH264DecodeEngine::SetDecodeEngineInputMediaType() {
-  ScopedComPtr<IMFMediaType> media_type;
+  base::win::ScopedComPtr<IMFMediaType> media_type;
   HRESULT hr = MFCreateMediaType(media_type.Receive());
   if (FAILED(hr)) {
     LOG(ERROR) << "Failed to create empty media type object";
     return false;
   }
 
   hr = media_type->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Video);
   if (FAILED(hr)) {
     LOG(ERROR) << "SetGUID for major type failed";
     return false;
@@ skipping 93 matching lines @@
 
   return true;
 }
 
 bool MftH264DecodeEngine::DoDecode(const PipelineStatistics& statistics) {
   if (state_ != kNormal && state_ != kEosDrain) {
     LOG(ERROR) << "DoDecode: not in normal or drain state";
     return false;
   }
   scoped_refptr<VideoFrame> frame;
-  ScopedComPtr<IMFSample> output_sample;
+  base::win::ScopedComPtr<IMFSample> output_sample;
   if (!use_dxva_) {
     output_sample.Attach(
         CreateEmptySampleWithBuffer(output_stream_info_.cbSize,
                                     output_stream_info_.cbAlignment));
     if (!output_sample.get()) {
       LOG(ERROR) << "GetSample: failed to create empty output sample";
       event_handler_->OnError();
       return false;
     }
   }
@@ skipping 71 matching lines @@
   duration /= 10;
 
   // Sanity checks for checking if there is really something in the sample.
   DWORD buf_count;
   hr = output_sample->GetBufferCount(&buf_count);
   if (FAILED(hr) || buf_count != 1) {
     LOG(ERROR) << "Failed to get buffer count, or buffer count mismatch";
     return true;
   }
 
-  ScopedComPtr<IMFMediaBuffer> output_buffer;
+  base::win::ScopedComPtr<IMFMediaBuffer> output_buffer;
   hr = output_sample->GetBufferByIndex(0, output_buffer.Receive());
   if (FAILED(hr)) {
     LOG(ERROR) << "Failed to get buffer from sample";
     return true;
   }
   if (use_dxva_) {
-    ScopedComPtr<IDirect3DSurface9, &IID_IDirect3DSurface9> surface;
+    base::win::ScopedComPtr<IDirect3DSurface9, &IID_IDirect3DSurface9> surface;
     hr = MFGetService(output_buffer, MR_BUFFER_SERVICE,
                       IID_PPV_ARGS(surface.Receive()));
     if (FAILED(hr)) {
       LOG(ERROR) << "Failed to get surface from buffer";
       return true;
     }
     // Since we only allocated 1 frame from context.
     // TODO(imcheng): Detect error.
     output_frames_[0]->SetTimestamp(TimeDelta::FromMicroseconds(timestamp));
     output_frames_[0]->SetDuration(TimeDelta::FromMicroseconds(duration));
@@ skipping 23 matching lines @@
     return true;
   uint8* dst_y = static_cast<uint8*>(frame->data(VideoFrame::kYPlane));
 
   memcpy(dst_y, src_y, current_length);
   CHECK(SUCCEEDED(output_buffer->Unlock()));
   event_handler_->ConsumeVideoFrame(frame, statistics);
   return true;
 }
 
 void MftH264DecodeEngine::OnUploadVideoFrameDone(
-    ScopedComPtr<IDirect3DSurface9, &IID_IDirect3DSurface9> surface,
+    base::win::ScopedComPtr<IDirect3DSurface9, &IID_IDirect3DSurface9> surface,
     scoped_refptr<VideoFrame> frame,
     PipelineStatistics statistics) {
   // After this method is exited the reference to surface is released.
   event_handler_->ConsumeVideoFrame(frame, statistics);
 }
 
 }  // namespace media
 
 DISABLE_RUNNABLE_METHOD_REFCOUNT(media::MftH264DecodeEngine);