Only parse PPS up to PPS and SPS ids in the depacketizater.

webrtc/common_video/h264/pps_parser.cc

 /*
  *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 10 matching lines @@
   if (!(x)) {                                    \
     return rtc::Optional<PpsParser::PpsState>(); \
   }
 
 namespace webrtc {
 
 // General note: this is based off the 02/2014 version of the H.264 standard.
 // You can find it on this page:
 // http://www.itu.int/rec/T-REC-H.264
 
+bool PpsParser::ParsePpsIds(const uint8_t* data,

[danilchap, 2016/09/07 10:38:51]

Function declaration order should match function definition order.
i.e. this one should be after ParsePps

+                            size_t length,
+                            uint32_t* pps_id,
+                            uint32_t* sps_id) {
+  RTC_DCHECK(pps_id);
+  RTC_DCHECK(sps_id);
+  // First, parse out rbsp, which is basically the source buffer minus emulation
+  // bytes (the last byte of a 0x00 0x00 0x03 sequence). RBSP is defined in
+  // section 7.3.1 of the H.264 standard.
+  std::unique_ptr<rtc::Buffer> unpacked_buffer = H264::ParseRbsp(data, length);
+  rtc::BitBuffer bit_buffer(unpacked_buffer->data(), unpacked_buffer->size());
+  return ParsePpsIdsInternal(&bit_buffer, pps_id, sps_id);
+}
+
+bool PpsParser::ParsePpsIdsInternal(rtc::BitBuffer* bit_buffer,

[danilchap, 2016/09/07 10:38:51]

and this one after ParseInternal

+                                    uint32_t* pps_id,
+                                    uint32_t* sps_id) {
+  // pic_parameter_set_id: ue(v)
+  if (!bit_buffer->ReadExponentialGolomb(pps_id))
+    return false;
+  // seq_parameter_set_id: ue(v)
+  if (!bit_buffer->ReadExponentialGolomb(sps_id))
+    return false;
+  return true;
+}
+
 rtc::Optional<PpsParser::PpsState> PpsParser::ParsePps(const uint8_t* data,
                                                        size_t length) {
   // First, parse out rbsp, which is basically the source buffer minus emulation
   // bytes (the last byte of a 0x00 0x00 0x03 sequence). RBSP is defined in
   // section 7.3.1 of the H.264 standard.
   std::unique_ptr<rtc::Buffer> unpacked_buffer = H264::ParseRbsp(data, length);
   rtc::BitBuffer bit_buffer(unpacked_buffer->data(), unpacked_buffer->size());
   return ParseInternal(&bit_buffer);
 }
 
@@ skipping 13 matching lines @@
   uint32_t slice_pps_id;
   if (!slice_reader.ReadExponentialGolomb(&slice_pps_id))
     return rtc::Optional<uint32_t>();
   return rtc::Optional<uint32_t>(slice_pps_id);
 }
 
 rtc::Optional<PpsParser::PpsState> PpsParser::ParseInternal(
     rtc::BitBuffer* bit_buffer) {
   PpsState pps;
 
+  RETURN_EMPTY_ON_FAIL(ParsePpsIdsInternal(bit_buffer, &pps.id, &pps.sps_id));
+
   uint32_t bits_tmp;
   uint32_t golomb_ignored;
-  // pic_parameter_set_id: ue(v)
-  RETURN_EMPTY_ON_FAIL(bit_buffer->ReadExponentialGolomb(&pps.id));
-  // seq_parameter_set_id: ue(v)
-  RETURN_EMPTY_ON_FAIL(bit_buffer->ReadExponentialGolomb(&pps.sps_id));
   // entropy_coding_mode_flag: u(1)
   uint32_t entropy_coding_mode_flag;
   RETURN_EMPTY_ON_FAIL(bit_buffer->ReadBits(&entropy_coding_mode_flag, 1));
   // TODO(pbos): Implement CABAC support if spotted in the wild.
   RTC_CHECK(entropy_coding_mode_flag == 0)
       << "Don't know how to parse CABAC streams.";
   // bottom_field_pic_order_in_frame_present_flag: u(1)
   uint32_t bottom_field_pic_order_in_frame_present_flag;
   RETURN_EMPTY_ON_FAIL(
       bit_buffer->ReadBits(&bottom_field_pic_order_in_frame_present_flag, 1));
@@ skipping 80 matching lines @@
   // constrained_intra_pred_flag: u(1)
   RETURN_EMPTY_ON_FAIL(bit_buffer->ReadBits(&bits_tmp, 2));
   // redundant_pic_cnt_present_flag: u(1)
   RETURN_EMPTY_ON_FAIL(
       bit_buffer->ReadBits(&pps.redundant_pic_cnt_present_flag, 1));
 
   return rtc::Optional<PpsParser::PpsState>(pps);
 }
 
 }  // namespace webrtc