Optimize ParseRbsp method in H264 bitstream parser.

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 <vector>
 
 #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 {
 const int kMaxPicInitQpDeltaValue = 25;
 const int kMinPicInitQpDeltaValue = -26;
 }
 
 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());
+  std::vector<uint8_t> unpacked_buffer = H264::ParseRbsp(data, length);
+  rtc::BitBuffer bit_buffer(unpacked_buffer.data(), unpacked_buffer.size());
   return ParseInternal(&bit_buffer);
 }
 
 bool PpsParser::ParsePpsIds(const uint8_t* data,
                             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());
+  std::vector<uint8_t> unpacked_buffer = H264::ParseRbsp(data, length);
+  rtc::BitBuffer bit_buffer(unpacked_buffer.data(), unpacked_buffer.size());
   return ParsePpsIdsInternal(&bit_buffer, pps_id, sps_id);
 }
 
 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());
+  std::vector<uint8_t> unpacked_buffer = H264::ParseRbsp(data, length);
+  rtc::BitBuffer slice_reader(unpacked_buffer.data(), unpacked_buffer.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;
@@ skipping 118 matching lines @@
   // 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;
 }
 
 }  // namespace webrtc