Delete all use of tick_util.h.

webrtc/modules/audio_processing/test/process_test.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include <math.h>
 #include <stdio.h>
 #include <string.h>
 #ifdef WEBRTC_ANDROID
 #include <sys/stat.h>
 #endif
 
 #include <algorithm>
 #include <memory>
 
 #include "webrtc/base/format_macros.h"
+#include "webrtc/base/timeutils.h"
 #include "webrtc/common.h"
 #include "webrtc/modules/audio_processing/include/audio_processing.h"
 #include "webrtc/modules/audio_processing/test/protobuf_utils.h"
 #include "webrtc/modules/audio_processing/test/test_utils.h"
 #include "webrtc/modules/include/module_common_types.h"
 #include "webrtc/system_wrappers/include/cpu_features_wrapper.h"
-#include "webrtc/system_wrappers/include/tick_util.h"
 #include "webrtc/test/testsupport/fileutils.h"
 #include "webrtc/test/testsupport/perf_test.h"
 #ifdef WEBRTC_ANDROID_PLATFORM_BUILD
 #include "gtest/gtest.h"
 #include "external/webrtc/webrtc/modules/audio_processing/debug.pb.h"
 #else
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/modules/audio_processing/debug.pb.h"
 #endif
 
@@ skipping 516 matching lines @@
   }
 
   if (aecm_echo_path_out_filename != NULL) {
     aecm_echo_path_out_file = OpenFile(aecm_echo_path_out_filename, "wb");
   }
 
   size_t read_count = 0;
   int reverse_count = 0;
   int primary_count = 0;
   int near_read_bytes = 0;
-  TickInterval acc_ticks;
+  int64_t acc_nanos = 0;
 
   AudioFrame far_frame;
   AudioFrame near_frame;
 
   int delay_ms = 0;
   int drift_samples = 0;
   int capture_level = 127;
   int8_t stream_has_voice = 0;
   float ns_speech_prob = 0.0f;
 
-  TickTime t0 = TickTime::Now();
-  TickTime t1 = t0;
+  int64_t t0 = rtc::TimeNanos();
+  int64_t t1 = t0;
   int64_t max_time_us = 0;
   int64_t max_time_reverse_us = 0;
   int64_t min_time_us = 1e6;
   int64_t min_time_reverse_us = 1e6;
 
   // TODO(ajm): Ideally we would refactor this block into separate functions,
   //            but for now we want to share the variables.
   if (pb_file) {
     Event event_msg;
     std::unique_ptr<ChannelBuffer<float> > reverse_cb;
@@ skipping 81 matching lines @@
         } else {
           for (int i = 0; i < msg.channel_size(); ++i) {
             memcpy(reverse_cb->channels()[i],
                    msg.channel(i).data(),
                    reverse_cb->num_frames() *
                        sizeof(reverse_cb->channels()[i][0]));
           }
         }
 
         if (perf_testing) {
-          t0 = TickTime::Now();
+          t0 = rtc::TimeNanos();
         }
 
         if (msg.has_data()) {
           ASSERT_EQ(apm->kNoError,
                     apm->ProcessReverseStream(&far_frame));
         } else {
           ASSERT_EQ(apm->kNoError,
                     apm->AnalyzeReverseStream(
                         reverse_cb->channels(),
                         far_frame.samples_per_channel_,
                         far_frame.sample_rate_hz_,
                         LayoutFromChannels(far_frame.num_channels_)));
         }
 
         if (perf_testing) {
-          t1 = TickTime::Now();
-          TickInterval tick_diff = t1 - t0;
-          acc_ticks += tick_diff;
-          if (tick_diff.Microseconds() > max_time_reverse_us) {
-            max_time_reverse_us = tick_diff.Microseconds();
+          t1 = rtc::TimeNanos();
+          int64_t diff_nanos = t1 - t0;
+          acc_nanos += diff_nanos;
+          int64_t diff_us = diff_nanos / rtc::kNumNanosecsPerMicrosec;
+          if (diff_us > max_time_reverse_us) {
+            max_time_reverse_us = diff_us;
           }
-          if (tick_diff.Microseconds() < min_time_reverse_us) {
-            min_time_reverse_us = tick_diff.Microseconds();
+          if (diff_us < min_time_reverse_us) {
+            min_time_reverse_us = diff_us;
           }
         }
 
       } else if (event_msg.type() == Event::STREAM) {
         ASSERT_TRUE(event_msg.has_stream());
         const Stream msg = event_msg.stream();
         primary_count++;
 
         // ProcessStream could have changed this for the output frame.
         near_frame.num_channels_ = apm->num_input_channels();
@@ skipping 17 matching lines @@
         }
 
         if (progress && primary_count % 100 == 0) {
           near_read_bytes = std::min(near_read_bytes, near_size_bytes);
           printf("%.0f%% complete\r",
               (near_read_bytes * 100.0) / near_size_bytes);
           fflush(stdout);
         }
 
         if (perf_testing) {
-          t0 = TickTime::Now();
+          t0 = rtc::TimeNanos();
         }
 
         ASSERT_EQ(apm->kNoError,
                   apm->gain_control()->set_stream_analog_level(msg.level()));
         delay_ms = msg.delay() + extra_delay_ms;
         if (override_delay_ms) {
           delay_ms = override_delay_ms;
         }
         ASSERT_EQ(apm->kNoError,
                   apm->set_stream_delay_ms(delay_ms));
@@ skipping 37 matching lines @@
 
         if (ns_prob_file != NULL) {
           ns_speech_prob = apm->noise_suppression()->speech_probability();
           ASSERT_EQ(1u, fwrite(&ns_speech_prob,
                                sizeof(ns_speech_prob),
                                1,
                                ns_prob_file));
         }
 
         if (perf_testing) {
-          t1 = TickTime::Now();
-          TickInterval tick_diff = t1 - t0;
-          acc_ticks += tick_diff;
-          if (tick_diff.Microseconds() > max_time_us) {
-            max_time_us = tick_diff.Microseconds();
+          t1 = rtc::TimeNanos();
+          int64_t diff_nanos = t1 - t0;
+          acc_nanos += diff_nanos;
+          int64_t diff_us = diff_nanos / rtc::kNumNanosecsPerMicrosec;
+          if (diff_us > max_time_us) {
+            max_time_us = diff_us;
           }
-          if (tick_diff.Microseconds() < min_time_us) {
-            min_time_us = tick_diff.Microseconds();
+          if (diff_us < min_time_us) {
+            min_time_us = diff_us;
           }
         }
 
         const size_t samples_per_channel = output_sample_rate / 100;
         if (msg.has_input_data()) {
           if (raw_output && !output_raw_file) {
             output_raw_file.reset(new RawFile(out_filename + ".pcm"));
           }
           WriteIntData(near_frame.data_,
                        apm->num_output_channels() * samples_per_channel,
@@ skipping 102 matching lines @@
             // not reaching end-of-file.
             EXPECT_EQ(0, fseek(near_file, read_count * sizeof(int16_t),
                       SEEK_CUR));
             break;  // This is expected.
           }
         } else {
           ASSERT_EQ(size, read_count);
         }
 
         if (perf_testing) {
-          t0 = TickTime::Now();
+          t0 = rtc::TimeNanos();
         }
 
         ASSERT_EQ(apm->kNoError,
                   apm->ProcessReverseStream(&far_frame));
 
         if (perf_testing) {
-          t1 = TickTime::Now();
-          TickInterval tick_diff = t1 - t0;
-          acc_ticks += tick_diff;
-          if (tick_diff.Microseconds() > max_time_reverse_us) {
-            max_time_reverse_us = tick_diff.Microseconds();
+          t1 = rtc::TimeNanos();
+          int64_t diff_nanos = t1 - t0;
+          acc_nanos += diff_nanos;
+          int64_t diff_us = diff_nanos / rtc::kNumNanosecsPerMicrosec;
+          if (diff_us > max_time_reverse_us) {
+            max_time_reverse_us = diff_us;
           }
-          if (tick_diff.Microseconds() < min_time_reverse_us) {
-            min_time_reverse_us = tick_diff.Microseconds();
+          if (diff_us < min_time_reverse_us) {
+            min_time_reverse_us = diff_us;
           }
         }
 
       } else if (event == kCaptureEvent) {
         primary_count++;
         near_frame.num_channels_ = num_capture_input_channels;
 
         size_t size = samples_per_channel * num_capture_input_channels;
         read_count = fread(near_frame.data_,
                            sizeof(int16_t),
@@ skipping 22 matching lines @@
           ASSERT_EQ(1u,
               fread(&drift_samples, sizeof(drift_samples), 1, drift_file));
         }
 
         if (apm->gain_control()->is_enabled() &&
             apm->gain_control()->mode() == GainControl::kAdaptiveAnalog) {
           SimulateMic(capture_level, &near_frame);
         }
 
         if (perf_testing) {
-          t0 = TickTime::Now();
+          t0 = rtc::TimeNanos();
         }
 
         const int capture_level_in = capture_level;
         ASSERT_EQ(apm->kNoError,
                   apm->gain_control()->set_stream_analog_level(capture_level));
         delay_ms += extra_delay_ms;
         if (override_delay_ms) {
           delay_ms = override_delay_ms;
         }
         ASSERT_EQ(apm->kNoError,
@@ skipping 27 matching lines @@
                                sizeof(ns_speech_prob),
                                1,
                                ns_prob_file));
         }
 
         if (apm->gain_control()->mode() != GainControl::kAdaptiveAnalog) {
           ASSERT_EQ(capture_level_in, capture_level);
         }
 
         if (perf_testing) {
-          t1 = TickTime::Now();
-          TickInterval tick_diff = t1 - t0;
-          acc_ticks += tick_diff;
-          if (tick_diff.Microseconds() > max_time_us) {
-            max_time_us = tick_diff.Microseconds();
+          t1 = rtc::TimeNanos();
+          int64_t diff_nanos = t1 - t0;
+          acc_nanos += diff_nanos;
+          int64_t diff_us = diff_nanos / rtc::kNumNanosecsPerMicrosec;
+          if (diff_us > max_time_us) {
+            max_time_us = diff_us;
           }
-          if (tick_diff.Microseconds() < min_time_us) {
-            min_time_us = tick_diff.Microseconds();
+          if (diff_us < min_time_us) {
+            min_time_us = diff_us;
           }
         }
 
         if (raw_output && !output_raw_file) {
           output_raw_file.reset(new RawFile(out_filename + ".pcm"));
         }
         if (!raw_output && !output_wav_file) {
           output_wav_file.reset(new WavWriter(out_filename + ".wav",
                                               sample_rate_hz,
                                               num_capture_output_channels));
@@ skipping 72 matching lines @@
       EXPECT_NE(0, feof(event_file)) << "Event file not fully processed";
       read_count = fread(&temp_int8, sizeof(temp_int8), 1, delay_file);
       EXPECT_NE(0, feof(delay_file)) << "Delay file not fully processed";
       read_count = fread(&temp_int8, sizeof(temp_int8), 1, drift_file);
       EXPECT_NE(0, feof(drift_file)) << "Drift file not fully processed";
     }
   }
 
   if (perf_testing) {
     if (primary_count > 0) {
-      int64_t exec_time = acc_ticks.Milliseconds();
+      int64_t exec_time = acc_nanos / rtc::kNumNanosecsPerMillisec;
       printf("\nTotal time: %.3f s, file time: %.2f s\n",
         exec_time * 0.001, primary_count * 0.01);
       printf("Time per frame: %.3f ms (average), %.3f ms (max),"
              " %.3f ms (min)\n",
           (exec_time * 1.0) / primary_count,
           (max_time_us + max_time_reverse_us) / 1000.0,
           (min_time_us + min_time_reverse_us) / 1000.0);
       // Record the results with Perf test tools.
       webrtc::test::PrintResult("audioproc", "", "time_per_10ms_frame",
           (exec_time * 1000) / primary_count, "us", false);
     } else {
       printf("Warning: no capture frames\n");
     }
   }
 }
 
 }  // namespace
 }  // namespace webrtc
 
 int main(int argc, char* argv[]) {
   webrtc::void_main(argc, argv);
 
   // Optional, but removes memory leak noise from Valgrind.
   google::protobuf::ShutdownProtobufLibrary();
   return 0;
 }