Remove kuint64max.

media/formats/mp4/mp4_stream_parser.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/mp4_stream_parser.h"
 
+#include <limits>
 #include <vector>
 
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/time/time.h"
 #include "media/base/audio_decoder_config.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"
@@ skipping 59 matching lines @@
   moof_head_ = 0;
   mdat_tail_ = 0;
 }
 
 void MP4StreamParser::Flush() {
   DCHECK_NE(state_, kWaitingForInit);
   Reset();
   ChangeState(kParsingBoxes);
 }
 
-bool MP4StreamParser::Parse(const uint8* buf, int size) {
+bool MP4StreamParser::Parse(const uint8_t* buf, int size) {
   DCHECK_NE(state_, kWaitingForInit);
 
   if (state_ == kError)
     return false;
 
   queue_.Push(buf, size);
 
   BufferQueue audio_buffers;
   BufferQueue video_buffers;
 
@@ skipping 13 matching lines @@
 
       case kWaitingForSampleData:
         result = HaveEnoughDataToEnqueueSamples();
         if (result)
           ChangeState(kEmittingSamples);
         break;
 
       case kEmittingSamples:
         result = EnqueueSample(&audio_buffers, &video_buffers, &err);
         if (result) {
-          int64 max_clear = runs_->GetMaxClearOffset() + moof_head_;
+          int64_t max_clear = runs_->GetMaxClearOffset() + moof_head_;
           err = !ReadAndDiscardMDATsUntil(max_clear);
         }
         break;
     }
   } while (result && !err);
 
   if (!err)
     err = !SendAndFlushSamples(&audio_buffers, &video_buffers);
 
   if (err) {
     DLOG(ERROR) << "Error while parsing MP4";
     moov_.reset();
     Reset();
     ChangeState(kError);
     return false;
   }
 
   return true;
 }
 
 bool MP4StreamParser::ParseBox(bool* err) {
-  const uint8* buf;
+  const uint8_t* buf;
   int size;
   queue_.Peek(&buf, &size);
   if (!size) return false;
 
   scoped_ptr<BoxReader> reader(
       BoxReader::ReadTopLevelBox(buf, size, media_log_, err));
   if (reader.get() == NULL) return false;
 
   if (reader->type() == FOURCC_MOOV) {
     *err = !ParseMoov(reader.get());
@@ skipping 65 matching lines @@
 
       if (!(entry.format == FOURCC_MP4A ||
             (entry.format == FOURCC_ENCA &&
              entry.sinf.format.format == FOURCC_MP4A))) {
         MEDIA_LOG(ERROR, media_log_) << "Unsupported audio format 0x"
                                      << std::hex << entry.format
                                      << " in stsd box.";
         return false;
       }
 
-      uint8 audio_type = entry.esds.object_type;
+      uint8_t audio_type = entry.esds.object_type;
       DVLOG(1) << "audio_type " << std::hex << static_cast<int>(audio_type);
       if (audio_object_types_.find(audio_type) == audio_object_types_.end()) {
         MEDIA_LOG(ERROR, media_log_)
             << "audio object type 0x" << std::hex << audio_type
             << " does not match what is specified in the"
             << " mimetype.";
         return false;
       }
 
       AudioCodec codec = kUnknownAudioCodec;
       ChannelLayout channel_layout = CHANNEL_LAYOUT_NONE;
       int sample_per_second = 0;
-      std::vector<uint8> extra_data;
+      std::vector<uint8_t> extra_data;
       // Check if it is MPEG4 AAC defined in ISO 14496 Part 3 or
       // supported MPEG2 AAC varients.
       if (ESDescriptor::IsAAC(audio_type)) {
         codec = kCodecAAC;
         channel_layout = aac.GetChannelLayout(has_sbr_);
         sample_per_second = aac.GetOutputSamplesPerSecond(has_sbr_);
 #if defined(OS_ANDROID)
         extra_data = aac.codec_specific_data();
 #endif
       } else {
@@ skipping 66 matching lines @@
   }
 
   RCHECK(config_cb_.Run(audio_config, video_config, TextTrackConfigMap()));
 
   StreamParser::InitParameters params(kInfiniteDuration());
   if (moov_->extends.header.fragment_duration > 0) {
     params.duration = TimeDeltaFromRational(
         moov_->extends.header.fragment_duration, moov_->header.timescale);
     params.liveness = DemuxerStream::LIVENESS_RECORDED;
   } else if (moov_->header.duration > 0 &&
-             moov_->header.duration != kuint64max) {
+             moov_->header.duration != std::numeric_limits<uint64_t>::max()) {
     params.duration =
         TimeDeltaFromRational(moov_->header.duration, moov_->header.timescale);
     params.liveness = DemuxerStream::LIVENESS_RECORDED;
   } else {
     // In ISO/IEC 14496-12:2005(E), 8.30.2: ".. If an MP4 file is created in
     // real-time, such as used in live streaming, it is not likely that the
     // fragment_duration is known in advance and this (mehd) box may be
     // omitted."
     // TODO(wolenetz): Investigate gating liveness detection on timeline_offset
     // when it's populated. See http://crbug.com/312699
@@ skipping 30 matching lines @@
 
 void MP4StreamParser::OnEncryptedMediaInitData(
     const std::vector<ProtectionSystemSpecificHeader>& headers) {
   // TODO(strobe): ensure that the value of init_data (all PSSH headers
   // concatenated in arbitrary order) matches the EME spec.
   // See https://www.w3.org/Bugs/Public/show_bug.cgi?id=17673.
   size_t total_size = 0;
   for (size_t i = 0; i < headers.size(); i++)
     total_size += headers[i].raw_box.size();
 
-  std::vector<uint8> init_data(total_size);
+  std::vector<uint8_t> init_data(total_size);
   size_t pos = 0;
   for (size_t i = 0; i < headers.size(); i++) {
     memcpy(&init_data[pos], &headers[i].raw_box[0],
            headers[i].raw_box.size());
     pos += headers[i].raw_box.size();
   }
   encrypted_media_init_data_cb_.Run(EmeInitDataType::CENC, init_data);
 }
 
 bool MP4StreamParser::PrepareAACBuffer(
-    const AAC& aac_config, std::vector<uint8>* frame_buf,
+    const AAC& aac_config,
+    std::vector<uint8_t>* frame_buf,
     std::vector<SubsampleEntry>* subsamples) const {
   // Append an ADTS header to every audio sample.
   RCHECK(aac_config.ConvertEsdsToADTS(frame_buf));
 
   // As above, adjust subsample information to account for the headers. AAC is
   // not required to use subsample encryption, so we may need to add an entry.
   if (subsamples->empty()) {
     subsamples->push_back(SubsampleEntry(
         kADTSHeaderMinSize, frame_buf->size() - kADTSHeaderMinSize));
   } else {
@@ skipping 24 matching lines @@
     return true;
   }
 
   if (!runs_->IsSampleValid()) {
     runs_->AdvanceRun();
     return true;
   }
 
   DCHECK(!(*err));
 
-  const uint8* buf;
+  const uint8_t* buf;
   int buf_size;
   queue_.Peek(&buf, &buf_size);
   if (!buf_size) return false;
 
   bool audio = has_audio_ && audio_track_id_ == runs_->track_id();
   bool video = has_video_ && video_track_id_ == runs_->track_id();
 
   // Skip this entire track if it's not one we're interested in
   if (!audio && !video) {
     runs_->AdvanceRun();
@@ skipping 21 matching lines @@
   std::vector<SubsampleEntry> subsamples;
   if (runs_->is_encrypted()) {
     decrypt_config = runs_->GetDecryptConfig();
     if (!decrypt_config) {
       *err = true;
       return false;
     }
     subsamples = decrypt_config->subsamples();
   }
 
-  std::vector<uint8> frame_buf(buf, buf + runs_->sample_size());
+  std::vector<uint8_t> frame_buf(buf, buf + runs_->sample_size());
   if (video) {
     DCHECK(runs_->video_description().frame_bitstream_converter);
     if (!runs_->video_description().frame_bitstream_converter->ConvertFrame(
         &frame_buf, runs_->is_keyframe(), &subsamples)) {
       MEDIA_LOG(ERROR, media_log_)
           << "Failed to prepare video sample for decode";
       *err = true;
       return false;
     }
   }
@@ skipping 67 matching lines @@
 
   TextBufferQueueMap empty_text_map;
   bool success = new_buffers_cb_.Run(*audio_buffers,
                                      *video_buffers,
                                      empty_text_map);
   audio_buffers->clear();
   video_buffers->clear();
   return success;
 }
 
-bool MP4StreamParser::ReadAndDiscardMDATsUntil(int64 max_clear_offset) {
+bool MP4StreamParser::ReadAndDiscardMDATsUntil(int64_t max_clear_offset) {
   bool err = false;
-  int64 upper_bound = std::min(max_clear_offset, queue_.tail());
+  int64_t upper_bound = std::min(max_clear_offset, queue_.tail());
   while (mdat_tail_ < upper_bound) {
-    const uint8* buf = NULL;
+    const uint8_t* buf = NULL;
     int size = 0;
     queue_.PeekAt(mdat_tail_, &buf, &size);
 
     FourCC type;
     int box_sz;
     if (!BoxReader::StartTopLevelBox(buf, size, media_log_, &type, &box_sz,
                                      &err))
       break;
 
     if (type != FOURCC_MDAT) {
@@ skipping 23 matching lines @@
            queue_.tail() < highest_end_offset_ + moof_head_);
 }
 
 bool MP4StreamParser::ComputeHighestEndOffset(const MovieFragment& moof) {
   highest_end_offset_ = 0;
 
   TrackRunIterator runs(moov_.get(), media_log_);
   RCHECK(runs.Init(moof));
 
   while (runs.IsRunValid()) {
-    int64 aux_info_end_offset = runs.aux_info_offset() + runs.aux_info_size();
+    int64_t aux_info_end_offset = runs.aux_info_offset() + runs.aux_info_size();
     if (aux_info_end_offset > highest_end_offset_)
       highest_end_offset_ = aux_info_end_offset;
 
     while (runs.IsSampleValid()) {
-      int64 sample_end_offset = runs.sample_offset() + runs.sample_size();
+      int64_t sample_end_offset = runs.sample_offset() + runs.sample_size();
       if (sample_end_offset > highest_end_offset_)
         highest_end_offset_ = sample_end_offset;
 
       runs.AdvanceSample();
     }
     runs.AdvanceRun();
   }
 
   return true;
 }
 
 }  // namespace mp4
 }  // namespace media