Added FakeGlVideoDecodeEngine to exercise the IPC protocol for hardware video decoding

media/video/ffmpeg_video_decode_engine.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 "media/video/ffmpeg_video_decode_engine.h"
 
 #include "base/command_line.h"
 #include "base/string_number_conversions.h"
 #include "base/task.h"
 #include "media/base/buffers.h"
@@ skipping 32 matching lines @@
   // performance benefits on older machines such as P4s with hyperthreading.
   //
   // Handling decoding on separate threads also frees up the pipeline thread to
   // continue processing. Although it'd be nice to have the option of a single
   // decoding thread, FFmpeg treats having one thread the same as having zero
   // threads (i.e., avcodec_decode_video() will execute on the calling thread).
   // Yet another reason for having two threads :)
   static const int kDecodeThreads = 2;
   static const int kMaxDecodeThreads = 16;
 
-  av_stream_ = static_cast<AVStream*>(config.opaque_context_);
+  av_stream_ = static_cast<AVStream*>(config.opaque_context);
   codec_context_ = av_stream_->codec;
   // Enable motion vector search (potentially slow), strong deblocking filter
   // for damaged macroblocks, and set our error detection sensitivity.
   codec_context_->error_concealment = FF_EC_GUESS_MVS | FF_EC_DEBLOCK;
   codec_context_->error_recognition = FF_ER_CAREFUL;
 
   AVCodec* codec = avcodec_find_decoder(codec_context_->codec_id);
 
   if (codec) {
 #ifdef FF_THREAD_FRAME  // Only defined in FFMPEG-MT.
@@ skipping 16 matching lines @@
       !base::StringToInt(threads, &decode_threads)) ||
       decode_threads < 0 || decode_threads > kMaxDecodeThreads) {
     decode_threads = kDecodeThreads;
   }
 
   // We don't allocate AVFrame on the stack since different versions of FFmpeg
   // may change the size of AVFrame, causing stack corruption.  The solution is
   // to let FFmpeg allocate the structure via avcodec_alloc_frame().
   av_frame_.reset(avcodec_alloc_frame());
   VideoCodecInfo info;
-  info.success_ = false;
-  info.provides_buffers_ = true;
-  info.stream_info_.surface_type_ = VideoFrame::TYPE_SYSTEM_MEMORY;
-  info.stream_info_.surface_format_ = GetSurfaceFormat();
-  info.stream_info_.surface_width_ = config.width_;
-  info.stream_info_.surface_height_ = config.height_;
+  info.success = false;
+  info.provides_buffers = true;
+  info.stream_info.surface_type = VideoFrame::TYPE_SYSTEM_MEMORY;
+  info.stream_info.surface_format = GetSurfaceFormat();
+  info.stream_info.surface_width = config.width;
+  info.stream_info.surface_height = config.height;
 
   // If we do not have enough buffers, we will report error too.
   bool buffer_allocated = true;
   frame_queue_available_.clear();
   if (!direct_rendering_) {
     // Create output buffer pool when direct rendering is not used.
     for (size_t i = 0; i < Limits::kMaxVideoFrames; ++i) {
       scoped_refptr<VideoFrame> video_frame;
       VideoFrame::CreateFrame(VideoFrame::YV12,
-                              config.width_,
-                              config.height_,
+                              config.width,
+                              config.height,
                               StreamSample::kInvalidTimestamp,
                               StreamSample::kInvalidTimestamp,
                               &video_frame);
       if (!video_frame.get()) {
         buffer_allocated = false;
         break;
       }
       frame_queue_available_.push_back(video_frame);
     }
   }
 
   if (codec &&
       avcodec_thread_init(codec_context_, decode_threads) >= 0 &&
       avcodec_open(codec_context_, codec) >= 0 &&
       av_frame_.get() &&
       buffer_allocated) {
-    info.success_ = true;
+    info.success = true;
   }
   event_handler_ = event_handler;
   event_handler_->OnInitializeComplete(info);
 }
 
 // TODO(fbarchard): Find way to remove this memcpy of the entire image.
 static void CopyPlane(size_t plane,
                       scoped_refptr<VideoFrame> video_frame,
                       const AVFrame* frame) {
   DCHECK_EQ(video_frame->width() % 2, 0u);
@@ skipping 221 matching lines @@
       // TODO(scherkus): More formats here?
       return VideoFrame::INVALID;
   }
 }
 
 }  // namespace media
 
 // Disable refcounting for this object because this object only lives
 // on the video decoder thread and there's no need to refcount it.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(media::FFmpegVideoDecodeEngine);