Reland of Add pps id and sps id parsing to the h.264 depacketizer.

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.
  */
 
 #include "webrtc/common_video/h264/pps_parser.h"
 
+#include <memory>
+
 #include "webrtc/common_video/h264/h264_common.h"
 #include "webrtc/base/bitbuffer.h"
 #include "webrtc/base/buffer.h"
 #include "webrtc/base/logging.h"
 
 #define RETURN_EMPTY_ON_FAIL(x)                  \
   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
 
 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);
 }
 
+rtc::Optional<uint32_t> PpsParser::ParsePpsIdFromSlice(const uint8_t* data,
+                                                       size_t length) {
+  std::unique_ptr<rtc::Buffer> slice_rbsp(H264::ParseRbsp(data, length));
+  rtc::BitBuffer slice_reader(slice_rbsp->data(), slice_rbsp->size());
+
+  uint32_t golomb_tmp;
+  // first_mb_in_slice: ue(v)
+  if (!slice_reader.ReadExponentialGolomb(&golomb_tmp))
+    return rtc::Optional<uint32_t>();
+  // slice_type: ue(v)
+  if (!slice_reader.ReadExponentialGolomb(&golomb_tmp))
+    return rtc::Optional<uint32_t>();
+  // pic_parameter_set_id: ue(v)
+  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;
 
   uint32_t bits_tmp;
   uint32_t golomb_ignored;
   // pic_parameter_set_id: ue(v)
-  RETURN_EMPTY_ON_FAIL(bit_buffer->ReadExponentialGolomb(&golomb_ignored));
+  RETURN_EMPTY_ON_FAIL(bit_buffer->ReadExponentialGolomb(&pps.id));
   // seq_parameter_set_id: ue(v)
-  RETURN_EMPTY_ON_FAIL(bit_buffer->ReadExponentialGolomb(&golomb_ignored));
+  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