Switch to standard integer types in media/.

media/filters/h264_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 "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 
 #include "media/base/decrypt_config.h"
 #include "media/filters/h264_parser.h"
@@ skipping 115 matching lines @@
   STLDeleteValues(&active_SPSes_);
   STLDeleteValues(&active_PPSes_);
 }
 
 void H264Parser::Reset() {
   stream_ = NULL;
   bytes_left_ = 0;
   encrypted_ranges_.clear();
 }
 
-void H264Parser::SetStream(const uint8* stream, off_t stream_size) {
+void H264Parser::SetStream(const uint8_t* stream, off_t stream_size) {
   std::vector<SubsampleEntry> subsamples;
   SetEncryptedStream(stream, stream_size, subsamples);
 }
 
 void H264Parser::SetEncryptedStream(
-    const uint8* stream, off_t stream_size,
+    const uint8_t* stream,
+    off_t stream_size,
     const std::vector<SubsampleEntry>& subsamples) {
   DCHECK(stream);
   DCHECK_GT(stream_size, 0);
 
   stream_ = stream;
   bytes_left_ = stream_size;
 
   encrypted_ranges_.clear();
-  const uint8* start = stream;
-  const uint8* stream_end = stream_ + bytes_left_;
+  const uint8_t* start = stream;
+  const uint8_t* stream_end = stream_ + bytes_left_;
   for (size_t i = 0; i < subsamples.size() && start < stream_end; ++i) {
     start += subsamples[i].clear_bytes;
 
-    const uint8* end = std::min(start + subsamples[i].cypher_bytes, stream_end);
+    const uint8_t* end =
+        std::min(start + subsamples[i].cypher_bytes, stream_end);
     encrypted_ranges_.Add(start, end);
     start = end;
   }
 }
 
 const H264PPS* H264Parser::GetPPS(int pps_id) const {
   auto it = active_PPSes_.find(pps_id);
   if (it == active_PPSes_.end()) {
     DVLOG(1) << "Requested a nonexistent PPS id " << pps_id;
     return nullptr;
   }
 
   return it->second;
 }
 
 const H264SPS* H264Parser::GetSPS(int sps_id) const {
   auto it = active_SPSes_.find(sps_id);
   if (it == active_SPSes_.end()) {
     DVLOG(1) << "Requested a nonexistent SPS id " << sps_id;
     return nullptr;
   }
 
   return it->second;
 }
 
-static inline bool IsStartCode(const uint8* data) {
+static inline bool IsStartCode(const uint8_t* data) {
   return data[0] == 0x00 && data[1] == 0x00 && data[2] == 0x01;
 }
 
 // static
-bool H264Parser::FindStartCode(const uint8* data, off_t data_size,
-                               off_t* offset, off_t* start_code_size) {
+bool H264Parser::FindStartCode(const uint8_t* data,
+                               off_t data_size,
+                               off_t* offset,
+                               off_t* start_code_size) {
   DCHECK_GE(data_size, 0);
   off_t bytes_left = data_size;
 
   while (bytes_left >= 3) {
     if (IsStartCode(data)) {
       // Found three-byte start code, set pointer at its beginning.
       *offset = data_size - bytes_left;
       *start_code_size = 3;
 
       // If there is a zero byte before this start code,
@@ skipping 29 matching lines @@
                                   encrypted_ranges_,
                                   &nalu_start_off, &annexb_start_code_size)) {
     DVLOG(4) << "Could not find start code, end of stream?";
     return false;
   }
 
   // Move the stream to the beginning of the NALU (pointing at the start code).
   stream_ += nalu_start_off;
   bytes_left_ -= nalu_start_off;
 
-  const uint8* nalu_data = stream_ + annexb_start_code_size;
+  const uint8_t* nalu_data = stream_ + annexb_start_code_size;
   off_t max_nalu_data_size = bytes_left_ - annexb_start_code_size;
   if (max_nalu_data_size <= 0) {
     DVLOG(3) << "End of stream";
     return false;
   }
 
   // Find the start code of next NALU;
   // if successful, |nalu_size_without_start_code| is the number of bytes from
   // after previous start code to before this one;
   // if next start code is not found, it is still a valid NALU since there
   // are some bytes left after the first start code: all the remaining bytes
   // belong to the current NALU.
   off_t next_start_code_size = 0;
   off_t nalu_size_without_start_code = 0;
   if (!FindStartCodeInClearRanges(nalu_data, max_nalu_data_size,
                                   encrypted_ranges_,
                                   &nalu_size_without_start_code,
                                   &next_start_code_size)) {
     nalu_size_without_start_code = max_nalu_data_size;
   }
   *nalu_size = nalu_size_without_start_code + annexb_start_code_size;
   *start_code_size = annexb_start_code_size;
   return true;
 }
 
 bool H264Parser::FindStartCodeInClearRanges(
-    const uint8* data,
+    const uint8_t* data,
     off_t data_size,
-    const Ranges<const uint8*>& encrypted_ranges,
+    const Ranges<const uint8_t*>& encrypted_ranges,
     off_t* offset,
     off_t* start_code_size) {
   if (encrypted_ranges.size() == 0)
     return FindStartCode(data, data_size, offset, start_code_size);
 
   DCHECK_GE(data_size, 0);
-  const uint8* start = data;
+  const uint8_t* start = data;
   do {
     off_t bytes_left = data_size - (start - data);
 
     if (!FindStartCode(start, bytes_left, offset, start_code_size))
       return false;
 
     // Construct a Ranges object that represents the region occupied
     // by the start code and the 1 byte needed to read the NAL unit type.
-    const uint8* start_code = start + *offset;
-    const uint8* start_code_end = start_code + *start_code_size;
-    Ranges<const uint8*> start_code_range;
+    const uint8_t* start_code = start + *offset;
+    const uint8_t* start_code_end = start_code + *start_code_size;
+    Ranges<const uint8_t*> start_code_range;
     start_code_range.Add(start_code, start_code_end + 1);
 
     if (encrypted_ranges.IntersectionWith(start_code_range).size() > 0) {
       // The start code is inside an encrypted section so we need to scan
       // for another start code.
       *start_code_size = 0;
       start += std::min(*offset + 1, bytes_left);
     }
   } while (*start_code_size == 0);
 
@@ skipping 1037 matching lines @@
 
     default:
       DVLOG(4) << "Unsupported SEI message";
       break;
   }
 
   return kOk;
 }
 
 }  // namespace media