Added FakeGlVideoDecodeEngine to exercise the IPC protocol for hardware video decoding

chrome/renderer/media/ipc_video_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 "chrome/renderer/media/ipc_video_decoder.h"
 
+#include <GLES2/gl2.h>
+
 #include "base/task.h"
 #include "chrome/renderer/ggl/ggl.h"
 #include "media/base/callback.h"
 #include "media/base/filters.h"
 #include "media/base/filter_host.h"
 #include "media/base/limits.h"
 #include "media/base/media_format.h"
 #include "media/base/video_frame.h"
 #include "media/ffmpeg/ffmpeg_common.h"
 #include "media/ffmpeg/ffmpeg_util.h"
@@ skipping 39 matching lines @@
   if (!demuxer_stream->QueryInterface(&av_stream_provider)) {
     GpuVideoDecoderInitDoneParam param;
     OnInitializeDone(false, param);
     return;
   }
 
   AVStream* av_stream = av_stream_provider->GetAVStream();
   width_ = av_stream->codec->width;
   height_ = av_stream->codec->height;
 
-  // TODO(hclam): Pass an actual context instead of NULL.
-  gpu_video_decoder_host_ = ggl::CreateVideoDecoder(NULL);
+  // Switch GL context.
+  bool ret = ggl::MakeCurrent(ggl_context_);
+  DCHECK(ret) << "Failed to switch GL context";
+
+  // Generate textures to be used by the hardware video decoder in the GPU
+  // process.
+  // TODO(hclam): Allocation of textures should be done based on the request
+  // of the GPU process.
+  GLuint texture;
+  glGenTextures(1, &texture);
+  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width_, height_, 0, GL_RGBA,
+               GL_UNSIGNED_BYTE, NULL);
+  texture_ = texture;
+
+  // Create a hardware video decoder handle for IPC communication.
+  gpu_video_decoder_host_ = ggl::CreateVideoDecoder(ggl_context_);
 
   // Initialize hardware decoder.
   GpuVideoDecoderInitParam param = {0};
-  param.width_ = width_;
-  param.height_ = height_;
+  param.width = width_;
+  param.height = height_;
   if (!gpu_video_decoder_host_->Initialize(this, param)) {
     GpuVideoDecoderInitDoneParam param;
     OnInitializeDone(false, param);
   }
 }
 
 void IpcVideoDecoder::OnInitializeDone(
     bool success, const GpuVideoDecoderInitDoneParam& param) {
   if (MessageLoop::current() != renderer_thread_message_loop_) {
     renderer_thread_message_loop_->PostTask(
         FROM_HERE,
         NewRunnableMethod(this,
                           &IpcVideoDecoder::OnInitializeDone,
                           success,
                           param));
     return;
   }
 
   media::AutoCallbackRunner done_runner(initialize_callback_.release());
 
   if (success) {
     media_format_.SetAsString(media::MediaFormat::kMimeType,
                               media::mime_type::kUncompressedVideo);
     media_format_.SetAsInteger(media::MediaFormat::kWidth, width_);
     media_format_.SetAsInteger(media::MediaFormat::kHeight, height_);
     media_format_.SetAsInteger(media::MediaFormat::kSurfaceType,
-                               static_cast<int>(param.surface_type_));
+                               static_cast<int>(param.surface_type));
     media_format_.SetAsInteger(media::MediaFormat::kSurfaceFormat,
-                               static_cast<int>(param.format_));
+                               static_cast<int>(param.format));
     state_ = kPlaying;
   } else {
     LOG(ERROR) << "IpcVideoDecoder initialization failed!";
     host()->SetError(media::PIPELINE_ERROR_DECODE);
   }
 }
 
 void IpcVideoDecoder::Stop(media::FilterCallback* callback) {
   if (MessageLoop::current() != renderer_thread_message_loop_) {
     renderer_thread_message_loop_->PostTask(
@@ skipping 149 matching lines @@
                           &IpcVideoDecoder::ProduceVideoFrame,
                           video_frame));
     return;
   }
 
   // Synchronized flushing before stop should prevent this.
   DCHECK_NE(state_, kStopped);
 
   // Notify decode engine the available of new frame.
   ++pending_requests_;
-  gpu_video_decoder_host_->FillThisBuffer(video_frame);
+
+  VideoFrame::GlTexture textures[3] = { texture_, 0, 0 };
+  scoped_refptr<VideoFrame> frame;
+  media::VideoFrame::CreateFrameGlTexture(
+      media::VideoFrame::RGBA, width_, height_, textures,
+      base::TimeDelta(), base::TimeDelta(), &frame);
+  gpu_video_decoder_host_->FillThisBuffer(frame);
 }
 
 void IpcVideoDecoder::OnFillBufferDone(
     scoped_refptr<media::VideoFrame> video_frame) {
   if (MessageLoop::current() != renderer_thread_message_loop_) {
     renderer_thread_message_loop_->PostTask(
         FROM_HERE,
         NewRunnableMethod(this,
                           &IpcVideoDecoder::OnFillBufferDone,
                           video_frame));
@@ skipping 60 matching lines @@
   if (!format.GetAsString(media::MediaFormat::kMimeType, &mime_type) &&
       media::mime_type::kFFmpegVideo != mime_type)
       return false;
 
   // TODO(jiesun): Although we current only support H264 hardware decoding,
   // in the future, we should query GpuVideoService for capabilities.
   int codec_id;
   return format.GetAsInteger(media::MediaFormat::kFFmpegCodecID, &codec_id) &&
       codec_id == CODEC_ID_H264;
 }