Add accelerated video decoder interface, VP8 and H.264 implementations and hook up to V4L2SVDA

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 <algorithm>
 #include <limits>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/numerics/safe_conversions.h"
@@ skipping 70 matching lines @@
 
   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;
+  prev_ref_field_ = VaapiH264Picture::FIELD_NONE;
 
   vaapi_wrapper_->DestroyPendingBuffers();
 
   ref_pic_list0_.clear();
   ref_pic_list1_.clear();
 
   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
@@ skipping 17 matching lines @@
   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) {
+void VaapiH264Decoder::FillVAPicture(VAPictureH264* va_pic,
+                                     VaapiH264Picture* pic) {
   DCHECK(pic);
 
   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 = dec_surface->va_surface()->id();
   va_pic->frame_idx = pic->frame_num;
   va_pic->flags = 0;
 
   switch (pic->field) {
-    case H264Picture::FIELD_NONE:
+    case VaapiH264Picture::FIELD_NONE:
       break;
-    case H264Picture::FIELD_TOP:
+    case VaapiH264Picture::FIELD_TOP:
       va_pic->flags |= VA_PICTURE_H264_TOP_FIELD;
       break;
-    case H264Picture::FIELD_BOTTOM:
+    case VaapiH264Picture::FIELD_BOTTOM:
       va_pic->flags |= VA_PICTURE_H264_BOTTOM_FIELD;
       break;
   }
 
   if (pic->ref) {
     va_pic->flags |= pic->long_term ? VA_PICTURE_H264_LONG_TERM_REFERENCE
                                     : VA_PICTURE_H264_SHORT_TERM_REFERENCE;
   }
 
   va_pic->TopFieldOrderCnt = pic->top_field_order_cnt;
   va_pic->BottomFieldOrderCnt = pic->bottom_field_order_cnt;
 }
 
 int VaapiH264Decoder::FillVARefFramesFromDPB(VAPictureH264 *va_pics,
                                              int num_pics) {
-  H264DPB::Pictures::reverse_iterator rit;
+  VaapiH264DPB::Pictures::reverse_iterator rit;
   int i;
 
   // Return reference frames in reverse order of insertion.
   // 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);
   }
 
@@ skipping 238 matching lines @@
       }
     }
   }
 
   for (int i = 0; i < 32; ++i) {
     InitVAPicture(&slice_param.RefPicList0[i]);
     InitVAPicture(&slice_param.RefPicList1[i]);
   }
 
   int i;
-  H264Picture::PtrVector::iterator it;
+  VaapiH264Picture::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);
 
   return vaapi_wrapper_->SubmitBuffer(VASliceParameterBufferType,
                                       sizeof(VASliceParameterBufferH264),
                                       &slice_param);
@@ skipping 57 matching lines @@
     DVLOG(1) << "Failed decoding picture";
     return false;
   }
 
   return true;
 }
 
 bool VaapiH264Decoder::InitCurrPicture(media::H264SliceHeader* slice_hdr) {
   DCHECK(curr_pic_.get());
 
-  memset(curr_pic_.get(), 0, sizeof(H264Picture));
+  memset(curr_pic_.get(), 0, sizeof(VaapiH264Picture));
 
   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;
+    curr_pic_->field = slice_hdr->bottom_field_flag
+                           ? VaapiH264Picture::FIELD_BOTTOM
+                           : VaapiH264Picture::FIELD_TOP;
   } else {
-    curr_pic_->field = H264Picture::FIELD_NONE;
+    curr_pic_->field = VaapiH264Picture::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.
@@ skipping 29 matching lines @@
   curr_pic_->pic_order_cnt_lsb = pic_order_cnt_lsb;
 
   switch (sps->pic_order_cnt_type) {
     case 0:
       // See spec 8.2.1.1.
       int prev_pic_order_cnt_msb, prev_pic_order_cnt_lsb;
       if (slice_hdr->idr_pic_flag) {
         prev_pic_order_cnt_msb = prev_pic_order_cnt_lsb = 0;
       } else {
         if (prev_ref_has_memmgmnt5_) {
-          if (prev_ref_field_ != H264Picture::FIELD_BOTTOM) {
+          if (prev_ref_field_ != VaapiH264Picture::FIELD_BOTTOM) {
             prev_pic_order_cnt_msb = 0;
             prev_pic_order_cnt_lsb = prev_ref_top_field_order_cnt_;
           } else {
             prev_pic_order_cnt_msb = 0;
             prev_pic_order_cnt_lsb = 0;
           }
         } else {
           prev_pic_order_cnt_msb = prev_ref_pic_order_cnt_msb_;
           prev_pic_order_cnt_lsb = prev_ref_pic_order_cnt_lsb_;
         }
       }
 
       DCHECK_NE(max_pic_order_cnt_lsb_, 0);
       if ((pic_order_cnt_lsb < prev_pic_order_cnt_lsb) &&
           (prev_pic_order_cnt_lsb - pic_order_cnt_lsb >=
            max_pic_order_cnt_lsb_ / 2)) {
         curr_pic_->pic_order_cnt_msb = prev_pic_order_cnt_msb +
           max_pic_order_cnt_lsb_;
       } else if ((pic_order_cnt_lsb > prev_pic_order_cnt_lsb) &&
           (pic_order_cnt_lsb - prev_pic_order_cnt_lsb >
            max_pic_order_cnt_lsb_ / 2)) {
         curr_pic_->pic_order_cnt_msb = prev_pic_order_cnt_msb -
           max_pic_order_cnt_lsb_;
       } else {
         curr_pic_->pic_order_cnt_msb = prev_pic_order_cnt_msb;
       }
 
-      if (curr_pic_->field != H264Picture::FIELD_BOTTOM) {
+      if (curr_pic_->field != VaapiH264Picture::FIELD_BOTTOM) {
         curr_pic_->top_field_order_cnt = curr_pic_->pic_order_cnt_msb +
           pic_order_cnt_lsb;
       }
 
-      if (curr_pic_->field != H264Picture::FIELD_TOP) {
+      if (curr_pic_->field != VaapiH264Picture::FIELD_TOP) {
         // TODO posciak: perhaps replace with pic->field?
         if (!slice_hdr->field_pic_flag) {
           curr_pic_->bottom_field_order_cnt = curr_pic_->top_field_order_cnt +
             slice_hdr->delta_pic_order_cnt_bottom;
         } else {
           curr_pic_->bottom_field_order_cnt = curr_pic_->pic_order_cnt_msb +
             pic_order_cnt_lsb;
         }
       }
       break;
@@ skipping 37 matching lines @@
         // frame_num_in_pic_order_cnt_cycle is verified < 255 in parser
         for (int i = 0; i <= frame_num_in_pic_order_cnt_cycle; ++i)
           expected_pic_order_cnt += sps->offset_for_ref_frame[i];
       }
 
       if (!slice_hdr->nal_ref_idc)
         expected_pic_order_cnt += sps->offset_for_non_ref_pic;
 
       if (!slice_hdr->field_pic_flag) {
         curr_pic_->top_field_order_cnt = expected_pic_order_cnt +
-            slice_hdr->delta_pic_order_cnt[0];
+            slice_hdr->delta_pic_order_cnt0;
         curr_pic_->bottom_field_order_cnt = curr_pic_->top_field_order_cnt +
             sps->offset_for_top_to_bottom_field +
-            slice_hdr->delta_pic_order_cnt[1];
+            slice_hdr->delta_pic_order_cnt1;
       } else if (!slice_hdr->bottom_field_flag) {
         curr_pic_->top_field_order_cnt = expected_pic_order_cnt +
-            slice_hdr->delta_pic_order_cnt[0];
+            slice_hdr->delta_pic_order_cnt0;
       } else {
         curr_pic_->bottom_field_order_cnt = expected_pic_order_cnt +
             sps->offset_for_top_to_bottom_field +
-            slice_hdr->delta_pic_order_cnt[0];
+            slice_hdr->delta_pic_order_cnt0;
       }
       break;
     }
 
     case 2:
       // See spec 8.2.1.3.
       if (prev_has_memmgmnt5_)
         prev_frame_num_offset_ = 0;
 
       if (slice_hdr->idr_pic_flag)
@@ skipping 23 matching lines @@
         curr_pic_->top_field_order_cnt = temp_pic_order_cnt;
       }
       break;
 
     default:
       DVLOG(1) << "Invalid pic_order_cnt_type: " << sps->pic_order_cnt_type;
       return false;
   }
 
   switch (curr_pic_->field) {
-    case H264Picture::FIELD_NONE:
+    case VaapiH264Picture::FIELD_NONE:
       curr_pic_->pic_order_cnt = std::min(curr_pic_->top_field_order_cnt,
                                           curr_pic_->bottom_field_order_cnt);
       break;
-    case H264Picture::FIELD_TOP:
+    case VaapiH264Picture::FIELD_TOP:
       curr_pic_->pic_order_cnt = curr_pic_->top_field_order_cnt;
       break;
-    case H264Picture::FIELD_BOTTOM:
+    case VaapiH264Picture::FIELD_BOTTOM:
       curr_pic_->pic_order_cnt = curr_pic_->bottom_field_order_cnt;
       break;
   }
 
   return true;
 }
 
 void VaapiH264Decoder::UpdatePicNums() {
-  for (H264DPB::Pictures::iterator it = dpb_.begin(); it != dpb_.end(); ++it) {
-    H264Picture* pic = *it;
+  for (VaapiH264DPB::Pictures::iterator it = dpb_.begin(); it != dpb_.end();
+       ++it) {
+    VaapiH264Picture* pic = *it;
     DCHECK(pic);
     if (!pic->ref)
       continue;
 
     // Below assumes non-interlaced stream.
-    DCHECK_EQ(pic->field, H264Picture::FIELD_NONE);
+    DCHECK_EQ(pic->field, VaapiH264Picture::FIELD_NONE);
     if (pic->long_term) {
       pic->long_term_pic_num = pic->long_term_frame_idx;
     } else {
       if (pic->frame_num > frame_num_)
         pic->frame_num_wrap = pic->frame_num - max_frame_num_;
       else
         pic->frame_num_wrap = pic->frame_num;
 
       pic->pic_num = pic->frame_num_wrap;
     }
   }
 }
 
 struct PicNumDescCompare {
-  bool operator()(const H264Picture* a, const H264Picture* b) const {
+  bool operator()(const VaapiH264Picture* a, const VaapiH264Picture* b) const {
     return a->pic_num > b->pic_num;
   }
 };
 
 struct LongTermPicNumAscCompare {
-  bool operator()(const H264Picture* a, const H264Picture* b) const {
+  bool operator()(const VaapiH264Picture* a, const VaapiH264Picture* b) const {
     return a->long_term_pic_num < b->long_term_pic_num;
   }
 };
 
 void VaapiH264Decoder::ConstructReferencePicListsP(
     media::H264SliceHeader* slice_hdr) {
   // RefPicList0 (8.2.4.2.1) [[1] [2]], where:
   // [1] shortterm ref pics sorted by descending pic_num,
   // [2] longterm ref pics by ascending long_term_pic_num.
   DCHECK(ref_pic_list0_.empty() && ref_pic_list1_.empty());
   // First get the short ref pics...
   dpb_.GetShortTermRefPicsAppending(ref_pic_list0_);
   size_t num_short_refs = ref_pic_list0_.size();
 
   // and sort them to get [1].
   std::sort(ref_pic_list0_.begin(), ref_pic_list0_.end(), PicNumDescCompare());
 
   // Now get long term pics and sort them by long_term_pic_num to get [2].
   dpb_.GetLongTermRefPicsAppending(ref_pic_list0_);
   std::sort(ref_pic_list0_.begin() + num_short_refs, ref_pic_list0_.end(),
             LongTermPicNumAscCompare());
 
   // Cut off if we have more than requested in slice header.
   ref_pic_list0_.resize(slice_hdr->num_ref_idx_l0_active_minus1 + 1);
 }
 
 struct POCAscCompare {
-  bool operator()(const H264Picture* a, const H264Picture* b) const {
+  bool operator()(const VaapiH264Picture* a, const VaapiH264Picture* b) const {
     return a->pic_order_cnt < b->pic_order_cnt;
   }
 };
 
 struct POCDescCompare {
-  bool operator()(const H264Picture* a, const H264Picture* b) const {
+  bool operator()(const VaapiH264Picture* a, const VaapiH264Picture* b) const {
     return a->pic_order_cnt > b->pic_order_cnt;
   }
 };
 
 void VaapiH264Decoder::ConstructReferencePicListsB(
     media::H264SliceHeader* slice_hdr) {
   // RefPicList0 (8.2.4.2.3) [[1] [2] [3]], where:
   // [1] shortterm ref pics with POC < curr_pic's POC sorted by descending POC,
   // [2] shortterm ref pics with POC > curr_pic's POC by ascending POC,
   // [3] longterm ref pics by ascending long_term_pic_num.
   DCHECK(ref_pic_list0_.empty() && ref_pic_list1_.empty());
   dpb_.GetShortTermRefPicsAppending(ref_pic_list0_);
   size_t num_short_refs = ref_pic_list0_.size();
 
   // First sort ascending, this will put [1] in right place and finish [2].
   std::sort(ref_pic_list0_.begin(), ref_pic_list0_.end(), POCAscCompare());
 
   // Find first with POC > curr_pic's POC to get first element in [2]...
-  H264Picture::PtrVector::iterator iter;
+  VaapiH264Picture::PtrVector::iterator iter;
   iter = std::upper_bound(ref_pic_list0_.begin(), ref_pic_list0_.end(),
                           curr_pic_.get(), POCAscCompare());
 
   // and sort [1] descending, thus finishing sequence [1] [2].
   std::sort(ref_pic_list0_.begin(), iter, POCDescCompare());
 
   // Now add [3] and sort by ascending long_term_pic_num.
   dpb_.GetLongTermRefPicsAppending(ref_pic_list0_);
   std::sort(ref_pic_list0_.begin() + num_short_refs, ref_pic_list0_.end(),
             LongTermPicNumAscCompare());
@@ skipping 28 matching lines @@
     std::swap(ref_pic_list1_[0], ref_pic_list1_[1]);
 
   // Per 8.2.4.2 it's possible for num_ref_idx_lX_active_minus1 to indicate
   // there should be more ref pics on list than we constructed.
   // Those superfluous ones should be treated as non-reference.
   ref_pic_list0_.resize(slice_hdr->num_ref_idx_l0_active_minus1 + 1);
   ref_pic_list1_.resize(slice_hdr->num_ref_idx_l1_active_minus1 + 1);
 }
 
 // See 8.2.4
-int VaapiH264Decoder::PicNumF(H264Picture *pic) {
+int VaapiH264Decoder::PicNumF(VaapiH264Picture* pic) {
   if (!pic)
       return -1;
 
   if (!pic->long_term)
       return pic->pic_num;
   else
       return max_pic_num_;
 }
 
 // See 8.2.4
-int VaapiH264Decoder::LongTermPicNumF(H264Picture *pic) {
+int VaapiH264Decoder::LongTermPicNumF(VaapiH264Picture* pic) {
   if (pic->ref && pic->long_term)
     return pic->long_term_pic_num;
   else
     return 2 * (max_long_term_frame_idx_ + 1);
 }
 
 // Shift elements on the |v| starting from |from| to |to|, inclusive,
 // one position to the right and insert pic at |from|.
-static void ShiftRightAndInsert(H264Picture::PtrVector *v,
+static void ShiftRightAndInsert(VaapiH264Picture::PtrVector* v,
                                 int from,
                                 int to,
-                                H264Picture* pic) {
+                                VaapiH264Picture* pic) {
   // Security checks, do not disable in Debug mode.
   CHECK(from <= to);
   CHECK(to <= std::numeric_limits<int>::max() - 2);
   // Additional checks. Debug mode ok.
   DCHECK(v);
   DCHECK(pic);
   DCHECK((to + 1 == static_cast<int>(v->size())) ||
          (to + 2 == static_cast<int>(v->size())));
 
   v->resize(to + 2);
 
   for (int i = to + 1; i > from; --i)
     (*v)[i] = (*v)[i - 1];
 
   (*v)[from] = pic;
 }
 
 bool VaapiH264Decoder::ModifyReferencePicList(media::H264SliceHeader* slice_hdr,
                                               int list) {
   int num_ref_idx_lX_active_minus1;
-  H264Picture::PtrVector* ref_pic_listx;
+  VaapiH264Picture::PtrVector* ref_pic_listx;
   media::H264ModificationOfPicNum* list_mod;
 
   // This can process either ref_pic_list0 or ref_pic_list1, depending on
   // the list argument. Set up pointers to proper list to be processed here.
   if (list == 0) {
     if (!slice_hdr->ref_pic_list_modification_flag_l0)
       return true;
 
     list_mod = slice_hdr->ref_list_l0_modifications;
     num_ref_idx_lX_active_minus1 = ref_pic_list0_.size() - 1;
@@ skipping 11 matching lines @@
 
   DCHECK_GE(num_ref_idx_lX_active_minus1, 0);
 
   // Spec 8.2.4.3:
   // Reorder pictures on the list in a way specified in the stream.
   int pic_num_lx_pred = curr_pic_->pic_num;
   int ref_idx_lx = 0;
   int pic_num_lx_no_wrap;
   int pic_num_lx;
   bool done = false;
-  H264Picture* pic;
+  VaapiH264Picture* pic;
   for (int i = 0; i < media::H264SliceHeader::kRefListModSize && !done; ++i) {
     switch (list_mod->modification_of_pic_nums_idc) {
       case 0:
       case 1:
         // Modify short reference picture position.
         if (list_mod->modification_of_pic_nums_idc == 0) {
           // Subtract given value from predicted PicNum.
           pic_num_lx_no_wrap = pic_num_lx_pred -
               (static_cast<int>(list_mod->abs_diff_pic_num_minus1) + 1);
           // Wrap around max_pic_num_ if it becomes < 0 as result
@@ skipping 75 matching lines @@
   }
 
   // Per NOTE 2 in 8.2.4.3.2, the ref_pic_listx size in the above loop is
   // 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) {
+bool VaapiH264Decoder::OutputPic(VaapiH264Picture* pic) {
   DCHECK(!pic->outputted);
   pic->outputted = true;
   last_output_poc_ = pic->pic_order_cnt;
 
   DecodeSurface* dec_surface = DecodeSurfaceByPoC(pic->pic_order_cnt);
   if (!dec_surface)
     return false;
 
   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_pic_cb_.Run(dec_surface->input_id(), dec_surface->va_surface());
 
   return true;
 }
 
 void VaapiH264Decoder::ClearDPB() {
   // Clear DPB contents, marking the pictures as unused first.
-  for (H264DPB::Pictures::iterator it = dpb_.begin(); it != dpb_.end(); ++it)
+  for (VaapiH264DPB::Pictures::iterator it = dpb_.begin(); it != dpb_.end();
+       ++it)
     UnassignSurfaceFromPoC((*it)->pic_order_cnt);
 
   dpb_.Clear();
   last_output_poc_ = std::numeric_limits<int>::min();
 }
 
 bool VaapiH264Decoder::OutputAllRemainingPics() {
   // Output all pictures that are waiting to be outputted.
   FinishPrevFrameIfPresent();
-  H264Picture::PtrVector to_output;
+  VaapiH264Picture::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;
+  VaapiH264Picture::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;
     }
   }
 
   return true;
 }
 
@@ skipping 21 matching lines @@
         return false;
     }
     dpb_.Clear();
     last_output_poc_ = std::numeric_limits<int>::min();
   }
 
   // curr_pic_ should have either been added to DPB or discarded when finishing
   // the last frame. DPB is responsible for releasing that memory once it's
   // not needed anymore.
   DCHECK(!curr_pic_.get());
-  curr_pic_.reset(new H264Picture);
+  curr_pic_.reset(new VaapiH264Picture);
   CHECK(curr_pic_.get());
 
   if (!InitCurrPicture(slice_hdr))
     return false;
 
   DCHECK_GT(max_frame_num_, 0);
 
   UpdatePicNums();
 
   // Send parameter buffers before each new picture, before the first slice.
   if (!SendPPS())
     return false;
 
   if (!SendIQMatrix())
     return false;
 
   if (!QueueSlice(slice_hdr))
     return false;
 
   return true;
 }
 
 bool VaapiH264Decoder::HandleMemoryManagementOps() {
   // 8.2.5.4
   for (unsigned int i = 0; i < arraysize(curr_pic_->ref_pic_marking); ++i) {
     // Code below does not support interlaced stream (per-field pictures).
     media::H264DecRefPicMarking* ref_pic_marking =
         &curr_pic_->ref_pic_marking[i];
-    H264Picture* to_mark;
+    VaapiH264Picture* to_mark;
     int pic_num_x;
 
     switch (ref_pic_marking->memory_mgmnt_control_operation) {
       case 0:
         // Normal end of operations' specification.
         return true;
 
       case 1:
         // Mark a short term reference picture as unused so it can be removed
         // if outputted.
@@ skipping 33 matching lines @@
         } else {
           DVLOG(1) << "Invalid short term ref pic num to mark as long ref";
           return false;
         }
         break;
 
       case 4: {
         // Unmark all reference pictures with long_term_frame_idx over new max.
         max_long_term_frame_idx_
             = ref_pic_marking->max_long_term_frame_idx_plus1 - 1;
-        H264Picture::PtrVector long_terms;
+        VaapiH264Picture::PtrVector long_terms;
         dpb_.GetLongTermRefPicsAppending(long_terms);
         for (size_t i = 0; i < long_terms.size(); ++i) {
-          H264Picture* pic = long_terms[i];
+          VaapiH264Picture* pic = long_terms[i];
           DCHECK(pic->ref && pic->long_term);
           // Ok to cast, max_long_term_frame_idx is much smaller than 16bit.
           if (pic->long_term_frame_idx >
               static_cast<int>(max_long_term_frame_idx_))
             pic->ref = false;
         }
         break;
       }
 
       case 5:
         // Unmark all reference pictures.
         dpb_.MarkAllUnusedForRef();
         max_long_term_frame_idx_ = -1;
         curr_pic_->mem_mgmt_5 = true;
         break;
 
       case 6: {
         // Replace long term reference pictures with current picture.
         // First unmark if any existing with this long_term_frame_idx...
-        H264Picture::PtrVector long_terms;
+        VaapiH264Picture::PtrVector long_terms;
         dpb_.GetLongTermRefPicsAppending(long_terms);
         for (size_t i = 0; i < long_terms.size(); ++i) {
-          H264Picture* pic = long_terms[i];
+          VaapiH264Picture* pic = long_terms[i];
           DCHECK(pic->ref && pic->long_term);
           // Ok to cast, long_term_frame_idx is much smaller than 16bit.
           if (pic->long_term_frame_idx ==
               static_cast<int>(ref_pic_marking->long_term_frame_idx))
             pic->ref = false;
         }
 
         // and mark the current one instead.
         curr_pic_->ref = true;
         curr_pic_->long_term = true;
@@ skipping 26 matching lines @@
       max_long_term_frame_idx_ = 0;
     } else {
       curr_pic_->long_term = false;
       max_long_term_frame_idx_ = -1;
     }
   } else {
     if (!curr_pic_->adaptive_ref_pic_marking_mode_flag) {
       // If non-IDR, and the stream does not indicate what we should do to
       // ensure DPB doesn't overflow, discard oldest picture.
       // See spec 8.2.5.3.
-      if (curr_pic_->field == H264Picture::FIELD_NONE) {
+      if (curr_pic_->field == VaapiH264Picture::FIELD_NONE) {
         DCHECK_LE(dpb_.CountRefPics(),
             std::max<int>(parser_.GetSPS(curr_sps_id_)->max_num_ref_frames,
                           1));
         if (dpb_.CountRefPics() ==
             std::max<int>(parser_.GetSPS(curr_sps_id_)->max_num_ref_frames,
                           1)) {
           // Max number of reference pics reached,
           // need to remove one of the short term ones.
           // Find smallest frame_num_wrap short reference picture and mark
           // it as unused.
-          H264Picture* to_unmark = dpb_.GetLowestFrameNumWrapShortRefPic();
+          VaapiH264Picture* 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.";
         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) {
+      if (curr_pic_->field == VaapiH264Picture::FIELD_NONE) {
         HandleMemoryManagementOps();
       } else {
         // Shouldn't get here.
         DVLOG(1) << "Interlaced video not supported.";
         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) {
+  for (VaapiH264DPB::Pictures::iterator it = dpb_.begin(); it != dpb_.end();
+       ++it) {
     if ((*it)->outputted && !(*it)->ref)
       UnassignSurfaceFromPoC((*it)->pic_order_cnt);
   }
   dpb_.DeleteUnused();
 
   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());
+  scoped_ptr<VaapiH264Picture> pic(curr_pic_.release());
 
   // Get all pictures that haven't been outputted yet.
-  H264Picture::PtrVector not_outputted;
+  VaapiH264Picture::PtrVector not_outputted;
   // TODO(posciak): pass as pointer, not reference (violates coding style).
   dpb_.GetNotOutputtedPicsAppending(not_outputted);
   // Include the one we've just decoded.
   not_outputted.push_back(pic.get());
 
   // Sort in output order.
   std::sort(not_outputted.begin(), not_outputted.end(), POCAscCompare());
 
   // Try to output as many pictures as we can. A picture can be output,
   // if the number of decoded and not yet outputted pictures that would remain
   // in DPB afterwards would at least be equal to max_num_reorder_frames.
   // If the outputted picture is not a reference picture, it doesn't have
   // to remain in the DPB and can be removed.
-  H264Picture::PtrVector::iterator output_candidate = not_outputted.begin();
+  VaapiH264Picture::PtrVector::iterator output_candidate =
+      not_outputted.begin();
   size_t num_remaining = not_outputted.size();
   while (num_remaining > max_num_reorder_frames_) {
     int poc = (*output_candidate)->pic_order_cnt;
     DCHECK_GE(poc, 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.
@@ skipping 129 matching lines @@
 
   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),
-                                 static_cast<int>(H264DPB::kDPBMaxSize));
+                                 static_cast<int>(VaapiH264DPB::kDPBMaxSize));
   DVLOG(1) << "Codec level: " << level << ", DPB size: " << max_dpb_size;
   if (max_dpb_size == 0) {
     DVLOG(1) << "Invalid DPB Size";
     return false;
   }
 
   dpb_.set_max_num_pics(max_dpb_size);
 
   if (!UpdateMaxNumReorderFrames(sps))
     return false;
@@ skipping 187 matching lines @@
         break;
     }
   }
 }
 
 size_t VaapiH264Decoder::GetRequiredNumOfPictures() {
   return dpb_.max_num_pics() + kPicsInPipeline;
 }
 
 }  // namespace content