Remove kint32max.

media/base/android/media_codec_bridge.cc

 // 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.
 
 #include "media/base/android/media_codec_bridge.h"
 
 #include <algorithm>
 
 #include "base/android/build_info.h"
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
-#include "base/basictypes.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "jni/MediaCodecBridge_jni.h"
 #include "media/base/bit_reader.h"
 #include "media/base/decrypt_config.h"
 
 using base::android::AttachCurrentThread;
@@ skipping 291 matching lines @@
 }
 
 int MediaCodecBridge::GetOutputSamplingRate() {
   JNIEnv* env = AttachCurrentThread();
 
   return Java_MediaCodecBridge_getOutputSamplingRate(env, j_media_codec_.obj());
 }
 
 MediaCodecStatus MediaCodecBridge::QueueInputBuffer(
     int index,
-    const uint8* data,
+    const uint8_t* data,
     size_t data_size,
     const base::TimeDelta& presentation_time) {
   DVLOG(3) << __PRETTY_FUNCTION__ << index << ": " << data_size;
-  if (data_size > base::checked_cast<size_t>(kint32max))
+  if (data_size >
+      base::checked_cast<size_t>(std::numeric_limits<int32_t>::max()))
     return MEDIA_CODEC_ERROR;
   if (data && !FillInputBuffer(index, data, data_size))
     return MEDIA_CODEC_ERROR;
   JNIEnv* env = AttachCurrentThread();
   return static_cast<MediaCodecStatus>(
       Java_MediaCodecBridge_queueInputBuffer(env,
                                              j_media_codec_.obj(),
                                              index,
                                              0,
                                              data_size,
                                              presentation_time.InMicroseconds(),
                                              0));
 }
 
 MediaCodecStatus MediaCodecBridge::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) {
   return QueueSecureInputBuffer(
       index, data, data_size, reinterpret_cast<const uint8_t*>(key_id.data()),
       key_id.size(), reinterpret_cast<const uint8_t*>(iv.data()), iv.size(),
       subsamples.empty() ? nullptr : &subsamples[0], subsamples.size(),
       presentation_time);
 }
 
 // TODO(timav): Combine this and above methods together keeping only the first
 // interface after we switch to Spitzer pipeline.
 MediaCodecStatus MediaCodecBridge::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) {
   DVLOG(3) << __PRETTY_FUNCTION__ << index << ": " << data_size;
-  if (data_size > base::checked_cast<size_t>(kint32max))
+  if (data_size >
+      base::checked_cast<size_t>(std::numeric_limits<int32_t>::max()))
     return MEDIA_CODEC_ERROR;
   if (data && !FillInputBuffer(index, data, data_size))
     return MEDIA_CODEC_ERROR;
 
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jbyteArray> j_key_id =
       base::android::ToJavaByteArray(env, key_id, key_id_size);
   ScopedJavaLocalRef<jbyteArray> j_iv =
       base::android::ToJavaByteArray(env, iv, iv_size);
 
   // MediaCodec.CryptoInfo documentations says passing NULL for |clear_array|
   // to indicate that all data is encrypted. But it doesn't specify what
   // |cypher_array| and |subsamples_size| should be in that case. Passing
   // one subsample here just to be on the safe side.
   int new_subsamples_size = subsamples_size == 0 ? 1 : subsamples_size;
 
   scoped_ptr<jint[]> native_clear_array(new jint[new_subsamples_size]);
   scoped_ptr<jint[]> native_cypher_array(new jint[new_subsamples_size]);
 
   if (subsamples_size == 0) {
     DCHECK(!subsamples);
     native_clear_array[0] = 0;
     native_cypher_array[0] = data_size;
   } else {
     DCHECK_GT(subsamples_size, 0);
     DCHECK(subsamples);
     for (int i = 0; i < subsamples_size; ++i) {
-      DCHECK(subsamples[i].clear_bytes <= std::numeric_limits<uint16>::max());
+      DCHECK(subsamples[i].clear_bytes <= std::numeric_limits<uint16_t>::max());
       if (subsamples[i].cypher_bytes >
-          static_cast<uint32>(std::numeric_limits<jint>::max())) {
+          static_cast<uint32_t>(std::numeric_limits<jint>::max())) {
         return MEDIA_CODEC_ERROR;
       }
 
       native_clear_array[i] = subsamples[i].clear_bytes;
       native_cypher_array[i] = subsamples[i].cypher_bytes;
     }
   }
 
   ScopedJavaLocalRef<jintArray> clear_array =
       ToJavaIntArray(env, native_clear_array.Pass(), new_subsamples_size);
@@ skipping 89 matching lines @@
   return Java_MediaCodecBridge_getOutputBuffersCount(env, j_media_codec_.obj());
 }
 
 size_t MediaCodecBridge::GetOutputBuffersCapacity() {
   JNIEnv* env = AttachCurrentThread();
   return Java_MediaCodecBridge_getOutputBuffersCapacity(env,
                                                         j_media_codec_.obj());
 }
 
 void MediaCodecBridge::GetInputBuffer(int input_buffer_index,
-                                      uint8** data,
+                                      uint8_t** data,
                                       size_t* capacity) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> j_buffer(Java_MediaCodecBridge_getInputBuffer(
       env, j_media_codec_.obj(), input_buffer_index));
-  *data = static_cast<uint8*>(env->GetDirectBufferAddress(j_buffer.obj()));
+  *data = static_cast<uint8_t*>(env->GetDirectBufferAddress(j_buffer.obj()));
   *capacity = base::checked_cast<size_t>(
       env->GetDirectBufferCapacity(j_buffer.obj()));
 }
 
 bool MediaCodecBridge::CopyFromOutputBuffer(int index,
                                             size_t offset,
                                             void* dst,
                                             int dst_size) {
   void* src_data = nullptr;
   int src_capacity = GetOutputBufferAddress(index, offset, &src_data);
   if (src_capacity < dst_size)
     return false;
   memcpy(dst, src_data, dst_size);
   return true;
 }
 
 int MediaCodecBridge::GetOutputBufferAddress(int index,
                                              size_t offset,
                                              void** addr) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> j_buffer(
       Java_MediaCodecBridge_getOutputBuffer(env, j_media_codec_.obj(), index));
-  *addr = reinterpret_cast<uint8*>(
-      env->GetDirectBufferAddress(j_buffer.obj())) + offset;
+  *addr =
+      reinterpret_cast<uint8_t*>(env->GetDirectBufferAddress(j_buffer.obj())) +
+      offset;
   return env->GetDirectBufferCapacity(j_buffer.obj()) - offset;
 }
 
 bool MediaCodecBridge::FillInputBuffer(int index,
-                                       const uint8* data,
+                                       const uint8_t* data,
                                        size_t size) {
-  uint8* dst = NULL;
+  uint8_t* dst = NULL;
   size_t capacity = 0;
   GetInputBuffer(index, &dst, &capacity);
   CHECK(dst);
 
   if (size > capacity) {
     LOG(ERROR) << "Input buffer size " << size
                << " exceeds MediaCodec input buffer capacity: " << capacity;
     return false;
   }
 
   memcpy(dst, data, size);
   return true;
 }
 
 AudioCodecBridge::AudioCodecBridge(const std::string& mime)
     // Audio codec doesn't care about security level and there is no need for
     // audio encoding yet.
     : MediaCodecBridge(mime, false, MEDIA_CODEC_DECODER) {}
 
 bool AudioCodecBridge::Start(const AudioCodec& codec,
                              int sample_rate,
                              int channel_count,
-                             const uint8* extra_data,
+                             const uint8_t* extra_data,
                              size_t extra_data_size,
-                             int64 codec_delay_ns,
-                             int64 seek_preroll_ns,
+                             int64_t codec_delay_ns,
+                             int64_t seek_preroll_ns,
                              bool play_audio,
                              jobject media_crypto) {
   JNIEnv* env = AttachCurrentThread();
 
   if (!media_codec())
     return false;
 
   std::string codec_string = AudioCodecToAndroidMimeType(codec);
   if (codec_string.empty())
     return false;
@@ skipping 12 matching lines @@
   if (!Java_MediaCodecBridge_configureAudio(
            env, media_codec(), j_format.obj(), media_crypto, 0, play_audio)) {
     return false;
   }
 
   return StartInternal();
 }
 
 bool AudioCodecBridge::ConfigureMediaFormat(jobject j_format,
                                             const AudioCodec& codec,
-                                            const uint8* extra_data,
+                                            const uint8_t* extra_data,
                                             size_t extra_data_size,
-                                            int64 codec_delay_ns,
-                                            int64 seek_preroll_ns) {
+                                            int64_t codec_delay_ns,
+                                            int64_t seek_preroll_ns) {
   if (extra_data_size == 0 && codec != kCodecOpus)
     return true;
 
   JNIEnv* env = AttachCurrentThread();
   switch (codec) {
     case kCodecVorbis: {
       if (extra_data[0] != 2) {
         LOG(ERROR) << "Invalid number of vorbis headers before the codec "
                    << "header: " << extra_data[0];
         return false;
       }
 
       size_t header_length[2];
       // |total_length| keeps track of the total number of bytes before the last
       // header.
       size_t total_length = 1;
-      const uint8* current_pos = extra_data;
+      const uint8_t* current_pos = extra_data;
       // Calculate the length of the first 2 headers.
       for (int i = 0; i < 2; ++i) {
         header_length[i] = 0;
         while (total_length < extra_data_size) {
           size_t size = *(++current_pos);
           total_length += 1 + size;
           if (total_length > 0x80000000) {
             LOG(ERROR) << "Vorbis header size too large";
             return false;
           }
@@ skipping 18 matching lines @@
               env, extra_data + total_length, extra_data_size - total_length);
       Java_MediaCodecBridge_setCodecSpecificData(
           env, j_format, 1, last_header.obj());
       break;
     }
     case kCodecAAC: {
       media::BitReader reader(extra_data, extra_data_size);
 
       // The following code is copied from aac.cc
       // TODO(qinmin): refactor the code in aac.cc to make it more reusable.
-      uint8 profile = 0;
-      uint8 frequency_index = 0;
-      uint8 channel_config = 0;
+      uint8_t profile = 0;
+      uint8_t frequency_index = 0;
+      uint8_t channel_config = 0;
       RETURN_ON_ERROR(reader.ReadBits(5, &profile));
       RETURN_ON_ERROR(reader.ReadBits(4, &frequency_index));
 
       if (0xf == frequency_index)
         RETURN_ON_ERROR(reader.SkipBits(24));
       RETURN_ON_ERROR(reader.ReadBits(4, &channel_config));
 
       if (profile == 5 || profile == 29) {
         // Read extension config.
         RETURN_ON_ERROR(reader.ReadBits(4, &frequency_index));
         if (frequency_index == 0xf)
           RETURN_ON_ERROR(reader.SkipBits(24));
         RETURN_ON_ERROR(reader.ReadBits(5, &profile));
       }
 
       if (profile < 1 || profile > 4 || frequency_index == 0xf ||
           channel_config > 7) {
         LOG(ERROR) << "Invalid AAC header";
         return false;
       }
       const size_t kCsdLength = 2;
-      uint8 csd[kCsdLength];
+      uint8_t csd[kCsdLength];
       csd[0] = profile << 3 | frequency_index >> 1;
       csd[1] = (frequency_index & 0x01) << 7 | channel_config << 3;
       ScopedJavaLocalRef<jbyteArray> byte_array =
           base::android::ToJavaByteArray(env, csd, kCsdLength);
       Java_MediaCodecBridge_setCodecSpecificData(
           env, j_format, 0, byte_array.obj());
 
       // TODO(qinmin): pass an extra variable to this function to determine
       // whether we need to call this.
       Java_MediaCodecBridge_setFrameHasADTSHeader(env, j_format);
       break;
     }
     case kCodecOpus: {
       if (!extra_data || extra_data_size == 0 ||
           codec_delay_ns < 0 || seek_preroll_ns < 0) {
         LOG(ERROR) << "Invalid Opus Header";
         return false;
       }
 
       // csd0 - Opus Header
       ScopedJavaLocalRef<jbyteArray> csd0 =
           base::android::ToJavaByteArray(env, extra_data, extra_data_size);
       Java_MediaCodecBridge_setCodecSpecificData(env, j_format, 0, csd0.obj());
 
       // csd1 - Codec Delay
-      ScopedJavaLocalRef<jbyteArray> csd1 =
-          base::android::ToJavaByteArray(
-              env, reinterpret_cast<const uint8*>(&codec_delay_ns),
-              sizeof(int64_t));
+      ScopedJavaLocalRef<jbyteArray> csd1 = base::android::ToJavaByteArray(
+          env, reinterpret_cast<const uint8_t*>(&codec_delay_ns),
+          sizeof(int64_t));
       Java_MediaCodecBridge_setCodecSpecificData(env, j_format, 1, csd1.obj());
 
       // csd2 - Seek Preroll
-      ScopedJavaLocalRef<jbyteArray> csd2 =
-          base::android::ToJavaByteArray(
-              env, reinterpret_cast<const uint8*>(&seek_preroll_ns),
-              sizeof(int64_t));
+      ScopedJavaLocalRef<jbyteArray> csd2 = base::android::ToJavaByteArray(
+          env, reinterpret_cast<const uint8_t*>(&seek_preroll_ns),
+          sizeof(int64_t));
       Java_MediaCodecBridge_setCodecSpecificData(env, j_format, 2, csd2.obj());
       break;
     }
     default:
       LOG(ERROR) << "Invalid header encountered for codec: "
                  << AudioCodecToAndroidMimeType(codec);
       return false;
   }
   return true;
 }
 
-int64 AudioCodecBridge::PlayOutputBuffer(int index,
-                                         size_t size,
-                                         size_t offset,
-                                         bool postpone) {
+int64_t AudioCodecBridge::PlayOutputBuffer(int index,
+                                           size_t size,
+                                           size_t offset,
+                                           bool postpone) {
   DCHECK_LE(0, index);
   int numBytes = base::checked_cast<int>(size);
 
   void* buffer = nullptr;
   int capacity = GetOutputBufferAddress(index, offset, &buffer);
   numBytes = std::min(capacity, numBytes);
   CHECK_GE(numBytes, 0);
 
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jbyteArray> byte_array = base::android::ToJavaByteArray(
-          env, static_cast<uint8*>(buffer), numBytes);
+      env, static_cast<uint8_t*>(buffer), numBytes);
   return Java_MediaCodecBridge_playOutputBuffer(env, media_codec(),
                                                 byte_array.obj(), postpone);
 }
 
 void AudioCodecBridge::SetVolume(double volume) {
   JNIEnv* env = AttachCurrentThread();
   Java_MediaCodecBridge_setVolume(env, media_codec(), volume);
 }
 
 // static
@@ skipping 121 matching lines @@
   JNIEnv* env = AttachCurrentThread();
   return Java_MediaCodecBridge_isAdaptivePlaybackSupported(
       env, media_codec(), width, height);
 }
 
 bool MediaCodecBridge::RegisterMediaCodecBridge(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 }  // namespace media