Switch to standard integer types in media/.

media/base/container_names.cc

 // Copyright (c) 2013 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/base/container_names.h"
 
 #include <cctype>
 #include <limits>
 
 #include "base/logging.h"
 #include "media/base/bit_reader.h"
 
 namespace media {
 
 namespace container_names {
 
-#define TAG(a, b, c, d) \
-    ((static_cast<uint32>(static_cast<uint8>(a)) << 24) | \
-     (static_cast<uint32>(static_cast<uint8>(b)) << 16) | \
-     (static_cast<uint32>(static_cast<uint8>(c)) << 8) | \
-     (static_cast<uint32>(static_cast<uint8>(d))))
+#define TAG(a, b, c, d)                                     \
+  ((static_cast<uint32_t>(static_cast<uint8_t>(a)) << 24) | \
+   (static_cast<uint32_t>(static_cast<uint8_t>(b)) << 16) | \
+   (static_cast<uint32_t>(static_cast<uint8_t>(c)) << 8) |  \
+   (static_cast<uint32_t>(static_cast<uint8_t>(d))))
 
 #define RCHECK(x)     \
     do {              \
       if (!(x))       \
         return false; \
     } while (0)
 
 #define UTF8_BYTE_ORDER_MARK "\xef\xbb\xbf"
 
 // Helper function to read 2 bytes (16 bits, big endian) from a buffer.
-static int Read16(const uint8* p) {
+static int Read16(const uint8_t* p) {
   return p[0] << 8 | p[1];
 }
 
 // Helper function to read 3 bytes (24 bits, big endian) from a buffer.
-static uint32 Read24(const uint8* p) {
+static uint32_t Read24(const uint8_t* p) {
   return p[0] << 16 | p[1] << 8 | p[2];
 }
 
 // Helper function to read 4 bytes (32 bits, big endian) from a buffer.
-static uint32 Read32(const uint8* p) {
+static uint32_t Read32(const uint8_t* p) {
   return p[0] << 24 | p[1] << 16 | p[2] << 8 | p[3];
 }
 
 // Helper function to read 4 bytes (32 bits, little endian) from a buffer.
-static uint32 Read32LE(const uint8* p) {
+static uint32_t Read32LE(const uint8_t* p) {
   return p[3] << 24 | p[2] << 16 | p[1] << 8 | p[0];
 }
 
 // Helper function to do buffer comparisons with a string without going off the
 // end of the buffer.
-static bool StartsWith(const uint8* buffer,
+static bool StartsWith(const uint8_t* buffer,
                        size_t buffer_size,
                        const char* prefix) {
   size_t prefix_size = strlen(prefix);
   return (prefix_size <= buffer_size &&
           memcmp(buffer, prefix, prefix_size) == 0);
 }
 
 // Helper function to do buffer comparisons with another buffer (to allow for
 // embedded \0 in the comparison) without going off the end of the buffer.
-static bool StartsWith(const uint8* buffer,
+static bool StartsWith(const uint8_t* buffer,
                        size_t buffer_size,
-                       const uint8* prefix,
+                       const uint8_t* prefix,
                        size_t prefix_size) {
   return (prefix_size <= buffer_size &&
           memcmp(buffer, prefix, prefix_size) == 0);
 }
 
 // Helper function to read up to 64 bits from a bit stream.
-static uint64 ReadBits(BitReader* reader, int num_bits) {
+static uint64_t ReadBits(BitReader* reader, int num_bits) {
   DCHECK_GE(reader->bits_available(), num_bits);
   DCHECK((num_bits > 0) && (num_bits <= 64));
-  uint64 value;
+  uint64_t value;
   reader->ReadBits(num_bits, &value);
   return value;
 }
 
 const int kAc3FrameSizeTable[38][3] = {
   { 128, 138, 192 }, { 128, 140, 192 }, { 160, 174, 240 }, { 160, 176, 240 },
   { 192, 208, 288 }, { 192, 210, 288 }, { 224, 242, 336 }, { 224, 244, 336 },
   { 256, 278, 384 }, { 256, 280, 384 }, { 320, 348, 480 }, { 320, 350, 480 },
   { 384, 416, 576 }, { 384, 418, 576 }, { 448, 486, 672 }, { 448, 488, 672 },
   { 512, 556, 768 }, { 512, 558, 768 }, { 640, 696, 960 }, { 640, 698, 960 },
   { 768, 834, 1152 }, { 768, 836, 1152 }, { 896, 974, 1344 },
   { 896, 976, 1344 }, { 1024, 1114, 1536 }, { 1024, 1116, 1536 },
   { 1280, 1392, 1920 }, { 1280, 1394, 1920 }, { 1536, 1670, 2304 },
   { 1536, 1672, 2304 }, { 1792, 1950, 2688 }, { 1792, 1952, 2688 },
   { 2048, 2228, 3072 }, { 2048, 2230, 3072 }, { 2304, 2506, 3456 },
   { 2304, 2508, 3456 }, { 2560, 2768, 3840 }, { 2560, 2770, 3840 }
 };
 
 // Checks for an ADTS AAC container.
-static bool CheckAac(const uint8* buffer, int buffer_size) {
+static bool CheckAac(const uint8_t* buffer, int buffer_size) {
   // Audio Data Transport Stream (ADTS) header is 7 or 9 bytes
   // (from http://wiki.multimedia.cx/index.php?title=ADTS)
   RCHECK(buffer_size > 6);
 
   int offset = 0;
   while (offset + 6 < buffer_size) {
     BitReader reader(buffer + offset, 6);
 
     // Syncword must be 0xfff.
     RCHECK(ReadBits(&reader, 12) == 0xfff);
@@ skipping 15 matching lines @@
     reader.SkipBits(1 + 3 + 1 + 1 + 1 + 1);
 
     // Get frame length (includes header).
     int size = ReadBits(&reader, 13);
     RCHECK(size > 0);
     offset += size;
   }
   return true;
 }
 
-const uint16 kAc3SyncWord = 0x0b77;
+const uint16_t kAc3SyncWord = 0x0b77;
 
 // Checks for an AC3 container.
-static bool CheckAc3(const uint8* buffer, int buffer_size) {
+static bool CheckAc3(const uint8_t* buffer, int buffer_size) {
   // Reference: ATSC Standard: Digital Audio Compression (AC-3, E-AC-3)
   //            Doc. A/52:2012
   // (http://www.atsc.org/cms/standards/A52-2012(12-17).pdf)
 
   // AC3 container looks like syncinfo | bsi | audblk * 6 | aux | check.
   RCHECK(buffer_size > 6);
 
   int offset = 0;
   while (offset + 6 < buffer_size) {
     BitReader reader(buffer + offset, 6);
@@ skipping 14 matching lines @@
 
     // Verify bsid.
     RCHECK(ReadBits(&reader, 5) < 10);  // Normally 8 or 6, 16 used by EAC3.
 
     offset += kAc3FrameSizeTable[frame_size_code][sample_rate_code];
   }
   return true;
 }
 
 // Checks for an EAC3 container (very similar to AC3)
-static bool CheckEac3(const uint8* buffer, int buffer_size) {
+static bool CheckEac3(const uint8_t* buffer, int buffer_size) {
   // Reference: ATSC Standard: Digital Audio Compression (AC-3, E-AC-3)
   //            Doc. A/52:2012
   // (http://www.atsc.org/cms/standards/A52-2012(12-17).pdf)
 
   // EAC3 container looks like syncinfo | bsi | audfrm | audblk* | aux | check.
   RCHECK(buffer_size > 6);
 
   int offset = 0;
   while (offset + 6 < buffer_size) {
     BitReader reader(buffer + offset, 6);
@@ skipping 17 matching lines @@
     // Verify bsid.
     int bit_stream_id = ReadBits(&reader, 5);
     RCHECK(bit_stream_id >= 11 && bit_stream_id <= 16);
 
     offset += frame_size;
   }
   return true;
 }
 
 // Additional checks for a BINK container.
-static bool CheckBink(const uint8* buffer, int buffer_size) {
+static bool CheckBink(const uint8_t* buffer, int buffer_size) {
   // Reference: http://wiki.multimedia.cx/index.php?title=Bink_Container
   RCHECK(buffer_size >= 44);
 
   // Verify number of frames specified.
   RCHECK(Read32LE(buffer + 8) > 0);
 
   // Verify width in range.
   int width = Read32LE(buffer + 20);
   RCHECK(width > 0 && width <= 32767);
 
   // Verify height in range.
   int height = Read32LE(buffer + 24);
   RCHECK(height > 0 && height <= 32767);
 
   // Verify frames per second specified.
   RCHECK(Read32LE(buffer + 28) > 0);
 
   // Verify video frames per second specified.
   RCHECK(Read32LE(buffer + 32) > 0);
 
   // Number of audio tracks must be 256 or less.
   return (Read32LE(buffer + 40) <= 256);
 }
 
 // Additional checks for a CAF container.
-static bool CheckCaf(const uint8* buffer, int buffer_size) {
+static bool CheckCaf(const uint8_t* buffer, int buffer_size) {
   // Reference: Apple Core Audio Format Specification 1.0
   // (https://developer.apple.com/library/mac/#documentation/MusicAudio/Reference/CAFSpec/CAF_spec/CAF_spec.html)
   RCHECK(buffer_size >= 52);
   BitReader reader(buffer, buffer_size);
 
   // mFileType should be "caff".
   RCHECK(ReadBits(&reader, 32) == TAG('c', 'a', 'f', 'f'));
 
   // mFileVersion should be 1.
   RCHECK(ReadBits(&reader, 16) == 1);
@@ skipping 20 matching lines @@
 }
 
 static bool kSamplingFrequencyValid[16] = { false, true, true, true, false,
                                             false, true, true, true, false,
                                             false, true, true, true, false,
                                             false };
 static bool kExtAudioIdValid[8] = { true, false, true, false, false, false,
                                     true, false };
 
 // Additional checks for a DTS container.
-static bool CheckDts(const uint8* buffer, int buffer_size) {
+static bool CheckDts(const uint8_t* buffer, int buffer_size) {
   // Reference: ETSI TS 102 114 V1.3.1 (2011-08)
   // (http://www.etsi.org/deliver/etsi_ts/102100_102199/102114/01.03.01_60/ts_102114v010301p.pdf)
   RCHECK(buffer_size > 11);
 
   int offset = 0;
   while (offset + 11 < buffer_size) {
     BitReader reader(buffer + offset, 11);
 
     // Verify sync word.
     RCHECK(ReadBits(&reader, 32) == 0x7ffe8001);
@@ skipping 34 matching lines @@
 
     // Verify low frequency effects flag is an allowed value.
     RCHECK(ReadBits(&reader, 2) != 3);
 
     offset += frame_size + 1;
   }
   return true;
 }
 
 // Checks for a DV container.
-static bool CheckDV(const uint8* buffer, int buffer_size) {
+static bool CheckDV(const uint8_t* buffer, int buffer_size) {
   // Reference: SMPTE 314M (Annex A has differences with IEC 61834).
   // (http://standards.smpte.org/content/978-1-61482-454-1/st-314-2005/SEC1.body.pdf)
   RCHECK(buffer_size > 11);
 
   int offset = 0;
   int current_sequence_number = -1;
   int last_block_number[6] = {0};
   while (offset + 11 < buffer_size) {
     BitReader reader(buffer + offset, 11);
 
@@ skipping 42 matching lines @@
     }
 
     // Move to next block.
     offset += 80;
   }
   return true;
 }
 
 
 // Checks for a GSM container.
-static bool CheckGsm(const uint8* buffer, int buffer_size) {
+static bool CheckGsm(const uint8_t* buffer, int buffer_size) {
   // Reference: ETSI EN 300 961 V8.1.1
   // (http://www.etsi.org/deliver/etsi_en/300900_300999/300961/08.01.01_60/en_300961v080101p.pdf)
   // also http://tools.ietf.org/html/rfc3551#page-24
   // GSM files have a 33 byte block, only first 4 bits are fixed.
   RCHECK(buffer_size >= 1024);  // Need enough data to do a decent check.
 
   int offset = 0;
   while (offset < buffer_size) {
     // First 4 bits of each block are xD.
     RCHECK((buffer[offset] & 0xf0) == 0xd0);
     offset += 33;
   }
   return true;
 }
 
 // Advance to the first set of |num_bits| bits that match |start_code|. |offset|
 // is the current location in the buffer, and is updated. |bytes_needed| is the
 // number of bytes that must remain in the buffer when |start_code| is found.
 // Returns true if start_code found (and enough space in the buffer after it),
 // false otherwise.
-static bool AdvanceToStartCode(const uint8* buffer,
+static bool AdvanceToStartCode(const uint8_t* buffer,
                                int buffer_size,
                                int* offset,
                                int bytes_needed,
                                int num_bits,
-                               uint32 start_code) {
+                               uint32_t start_code) {
   DCHECK_GE(bytes_needed, 3);
   DCHECK_LE(num_bits, 24);  // Only supports up to 24 bits.
 
   // Create a mask to isolate |num_bits| bits, once shifted over.
-  uint32 bits_to_shift = 24 - num_bits;
-  uint32 mask = (1 << num_bits) - 1;
+  uint32_t bits_to_shift = 24 - num_bits;
+  uint32_t mask = (1 << num_bits) - 1;
   while (*offset + bytes_needed < buffer_size) {
-    uint32 next = Read24(buffer + *offset);
+    uint32_t next = Read24(buffer + *offset);
     if (((next >> bits_to_shift) & mask) == start_code)
       return true;
     ++(*offset);
   }
   return false;
 }
 
 // Checks for an H.261 container.
-static bool CheckH261(const uint8* buffer, int buffer_size) {
+static bool CheckH261(const uint8_t* buffer, int buffer_size) {
   // Reference: ITU-T Recommendation H.261 (03/1993)
   // (http://www.itu.int/rec/T-REC-H.261-199303-I/en)
   RCHECK(buffer_size > 16);
 
   int offset = 0;
   bool seen_start_code = false;
   while (true) {
     // Advance to picture_start_code, if there is one.
     if (!AdvanceToStartCode(buffer, buffer_size, &offset, 4, 20, 0x10)) {
       // No start code found (or off end of buffer), so success if
@@ skipping 27 matching lines @@
       return seen_start_code;
     RCHECK(next == 1);
 
     // Move to the next block.
     seen_start_code = true;
     offset += 4;
   }
 }
 
 // Checks for an H.263 container.
-static bool CheckH263(const uint8* buffer, int buffer_size) {
+static bool CheckH263(const uint8_t* buffer, int buffer_size) {
   // Reference: ITU-T Recommendation H.263 (01/2005)
   // (http://www.itu.int/rec/T-REC-H.263-200501-I/en)
   // header is PSC(22b) + TR(8b) + PTYPE(8+b).
   RCHECK(buffer_size > 16);
 
   int offset = 0;
   bool seen_start_code = false;
   while (true) {
     // Advance to picture_start_code, if there is one.
     if (!AdvanceToStartCode(buffer, buffer_size, &offset, 9, 22, 0x20)) {
@@ skipping 47 matching lines @@
       RCHECK(ReadBits(&reader, 3) == 1);  // Not allowed.
     }
 
     // Move to the next block.
     seen_start_code = true;
     offset += 9;
   }
 }
 
 // Checks for an H.264 container.
-static bool CheckH264(const uint8* buffer, int buffer_size) {
+static bool CheckH264(const uint8_t* buffer, int buffer_size) {
   // Reference: ITU-T Recommendation H.264 (01/2012)
   // (http://www.itu.int/rec/T-REC-H.264)
   // Section B.1: Byte stream NAL unit syntax and semantics.
   RCHECK(buffer_size > 4);
 
   int offset = 0;
   int parameter_count = 0;
   while (true) {
     // Advance to picture_start_code, if there is one.
     if (!AdvanceToStartCode(buffer, buffer_size, &offset, 4, 24, 1)) {
@@ skipping 35 matching lines @@
     offset += 4;
   }
 }
 
 static const char kHlsSignature[] = "#EXTM3U";
 static const char kHls1[] = "#EXT-X-STREAM-INF:";
 static const char kHls2[] = "#EXT-X-TARGETDURATION:";
 static const char kHls3[] = "#EXT-X-MEDIA-SEQUENCE:";
 
 // Additional checks for a HLS container.
-static bool CheckHls(const uint8* buffer, int buffer_size) {
+static bool CheckHls(const uint8_t* buffer, int buffer_size) {
   // HLS is simply a play list used for Apple HTTP Live Streaming.
   // Reference: Apple HTTP Live Streaming Overview
   // (http://goo.gl/MIwxj)
 
   if (StartsWith(buffer, buffer_size, kHlsSignature)) {
     // Need to find "#EXT-X-STREAM-INF:", "#EXT-X-TARGETDURATION:", or
     // "#EXT-X-MEDIA-SEQUENCE:" somewhere in the buffer. Other playlists (like
     // WinAmp) only have additional lines with #EXTINF
     // (http://en.wikipedia.org/wiki/M3U).
     int offset = strlen(kHlsSignature);
     while (offset < buffer_size) {
       if (buffer[offset] == '#') {
         if (StartsWith(buffer + offset, buffer_size - offset, kHls1) ||
             StartsWith(buffer + offset, buffer_size - offset, kHls2) ||
             StartsWith(buffer + offset, buffer_size - offset, kHls3)) {
           return true;
         }
       }
       ++offset;
     }
   }
   return false;
 }
 
 // Checks for a MJPEG stream.
-static bool CheckMJpeg(const uint8* buffer, int buffer_size) {
+static bool CheckMJpeg(const uint8_t* buffer, int buffer_size) {
   // Reference: ISO/IEC 10918-1 : 1993(E), Annex B
   // (http://www.w3.org/Graphics/JPEG/itu-t81.pdf)
   RCHECK(buffer_size >= 16);
 
   int offset = 0;
   int last_restart = -1;
   int num_codes = 0;
   while (offset + 5 < buffer_size) {
     // Marker codes are always a two byte code with the first byte xFF.
     RCHECK(buffer[offset] == 0xff);
-    uint8 code = buffer[offset + 1];
+    uint8_t code = buffer[offset + 1];
     RCHECK(code >= 0xc0 || code == 1);
 
     // Skip sequences of xFF.
     if (code == 0xff) {
       ++offset;
       continue;
     }
 
     // Success if the next marker code is EOI (end of image)
     if (code == 0xd9)
@@ skipping 37 matching lines @@
   }
   return (num_codes > 1);
 }
 
 enum Mpeg2StartCodes {
   PROGRAM_END_CODE = 0xb9,
   PACK_START_CODE = 0xba
 };
 
 // Checks for a MPEG2 Program Stream.
-static bool CheckMpeg2ProgramStream(const uint8* buffer, int buffer_size) {
+static bool CheckMpeg2ProgramStream(const uint8_t* buffer, int buffer_size) {
   // Reference: ISO/IEC 13818-1 : 2000 (E) / ITU-T Rec. H.222.0 (2000 E).
   RCHECK(buffer_size > 14);
 
   int offset = 0;
   while (offset + 14 < buffer_size) {
     BitReader reader(buffer + offset, 14);
 
     // Must start with pack_start_code.
     RCHECK(ReadBits(&reader, 24) == 1);
     RCHECK(ReadBits(&reader, 8) == PACK_START_CODE);
@@ skipping 74 matching lines @@
       int pes_length = Read16(buffer + offset + 4);
       RCHECK(pes_length > 0);
       offset = offset + 6 + pes_length;
     }
   }
   // Success as we are off the end of the buffer and liked everything
   // in the buffer.
   return true;
 }
 
-const uint8 kMpeg2SyncWord = 0x47;
+const uint8_t kMpeg2SyncWord = 0x47;
 
 // Checks for a MPEG2 Transport Stream.
-static bool CheckMpeg2TransportStream(const uint8* buffer, int buffer_size) {
+static bool CheckMpeg2TransportStream(const uint8_t* buffer, int buffer_size) {
   // Spec: ISO/IEC 13818-1 : 2000 (E) / ITU-T Rec. H.222.0 (2000 E).
   // Normal packet size is 188 bytes. However, some systems add various error
   // correction data at the end, resulting in packet of length 192/204/208
   // (https://en.wikipedia.org/wiki/MPEG_transport_stream). Determine the
   // length with the first packet.
   RCHECK(buffer_size >= 250);  // Want more than 1 packet to check.
 
   int offset = 0;
   int packet_length = -1;
   while (buffer[offset] != kMpeg2SyncWord && offset < 20) {
@@ skipping 52 matching lines @@
 }
 
 enum Mpeg4StartCodes {
   VISUAL_OBJECT_SEQUENCE_START_CODE = 0xb0,
   VISUAL_OBJECT_SEQUENCE_END_CODE = 0xb1,
   VISUAL_OBJECT_START_CODE = 0xb5,
   VOP_START_CODE = 0xb6
 };
 
 // Checks for a raw MPEG4 bitstream container.
-static bool CheckMpeg4BitStream(const uint8* buffer, int buffer_size) {
+static bool CheckMpeg4BitStream(const uint8_t* buffer, int buffer_size) {
   // Defined in ISO/IEC 14496-2:2001.
   // However, no length ... simply scan for start code values.
   // Note tags are very similar to H.264.
   RCHECK(buffer_size > 4);
 
   int offset = 0;
   int sequence_start_count = 0;
   int sequence_end_count = 0;
   int visual_object_count = 0;
   int vop_count = 0;
@@ skipping 55 matching lines @@
       case VOP_START_CODE:
         RCHECK(++vop_count <= visual_object_count);
         break;
     }
     // Skip this block.
     offset += 6;
   }
 }
 
 // Additional checks for a MOV/QuickTime/MPEG4 container.
-static bool CheckMov(const uint8* buffer, int buffer_size) {
+static bool CheckMov(const uint8_t* buffer, int buffer_size) {
   // Reference: ISO/IEC 14496-12:2005(E).
   // (http://standards.iso.org/ittf/PubliclyAvailableStandards/c061988_ISO_IEC_14496-12_2012.zip)
   RCHECK(buffer_size > 8);
 
   int offset = 0;
   while (offset + 8 < buffer_size) {
-    uint32 atomsize = Read32(buffer + offset);
-    uint32 atomtype = Read32(buffer + offset + 4);
+    uint32_t atomsize = Read32(buffer + offset);
+    uint32_t atomtype = Read32(buffer + offset + 4);
     // Only need to check for ones that are valid at the top level.
     switch (atomtype) {
       case TAG('f','t','y','p'):
       case TAG('p','d','i','n'):
       case TAG('m','o','o','v'):
       case TAG('m','o','o','f'):
       case TAG('m','f','r','a'):
       case TAG('m','d','a','t'):
       case TAG('f','r','e','e'):
       case TAG('s','k','i','p'):
@@ skipping 46 matching lines @@
                                      288, 320, 352, 384, 416, 448, 0 };
 static int kBitRateTableV1L2[16] = { 0, 32, 48, 56, 64, 80, 96, 112, 128, 160,
                                      192, 224, 256, 320, 384, 0 };
 static int kBitRateTableV1L3[16] = { 0, 32, 40, 48, 56, 64, 80, 96, 112, 128,
                                      160, 192, 224, 256, 320, 0 };
 static int kBitRateTableV2L1[16] = { 0, 32, 48, 56, 64, 80, 96, 112, 128, 144,
                                      160, 176, 192, 224, 256, 0 };
 static int kBitRateTableV2L23[16] = { 0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96,
                                       112, 128, 144, 160, 0 };
 
-static bool ValidMpegAudioFrameHeader(const uint8* header,
+static bool ValidMpegAudioFrameHeader(const uint8_t* header,
                                       int header_size,
                                       int* framesize) {
   // Reference: http://mpgedit.org/mpgedit/mpeg_format/mpeghdr.htm.
   DCHECK_GE(header_size, 4);
   *framesize = 0;
   BitReader reader(header, 4);  // Header can only be 4 bytes long.
 
   // Verify frame sync (11 bits) are all set.
   RCHECK(ReadBits(&reader, 11) == 0x7ff);
 
@@ skipping 39 matching lines @@
       bitrate = kBitRateTableV2L23[bitrate_index];
   }
   if (layer == LAYER_1)
     *framesize = ((12000 * bitrate) / sampling_rate + padding) * 4;
   else
     *framesize = (144000 * bitrate) / sampling_rate + padding;
   return (bitrate > 0 && sampling_rate > 0);
 }
 
 // Extract a size encoded the MP3 way.
-static int GetMp3HeaderSize(const uint8* buffer, int buffer_size) {
+static int GetMp3HeaderSize(const uint8_t* buffer, int buffer_size) {
   DCHECK_GE(buffer_size, 9);
   int size = ((buffer[6] & 0x7f) << 21) + ((buffer[7] & 0x7f) << 14) +
              ((buffer[8] & 0x7f) << 7) + (buffer[9] & 0x7f) + 10;
   if (buffer[5] & 0x10)  // Footer added?
     size += 10;
   return size;
 }
 
 // Additional checks for a MP3 container.
-static bool CheckMp3(const uint8* buffer, int buffer_size, bool seenHeader) {
+static bool CheckMp3(const uint8_t* buffer, int buffer_size, bool seenHeader) {
   RCHECK(buffer_size >= 10);  // Must be enough to read the initial header.
 
   int framesize;
   int numSeen = 0;
   int offset = 0;
   if (seenHeader) {
     offset = GetMp3HeaderSize(buffer, buffer_size);
   } else {
     // Skip over leading 0's.
     while (offset < buffer_size && buffer[offset] == 0)
@@ skipping 10 matching lines @@
     offset += framesize;
   }
   // Off the end of the buffer, return success if a few valid headers seen.
   return numSeen > 2;
 }
 
 // Check that the next characters in |buffer| represent a number. The format
 // accepted is optional whitespace followed by 1 or more digits. |max_digits|
 // specifies the maximum number of digits to process. Returns true if a valid
 // number is found, false otherwise.
-static bool VerifyNumber(const uint8* buffer,
+static bool VerifyNumber(const uint8_t* buffer,
                          int buffer_size,
                          int* offset,
                          int max_digits) {
   RCHECK(*offset < buffer_size);
 
   // Skip over any leading space.
   while (isspace(buffer[*offset])) {
     ++(*offset);
     RCHECK(*offset < buffer_size);
   }
 
   // Need to process up to max_digits digits.
   int numSeen = 0;
   while (--max_digits >= 0 && isdigit(buffer[*offset])) {
     ++numSeen;
     ++(*offset);
     if (*offset >= buffer_size)
       return true;  // Out of space but seen a digit.
   }
 
   // Success if at least one digit seen.
   return (numSeen > 0);
 }
 
 // Check that the next character in |buffer| is one of |c1| or |c2|. |c2| is
 // optional. Returns true if there is a match, false if no match or out of
 // space.
-static inline bool VerifyCharacters(const uint8* buffer,
+static inline bool VerifyCharacters(const uint8_t* buffer,
                                     int buffer_size,
                                     int* offset,
                                     char c1,
                                     char c2) {
   RCHECK(*offset < buffer_size);
   char c = static_cast<char>(buffer[(*offset)++]);
   return (c == c1 || (c == c2 && c2 != 0));
 }
 
 // Checks for a SRT container.
-static bool CheckSrt(const uint8* buffer, int buffer_size) {
+static bool CheckSrt(const uint8_t* buffer, int buffer_size) {
   // Reference: http://en.wikipedia.org/wiki/SubRip
   RCHECK(buffer_size > 20);
 
   // First line should just be the subtitle sequence number.
   int offset = StartsWith(buffer, buffer_size, UTF8_BYTE_ORDER_MARK) ? 3 : 0;
   RCHECK(VerifyNumber(buffer, buffer_size, &offset, 100));
   RCHECK(VerifyCharacters(buffer, buffer_size, &offset, '\n', '\r'));
 
   // Skip any additional \n\r.
   while (VerifyCharacters(buffer, buffer_size, &offset, '\n', '\r')) {}
@@ skipping 40 matching lines @@
         // prefix[] adds back the bits read individually.
         return ReadBits(reader, num_bits_to_read) | prefix[i];
       }
     }
   }
   // Invalid encoding, return something not expected.
   return -1;
 }
 
 // Read a Matroska Unsigned Integer (VINT).
-static uint64 GetVint(BitReader* reader) {
+static uint64_t GetVint(BitReader* reader) {
   // Values are coded with the leading zero bits (max 7) determining size.
   // If it is an invalid coding or the end of the buffer is reached,
   // return something that will go off the end of the buffer.
   if (reader->bits_available() >= 8) {
     int num_bits_to_read = 0;
     for (int i = 0; i < 8; ++i) {
       num_bits_to_read += 7;
       if (ReadBits(reader, 1) == 1) {
         if (reader->bits_available() < num_bits_to_read)
           break;
         return ReadBits(reader, num_bits_to_read);
       }
     }
   }
   // Incorrect format (more than 7 leading 0's) or off the end of the buffer.
   // Since the return value is used as a byte size, return a value that will
   // cause a failure when used.
   return (reader->bits_available() / 8) + 2;
 }
 
 // Additional checks for a WEBM container.
-static bool CheckWebm(const uint8* buffer, int buffer_size) {
+static bool CheckWebm(const uint8_t* buffer, int buffer_size) {
   // Reference: http://www.matroska.org/technical/specs/index.html
   RCHECK(buffer_size > 12);
 
   BitReader reader(buffer, buffer_size);
 
   // Verify starting Element Id.
   RCHECK(GetElementId(&reader) == 0x1a45dfa3);
 
   // Get the header size, and ensure there are enough bits to check.
   int header_size = GetVint(&reader);
@@ skipping 32 matching lines @@
   return false;
 }
 
 enum VC1StartCodes {
   VC1_FRAME_START_CODE = 0x0d,
   VC1_ENTRY_POINT_START_CODE = 0x0e,
   VC1_SEQUENCE_START_CODE = 0x0f
 };
 
 // Checks for a VC1 bitstream container.
-static bool CheckVC1(const uint8* buffer, int buffer_size) {
+static bool CheckVC1(const uint8_t* buffer, int buffer_size) {
   // Reference: SMPTE 421M
   // (http://standards.smpte.org/content/978-1-61482-555-5/st-421-2006/SEC1.body.pdf)
   // However, no length ... simply scan for start code values.
   // Expect to see SEQ | [ [ ENTRY ] PIC* ]*
   // Note tags are very similar to H.264.
 
   RCHECK(buffer_size >= 24);
 
   // First check for Bitstream Metadata Serialization (Annex L)
   if (buffer[0] == 0xc5 &&
@@ skipping 87 matching lines @@
         ++frame_start_code;
         break;
     }
     offset += 5;
   }
 }
 
 // For some formats the signature is a bunch of characters. They are defined
 // below. Note that the first 4 characters of the string may be used as a TAG
 // in LookupContainerByFirst4. For signatures that contain embedded \0, use
-// uint8[].
+// uint8_t[].
 static const char kAmrSignature[] = "#!AMR";
-static const uint8 kAsfSignature[] = { 0x30, 0x26, 0xb2, 0x75, 0x8e, 0x66, 0xcf,
-                                       0x11, 0xa6, 0xd9, 0x00, 0xaa, 0x00, 0x62,
-                                       0xce, 0x6c };
+static const uint8_t kAsfSignature[] = {0x30, 0x26, 0xb2, 0x75, 0x8e, 0x66,
+                                        0xcf, 0x11, 0xa6, 0xd9, 0x00, 0xaa,
+                                        0x00, 0x62, 0xce, 0x6c};
 static const char kAssSignature[] = "[Script Info]";
 static const char kAssBomSignature[] = UTF8_BYTE_ORDER_MARK "[Script Info]";
-static const uint8 kWtvSignature[] = { 0xb7, 0xd8, 0x00, 0x20, 0x37, 0x49, 0xda,
-                                       0x11, 0xa6, 0x4e, 0x00, 0x07, 0xe9, 0x5e,
-                                       0xad, 0x8d };
+static const uint8_t kWtvSignature[] = {0xb7, 0xd8, 0x00, 0x20, 0x37, 0x49,
+                                        0xda, 0x11, 0xa6, 0x4e, 0x00, 0x07,
+                                        0xe9, 0x5e, 0xad, 0x8d};
 
 // Attempt to determine the container type from the buffer provided. This is
 // a simple pass, that uses the first 4 bytes of the buffer as an index to get
 // a rough idea of the container format.
-static MediaContainerName LookupContainerByFirst4(const uint8* buffer,
+static MediaContainerName LookupContainerByFirst4(const uint8_t* buffer,
                                                   int buffer_size) {
   // Minimum size that the code expects to exist without checking size.
   if (buffer_size < 12)
     return CONTAINER_UNKNOWN;
 
-  uint32 first4 = Read32(buffer);
+  uint32_t first4 = Read32(buffer);
   switch (first4) {
     case 0x1a45dfa3:
       if (CheckWebm(buffer, buffer_size))
         return CONTAINER_WEBM;
       break;
 
     case 0x3026b275:
       if (StartsWith(buffer,
                      buffer_size,
                      kAsfSignature,
@@ skipping 132 matching lines @@
                      buffer_size,
                      kWtvSignature,
                      sizeof(kWtvSignature))) {
         return CONTAINER_WTV;
       }
       break;
   }
 
   // Now try a few different ones that look at something other
   // than the first 4 bytes.
-  uint32 first3 = first4 & 0xffffff00;
+  uint32_t first3 = first4 & 0xffffff00;
   switch (first3) {
     case TAG('C','W','S',0):
     case TAG('F','W','S',0):
       return CONTAINER_SWF;
 
     case TAG('I','D','3',0):
       if (CheckMp3(buffer, buffer_size, true))
         return CONTAINER_MP3;
       break;
   }
 
   // Maybe the first 2 characters are something we can use.
-  uint32 first2 = Read16(buffer);
+  uint32_t first2 = Read16(buffer);
   switch (first2) {
     case kAc3SyncWord:
       if (CheckAc3(buffer, buffer_size))
         return CONTAINER_AC3;
       if (CheckEac3(buffer, buffer_size))
         return CONTAINER_EAC3;
       break;
 
     case 0xfff0:
     case 0xfff1:
     case 0xfff8:
     case 0xfff9:
       if (CheckAac(buffer, buffer_size))
         return CONTAINER_AAC;
       break;
   }
 
   // Check if the file is in MP3 format without the header.
   if (CheckMp3(buffer, buffer_size, false))
     return CONTAINER_MP3;
 
   return CONTAINER_UNKNOWN;
 }
 
 // Attempt to determine the container name from the buffer provided.
-MediaContainerName DetermineContainer(const uint8* buffer, int buffer_size) {
+MediaContainerName DetermineContainer(const uint8_t* buffer, int buffer_size) {
   DCHECK(buffer);
 
   // Since MOV/QuickTime/MPEG4 streams are common, check for them first.
   if (CheckMov(buffer, buffer_size))
     return CONTAINER_MOV;
 
   // Next attempt the simple checks, that typically look at just the
   // first few bytes of the file.
   MediaContainerName result = LookupContainerByFirst4(buffer, buffer_size);
   if (result != CONTAINER_UNKNOWN)
@@ skipping 32 matching lines @@
     if (CheckEac3(buffer + offset, buffer_size - offset))
       return CONTAINER_EAC3;
   }
 
   return CONTAINER_UNKNOWN;
 }
 
 }  // namespace container_names
 
 }  // namespace media