Switch to standard integer types in media/.

media/filters/h264_parser.h

 // 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.
 //
 // This file contains an implementation of an H264 Annex-B video stream parser.
 
 #ifndef MEDIA_FILTERS_H264_PARSER_H_
 #define MEDIA_FILTERS_H264_PARSER_H_
 
 #include <sys/types.h>
 
 #include <map>
 #include <vector>
 
-#include "base/basictypes.h"
 #include "media/base/media_export.h"
 #include "media/base/ranges.h"
 #include "media/filters/h264_bit_reader.h"
 
 namespace media {
 
 struct SubsampleEntry;
 
 // For explanations of each struct and its members, see H.264 specification
 // at http://www.itu.int/rec/T-REC-H.264.
@@ skipping 19 matching lines @@
     kReserved15 = 15,
     kReserved16 = 16,
     kReserved17 = 17,
     kReserved18 = 18,
     kCodedSliceAux = 19,
     kCodedSliceExtension = 20,
   };
 
   // After (without) start code; we don't own the underlying memory
   // and a shallow copy should be made when copying this struct.
-  const uint8* data;
+  const uint8_t* data;
   off_t size;  // From after start code to start code of next NALU (or EOS).
 
   int nal_ref_idc;
   int nal_unit_type;
 };
 
 enum {
   kH264ScalingList4x4Length = 16,
   kH264ScalingList8x8Length = 64,
 };
@@ skipping 162 matching lines @@
   };
 
   bool IsPSlice() const;
   bool IsBSlice() const;
   bool IsISlice() const;
   bool IsSPSlice() const;
   bool IsSISlice() const;
 
   bool idr_pic_flag;       // from NAL header
   int nal_ref_idc;         // from NAL header
-  const uint8* nalu_data;  // from NAL header
+  const uint8_t* nalu_data;  // from NAL header
   off_t nalu_size;         // from NAL header
   off_t header_bit_size;   // calculated
 
   int first_mb_in_slice;
   int slice_type;
   int pic_parameter_set_id;
   int colour_plane_id;  // TODO(posciak): use this!  http://crbug.com/139878
   int frame_num;
   bool field_pic_flag;
   bool bottom_field_flag;
@@ skipping 82 matching lines @@
   // and size of found start code (3 or 4 bytes).
   // If no start code is found, offset is pointing to the first unprocessed byte
   // (i.e. the first byte that was not considered as a possible start of a start
   // code) and |*start_code_size| is set to 0.
   // Preconditions:
   // - |data_size| >= 0
   // Postconditions:
   // - |*offset| is between 0 and |data_size| included.
   //   It is strictly less than |data_size| if |data_size| > 0.
   // - |*start_code_size| is either 0, 3 or 4.
-  static bool FindStartCode(const uint8* data, off_t data_size,
-                            off_t* offset, off_t* start_code_size);
+  static bool FindStartCode(const uint8_t* data,
+                            off_t data_size,
+                            off_t* offset,
+                            off_t* start_code_size);
 
   // Wrapper for FindStartCode() that skips over start codes that
   // may appear inside of |encrypted_ranges_|.
   // Returns true if a start code was found. Otherwise returns false.
-  static bool FindStartCodeInClearRanges(const uint8* data, off_t data_size,
-                                         const Ranges<const uint8*>& ranges,
-                                         off_t* offset, off_t* start_code_size);
+  static bool FindStartCodeInClearRanges(const uint8_t* data,
+                                         off_t data_size,
+                                         const Ranges<const uint8_t*>& ranges,
+                                         off_t* offset,
+                                         off_t* start_code_size);
   H264Parser();
   ~H264Parser();
 
   void Reset();
   // Set current stream pointer to |stream| of |stream_size| in bytes,
   // |stream| owned by caller.
   // |subsamples| contains information about what parts of |stream| are
   // encrypted.
-  void SetStream(const uint8* stream, off_t stream_size);
-  void SetEncryptedStream(const uint8* stream, off_t stream_size,
+  void SetStream(const uint8_t* stream, off_t stream_size);
+  void SetEncryptedStream(const uint8_t* stream,
+                          off_t stream_size,
                           const std::vector<SubsampleEntry>& subsamples);
 
   // Read the stream to find the next NALU, identify it and return
   // that information in |*nalu|. This advances the stream to the beginning
   // of this NALU, but not past it, so subsequent calls to NALU-specific
   // parsing functions (ParseSPS, etc.)  will parse this NALU.
   // If the caller wishes to skip the current NALU, it can call this function
   // again, instead of any NALU-type specific parse functions below.
   Result AdvanceToNextNALU(H264NALU* nalu);
 
@@ skipping 71 matching lines @@
   Result ParseWeightingFactors(int num_ref_idx_active_minus1,
                                int chroma_array_type,
                                int luma_log2_weight_denom,
                                int chroma_log2_weight_denom,
                                H264WeightingFactors* w_facts);
 
   // Parse decoded reference picture marking information (see spec).
   Result ParseDecRefPicMarking(H264SliceHeader* shdr);
 
   // Pointer to the current NALU in the stream.
-  const uint8* stream_;
+  const uint8_t* stream_;
 
   // Bytes left in the stream after the current NALU.
   off_t bytes_left_;
 
   H264BitReader br_;
 
   // PPSes and SPSes stored for future reference.
   typedef std::map<int, H264SPS*> SPSById;
   typedef std::map<int, H264PPS*> PPSById;
   SPSById active_SPSes_;
   PPSById active_PPSes_;
 
   // Ranges of encrypted bytes in the buffer passed to
   // SetEncryptedStream().
-  Ranges<const uint8*> encrypted_ranges_;
+  Ranges<const uint8_t*> encrypted_ranges_;
 
   DISALLOW_COPY_AND_ASSIGN(H264Parser);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_FILTERS_H264_PARSER_H_