Implement media::VideoDecodeAccelerator on Mac

content/common/gpu/media/video_decode_accelerator_unittest.cc

 // Copyright (c) 2012 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
@@ skipping 20 matching lines @@
 #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)
-#error The VideoAccelerator tests are only supported on cros/ARM/Windows.
-#endif
+#include "content/common/gpu/media/rendering_helper.h"
 
 #if defined(OS_WIN)
 #include "content/common/gpu/media/dxva_video_decode_accelerator.h"
-#else  // OS_WIN
+#elif defined(OS_CHROMEOS) && defined(ARCH_CPU_ARMEL)
 #include "content/common/gpu/media/omx_video_decode_accelerator.h"
+#elif defined(OS_MACOSX)
+#include "content/common/gpu/media/mac_video_decode_accelerator.h"
+#else
+#error The VideoAccelerator tests are not supported on this platform.
 #endif  // defined(OS_WIN)
 
-#include "third_party/angle/include/EGL/egl.h"
-
-#if defined(OS_WIN)
-#include "ui/gl/gl_bindings.h"
-#include "ui/gl/gl_context.h"
-#include "ui/gl/gl_implementation.h"
-#include "ui/gl/gl_surface.h"
-#else  // OS_WIN
-#include "third_party/angle/include/GLES2/gl2.h"
-#endif  // OS_WIN
-
 using media::VideoDecodeAccelerator;
+using video_test_util::RenderingHelper;
 
 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".
+#if defined(OS_MACOSX)
+const FilePath::CharType* test_video_data =
+    FILE_PATH_LITERAL("test-25fps_high.h264:1280:720:249:252:50:175:4");
+#else
 const FilePath::CharType* test_video_data =
     FILE_PATH_LITERAL("test-25fps.h264:320:240:250:258:50:175:1");
+#endif
+
+// AAVC data required to initialize the H.264 video decoder.
+const uint8_t MP4_EXTRA_DATA[] = {

[Ami GONE FROM CHROMIUM, 2012/05/17 21:44:47]

Hopefully you can drop this in favor of H264Parser, per my response
https://chromiumcodereview.appspot.com/10408003/#msg3

+  0x01, 0x64, 0x00, 0x1f,    0xff, 0xe1, 0x00, 0x19,
+  0x67, 0x64, 0x00, 0x1f,    0xac, 0x34, 0xec, 0x05,
+  0x00, 0x5b, 0xa1, 0x00,    0x00, 0x03, 0x00, 0x01,
+  0x00, 0x00, 0x03, 0x00,    0x32, 0x0f, 0x18, 0x31,
+  0x38, 0x01, 0x00, 0x05,    0x68, 0xef, 0xb2, 0xc8,
+  0xb0,
+};
 
 // 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(FilePath::StringType data,
                         FilePath::StringType* 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));
 }
 
-// Provides functionality for managing EGL, GLES2 and UI resources.
-// 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.
-class RenderingHelper {
- public:
-  RenderingHelper();
-  ~RenderingHelper();
-
-  // 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
-  // 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);
-
-  // Undo the effects of Initialize() and signal |*done|.
-  void UnInitialize(base::WaitableEvent* 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);
-
-  // Platform specific Init/Uninit.
-  void PlatformInitialize();
-  void PlatformUnInitialize();
-
-  // Platform specific window creation.
-  EGLNativeWindowType PlatformCreateWindow(int top_left_x, int top_left_y);
-
-  // Platform specific display surface returned here.
-  EGLDisplay PlatformGetDisplay();
-
-  EGLDisplay egl_display() { return egl_display_; }
-
-  EGLContext egl_context() { return egl_context_; }
-
-  MessageLoop* message_loop() { return message_loop_; }
-
- protected:
-  void Clear();
-
-  // We ensure all operations are carried out on the same thread by remembering
-  // where we were Initialized.
-  MessageLoop* message_loop_;
-  int width_;
-  int height_;
-  bool suppress_swap_to_display_;
-
-  EGLDisplay egl_display_;
-  EGLContext egl_context_;
-  std::vector<EGLSurface> egl_surfaces_;
-  std::map<GLuint, int> texture_id_to_surface_index_;
-
-#if defined(OS_WIN)
-  std::vector<HWND> windows_;
-#else  // OS_WIN
-  Display* x_display_;
-  std::vector<Window> x_windows_;
-#endif  // OS_WIN
-};
-
-RenderingHelper::RenderingHelper() {
-  Clear();
-}
-
-RenderingHelper::~RenderingHelper() {
-  CHECK_EQ(width_, 0) << "Must call UnInitialize before dtor.";
-  Clear();
-}
-
-// 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) {
-  // 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);
-
-  PlatformInitialize();
-
-  egl_display_ = PlatformGetDisplay();
-
-  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);
-
-    EGLNativeWindowType window = PlatformCreateWindow(top_left_x, top_left_y);
-    EGLSurface egl_surface =
-        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();
-
-  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;
-        gl_Position = in_pos;
-      }
-                                                );
-  static const char kFragmentShaderEgl[] = STRINGIZE(
-      precision mediump float;
-      varying vec2 interp_tc;
-      uniform sampler2D tex;
-      void main() {
-        gl_FragColor = texture2D(tex, interp_tc);
-      }
-                                                     );
-  GLuint program = glCreateProgram();
-  CreateShader(program, GL_VERTEX_SHADER,
-               kVertexShader, arraysize(kVertexShader));
-  CreateShader(program, GL_FRAGMENT_SHADER,
-               kFragmentShaderEgl, arraysize(kFragmentShaderEgl));
-  glLinkProgram(program);
-  int result = GL_FALSE;
-  glGetProgramiv(program, GL_LINK_STATUS, &result);
-  if (!result) {
-    char log[4096];
-    glGetShaderInfoLog(program, arraysize(log), NULL, log);
-    LOG(FATAL) << log;
-  }
-  glUseProgram(program);
-  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();
-}
-
-void RenderingHelper::UnInitialize(base::WaitableEvent* done) {
-  CHECK_EQ(MessageLoop::current(), message_loop_);
-  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_));
-  Clear();
-  done->Signal();
-}
-
-void RenderingHelper::Clear() {
-  suppress_swap_to_display_ = false;
-  width_ = 0;
-  height_ = 0;
-  texture_id_to_surface_index_.clear();
-  message_loop_ = NULL;
-  egl_display_ = EGL_NO_DISPLAY;
-  egl_context_ = EGL_NO_CONTEXT;
-  egl_surfaces_.clear();
-  PlatformUnInitialize();
-}
-
-void RenderingHelper::CreateTexture(int window_id, GLuint* texture_id,
-                                    base::WaitableEvent* done) {
-  if (MessageLoop::current() != message_loop_) {
-    message_loop_->PostTask(
-        FROM_HERE,
-        base::Bind(&RenderingHelper::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) {
-  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) {
-  glDeleteTextures(1, &texture_id);
-  CHECK_EQ(static_cast<int>(glGetError()), GL_NO_ERROR);
-}
-
-#if defined(OS_WIN)
-void RenderingHelper::PlatformInitialize() {}
-
-void RenderingHelper::PlatformUnInitialize() {
-  for (size_t i = 0; i < windows_.size(); ++i) {
-    DestroyWindow(windows_[i]);
-  }
-  windows_.clear();
-}
-
-EGLNativeWindowType RenderingHelper::PlatformCreateWindow(
-    int top_left_x, int top_left_y) {
-  HWND window = CreateWindowEx(0, L"Static", 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;
-}
-
-EGLDisplay RenderingHelper::PlatformGetDisplay() {
-  return eglGetDisplay(EGL_DEFAULT_DISPLAY);
-}
-
-#else  // OS_WIN
-
-void RenderingHelper::PlatformInitialize() {
-  CHECK(x_display_ = base::MessagePumpForUI::GetDefaultXDisplay());
-}
-
-void RenderingHelper::PlatformUnInitialize() {
-  // 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.
-  x_display_ = NULL;
-  x_windows_.clear();
-}
-
-EGLDisplay RenderingHelper::PlatformGetDisplay() {
-  return eglGetDisplay(x_display_);
-}
-
-EGLNativeWindowType RenderingHelper::PlatformCreateWindow(int top_left_x,
-                                                          int top_left_y) {
-  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;
-
-  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 65 matching lines @@
   // last play-through (governed by |num_play_throughs|).
   EglRenderingVDAClient(RenderingHelper* rendering_helper,
                         int rendering_window_id,
                         ClientStateNotification* note,
                         const std::string& encoded_data,
                         int num_NALUs_per_decode,
                         int num_in_flight_decodes,
                         int num_play_throughs,
                         int reset_after_frame_num,
                         int delete_decoder_state,
+                        int frame_width,
+                        int frame_height,
                         int profile);
   virtual ~EglRenderingVDAClient();
   void CreateDecoder();
 
   // VideoDecodeAccelerator::Client implementation.
   // The heart of the Client.
   virtual void ProvidePictureBuffers(
       uint32 requested_num_of_buffers,
       const gfx::Size& dimensions);
   virtual void DismissPictureBuffer(int32 picture_buffer_id);
   virtual void PictureReady(const media::Picture& picture);
   // Simple state changes.
   virtual void NotifyInitializeDone();
   virtual void NotifyEndOfBitstreamBuffer(int32 bitstream_buffer_id);
   virtual void NotifyFlushDone();
   virtual void NotifyResetDone();
   virtual void NotifyError(VideoDecodeAccelerator::Error error);
 
   // Simple getters for inspecting the state of the Client.
   ClientState state() { return state_; }
   int num_done_bitstream_buffers() { return num_done_bitstream_buffers_; }
   int num_decoded_frames() { return num_decoded_frames_; }
-  EGLDisplay egl_display() { return rendering_helper_->egl_display(); }
-  EGLContext egl_context() { return rendering_helper_->egl_context(); }
   double frames_per_second();
   bool decoder_deleted() { return !decoder_; }
 
  private:
   typedef std::map<int, media::PictureBuffer*> PictureBufferById;
 
   void SetState(ClientState new_state);
 
   // Delete the associated OMX decoder helper.
   void DeleteDecoder();
@@ skipping 18 matching lines @@
   std::set<int> outstanding_texture_ids_;
   int remaining_play_throughs_;
   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 frame_width_;
+  int frame_height_;
   int profile_;
 };
 
 EglRenderingVDAClient::EglRenderingVDAClient(
     RenderingHelper* rendering_helper,
     int rendering_window_id,
     ClientStateNotification* note,
     const std::string& encoded_data,
     int num_NALUs_per_decode,
     int num_in_flight_decodes,
     int num_play_throughs,
     int reset_after_frame_num,
     int delete_decoder_state,
+    int frame_width,
+    int frame_height,
     int profile)
     : rendering_helper_(rendering_helper),
       rendering_window_id_(rendering_window_id),
       encoded_data_(encoded_data), num_NALUs_per_decode_(num_NALUs_per_decode),
       num_in_flight_decodes_(num_in_flight_decodes), outstanding_decodes_(0),
       encoded_data_next_pos_to_decode_(0), next_bitstream_buffer_id_(0),
       note_(note),
       remaining_play_throughs_(num_play_throughs),
       reset_after_frame_num_(reset_after_frame_num),
       delete_decoder_state_(delete_decoder_state),
       state_(CS_CREATED),
       num_decoded_frames_(0), num_done_bitstream_buffers_(0),
+      frame_width_(frame_width),
+      frame_height_(frame_height),
       profile_(profile) {
   CHECK_GT(num_NALUs_per_decode, 0);
   CHECK_GT(num_in_flight_decodes, 0);
   CHECK_GT(num_play_throughs, 0);
 }
 
 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)
   scoped_refptr<DXVAVideoDecodeAccelerator> decoder =
       new DXVAVideoDecodeAccelerator(this);
-#else  // OS_WIN
+#elif defined(OS_CHROMEOS) && defined(ARCH_CPU_ARMEL)
   scoped_refptr<OmxVideoDecodeAccelerator> decoder =
       new OmxVideoDecodeAccelerator(this);
-  decoder->SetEglState(egl_display(), egl_context());
+  decoder->SetEglState(
+      static_cast<EGLDisplay>(rendering_helper->GetGLDisplay()),
+      static_cast<EGLContext>(rendering_helper->GetGLContext()));
+#elif defined(OS_MACOSX)
+  scoped_refptr<MacVideoDecodeAccelerator> decoder =
+      new MacVideoDecodeAccelerator(this);
+  decoder->SetGLContext(rendering_helper_->GetGLContext());
+  std::vector<uint8_t> avc_data(MP4_EXTRA_DATA,
+                                MP4_EXTRA_DATA + arraysize(MP4_EXTRA_DATA));
+  if (!decoder->SetConfigInfo(frame_width_, frame_height_, avc_data)) {
+    SetState(CS_ERROR);
+    return;
+  }
 #endif  // OS_WIN
   decoder_ = decoder.release();
   SetState(CS_DECODER_SET);
   if (decoder_deleted())
     return;
 
   // Configure the decoder.
   media::VideoCodecProfile profile = media::H264PROFILE_BASELINE;
   if (profile_ != -1)
     profile = static_cast<media::VideoCodecProfile>(profile_);
   CHECK(decoder_->Initialize(profile));
 }
 
 void EglRenderingVDAClient::ProvidePictureBuffers(
     uint32 requested_num_of_buffers,
     const gfx::Size& dimensions) {
   if (decoder_deleted())
     return;
   std::vector<media::PictureBuffer> buffers;
 
   for (uint32 i = 0; i < requested_num_of_buffers; ++i) {
     uint32 id = picture_buffers_by_id_.size();
-    GLuint texture_id;
+    uint32 texture_id;
     base::WaitableEvent done(false, false);
     rendering_helper_->CreateTexture(rendering_window_id_, &texture_id, &done);
     done.Wait();
     CHECK(outstanding_texture_ids_.insert(texture_id).second);
     media::PictureBuffer* buffer =
         new media::PictureBuffer(id, dimensions, texture_id);
     CHECK(picture_buffers_by_id_.insert(std::make_pair(id, buffer)).second);
     buffers.push_back(*buffer);
   }
   decoder_->AssignPictureBuffers(buffers);
-  CHECK_EQ(static_cast<int>(glGetError()), GL_NO_ERROR);
-  CHECK_EQ(static_cast<int>(eglGetError()), EGL_SUCCESS);
 }
 
 void EglRenderingVDAClient::DismissPictureBuffer(int32 picture_buffer_id) {
   PictureBufferById::iterator it =
       picture_buffers_by_id_.find(picture_buffer_id);
   CHECK(it != picture_buffers_by_id_.end());
   CHECK_EQ(outstanding_texture_ids_.erase(it->second->texture_id()), 1U);
   rendering_helper_->DeleteTexture(it->second->texture_id());
   delete it->second;
   picture_buffers_by_id_.erase(it);
@@ skipping 149 matching lines @@
   // Populate the shared memory buffer w/ the NALU, duplicate its handle, and
   // hand it off to the decoder.
   base::SharedMemory shm;
   CHECK(shm.CreateAndMapAnonymous(end_pos - start_pos))
       << start_pos << ", " << end_pos;
   memcpy(shm.memory(), encoded_data_.data() + start_pos, end_pos - start_pos);
   base::SharedMemoryHandle dup_handle;
   CHECK(shm.ShareToProcess(base::Process::Current().handle(), &dup_handle));
   media::BitstreamBuffer bitstream_buffer(
       next_bitstream_buffer_id_++, dup_handle, end_pos - start_pos);
-  decoder_->Decode(bitstream_buffer);
+  // Avoid becoming reentrant by decoding on next event cycle.
+  MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&VideoDecodeAccelerator::Decode, decoder_, bitstream_buffer));
+
   ++outstanding_decodes_;
   encoded_data_next_pos_to_decode_ = end_pos;
 
   if (!remaining_play_throughs_ &&
       -delete_decoder_state_ == next_bitstream_buffer_id_) {
     DeleteDecoder();

[Ami GONE FROM CHROMIUM, 2012/05/17 21:44:47]

I think you missed my comment:
Should this be posting instead of calling in-line to account for outstanding
Decode tasks from above, now?

   }
 }
 
 double EglRenderingVDAClient::frames_per_second() {
   base::TimeDelta delta = last_frame_delivered_ticks_ - initialize_done_ticks_;
   if (delta.InSecondsF() == 0)
     return 0;
   return num_decoded_frames_ / delta.InSecondsF();
 }
 
@@ skipping 72 matching lines @@
   base::Thread rendering_thread("EglRenderingVDAClientThread");
   base::Thread::Options options;
   options.message_loop_type = MessageLoop::TYPE_DEFAULT;
 #if defined(OS_WIN)
   // For windows the decoding thread initializes the media foundation decoder
   // which uses COM. We need the thread to be a UI thread.
   options.message_loop_type = MessageLoop::TYPE_UI;
 #endif  // OS_WIN
 
   rendering_thread.StartWithOptions(options);
-  RenderingHelper rendering_helper;
+  scoped_ptr<RenderingHelper> rendering_helper(RenderingHelper::Create());
 
   base::WaitableEvent done(false, false);
   rendering_thread.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&RenderingHelper::Initialize,
-                 base::Unretained(&rendering_helper),
+                 base::Unretained(rendering_helper.get()),
                  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(
-        &rendering_helper, index,
-        note, data_str, num_NALUs_per_decode,
-        num_in_flight_decodes, num_play_throughs,
-        reset_after_frame_num, delete_decoder_state, profile);
+        rendering_helper.get(), index, note, data_str, num_NALUs_per_decode,
+        num_in_flight_decodes, num_play_throughs, reset_after_frame_num,
+        delete_decoder_state, frame_width, frame_height, profile);
     clients[index] = client;
 
     rendering_thread.message_loop()->PostTask(
         FROM_HERE,
         base::Bind(&EglRenderingVDAClient::CreateDecoder,
                    base::Unretained(client)));
 
     ASSERT_EQ(note->Wait(), CS_DECODER_SET);
   }
   // Then wait for all the decodes to finish.
@@ skipping 59 matching lines @@
       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::Unretained(&rendering_helper),
+                 base::Unretained(rendering_helper.get()),
                  &done));
   done.Wait();
   rendering_thread.Stop();
 };
 
 // Test that replay after EOS works fine.
 INSTANTIATE_TEST_CASE_P(
     ReplayAfterEOS, VideoDecodeAcceleratorTest,
     ::testing::Values(
         MakeTuple(1, 1, 1, 4, END_OF_STREAM_RESET, CS_RESET)));
@@ skipping 73 matching lines @@
 
   CommandLine::SwitchMap switches = cmd_line->GetSwitches();
   for (CommandLine::SwitchMap::const_iterator it = switches.begin();
        it != switches.end(); ++it) {
     if (it->first == "test_video_data") {
       test_video_data = it->second.c_str();
       continue;
     }
     LOG(FATAL) << "Unexpected switch: " << it->first << ":" << it->second;
   }
+
+  base::ShadowingAtExitManager at_exit_manager;
+  RenderingHelper::InitializePlatform();
+
 #if defined(OS_WIN)
-  base::ShadowingAtExitManager at_exit_manager;
-  gfx::InitializeGLBindings(gfx::kGLImplementationEGLGLES2);
-  gfx::GLSurface::InitializeOneOff();
-  {
-    // Hack to ensure that EGL extension function pointers are initialized.
-    scoped_refptr<gfx::GLSurface> surface(
-        gfx::GLSurface::CreateOffscreenGLSurface(false, gfx::Size(1, 1)));
-    scoped_refptr<gfx::GLContext> context(
-        gfx::GLContext::CreateGLContext(NULL, surface.get(),
-                                        gfx::PreferIntegratedGpu));
-    context->MakeCurrent(surface.get());
-  }
   DXVAVideoDecodeAccelerator::PreSandboxInitialization();
-#endif  // OS_WIN
+#endif
+
   return RUN_ALL_TESTS();
 }