VAVDA: Switch to using max_num_reorder_frames.

media/filters/h264_parser.cc

 // Copyright 2014 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 "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 
 #include "media/filters/h264_parser.h"
 
@@ skipping 561 matching lines @@
                                  sps.scaling_list8x8[0],
                                  sps.scaling_list8x8[1],
                                  pps->scaling_list8x8);
         }
       }
     }
   }
   return kOk;
 }
 
+H264Parser::Result H264Parser::ParseAndIgnoreHRDParameters(
+    bool* hrd_parameters_present) {
+  int data;
+  READ_BOOL_OR_RETURN(&data);  // {nal,vcl}_hrd_parameters_present_flag
+  if (!data)
+    return kOk;
+
+  *hrd_parameters_present = true;
+
+  int cpb_cnt_minus1;
+  READ_UE_OR_RETURN(&cpb_cnt_minus1);
+  IN_RANGE_OR_RETURN(cpb_cnt_minus1, 0, 31);
+  READ_BITS_OR_RETURN(8, &data);  // bit_rate_scale, cpb_size_scale
+  for (int i = 0; i <= cpb_cnt_minus1; ++i) {
+    READ_UE_OR_RETURN(&data);  // bit_rate_value_minus1[i]
+    READ_UE_OR_RETURN(&data);  // cpb_size_value_minus1[i]
+    READ_BOOL_OR_RETURN(&data);  // cbr_flag
+  }
+  READ_BITS_OR_RETURN(20, &data);  // cpb/dpb delays, etc.
+
+  return kOk;
+}
+
+H264Parser::Result H264Parser::ParseVUIParameters(H264SPS* sps) {
+  bool aspect_ratio_info_present_flag;
+  READ_BOOL_OR_RETURN(&aspect_ratio_info_present_flag);
+  if (aspect_ratio_info_present_flag) {
+    int aspect_ratio_idc;
+    READ_BITS_OR_RETURN(8, &aspect_ratio_idc);
+    if (aspect_ratio_idc == kExtendedSar) {
+      READ_BITS_OR_RETURN(16, &sps->sar_width);
+      READ_BITS_OR_RETURN(16, &sps->sar_height);
+    } else {
+      const int max_aspect_ratio_idc = arraysize(kTableSarWidth) - 1;
+      IN_RANGE_OR_RETURN(aspect_ratio_idc, 0, max_aspect_ratio_idc);
+      sps->sar_width = kTableSarWidth[aspect_ratio_idc];
+      sps->sar_height = kTableSarHeight[aspect_ratio_idc];
+    }
+  }
+
+  int data;
+  // Read and ignore overscan and video signal type info.
+  READ_BOOL_OR_RETURN(&data);  // overscan_info_present_flag
+  if (data)
+    READ_BOOL_OR_RETURN(&data);  // overscan_appropriate_flag
+
+  READ_BOOL_OR_RETURN(&data);  // video_signal_type_present_flag
+  if (data) {
+    READ_BITS_OR_RETURN(3, &data);  // video_format
+    READ_BOOL_OR_RETURN(&data);  // video_full_range_flag
+    READ_BOOL_OR_RETURN(&data);  // colour_description_present_flag
+    if (data)
+      READ_BITS_OR_RETURN(24, &data);  // color description syntax elements
+  }
+
+  READ_BOOL_OR_RETURN(&data);  // chroma_loc_info_present_flag
+  if (data) {
+    READ_UE_OR_RETURN(&data);  // chroma_sample_loc_type_top_field
+    READ_UE_OR_RETURN(&data);  // chroma_sample_loc_type_bottom_field
+  }
+
+  // Read and ignore timing info.
+  READ_BOOL_OR_RETURN(&data);  // timing_info_present_flag
+  if (data) {
+    READ_BITS_OR_RETURN(16, &data);  // num_units_in_tick
+    READ_BITS_OR_RETURN(16, &data);  // num_units_in_tick
+    READ_BITS_OR_RETURN(16, &data);  // time_scale
+    READ_BITS_OR_RETURN(16, &data);  // time_scale
+    READ_BOOL_OR_RETURN(&data);  // fixed_frame_rate_flag
+  }
+
+  // Read and ignore NAL HRD parameters, if present.
+  bool hrd_parameters_present = false;
+  Result res = ParseAndIgnoreHRDParameters(&hrd_parameters_present);
+  if (res != kOk)
+    return res;
+
+  // Read and ignore VCL HRD parameters, if present.
+  res = ParseAndIgnoreHRDParameters(&hrd_parameters_present);
+  if (res != kOk)
+    return res;
+
+  if (hrd_parameters_present)  // One of NAL or VCL params present is enough.
+    READ_BOOL_OR_RETURN(&data);  // low_delay_hrd_flag
+
+  READ_BOOL_OR_RETURN(&data);  // pic_struct_present_flag
+  READ_BOOL_OR_RETURN(&sps->bitstream_restriction_flag);
+  if (sps->bitstream_restriction_flag) {
+    READ_BOOL_OR_RETURN(&data);  // motion_vectors_over_pic_boundaries_flag
+    READ_UE_OR_RETURN(&data);  // max_bytes_per_pic_denom
+    READ_UE_OR_RETURN(&data);  // max_bits_per_mb_denom
+    READ_UE_OR_RETURN(&data);  // log2_max_mv_length_horizontal
+    READ_UE_OR_RETURN(&data);  // log2_max_mv_length_vertical
+    READ_UE_OR_RETURN(&sps->max_num_reorder_frames);
+    READ_UE_OR_RETURN(&sps->max_dec_frame_buffering);
+    TRUE_OR_RETURN(sps->max_dec_frame_buffering >= sps->max_num_ref_frames);
+    IN_RANGE_OR_RETURN(
+        sps->max_num_reorder_frames, 0, sps->max_dec_frame_buffering);
+  }
+
+  return kOk;
+}
+
 static void FillDefaultSeqScalingLists(H264SPS* sps) {
   for (int i = 0; i < 6; ++i)
     for (int j = 0; j < kH264ScalingList4x4Length; ++j)
       sps->scaling_list4x4[i][j] = 16;
 
   for (int i = 0; i < 6; ++i)
     for (int j = 0; j < kH264ScalingList8x8Length; ++j)
       sps->scaling_list8x8[i][j] = 16;
 }
 
 H264Parser::Result H264Parser::ParseSPS(int* sps_id) {
   // See 7.4.2.1.
   int data;
   Result res;
 
   *sps_id = -1;
 
   scoped_ptr<H264SPS> sps(new H264SPS());
 
   READ_BITS_OR_RETURN(8, &sps->profile_idc);
-  READ_BITS_OR_RETURN(6, &sps->constraint_setx_flag);
+  for (size_t i = 0; i < arraysize(sps->constraint_setx_flag); ++i)
+    READ_BOOL_OR_RETURN(&sps->constraint_setx_flag[0]);

[Ami GONE FROM CHROMIUM, 2014/02/25 09:45:37]

s/0/i/ ??

[Pawel Osciak, 2014/02/26 06:02:15]

Uh... yeah, and tests can't catch it, because default is false and that means
max_num_reorder_frames becomes max, which is always ok (using m_n_r_f is an
optional optimization).

[Ami GONE FROM CHROMIUM, 2014/02/26 17:15:58]

I don't get it.  m_n_r_f allows handling negative-POC streams, so it's not "just
an optimization" - handling it correctly is required for some streams.  I'm
asking can the test stream use this feature to ensure we don't regress?

(IDK what the "stress test" you mention is, but if you're saying you want to add
a negative-POC stream to the autotest suite, instead, that's fine by me too)

   READ_BITS_OR_RETURN(2, &data);
   READ_BITS_OR_RETURN(8, &sps->level_idc);
   READ_UE_OR_RETURN(&sps->seq_parameter_set_id);
   TRUE_OR_RETURN(sps->seq_parameter_set_id < 32);
 
   if (sps->profile_idc == 100 || sps->profile_idc == 110 ||
       sps->profile_idc == 122 || sps->profile_idc == 244 ||
       sps->profile_idc == 44 || sps->profile_idc == 83 ||
       sps->profile_idc == 86 || sps->profile_idc == 118 ||
       sps->profile_idc == 128) {
@@ skipping 72 matching lines @@
   READ_BOOL_OR_RETURN(&sps->frame_cropping_flag);
   if (sps->frame_cropping_flag) {
     READ_UE_OR_RETURN(&sps->frame_crop_left_offset);
     READ_UE_OR_RETURN(&sps->frame_crop_right_offset);
     READ_UE_OR_RETURN(&sps->frame_crop_top_offset);
     READ_UE_OR_RETURN(&sps->frame_crop_bottom_offset);
   }
 
   READ_BOOL_OR_RETURN(&sps->vui_parameters_present_flag);
   if (sps->vui_parameters_present_flag) {
-    bool aspect_ratio_info_present_flag;
-    READ_BOOL_OR_RETURN(&aspect_ratio_info_present_flag);
-    if (aspect_ratio_info_present_flag) {
-      int aspect_ratio_idc;
-      READ_BITS_OR_RETURN(8, &aspect_ratio_idc);
-      if (aspect_ratio_idc == kExtendedSar) {
-        READ_BITS_OR_RETURN(16, &sps->sar_width);
-        READ_BITS_OR_RETURN(16, &sps->sar_height);
-      } else {
-        const int max_aspect_ratio_idc = arraysize(kTableSarWidth) - 1;
-        IN_RANGE_OR_RETURN(aspect_ratio_idc, 0, max_aspect_ratio_idc);
-        sps->sar_width = kTableSarWidth[aspect_ratio_idc];
-        sps->sar_height = kTableSarHeight[aspect_ratio_idc];
-      }
-    }
+    DVLOG(4) << "VUI parameters present";
+    res = ParseVUIParameters(sps.get());
+    if (res != kOk)
+      return res;
   }
 
   // If an SPS with the same id already exists, replace it.
   *sps_id = sps->seq_parameter_set_id;
   delete active_SPSes_[*sps_id];
   active_SPSes_[*sps_id] = sps.release();
 
   return kOk;
 }
 
@@ skipping 438 matching lines @@
 
     default:
       DVLOG(4) << "Unsupported SEI message";
       break;
   }
 
   return kOk;
 }
 
 }  // namespace media