Switch to standard integer types in media/.

media/formats/mp4/box_definitions.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/box_definitions.h"
 
 #include "base/logging.h"
 #include "media/base/video_types.h"
 #include "media/base/video_util.h"
 #include "media/formats/mp4/avc.h"
@@ skipping 83 matching lines @@
 
 SampleAuxiliaryInformationOffset::SampleAuxiliaryInformationOffset() {}
 SampleAuxiliaryInformationOffset::~SampleAuxiliaryInformationOffset() {}
 FourCC SampleAuxiliaryInformationOffset::BoxType() const { return FOURCC_SAIO; }
 
 bool SampleAuxiliaryInformationOffset::Parse(BoxReader* reader) {
   RCHECK(reader->ReadFullBoxHeader());
   if (reader->flags() & 1)
     RCHECK(reader->SkipBytes(8));
 
-  uint32 count;
+  uint32_t count;
   RCHECK(reader->Read4(&count) &&
          reader->HasBytes(count * (reader->version() == 1 ? 8 : 4)));
   offsets.resize(count);
 
-  for (uint32 i = 0; i < count; i++) {
+  for (uint32_t i = 0; i < count; i++) {
     if (reader->version() == 1) {
       RCHECK(reader->Read8(&offsets[i]));
     } else {
       RCHECK(reader->Read4Into8(&offsets[i]));
     }
   }
   return true;
 }
 
 SampleAuxiliaryInformationSize::SampleAuxiliaryInformationSize()
@@ skipping 33 matching lines @@
   return true;
 }
 
 TrackEncryption::TrackEncryption()
   : is_encrypted(false), default_iv_size(0) {
 }
 TrackEncryption::~TrackEncryption() {}
 FourCC TrackEncryption::BoxType() const { return FOURCC_TENC; }
 
 bool TrackEncryption::Parse(BoxReader* reader) {
-  uint8 flag;
+  uint8_t flag;
   RCHECK(reader->ReadFullBoxHeader() &&
          reader->SkipBytes(2) &&
          reader->Read1(&flag) &&
          reader->Read1(&default_iv_size) &&
          reader->ReadVec(&default_kid, 16));
   is_encrypted = (flag != 0);
   if (is_encrypted) {
     RCHECK(default_iv_size == 8 || default_iv_size == 16);
   } else {
     RCHECK(default_iv_size == 0);
@@ skipping 110 matching lines @@
   height >>= 1;
 
   return true;
 }
 
 SampleDescription::SampleDescription() : type(kInvalid) {}
 SampleDescription::~SampleDescription() {}
 FourCC SampleDescription::BoxType() const { return FOURCC_STSD; }
 
 bool SampleDescription::Parse(BoxReader* reader) {
-  uint32 count;
+  uint32_t count;
   RCHECK(reader->SkipBytes(4) &&
          reader->Read4(&count));
   video_entries.clear();
   audio_entries.clear();
 
   // Note: this value is preset before scanning begins. See comments in the
   // Parse(Media*) function.
   if (type == kVideo) {
     RCHECK(reader->ReadAllChildren(&video_entries));
   } else if (type == kAudio) {
@@ skipping 20 matching lines @@
     sample_group_description.entries.clear();
   }
   return true;
 }
 
 EditList::EditList() {}
 EditList::~EditList() {}
 FourCC EditList::BoxType() const { return FOURCC_ELST; }
 
 bool EditList::Parse(BoxReader* reader) {
-  uint32 count;
+  uint32_t count;
   RCHECK(reader->ReadFullBoxHeader() && reader->Read4(&count));
 
   if (reader->version() == 1) {
     RCHECK(reader->HasBytes(count * 20));
   } else {
     RCHECK(reader->HasBytes(count * 12));
   }
   edits.resize(count);
 
   for (std::vector<EditListEntry>::iterator edit = edits.begin();
@@ skipping 44 matching lines @@
       avc_level(0),
       length_size(0) {}
 
 AVCDecoderConfigurationRecord::~AVCDecoderConfigurationRecord() {}
 FourCC AVCDecoderConfigurationRecord::BoxType() const { return FOURCC_AVCC; }
 
 bool AVCDecoderConfigurationRecord::Parse(BoxReader* reader) {
   return ParseInternal(reader, reader->media_log());
 }
 
-bool AVCDecoderConfigurationRecord::Parse(const uint8* data, int data_size) {
+bool AVCDecoderConfigurationRecord::Parse(const uint8_t* data, int data_size) {
   BufferReader reader(data, data_size);
   return ParseInternal(&reader, new MediaLog());
 }
 
 bool AVCDecoderConfigurationRecord::ParseInternal(
     BufferReader* reader,
     const scoped_refptr<MediaLog>& media_log) {
   RCHECK(reader->Read1(&version) && version == 1 &&
          reader->Read1(&profile_indication) &&
          reader->Read1(&profile_compatibility) &&
          reader->Read1(&avc_level));
 
-  uint8 length_size_minus_one;
+  uint8_t length_size_minus_one;
   RCHECK(reader->Read1(&length_size_minus_one));
   length_size = (length_size_minus_one & 0x3) + 1;
 
   RCHECK(length_size != 3); // Only values of 1, 2, and 4 are valid.
 
-  uint8 num_sps;
+  uint8_t num_sps;
   RCHECK(reader->Read1(&num_sps));
   num_sps &= 0x1f;
 
   sps_list.resize(num_sps);
   for (int i = 0; i < num_sps; i++) {
-    uint16 sps_length;
+    uint16_t sps_length;
     RCHECK(reader->Read2(&sps_length) &&
            reader->ReadVec(&sps_list[i], sps_length));
     RCHECK(sps_list[i].size() > 4);
 
     if (media_log.get()) {
       MEDIA_LOG(INFO, media_log) << "Video codec: avc1." << std::hex
                                  << static_cast<int>(sps_list[i][1])
                                  << static_cast<int>(sps_list[i][2])
                                  << static_cast<int>(sps_list[i][3]);
     }
   }
 
-  uint8 num_pps;
+  uint8_t num_pps;
   RCHECK(reader->Read1(&num_pps));
 
   pps_list.resize(num_pps);
   for (int i = 0; i < num_pps; i++) {
-    uint16 pps_length;
+    uint16_t pps_length;
     RCHECK(reader->Read2(&pps_length) &&
            reader->ReadVec(&pps_list[i], pps_length));
   }
 
   return true;
 }
 
 PixelAspectRatioBox::PixelAspectRatioBox() : h_spacing(1), v_spacing(1) {}
 PixelAspectRatioBox::~PixelAspectRatioBox() {}
 FourCC PixelAspectRatioBox::BoxType() const { return FOURCC_PASP; }
@@ skipping 103 matching lines @@
 ElementaryStreamDescriptor::ElementaryStreamDescriptor()
     : object_type(kForbidden) {}
 
 ElementaryStreamDescriptor::~ElementaryStreamDescriptor() {}
 
 FourCC ElementaryStreamDescriptor::BoxType() const {
   return FOURCC_ESDS;
 }
 
 bool ElementaryStreamDescriptor::Parse(BoxReader* reader) {
-  std::vector<uint8> data;
+  std::vector<uint8_t> data;
   ESDescriptor es_desc;
 
   RCHECK(reader->ReadFullBoxHeader());
   RCHECK(reader->ReadVec(&data, reader->size() - reader->pos()));
   RCHECK(es_desc.Parse(data));
 
   object_type = es_desc.object_type();
 
   if (object_type != 0x40) {
     MEDIA_LOG(INFO, reader->media_log()) << "Audio codec: mp4a." << std::hex
@@ skipping 246 matching lines @@
 }
 
 TrackFragmentRun::TrackFragmentRun()
     : sample_count(0), data_offset(0) {}
 TrackFragmentRun::~TrackFragmentRun() {}
 FourCC TrackFragmentRun::BoxType() const { return FOURCC_TRUN; }
 
 bool TrackFragmentRun::Parse(BoxReader* reader) {
   RCHECK(reader->ReadFullBoxHeader() &&
          reader->Read4(&sample_count));
-  const uint32 flags = reader->flags();
+  const uint32_t flags = reader->flags();
 
   bool data_offset_present = (flags & 0x1) != 0;
   bool first_sample_flags_present = (flags & 0x4) != 0;
   bool sample_duration_present = (flags & 0x100) != 0;
   bool sample_size_present = (flags & 0x200) != 0;
   bool sample_flags_present = (flags & 0x400) != 0;
   bool sample_composition_time_offsets_present = (flags & 0x800) != 0;
 
   if (data_offset_present) {
     RCHECK(reader->Read4(&data_offset));
   } else {
     data_offset = 0;
   }
 
-  uint32 first_sample_flags = 0;
+  uint32_t first_sample_flags = 0;
   if (first_sample_flags_present)
     RCHECK(reader->Read4(&first_sample_flags));
 
   int fields = sample_duration_present + sample_size_present +
       sample_flags_present + sample_composition_time_offsets_present;
   RCHECK(reader->HasBytes(fields * sample_count));
 
   if (sample_duration_present)
     sample_durations.resize(sample_count);
   if (sample_size_present)
     sample_sizes.resize(sample_count);
   if (sample_flags_present)
     sample_flags.resize(sample_count);
   if (sample_composition_time_offsets_present)
     sample_composition_time_offsets.resize(sample_count);
 
-  for (uint32 i = 0; i < sample_count; ++i) {
+  for (uint32_t i = 0; i < sample_count; ++i) {
     if (sample_duration_present)
       RCHECK(reader->Read4(&sample_durations[i]));
     if (sample_size_present)
       RCHECK(reader->Read4(&sample_sizes[i]));
     if (sample_flags_present)
       RCHECK(reader->Read4(&sample_flags[i]));
     if (sample_composition_time_offsets_present)
       RCHECK(reader->Read4s(&sample_composition_time_offsets[i]));
   }
 
@@ skipping 17 matching lines @@
 
   if (reader->version() == 1)
     RCHECK(reader->Read4(&grouping_type_parameter));
 
   if (grouping_type != FOURCC_SEIG) {
     DLOG(WARNING) << "SampleToGroup box with grouping_type '" << grouping_type
                   << "' is not supported.";
     return true;
   }
 
-  uint32 count;
+  uint32_t count;
   RCHECK(reader->Read4(&count));
   entries.resize(count);
-  for (uint32 i = 0; i < count; ++i) {
+  for (uint32_t i = 0; i < count; ++i) {
     RCHECK(reader->Read4(&entries[i].sample_count) &&
            reader->Read4(&entries[i].group_description_index));
   }
   return true;
 }
 
 CencSampleEncryptionInfoEntry::CencSampleEncryptionInfoEntry()
     : is_encrypted(false), iv_size(0) {}
 CencSampleEncryptionInfoEntry::~CencSampleEncryptionInfoEntry() {}
 
 SampleGroupDescription::SampleGroupDescription() : grouping_type(0) {}
 SampleGroupDescription::~SampleGroupDescription() {}
 FourCC SampleGroupDescription::BoxType() const { return FOURCC_SGPD; }
 
 bool SampleGroupDescription::Parse(BoxReader* reader) {
   RCHECK(reader->ReadFullBoxHeader() &&
          reader->Read4(&grouping_type));
 
   if (grouping_type != FOURCC_SEIG) {
     DLOG(WARNING) << "SampleGroupDescription box with grouping_type '"
                   << grouping_type << "' is not supported.";
     return true;
   }
 
-  const uint8 version = reader->version();
+  const uint8_t version = reader->version();
 
   const size_t kKeyIdSize = 16;
-  const size_t kEntrySize = sizeof(uint32) + kKeyIdSize;
-  uint32 default_length = 0;
+  const size_t kEntrySize = sizeof(uint32_t) + kKeyIdSize;
+  uint32_t default_length = 0;
   if (version == 1) {
       RCHECK(reader->Read4(&default_length));
       RCHECK(default_length == 0 || default_length >= kEntrySize);
   }
 
-  uint32 count;
+  uint32_t count;
   RCHECK(reader->Read4(&count));
   entries.resize(count);
-  for (uint32 i = 0; i < count; ++i) {
+  for (uint32_t i = 0; i < count; ++i) {
     if (version == 1) {
       if (default_length == 0) {
-        uint32 description_length = 0;
+        uint32_t description_length = 0;
         RCHECK(reader->Read4(&description_length));
         RCHECK(description_length >= kEntrySize);
       }
     }
 
-    uint8 flag;
+    uint8_t flag;
     RCHECK(reader->SkipBytes(2) &&  // reserved.
            reader->Read1(&flag) &&
            reader->Read1(&entries[i].iv_size) &&
            reader->ReadVec(&entries[i].key_id, kKeyIdSize));
 
     entries[i].is_encrypted = (flag != 0);
     if (entries[i].is_encrypted) {
       RCHECK(entries[i].iv_size == 8 || entries[i].iv_size == 16);
     } else {
       RCHECK(entries[i].iv_size == 0);
@@ skipping 52 matching lines @@
 FourCC IndependentAndDisposableSamples::BoxType() const { return FOURCC_SDTP; }
 
 bool IndependentAndDisposableSamples::Parse(BoxReader* reader) {
   RCHECK(reader->ReadFullBoxHeader());
   RCHECK(reader->version() == 0);
   RCHECK(reader->flags() == 0);
 
   int sample_count = reader->size() - reader->pos();
   sample_depends_on_.resize(sample_count);
   for (int i = 0; i < sample_count; ++i) {
-    uint8 sample_info;
+    uint8_t sample_info;
     RCHECK(reader->Read1(&sample_info));
 
     sample_depends_on_[i] =
         static_cast<SampleDependsOn>((sample_info >> 4) & 0x3);
 
     RCHECK(sample_depends_on_[i] != kSampleDependsOnReserved);
   }
 
   return true;
 }
 
 SampleDependsOn IndependentAndDisposableSamples::sample_depends_on(
     size_t i) const {
   if (i >= sample_depends_on_.size())
     return kSampleDependsOnUnknown;
 
   return sample_depends_on_[i];
 }
 
 }  // namespace mp4
 }  // namespace media