Initial implementation of the DXVA 2.0 H.264 hardware decoder for pepper for Windows. The decodin...

content/common/gpu/media/video_decode_accelerator_unittest.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.
 //
 // The bulk of this file is support code; sorry about that.  Here's an overview
 // to hopefully help readers of this code:
 // - RenderingHelper is charged with interacting with X11, EGL, and GLES2.
 // - ClientState is an enum for the state of the decode client used by the test.
 // - ClientStateNotification is a barrier abstraction that allows the test code
 //   to be written sequentially and wait for the decode client to see certain
 //   state transitions.
 // - EglRenderingVDAClient is a VideoDecodeAccelerator::Client implementation
 // - Finally actual TEST cases are at the bottom of this file, using the above
 //   infrastructure.
 
 #include <fcntl.h>
 #include <math.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 
 // Include gtest.h out of order because <X11/X.h> #define's Bool & None, which
 // gtest uses as struct names (inside a namespace).  This means that
 // #include'ing gtest after anything that pulls in X.h fails to compile.
 // This is http://code.google.com/p/googletest/issues/detail?id=371
-#include "testing/gtest/include/gtest/gtest.h"

[Ami GONE FROM CHROMIUM, 2011/12/16 07:38:54]

See the comment above this line for why it's included out-of-order.

[ananta, 2011/12/17 00:40:25]

Sorry about that. Restored. I did this to fix a lint error :(

-
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
+#include "base/process_util.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
 #include "base/stringize_macros.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
+#include "base/utf_string_conversions.h"
+
+#if (defined(OS_CHROMEOS) && defined(ARCH_CPU_ARMEL)) || defined(OS_WIN)

[Ami GONE FROM CHROMIUM, 2011/12/16 07:38:54]

If you negate this up here & #error out, then afterwards you can just check for
one or the other.

#if (!cros||!armel) && !win
#error
#endif

#if win
...
#else
(can assume cros & arm)
#endif

[ananta, 2011/12/17 00:40:25]

Done.

+#if defined(OS_WIN)
+#include "content/common/gpu/media/dxva_video_decode_accelerator.h"
+#else  // OS_WIN
 #include "content/common/gpu/media/omx_video_decode_accelerator.h"
+#endif  // defined(OS_WIN)
+#endif  // (defined(OS_CHROMEOS) && defined(ARCH_CPU_ARMEL)) || defined(OS_WIN)
+
+#include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/angle/include/EGL/egl.h"
 #include "third_party/angle/include/GLES2/gl2.h"
 
-#if !defined(OS_CHROMEOS) || !defined(ARCH_CPU_ARMEL)
-#error This test (and OmxVideoDecodeAccelerator) are only supported on cros/ARM!
+#if !defined(OS_CHROMEOS) && !defined(ARCH_CPU_ARMEL) && !defined(OS_WIN)
+#error The VideoAccelerator tests are only supported on cros/ARM/Windows.
 #endif
 
 using media::VideoDecodeAccelerator;
 
 namespace {
 
 // Values optionally filled in from flags; see main() below.
 // The syntax of this variable is:
 //   filename:width:height:numframes:numNALUs:minFPSwithRender:minFPSnoRender
 // where only the first field is required.  Value details:
 // - |filename| must be an h264 Annex B (NAL) stream.
 // - |width| and |height| are in pixels.
 // - |numframes| is the number of picture frames in the file.
 // - |numNALUs| is the number of NAL units in the stream.
 // - |minFPSwithRender| and |minFPSnoRender| are minimum frames/second speeds
 //   expected to be achieved with and without rendering to the screen, resp.
 //   (the latter tests just decode speed).
 // - |profile| is the media::H264Profile set during Initialization.
 // An empty value for a numeric field means "ignore".
-const char* test_video_data = "test-25fps.h264:320:240:250:258:50:175:1";
+std::string test_video_data = "test-25fps.h264:320:240:250:258:50:175:1";

[Ami GONE FROM CHROMIUM, 2011/12/16 07:38:54]

style guide prohibits global vars of class type, which is why this was a char*
to begin with.

[ananta, 2011/12/17 00:40:25]

Restored.

 
 // Parse |data| into its constituent parts and set the various output fields
 // accordingly.  CHECK-fails on unexpected or missing required data.
 // Unspecified optional fields are set to -1.
 void ParseTestVideoData(std::string data,
                         std::string* file_name,
                         int* width, int* height,
                         int* num_frames,
                         int* num_NALUs,
                         int* min_fps_render,
@@ skipping 16 matching lines @@
   if (!elements[4].empty())
     CHECK(base::StringToInt(elements[4], num_NALUs));
   if (!elements[5].empty())
     CHECK(base::StringToInt(elements[5], min_fps_render));
   if (!elements[6].empty())
     CHECK(base::StringToInt(elements[6], min_fps_no_render));
   if (!elements[7].empty())
     CHECK(base::StringToInt(elements[7], profile));
 }
 
+// Helper for Shader creation.
+static void CreateShader(
+    GLuint program, GLenum type, const char* source, int size) {
+  GLuint shader = glCreateShader(type);
+  glShaderSource(shader, 1, &source, &size);
+  glCompileShader(shader);
+  int result = GL_FALSE;
+  glGetShaderiv(shader, GL_COMPILE_STATUS, &result);
+  if (!result) {
+    char log[4096];
+    glGetShaderInfoLog(shader, arraysize(log), NULL, log);
+    LOG(FATAL) << log;
+  }
+  glAttachShader(program, shader);
+  glDeleteShader(shader);
+  CHECK_EQ(static_cast<int>(glGetError()), GL_NO_ERROR);
+}
 
-// Helper for managing X11, EGL, and GLES2 resources.  Xlib is not thread-safe,
-// and GL state is thread-specific, so all the methods of this class (except for
-// ctor/dtor) ensure they're being run on a single thread.
+// Provides base functionality for managing EGL and GLES2 resources.

[Ami GONE FROM CHROMIUM, 2011/12/16 07:38:54]

Why move this below CreateShader above?  It makes diff'ing harder than it needs
to be.

[ananta, 2011/12/17 00:40:25]

Moved this back to just before Initialize.
The CreateTexture method in this class needs to access the 

[Ami GONE FROM CHROMIUM, 2011/12/19 22:53:44]

Hahahahahahaha - now it's harder to diff between patchsets!
Don't worry about it.  I'll live :)
Not sure what you meant to say here.

+// This class is not thread safe and thus all the methods of this class
+// (except for ctor/dtor) ensure they're being run on a single thread.
 //
-// TODO(fischman): consider moving this into media/ if we can de-dup some of the
-// code that ends up getting copy/pasted all over the place (esp. the GL setup
-// code).
-class RenderingHelper {
+// TODO(fischman): consider moving this into media/ if we can de-dup some of

[Ami GONE FROM CHROMIUM, 2011/12/16 07:38:54]

TODO can be dropped now that the media/ version of the copy/paste is deleted :)

[ananta, 2011/12/17 00:40:25]

Done.

+// the code that ends up getting copy/pasted all over the place (esp. the GL
+// setup code).
+class RenderingHelperBase {
  public:
-  explicit RenderingHelper();
-  ~RenderingHelper();
+  RenderingHelperBase();
+  virtual ~RenderingHelperBase();
 
   // Initialize all structures to prepare to render to one or more windows of
   // the specified dimensions.  CHECK-fails if any initialization step fails.
   // After this returns, texture creation and rendering can be requested.  This
   // method can be called multiple times, in which case all previously-acquired
   // resources and initializations are discarded.  If |suppress_swap_to_display|
   // then all the usual work is done, except for the final swap of the EGL

[Ami GONE FROM CHROMIUM, 2011/12/16 07:38:54]

s/EGL// ?

[ananta, 2011/12/17 00:40:25]

I just copied this as is from the existing comment.

[Ami GONE FROM CHROMIUM, 2011/12/19 22:53:44]

My point was that in the DXVA case the surfaces aren't EGL, but I guess I was
wrong.

   // surface to the display.  This cuts test times over 50% so is worth doing
   // when testing non-rendering-related aspects.
-  void Initialize(bool suppress_swap_to_display, int num_windows,
-                  int width, int height, base::WaitableEvent* done);
+  virtual void Initialize(

[Ami GONE FROM CHROMIUM, 2011/12/16 07:38:54]

You've introduced a de-facto requirement that subclasses populate egl_display_
in their Initialize() before calling this base implementation.  IWBN if instead
you extract that part to mirror PlatformCreateWindow().
I think if you do that then this can stop being virtual.
(taking it further, I think it would be best if this class only contained
pure-virtuals and non-virtuals).

[ananta, 2011/12/17 00:40:25]

Done.

+      bool suppress_swap_to_display, int num_windows,
+      int width, int height, base::WaitableEvent* done);
 
   // Undo the effects of Initialize() and signal |*done|.
-  void UnInitialize(base::WaitableEvent* done);
+  virtual void UnInitialize(base::WaitableEvent* done);
+
+  // Platform specific window creation.
+  virtual EGLNativeWindowType PlatformCreateWindow(int top_left_x,
+                                                   int top_left_y) PURE;

[Ami GONE FROM CHROMIUM, 2011/12/16 07:38:54]

Is PURE cross-platform?  I've only ever seen =0 in chromium code.

[ananta, 2011/12/17 00:40:25]

Done.

 
   // Return a newly-created GLES2 texture id rendering to a specific window, and
   // signal |*done|.
   void CreateTexture(int window_id, GLuint* texture_id,
                      base::WaitableEvent* done);
 
   // Render |texture_id| to the screen (unless |suppress_swap_to_display_|).
   void RenderTexture(GLuint texture_id);
 
   // Delete |texture_id|.
   void DeleteTexture(GLuint texture_id);
 
-  EGLDisplay egl_display() { return egl_display_; }
-  EGLContext egl_context() { return egl_context_; }
+  EGLDisplay egl_display() {

[Ami GONE FROM CHROMIUM, 2011/12/16 07:38:54]

single-line

[ananta, 2011/12/17 00:40:25]

Done.

+    return egl_display_;
+  }
+
+  EGLContext egl_context() {

[Ami GONE FROM CHROMIUM, 2011/12/16 07:38:54]

single line

[ananta, 2011/12/17 00:40:25]

Done.

+    return egl_context_;
+  }
+
   MessageLoop* message_loop() { return message_loop_; }
 
- private:
-  // Zero-out internal state.  Helper for ctor & UnInitialize().
+ protected:
   void Clear();
 
-  bool suppress_swap_to_display_;
+  // We ensure all operations are carried out on the same thread by remembering
+  // where we were Initialized.
+  MessageLoop* message_loop_;
   int width_;
   int height_;
-  Display* x_display_;
-  std::vector<Window> x_windows_;
+  bool suppress_swap_to_display_;
+  int num_windows_;

[Ami GONE FROM CHROMIUM, 2011/12/16 07:38:54]

Never used.

[ananta, 2011/12/17 00:40:25]

Removed

+
   EGLDisplay egl_display_;
   EGLContext egl_context_;
   std::vector<EGLSurface> egl_surfaces_;
   std::map<GLuint, int> texture_id_to_surface_index_;
-  // We ensure all operations are carried out on the same thread by remembering
-  // where we were Initialized.
-  MessageLoop* message_loop_;
 };
 
-RenderingHelper::RenderingHelper() {
+RenderingHelperBase::RenderingHelperBase() {
   Clear();
 }
 
-RenderingHelper::~RenderingHelper() {
-  CHECK_EQ(width_, 0) << "Must call UnInitialize before dtor.";
+RenderingHelperBase::~RenderingHelperBase() {
+  Clear();
 }
 
-void RenderingHelper::Clear() {
-  suppress_swap_to_display_ = false;
-  width_ = 0;
-  height_ = 0;
-  x_display_ = NULL;
-  x_windows_.clear();
-  egl_display_ = EGL_NO_DISPLAY;
-  egl_context_ = EGL_NO_CONTEXT;
-  egl_surfaces_.clear();
-  texture_id_to_surface_index_.clear();
-  message_loop_ = NULL;
-}
-
-// Helper for Shader creation.
-static void CreateShader(
-    GLuint program, GLenum type, const char* source, int size) {
-  GLuint shader = glCreateShader(type);
-  glShaderSource(shader, 1, &source, &size);
-  glCompileShader(shader);
-  int result = GL_FALSE;
-  glGetShaderiv(shader, GL_COMPILE_STATUS, &result);
-  if (!result) {
-    char log[4096];
-    glGetShaderInfoLog(shader, arraysize(log), NULL, log);
-    LOG(FATAL) << log;
-  }
-  glAttachShader(program, shader);
-  glDeleteShader(shader);
-  CHECK_EQ(static_cast<int>(glGetError()), GL_NO_ERROR);
-}
-
-void RenderingHelper::Initialize(
-    bool suppress_swap_to_display,
-    int num_windows,
-    int width, int height,
-    base::WaitableEvent* done) {
+void RenderingHelperBase::Initialize(bool suppress_swap_to_display,
+                                     int num_windows,
+                                     int width,
+                                     int height,
+                                     base::WaitableEvent* done) {
   // Use width_ != 0 as a proxy for the class having already been
   // Initialize()'d, and UnInitialize() before continuing.
   if (width_) {
     base::WaitableEvent done(false, false);
     UnInitialize(&done);
     done.Wait();
   }
 
   suppress_swap_to_display_ = suppress_swap_to_display;
   CHECK_GT(width, 0);
   CHECK_GT(height, 0);
   width_ = width;
   height_ = height;
   message_loop_ = MessageLoop::current();
   CHECK_GT(num_windows, 0);
+  num_windows_ = num_windows;
 
-  // Per-display X11 & EGL initialization.
-  CHECK(x_display_ = XOpenDisplay(NULL));
-  int depth = DefaultDepth(x_display_, DefaultScreen(x_display_));
-  XSetWindowAttributes window_attributes;
-  window_attributes.background_pixel =
-      BlackPixel(x_display_, DefaultScreen(x_display_));
-  window_attributes.override_redirect = true;
-
-  egl_display_ = eglGetDisplay(x_display_);
   EGLint major;
   EGLint minor;
   CHECK(eglInitialize(egl_display_, &major, &minor)) << eglGetError();
   static EGLint rgba8888[] = {
     EGL_RED_SIZE, 8,
     EGL_GREEN_SIZE, 8,
     EGL_BLUE_SIZE, 8,
     EGL_ALPHA_SIZE, 8,
     EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
     EGL_NONE,
   };
   EGLConfig egl_config;
   int num_configs;
   CHECK(eglChooseConfig(egl_display_, rgba8888, &egl_config, 1, &num_configs))
       << eglGetError();
   CHECK_GE(num_configs, 1);
   static EGLint context_attribs[] = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE};
   egl_context_ = eglCreateContext(
       egl_display_, egl_config, EGL_NO_CONTEXT, context_attribs);
   CHECK_NE(egl_context_, EGL_NO_CONTEXT) << eglGetError();
 
   // Per-window/surface X11 & EGL initialization.
   for (int i = 0; i < num_windows; ++i) {
     // Arrange X windows whimsically, with some padding.
     int top_left_x = (width + 20) * (i % 4);
     int top_left_y = (height + 12) * (i % 3);
-    Window x_window = XCreateWindow(
-      x_display_, DefaultRootWindow(x_display_),
-      top_left_x, top_left_y, width_, height_,
-      0 /* border width */,
-      depth, CopyFromParent /* class */, CopyFromParent /* visual */,
-      (CWBackPixel | CWOverrideRedirect), &window_attributes);
-    x_windows_.push_back(x_window);
-    XStoreName(x_display_, x_window, "OmxVideoDecodeAcceleratorTest");
-    XSelectInput(x_display_, x_window, ExposureMask);
-    XMapWindow(x_display_, x_window);
 
+    EGLNativeWindowType window = PlatformCreateWindow(top_left_x, top_left_y);
     EGLSurface egl_surface =
-        eglCreateWindowSurface(egl_display_, egl_config, x_window, NULL);
+        eglCreateWindowSurface(egl_display_, egl_config, window, NULL);
     egl_surfaces_.push_back(egl_surface);
     CHECK_NE(egl_surface, EGL_NO_SURFACE);
   }
   CHECK(eglMakeCurrent(egl_display_, egl_surfaces_[0],
                        egl_surfaces_[0], egl_context_)) << eglGetError();
-
   // GLES2 initialization.  Note: This is pretty much copy/pasted from
   // media/tools/player_x11/gles_video_renderer.cc, with some simplification

[Ami GONE FROM CHROMIUM, 2011/12/16 07:38:54]

Drop the Note: since that file is now gone.

[ananta, 2011/12/17 00:40:25]

Done.

   // applied.
   static const float kVertices[] =
       { -1.f, 1.f, -1.f, -1.f, 1.f, 1.f, 1.f, -1.f, };
   static const float kTextureCoordsEgl[] = { 0, 1, 0, 0, 1, 1, 1, 0, };
   static const char kVertexShader[] = STRINGIZE(
       varying vec2 interp_tc;
       attribute vec4 in_pos;
       attribute vec2 in_tc;
       void main() {
         interp_tc = in_tc;
@@ skipping 25 matching lines @@
   glDeleteProgram(program);
 
   glUniform1i(glGetUniformLocation(program, "tex"), 0);
   int pos_location = glGetAttribLocation(program, "in_pos");
   glEnableVertexAttribArray(pos_location);
   glVertexAttribPointer(pos_location, 2, GL_FLOAT, GL_FALSE, 0, kVertices);
   int tc_location = glGetAttribLocation(program, "in_tc");
   glEnableVertexAttribArray(tc_location);
   glVertexAttribPointer(tc_location, 2, GL_FLOAT, GL_FALSE, 0,
                         kTextureCoordsEgl);
-
-  done->Signal();

[Ami GONE FROM CHROMIUM, 2011/12/16 07:38:54]

Since neither impl does anything after calling this, I think done should be
signalled from the base impl (even if you didn't take my advice elsewhere to
de-virtual'ize Initialize/UnInitialize).

 }
 
-void RenderingHelper::UnInitialize(base::WaitableEvent* done) {
+void RenderingHelperBase::UnInitialize(base::WaitableEvent* done) {
   CHECK_EQ(MessageLoop::current(), message_loop_);
-  // Destroy resources acquired in Initialize, in reverse-acquisition order.
   CHECK(eglMakeCurrent(egl_display_, EGL_NO_SURFACE, EGL_NO_SURFACE,
                        EGL_NO_CONTEXT)) << eglGetError();
   CHECK(eglDestroyContext(egl_display_, egl_context_));
   for (size_t i = 0; i < egl_surfaces_.size(); ++i)
     CHECK(eglDestroySurface(egl_display_, egl_surfaces_[i]));
   CHECK(eglTerminate(egl_display_));
-  for (size_t i = 0; i < x_windows_.size(); ++i) {
-    CHECK(XUnmapWindow(x_display_, x_windows_[i]));
-    CHECK(XDestroyWindow(x_display_, x_windows_[i]));
-  }
-  // Mimic newly-created object.
   Clear();
-  done->Signal();
 }
 
-void RenderingHelper::CreateTexture(int window_id, GLuint* texture_id,
-                                    base::WaitableEvent* done) {
+void RenderingHelperBase::Clear() {
+  suppress_swap_to_display_ = false;
+  width_ = 0;
+  height_ = 0;
+  texture_id_to_surface_index_.clear();
+  message_loop_ = NULL;
+  num_windows_ = 0;
+  egl_display_ = EGL_NO_DISPLAY;
+  egl_context_ = EGL_NO_CONTEXT;
+  egl_surfaces_.clear();
+}
+
+void RenderingHelperBase::CreateTexture(int window_id, GLuint* texture_id,
+                                        base::WaitableEvent* done) {
+  CHECK(eglMakeCurrent(egl_display_, egl_surfaces_[window_id],

[Ami GONE FROM CHROMIUM, 2011/12/16 07:38:54]

Why is this before the trampoline?

[ananta, 2011/12/17 00:40:25]

Stupid mistake :(

+                       egl_surfaces_[window_id], egl_context_))
+      << eglGetError();
   if (MessageLoop::current() != message_loop_) {
     message_loop_->PostTask(
         FROM_HERE,
-        base::Bind(&RenderingHelper::CreateTexture, base::Unretained(this),
+        base::Bind(&RenderingHelperBase::CreateTexture, base::Unretained(this),
                    window_id, texture_id, done));
     return;
   }
-  CHECK(eglMakeCurrent(egl_display_, egl_surfaces_[window_id],
-                       egl_surfaces_[window_id], egl_context_))
-      << eglGetError();
   glGenTextures(1, texture_id);
   glBindTexture(GL_TEXTURE_2D, *texture_id);
   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width_, height_, 0, GL_RGBA,
                GL_UNSIGNED_BYTE, NULL);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
   // OpenGLES2.0.25 section 3.8.2 requires CLAMP_TO_EDGE for NPOT textures.
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
   CHECK_EQ(static_cast<int>(glGetError()), GL_NO_ERROR);
   CHECK(texture_id_to_surface_index_.insert(
       std::make_pair(*texture_id, window_id)).second);
   done->Signal();
 }
 
-void RenderingHelper::RenderTexture(GLuint texture_id) {
+void RenderingHelperBase::RenderTexture(GLuint texture_id) {
   CHECK_EQ(MessageLoop::current(), message_loop_);
   glActiveTexture(GL_TEXTURE0);
   glBindTexture(GL_TEXTURE_2D, texture_id);
   glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
   CHECK_EQ(static_cast<int>(glGetError()), GL_NO_ERROR);
   CHECK_EQ(static_cast<int>(eglGetError()), EGL_SUCCESS);
+
   if (!suppress_swap_to_display_) {
     int window_id = texture_id_to_surface_index_[texture_id];
     CHECK(eglMakeCurrent(egl_display_, egl_surfaces_[window_id],
                          egl_surfaces_[window_id], egl_context_))
         << eglGetError();
     eglSwapBuffers(egl_display_, egl_surfaces_[window_id]);
   }
   CHECK_EQ(static_cast<int>(eglGetError()), EGL_SUCCESS);
 }
 
-void RenderingHelper::DeleteTexture(GLuint texture_id) {
+void RenderingHelperBase::DeleteTexture(GLuint texture_id) {
   glDeleteTextures(1, &texture_id);
   CHECK_EQ(static_cast<int>(glGetError()), GL_NO_ERROR);
 }
 
+#if defined(OS_WIN)
+// Provides Windows specific functionality for managing resources like HWND's
+// The OpenGL and GLES management is provided by the RenderingHelperBase class.
+class Win32RenderingHelper : public RenderingHelperBase {
+ public:
+  Win32RenderingHelper();
+  virtual ~Win32RenderingHelper();
+
+  virtual void Initialize(
+    bool suppress_swap_to_display, int num_windows,
+    int width, int height, base::WaitableEvent* done) OVERRIDE;
+
+  virtual void UnInitialize(base::WaitableEvent* done) OVERRIDE;
+
+  EGLNativeWindowType PlatformCreateWindow(int top_left_x,
+                                           int top_left_y) OVERRIDE;
+ private:
+  void Clear();

[Ami GONE FROM CHROMIUM, 2011/12/16 07:38:54]

This shadows the base-class Clear (which isn't virtual).
Is this really as clear as can be?

[ananta, 2011/12/17 00:40:25]

Replaced this with a virtual override combo
PlatformInitialize/PlatformUnInitialize

+
+  std::vector<HWND> windows_;
+};
+
+Win32RenderingHelper::Win32RenderingHelper()

[Ami GONE FROM CHROMIUM, 2011/12/16 07:38:54]

Single line.

[ananta, 2011/12/17 00:40:25]

Done.

+    : windows_(NULL) {
+}
+
+Win32RenderingHelper::~Win32RenderingHelper() {
+  Clear();
+}
+
+void Win32RenderingHelper::Initialize(bool suppress_swap_to_display,
+                                      int num_windows,
+                                      int width,
+                                      int height,
+                                      base::WaitableEvent* done) {
+  egl_display_ = eglGetDisplay(EGL_DEFAULT_DISPLAY);
+  RenderingHelperBase::Initialize(suppress_swap_to_display, num_windows, width,
+                                  height, done);
+  done->Signal();
+}
+
+void Win32RenderingHelper::UnInitialize(base::WaitableEvent* done) {
+  RenderingHelperBase::UnInitialize(done);

[Ami GONE FROM CHROMIUM, 2011/12/16 07:38:54]

No need to undo the eglGetDisplay() from Initialize?

[ananta, 2011/12/17 00:40:25]

That happens in the base class Clear function. We set it back to EGL_NO_DISPLAY
there.

+  Clear();
+  done->Signal();
+}
+
+void Win32RenderingHelper::Clear() {
+  for (size_t i = 0; i < windows_.size(); ++i) {
+    DestroyWindow(windows_[i]);
+  }
+  windows_.clear();
+}
+
+EGLNativeWindowType Win32RenderingHelper::PlatformCreateWindow(
+    int top_left_x, int top_left_y) {
+  HWND window = CreateWindowEx(0,
+                               L"Static",

[Ami GONE FROM CHROMIUM, 2011/12/16 07:38:54]

Wrap a bit more aggressively?

[ananta, 2011/12/17 00:40:25]

Done.

+                               L"VideoDecodeAcceleratorTest",
+                               WS_OVERLAPPEDWINDOW | WS_VISIBLE,
+                               top_left_x,
+                               top_left_y,
+                               width_,
+                               height_,
+                               NULL,
+                               NULL,
+                               NULL,
+                               NULL);
+  CHECK(window != NULL);
+  windows_.push_back(window);
+  return window;
+}
+
+#else  // OS_WIN
+
+// Provides X11 specific functionality for managing X11 resources. The OpenGL
+// and GLES management is provided by the RenderingHelperBase class.
+class OmxRenderingHelper : public RenderingHelperBase {
+ public:
+  explicit OmxRenderingHelper();
+  ~OmxRenderingHelper();
+
+  // Initialize all structures to prepare to render to one or more windows of

[Ami GONE FROM CHROMIUM, 2011/12/16 07:38:54]

Commentary isn't necessary for OVERRIDEs.  Just preface the list of overridden
methods with a 
// RenderingHelperBase implementation.

[ananta, 2011/12/17 00:40:25]

Done.

+  // the specified dimensions.  CHECK-fails if any initialization step fails.
+  // After this returns, texture creation and rendering can be requested.  This
+  // method can be called multiple times, in which case all previously-acquired
+  // resources and initializations are discarded.  If |suppress_swap_to_display|
+  // then all the usual work is done, except for the final swap of the EGL
+  // surface to the display.  This cuts test times over 50% so is worth doing
+  // when testing non-rendering-related aspects.
+  virtual void Initialize(
+    bool suppress_swap_to_display, int num_windows,
+    int width, int height, base::WaitableEvent* done) OVERRIDE;
+
+  // Undo the effects of Initialize() and signal |*done|.
+  virtual void UnInitialize(base::WaitableEvent* done) OVERRIDE;
+
+  virtual EGLNativeWindowType PlatformCreateWindow(int top_left_x,
+                                                   int top_left_y) OVERRIDE;
+
+
+ private:
+  // Zero-out internal state.  Helper for ctor & UnInitialize().
+  void Clear();
+
+  Display* x_display_;
+  std::vector<Window> x_windows_;
+};
+
+OmxRenderingHelper::OmxRenderingHelper() {
+  Clear();
+}
+
+OmxRenderingHelper::~OmxRenderingHelper() {
+  CHECK_EQ(width_, 0) << "Must call UnInitialize before dtor.";
+}
+
+void OmxRenderingHelper::Clear() {
+  x_display_ = NULL;
+  x_windows_.clear();
+}
+
+void OmxRenderingHelper::Initialize(
+    bool suppress_swap_to_display,
+    int num_windows,
+    int width, int height,
+    base::WaitableEvent* done) {
+  // Per-display X11 & EGL initialization.
+  CHECK(x_display_ = XOpenDisplay(NULL));
+  int depth = DefaultDepth(x_display_, DefaultScreen(x_display_));
+  XSetWindowAttributes window_attributes;
+  window_attributes.background_pixel =
+      BlackPixel(x_display_, DefaultScreen(x_display_));
+  window_attributes.override_redirect = true;
+
+  egl_display_ = eglGetDisplay(x_display_);
+
+  RenderingHelperBase::Initialize(suppress_swap_to_display, num_windows,
+                                  width, height, done);
+  done->Signal();
+}
+
+void OmxRenderingHelper::UnInitialize(base::WaitableEvent* done) {
+  RenderingHelperBase::Uninitialize();
+  // Destroy resources acquired in Initialize, in reverse-acquisition order.
+  for (size_t i = 0; i < x_windows_.size(); ++i) {
+    CHECK(XUnmapWindow(x_display_, x_windows_[i]));
+    CHECK(XDestroyWindow(x_display_, x_windows_[i]));
+  }
+  // Mimic newly-created object.
+  Clear();
+  done->Signal();
+}
+
+EGLNativeWindowType OmxRenderingHelper::PlatformCreateWindow(int top_left_x,
+                                                             int top_left_y) {
+  Window x_window = XCreateWindow(
+      x_display_, DefaultRootWindow(x_display_),
+      top_left_x, top_left_y, width_, height_,
+      0 /* border width */,
+      depth, CopyFromParent /* class */, CopyFromParent /* visual */,
+      (CWBackPixel | CWOverrideRedirect), &window_attributes);
+  x_windows_.push_back(x_window);
+  XStoreName(x_display_, x_window, "VideoDecodeAcceleratorTest");
+  XSelectInput(x_display_, x_window, ExposureMask);
+  XMapWindow(x_display_, x_window);
+  return x_window;
+}
+
+#endif  // OS_WIN
+
 // State of the EglRenderingVDAClient below.  Order matters here as the test
 // makes assumptions about it.
 enum ClientState {
   CS_CREATED,
   CS_DECODER_SET,
   CS_INITIALIZED,
   CS_FLUSHING,
   CS_FLUSHED,
   CS_DONE,
   CS_RESETTING,
@@ skipping 53 matching lines @@
 class EglRenderingVDAClient : public VideoDecodeAccelerator::Client {
  public:
   // Doesn't take ownership of |rendering_helper| or |note|, which must outlive
   // |*this|.
   // |reset_after_frame_num| can be a frame number >=0 indicating a mid-stream
   // Reset() should be done after that frame number is delivered, or
   // END_OF_STREAM_RESET to indicate no mid-stream Reset().
   // |delete_decoder_state| indicates when the underlying decoder should be
   // Destroy()'d and deleted and can take values: N<0: delete after -N Decode()
   // calls have been made, N>=0 means interpret as ClientState.
-  EglRenderingVDAClient(RenderingHelper* rendering_helper,
+  EglRenderingVDAClient(RenderingHelperBase* rendering_helper,
                         int rendering_window_id,
                         ClientStateNotification* note,
                         const std::string& encoded_data,
                         int num_NALUs_per_decode,
                         int num_in_flight_decodes,
                         int reset_after_frame_num,
                         int delete_decoder_state,
                         int profile);
   virtual ~EglRenderingVDAClient();
   void CreateDecoder();
@@ skipping 30 matching lines @@
   // Delete the associated OMX decoder helper.
   void DeleteDecoder();
 
   // Compute & return in |*end_pos| the end position for the next batch of NALUs
   // to ship to the decoder (based on |start_pos| & |num_NALUs_per_decode_|).
   void GetRangeForNextNALUs(size_t start_pos, size_t* end_pos);
 
   // Request decode of the next batch of NALUs in the encoded data.
   void DecodeNextNALUs();
 
-  RenderingHelper* rendering_helper_;
+  RenderingHelperBase* rendering_helper_;
+
   int rendering_window_id_;
   std::string encoded_data_;
   const int num_NALUs_per_decode_;
   const int num_in_flight_decodes_;
   int outstanding_decodes_;
   size_t encoded_data_next_pos_to_decode_;
   int next_bitstream_buffer_id_;
   ClientStateNotification* note_;
+#if defined(OS_WIN)
+  scoped_refptr<DXVAVideoDecodeAccelerator> decoder_;

[Ami GONE FROM CHROMIUM, 2011/12/16 07:38:54]

Can this simply store a scoped_refptr<media::VideoDecodeAccelerator> and avoid
the #if?

[ananta, 2011/12/17 00:40:25]

Done.

+#else  // OS_WIN
   scoped_refptr<OmxVideoDecodeAccelerator> decoder_;
+#endif  // OS_WIN
   std::set<int> outstanding_texture_ids_;
   int reset_after_frame_num_;
   int delete_decoder_state_;
   ClientState state_;
   int num_decoded_frames_;
   int num_done_bitstream_buffers_;
   PictureBufferById picture_buffers_by_id_;
   base::TimeTicks initialize_done_ticks_;
   base::TimeTicks last_frame_delivered_ticks_;
   int profile_;
 };
 
 EglRenderingVDAClient::EglRenderingVDAClient(
-    RenderingHelper* rendering_helper,
+    RenderingHelperBase* rendering_helper,
     int rendering_window_id,
     ClientStateNotification* note,
     const std::string& encoded_data,
     int num_NALUs_per_decode,
     int num_in_flight_decodes,
     int reset_after_frame_num,
     int delete_decoder_state,
     int profile)
     : rendering_helper_(rendering_helper),
       rendering_window_id_(rendering_window_id),
@@ skipping 11 matching lines @@
 
 EglRenderingVDAClient::~EglRenderingVDAClient() {
   DeleteDecoder();  // Clean up in case of expected error.
   CHECK(decoder_deleted());
   STLDeleteValues(&picture_buffers_by_id_);
   SetState(CS_DESTROYED);
 }
 
 void EglRenderingVDAClient::CreateDecoder() {
   CHECK(decoder_deleted());
+#if defined(OS_WIN)
+  decoder_ = new DXVAVideoDecodeAccelerator(this,
+                                            base::GetCurrentProcessHandle());
+#else  // OS_WIN
   decoder_ = new OmxVideoDecodeAccelerator(this);
   decoder_->SetEglState(egl_display(), egl_context());
+#endif  // OS_WIN
   SetState(CS_DECODER_SET);
   if (decoder_deleted())
     return;
 
   // Configure the decoder.
   media::VideoDecodeAccelerator::Profile profile = media::H264PROFILE_BASELINE;
   if (profile_ != -1)
     profile = static_cast<media::VideoDecodeAccelerator::Profile>(profile_);
   CHECK(decoder_->Initialize(profile));
 }
@@ skipping 194 matching lines @@
     return 0;
   return num_decoded_frames_ / delta.InSecondsF();
 }
 
 // Test parameters:
 // - Number of NALUs per Decode() call.
 // - Number of concurrent decoders.
 // - Number of concurrent in-flight Decode() calls per decoder.
 // - reset_after_frame_num: see EglRenderingVDAClient ctor.
 // - delete_decoder_phase: see EglRenderingVDAClient ctor.
-class OmxVideoDecodeAcceleratorTest
+class VideoDecodeAcceleratorTest
     : public ::testing::TestWithParam<
   Tuple5<int, int, int, ResetPoint, ClientState> > {
 };
 
 // Wait for |note| to report a state and if it's not |expected_state| then
 // assert |client| has deleted its decoder.
 static void AssertWaitForStateOrDeleted(ClientStateNotification* note,
                                         EglRenderingVDAClient* client,
                                         ClientState expected_state) {
   ClientState state = note->Wait();
   if (state == expected_state) return;
   ASSERT_TRUE(client->decoder_deleted())
       << "Decoder not deleted but Wait() returned " << state
       << ", instead of " << expected_state;
 }
 
 // We assert a minimal number of concurrent decoders we expect to succeed.
 // Different platforms can support more concurrent decoders, so we don't assert
 // failure above this.
 enum { kMinSupportedNumConcurrentDecoders = 3 };
 
 // Test the most straightforward case possible: data is decoded from a single
 // chunk and rendered to the screen.
-TEST_P(OmxVideoDecodeAcceleratorTest, TestSimpleDecode) {
+TEST_P(VideoDecodeAcceleratorTest, TestSimpleDecode) {
   // Can be useful for debugging VLOGs from OVDA.
   // logging::SetMinLogLevel(-1);
 
   // Required for Thread to work.  Not used otherwise.
   base::ShadowingAtExitManager at_exit_manager;
 
   const int num_NALUs_per_decode = GetParam().a;
   const size_t num_concurrent_decoders = GetParam().b;
   const size_t num_in_flight_decodes = GetParam().c;
   const int reset_after_frame_num = GetParam().d;
@@ skipping 15 matching lines @@
 
   // Suppress EGL surface swapping in all but a few tests, to cut down overall
   // test runtime.
   const bool suppress_swap_to_display = num_NALUs_per_decode > 1;
 
   std::vector<ClientStateNotification*> notes(num_concurrent_decoders, NULL);
   std::vector<EglRenderingVDAClient*> clients(num_concurrent_decoders, NULL);
 
   // Read in the video data.
   std::string data_str;
-  CHECK(file_util::ReadFileToString(FilePath(test_video_file), &data_str));
+  CHECK(file_util::ReadFileToString(FilePath(UTF8ToWide(test_video_file)),

[Ami GONE FROM CHROMIUM, 2011/12/16 07:38:54]

This is win-specific.
Instead use FILE_PATH_LITERAL to account for char/wchar in these APIs.

[ananta, 2011/12/17 00:40:25]

Done.

+                                    &data_str));
 
   // Initialize the rendering helper.
   base::Thread rendering_thread("EglRenderingVDAClientThread");
   rendering_thread.Start();
-  RenderingHelper rendering_helper;
+#if defined(OS_WIN)
+  Win32RenderingHelper rendering_helper;

[Ami GONE FROM CHROMIUM, 2011/12/16 07:38:54]

A crazy idea appears: if you named both renderinghelper derived classes
RenderingHelper than a lot of the #if'ing later on can go away (as well as the
need to Bind to base-class methods and rely on virtual dispatch inside of Bind,
which makes me worry).
Crazy or crazy like a fox?

[ananta, 2011/12/17 00:40:25]

Done.

+#else  // OS_WIN
+  OmxRenderingHelper rendering_helper;
+#endif  // OS_WIN
 
   base::WaitableEvent done(false, false);
   rendering_thread.message_loop()->PostTask(
       FROM_HERE,
-      base::Bind(&RenderingHelper::Initialize,
+      base::Bind(&RenderingHelperBase::Initialize,
                  base::Unretained(&rendering_helper),
                  suppress_swap_to_display, num_concurrent_decoders,
                  frame_width, frame_height, &done));
   done.Wait();
 
   // First kick off all the decoders.
   for (size_t index = 0; index < num_concurrent_decoders; ++index) {
     ClientStateNotification* note = new ClientStateNotification();
     notes[index] = note;
     EglRenderingVDAClient* client = new EglRenderingVDAClient(
@@ skipping 13 matching lines @@
   // Then wait for all the decodes to finish.
   bool saw_init_failure = false;
   for (size_t i = 0; i < num_concurrent_decoders; ++i) {
     ClientStateNotification* note = notes[i];
     ClientState state = note->Wait();
     if (state != CS_INITIALIZED) {
       saw_init_failure = true;
       // We expect initialization to fail only when more than the supported
       // number of decoders is instantiated.  Assert here that something else
       // didn't trigger failure.
-      ASSERT_GT(num_concurrent_decoders, kMinSupportedNumConcurrentDecoders);
+      ASSERT_GT(num_concurrent_decoders,
+                static_cast<size_t>(kMinSupportedNumConcurrentDecoders));
       continue;
     }
     ASSERT_EQ(state, CS_INITIALIZED);
     // InitializeDone kicks off decoding inside the client, so we just need to
     // wait for Flush.
     ASSERT_NO_FATAL_FAILURE(
         AssertWaitForStateOrDeleted(note, clients[i], CS_FLUSHING));
     ASSERT_NO_FATAL_FAILURE(
         AssertWaitForStateOrDeleted(note, clients[i], CS_FLUSHED));
     // FlushDone requests Reset().
@@ skipping 27 matching lines @@
   rendering_thread.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&STLDeleteElements<std::vector<EglRenderingVDAClient*> >,
                  &clients));
   rendering_thread.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&STLDeleteElements<std::vector<ClientStateNotification*> >,
                  &notes));
   rendering_thread.message_loop()->PostTask(
       FROM_HERE,
-      base::Bind(&RenderingHelper::UnInitialize,
+      base::Bind(&RenderingHelperBase::UnInitialize,
                  base::Unretained(&rendering_helper),
                  &done));
   done.Wait();
   rendering_thread.Stop();
 };
 
 // Test that Reset() mid-stream works fine and doesn't affect decoding even when
 // Decode() calls are made during the reset.
 INSTANTIATE_TEST_CASE_P(
-    MidStreamReset, OmxVideoDecodeAcceleratorTest,
+    MidStreamReset, VideoDecodeAcceleratorTest,
     ::testing::Values(
         MakeTuple(1, 1, 1, static_cast<ResetPoint>(100), CS_RESET)));
 
 // Test that Destroy() mid-stream works fine (primarily this is testing that no
 // crashes occur).
 INSTANTIATE_TEST_CASE_P(
-    TearDownTiming, OmxVideoDecodeAcceleratorTest,
+    TearDownTiming, VideoDecodeAcceleratorTest,
     ::testing::Values(
         MakeTuple(1, 1, 1, END_OF_STREAM_RESET, CS_DECODER_SET),
         MakeTuple(1, 1, 1, END_OF_STREAM_RESET, CS_INITIALIZED),
         MakeTuple(1, 1, 1, END_OF_STREAM_RESET, CS_FLUSHING),
         MakeTuple(1, 1, 1, END_OF_STREAM_RESET, CS_FLUSHED),
         MakeTuple(1, 1, 1, END_OF_STREAM_RESET, CS_RESETTING),
         MakeTuple(1, 1, 1, END_OF_STREAM_RESET, CS_RESET),
         MakeTuple(1, 1, 1, END_OF_STREAM_RESET, static_cast<ClientState>(-1)),
         MakeTuple(1, 1, 1, END_OF_STREAM_RESET, static_cast<ClientState>(-10)),
         MakeTuple(1, 1, 1, END_OF_STREAM_RESET,
                   static_cast<ClientState>(-100))));
 
 // Test that decoding various variation works: multiple concurrent decoders and
 // multiple NALUs per Decode() call.
 INSTANTIATE_TEST_CASE_P(
-    DecodeVariations, OmxVideoDecodeAcceleratorTest,
+    DecodeVariations, VideoDecodeAcceleratorTest,
     ::testing::Values(
         MakeTuple(1, 1, 1, END_OF_STREAM_RESET, CS_RESET),
         MakeTuple(1, 1, 10, END_OF_STREAM_RESET, CS_RESET),
         MakeTuple(1, 1, 15, END_OF_STREAM_RESET, CS_RESET),  // Tests queuing.
         MakeTuple(1, 3, 1, END_OF_STREAM_RESET, CS_RESET),
         MakeTuple(2, 1, 1, END_OF_STREAM_RESET, CS_RESET),
         MakeTuple(3, 1, 1, END_OF_STREAM_RESET, CS_RESET),
         MakeTuple(5, 1, 1, END_OF_STREAM_RESET, CS_RESET),
         MakeTuple(8, 1, 1, END_OF_STREAM_RESET, CS_RESET),
         // TODO(fischman): decoding more than 15 NALUs at once breaks decode -
         // visual artifacts are introduced as well as spurious frames are
         // delivered (more pictures are returned than NALUs are fed to the
         // decoder).  Increase the "15" below when
         // http://code.google.com/p/chrome-os-partner/issues/detail?id=4378 is
         // fixed.
         MakeTuple(15, 1, 1, END_OF_STREAM_RESET, CS_RESET)));
 
 // Find out how many concurrent decoders can go before we exhaust system
 // resources.
 INSTANTIATE_TEST_CASE_P(
-    ResourceExhaustion, OmxVideoDecodeAcceleratorTest,
+    ResourceExhaustion, VideoDecodeAcceleratorTest,
     ::testing::Values(
         // +0 hack below to promote enum to int.
         MakeTuple(1, kMinSupportedNumConcurrentDecoders + 0, 1,
                   END_OF_STREAM_RESET, CS_RESET),
         MakeTuple(1, kMinSupportedNumConcurrentDecoders + 1, 1,
                   END_OF_STREAM_RESET, CS_RESET)));
 
 // TODO(fischman, vrk): add more tests!  In particular:
 // - Test life-cycle: Seek/Stop/Pause/Play/RePlay for a single decoder.
 // - Test alternate configurations
 // - Test failure conditions.
 // - Test frame size changes mid-stream
 
 }  // namespace
 
 int main(int argc, char **argv) {
   testing::InitGoogleTest(&argc, argv);  // Removes gtest-specific args.
-  CommandLine cmd_line(argc, argv);  // Must run after InitGoogleTest.
-  CommandLine::SwitchMap switches = cmd_line.GetSwitches();
+  CommandLine::Init(argc, argv);
+
+  CommandLine* cmd_line = CommandLine::ForCurrentProcess();
+  DCHECK(cmd_line);
+
+  CommandLine::SwitchMap switches = cmd_line->GetSwitches();
   for (CommandLine::SwitchMap::const_iterator it = switches.begin();
        it != switches.end(); ++it) {
     if (it->first == "test_video_data") {
+#if defined(OS_WIN)

[Ami GONE FROM CHROMIUM, 2011/12/16 07:38:54]

FILE_PATH_LITERAL should let you lose this.

[ananta, 2011/12/17 00:40:25]

Done.

+      test_video_data = WideToUTF8(it->second);
+#else  // OS_WIN
       test_video_data = it->second.c_str();
+#endif  // OS_WIN
       continue;
     }
     LOG(FATAL) << "Unexpected switch: " << it->first << ":" << it->second;
   }
-
   return RUN_ALL_TESTS();
 }