Switch to standard integer types in media/.

media/formats/mpeg/mpeg_audio_stream_parser_base.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/mpeg/mpeg_audio_stream_parser_base.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/message_loop/message_loop.h"
 #include "media/base/stream_parser_buffer.h"
 #include "media/base/text_track_config.h"
 #include "media/base/timestamp_constants.h"
 #include "media/base/video_decoder_config.h"
 
 namespace media {
 
-static const uint32 kICYStartCode = 0x49435920; // 'ICY '
+static const uint32_t kICYStartCode = 0x49435920;  // 'ICY '
 
 // Arbitrary upper bound on the size of an IceCast header before it
 // triggers an error.
 static const int kMaxIcecastHeaderSize = 4096;
 
-static const uint32 kID3StartCodeMask = 0xffffff00;
-static const uint32 kID3v1StartCode = 0x54414700; // 'TAG\0'
+static const uint32_t kID3StartCodeMask = 0xffffff00;
+static const uint32_t kID3v1StartCode = 0x54414700;  // 'TAG\0'
 static const int kID3v1Size = 128;
 static const int kID3v1ExtendedSize = 227;
-static const uint32 kID3v2StartCode = 0x49443300; // 'ID3\0'
+static const uint32_t kID3v2StartCode = 0x49443300;  // 'ID3\0'
 
 static int LocateEndOfHeaders(const uint8_t* buf, int buf_len, int i) {
   bool was_lf = false;
   char last_c = '\0';
   for (; i < buf_len; ++i) {
     char c = buf[i];
     if (c == '\n') {
       if (was_lf)
         return i + 1;
       was_lf = true;
     } else if (c != '\r' || last_c != '\n') {
       was_lf = false;
     }
     last_c = c;
   }
   return -1;
 }
 
-MPEGAudioStreamParserBase::MPEGAudioStreamParserBase(uint32 start_code_mask,
+MPEGAudioStreamParserBase::MPEGAudioStreamParserBase(uint32_t start_code_mask,
                                                      AudioCodec audio_codec,
                                                      int codec_delay)
     : state_(UNINITIALIZED),
       in_media_segment_(false),
       start_code_mask_(start_code_mask),
       audio_codec_(audio_codec),
       codec_delay_(codec_delay) {}
 
 MPEGAudioStreamParserBase::~MPEGAudioStreamParserBase() {}
 
@@ skipping 20 matching lines @@
 
 void MPEGAudioStreamParserBase::Flush() {
   DVLOG(1) << __FUNCTION__;
   DCHECK_NE(state_, UNINITIALIZED);
   queue_.Reset();
   if (timestamp_helper_)
     timestamp_helper_->SetBaseTimestamp(base::TimeDelta());
   in_media_segment_ = false;
 }
 
-bool MPEGAudioStreamParserBase::Parse(const uint8* buf, int size) {
+bool MPEGAudioStreamParserBase::Parse(const uint8_t* buf, int size) {
   DVLOG(1) << __FUNCTION__ << "(" << size << ")";
   DCHECK(buf);
   DCHECK_GT(size, 0);
   DCHECK_NE(state_, UNINITIALIZED);
 
   if (state_ == PARSE_ERROR)
     return false;
 
   DCHECK_EQ(state_, INITIALIZED);
 
   queue_.Push(buf, size);
 
   bool end_of_segment = true;
   BufferQueue buffers;
   for (;;) {
-    const uint8* data;
+    const uint8_t* data;
     int data_size;
     queue_.Peek(&data, &data_size);
 
     if (data_size < 4)
       break;
 
-    uint32 start_code = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
+    uint32_t start_code =
+        data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
     int bytes_read = 0;
     bool parsed_metadata = true;
     if ((start_code & start_code_mask_) == start_code_mask_) {
       bytes_read = ParseFrame(data, data_size, &buffers);
 
       // Only allow the current segment to end if a full frame has been parsed.
       end_of_segment = bytes_read > 0;
       parsed_metadata = false;
     } else if (start_code == kICYStartCode) {
       bytes_read = ParseIcecastHeader(data, data_size);
@@ skipping 33 matching lines @@
 
   // Send buffers collected in this append that haven't been sent yet.
   return SendBuffers(&buffers, end_of_segment);
 }
 
 void MPEGAudioStreamParserBase::ChangeState(State state) {
   DVLOG(1) << __FUNCTION__ << "() : " << state_ << " -> " << state;
   state_ = state;
 }
 
-int MPEGAudioStreamParserBase::ParseFrame(const uint8* data,
+int MPEGAudioStreamParserBase::ParseFrame(const uint8_t* data,
                                           int size,
                                           BufferQueue* buffers) {
   DVLOG(2) << __FUNCTION__ << "(" << size << ")";
 
   int sample_rate;
   ChannelLayout channel_layout;
   int frame_size;
   int sample_count;
   bool metadata_frame = false;
   int bytes_read = ParseFrameHeader(data,
@@ skipping 66 matching lines @@
                                    DemuxerStream::AUDIO, 0);
   buffer->set_timestamp(timestamp_helper_->GetTimestamp());
   buffer->set_duration(timestamp_helper_->GetFrameDuration(sample_count));
   buffers->push_back(buffer);
 
   timestamp_helper_->AddFrames(sample_count);
 
   return frame_size;
 }
 
-int MPEGAudioStreamParserBase::ParseIcecastHeader(const uint8* data, int size) {
+int MPEGAudioStreamParserBase::ParseIcecastHeader(const uint8_t* data,
+                                                  int size) {
   DVLOG(1) << __FUNCTION__ << "(" << size << ")";
 
   if (size < 4)
     return 0;
 
   if (memcmp("ICY ", data, 4))
     return -1;
 
   int locate_size = std::min(size, kMaxIcecastHeaderSize);
   int offset = LocateEndOfHeaders(data, locate_size, 4);
   if (offset < 0) {
     if (locate_size == kMaxIcecastHeaderSize) {
       MEDIA_LOG(ERROR, media_log_) << "Icecast header is too large.";
       return -1;
     }
 
     return 0;
   }
 
   return offset;
 }
 
-int MPEGAudioStreamParserBase::ParseID3v1(const uint8* data, int size) {
+int MPEGAudioStreamParserBase::ParseID3v1(const uint8_t* data, int size) {
   DVLOG(1) << __FUNCTION__ << "(" << size << ")";
 
   if (size < kID3v1Size)
     return 0;
 
   // TODO(acolwell): Add code to actually validate ID3v1 data and
   // expose it as a metadata text track.
   return !memcmp(data, "TAG+", 4) ? kID3v1ExtendedSize : kID3v1Size;
 }
 
-int MPEGAudioStreamParserBase::ParseID3v2(const uint8* data, int size) {
+int MPEGAudioStreamParserBase::ParseID3v2(const uint8_t* data, int size) {
   DVLOG(1) << __FUNCTION__ << "(" << size << ")";
 
   if (size < 10)
     return 0;
 
   BitReader reader(data, size);
-  int32 id;
+  int32_t id;
   int version;
-  uint8 flags;
-  int32 id3_size;
+  uint8_t flags;
+  int32_t id3_size;
 
   if (!reader.ReadBits(24, &id) ||
       !reader.ReadBits(16, &version) ||
       !reader.ReadBits(8, &flags) ||
       !ParseSyncSafeInt(&reader, &id3_size)) {
     return -1;
   }
 
-  int32 actual_tag_size = 10 + id3_size;
+  int32_t actual_tag_size = 10 + id3_size;
 
   // Increment size if 'Footer present' flag is set.
   if (flags & 0x10)
     actual_tag_size += 10;
 
   // Make sure we have the entire tag.
   if (size < actual_tag_size)
     return 0;
 
   // TODO(acolwell): Add code to actually validate ID3v2 data and
   // expose it as a metadata text track.
   return actual_tag_size;
 }
 
 bool MPEGAudioStreamParserBase::ParseSyncSafeInt(BitReader* reader,
-                                                 int32* value) {
+                                                 int32_t* value) {
   *value = 0;
   for (int i = 0; i < 4; ++i) {
-    uint8 tmp;
+    uint8_t tmp;
     if (!reader->ReadBits(1, &tmp) || tmp != 0) {
       MEDIA_LOG(ERROR, media_log_) << "ID3 syncsafe integer byte MSb is not 0!";
       return false;
     }
 
     if (!reader->ReadBits(7, &tmp))
       return false;
 
     *value <<= 7;
     *value += tmp;
   }
 
   return true;
 }
 
-int MPEGAudioStreamParserBase::FindNextValidStartCode(const uint8* data,
+int MPEGAudioStreamParserBase::FindNextValidStartCode(const uint8_t* data,
                                                       int size) const {
-  const uint8* start = data;
-  const uint8* end = data + size;
+  const uint8_t* start = data;
+  const uint8_t* end = data + size;
 
   while (start < end) {
     int bytes_left = end - start;
-    const uint8* candidate_start_code =
-        static_cast<const uint8*>(memchr(start, 0xff, bytes_left));
+    const uint8_t* candidate_start_code =
+        static_cast<const uint8_t*>(memchr(start, 0xff, bytes_left));
 
     if (!candidate_start_code)
       return 0;
 
     bool parse_header_failed = false;
-    const uint8* sync = candidate_start_code;
+    const uint8_t* sync = candidate_start_code;
     // Try to find 3 valid frames in a row. 3 was selected to decrease
     // the probability of false positives.
     for (int i = 0; i < 3; ++i) {
       int sync_size = end - sync;
       int frame_size;
       int sync_bytes = ParseFrameHeader(
           sync, sync_size, &frame_size, NULL, NULL, NULL, NULL);
 
       if (sync_bytes == 0)
         return 0;
@@ skipping 46 matching lines @@
   if (end_of_segment) {
     in_media_segment_ = false;
     end_of_segment_cb_.Run();
   }
 
   timestamp_helper_->SetBaseTimestamp(base::TimeDelta());
   return true;
 }
 
 }  // namespace media