Remove kint32max.

media/base/android/media_codec_bridge.h

 // Copyright (c) 2013 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.
 
 #ifndef MEDIA_BASE_ANDROID_MEDIA_CODEC_BRIDGE_H_
 #define MEDIA_BASE_ANDROID_MEDIA_CODEC_BRIDGE_H_
 
 #include <jni.h>
+#include <stdint.h>
+
 #include <set>
 #include <string>
 
 #include "base/android/scoped_java_ref.h"
 #include "base/time/time.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/video_decoder_config.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace media {
@@ skipping 91 matching lines @@
 
   // Used for checking for new sampling rate after DequeueInputBuffer() returns
   // INFO_OUTPUT_FORMAT_CHANGED
   int GetOutputSamplingRate();
 
   // Submits a byte array to the given input buffer. Call this after getting an
   // available buffer from DequeueInputBuffer().  If |data| is NULL, assume the
   // input buffer has already been populated (but still obey |size|).
   // |data_size| must be less than kint32max (because Java).
   MediaCodecStatus QueueInputBuffer(int index,
-                                    const uint8* data,
+                                    const uint8_t* data,
                                     size_t data_size,
                                     const base::TimeDelta& presentation_time);
 
   // Similar to the above call, but submits a buffer that is encrypted.  Note:
   // NULL |subsamples| indicates the whole buffer is encrypted.  If |data| is
   // NULL, assume the input buffer has already been populated (but still obey
   // |data_size|).  |data_size| must be less than kint32max (because Java).
   MediaCodecStatus QueueSecureInputBuffer(
       int index,
-      const uint8* data,
+      const uint8_t* data,
       size_t data_size,
       const std::string& key_id,
       const std::string& iv,
       const std::vector<SubsampleEntry>& subsamples,
       const base::TimeDelta& presentation_time);
 
   // Same QueueSecureInputBuffer overriden for the use with MediaSourcePlayer
   // and MediaCodecPlayer.
   // TODO(timav): remove this method and keep only the one above after we
   // switch to the Spitzer pipeline.
   MediaCodecStatus QueueSecureInputBuffer(
       int index,
-      const uint8* data,
+      const uint8_t* data,
       size_t data_size,
-      const uint8* key_id,
+      const uint8_t* key_id,
       int key_id_size,
-      const uint8* iv,
+      const uint8_t* iv,
       int iv_size,
       const SubsampleEntry* subsamples,
       int subsamples_size,
       const base::TimeDelta& presentation_time);
 
   // Submits an empty buffer with a EOS (END OF STREAM) flag.
   void QueueEOS(int input_buffer_index);
 
   // Returns:
   // MEDIA_CODEC_OK if an input buffer is ready to be filled with valid data,
@@ skipping 27 matching lines @@
 
   // Returns the number of output buffers used by the codec.
   // TODO(qinmin): this call is deprecated in Lollipop.
   int GetOutputBuffersCount();
 
   // Returns the capacity of each output buffer used by the codec.
   // TODO(qinmin): this call is deprecated in Lollipop.
   size_t GetOutputBuffersCapacity();
 
   // Returns an input buffer's base pointer and capacity.
-  void GetInputBuffer(int input_buffer_index, uint8** data, size_t* capacity);
+  void GetInputBuffer(int input_buffer_index, uint8_t** data, size_t* capacity);
 
   // Copy |dst_size| bytes from output buffer |index|'s |offset| onwards into
   // |*dst|.
   bool CopyFromOutputBuffer(int index, size_t offset, void* dst, int dst_size);
 
   static bool RegisterMediaCodecBridge(JNIEnv* env);
 
  protected:
   // Returns true if |mime_type| is known to be unaccelerated (i.e. backed by a
   // software codec instead of a hardware one).
@@ skipping 14 matching lines @@
   // the address to read.
   int GetOutputBufferAddress(int index, size_t offset, void** addr);
 
   jobject media_codec() { return j_media_codec_.obj(); }
   MediaCodecDirection direction_;
 
  private:
   // Fills a particular input buffer; returns false if |data_size| exceeds the
   // input buffer's capacity (and doesn't touch the input buffer in that case).
   bool FillInputBuffer(int index,
-                       const uint8* data,
+                       const uint8_t* data,
                        size_t data_size) WARN_UNUSED_RESULT;
 
   // Java MediaCodec instance.
   base::android::ScopedJavaGlobalRef<jobject> j_media_codec_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaCodecBridge);
 };
 
 class AudioCodecBridge : public MediaCodecBridge {
  public:
   // Returns an AudioCodecBridge instance if |codec| is supported, or a NULL
   // pointer otherwise.
   static AudioCodecBridge* Create(const AudioCodec& codec);
 
   // See MediaCodecBridge::IsKnownUnaccelerated().
   static bool IsKnownUnaccelerated(const AudioCodec& codec);
 
   // Start the audio codec bridge.
-  bool Start(const AudioCodec& codec, int sample_rate, int channel_count,
-             const uint8* extra_data, size_t extra_data_size,
-             int64 codec_delay_ns, int64 seek_preroll_ns,
-             bool play_audio, jobject media_crypto) WARN_UNUSED_RESULT;
+  bool Start(const AudioCodec& codec,
+             int sample_rate,
+             int channel_count,
+             const uint8_t* extra_data,
+             size_t extra_data_size,
+             int64_t codec_delay_ns,
+             int64_t seek_preroll_ns,
+             bool play_audio,
+             jobject media_crypto) WARN_UNUSED_RESULT;
 
   // Plays the output buffer right away or save for later playback if |postpone|
   // is set to true. This call must be called after DequeueOutputBuffer() and
   // before ReleaseOutputBuffer. The data is extracted from the output buffers
   // using |index|, |size| and |offset|. Returns the playback head position
   // expressed in frames.
   // When |postpone| is set to true, the next PlayOutputBuffer() should have
   // postpone == false, and it will play two buffers: the postponed one and
   // the one identified by |index|.
-  int64 PlayOutputBuffer(int index,
-                         size_t size,
-                         size_t offset,
-                         bool postpone = false);
+  int64_t PlayOutputBuffer(int index,
+                           size_t size,
+                           size_t offset,
+                           bool postpone = false);
 
   // Set the volume of the audio output.
   void SetVolume(double volume);
 
  private:
   explicit AudioCodecBridge(const std::string& mime);
 
   // Configure the java MediaFormat object with the extra codec data passed in.
-  bool ConfigureMediaFormat(jobject j_format, const AudioCodec& codec,
-                            const uint8* extra_data, size_t extra_data_size,
-                            int64 codec_delay_ns, int64 seek_preroll_ns);
+  bool ConfigureMediaFormat(jobject j_format,
+                            const AudioCodec& codec,
+                            const uint8_t* extra_data,
+                            size_t extra_data_size,
+                            int64_t codec_delay_ns,
+                            int64_t seek_preroll_ns);
 };
 
 class MEDIA_EXPORT VideoCodecBridge : public MediaCodecBridge {
  public:
   // See MediaCodecBridge::IsKnownUnaccelerated().
   static bool IsKnownUnaccelerated(const VideoCodec& codec,
                                    MediaCodecDirection direction);
 
   // Create, start, and return a VideoCodecBridge decoder or NULL on failure.
   static VideoCodecBridge* CreateDecoder(
@@ skipping 33 matching lines @@
   VideoCodecBridge(const std::string& mime,
                    bool is_secure,
                    MediaCodecDirection direction);
 
   int adaptive_playback_supported_for_testing_;
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_ANDROID_MEDIA_CODEC_BRIDGE_H_