Switch to standard integer types in media/.

media/formats/mp4/aac.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/formats/mp4/aac.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "media/base/bit_reader.h"
 #include "media/formats/mp4/rcheck.h"
 #include "media/formats/mpeg/adts_constants.h"
 
 namespace media {
 namespace mp4 {
 
 AAC::AAC()
     : profile_(0), frequency_index_(0), channel_config_(0), frequency_(0),
       extension_frequency_(0), channel_layout_(CHANNEL_LAYOUT_UNSUPPORTED) {
 }
 
 AAC::~AAC() {
 }
 
-bool AAC::Parse(const std::vector<uint8>& data,
+bool AAC::Parse(const std::vector<uint8_t>& data,
                 const scoped_refptr<MediaLog>& media_log) {
 #if defined(OS_ANDROID)
   codec_specific_data_ = data;
 #endif
   if (data.empty())
     return false;
 
   BitReader reader(&data[0], data.size());
-  uint8 extension_type = 0;
+  uint8_t extension_type = 0;
   bool ps_present = false;
-  uint8 extension_frequency_index = 0xff;
+  uint8_t extension_frequency_index = 0xff;
 
   frequency_ = 0;
   extension_frequency_ = 0;
 
   // TODO(msu.koo): Need to consider whether ISO 14496-3:2009 needs
   // to be reflected instead of ISO 14496-3:2005.
   // https://crbug.com/532281
 
   // The following code is written according to ISO 14496-3:2005 Table 1.13 -
   // Syntax of AudioSpecificConfig.
@@ skipping 14 matching lines @@
       RCHECK(reader.ReadBits(24, &extension_frequency_));
     RCHECK(reader.ReadBits(5, &profile_));
   }
 
   RCHECK(SkipDecoderGASpecificConfig(&reader));
   RCHECK(SkipErrorSpecificConfig());
 
   // Read extension configuration again
   // Note: The check for 16 available bits comes from the AAC spec.
   if (extension_type != 5 && reader.bits_available() >= 16) {
-    uint16 sync_extension_type;
-    uint8 sbr_present_flag;
-    uint8 ps_present_flag;
+    uint16_t sync_extension_type;
+    uint8_t sbr_present_flag;
+    uint8_t ps_present_flag;
 
     if (reader.ReadBits(11, &sync_extension_type) &&
         sync_extension_type == 0x2b7) {
       if (reader.ReadBits(5, &extension_type) && extension_type == 5) {
         RCHECK(reader.ReadBits(1, &sbr_present_flag));
 
         if (sbr_present_flag) {
           RCHECK(reader.ReadBits(4, &extension_frequency_index));
 
           if (extension_frequency_index == 0xf)
@@ skipping 87 matching lines @@
 ChannelLayout AAC::GetChannelLayout(bool sbr_in_mimetype) const {
   // Check for implicit signalling of HE-AAC and indicate stereo output
   // if the mono channel configuration is signalled.
   // See ISO 14496-3:2005 Section 1.6.5.3 for details about this special casing.
   if (sbr_in_mimetype && channel_config_ == 1)
     return CHANNEL_LAYOUT_STEREO;
 
   return channel_layout_;
 }
 
-bool AAC::ConvertEsdsToADTS(std::vector<uint8>* buffer) const {
+bool AAC::ConvertEsdsToADTS(std::vector<uint8_t>* buffer) const {
   size_t size = buffer->size() + kADTSHeaderMinSize;
 
   DCHECK(profile_ >= 1 && profile_ <= 4 && frequency_index_ != 0xf &&
          channel_config_ <= 7);
 
   // ADTS header uses 13 bits for packet size.
   if (size >= (1 << 13))
     return false;
 
-  std::vector<uint8>& adts = *buffer;
+  std::vector<uint8_t>& adts = *buffer;
 
   adts.insert(buffer->begin(), kADTSHeaderMinSize, 0);
   adts[0] = 0xff;
   adts[1] = 0xf1;
   adts[2] = ((profile_ - 1) << 6) + (frequency_index_ << 2) +
       (channel_config_ >> 2);
-  adts[3] = static_cast<uint8>(((channel_config_ & 0x3) << 6) + (size >> 11));
-  adts[4] = static_cast<uint8>((size & 0x7ff) >> 3);
+  adts[3] = static_cast<uint8_t>(((channel_config_ & 0x3) << 6) + (size >> 11));
+  adts[4] = static_cast<uint8_t>((size & 0x7ff) >> 3);
   adts[5] = ((size & 7) << 5) + 0x1f;
   adts[6] = 0xfc;
 
   return true;
 }
 
 // Currently this function only support GASpecificConfig defined in
 // ISO 14496-3:2005 Table 4.1 - Syntax of GASpecificConfig()
 bool AAC::SkipDecoderGASpecificConfig(BitReader* bit_reader) const {
   switch (profile_) {
@@ skipping 33 matching lines @@
     default:
       break;
   }
 
   return true;
 }
 
 // The following code is written according to ISO 14496-3:2005 Table 4.1 -
 // GASpecificConfig.
 bool AAC::SkipGASpecificConfig(BitReader* bit_reader) const {
-  uint8 extension_flag = 0;
-  uint8 depends_on_core_coder;
-  uint16 dummy;
+  uint8_t extension_flag = 0;
+  uint8_t depends_on_core_coder;
+  uint16_t dummy;
 
   RCHECK(bit_reader->ReadBits(1, &dummy));  // frameLengthFlag
   RCHECK(bit_reader->ReadBits(1, &depends_on_core_coder));
   if (depends_on_core_coder == 1)
     RCHECK(bit_reader->ReadBits(14, &dummy));  // coreCoderDelay
 
   RCHECK(bit_reader->ReadBits(1, &extension_flag));
   RCHECK(channel_config_ != 0);
 
   if (profile_ == 6 || profile_ == 20)
@@ skipping 11 matching lines @@
 
     RCHECK(bit_reader->ReadBits(1, &dummy));  // extensionFlag3
   }
 
   return true;
 }
 
 }  // namespace mp4
 
 }  // namespace media