Remove kint16max.

media/base/audio_buffer_unittest.cc

 // Copyright 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 <stdint.h>
+
+#include <limits>
+
 #include "media/base/audio_buffer.h"
 #include "media/base/audio_bus.h"
 #include "media/base/test_helpers.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace media {
 
 static const int kSampleRate = 48000;
 
 static void VerifyBusWithOffset(AudioBus* bus,
@@ skipping 132 matching lines @@
   VerifyBusWithOffset(bus.get(),
                       trim_start,
                       buffer->frame_count() - trim_start,
                       trim_length * 2,
                       trim_length * 2,
                       1);
 }
 
 TEST(AudioBufferTest, CopyFrom) {
   const ChannelLayout kChannelLayout = CHANNEL_LAYOUT_MONO;
-  scoped_refptr<AudioBuffer> original_buffer =
-      MakeAudioBuffer<uint8>(kSampleFormatU8,
-                             kChannelLayout,
-                             ChannelLayoutToChannelCount(kChannelLayout),
-                             kSampleRate,
-                             1,
-                             1,
-                             kSampleRate / 100,
-                             base::TimeDelta());
+  scoped_refptr<AudioBuffer> original_buffer = MakeAudioBuffer<uint8_t>(
+      kSampleFormatU8, kChannelLayout,
+      ChannelLayoutToChannelCount(kChannelLayout), kSampleRate, 1, 1,
+      kSampleRate / 100, base::TimeDelta());
   scoped_refptr<AudioBuffer> new_buffer =
       AudioBuffer::CopyFrom(kSampleFormatU8,
                             original_buffer->channel_layout(),
                             original_buffer->channel_count(),
                             original_buffer->sample_rate(),
                             original_buffer->frame_count(),
                             &original_buffer->channel_data()[0],
                             original_buffer->timestamp());
   EXPECT_EQ(original_buffer->frame_count(), new_buffer->frame_count());
   EXPECT_EQ(original_buffer->timestamp(), new_buffer->timestamp());
   EXPECT_EQ(original_buffer->duration(), new_buffer->duration());
   EXPECT_EQ(original_buffer->sample_rate(), new_buffer->sample_rate());
   EXPECT_EQ(original_buffer->channel_count(), new_buffer->channel_count());
   EXPECT_EQ(original_buffer->channel_layout(), new_buffer->channel_layout());
   EXPECT_FALSE(original_buffer->end_of_stream());
 }
 
 TEST(AudioBufferTest, CreateEOSBuffer) {
   scoped_refptr<AudioBuffer> buffer = AudioBuffer::CreateEOSBuffer();
   EXPECT_TRUE(buffer->end_of_stream());
 }
 
 TEST(AudioBufferTest, FrameSize) {
-  const uint8 kTestData[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
-                              15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
-                              27, 28, 29, 30, 31 };
+  const uint8_t kTestData[] = {0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10,
+                               11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
+                               22, 23, 24, 25, 26, 27, 28, 29, 30, 31};
   const base::TimeDelta kTimestamp = base::TimeDelta::FromMicroseconds(1337);
 
-  const uint8* const data[] = { kTestData };
+  const uint8_t* const data[] = {kTestData};
   scoped_refptr<AudioBuffer> buffer =
       AudioBuffer::CopyFrom(kSampleFormatU8,
                             CHANNEL_LAYOUT_STEREO,
                             2,
                             kSampleRate,
                             16,
                             data,
                             kTimestamp);
   EXPECT_EQ(16, buffer->frame_count());  // 2 channels of 8-bit data
 
   buffer = AudioBuffer::CopyFrom(kSampleFormatF32, CHANNEL_LAYOUT_4_0, 4,
                                  kSampleRate, 2, data, kTimestamp);
   EXPECT_EQ(2, buffer->frame_count());  // now 4 channels of 32-bit data
 }
 
 TEST(AudioBufferTest, ReadU8) {
   const ChannelLayout channel_layout = CHANNEL_LAYOUT_4_0;
   const int channels = ChannelLayoutToChannelCount(channel_layout);
   const int frames = 10;
   const base::TimeDelta start_time;
-  scoped_refptr<AudioBuffer> buffer = MakeAudioBuffer<uint8>(kSampleFormatU8,
-                                                             channel_layout,
-                                                             channels,
-                                                             kSampleRate,
-                                                             128,
-                                                             1,
-                                                             frames,
-                                                             start_time);
+  scoped_refptr<AudioBuffer> buffer =
+      MakeAudioBuffer<uint8_t>(kSampleFormatU8, channel_layout, channels,
+                               kSampleRate, 128, 1, frames, start_time);
   scoped_ptr<AudioBus> bus = AudioBus::Create(channels, frames);
   buffer->ReadFrames(frames, 0, 0, bus.get());
   VerifyBus(bus.get(), frames, 0, 1.0f / 127.0f);
 
   // Now read the same data one frame at a time.
   bus->Zero();
   for (int i = 0; i < frames; ++i)
     buffer->ReadFrames(1, i, i, bus.get());
   VerifyBus(bus.get(), frames, 0, 1.0f / 127.0f);
 }
 
 TEST(AudioBufferTest, ReadS16) {
   const ChannelLayout channel_layout = CHANNEL_LAYOUT_STEREO;
   const int channels = ChannelLayoutToChannelCount(channel_layout);
   const int frames = 10;
   const base::TimeDelta start_time;
-  scoped_refptr<AudioBuffer> buffer = MakeAudioBuffer<int16>(kSampleFormatS16,
-                                                             channel_layout,
-                                                             channels,
-                                                             kSampleRate,
-                                                             1,
-                                                             1,
-                                                             frames,
-                                                             start_time);
+  scoped_refptr<AudioBuffer> buffer =
+      MakeAudioBuffer<int16_t>(kSampleFormatS16, channel_layout, channels,
+                               kSampleRate, 1, 1, frames, start_time);
   scoped_ptr<AudioBus> bus = AudioBus::Create(channels, frames);
   buffer->ReadFrames(frames, 0, 0, bus.get());
-  VerifyBus(bus.get(), frames, 1.0f / kint16max, 1.0f / kint16max);
+  VerifyBus(bus.get(), frames, 1.0f / std::numeric_limits<int16_t>::max(),
+            1.0f / std::numeric_limits<int16_t>::max());
 
   // Now read the same data one frame at a time.
   bus->Zero();
   for (int i = 0; i < frames; ++i)
     buffer->ReadFrames(1, i, i, bus.get());
-  VerifyBus(bus.get(), frames, 1.0f / kint16max, 1.0f / kint16max);
+  VerifyBus(bus.get(), frames, 1.0f / std::numeric_limits<int16_t>::max(),
+            1.0f / std::numeric_limits<int16_t>::max());
 }
 
 TEST(AudioBufferTest, ReadS32) {
   const ChannelLayout channel_layout = CHANNEL_LAYOUT_STEREO;
   const int channels = ChannelLayoutToChannelCount(channel_layout);
   const int frames = 20;
   const base::TimeDelta start_time;
-  scoped_refptr<AudioBuffer> buffer = MakeAudioBuffer<int32>(kSampleFormatS32,
-                                                             channel_layout,
-                                                             channels,
-                                                             kSampleRate,
-                                                             1,
-                                                             1,
-                                                             frames,
-                                                             start_time);
+  scoped_refptr<AudioBuffer> buffer =
+      MakeAudioBuffer<int32_t>(kSampleFormatS32, channel_layout, channels,
+                               kSampleRate, 1, 1, frames, start_time);
   scoped_ptr<AudioBus> bus = AudioBus::Create(channels, frames);
   buffer->ReadFrames(frames, 0, 0, bus.get());
-  VerifyBus(bus.get(), frames, 1.0f / kint32max, 1.0f / kint32max);
+  VerifyBus(bus.get(), frames, 1.0f / std::numeric_limits<int32_t>::max(),
+            1.0f / std::numeric_limits<int32_t>::max());
 
   // Read second 10 frames.
   bus->Zero();
   buffer->ReadFrames(10, 10, 0, bus.get());
-  VerifyBus(bus.get(), 10, 11.0f / kint32max, 1.0f / kint32max);
+  VerifyBus(bus.get(), 10, 11.0f / std::numeric_limits<int32_t>::max(),
+            1.0f / std::numeric_limits<int32_t>::max());
 }
 
 TEST(AudioBufferTest, ReadF32) {
   const ChannelLayout channel_layout = CHANNEL_LAYOUT_STEREO;
   const int channels = ChannelLayoutToChannelCount(channel_layout);
   const int frames = 20;
   const base::TimeDelta start_time;
   scoped_refptr<AudioBuffer> buffer = MakeAudioBuffer<float>(kSampleFormatF32,
                                                              channel_layout,
                                                              channels,
@@ skipping 11 matching lines @@
   buffer->ReadFrames(10, 10, 0, bus.get());
   VerifyBus(bus.get(), 10, 11, 1);
 }
 
 TEST(AudioBufferTest, ReadS16Planar) {
   const ChannelLayout channel_layout = CHANNEL_LAYOUT_STEREO;
   const int channels = ChannelLayoutToChannelCount(channel_layout);
   const int frames = 20;
   const base::TimeDelta start_time;
   scoped_refptr<AudioBuffer> buffer =
-      MakeAudioBuffer<int16>(kSampleFormatPlanarS16,
-                             channel_layout,
-                             channels,
-                             kSampleRate,
-                             1,
-                             1,
-                             frames,
-                             start_time);
+      MakeAudioBuffer<int16_t>(kSampleFormatPlanarS16, channel_layout, channels,
+                               kSampleRate, 1, 1, frames, start_time);
   scoped_ptr<AudioBus> bus = AudioBus::Create(channels, frames);
   buffer->ReadFrames(10, 0, 0, bus.get());
-  VerifyBus(bus.get(), 10, 1.0f / kint16max, 1.0f / kint16max);
+  VerifyBus(bus.get(), 10, 1.0f / std::numeric_limits<int16_t>::max(),
+            1.0f / std::numeric_limits<int16_t>::max());
 
   // Read all the frames backwards, one by one. ch[0] should be 20, 19, ...
   bus->Zero();
   for (int i = frames - 1; i >= 0; --i)
     buffer->ReadFrames(1, i, i, bus.get());
-  VerifyBus(bus.get(), frames, 1.0f / kint16max, 1.0f / kint16max);
+  VerifyBus(bus.get(), frames, 1.0f / std::numeric_limits<int16_t>::max(),
+            1.0f / std::numeric_limits<int16_t>::max());
 
   // Read 0 frames with different offsets. Existing data in AudioBus should be
   // unchanged.
   buffer->ReadFrames(0, 0, 0, bus.get());
-  VerifyBus(bus.get(), frames, 1.0f / kint16max, 1.0f / kint16max);
+  VerifyBus(bus.get(), frames, 1.0f / std::numeric_limits<int16_t>::max(),
+            1.0f / std::numeric_limits<int16_t>::max());
   buffer->ReadFrames(0, 0, 10, bus.get());
-  VerifyBus(bus.get(), frames, 1.0f / kint16max, 1.0f / kint16max);
+  VerifyBus(bus.get(), frames, 1.0f / std::numeric_limits<int16_t>::max(),
+            1.0f / std::numeric_limits<int16_t>::max());
   buffer->ReadFrames(0, 10, 0, bus.get());
-  VerifyBus(bus.get(), frames, 1.0f / kint16max, 1.0f / kint16max);
+  VerifyBus(bus.get(), frames, 1.0f / std::numeric_limits<int16_t>::max(),
+            1.0f / std::numeric_limits<int16_t>::max());
 }
 
 TEST(AudioBufferTest, ReadF32Planar) {
   const ChannelLayout channel_layout = CHANNEL_LAYOUT_4_0;
   const int channels = ChannelLayoutToChannelCount(channel_layout);
   const int frames = 100;
   const base::TimeDelta start_time;
   scoped_refptr<AudioBuffer> buffer =
       MakeAudioBuffer<float>(kSampleFormatPlanarF32,
                              channel_layout,
@@ skipping 102 matching lines @@
 
 static scoped_refptr<AudioBuffer> MakeReadFramesInterleavedTestBuffer(
     SampleFormat sample_format,
     int sample_rate,
     ChannelLayout channel_layout,
     int channel_count,
     int frames) {
   switch (sample_format) {
     case kSampleFormatS16:
     case kSampleFormatPlanarS16:
-      return MakeAudioBuffer<int16>(sample_format,
-                                    channel_layout,
-                                    channel_count,
-                                    sample_rate,
-                                    0,
-                                    1,
-                                    frames,
-                                    base::TimeDelta::FromSeconds(0));
+      return MakeAudioBuffer<int16_t>(sample_format, channel_layout,
+                                      channel_count, sample_rate, 0, 1, frames,
+                                      base::TimeDelta::FromSeconds(0));
     case kSampleFormatS24:
     case kSampleFormatS32:
-      return MakeAudioBuffer<int32>(kSampleFormatS32,
-                                    channel_layout,
-                                    channel_count,
-                                    sample_rate,
-                                    0,
-                                    65536,
-                                    frames,
-                                    base::TimeDelta::FromSeconds(0));
+      return MakeAudioBuffer<int32_t>(kSampleFormatS32, channel_layout,
+                                      channel_count, sample_rate, 0, 65536,
+                                      frames, base::TimeDelta::FromSeconds(0));
     case kSampleFormatF32:
     case kSampleFormatPlanarF32:
       return MakeAudioBuffer<float>(
-          sample_format,
-          channel_layout,
-          channel_count,
-          sample_rate,
-          0.0f,
-          65536.0f / std::numeric_limits<int32>::max(),
-          frames,
+          sample_format, channel_layout, channel_count, sample_rate, 0.0f,
+          65536.0f / std::numeric_limits<int32_t>::max(), frames,
           base::TimeDelta::FromSeconds(0));
     case kSampleFormatPlanarS32:
-      return MakeAudioBuffer<int32>(
-          sample_format,
-          channel_layout,
-          channel_count,
-          sample_rate,
-          0.0f,
-          65536.0f / std::numeric_limits<int32>::max(),
-          frames,
+      return MakeAudioBuffer<int32_t>(
+          sample_format, channel_layout, channel_count, sample_rate, 0.0f,
+          65536.0f / std::numeric_limits<int32_t>::max(), frames,
           base::TimeDelta::FromSeconds(0));
     case kSampleFormatU8:
     case kUnknownSampleFormat:
       EXPECT_FALSE(true);
       break;
   }
   return AudioBuffer::CreateEOSBuffer();
 }
 
 static void ReadFramesInterleavedS32Test(SampleFormat sample_format) {
@@ skipping 74 matching lines @@
 
 TEST(AudioBufferTest, ReadFramesInterleavedS16FromPlanarS16) {
   ReadFramesInterleavedS16Test(kSampleFormatPlanarS16);
 }
 
 TEST(AudioBufferTest, ReadFramesInterleavedS16FromPlanarF32) {
   ReadFramesInterleavedS16Test(kSampleFormatPlanarF32);
 }
 
 }  // namespace media