Split ByteBuffer into writer/reader objects.

webrtc/modules/rtp_rtcp/source/h264_bitstream_parser.cc

 /*
  *  Copyright (c) 2015 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/modules/rtp_rtcp/source/h264_bitstream_parser.h"
@@ skipping 50 matching lines @@
 
 // Parses RBSP from source bytes. Removes emulation bytes, but leaves the
 // rbsp_trailing_bits() in the stream, since none of the parsing reads all the
 // way to the end of a parsed RBSP sequence. When writing, that means the
 // rbsp_trailing_bits() should be preserved and don't need to be restored (i.e.
 // the rbsp_stop_one_bit, which is just a 1, then zero padded), and alignment
 // should "just work".
 // TODO(pbos): Make parsing RBSP something that can be integrated into BitBuffer
 // so we don't have to copy the entire frames when only interested in the
 // headers.
-rtc::ByteBuffer* ParseRbsp(const uint8_t* bytes, size_t length) {
+rtc::ByteBufferWriter* ParseRbsp(const uint8_t* bytes, size_t length) {
   // Copied from webrtc::H264SpsParser::Parse.
-  rtc::ByteBuffer* rbsp_buffer = new rtc::ByteBuffer;
+  rtc::ByteBufferWriter* rbsp_buffer = new rtc::ByteBufferWriter();
   for (size_t i = 0; i < length;) {
     if (length - i >= 3 && bytes[i] == 0 && bytes[i + 1] == 0 &&
         bytes[i + 2] == 3) {
       rbsp_buffer->WriteBytes(reinterpret_cast<const char*>(bytes) + i, 2);
       i += 3;
     } else {
       rbsp_buffer->WriteBytes(reinterpret_cast<const char*>(bytes) + i, 1);
       i++;
     }
   }
@@ skipping 12 matching lines @@
 
 // These functions are similar to webrtc::H264SpsParser::Parse, and based on the
 // same version of the H.264 standard. You can find it here:
 // http://www.itu.int/rec/T-REC-H.264
 bool H264BitstreamParser::ParseSpsNalu(const uint8_t* sps, size_t length) {
   // Reset SPS state.
   sps_ = SpsState();
   sps_parsed_ = false;
   // Parse out the SPS RBSP. It should be small, so it's ok that we create a
   // copy. We'll eventually write this back.
-  rtc::scoped_ptr<rtc::ByteBuffer> sps_rbsp(
+  rtc::scoped_ptr<rtc::ByteBufferWriter> sps_rbsp(
       ParseRbsp(sps + kNaluHeaderAndTypeSize, length - kNaluHeaderAndTypeSize));
   rtc::BitBuffer sps_parser(reinterpret_cast<const uint8_t*>(sps_rbsp->Data()),
                             sps_rbsp->Length());
 
   uint8_t byte_tmp;
   uint32_t golomb_tmp;
   uint32_t bits_tmp;
 
   // profile_idc: u(8).
   uint8_t profile_idc;
@@ skipping 85 matching lines @@
   RETURN_FALSE_ON_FAIL(sps_parser.ReadBits(&sps_.frame_mbs_only_flag, 1));
   sps_parsed_ = true;
   return true;
 }
 
 bool H264BitstreamParser::ParsePpsNalu(const uint8_t* pps, size_t length) {
   RTC_CHECK(sps_parsed_);
   // We're starting a new stream, so reset picture type rewriting values.
   pps_ = PpsState();
   pps_parsed_ = false;
-  rtc::scoped_ptr<rtc::ByteBuffer> buffer(
+  rtc::scoped_ptr<rtc::ByteBufferWriter> buffer(
       ParseRbsp(pps + kNaluHeaderAndTypeSize, length - kNaluHeaderAndTypeSize));
   rtc::BitBuffer parser(reinterpret_cast<const uint8_t*>(buffer->Data()),
                         buffer->Length());
 
   uint32_t bits_tmp;
   uint32_t golomb_ignored;
   // pic_parameter_set_id: ue(v)
   RETURN_FALSE_ON_FAIL(parser.ReadExponentialGolomb(&golomb_ignored));
   // seq_parameter_set_id: ue(v)
   RETURN_FALSE_ON_FAIL(parser.ReadExponentialGolomb(&golomb_ignored));
@@ skipping 87 matching lines @@
   pps_parsed_ = true;
   return true;
 }
 
 bool H264BitstreamParser::ParseNonParameterSetNalu(const uint8_t* source,
                                                    size_t source_length,
                                                    uint8_t nalu_type) {
   RTC_CHECK(sps_parsed_);
   RTC_CHECK(pps_parsed_);
   last_slice_qp_delta_parsed_ = false;
-  rtc::scoped_ptr<rtc::ByteBuffer> slice_rbsp(ParseRbsp(
+  rtc::scoped_ptr<rtc::ByteBufferWriter> slice_rbsp(ParseRbsp(
       source + kNaluHeaderAndTypeSize, source_length - kNaluHeaderAndTypeSize));
   rtc::BitBuffer slice_reader(
       reinterpret_cast<const uint8_t*>(slice_rbsp->Data()),
       slice_rbsp->Length());
   // Check to see if this is an IDR slice, which has an extra field to parse
   // out.
   bool is_idr = (source[kNaluHeaderSize] & 0x0F) == kNaluIdr;
   uint8_t nal_ref_idc = (source[kNaluHeaderSize] & 0x60) >> 5;
   uint32_t golomb_tmp;
   uint32_t bits_tmp;
@@ skipping 225 matching lines @@
 }
 
 bool H264BitstreamParser::GetLastSliceQp(int* qp) const {
   if (!last_slice_qp_delta_parsed_)
     return false;
   *qp = 26 + pps_.pic_init_qp_minus26 + last_slice_qp_delta_;
   return true;
 }
 
 }  // namespace webrtc