Switch to standard integer types in content/browser/.

content/browser/speech/endpointer/energy_endpointer.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.
 //
 // To know more about the algorithm used and the original code which this is
 // based of, see
 // https://wiki.corp.google.com/twiki/bin/view/Main/ChromeGoogleCodeXRef
 
 #include "content/browser/speech/endpointer/energy_endpointer.h"
 
 #include <math.h>
+#include <stddef.h>
 
 #include "base/logging.h"
+#include "base/macros.h"
 
 namespace {
 
 // Returns the RMS (quadratic mean) of the input signal.
-float RMS(const int16* samples, int num_samples) {
-  int64 ssq_int64 = 0;
-  int64 sum_int64 = 0;
+float RMS(const int16_t* samples, int num_samples) {
+  int64_t ssq_int64 = 0;
+  int64_t sum_int64 = 0;
   for (int i = 0; i < num_samples; ++i) {
     sum_int64 += samples[i];
     ssq_int64 += samples[i] * samples[i];
   }
   // now convert to floats.
   double sum = static_cast<double>(sum_int64);
   sum /= num_samples;
   double ssq = static_cast<double>(ssq_int64);
   return static_cast<float>(sqrt((ssq / num_samples) - (sum * sum)));
 }
 
-int64 Secs2Usecs(float seconds) {
-  return static_cast<int64>(0.5 + (1.0e6 * seconds));
+int64_t Secs2Usecs(float seconds) {
+  return static_cast<int64_t>(0.5 + (1.0e6 * seconds));
 }
 
 float GetDecibel(float value) {
   if (value > 1.0e-100)
     return 20 * log10(value);
   return -2000.0;
 }
 
 }  // namespace
 
 namespace content {
 
 // Stores threshold-crossing histories for making decisions about the speech
 // state.
 class EnergyEndpointer::HistoryRing {
  public:
   HistoryRing() : insertion_index_(0) {}
 
   // Resets the ring to |size| elements each with state |initial_state|
   void SetRing(int size, bool initial_state);
 
   // Inserts a new entry into the ring and drops the oldest entry.
-  void Insert(int64 time_us, bool decision);
+  void Insert(int64_t time_us, bool decision);
 
   // Returns the time in microseconds of the most recently added entry.
-  int64 EndTime() const;
+  int64_t EndTime() const;
 
   // Returns the sum of all intervals during which 'decision' is true within
   // the time in seconds specified by 'duration'. The returned interval is
   // in seconds.
   float RingSum(float duration_sec);
 
  private:
   struct DecisionPoint {
-    int64 time_us;
+    int64_t time_us;
     bool decision;
   };
 
   std::vector<DecisionPoint> decision_points_;
   int insertion_index_;  // Index at which the next item gets added/inserted.
 
   DISALLOW_COPY_AND_ASSIGN(HistoryRing);
 };
 
 void EnergyEndpointer::HistoryRing::SetRing(int size, bool initial_state) {
   insertion_index_ = 0;
   decision_points_.clear();
   DecisionPoint init = { -1, initial_state };
   decision_points_.resize(size, init);
 }
 
-void EnergyEndpointer::HistoryRing::Insert(int64 time_us, bool decision) {
+void EnergyEndpointer::HistoryRing::Insert(int64_t time_us, bool decision) {
   decision_points_[insertion_index_].time_us = time_us;
   decision_points_[insertion_index_].decision = decision;
   insertion_index_ = (insertion_index_ + 1) % decision_points_.size();
 }
 
-int64 EnergyEndpointer::HistoryRing::EndTime() const {
+int64_t EnergyEndpointer::HistoryRing::EndTime() const {
   int ind = insertion_index_ - 1;
   if (ind < 0)
     ind = decision_points_.size() - 1;
   return decision_points_[ind].time_us;
 }
 
 float EnergyEndpointer::HistoryRing::RingSum(float duration_sec) {
   if (!decision_points_.size())
     return 0.0;
 
-  int64 sum_us = 0;
+  int64_t sum_us = 0;
   int ind = insertion_index_ - 1;
   if (ind < 0)
     ind = decision_points_.size() - 1;
-  int64 end_us = decision_points_[ind].time_us;
+  int64_t end_us = decision_points_[ind].time_us;
   bool is_on = decision_points_[ind].decision;
-  int64 start_us = end_us - static_cast<int64>(0.5 + (1.0e6 * duration_sec));
+  int64_t start_us =
+      end_us - static_cast<int64_t>(0.5 + (1.0e6 * duration_sec));
   if (start_us < 0)
     start_us = 0;
   size_t n_summed = 1;  // n points ==> (n-1) intervals
   while ((decision_points_[ind].time_us > start_us) &&
          (n_summed < decision_points_.size())) {
     --ind;
     if (ind < 0)
       ind = decision_points_.size() - 1;
     if (is_on)
       sum_us += end_us - decision_points_[ind].time_us;
@@ skipping 20 matching lines @@
       rms_adapt_(0),
       start_lag_(0),
       end_lag_(0),
       user_input_start_time_us_(0) {
 }
 
 EnergyEndpointer::~EnergyEndpointer() {
 }
 
 int EnergyEndpointer::TimeToFrame(float time) const {
-  return static_cast<int32>(0.5 + (time / params_.frame_period()));
+  return static_cast<int32_t>(0.5 + (time / params_.frame_period()));
 }
 
 void EnergyEndpointer::Restart(bool reset_threshold) {
   status_ = EP_PRE_SPEECH;
   user_input_start_time_us_ = 0;
 
   if (reset_threshold) {
     decision_threshold_ = params_.decision_threshold();
     rms_adapt_ = decision_threshold_;
     noise_level_ = params_.decision_threshold() / 2.0f;
@@ skipping 33 matching lines @@
 
   // Flag that indicates that  current input should be used for
   // estimating the environment. The user has not yet started input
   // by e.g. pressed the push-to-talk button. By default, this is
   // false for backward compatibility.
   estimating_environment_ = false;
   // The initial value of the noise and speech levels is inconsequential.
   // The level of the first frame will overwrite these values.
   noise_level_ = params_.decision_threshold() / 2.0f;
   fast_update_frames_ =
-      static_cast<int64>(params_.fast_update_dur() / params_.frame_period());
+      static_cast<int64_t>(params_.fast_update_dur() / params_.frame_period());
 
   frame_counter_ = 0;  // Used for rapid initial update of levels.
 
   sample_rate_ = params_.sample_rate();
   start_lag_ = static_cast<int>(sample_rate_ /
                                 params_.max_fundamental_frequency());
   end_lag_ = static_cast<int>(sample_rate_ /
                               params_.min_fundamental_frequency());
 }
 
 void EnergyEndpointer::StartSession() {
   Restart(true);
 }
 
 void EnergyEndpointer::EndSession() {
   status_ = EP_POST_SPEECH;
 }
 
 void EnergyEndpointer::SetEnvironmentEstimationMode() {
   Restart(true);
   estimating_environment_ = true;
 }
 
 void EnergyEndpointer::SetUserInputMode() {
   estimating_environment_ = false;
   user_input_start_time_us_ = endpointer_time_us_;
 }
 
-void EnergyEndpointer::ProcessAudioFrame(int64 time_us,
-                                         const int16* samples,
+void EnergyEndpointer::ProcessAudioFrame(int64_t time_us,
+                                         const int16_t* samples,
                                          int num_samples,
                                          float* rms_out) {
   endpointer_time_us_ = time_us;
   float rms = RMS(samples, num_samples);
 
   // Check that this is user input audio vs. pre-input adaptation audio.
   // Input audio starts when the user indicates start of input, by e.g.
   // pressing push-to-talk. Audio received prior to that is used to update
   // noise and speech level estimates.
   if (!estimating_environment_) {
@@ skipping 117 matching lines @@
       noise_level_ = (0.95f * noise_level_) + (0.05f * rms);
   }
   if (estimating_environment_ || (frame_counter_ < fast_update_frames_)) {
     decision_threshold_ = noise_level_ * 2; // 6dB above noise level.
     // Set a floor
     if (decision_threshold_ < params_.min_decision_threshold())
       decision_threshold_ = params_.min_decision_threshold();
   }
 }
 
-EpStatus EnergyEndpointer::Status(int64* status_time)  const {
+EpStatus EnergyEndpointer::Status(int64_t* status_time) const {
   *status_time = history_->EndTime();
   return status_;
 }
 
 }  // namespace content