Switch to standard integer types in media/.

media/formats/mp2t/es_parser_h264.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/es_parser_h264.h"
 
 #include "base/logging.h"
 #include "base/numerics/safe_conversions.h"
 #include "media/base/stream_parser_buffer.h"
 #include "media/base/timestamp_constants.h"
@@ skipping 23 matching lines @@
 EsParserH264::~EsParserH264() {
 }
 
 void EsParserH264::Flush() {
   DVLOG(1) << __FUNCTION__;
   if (!FindAUD(&current_access_unit_pos_))
     return;
 
   // Simulate an additional AUD to force emitting the last access unit
   // which is assumed to be complete at this point.
-  uint8 aud[] = { 0x00, 0x00, 0x01, 0x09 };
+  uint8_t aud[] = {0x00, 0x00, 0x01, 0x09};
   es_queue_->Push(aud, sizeof(aud));
   ParseFromEsQueue();
 
   es_adapter_.Flush();
 }
 
 void EsParserH264::ResetInternal() {
   DVLOG(1) << __FUNCTION__;
   h264_parser_.reset(new H264Parser());
   current_access_unit_pos_ = 0;
   next_access_unit_pos_ = 0;
   last_video_decoder_config_ = VideoDecoderConfig();
   es_adapter_.Reset();
 }
 
-bool EsParserH264::FindAUD(int64* stream_pos) {
+bool EsParserH264::FindAUD(int64_t* stream_pos) {
   while (true) {
-    const uint8* es;
+    const uint8_t* es;
     int size;
     es_queue_->PeekAt(*stream_pos, &es, &size);
 
     // Find a start code and move the stream to the start code parser position.
     off_t start_code_offset;
     off_t start_code_size;
     bool start_code_found = H264Parser::FindStartCode(
         es, size, &start_code_offset, &start_code_size);
     *stream_pos += start_code_offset;
 
@@ skipping 40 matching lines @@
     next_access_unit_pos_ = current_access_unit_pos_ + kMinAUDSize;
     DCHECK_LE(next_access_unit_pos_, es_queue_->tail());
   }
   if (!FindAUD(&next_access_unit_pos_))
     return true;
 
   // At this point, we know we have a full access unit.
   bool is_key_frame = false;
   int pps_id_for_access_unit = -1;
 
-  const uint8* es;
+  const uint8_t* es;
   int size;
   es_queue_->PeekAt(current_access_unit_pos_, &es, &size);
-  int access_unit_size = base::checked_cast<int, int64>(
+  int access_unit_size = base::checked_cast<int, int64_t>(
       next_access_unit_pos_ - current_access_unit_pos_);
   DCHECK_LE(access_unit_size, size);
   h264_parser_->SetStream(es, access_unit_size);
 
   while (true) {
     bool is_eos = false;
     H264NALU nalu;
     switch (h264_parser_->AdvanceToNextNALU(&nalu)) {
       case H264Parser::kOk:
         break;
@@ skipping 51 matching lines @@
 
   // Emit a frame and move the stream to the next AUD position.
   RCHECK(EmitFrame(current_access_unit_pos_, access_unit_size,
                    is_key_frame, pps_id_for_access_unit));
   current_access_unit_pos_ = next_access_unit_pos_;
   es_queue_->Trim(current_access_unit_pos_);
 
   return true;
 }
 
-bool EsParserH264::EmitFrame(int64 access_unit_pos, int access_unit_size,
-                             bool is_key_frame, int pps_id) {
+bool EsParserH264::EmitFrame(int64_t access_unit_pos,
+                             int access_unit_size,
+                             bool is_key_frame,
+                             int pps_id) {
   // Get the access unit timing info.
   // Note: |current_timing_desc.pts| might be |kNoTimestamp()| at this point
   // if:
   // - the stream is not fully MPEG-2 compliant.
   // - or if the stream relies on H264 VUI parameters to compute the timestamps.
   //   See H.222 spec: section 2.7.5 "Conditional coding of timestamps".
   //   This part is not yet implemented in EsParserH264.
   // |es_adapter_| will take care of the missing timestamps.
   TimingDesc current_timing_desc = GetTimingDescriptor(access_unit_pos);
   DVLOG_IF(1, current_timing_desc.pts == kNoTimestamp())
@@ skipping 19 matching lines @@
     const H264SPS* sps = h264_parser_->GetSPS(pps->seq_parameter_set_id);
     if (!sps)
       return false;
     RCHECK(UpdateVideoDecoderConfig(sps));
   }
 
   // Emit a frame.
   DVLOG(LOG_LEVEL_ES) << "Emit frame: stream_pos=" << current_access_unit_pos_
                       << " size=" << access_unit_size;
   int es_size;
-  const uint8* es;
+  const uint8_t* es;
   es_queue_->PeekAt(current_access_unit_pos_, &es, &es_size);
   CHECK_GE(es_size, access_unit_size);
 
   // TODO(wolenetz/acolwell): Validate and use a common cross-parser TrackId
   // type and allow multiple video tracks. See https://crbug.com/341581.
   scoped_refptr<StreamParserBuffer> stream_parser_buffer =
       StreamParserBuffer::CopyFrom(
           es,
           access_unit_size,
           is_key_frame,
@@ skipping 44 matching lines @@
              << " height=" << sps->sar_height;
     last_video_decoder_config_ = video_decoder_config;
     es_adapter_.OnConfigChanged(video_decoder_config);
   }
 
   return true;
 }
 
 }  // namespace mp2t
 }  // namespace media