Added FakeGlVideoDecodeEngine to exercise the IPC protocol for hardware video decoding

media/mf/mft_h264_decoder.cc

 // Copyright (c) 2010 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 "build/build_config.h"  // For OS_WIN.
 
 #if defined(OS_WIN)
 
 #include "media/mf/mft_h264_decoder.h"
 
@@ skipping 154 matching lines @@
     return;
   }
   if (!message_loop || !event_handler) {
     LOG(ERROR) << "MftH264Decoder::Initialize: parameters cannot be NULL";
     return;
   }
 
   config_ = config;
   event_handler_ = event_handler;
 
-  info_.provides_buffers_ = true;
+  info_.provides_buffers = true;
 
   // TODO(jiesun): Actually it is more likely an NV12 D3DSuface9.
   // Until we had hardware composition working.
   if (use_dxva_) {
-    info_.stream_info_.surface_format_ = VideoFrame::YV12;
-    info_.stream_info_.surface_type_ = VideoFrame::TYPE_SYSTEM_MEMORY;
+    info_.stream_info.surface_format = VideoFrame::YV12;
+    info_.stream_info.surface_type = VideoFrame::TYPE_SYSTEM_MEMORY;
   } else {
-    info_.stream_info_.surface_format_ = VideoFrame::YV12;
-    info_.stream_info_.surface_type_ = VideoFrame::TYPE_SYSTEM_MEMORY;
+    info_.stream_info.surface_format = VideoFrame::YV12;
+    info_.stream_info.surface_type = VideoFrame::TYPE_SYSTEM_MEMORY;
   }
 
   // codec_info.stream_info_.surface_width_/height_ are initialized
   // in InitInternal().
-  info_.success_ = InitInternal();
-  if (info_.success_) {
+  info_.success = InitInternal();
+  if (info_.success) {
     state_ = kNormal;
     event_handler_->OnInitializeComplete(info_);
   } else {
     LOG(ERROR) << "MftH264Decoder::Initialize failed";
   }
 }
 
 void MftH264Decoder::Uninitialize() {
   LOG(INFO) << "MftH264Decoder::Uninitialize";
   if (state_ == kUninitialized) {
@@ skipping 283 matching lines @@
     GUID out_subtype;
     HRESULT hr = out_media_type->GetGUID(MF_MT_SUBTYPE, &out_subtype);
     if (FAILED(hr)) {
       LOG(ERROR) << "Failed to GetGUID() on GetOutputAvailableType() " << i;
       out_media_type->Release();
       continue;
     }
     if (out_subtype == subtype) {
       hr = decoder_->SetOutputType(0, out_media_type, 0);  // No flags
       hr = MFGetAttributeSize(out_media_type, MF_MT_FRAME_SIZE,
-          reinterpret_cast<UINT32*>(&info_.stream_info_.surface_width_),
-          reinterpret_cast<UINT32*>(&info_.stream_info_.surface_height_));
-      config_.width_ = info_.stream_info_.surface_width_;
-      config_.height_ = info_.stream_info_.surface_height_;
+          reinterpret_cast<UINT32*>(&info_.stream_info.surface_width),
+          reinterpret_cast<UINT32*>(&info_.stream_info.surface_height));
+      config_.width = info_.stream_info.surface_width;
+      config_.height = info_.stream_info.surface_height;
       if (FAILED(hr)) {
         LOG(ERROR) << "Failed to SetOutputType to |subtype| or obtain "
                    << "width/height " << std::hex << hr;
       } else {
         out_media_type->Release();
         return true;
       }
     }
     i++;
     out_media_type->Release();
@@ skipping 80 matching lines @@
   if (events != NULL) {
     LOG(INFO) << "Got events from ProcessOuput, but discarding";
     events->Release();
   }
 
   if (FAILED(hr)) {
     if (hr == MF_E_TRANSFORM_STREAM_CHANGE) {
       hr = SetDecoderOutputMediaType(use_dxva_ ? MFVideoFormat_NV12
                                                : MFVideoFormat_YV12);
       if (SUCCEEDED(hr)) {
-        event_handler_->OnFormatChange(info_.stream_info_);
+        event_handler_->OnFormatChange(info_.stream_info);
         return true;
       } else {
         event_handler_->OnError();
         return false;
       }
     } else if (hr == MF_E_TRANSFORM_NEED_MORE_INPUT) {
       if (state_ == kEosDrain) {
         // No more output from the decoder. Notify EOS and stop playback.
         scoped_refptr<VideoFrame> frame;
         VideoFrame::CreateEmptyFrame(&frame);
@@ skipping 40 matching lines @@
     return true;
   }
 
   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;
   }
 
-  VideoFrame::CreateFrame(info_.stream_info_.surface_format_,
-                          info_.stream_info_.surface_width_,
-                          info_.stream_info_.surface_height_,
+  VideoFrame::CreateFrame(info_.stream_info.surface_format,
+                          info_.stream_info.surface_width,
+                          info_.stream_info.surface_height,
                           base::TimeDelta::FromMicroseconds(timestamp),
                           base::TimeDelta::FromMicroseconds(duration),
                           &frame);
   if (!frame.get()) {
     LOG(ERROR) << "Failed to allocate video frame";
     event_handler_->OnError();
     return true;
   }
 
   if (use_dxva_) {
@@ skipping 17 matching lines @@
     }
     D3DSURFACE_DESC desc;
     hr = surface->GetDesc(&desc);
     if (FAILED(hr)) {
       LOG(ERROR) << "GetDesc";
       CHECK(SUCCEEDED(surface->UnlockRect()));
       return true;
     }
 
     uint32 src_stride = d3dlocked_rect.Pitch;
-    uint32 dst_stride = config_.width_;
+    uint32 dst_stride = config_.width;
     uint8* src_y = static_cast<uint8*>(d3dlocked_rect.pBits);
     uint8* src_uv = src_y + src_stride * desc.Height;
     uint8* dst_y = static_cast<uint8*>(frame->data(VideoFrame::kYPlane));
     uint8* dst_u = static_cast<uint8*>(frame->data(VideoFrame::kVPlane));
     uint8* dst_v = static_cast<uint8*>(frame->data(VideoFrame::kUPlane));
 
-    for (int y = 0; y < config_.height_; ++y) {
-      for (int x = 0; x < config_.width_; ++x) {
+    for (int y = 0; y < config_.height; ++y) {
+      for (int x = 0; x < config_.width; ++x) {
         dst_y[x] = src_y[x];
         if (!(y & 1)) {
           if (x & 1)
             dst_v[x>>1] = src_uv[x];
           else
             dst_u[x>>1] = src_uv[x];
         }
       }
       dst_y += dst_stride;
       src_y += src_stride;
@@ skipping 17 matching lines @@
     CHECK(SUCCEEDED(output_buffer->Unlock()));
   }
   // TODO(jiesun): non-System memory case
   event_handler_->ConsumeVideoFrame(frame);
   return true;
 }
 
 }  // namespace media
 
 #endif  // defined(OS_WIN)