Switch to standard integer types in media/.

media/formats/mp2t/ts_packet.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/mp2t/ts_packet.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "media/base/bit_reader.h"
 #include "media/formats/mp2t/mp2t_common.h"
 
 namespace media {
 namespace mp2t {
 
-static const uint8 kTsHeaderSyncword = 0x47;
+static const uint8_t kTsHeaderSyncword = 0x47;
 
 // static
-int TsPacket::Sync(const uint8* buf, int size) {
+int TsPacket::Sync(const uint8_t* buf, int size) {
   int k = 0;
   for (; k < size; k++) {
     // Verify that we have 4 syncwords in a row when possible,
     // this should improve synchronization robustness.
     // TODO(damienv): Consider the case where there is garbage
     // between TS packets.
     bool is_header = true;
     for (int i = 0; i < 4; i++) {
       int idx = k + i * kPacketSize;
       if (idx >= size)
         break;
       if (buf[idx] != kTsHeaderSyncword) {
         DVLOG(LOG_LEVEL_TS)
             << "ByteSync" << idx << ": "
             << std::hex << static_cast<int>(buf[idx]) << std::dec;
         is_header = false;
         break;
       }
     }
     if (is_header)
       break;
   }
 
   DVLOG_IF(1, k != 0) << "SYNC: nbytes_skipped=" << k;
   return k;
 }
 
 // static
-TsPacket* TsPacket::Parse(const uint8* buf, int size) {
+TsPacket* TsPacket::Parse(const uint8_t* buf, int size) {
   if (size < kPacketSize) {
     DVLOG(1) << "Buffer does not hold one full TS packet:"
              << " buffer_size=" << size;
     return NULL;
   }
 
   DCHECK_EQ(buf[0], kTsHeaderSyncword);
   if (buf[0] != kTsHeaderSyncword) {
     DVLOG(1) << "Not on a TS syncword:"
              << " buf[0]="
              << std::hex << static_cast<int>(buf[0]) << std::dec;
     return NULL;
   }
 
   scoped_ptr<TsPacket> ts_packet(new TsPacket());
   bool status = ts_packet->ParseHeader(buf);
   if (!status) {
     DVLOG(1) << "Parsing header failed";
     return NULL;
   }
   return ts_packet.release();
 }
 
 TsPacket::TsPacket() {
 }
 
 TsPacket::~TsPacket() {
 }
 
-bool TsPacket::ParseHeader(const uint8* buf) {
+bool TsPacket::ParseHeader(const uint8_t* buf) {
   BitReader bit_reader(buf, kPacketSize);
   payload_ = buf;
   payload_size_ = kPacketSize;
 
   // Read the TS header: 4 bytes.
   int syncword;
   int transport_error_indicator;
   int payload_unit_start_indicator;
   int transport_priority;
   int transport_scrambling_control;
@@ skipping 67 matching lines @@
   RCHECK(bit_reader->ReadBits(1, &elementary_stream_priority_indicator));
   RCHECK(bit_reader->ReadBits(1, &pcr_flag));
   RCHECK(bit_reader->ReadBits(1, &opcr_flag));
   RCHECK(bit_reader->ReadBits(1, &splicing_point_flag));
   RCHECK(bit_reader->ReadBits(1, &transport_private_data_flag));
   RCHECK(bit_reader->ReadBits(1, &adaptation_field_extension_flag));
   discontinuity_indicator_ = (discontinuity_indicator != 0);
   random_access_indicator_ = (random_access_indicator != 0);
 
   if (pcr_flag) {
-    int64 program_clock_reference_base;
+    int64_t program_clock_reference_base;
     int reserved;
     int program_clock_reference_extension;
     RCHECK(bit_reader->ReadBits(33, &program_clock_reference_base));
     RCHECK(bit_reader->ReadBits(6, &reserved));
     RCHECK(bit_reader->ReadBits(9, &program_clock_reference_extension));
   }
 
   if (opcr_flag) {
-    int64 original_program_clock_reference_base;
+    int64_t original_program_clock_reference_base;
     int reserved;
     int original_program_clock_reference_extension;
     RCHECK(bit_reader->ReadBits(33, &original_program_clock_reference_base));
     RCHECK(bit_reader->ReadBits(6, &reserved));
     RCHECK(
         bit_reader->ReadBits(9, &original_program_clock_reference_extension));
   }
 
   if (splicing_point_flag) {
     int splice_countdown;
@@ skipping 27 matching lines @@
         << std::hex << stuffing_byte;
   }
 
   DVLOG(LOG_LEVEL_TS) << "random_access_indicator=" << random_access_indicator_;
   return true;
 }
 
 }  // namespace mp2t
 }  // namespace media