VAVDA: Switch to using max_num_reorder_frames.

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"
 #include "base/stl_util.h"
 #include "content/common/gpu/media/vaapi_h264_decoder.h"
 
 namespace content {
 
 // 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:
@@ skipping 35 matching lines @@
 }
 
 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),
+      max_num_reorder_frames_(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();
   state_ = kNeedStreamMetadata;
 }
 
 VaapiH264Decoder::~VaapiH264Decoder() {
@@ skipping 23 matching lines @@
     int poc = it->second->poc();
     // Must be incremented before UnassignSurfaceFromPoC as this call
     // invalidates |it|.
     ++it;
     UnassignSurfaceFromPoC(poc);
   }
   DCHECK(decode_surfaces_in_use_.empty());
 
   dpb_.Clear();
   parser_.Reset();
-  last_output_poc_ = 0;
+  last_output_poc_ = std::numeric_limits<int>::min();
 
   // If we are in kDecoding, we can resume without processing an SPS.
   if (state_ == kDecoding)
     state_ = kAfterReset;
 }
 
 void VaapiH264Decoder::ReuseSurface(
     const scoped_refptr<VASurface>& va_surface) {
   available_va_surfaces_.push_back(va_surface);
 }
@@ skipping 916 matching lines @@
 
   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)
     UnassignSurfaceFromPoC((*it)->pic_order_cnt);
 
   dpb_.Clear();
-  last_output_poc_ = 0;
+  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;
   dpb_.GetNotOutputtedPicsAppending(to_output);
   // Sort them by ascending POC to output in order.
   std::sort(to_output.begin(), to_output.end(), POCAscCompare());
 
@@ skipping 25 matching lines @@
 
   // 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;
     }
     dpb_.Clear();
-    last_output_poc_ = 0;
+    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);
   CHECK(curr_pic_.get());
 
   if (!InitCurrPicture(slice_hdr))
@@ skipping 220 matching lines @@
   // 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;
   // 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 its POC is next after the previously outputted one (which means
-  // last_output_poc_ + 2, because POCs are incremented by 2 to accommodate
-  // fields when decoding interleaved streams). POC can also be equal to
-  // last outputted picture's POC when it wraps around back to 0.
+  // 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();
-  for (; output_candidate != not_outputted.end() &&
-      (*output_candidate)->pic_order_cnt <= last_output_poc_ + 2;
-      ++output_candidate) {
+  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.
       if (*output_candidate != pic)
         dpb_.DeleteByPOC(poc);
       // Mark as unused.
       UnassignSurfaceFromPoC(poc);
     }
+
+    ++output_candidate;
+    --num_remaining;
   }
 
   // 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
       // to store this picture, it's an error in the stream.
       DVLOG(1) << "Could not free up space in DPB!";
       return false;
@@ skipping 23 matching lines @@
     case 42: return 34816;
     case 50: return 110400;
     case 51: //  fallthrough
     case 52: return 184320;
     default:
       DVLOG(1) << "Invalid codec level (" << level << ")";
       return 0;
   }
 }
 
+bool VaapiH264Decoder::UpdateMaxNumReorderFrames(const media::H264SPS* sps) {
+  if (sps->vui_parameters_present_flag && sps->bitstream_restriction_flag) {
+    max_num_reorder_frames_ =
+        base::checked_cast<size_t>(sps->max_num_reorder_frames);
+    if (max_num_reorder_frames_ > dpb_.max_num_pics()) {
+      DVLOG(1)
+          << "max_num_reorder_frames present, but larger than MaxDpbFrames ("
+          << max_num_reorder_frames_ << " > " << dpb_.max_num_pics() << ")";
+      max_num_reorder_frames_ = 0;
+      return false;
+    }
+    return true;
+  }
+
+  // max_num_reorder_frames not present, infer from profile/constraints
+  // (see VUI semantics in spec).
+  if (sps->constraint_set3_flag) {
+    switch (sps->profile_idc) {
+      case 44:
+      case 86:
+      case 100:
+      case 110:
+      case 122:
+      case 244:
+        max_num_reorder_frames_ = 0;
+        break;
+      default:
+        max_num_reorder_frames_ = dpb_.max_num_pics();
+        break;
+    }
+  } else {
+    max_num_reorder_frames_ = dpb_.max_num_pics();
+  }
+
+  return true;
+}
+
 bool VaapiH264Decoder::ProcessSPS(int sps_id, bool* need_new_buffers) {
   const media::H264SPS* sps = parser_.GetSPS(sps_id);
   DCHECK(sps);
   DVLOG(4) << "Processing SPS";
 
   *need_new_buffers = false;
 
   if (sps->frame_mbs_only_flag == 0) {
     DVLOG(1) << "frame_mbs_only_flag != 1 not supported";
     report_error_to_uma_cb_.Run(FRAME_MBS_ONLY_FLAG_NOT_ONE);
@@ skipping 40 matching lines @@
   size_t max_dpb_size = std::min(max_dpb_mbs / (width_mb * height_mb),
                                  static_cast<int>(H264DPB::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;
+  DVLOG(1) << "max_num_reorder_frames: " << max_num_reorder_frames_;
+
   *need_new_buffers = true;
   return true;
 }
 
 bool VaapiH264Decoder::ProcessPPS(int pps_id) {
   const media::H264PPS* pps = parser_.GetPPS(pps_id);
   DCHECK(pps);
 
   curr_pps_id_ = pps->pic_parameter_set_id;
 
@@ skipping 165 matching lines @@
         break;
     }
   }
 }
 
 size_t VaapiH264Decoder::GetRequiredNumOfPictures() {
   return dpb_.max_num_pics() + kPicsInPipeline;
 }
 
 }  // namespace content