Use suffixed {uint,int}{8,16,32,64}_t types.

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 72 matching lines @@
   }
   return rbsp_buffer;
 }
 
 #define RETURN_FALSE_ON_FAIL(x)       \
   if (!(x)) {                         \
     LOG_F(LS_ERROR) << "FAILED: " #x; \
     return false;                     \
   }
 
-H264BitstreamParser::PpsState::PpsState() {
-}
+H264BitstreamParser::PpsState::PpsState() {}
 
-H264BitstreamParser::SpsState::SpsState() {
-}
+H264BitstreamParser::SpsState::SpsState() {}
 
 // 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(
       ParseRbsp(sps + kNaluHeaderAndTypeSize, length - kNaluHeaderAndTypeSize));
-  rtc::BitBuffer sps_parser(reinterpret_cast<const uint8*>(sps_rbsp->Data()),
+  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 profile_idc;
+  uint8_t profile_idc;
   RETURN_FALSE_ON_FAIL(sps_parser.ReadUInt8(&profile_idc));
   // constraint_set0_flag through constraint_set5_flag + reserved_zero_2bits
   // 1 bit each for the flags + 2 bits = 8 bits = 1 byte.
   RETURN_FALSE_ON_FAIL(sps_parser.ReadUInt8(&byte_tmp));
   // level_idc: u(8)
   RETURN_FALSE_ON_FAIL(sps_parser.ReadUInt8(&byte_tmp));
   // seq_parameter_set_id: ue(v)
   RETURN_FALSE_ON_FAIL(sps_parser.ReadExponentialGolomb(&golomb_tmp));
   sps_.separate_colour_plane_flag = 0;
   // See if profile_idc has chroma format information.
   if (profile_idc == 100 || profile_idc == 110 || profile_idc == 122 ||
       profile_idc == 244 || profile_idc == 44 || profile_idc == 83 ||
       profile_idc == 86 || profile_idc == 118 || profile_idc == 128 ||
       profile_idc == 138 || profile_idc == 139 || profile_idc == 134) {
     // chroma_format_idc: ue(v)
-    uint32 chroma_format_idc;
+    uint32_t chroma_format_idc;
     RETURN_FALSE_ON_FAIL(sps_parser.ReadExponentialGolomb(&chroma_format_idc));
     if (chroma_format_idc == 3) {
       // separate_colour_plane_flag: u(1)
       RETURN_FALSE_ON_FAIL(
           sps_parser.ReadBits(&sps_.separate_colour_plane_flag, 1));
     }
     // bit_depth_luma_minus8: ue(v)
     RETURN_FALSE_ON_FAIL(sps_parser.ReadExponentialGolomb(&golomb_tmp));
     // bit_depth_chroma_minus8: ue(v)
     RETURN_FALSE_ON_FAIL(sps_parser.ReadExponentialGolomb(&golomb_tmp));
@@ skipping 61 matching lines @@
   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(
       ParseRbsp(pps + kNaluHeaderAndTypeSize, length - kNaluHeaderAndTypeSize));
-  rtc::BitBuffer parser(reinterpret_cast<const uint8*>(buffer->Data()),
+  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));
   // entropy_coding_mode_flag: u(1)
   uint32_t entropy_coding_mode_flag;
@@ skipping 88 matching lines @@
 
 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(
       source + kNaluHeaderAndTypeSize, source_length - kNaluHeaderAndTypeSize));
   rtc::BitBuffer slice_reader(
-      reinterpret_cast<const uint8*>(slice_rbsp->Data()), slice_rbsp->Length());
+      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;
 
   // first_mb_in_slice: ue(v)
   RETURN_FALSE_ON_FAIL(slice_reader.ReadExponentialGolomb(&golomb_tmp));
   // slice_type: ue(v)
   uint32_t slice_type;
   RETURN_FALSE_ON_FAIL(slice_reader.ReadExponentialGolomb(&slice_type));
   // slice_type's 5..9 range is used to indicate that all slices of a picture
   // have the same value of slice_type % 5, we don't care about that, so we map
   // to the corresponding 0..4 range.
   slice_type %= 5;
   // pic_parameter_set_id: ue(v)
   RETURN_FALSE_ON_FAIL(slice_reader.ReadExponentialGolomb(&golomb_tmp));
   if (sps_.separate_colour_plane_flag == 1) {
     // colour_plane_id
     RETURN_FALSE_ON_FAIL(slice_reader.ReadBits(&bits_tmp, 2));
   }
   // frame_num: u(v)
   // Represented by log2_max_frame_num_minus4 + 4 bits.
   RETURN_FALSE_ON_FAIL(
       slice_reader.ReadBits(&bits_tmp, sps_.log2_max_frame_num_minus4 + 4));
-  uint32 field_pic_flag = 0;
+  uint32_t field_pic_flag = 0;
   if (sps_.frame_mbs_only_flag == 0) {
     // field_pic_flag: u(1)
     RETURN_FALSE_ON_FAIL(slice_reader.ReadBits(&field_pic_flag, 1));
     if (field_pic_flag != 0) {
       // bottom_field_flag: u(1)
       RETURN_FALSE_ON_FAIL(slice_reader.ReadBits(&bits_tmp, 1));
     }
   }
   if (is_idr) {
     // idr_pic_id: ue(v)
@@ skipping 194 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