Switch to standard integer types in remoting/.

remoting/codec/audio_encoder_opus_unittest.cc

 // Copyright (c) 2012 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.
 
 // MSVC++ requires this to get M_PI.
 #define _USE_MATH_DEFINES
 #include <math.h>
+#include <stddef.h>
+#include <stdint.h>
 
 #include "remoting/codec/audio_encoder_opus.h"
 
 #include "base/logging.h"
 #include "remoting/codec/audio_decoder_opus.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace remoting {
 
 namespace {
@@ skipping 26 matching lines @@
 const double kMaxSignalDeviation = 0.1;
 
 }  // namespace
 
 class OpusAudioEncoderTest : public testing::Test {
  public:
   // Return test signal value at the specified position |pos|. |frequency_hz|
   // defines frequency of the signal. |channel| is used to calculate phase shift
   // of the signal, so that different signals are generated for left and right
   // channels.
-  static int16 GetSampleValue(
-      AudioPacket::SamplingRate rate,
-      double frequency_hz,
-      double pos,
-      int channel) {
+  static int16_t GetSampleValue(AudioPacket::SamplingRate rate,
+                                double frequency_hz,
+                                double pos,
+                                int channel) {
     double angle = pos * 2 * M_PI * frequency_hz / rate +
         kChannelPhaseShift * channel;
     return static_cast<int>(sin(angle) * kMaxSampleValue + 0.5);
   }
 
   // Creates  audio packet filled with a test signal with the specified
   // |frequency_hz|.
   scoped_ptr<AudioPacket> CreatePacket(
       int samples,
       AudioPacket::SamplingRate rate,
       double frequency_hz,
       int pos) {
-    std::vector<int16> data(samples * kChannels);
+    std::vector<int16_t> data(samples * kChannels);
     for (int i = 0; i < samples; ++i) {
       data[i * kChannels] = GetSampleValue(rate, frequency_hz, i + pos, 0);
       data[i * kChannels + 1] = GetSampleValue(rate, frequency_hz, i + pos, 1);
     }
 
     scoped_ptr<AudioPacket> packet(new AudioPacket());
     packet->add_data(reinterpret_cast<char*>(&(data[0])),
-                     samples * kChannels * sizeof(int16));
+                     samples * kChannels * sizeof(int16_t));
     packet->set_encoding(AudioPacket::ENCODING_RAW);
     packet->set_sampling_rate(rate);
     packet->set_bytes_per_sample(AudioPacket::BYTES_PER_SAMPLE_2);
     packet->set_channels(AudioPacket::CHANNELS_STEREO);
     return packet.Pass();
   }
 
   // Decoded data is normally shifted in phase relative to the original signal.
   // This function returns the approximate shift in samples by finding the first
   // point when signal goes from negative to positive.
-  double EstimateSignalShift(const std::vector<int16>& received_data) {
+  double EstimateSignalShift(const std::vector<int16_t>& received_data) {
     for (size_t i = kSkippedFirstSamples;
          i < received_data.size() / kChannels - 1; i++) {
-      int16 this_sample = received_data[i * kChannels];
-      int16 next_sample = received_data[(i + 1) * kChannels];
+      int16_t this_sample = received_data[i * kChannels];
+      int16_t next_sample = received_data[(i + 1) * kChannels];
       if (this_sample < 0 && next_sample > 0) {
         return
             i + static_cast<double>(-this_sample) / (next_sample - this_sample);
       }
     }
     return 0;
   }
 
   // Compares decoded signal with the test signal that was encoded. It estimates
   // phase shift from the original signal, then calculates standard deviation of
   // the difference between original and decoded signals.
   void ValidateReceivedData(int samples,
                             AudioPacket::SamplingRate rate,
                             double frequency_hz,
-                            const std::vector<int16>& received_data) {
+                            const std::vector<int16_t>& received_data) {
     double shift = EstimateSignalShift(received_data);
     double diff_sqare_sum = 0;
     for (size_t i = kSkippedFirstSamples;
          i < received_data.size() / kChannels; i++) {
       double d = received_data[i * kChannels] -
           GetSampleValue(rate, frequency_hz, i - shift, 0);
       diff_sqare_sum += d * d;
       d = received_data[i * kChannels + 1] -
           GetSampleValue(rate, frequency_hz, i - shift, 1);
       diff_sqare_sum += d * d;
     }
     double deviation = sqrt(diff_sqare_sum / received_data.size())
          / kMaxSampleValue;
     LOG(ERROR) << "Decoded signal deviation: " << deviation;
     EXPECT_LE(deviation, kMaxSignalDeviation);
   }
 
   void TestEncodeDecode(int packet_size,
                           double frequency_hz,
                           AudioPacket::SamplingRate rate) {
     const int kTotalTestSamples = 24000;
 
     encoder_.reset(new AudioEncoderOpus());
     decoder_.reset(new AudioDecoderOpus());
 
-    std::vector<int16> received_data;
+    std::vector<int16_t> received_data;
     int pos = 0;
     for (; pos < kTotalTestSamples; pos += packet_size) {
         scoped_ptr<AudioPacket> source_packet =
             CreatePacket(packet_size, rate, frequency_hz, pos);
         scoped_ptr<AudioPacket> encoded =
             encoder_->Encode(source_packet.Pass());
         if (encoded.get()) {
           scoped_ptr<AudioPacket> decoded = decoder_->Decode(encoded.Pass());
           EXPECT_EQ(kDefaultSamplingRate, decoded->sampling_rate());
           for (int i = 0; i < decoded->data_size(); ++i) {
-            const int16* data =
-                reinterpret_cast<const int16*>(decoded->data(i).data());
+            const int16_t* data =
+                reinterpret_cast<const int16_t*>(decoded->data(i).data());
             received_data.insert(
                 received_data.end(), data,
-                data + decoded->data(i).size() / sizeof(int16));
+                data + decoded->data(i).size() / sizeof(int16_t));
           }
         }
     }
 
     // Verify that at most kMaxLatencyMs worth of samples is buffered inside
     // |encoder_| and |decoder_|.
     EXPECT_GE(static_cast<int>(received_data.size()) / kChannels,
               pos - rate * kMaxLatencyMs / 1000);
 
     ValidateReceivedData(packet_size, kDefaultSamplingRate,
@@ skipping 20 matching lines @@
   TestEncodeDecode(2000, 10000, AudioPacket::SAMPLING_RATE_44100);
 }
 
 TEST_F(OpusAudioEncoderTest, BufferSizeAndResampling) {
   TestEncodeDecode(500, 3000, AudioPacket::SAMPLING_RATE_44100);
   TestEncodeDecode(1000, 3000, AudioPacket::SAMPLING_RATE_44100);
   TestEncodeDecode(5000, 3000, AudioPacket::SAMPLING_RATE_44100);
 }
 
 }  // namespace remoting