VAVDA: Redesign stage 1.

content/common/gpu/media/vaapi_h264_decoder.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.
 
-#include <dlfcn.h>
-
 #include <algorithm>
 #include <limits>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
-#include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "content/common/gpu/media/vaapi_h264_decoder.h"
-#include "third_party/libva/va/va.h"
-#include "third_party/libva/va/va_x11.h"
-#include "ui/gl/gl_bindings.h"
-#include "ui/gl/scoped_binders.h"
-
-namespace {
-
-enum VAVDAH264DecoderFailure {
-  FRAME_MBS_ONLY_FLAG_NOT_ONE = 0,
-  GAPS_IN_FRAME_NUM = 1,
-  MID_STREAM_RESOLUTION_CHANGE = 2,
-  INTERLACED_STREAM = 3,
-  VAAPI_ERROR = 4,
-  VAVDA_H264_DECODER_FAILURES_MAX,
-};
-
-static void ReportToUMA(VAVDAH264DecoderFailure failure) {
-  UMA_HISTOGRAM_ENUMERATION("Media.VAVDAH264.DecoderFailure",
-                            failure,
-                            VAVDA_H264_DECODER_FAILURES_MAX);
-}
-
-}  // namespace
-
-#define LOG_VA_ERROR_AND_RECORD_UMA(va_res, err_msg)       \
-  do {                                                     \
-      DVLOG(1) << err_msg                                  \
-               << " VA error: " << VAAPI_ErrorStr(va_res); \
-      ReportToUMA(VAAPI_ERROR);                            \
-  } while (0)
-
-#define VA_LOG_ON_ERROR(va_res, err_msg)                   \
-  do {                                                     \
-    if ((va_res) != VA_STATUS_SUCCESS) {                   \
-      LOG_VA_ERROR_AND_RECORD_UMA(va_res, err_msg);        \
-    }                                                      \
-  } while (0)
-
-#define VA_SUCCESS_OR_RETURN(va_res, err_msg, ret)         \
-  do {                                                     \
-    if ((va_res) != VA_STATUS_SUCCESS) {                   \
-      LOG_VA_ERROR_AND_RECORD_UMA(va_res, err_msg);        \
-      return (ret);                                        \
-    }                                                      \
-  } while (0)
 
 namespace content {
 
-void *vaapi_handle = NULL;
-void *vaapi_x11_handle = NULL;
-
-typedef VADisplay (*VaapiGetDisplay)(Display *dpy);
-typedef int (*VaapiDisplayIsValid)(VADisplay dpy);
-typedef VAStatus (*VaapiInitialize)(VADisplay dpy,
-                                    int *major_version,
-                                    int *minor_version);
-typedef VAStatus (*VaapiTerminate)(VADisplay dpy);
-typedef VAStatus (*VaapiGetConfigAttributes)(VADisplay dpy,
-                                             VAProfile profile,
-                                             VAEntrypoint entrypoint,
-                                             VAConfigAttrib *attrib_list,
-                                             int num_attribs);
-typedef VAStatus (*VaapiCreateConfig)(VADisplay dpy,
-                                      VAProfile profile,
-                                      VAEntrypoint entrypoint,
-                                      VAConfigAttrib *attrib_list,
-                                      int num_attribs,
-                                      VAConfigID *config_id);
-typedef VAStatus (*VaapiDestroyConfig)(VADisplay dpy, VAConfigID config_id);
-typedef VAStatus (*VaapiCreateSurfaces)(VADisplay dpy,
-                                        int width,
-                                        int height,
-                                        int format,
-                                        int num_surfaces,
-                                        VASurfaceID *surfaces);
-typedef VAStatus (*VaapiDestroySurfaces)(VADisplay dpy,
-                                         VASurfaceID *surfaces,
-                                         int num_surfaces);
-typedef VAStatus (*VaapiCreateContext)(VADisplay dpy,
-                                       VAConfigID config_id,
-                                       int picture_width,
-                                       int picture_height,
-                                       int flag,
-                                       VASurfaceID *render_targets,
-                                       int num_render_targets,
-                                       VAContextID *context);
-typedef VAStatus (*VaapiDestroyContext)(VADisplay dpy, VAContextID context);
-typedef VAStatus (*VaapiPutSurface)(VADisplay dpy,
-                                    VASurfaceID surface,
-                                    Drawable draw,
-                                    short srcx,
-                                    short srcy,
-                                    unsigned short srcw,
-                                    unsigned short srch,
-                                    short destx,
-                                    short desty,
-                                    unsigned short destw,
-                                    unsigned short desth,
-                                    VARectangle *cliprects,
-                                    unsigned int number_cliprects,
-                                    unsigned int flags);
-typedef VAStatus (*VaapiSyncSurface)(VADisplay dpy, VASurfaceID render_target);
-typedef VAStatus (*VaapiBeginPicture)(VADisplay dpy,
-                                      VAContextID context,
-                                      VASurfaceID render_target);
-typedef VAStatus (*VaapiRenderPicture)(VADisplay dpy,
-                                       VAContextID context,
-                                       VABufferID *buffers,
-                                       int num_buffers);
-typedef VAStatus (*VaapiEndPicture)(VADisplay dpy, VAContextID context);
-typedef VAStatus (*VaapiCreateBuffer)(VADisplay dpy,
-                                      VAContextID context,
-                                      VABufferType type,
-                                      unsigned int size,
-                                      unsigned int num_elements,
-                                      void *data,
-                                      VABufferID *buf_id);
-typedef VAStatus (*VaapiDestroyBuffer)(VADisplay dpy, VABufferID buffer_id);
-typedef const char* (*VaapiErrorStr)(VAStatus error_status);
-
-#define VAAPI_SYM(name, handle) Vaapi##name VAAPI_##name = NULL
-
-VAAPI_SYM(GetDisplay, vaapi_x11_handle);
-VAAPI_SYM(DisplayIsValid, vaapi_handle);
-VAAPI_SYM(Initialize, vaapi_handle);
-VAAPI_SYM(Terminate, vaapi_handle);
-VAAPI_SYM(GetConfigAttributes, vaapi_handle);
-VAAPI_SYM(CreateConfig, vaapi_handle);
-VAAPI_SYM(DestroyConfig, vaapi_handle);
-VAAPI_SYM(CreateSurfaces, vaapi_handle);
-VAAPI_SYM(DestroySurfaces, vaapi_handle);
-VAAPI_SYM(CreateContext, vaapi_handle);
-VAAPI_SYM(DestroyContext, vaapi_handle);
-VAAPI_SYM(PutSurface, vaapi_x11_handle);
-VAAPI_SYM(SyncSurface, vaapi_x11_handle);
-VAAPI_SYM(BeginPicture, vaapi_handle);
-VAAPI_SYM(RenderPicture, vaapi_handle);
-VAAPI_SYM(EndPicture, vaapi_handle);
-VAAPI_SYM(CreateBuffer, vaapi_handle);
-VAAPI_SYM(DestroyBuffer, vaapi_handle);
-VAAPI_SYM(ErrorStr, vaapi_handle);
-
-// static
-bool VaapiH264Decoder::pre_sandbox_init_done_ = false;
-
+// Decode surface, used for decoding and reference. input_id comes from client
+// and is associated with the surface that was produced as the result
+// of decoding a bitstream buffer with that id.
 class VaapiH264Decoder::DecodeSurface {
  public:
-  DecodeSurface(const GLXFBConfig& fb_config,
-                Display* x_display,
-                VADisplay va_display,
-                const base::Callback<bool(void)>& make_context_current,
-                VASurfaceID va_surface_id,
-                int32 picture_buffer_id,
-                uint32 texture_id,
-                int width, int height);
+  DecodeSurface(int poc,
+                int32 input_id,
+                const scoped_refptr<VASurface>& va_surface);
+  DecodeSurface(int poc, const scoped_refptr<DecodeSurface>& dec_surface);
   ~DecodeSurface();
 
-  VASurfaceID va_surface_id() {
-    return va_surface_id_;
+  int poc() {
+    return poc_;
   }
 
-  int32 picture_buffer_id() {
-    return picture_buffer_id_;
-  }
-
-  uint32 texture_id() {
-    return texture_id_;
-  }
-
-  bool available() {
-    return available_;
-  }
-
-  bool used() {
-    return used_;
-  }
-
-  void set_used(bool used) {
-    DCHECK(!available_);
-    used_ = used;
-  }
-
-  bool at_client() {
-    return at_client_;
-  }
-
-  void set_at_client(bool at_client) {
-    DCHECK(!available_);
-    at_client_ = at_client;
+  scoped_refptr<VASurface> va_surface() {
+    return va_surface_;
   }
 
   int32 input_id() {
     return input_id_;
   }
 
-  int poc() {
-    return poc_;
-  }
-
-  // Associate the surface with |input_id| and |poc|, and make it unavailable
-  // (in use).
-  void Acquire(int32 input_id, int poc);
-
-  // Make this surface available, ready to be reused.
-  void Release();
-
-  // Has to be called before output to sync texture contents.
-  // Returns true if successful.
-  bool Sync();
-
  private:
-  Display* x_display_;
-  VADisplay va_display_;
-  base::Callback<bool(void)> make_context_current_;
-  VASurfaceID va_surface_id_;
-
-  // Client-provided ids.
+  int poc_;
   int32 input_id_;
-  int32 picture_buffer_id_;
-  uint32 texture_id_;
-
-  int width_;
-  int height_;
-
-  // Available for decoding (data no longer used for reference or displaying).
-  // TODO(posciak): this is almost surely not needed anymore. Rethink and
-  // remove if possible.
-  bool available_;
-  // Used for decoding.
-  bool used_;
-  // Whether the surface has been sent to client for display.
-  bool at_client_;
-
-  // PicOrderCount
-  int poc_;
-
-  // Pixmaps bound to this texture.
-  Pixmap x_pixmap_;
-  GLXPixmap glx_pixmap_;
-
-  DISALLOW_COPY_AND_ASSIGN(DecodeSurface);
+  scoped_refptr<VASurface> va_surface_;
 };
 
 VaapiH264Decoder::DecodeSurface::DecodeSurface(
-    const GLXFBConfig& fb_config,
-    Display* x_display,
-    VADisplay va_display,
-    const base::Callback<bool(void)>& make_context_current,
-    VASurfaceID va_surface_id,
-    int32 picture_buffer_id,
-    uint32 texture_id,
-    int width, int height)
-    : x_display_(x_display),
-      va_display_(va_display),
-      make_context_current_(make_context_current),
-      va_surface_id_(va_surface_id),
-      input_id_(0),
-      picture_buffer_id_(picture_buffer_id),
-      texture_id_(texture_id),
-      width_(width),
-      height_(height),
-      available_(false),
-      used_(false),
-      at_client_(false),
-      poc_(0),
-      x_pixmap_(0),
-      glx_pixmap_(0) {
-  // Bind the surface to a texture of the given width and height,
-  // allocating pixmaps as needed.
-  if (!make_context_current_.Run())
-    return;
-
-  gfx::ScopedTextureBinder texture_binder(GL_TEXTURE_2D, texture_id_);
-  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-
-  XWindowAttributes win_attr;
-  int screen = DefaultScreen(x_display_);
-  XGetWindowAttributes(x_display_, RootWindow(x_display_, screen), &win_attr);
-  //TODO(posciak): pass the depth required by libva, not the RootWindow's depth
-  x_pixmap_ = XCreatePixmap(x_display_, RootWindow(x_display_, screen),
-                            width_, height_, win_attr.depth);
-  if (!x_pixmap_) {
-    DVLOG(1) << "Failed creating an X Pixmap for TFP";
-    return;
-  }
-
-  static const int pixmap_attr[] = {
-    GLX_TEXTURE_TARGET_EXT, GLX_TEXTURE_2D_EXT,
-    GLX_TEXTURE_FORMAT_EXT, GLX_TEXTURE_FORMAT_RGB_EXT,
-    GL_NONE,
-  };
-
-  glx_pixmap_ = glXCreatePixmap(x_display_, fb_config, x_pixmap_, pixmap_attr);
-  if (!glx_pixmap_) {
-    // x_pixmap_ will be freed in the destructor.
-    DVLOG(1) << "Failed creating a GLX Pixmap for TFP";
-    return;
-  }
-
-  glXBindTexImageEXT(x_display_, glx_pixmap_, GLX_FRONT_LEFT_EXT, NULL);
-
-  available_ = true;
+    int poc,
+    int32 input_id,
+    const scoped_refptr<VASurface>& va_surface)
+    : poc_(poc),
+      input_id_(input_id),
+      va_surface_(va_surface) {
+  DCHECK(va_surface_.get());
 }
 
 VaapiH264Decoder::DecodeSurface::~DecodeSurface() {
-  // Unbind surface from texture and deallocate resources.
-  if (glx_pixmap_ && make_context_current_.Run()) {
-    glXReleaseTexImageEXT(x_display_, glx_pixmap_, GLX_FRONT_LEFT_EXT);
-    glXDestroyPixmap(x_display_, glx_pixmap_);
-  }
-
-  if (x_pixmap_)
-    XFreePixmap(x_display_, x_pixmap_);
-  XSync(x_display_, False);  // Needed to work around buggy vdpau-driver.
 }
 
-void VaapiH264Decoder::DecodeSurface::Acquire(int32 input_id, int poc) {
-  DCHECK_EQ(available_, true);
-  available_ = false;
-  at_client_ = false;
-  used_ = true;
-  input_id_ = input_id;
-  poc_ = poc;
-}
-
-void VaapiH264Decoder::DecodeSurface::Release() {
-  DCHECK_EQ(available_, false);
-  available_ = true;
-  used_ = false;
-  at_client_ = false;
-}
-
-bool VaapiH264Decoder::DecodeSurface::Sync() {
-  if (!make_context_current_.Run())
-    return false;
-
-  // Wait for the data to be put into the buffer so it'd ready for output.
-  VAStatus va_res = VAAPI_SyncSurface(va_display_, va_surface_id_);
-  VA_SUCCESS_OR_RETURN(va_res, "Failed syncing decoded picture", false);
-
-  // Put the decoded data into XPixmap bound to the texture.
-  va_res = VAAPI_PutSurface(va_display_,
-                            va_surface_id_, x_pixmap_,
-                            0, 0, width_, height_,
-                            0, 0, width_, height_,
-                            NULL, 0, 0);
-  VA_SUCCESS_OR_RETURN(va_res, "Failed putting decoded picture to texture",
-                       false);
-
-  return true;
-}
-
-VaapiH264Decoder::VaapiH264Decoder() {
+VaapiH264Decoder::VaapiH264Decoder(
+    VaapiWrapper* vaapi_wrapper,
+    const OutputPicCB& output_pic_cb,
+    const ReportErrorToUmaCB& report_error_to_uma_cb)
+    : max_pic_order_cnt_lsb_(0),
+      max_frame_num_(0),
+      max_pic_num_(0),
+      max_long_term_frame_idx_(0),
+      curr_sps_id_(-1),
+      curr_pps_id_(-1),
+      vaapi_wrapper_(vaapi_wrapper),
+      output_pic_cb_(output_pic_cb),
+      report_error_to_uma_cb_(report_error_to_uma_cb) {
   Reset();
-  curr_input_id_ = -1;
-  x_display_ = NULL;
-  fb_config_ = NULL;
-  va_display_ = NULL;
-  curr_sps_id_ = -1;
-  curr_pps_id_ = -1;
-  pic_width_ = -1;
-  pic_height_ = -1;
-  max_frame_num_ = 0;
-  max_pic_num_ = 0;
-  max_long_term_frame_idx_ = 0;
-  max_pic_order_cnt_lsb_ = 0;
-  state_ = kUninitialized;
-  num_available_decode_surfaces_ = 0;
-  va_context_created_ = false;
-  last_output_poc_ = 0;
 }
 
 VaapiH264Decoder::~VaapiH264Decoder() {
-  Destroy();
 }
 
-// This puts the decoder in state where it keeps stream data and is ready
-// to resume playback from a random location in the stream, but drops all
-// inputs and outputs and makes all surfaces available for use.
 void VaapiH264Decoder::Reset() {
-  frame_ready_at_hw_ = false;
-
   curr_pic_.reset();
 
+  curr_input_id_ = -1;
   frame_num_ = 0;
   prev_frame_num_ = -1;
   prev_frame_num_offset_ = -1;
 
   prev_ref_has_memmgmnt5_ = false;
   prev_ref_top_field_order_cnt_ = -1;
   prev_ref_pic_order_cnt_msb_ = -1;
   prev_ref_pic_order_cnt_lsb_ = -1;
   prev_ref_field_ = H264Picture::FIELD_NONE;
 
-  // When called from the constructor, although va_display_ is invalid,
-  // |pending_slice_bufs_| and |pending_va_bufs_| are empty.
-  DestroyPendingBuffers();
-
-  pending_slice_bufs_ = std::queue<VABufferID>();
-  pending_va_bufs_ = std::queue<VABufferID>();
+  vaapi_wrapper_->DestroyPendingBuffers();
 
   ref_pic_list0_.clear();
   ref_pic_list1_.clear();
 
-  for (POCToDecodeSurfaces::iterator it = poc_to_decode_surfaces_.begin();
-       it != poc_to_decode_surfaces_.end(); ) {
+  for (DecSurfacesInUse::iterator it = decode_surfaces_in_use_.begin();
+       it != decode_surfaces_in_use_.end(); ) {
     int poc = it->second->poc();
     // Must be incremented before UnassignSurfaceFromPoC as this call
     // invalidates |it|.
     ++it;
     UnassignSurfaceFromPoC(poc);
   }
-  DCHECK(poc_to_decode_surfaces_.empty());
+  DCHECK(decode_surfaces_in_use_.empty());
 
   dpb_.Clear();
   parser_.Reset();
   last_output_poc_ = 0;
 
-  // Still initialized and ready to decode, unless called from constructor,
-  // which will change it back.
-  state_ = kAfterReset;
+  state_ = kIdle;
 }
 
-void VaapiH264Decoder::Destroy() {
-  if (state_ == kUninitialized)
-    return;
-
-  VAStatus va_res;
-  bool destroy_surfaces = false;
-  switch (state_) {
-    case kDecoding:
-    case kAfterReset:
-    case kError:
-      destroy_surfaces = true;
-      // fallthrough
-    case kInitialized:
-      if (!make_context_current_.Run())
-        break;
-      if (destroy_surfaces)
-        DestroyVASurfaces();
-      DestroyPendingBuffers();
-      va_res = VAAPI_DestroyConfig(va_display_, va_config_id_);
-      VA_LOG_ON_ERROR(va_res, "vaDestroyConfig failed");
-      va_res = VAAPI_Terminate(va_display_);
-      VA_LOG_ON_ERROR(va_res, "vaTerminate failed");
-      // fallthrough
-    case kUninitialized:
-      break;
-  }
-
-  state_ = kUninitialized;
-}
-
-// Maps Profile enum values to VaProfile values.
-bool VaapiH264Decoder::SetProfile(media::VideoCodecProfile profile) {
-  switch (profile) {
-    case media::H264PROFILE_BASELINE:
-      profile_ = VAProfileH264Baseline;
-      break;
-    case media::H264PROFILE_MAIN:
-      profile_ = VAProfileH264Main;
-      break;
-    case media::H264PROFILE_HIGH:
-      profile_ = VAProfileH264High;
-      break;
-    default:
-      return false;
-  }
-  return true;
-}
-
-class ScopedPtrXFree {
- public:
-  void operator()(void* x) const {
-    ::XFree(x);
-  }
-};
-
-bool VaapiH264Decoder::InitializeFBConfig() {
-  const int fbconfig_attr[] = {
-    GLX_DRAWABLE_TYPE, GLX_PIXMAP_BIT,
-    GLX_BIND_TO_TEXTURE_TARGETS_EXT, GLX_TEXTURE_2D_BIT_EXT,
-    GLX_BIND_TO_TEXTURE_RGB_EXT, GL_TRUE,
-    GLX_Y_INVERTED_EXT, GL_TRUE,
-    GL_NONE,
-  };
-
-  int num_fbconfigs;
-  scoped_ptr_malloc<GLXFBConfig, ScopedPtrXFree> glx_fb_configs(
-      glXChooseFBConfig(x_display_, DefaultScreen(x_display_), fbconfig_attr,
-                        &num_fbconfigs));
-  if (!glx_fb_configs)
-    return false;
-  if (!num_fbconfigs)
-    return false;
-
-  fb_config_ = glx_fb_configs.get()[0];
-  return true;
-}
-
-bool VaapiH264Decoder::Initialize(
-    media::VideoCodecProfile profile,
-    Display* x_display,
-    GLXContext glx_context,
-    const base::Callback<bool(void)>& make_context_current,
-    const OutputPicCB& output_pic_cb,
-    const SubmitDecodeCB& submit_decode_cb) {
-  DCHECK_EQ(state_, kUninitialized);
-
-  output_pic_cb_ = output_pic_cb;
-  submit_decode_cb_ = submit_decode_cb;
-
-  x_display_ = x_display;
-  make_context_current_ = make_context_current;
-
-  if (!make_context_current_.Run())
-    return false;
-
-  if (!SetProfile(profile)) {
-    DVLOG(1) << "Unsupported profile";
-    return false;
-  }
-
-  if (!InitializeFBConfig()) {
-    DVLOG(1) << "Could not get a usable FBConfig";
-    return false;
-  }
-
-  va_display_ = VAAPI_GetDisplay(x_display_);
-  if (!VAAPI_DisplayIsValid(va_display_)) {
-    DVLOG(1) << "Could not get a valid VA display";
-    return false;
-  }
-
-  int major_version, minor_version;
-  VAStatus va_res;
-  va_res = VAAPI_Initialize(va_display_, &major_version, &minor_version);
-  VA_SUCCESS_OR_RETURN(va_res, "vaInitialize failed", false);
-  DVLOG(1) << "VAAPI version: " << major_version << "." << minor_version;
-
-  VAConfigAttrib attrib;
-  attrib.type = VAConfigAttribRTFormat;
-
-  VAEntrypoint entrypoint = VAEntrypointVLD;
-  va_res = VAAPI_GetConfigAttributes(va_display_, profile_, entrypoint,
-                                     &attrib, 1);
-  VA_SUCCESS_OR_RETURN(va_res, "vaGetConfigAttributes failed", false);
-
-  if (!(attrib.value & VA_RT_FORMAT_YUV420)) {
-    DVLOG(1) << "YUV420 not supported";
-    return false;
-  }
-
-  va_res = VAAPI_CreateConfig(va_display_, profile_, entrypoint,
-                              &attrib, 1, &va_config_id_);
-  VA_SUCCESS_OR_RETURN(va_res, "vaCreateConfig failed", false);
-
-  state_ = kInitialized;
-  return true;
-}
-
-void VaapiH264Decoder::ReusePictureBuffer(int32 picture_buffer_id) {
-  DecodeSurfaces::iterator it = decode_surfaces_.find(picture_buffer_id);
-  if (it == decode_surfaces_.end()) {
-    DVLOG(1) << "Asked to reuse an invalid surface "
-             << picture_buffer_id;
-    return;
-  }
-  if (it->second->available()) {
-    DVLOG(1) << "Asked to reuse an already available surface "
-             << picture_buffer_id;
-    return;
-  }
-
-  it->second->set_at_client(false);
-  if (!it->second->used()) {
-    it->second->Release();
-    ++num_available_decode_surfaces_;
-  }
-}
-
-bool VaapiH264Decoder::AssignPictureBuffer(int32 picture_buffer_id,
-                                           uint32 texture_id) {
-  DCHECK_EQ(state_, kDecoding);
-
-  if (decode_surfaces_.size() >= GetRequiredNumOfPictures()) {
-    DVLOG(1) << "Got more surfaces than required";
-    return false;
-  }
-
-  // This will not work if we start using VDA.DismissPicture()
-  linked_ptr<DecodeSurface> dec_surface(new DecodeSurface(
-      fb_config_, x_display_, va_display_, make_context_current_,
-      va_surface_ids_[decode_surfaces_.size()], picture_buffer_id, texture_id,
-      pic_width_, pic_height_));
-  if (!dec_surface->available()) {
-    DVLOG(1) << "Error creating a decoding surface (binding to texture?)";
-    return false;
-  }
-
-  DVLOG(2) << "New picture assigned, texture id: " << dec_surface->texture_id()
-           << " pic buf id: " << dec_surface->picture_buffer_id()
-           << " will use va surface " << dec_surface->va_surface_id();
-
-  bool inserted = decode_surfaces_.insert(std::make_pair(picture_buffer_id,
-                                                         dec_surface)).second;
-  DCHECK(inserted);
-  ++num_available_decode_surfaces_;
-
-  return true;
-}
-
-bool VaapiH264Decoder::CreateVASurfaces() {
-  DCHECK_NE(pic_width_, -1);
-  DCHECK_NE(pic_height_, -1);
-  if (state_ == kAfterReset)
-    return true;
-  DCHECK_EQ(state_, kInitialized);
-
-  // Allocate VASurfaces in driver.
-  VAStatus va_res = VAAPI_CreateSurfaces(va_display_, pic_width_,
-                                         pic_height_, VA_RT_FORMAT_YUV420,
-                                         GetRequiredNumOfPictures(),
-                                         va_surface_ids_);
-  VA_SUCCESS_OR_RETURN(va_res, "vaCreateSurfaces failed", false);
-
-  DCHECK(decode_surfaces_.empty());
-  // And create a context associated with them.
-  va_res = VAAPI_CreateContext(va_display_, va_config_id_,
-                               pic_width_, pic_height_, VA_PROGRESSIVE,
-                               va_surface_ids_, GetRequiredNumOfPictures(),
-                               &va_context_id_);
-
-  if (va_res != VA_STATUS_SUCCESS) {
-    DVLOG(1) << "Error creating a decoding surface (binding to texture?)";
-    VAAPI_DestroySurfaces(va_display_, va_surface_ids_,
-                          GetRequiredNumOfPictures());
-    return false;
-  }
-
-  va_context_created_ = true;
-
-  return true;
-}
-
-void VaapiH264Decoder::DestroyVASurfaces() {
-  DCHECK(state_ == kDecoding || state_ == kError || state_ == kAfterReset);
-  decode_surfaces_.clear();
-
-  // This can happen if we fail during DecodeInitial.
-  if (!va_context_created_)
-    return;
-
-  VAStatus va_res = VAAPI_DestroyContext(va_display_, va_context_id_);
-  VA_LOG_ON_ERROR(va_res, "vaDestroyContext failed");
-
-  va_res = VAAPI_DestroySurfaces(va_display_, va_surface_ids_,
-                                 GetRequiredNumOfPictures());
-  VA_LOG_ON_ERROR(va_res, "vaDestroySurfaces failed");
-
-  va_context_created_ = false;
-}
-
-void VaapiH264Decoder::DestroyPendingBuffers() {
-  while (!pending_slice_bufs_.empty()) {
-    VABufferID buffer = pending_slice_bufs_.front();
-    VAStatus va_res = VAAPI_DestroyBuffer(va_display_, buffer);
-    VA_LOG_ON_ERROR(va_res, "vaDestroyBuffer failed");
-    pending_slice_bufs_.pop();
-  }
-  while (!pending_va_bufs_.empty()) {
-    VABufferID buffer = pending_va_bufs_.front();
-    VAStatus va_res = VAAPI_DestroyBuffer(va_display_, buffer);
-    VA_LOG_ON_ERROR(va_res, "vaDestroyBuffer failed");
-    pending_va_bufs_.pop();
-  }
+void VaapiH264Decoder::ReuseSurface(
+    const scoped_refptr<VASurface>& va_surface) {
+  available_va_surfaces_.push_back(va_surface);
 }
 
 // Fill |va_pic| with default/neutral values.
 static void InitVAPicture(VAPictureH264* va_pic) {
   memset(va_pic, 0, sizeof(*va_pic));
   va_pic->picture_id = VA_INVALID_ID;
   va_pic->flags = VA_PICTURE_H264_INVALID;
 }
 
 void VaapiH264Decoder::FillVAPicture(VAPictureH264 *va_pic, H264Picture* pic) {
   DCHECK(pic);
-  POCToDecodeSurfaces::iterator iter = poc_to_decode_surfaces_.find(
-      pic->pic_order_cnt);
-  if (iter == poc_to_decode_surfaces_.end()) {
-    DVLOG(1) << "Could not find surface with POC: " << pic->pic_order_cnt;
+
+  DecodeSurface* dec_surface = DecodeSurfaceByPoC(pic->pic_order_cnt);
+  if (!dec_surface) {
     // Cannot provide a ref picture, will corrupt output, but may be able
     // to recover.
     InitVAPicture(va_pic);
     return;
   }
 
-  va_pic->picture_id = iter->second->va_surface_id();
+  va_pic->picture_id = dec_surface->va_surface()->id();
   va_pic->frame_idx = pic->frame_num;
   va_pic->flags = 0;
 
   switch (pic->field) {
     case H264Picture::FIELD_NONE:
       break;
     case H264Picture::FIELD_TOP:
       va_pic->flags |= VA_PICTURE_H264_TOP_FIELD;
       break;
     case H264Picture::FIELD_BOTTOM:
@@ skipping 19 matching lines @@
   // Libva does not document this, but other implementations (e.g. mplayer)
   // do it this way as well.
   for (rit = dpb_.rbegin(), i = 0; rit != dpb_.rend() && i < num_pics; ++rit) {
     if ((*rit)->ref)
       FillVAPicture(&va_pics[i++], *rit);
   }
 
   return i;
 }
 
-// Can only be called when all surfaces are already bound
-// to textures (cannot be run at the same time as AssignPictureBuffer).
-bool VaapiH264Decoder::AssignSurfaceToPoC(int poc) {
-  DCHECK_GT(num_available_decode_surfaces_, 0) << decode_surfaces_.size();
-
-  // Find a surface not currently holding data used for reference and/or
-  // to be displayed and mark it as used.
-  DecodeSurfaces::iterator iter = decode_surfaces_.begin();
-  for (; iter != decode_surfaces_.end(); ++iter) {
-    if (!iter->second->available())
-      continue;
-
-    --num_available_decode_surfaces_;
-    DCHECK_GE(num_available_decode_surfaces_, 0);
-
-    // Associate with input id and poc and mark as unavailable.
-    iter->second->Acquire(curr_input_id_, poc);
-    DVLOG(4) << "Will use surface " << iter->second->va_surface_id()
-             << " for POC " << iter->second->poc()
-             << " input ID: " << iter->second->input_id();
-    bool inserted = poc_to_decode_surfaces_.insert(std::make_pair(
-        poc, iter->second.get())).second;
-    DCHECK(inserted);
-    return true;
+VaapiH264Decoder::DecodeSurface* VaapiH264Decoder::DecodeSurfaceByPoC(int poc) {
+  DecSurfacesInUse::iterator iter = decode_surfaces_in_use_.find(poc);
+  if (iter == decode_surfaces_in_use_.end()) {
+    DVLOG(1) << "Could not find surface assigned to POC: " << poc;
+    return NULL;
   }
 
-  // Could not find an available surface.
-  return false;
+  return iter->second.get();
 }
 
-// Can only be called when all surfaces are already bound
-// to textures (cannot be run at the same time as AssignPictureBuffer).
+bool VaapiH264Decoder::AssignSurfaceToPoC(int32 input_id, int poc) {
+  if (available_va_surfaces_.empty()) {
+    DVLOG(1) << "No VA Surfaces available";
+    return false;
+  }
+
+  linked_ptr<DecodeSurface> dec_surface(new DecodeSurface(
+      poc, input_id, available_va_surfaces_.back()));
+  available_va_surfaces_.pop_back();
+
+  DVLOG(4) << "POC " << poc
+           << " will use surface " << dec_surface->va_surface()->id();
+
+  bool inserted = decode_surfaces_in_use_.insert(
+      std::make_pair(poc, dec_surface)).second;
+  DCHECK(inserted);
+
+  return true;
+}
+
 void VaapiH264Decoder::UnassignSurfaceFromPoC(int poc) {
-  DecodeSurface* dec_surface;
-  POCToDecodeSurfaces::iterator it = poc_to_decode_surfaces_.find(poc);
-  if (it == poc_to_decode_surfaces_.end()) {
+  DecSurfacesInUse::iterator it = decode_surfaces_in_use_.find(poc);
+  if (it == decode_surfaces_in_use_.end()) {
     DVLOG(1) << "Asked to unassign an unassigned POC " << poc;
     return;
   }
-  dec_surface = it->second;
-  DVLOG(4) << "POC " << poc << " no longer using surface "
-           << dec_surface->va_surface_id();
-  poc_to_decode_surfaces_.erase(it);
 
-  dec_surface->set_used(false);
-  if (!dec_surface->at_client()) {
-    dec_surface->Release();
-    ++num_available_decode_surfaces_;
-  }
+  DVLOG(4) << "POC " << poc << " no longer using VA surface "
+           << it->second->va_surface()->id();
+
+  decode_surfaces_in_use_.erase(it);
 }
 
-// Fill a VAPictureParameterBufferH264 to be later sent to the HW decoder.
 bool VaapiH264Decoder::SendPPS() {
   const H264PPS* pps = parser_.GetPPS(curr_pps_id_);
   DCHECK(pps);
 
   const H264SPS* sps = parser_.GetSPS(pps->seq_parameter_set_id);
   DCHECK(sps);
 
   DCHECK(curr_pic_.get());
 
   VAPictureParameterBufferH264 pic_param;
@@ skipping 62 matching lines @@
   // Init reference pictures' array.
   for (int i = 0; i < 16; ++i)
     InitVAPicture(&pic_param.ReferenceFrames[i]);
 
   // And fill it with picture info from DPB.
   FillVARefFramesFromDPB(pic_param.ReferenceFrames,
                          arraysize(pic_param.ReferenceFrames));
 
   pic_param.num_ref_frames = sps->max_num_ref_frames;
 
-  // Allocate a buffer in driver for this parameter buffer and upload data.
-  VABufferID pic_param_buf_id;
-  VAStatus va_res = VAAPI_CreateBuffer(va_display_, va_context_id_,
-                                       VAPictureParameterBufferType,
-                                       sizeof(VAPictureParameterBufferH264),
-                                       1, &pic_param, &pic_param_buf_id);
-  VA_SUCCESS_OR_RETURN(va_res, "Failed to create a buffer for PPS", false);
-
-  // Queue its VA buffer ID to be committed on HW decode run.
-  pending_va_bufs_.push(pic_param_buf_id);
-
-  return true;
+  return vaapi_wrapper_->SubmitBuffer(VAPictureParameterBufferType,
+                                      sizeof(VAPictureParameterBufferH264),
+                                      &pic_param);
 }
 
-// Fill a VAIQMatrixBufferH264 to be later sent to the HW decoder.
 bool VaapiH264Decoder::SendIQMatrix() {
   const H264PPS* pps = parser_.GetPPS(curr_pps_id_);
   DCHECK(pps);
 
   VAIQMatrixBufferH264 iq_matrix_buf;
   memset(&iq_matrix_buf, 0, sizeof(VAIQMatrixBufferH264));
 
   if (pps->pic_scaling_matrix_present_flag) {
     for (int i = 0; i < 6; ++i) {
       for (int j = 0; j < 16; ++j)
@@ skipping 11 matching lines @@
       for (int j = 0; j < 16; ++j)
         iq_matrix_buf.ScalingList4x4[i][j] = sps->scaling_list4x4[i][j];
     }
 
     for (int i = 0; i < 2; ++i) {
       for (int j = 0; j < 64; ++j)
         iq_matrix_buf.ScalingList8x8[i][j] = sps->scaling_list8x8[i][j];
     }
   }
 
-  // Allocate a buffer in driver for this parameter buffer and upload data.
-  VABufferID iq_matrix_buf_id;
-  VAStatus va_res = VAAPI_CreateBuffer(va_display_, va_context_id_,
-                                       VAIQMatrixBufferType,
-                                       sizeof(VAIQMatrixBufferH264), 1,
-                                       &iq_matrix_buf, &iq_matrix_buf_id);
-  VA_SUCCESS_OR_RETURN(va_res, "Failed to create a buffer for IQMatrix",
-                       false);
-
-  // Queue its VA buffer ID to be committed on HW decode run.
-  pending_va_bufs_.push(iq_matrix_buf_id);
-
-  return true;
+  return vaapi_wrapper_->SubmitBuffer(VAIQMatrixBufferType,
+                                      sizeof(VAIQMatrixBufferH264),
+                                      &iq_matrix_buf);
 }
 
 bool VaapiH264Decoder::SendVASliceParam(H264SliceHeader* slice_hdr) {
   const H264PPS* pps = parser_.GetPPS(slice_hdr->pic_parameter_set_id);
   DCHECK(pps);
 
   const H264SPS* sps = parser_.GetSPS(pps->seq_parameter_set_id);
   DCHECK(sps);
 
   VASliceParameterBufferH264 slice_param;
@@ skipping 69 matching lines @@
 
   int i;
   H264Picture::PtrVector::iterator it;
   for (it = ref_pic_list0_.begin(), i = 0; it != ref_pic_list0_.end() && *it;
        ++it, ++i)
     FillVAPicture(&slice_param.RefPicList0[i], *it);
   for (it = ref_pic_list1_.begin(), i = 0; it != ref_pic_list1_.end() && *it;
        ++it, ++i)
     FillVAPicture(&slice_param.RefPicList1[i], *it);
 
-  // Allocate a buffer in driver for this parameter buffer and upload data.
-  VABufferID slice_param_buf_id;
-  VAStatus va_res = VAAPI_CreateBuffer(va_display_, va_context_id_,
-                                       VASliceParameterBufferType,
-                                       sizeof(VASliceParameterBufferH264),
-                                       1, &slice_param, &slice_param_buf_id);
-  VA_SUCCESS_OR_RETURN(va_res, "Failed creating a buffer for slice param",
-                       false);
-
-  // Queue its VA buffer ID to be committed on HW decode run.
-  pending_slice_bufs_.push(slice_param_buf_id);
-
-  return true;
+  return vaapi_wrapper_->SubmitBuffer(VASliceParameterBufferType,
+                                      sizeof(VASliceParameterBufferH264),
+                                      &slice_param);
 }
 
 bool VaapiH264Decoder::SendSliceData(const uint8* ptr, size_t size) {
-    // Can't help it, blame libva...
-    void* non_const_ptr = const_cast<uint8*>(ptr);
-
-    VABufferID slice_data_buf_id;
-    VAStatus va_res = VAAPI_CreateBuffer(va_display_, va_context_id_,
-                                         VASliceDataBufferType, size, 1,
-                                         non_const_ptr, &slice_data_buf_id);
-    VA_SUCCESS_OR_RETURN(va_res, "Failed creating a buffer for slice data",
-                         false);
-
-    pending_slice_bufs_.push(slice_data_buf_id);
-    return true;
+  // Can't help it, blame libva...
+  void* non_const_ptr = const_cast<uint8*>(ptr);
+  return vaapi_wrapper_->SubmitBuffer(VASliceDataBufferType, size,
+                                      non_const_ptr);
 }
 
 bool VaapiH264Decoder::QueueSlice(H264SliceHeader* slice_hdr) {
   DCHECK(curr_pic_.get());
 
   if (!SendVASliceParam(slice_hdr))
     return false;
 
   if (!SendSliceData(slice_hdr->nalu_data, slice_hdr->nalu_size))
     return false;
 
   return true;
 }
 
+// TODO(posciak) start using vaMapBuffer instead of vaCreateBuffer wherever
+// possible.
 bool VaapiH264Decoder::DecodePicture() {
-  DCHECK(!frame_ready_at_hw_);
   DCHECK(curr_pic_.get());
 
-  // Find the surface associated with the picture to be decoded.
-  DecodeSurface* dec_surface =
-      poc_to_decode_surfaces_[curr_pic_->pic_order_cnt];
-  DVLOG(4) << "Decoding POC " << curr_pic_->pic_order_cnt
-           << " into surface " << dec_surface->va_surface_id();
+  DVLOG(4) << "Decoding POC " << curr_pic_->pic_order_cnt;
+  DecodeSurface* dec_surface = DecodeSurfaceByPoC(curr_pic_->pic_order_cnt);
+  if (!dec_surface) {
+    DVLOG(1) << "Asked to decode an invalid POC " << curr_pic_->pic_order_cnt;
+    return false;
+  }
 
-  DVLOG(4) << "Pending VA bufs to commit: " << pending_va_bufs_.size();
-  DVLOG(4) << "Pending slice bufs to commit: " << pending_slice_bufs_.size();
-
-  DCHECK(pending_slice_bufs_.size());
-  scoped_ptr<std::queue<VABufferID> > va_bufs(new std::queue<VABufferID>());
-  std::swap(*va_bufs, pending_va_bufs_);
-  scoped_ptr<std::queue<VABufferID> > slice_bufs(new std::queue<VABufferID>());
-  std::swap(*slice_bufs, pending_slice_bufs_);
-
-  // Fire up a parallel job on the GPU on the ChildThread to decode and put
-  // the decoded/converted/scaled picture into the pixmap.
-  // Callee will take care of freeing the buffer queues.
-  submit_decode_cb_.Run(
-      dec_surface->picture_buffer_id(), va_bufs.Pass(), slice_bufs.Pass());
-
-  // Used to notify clients that we had sufficient data to start decoding
-  // a new frame.
-  frame_ready_at_hw_ = true;
+  if (!vaapi_wrapper_->DecodeAndDestroyPendingBuffers(
+      dec_surface->va_surface()->id())) {
+    DVLOG(1) << "Failed decoding picture";
+    return false;
+  }
 
   return true;
 }
 
-void VaapiH264Decoder::DestroyBuffers(size_t num_va_buffers,
-                                      const VABufferID* va_buffers) {
-  for (size_t i = 0; i < num_va_buffers; ++i) {
-    VAStatus va_res = VAAPI_DestroyBuffer(va_display_, va_buffers[i]);
-    VA_LOG_ON_ERROR(va_res, "vaDestroyBuffer failed");
-  }
-}
 
-// TODO(posciak) start using vaMapBuffer instead of vaCreateBuffer wherever
-// possible.
-bool VaapiH264Decoder::SubmitDecode(
-    int32 picture_buffer_id,
-    scoped_ptr<std::queue<VABufferID> > va_bufs,
-    scoped_ptr<std::queue<VABufferID> > slice_bufs) {
-
-  static const size_t kMaxVABuffers = 32;
-  DCHECK_LE(va_bufs->size(), kMaxVABuffers);
-  DCHECK_LE(slice_bufs->size(), kMaxVABuffers);
-
-  DecodeSurfaces::iterator it = decode_surfaces_.find(picture_buffer_id);
-  if (it == decode_surfaces_.end()) {
-    DVLOG(1) << "Asked to put an invalid buffer";
-    return false;
-  }
-
-  // Get ready to decode into surface.
-  VAStatus va_res = VAAPI_BeginPicture(va_display_, va_context_id_,
-                                       it->second->va_surface_id());
-  VA_SUCCESS_OR_RETURN(va_res, "vaBeginPicture failed", false);
-
-  // Put buffer IDs for pending parameter buffers into va_buffers[].
-  VABufferID va_buffers[kMaxVABuffers];
-  size_t num_va_buffers = va_bufs->size();
-  for (size_t i = 0; i < num_va_buffers && i < kMaxVABuffers; ++i) {
-    va_buffers[i] = va_bufs->front();
-    va_bufs->pop();
-  }
-  base::Closure va_buffers_callback =
-      base::Bind(&VaapiH264Decoder::DestroyBuffers, base::Unretained(this),
-                 num_va_buffers, va_buffers);
-  base::ScopedClosureRunner va_buffers_deleter(va_buffers_callback);
-
-  // And send them to the HW decoder.
-  va_res = VAAPI_RenderPicture(va_display_, va_context_id_, va_buffers,
-                               num_va_buffers);
-  VA_SUCCESS_OR_RETURN(va_res, "vaRenderPicture for va_bufs failed", false);
-
-  DVLOG(4) << "Committed " << num_va_buffers << "VA buffers";
-
-  // Put buffer IDs for pending slice data buffers into slice_buffers[].
-  VABufferID slice_buffers[kMaxVABuffers];
-  size_t num_slice_buffers = slice_bufs->size();
-  for (size_t i = 0; i < num_slice_buffers && i < kMaxVABuffers; ++i) {
-    slice_buffers[i] = slice_bufs->front();
-    slice_bufs->pop();
-  }
-  base::Closure va_slices_callback =
-      base::Bind(&VaapiH264Decoder::DestroyBuffers, base::Unretained(this),
-                 num_slice_buffers, slice_buffers);
-  base::ScopedClosureRunner slice_buffers_deleter(va_slices_callback);
-
-  // And send them to the Hw decoder.
-  va_res = VAAPI_RenderPicture(va_display_, va_context_id_, slice_buffers,
-                               num_slice_buffers);
-  VA_SUCCESS_OR_RETURN(va_res, "vaRenderPicture for slices failed", false);
-
-  DVLOG(4) << "Committed " << num_slice_buffers << "slice buffers";
-
-  // Instruct HW decoder to start processing committed buffers (decode this
-  // picture). This does not block until the end of decode.
-  va_res = VAAPI_EndPicture(va_display_, va_context_id_);
-  VA_SUCCESS_OR_RETURN(va_res, "vaEndPicture failed", false);
-
-  DVLOG(3) << "Will output from VASurface " << it->second->va_surface_id()
-           << " to texture id " << it->second->texture_id();
-
-  return it->second->Sync();
-}
-
-
 bool VaapiH264Decoder::InitCurrPicture(H264SliceHeader* slice_hdr) {
   DCHECK(curr_pic_.get());
 
   memset(curr_pic_.get(), 0, sizeof(H264Picture));
 
   curr_pic_->idr = slice_hdr->idr_pic_flag;
 
   if (slice_hdr->field_pic_flag) {
     curr_pic_->field = slice_hdr->bottom_field_flag ? H264Picture::FIELD_BOTTOM
                                                     : H264Picture::FIELD_TOP;
   } else {
     curr_pic_->field = H264Picture::FIELD_NONE;
   }
 
   curr_pic_->ref = slice_hdr->nal_ref_idc != 0;
   // This assumes non-interlaced stream.
   curr_pic_->frame_num = curr_pic_->pic_num = slice_hdr->frame_num;
 
   if (!CalculatePicOrderCounts(slice_hdr))
     return false;
 
   // Try to get an empty surface to decode this picture to.
-  if (!AssignSurfaceToPoC(curr_pic_->pic_order_cnt)) {
+  if (!AssignSurfaceToPoC(curr_input_id_, curr_pic_->pic_order_cnt)) {
     DVLOG(1) << "Failed getting a free surface for a picture";
     return false;
   }
 
   curr_pic_->long_term_reference_flag = slice_hdr->long_term_reference_flag;
   curr_pic_->adaptive_ref_pic_marking_mode_flag =
       slice_hdr->adaptive_ref_pic_marking_mode_flag;
 
   // If the slice header indicates we will have to perform reference marking
   // process after this picture is decoded, store required data for that
@@ skipping 481 matching lines @@
   // temporarily made one element longer than the required final list.
   // Resize the list back to its required size.
   ref_pic_listx->resize(num_ref_idx_lX_active_minus1 + 1);
 
   return true;
 }
 
 bool VaapiH264Decoder::OutputPic(H264Picture* pic) {
   DCHECK(!pic->outputted);
   pic->outputted = true;
-  POCToDecodeSurfaces::iterator iter = poc_to_decode_surfaces_.find(
-      pic->pic_order_cnt);
-  if (iter == poc_to_decode_surfaces_.end())
+  last_output_poc_ = pic->pic_order_cnt;
+
+  DecodeSurface* dec_surface = DecodeSurfaceByPoC(pic->pic_order_cnt);
+  if (!dec_surface)
     return false;
-  DecodeSurface* dec_surface = iter->second;
 
-  dec_surface->set_at_client(true);
-  last_output_poc_ = pic->pic_order_cnt;
-  // Notify the client that a picture can be output.
+  DCHECK_GE(dec_surface->input_id(), 0);
   DVLOG(4) << "Posting output task for POC: " << pic->pic_order_cnt
-           << " input_id: " << dec_surface->input_id()
-           << "output_id: " << dec_surface->picture_buffer_id();
-  output_pic_cb_.Run(dec_surface->input_id(),
-                     dec_surface->picture_buffer_id());
+           << " input_id: " << dec_surface->input_id();
+  output_pic_cb_.Run(dec_surface->input_id(), dec_surface->va_surface());
 
   return true;
 }
 
-bool VaapiH264Decoder::Flush() {
+void VaapiH264Decoder::ClearDPB() {
+  // Clear DPB contents, marking the pictures as unused first.
+  for (H264DPB::Pictures::iterator it = dpb_.begin(); it != dpb_.end(); ++it)
+    UnassignSurfaceFromPoC((*it)->pic_order_cnt);
+
+  dpb_.Clear();
+  last_output_poc_ = 0;
+}
+
+bool VaapiH264Decoder::OutputAllRemainingPics() {
   // Output all pictures that are waiting to be outputted.
   FinishPrevFrameIfPresent();
   H264Picture::PtrVector to_output;
   dpb_.GetNotOutputtedPicsAppending(to_output);
   // Sort them by ascending POC to output in order.
   std::sort(to_output.begin(), to_output.end(), POCAscCompare());
 
   H264Picture::PtrVector::iterator it;
   for (it = to_output.begin(); it != to_output.end(); ++it) {
     if (!OutputPic(*it)) {
       DVLOG(1) << "Failed to output pic POC: " << (*it)->pic_order_cnt;
       return false;
     }
   }
 
-  // And clear DPB contents, marking the pictures as unused first.
-  // The surfaces will be released after they have been displayed and returned.
-  for (H264DPB::Pictures::iterator it = dpb_.begin(); it != dpb_.end(); ++it) {
-    UnassignSurfaceFromPoC((*it)->pic_order_cnt);
-  }
-  dpb_.Clear();
-  last_output_poc_ = 0;
-
   return true;
 }
 
+bool VaapiH264Decoder::Flush() {
+  if (!OutputAllRemainingPics())
+    return false;
+
+  ClearDPB();
+
+  DCHECK(decode_surfaces_in_use_.empty());
+  return true;
+}
+
 bool VaapiH264Decoder::StartNewFrame(H264SliceHeader* slice_hdr) {
   // TODO posciak: add handling of max_num_ref_frames per spec.
 
   // If the new frame is an IDR, output what's left to output and clear DPB
   if (slice_hdr->idr_pic_flag) {
     // (unless we are explicitly instructed not to do so).
     if (!slice_hdr->no_output_of_prior_pics_flag) {
       // Output DPB contents.
       if (!Flush())
         return false;
@@ skipping 190 matching lines @@
           H264Picture* to_unmark = dpb_.GetLowestFrameNumWrapShortRefPic();
           if (to_unmark == NULL) {
             DVLOG(1) << "Couldn't find a short ref picture to unmark";
             return;
           }
           to_unmark->ref = false;
         }
       } else {
         // Shouldn't get here.
         DVLOG(1) << "Interlaced video not supported.";
-        ReportToUMA(INTERLACED_STREAM);
+        report_error_to_uma_cb_.Run(INTERLACED_STREAM);
       }
     } else {
       // Stream has instructions how to discard pictures from DPB and how
       // to mark/unmark existing reference pictures. Do it.
       // Spec 8.2.5.4.
       if (curr_pic_->field == H264Picture::FIELD_NONE) {
         HandleMemoryManagementOps();
       } else {
         // Shouldn't get here.
         DVLOG(1) << "Interlaced video not supported.";
-        ReportToUMA(INTERLACED_STREAM);
+        report_error_to_uma_cb_.Run(INTERLACED_STREAM);
       }
     }
   }
 }
 
 bool VaapiH264Decoder::FinishPicture() {
   DCHECK(curr_pic_.get());
 
   // Finish processing previous picture.
   // Start by storing previous reference picture data for later use,
   // if picture being finished is a reference picture.
   if (curr_pic_->ref) {
     ReferencePictureMarking();
     prev_ref_has_memmgmnt5_ = curr_pic_->mem_mgmt_5;
     prev_ref_top_field_order_cnt_ = curr_pic_->top_field_order_cnt;
     prev_ref_pic_order_cnt_msb_ = curr_pic_->pic_order_cnt_msb;
     prev_ref_pic_order_cnt_lsb_ = curr_pic_->pic_order_cnt_lsb;
     prev_ref_field_ = curr_pic_->field;
   }
   prev_has_memmgmnt5_ = curr_pic_->mem_mgmt_5;
   prev_frame_num_offset_ = curr_pic_->frame_num_offset;
 
   // Remove unused (for reference or later output) pictures from DPB, marking
   // them as such.
   for (H264DPB::Pictures::iterator it = dpb_.begin(); it != dpb_.end(); ++it) {
     if ((*it)->outputted && !(*it)->ref)
       UnassignSurfaceFromPoC((*it)->pic_order_cnt);
   }
-  dpb_.RemoveUnused();
+  dpb_.DeleteUnused();
 
-  DVLOG(4) << "Finishing picture, DPB entries: " << dpb_.size()
-           << " Num available dec surfaces: "
-           << num_available_decode_surfaces_;
+  DVLOG(4) << "Finishing picture, entries in DPB: " << dpb_.size();
 
   // Whatever happens below, curr_pic_ will stop managing the pointer to the
   // picture after this function returns. The ownership will either be
   // transferred to DPB, if the image is still needed (for output and/or
   // reference), or the memory will be released if we manage to output it here
   // without having to store it for future reference.
   scoped_ptr<H264Picture> pic(curr_pic_.release());
 
   // Get all pictures that haven't been outputted yet.
   H264Picture::PtrVector not_outputted;
@@ skipping 16 matching lines @@
       (*output_candidate)->pic_order_cnt <= last_output_poc_ + 2;
       ++output_candidate) {
     DCHECK_GE((*output_candidate)->pic_order_cnt, last_output_poc_);
     if (!OutputPic(*output_candidate))
       return false;
 
     if (!(*output_candidate)->ref) {
       // Current picture hasn't been inserted into DPB yet, so don't remove it
       // if we managed to output it immediately.
       if (*output_candidate != pic)
-        dpb_.RemoveByPOC((*output_candidate)->pic_order_cnt);
+        dpb_.DeleteByPOC((*output_candidate)->pic_order_cnt);
       // Mark as unused.
       UnassignSurfaceFromPoC((*output_candidate)->pic_order_cnt);
     }
   }
 
   // If we haven't managed to output the picture that we just decoded, or if
   // it's a reference picture, we have to store it in DPB.
   if (!pic->outputted || pic->ref) {
     if (dpb_.IsFull()) {
       // If we haven't managed to output anything to free up space in DPB
@@ skipping 32 matching lines @@
       return 0;
   }
 }
 
 bool VaapiH264Decoder::ProcessSPS(int sps_id) {
   const H264SPS* sps = parser_.GetSPS(sps_id);
   DCHECK(sps);
 
   if (sps->frame_mbs_only_flag == 0) {
     DVLOG(1) << "frame_mbs_only_flag != 1 not supported";
-    ReportToUMA(FRAME_MBS_ONLY_FLAG_NOT_ONE);
+    report_error_to_uma_cb_.Run(FRAME_MBS_ONLY_FLAG_NOT_ONE);
     return false;
   }
 
   if (sps->gaps_in_frame_num_value_allowed_flag) {
     DVLOG(1) << "Gaps in frame numbers not supported";
-    ReportToUMA(GAPS_IN_FRAME_NUM);
+    report_error_to_uma_cb_.Run(GAPS_IN_FRAME_NUM);
     return false;
   }
 
   curr_sps_id_ = sps->seq_parameter_set_id;
 
   // Calculate picture height/width in macroblocks and pixels
   // (spec 7.4.2.1.1, 7.4.3).
   int width_mb = sps->pic_width_in_mbs_minus1 + 1;
   int height_mb = (2 - sps->frame_mbs_only_flag) *
       (sps->pic_height_in_map_units_minus1 + 1);
 
   int width = 16 * width_mb;
   int height = 16 * height_mb;
 
   DVLOG(1) << "New picture size: " << width << "x" << height;
   if (width == 0 || height == 0) {
     DVLOG(1) << "Invalid picture size!";
     return false;
   }
 
-  if ((pic_width_ != -1 || pic_height_ != -1) &&
-      (width != pic_width_ || height != pic_height_)) {
+  if (!pic_size_.IsEmpty() &&
+      (width != pic_size_.width() || height != pic_size_.height())) {
     DVLOG(1) << "Picture size changed mid-stream";
-    ReportToUMA(MID_STREAM_RESOLUTION_CHANGE);
+    report_error_to_uma_cb_.Run(MID_STREAM_RESOLUTION_CHANGE);
     return false;
   }
 
-  pic_width_ = width;
-  pic_height_ = height;
+  pic_size_.SetSize(width, height);
 
   max_pic_order_cnt_lsb_ = 1 << (sps->log2_max_pic_order_cnt_lsb_minus4 + 4);
   max_frame_num_ = 1 << (sps->log2_max_frame_num_minus4 + 4);
 
   int level = sps->level_idc;
   int max_dpb_mbs = LevelToMaxDpbMbs(level);
   if (max_dpb_mbs == 0)
     return false;
 
   size_t max_dpb_size = std::min(max_dpb_mbs / (width_mb * height_mb),
@@ skipping 24 matching lines @@
 
   return true;
 }
 
 bool VaapiH264Decoder::ProcessSlice(H264SliceHeader* slice_hdr) {
   prev_frame_num_ = frame_num_;
   frame_num_ = slice_hdr->frame_num;
 
   if (prev_frame_num_ > 0 && prev_frame_num_ < frame_num_ - 1) {
     DVLOG(1) << "Gap in frame_num!";
-    ReportToUMA(GAPS_IN_FRAME_NUM);
+    report_error_to_uma_cb_.Run(GAPS_IN_FRAME_NUM);
     return false;
   }
 
   if (slice_hdr->field_pic_flag == 0)
     max_pic_num_ = max_frame_num_;
   else
     max_pic_num_ = 2 * max_frame_num_;
 
   // TODO posciak: switch to new picture detection per 7.4.1.2.4.
   if (curr_pic_ != NULL && slice_hdr->first_mb_in_slice != 0) {
@@ skipping 17 matching lines @@
     state_ = kError;                       \
     return VaapiH264Decoder::kDecodeError; \
   } while (0)
 
 VaapiH264Decoder::DecResult VaapiH264Decoder::DecodeInitial(int32 input_id) {
   // Decode enough to get required picture size (i.e. until we find an SPS),
   // if we get any slice data, we are missing the beginning of the stream.
   H264NALU nalu;
   H264Parser::Result res;
 
-  DCHECK_NE(state_, kUninitialized);
+  if (state_ == kDecoding)
+    return kReadyToDecode;
 
   curr_input_id_ = input_id;
 
   while (1) {
-    if (state_ == kAfterReset && num_available_decode_surfaces_ == 0) {
+    // If we've already decoded some of the stream (after reset), we may be able
+    // to go into decoding state not only starting at/resuming from an SPS, but
+    // also from other resume points, such as IDRs. In such a case we need an
+    // output surface in case we end up decoding a frame. Otherwise we just look
+    // for an SPS and don't need any outputs.
+    if (curr_sps_id_ != -1 && available_va_surfaces_.empty()) {
       DVLOG(4) << "No output surfaces available";
       return kNoOutputAvailable;
     }
 
     // Get next NALU looking for SPS or IDR if after reset.
     res = parser_.AdvanceToNextNALU(&nalu);
     if (res == H264Parser::kEOStream) {
       DVLOG(1) << "Could not find SPS before EOS";
       return kNeedMoreStreamData;
     } else if (res != H264Parser::kOk) {
       SET_ERROR_AND_RETURN();
     }
 
     DVLOG(4) << " NALU found: " << static_cast<int>(nalu.nal_unit_type);
 
     switch (nalu.nal_unit_type) {
       case H264NALU::kSPS:
         res = parser_.ParseSPS(&curr_sps_id_);
         if (res != H264Parser::kOk)
           SET_ERROR_AND_RETURN();
 
         if (!ProcessSPS(curr_sps_id_))
           SET_ERROR_AND_RETURN();
 
-        // Just got information about the video size from SPS, so we can
-        // now allocate surfaces and let the client now we are ready to
-        // accept output buffers and decode.
-        if (!CreateVASurfaces())
-          SET_ERROR_AND_RETURN();
-
         state_ = kDecoding;
         return kReadyToDecode;
 
       case H264NALU::kIDRSlice:
         // If after reset, should be able to recover from an IDR.
-        if (state_ == kAfterReset) {
+        // TODO(posciak): the IDR may require an SPS that we don't have
+        // available. For now we'd fail if that happens, but ideally we'd like
+        // to keep going until the next SPS in the stream.
+        if (curr_sps_id_ != -1) {
           H264SliceHeader slice_hdr;
 
           res = parser_.ParseSliceHeader(nalu, &slice_hdr);
           if (res != H264Parser::kOk)
             SET_ERROR_AND_RETURN();
 
           if (!ProcessSlice(&slice_hdr))
             SET_ERROR_AND_RETURN();
 
           state_ = kDecoding;
@@ skipping 34 matching lines @@
     DVLOG(1) << "Decoder not ready: error in stream or not initialized";
     return kDecodeError;
   }
 
   // All of the actions below might result in decoding a picture from
   // previously parsed data, but we still have to handle/parse current input
   // first.
   // Note: this may drop some already decoded frames if there are errors
   // further in the stream, but we are OK with that.
   while (1) {
-    if (num_available_decode_surfaces_ == 0) {
+    if (available_va_surfaces_.empty()) {
       DVLOG(4) << "No output surfaces available";
       return kNoOutputAvailable;
     }
+
     par_res = parser_.AdvanceToNextNALU(&nalu);
     if (par_res == H264Parser::kEOStream)
       return kNeedMoreStreamData;
     else if (par_res != H264Parser::kOk)
       SET_ERROR_AND_RETURN();
 
     DVLOG(4) << "NALU found: " << static_cast<int>(nalu.nal_unit_type);
 
     switch (nalu.nal_unit_type) {
       case H264NALU::kNonIDRSlice:
@@ skipping 34 matching lines @@
           SET_ERROR_AND_RETURN();
 
         if (!ProcessPPS(pps_id))
           SET_ERROR_AND_RETURN();
         break;
 
       default:
         // skip NALU
         break;
     }
-
-    // If the last action resulted in decoding a frame, possibly from older
-    // data, return. Otherwise keep reading the stream.
-    if (frame_ready_at_hw_) {
-      frame_ready_at_hw_ = false;
-      return kDecodedFrame;
-    }
   }
 }
 
 size_t VaapiH264Decoder::GetRequiredNumOfPictures() {
   return dpb_.max_num_pics() + kPicsInPipeline;
 }
 
-// static
-void VaapiH264Decoder::PreSandboxInitialization() {
-  DCHECK(!pre_sandbox_init_done_);
-  vaapi_handle = dlopen("libva.so", RTLD_NOW);
-  vaapi_x11_handle = dlopen("libva-x11.so", RTLD_NOW);
-  pre_sandbox_init_done_ = vaapi_handle && vaapi_x11_handle;
-}
-
-// static
-bool VaapiH264Decoder::PostSandboxInitialization() {
-  if (!pre_sandbox_init_done_)
-    return false;
-#define VAAPI_DLSYM(name, handle)                                       \
-  VAAPI_##name = reinterpret_cast<Vaapi##name>(dlsym((handle), "va"#name)) \
-
-  VAAPI_DLSYM(GetDisplay, vaapi_x11_handle);
-  VAAPI_DLSYM(DisplayIsValid, vaapi_handle);
-  VAAPI_DLSYM(Initialize, vaapi_handle);
-  VAAPI_DLSYM(Terminate, vaapi_handle);
-  VAAPI_DLSYM(GetConfigAttributes, vaapi_handle);
-  VAAPI_DLSYM(CreateConfig, vaapi_handle);
-  VAAPI_DLSYM(DestroyConfig, vaapi_handle);
-  VAAPI_DLSYM(CreateSurfaces, vaapi_handle);
-  VAAPI_DLSYM(DestroySurfaces, vaapi_handle);
-  VAAPI_DLSYM(CreateContext, vaapi_handle);
-  VAAPI_DLSYM(DestroyContext, vaapi_handle);
-  VAAPI_DLSYM(PutSurface, vaapi_x11_handle);
-  VAAPI_DLSYM(SyncSurface, vaapi_x11_handle);
-  VAAPI_DLSYM(BeginPicture, vaapi_handle);
-  VAAPI_DLSYM(RenderPicture, vaapi_handle);
-  VAAPI_DLSYM(EndPicture, vaapi_handle);
-  VAAPI_DLSYM(CreateBuffer, vaapi_handle);
-  VAAPI_DLSYM(DestroyBuffer, vaapi_handle);
-  VAAPI_DLSYM(ErrorStr, vaapi_handle);
-#undef VAAPI_DLSYM
-
-  return VAAPI_GetDisplay &&
-      VAAPI_DisplayIsValid &&
-      VAAPI_Initialize &&
-      VAAPI_Terminate &&
-      VAAPI_GetConfigAttributes &&
-      VAAPI_CreateConfig &&
-      VAAPI_DestroyConfig &&
-      VAAPI_CreateSurfaces &&
-      VAAPI_DestroySurfaces &&
-      VAAPI_CreateContext &&
-      VAAPI_DestroyContext &&
-      VAAPI_PutSurface &&
-      VAAPI_SyncSurface &&
-      VAAPI_BeginPicture &&
-      VAAPI_RenderPicture &&
-      VAAPI_EndPicture &&
-      VAAPI_CreateBuffer &&
-      VAAPI_DestroyBuffer &&
-      VAAPI_ErrorStr;
-}
-
 }  // namespace content