Delete all use of tick_util.h.

webrtc/api/java/jni/androidmediaencoder_jni.cc

 /*
  *  Copyright 2015 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.
  */
 
 // NOTICE: androidmediaencoder_jni.h must be included before
 // androidmediacodeccommon.h to avoid build errors.
 #include "webrtc/api/java/jni/androidmediaencoder_jni.h"
 
 #include <algorithm>
 #include <memory>
 #include <list>
 
 #include "third_party/libyuv/include/libyuv/convert.h"
 #include "third_party/libyuv/include/libyuv/convert_from.h"
 #include "third_party/libyuv/include/libyuv/video_common.h"
 #include "webrtc/api/java/jni/androidmediacodeccommon.h"
 #include "webrtc/api/java/jni/classreferenceholder.h"
 #include "webrtc/api/java/jni/native_handle_impl.h"
 #include "webrtc/base/bind.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/thread.h"
 #include "webrtc/base/thread_checker.h"
+#include "webrtc/base/timeutils.h"
 #include "webrtc/common_types.h"
 #include "webrtc/modules/rtp_rtcp/source/h264_bitstream_parser.h"
 #include "webrtc/modules/video_coding/include/video_codec_interface.h"
 #include "webrtc/modules/video_coding/utility/quality_scaler.h"
 #include "webrtc/modules/video_coding/utility/vp8_header_parser.h"
 #include "webrtc/system_wrappers/include/field_trial.h"
 #include "webrtc/system_wrappers/include/logcat_trace_context.h"
 
 using rtc::Bind;
 using rtc::Thread;
@@ skipping 477 matching lines @@
   width_ = width;
   height_ = height;
   last_set_bitrate_kbps_ = kbps;
   last_set_fps_ = (fps < MAX_VIDEO_FPS) ? fps : MAX_VIDEO_FPS;
   yuv_size_ = width_ * height_ * 3 / 2;
   frames_received_ = 0;
   frames_encoded_ = 0;
   frames_dropped_media_encoder_ = 0;
   consecutive_full_queue_frame_drops_ = 0;
   current_timestamp_us_ = 0;
-  stat_start_time_ms_ = GetCurrentTimeMs();
+  stat_start_time_ms_ = rtc::TimeMillis();
   current_frames_ = 0;
   current_bytes_ = 0;
   current_acc_qp_ = 0;
   current_encoding_time_ms_ = 0;
   last_input_timestamp_ms_ = -1;
   last_output_timestamp_ms_ = -1;
   output_timestamp_ = 0;
   output_render_time_ms_ = 0;
   input_frame_infos_.clear();
   drop_next_input_frame_ = false;
@@ skipping 67 matching lines @@
   JNIEnv* jni = AttachCurrentThreadIfNeeded();
   ScopedLocalRefFrame local_ref_frame(jni);
 
   if (!inited_) {
     return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
   }
 
   bool send_key_frame = false;
   if (codec_mode_ == webrtc::kRealtimeVideo) {
     ++frames_received_since_last_key_;
-    int64_t now_ms = GetCurrentTimeMs();
+    int64_t now_ms = rtc::TimeMillis();
     if (last_frame_received_ms_ != -1 &&
         (now_ms - last_frame_received_ms_) > kFrameDiffThresholdMs) {
       // Add limit to prevent triggering a key for every frame for very low
       // framerates (e.g. if frame diff > kFrameDiffThresholdMs).
       if (frames_received_since_last_key_ > kMinKeyFrameInterval) {
         ALOGD << "Send key, frame diff: " << (now_ms - last_frame_received_ms_);
         send_key_frame = true;
       }
       frames_received_since_last_key_ = 0;
     }
@@ skipping 65 matching lines @@
         input_frame = quality_scaler_.GetScaledFrame(frame);
       }
     }
   }
 
   if (!MaybeReconfigureEncoderOnCodecThread(input_frame)) {
     ALOGE << "Failed to reconfigure encoder.";
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
 
-  const int64_t time_before_calling_encode = GetCurrentTimeMs();
+  const int64_t time_before_calling_encode = rtc::TimeMillis();
   const bool key_frame =
       frame_types->front() != webrtc::kVideoFrameDelta || send_key_frame;
   bool encode_status = true;
   if (!input_frame.video_frame_buffer()->native_handle()) {
     int j_input_buffer_index = jni->CallIntMethod(*j_media_codec_video_encoder_,
         j_dequeue_input_buffer_method_);
     CHECK_EXCEPTION(jni);
     if (j_input_buffer_index == -1) {
       // Video codec falls behind - no input buffer available.
       ALOGW << "Encoder drop frame - no input buffers available";
@@ skipping 231 matching lines @@
     int64_t frame_encoding_time_ms = 0;
     last_output_timestamp_ms_ =
         GetOutputBufferInfoPresentationTimestampUs(jni, j_output_buffer_info) /
         1000;
     if (!input_frame_infos_.empty()) {
       const InputFrameInfo& frame_info = input_frame_infos_.front();
       output_timestamp_ = frame_info.frame_timestamp;
       output_render_time_ms_ = frame_info.frame_render_time_ms;
       output_rotation_ = frame_info.rotation;
       frame_encoding_time_ms =
-          GetCurrentTimeMs() - frame_info.encode_start_time;
+          rtc::TimeMillis() - frame_info.encode_start_time;
       input_frame_infos_.pop_front();
     }
 
     // Extract payload.
     size_t payload_size = jni->GetDirectBufferCapacity(j_output_buffer);
     uint8_t* payload = reinterpret_cast<uint8_t*>(
         jni->GetDirectBufferAddress(j_output_buffer));
     CHECK_EXCEPTION(jni);
 
     if (frames_encoded_ < kMaxEncodedLogFrames) {
@@ skipping 142 matching lines @@
     if (callback_status > 0) {
       drop_next_input_frame_ = true;
       // Theoretically could handle callback_status<0 here, but unclear what
       // that would mean for us.
     }
   }
   return true;
 }
 
 void MediaCodecVideoEncoder::LogStatistics(bool force_log) {
-  int statistic_time_ms = GetCurrentTimeMs() - stat_start_time_ms_;
+  int statistic_time_ms = rtc::TimeMillis() - stat_start_time_ms_;
   if ((statistic_time_ms >= kMediaCodecStatisticsIntervalMs || force_log) &&
       current_frames_ > 0 && statistic_time_ms > 0) {
     int current_bitrate = current_bytes_ * 8 / statistic_time_ms;
     int current_fps =
         (current_frames_ * 1000 + statistic_time_ms / 2) / statistic_time_ms;
     ALOGD << "Encoded frames: " << frames_encoded_ <<
         ". Bitrate: " << current_bitrate <<
         ", target: " << last_set_bitrate_kbps_ << " kbps" <<
         ", fps: " << current_fps <<
         ", encTime: " << (current_encoding_time_ms_ / current_frames_) <<
         ". QP: " << (current_acc_qp_ / current_frames_) <<
         " for last " << statistic_time_ms << " ms.";
-    stat_start_time_ms_ = GetCurrentTimeMs();
+    stat_start_time_ms_ = rtc::TimeMillis();
     current_frames_ = 0;
     current_bytes_ = 0;
     current_acc_qp_ = 0;
     current_encoding_time_ms_ = 0;
   }
 }
 
 int32_t MediaCodecVideoEncoder::NextNaluPosition(
     uint8_t *buffer, size_t buffer_size) {
   if (buffer_size < H264_SC_LENGTH) {
@@ skipping 128 matching lines @@
   return supported_codecs_;
 }
 
 void MediaCodecVideoEncoderFactory::DestroyVideoEncoder(
     webrtc::VideoEncoder* encoder) {
   ALOGD << "Destroy video encoder.";
   delete encoder;
 }
 
 }  // namespace webrtc_jni