admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Delete all use of tick_util.h.

Browse Source 
Depends on Chrome cl https://codereview.chromium.org/1888003002/, which was landed some time ago.

BUG=webrtc:5740
R=stefan@webrtc.org, tommi@webrtc.org

Review URL: https://codereview.webrtc.org/1888593004 .

Cr-Commit-Position: refs/heads/master@{#12674}
This commit is contained in:
Niels Möller 2016-05-10 16:31:47 +02:00
parent b031a2e862
commit d28db7fd65
68 changed files with 269 additions and 518 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
webrtc/api/java/jni/androidmediacodeccommon.h
View File

@ -19,7 +19,6 @@
#include "webrtc/api/java/jni/jni_helpers.h"
#include "webrtc/base/logging.h"
#include "webrtc/base/thread.h"
#include "webrtc/system_wrappers/include/tick_util.h"
namespace webrtc_jni {
@ -59,10 +58,6 @@ enum { kMaxDecodedLogFrames = 10 };
// Maximum amount of encoded frames for which per-frame logging is enabled.
enum { kMaxEncodedLogFrames = 10 };
static inline int64_t GetCurrentTimeMs() {
return webrtc::TickTime::Now().Ticks() / 1000000LL;
}
static inline void AllowBlockingCalls() {
rtc::Thread* current_thread = rtc::Thread::Current();
if (current_thread != NULL)

13
webrtc/api/java/jni/androidmediadecoder_jni.cc
View File

@ -32,7 +32,6 @@
#include "webrtc/common_video/include/i420_buffer_pool.h"
#include "webrtc/modules/video_coding/include/video_codec_interface.h"
#include "webrtc/system_wrappers/include/logcat_trace_context.h"
#include "webrtc/system_wrappers/include/tick_util.h"
using rtc::Bind;
using rtc::Thread;
@ -43,7 +42,6 @@ using webrtc::DecodedImageCallback;
using webrtc::EncodedImage;
using webrtc::VideoFrame;
using webrtc::RTPFragmentationHeader;
using webrtc::TickTime;
using webrtc::VideoCodec;
using webrtc::VideoCodecType;
using webrtc::kVideoCodecH264;
@ -319,7 +317,7 @@ void MediaCodecVideoDecoder::ResetVariables() {
frames_received_ = 0;
frames_decoded_ = 0;
frames_decoded_logged_ = kMaxDecodedLogFrames;
start_time_ms_ = GetCurrentTimeMs();
start_time_ms_ = rtc::TimeMillis();
current_frames_ = 0;
current_bytes_ = 0;
current_decoding_time_ms_ = 0;
@ -589,9 +587,9 @@ int32_t MediaCodecVideoDecoder::DecodeOnCodecThread(
frames_received_ << ". Decoded: " << frames_decoded_;
EnableFrameLogOnWarning();
}
const int64 drain_start = GetCurrentTimeMs();
const int64 drain_start = rtc::TimeMillis();
while ((frames_received_ > frames_decoded_ + max_pending_frames_) &&
(GetCurrentTimeMs() - drain_start) < kMediaCodecTimeoutMs) {
(rtc::TimeMillis() - drain_start) < kMediaCodecTimeoutMs) {
if (!DeliverPendingOutputs(jni, kMediaCodecPollMs)) {
ALOGE << "DeliverPendingOutputs error. Frames received: " <<
frames_received_ << ". Frames decoded: " << frames_decoded_;
@ -844,7 +842,7 @@ bool MediaCodecVideoDecoder::DeliverPendingOutputs(
current_frames_++;
current_decoding_time_ms_ += decode_time_ms;
current_delay_time_ms_ += frame_delayed_ms;
int statistic_time_ms = GetCurrentTimeMs() - start_time_ms_;
int statistic_time_ms = rtc::TimeMillis() - start_time_ms_;
if (statistic_time_ms >= kMediaCodecStatisticsIntervalMs &&
current_frames_ > 0) {
int current_bitrate = current_bytes_ * 8 / statistic_time_ms;
@ -857,7 +855,7 @@ bool MediaCodecVideoDecoder::DeliverPendingOutputs(
". DecTime: " << (current_decoding_time_ms_ / current_frames_) <<
". DelayTime: " << (current_delay_time_ms_ / current_frames_) <<
" for last " << statistic_time_ms << " ms.";
start_time_ms_ = GetCurrentTimeMs();
start_time_ms_ = rtc::TimeMillis();
current_frames_ = 0;
current_bytes_ = 0;
current_decoding_time_ms_ = 0;
@ -993,4 +991,3 @@ const char* MediaCodecVideoDecoder::ImplementationName() const {
}
} // namespace webrtc_jni

13
webrtc/api/java/jni/androidmediaencoder_jni.cc
View File

@ -27,6 +27,7 @@
#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"
@ -524,7 +525,7 @@ int32_t MediaCodecVideoEncoder::InitEncodeOnCodecThread(
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;
@ -612,7 +613,7 @@ int32_t MediaCodecVideoEncoder::EncodeOnCodecThread(
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
@ -698,7 +699,7 @@ int32_t MediaCodecVideoEncoder::EncodeOnCodecThread(
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;
@ -950,7 +951,7 @@ bool MediaCodecVideoEncoder::DeliverPendingOutputs(JNIEnv* jni) {
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();
}
@ -1113,7 +1114,7 @@ bool MediaCodecVideoEncoder::DeliverPendingOutputs(JNIEnv* jni) {
}
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;
@ -1126,7 +1127,7 @@ void MediaCodecVideoEncoder::LogStatistics(bool force_log) {
", 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;

4
webrtc/audio/audio_receive_stream.cc
View File

@ -18,9 +18,9 @@
#include "webrtc/audio/conversion.h"
#include "webrtc/base/checks.h"
#include "webrtc/base/logging.h"
#include "webrtc/base/timeutils.h"
#include "webrtc/modules/congestion_controller/include/congestion_controller.h"
#include "webrtc/modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h"
#include "webrtc/system_wrappers/include/tick_util.h"
#include "webrtc/voice_engine/channel_proxy.h"
#include "webrtc/voice_engine/include/voe_base.h"
#include "webrtc/voice_engine/include/voe_codec.h"
@ -230,7 +230,7 @@ bool AudioReceiveStream::DeliverRtp(const uint8_t* packet,
// video and shouldn't be mixed.
if (remote_bitrate_estimator_ &&
header.extension.hasTransportSequenceNumber) {
int64_t arrival_time_ms = TickTime::MillisecondTimestamp();
int64_t arrival_time_ms = rtc::TimeMillis();
if (packet_time.timestamp >= 0)
arrival_time_ms = (packet_time.timestamp + 500) / 1000;
size_t payload_size = length - header.headerLength;

12
webrtc/common_audio/resampler/push_sinc_resampler_unittest.cc
View File

@ -14,10 +14,10 @@
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "webrtc/base/timeutils.h"
#include "webrtc/common_audio/include/audio_util.h"
#include "webrtc/common_audio/resampler/push_sinc_resampler.h"
#include "webrtc/common_audio/resampler/sinusoidal_linear_chirp_source.h"
#include "webrtc/system_wrappers/include/tick_util.h"
#include "webrtc/typedefs.h"
namespace webrtc {
@ -86,16 +86,17 @@ void PushSincResamplerTest::ResampleBenchmarkTest(bool int_format) {
const double io_ratio = input_rate_ / static_cast<double>(output_rate_);
SincResampler sinc_resampler(io_ratio, SincResampler::kDefaultRequestSize,
&resampler_source);
TickTime start = TickTime::Now();
int64_t start = rtc::TimeNanos();
for (int i = 0; i < kResampleIterations; ++i) {
sinc_resampler.Resample(output_samples, resampled_destination.get());
}
double total_time_sinc_us = (TickTime::Now() - start).Microseconds();
double total_time_sinc_us =
(rtc::TimeNanos() - start) / rtc::kNumNanosecsPerMicrosec;
printf("SincResampler took %.2f us per frame.\n",
total_time_sinc_us / kResampleIterations);
PushSincResampler resampler(input_samples, output_samples);
start = TickTime::Now();
start = rtc::TimeNanos();
if (int_format) {
for (int i = 0; i < kResampleIterations; ++i) {
EXPECT_EQ(output_samples,
@ -113,7 +114,8 @@ void PushSincResamplerTest::ResampleBenchmarkTest(bool int_format) {
output_samples));
}
}
double total_time_us = (TickTime::Now() - start).Microseconds();
double total_time_us =
(rtc::TimeNanos() - start) / rtc::kNumNanosecsPerMicrosec;
printf("PushSincResampler took %.2f us per frame; which is a %.1f%% overhead "
"on SincResampler.\n\n", total_time_us / kResampleIterations,
(total_time_us - total_time_sinc_us) / total_time_sinc_us * 100);

20
webrtc/common_audio/resampler/sinc_resampler_unittest.cc
View File

@ -20,11 +20,11 @@
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "webrtc/base/timeutils.h"
#include "webrtc/common_audio/resampler/sinc_resampler.h"
#include "webrtc/common_audio/resampler/sinusoidal_linear_chirp_source.h"
#include "webrtc/system_wrappers/include/cpu_features_wrapper.h"
#include "webrtc/system_wrappers/include/stringize_macros.h"
#include "webrtc/system_wrappers/include/tick_util.h"
#include "webrtc/test/test_suite.h"
using testing::_;
@ -107,10 +107,11 @@ TEST(SincResamplerTest, DISABLED_SetRatioBench) {
SincResampler resampler(kSampleRateRatio, SincResampler::kDefaultRequestSize,
&mock_source);
TickTime start = TickTime::Now();
int64_t start = rtc::TimeNanos();
for (int i = 1; i < 10000; ++i)
resampler.SetRatio(1.0 / i);
double total_time_c_us = (TickTime::Now() - start).Microseconds();
double total_time_c_us =
(rtc::TimeNanos() - start) / rtc::kNumNanosecsPerMicrosec;
printf("SetRatio() took %.2fms.\n", total_time_c_us / 1000);
}
@ -179,13 +180,14 @@ TEST(SincResamplerTest, ConvolveBenchmark) {
printf("Benchmarking %d iterations:\n", kConvolveIterations);
// Benchmark Convolve_C().
TickTime start = TickTime::Now();
int64_t start = rtc::TimeNanos();
for (int i = 0; i < kConvolveIterations; ++i) {
resampler.Convolve_C(
resampler.kernel_storage_.get(), resampler.kernel_storage_.get(),
resampler.kernel_storage_.get(), kKernelInterpolationFactor);
}
double total_time_c_us = (TickTime::Now() - start).Microseconds();
double total_time_c_us =
(rtc::TimeNanos() - start) / rtc::kNumNanosecsPerMicrosec;
printf("Convolve_C took %.2fms.\n", total_time_c_us / 1000);
#if defined(CONVOLVE_FUNC)
@ -196,27 +198,27 @@ TEST(SincResamplerTest, ConvolveBenchmark) {
#endif
// Benchmark with unaligned input pointer.
start = TickTime::Now();
start = rtc::TimeNanos();
for (int j = 0; j < kConvolveIterations; ++j) {
resampler.CONVOLVE_FUNC(
resampler.kernel_storage_.get() + 1, resampler.kernel_storage_.get(),
resampler.kernel_storage_.get(), kKernelInterpolationFactor);
}
double total_time_optimized_unaligned_us =
(TickTime::Now() - start).Microseconds();
(rtc::TimeNanos() - start) / rtc::kNumNanosecsPerMicrosec;
printf(STRINGIZE(CONVOLVE_FUNC) "(unaligned) took %.2fms; which is %.2fx "
"faster than Convolve_C.\n", total_time_optimized_unaligned_us / 1000,
total_time_c_us / total_time_optimized_unaligned_us);
// Benchmark with aligned input pointer.
start = TickTime::Now();
start = rtc::TimeNanos();
for (int j = 0; j < kConvolveIterations; ++j) {
resampler.CONVOLVE_FUNC(
resampler.kernel_storage_.get(), resampler.kernel_storage_.get(),
resampler.kernel_storage_.get(), kKernelInterpolationFactor);
}
double total_time_optimized_aligned_us =
(TickTime::Now() - start).Microseconds();
(rtc::TimeNanos() - start) / rtc::kNumNanosecsPerMicrosec;
printf(STRINGIZE(CONVOLVE_FUNC) " (aligned) took %.2fms; which is %.2fx "
"faster than Convolve_C and %.2fx faster than "
STRINGIZE(CONVOLVE_FUNC) " (unaligned).\n",

4
webrtc/common_video/incoming_video_stream.cc
View File

@ -22,11 +22,11 @@
#endif
#include "webrtc/base/platform_thread.h"
#include "webrtc/base/timeutils.h"
#include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
#include "webrtc/common_video/video_render_frames.h"
#include "webrtc/system_wrappers/include/critical_section_wrapper.h"
#include "webrtc/system_wrappers/include/event_wrapper.h"
#include "webrtc/system_wrappers/include/tick_util.h"
#include "webrtc/system_wrappers/include/trace.h"
namespace webrtc {
@ -56,7 +56,7 @@ void IncomingVideoStream::OnFrame(const VideoFrame& video_frame) {
// Rate statistics.
num_frames_since_last_calculation_++;
int64_t now_ms = TickTime::MillisecondTimestamp();
int64_t now_ms = rtc::TimeMillis();
if (now_ms >= last_rate_calculation_time_ms_ + kFrameRatePeriodMs) {
incoming_rate_ =
static_cast<uint32_t>(1000 * num_frames_since_last_calculation_ /

1
webrtc/common_video/libyuv/libyuv_unittest.cc
View File

@ -15,7 +15,6 @@
#include "testing/gtest/include/gtest/gtest.h"
#include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
#include "webrtc/system_wrappers/include/tick_util.h"
#include "webrtc/test/testsupport/fileutils.h"
#include "webrtc/video_frame.h"

6
webrtc/common_video/libyuv/scaler_unittest.cc
View File

@ -14,8 +14,8 @@
#include <memory>
#include "testing/gtest/include/gtest/gtest.h"
#include "webrtc/base/timeutils.h"
#include "webrtc/common_video/libyuv/include/scaler.h"
#include "webrtc/system_wrappers/include/tick_util.h"
#include "webrtc/test/testsupport/fileutils.h"
namespace webrtc {
@ -378,9 +378,9 @@ void TestScaler::ScaleSequence(ScaleMethod method,
(src_width + 1) / 2,
kVideoRotation_0);
start_clock = TickTime::MillisecondTimestamp();
start_clock = rtc::TimeMillis();
EXPECT_EQ(0, test_scaler_.Scale(input_frame, &output_frame));
total_clock += TickTime::MillisecondTimestamp() - start_clock;
total_clock += rtc::TimeMillis() - start_clock;
if (PrintVideoFrame(output_frame, output_file) < 0) {
return;
}

6
webrtc/common_video/video_render_frames.cc
View File

@ -12,8 +12,8 @@
#include <assert.h>
#include "webrtc/base/timeutils.h"
#include "webrtc/modules/include/module_common_types.h"
#include "webrtc/system_wrappers/include/tick_util.h"
#include "webrtc/system_wrappers/include/trace.h"
namespace webrtc {
@ -27,7 +27,7 @@ VideoRenderFrames::VideoRenderFrames()
}
int32_t VideoRenderFrames::AddFrame(const VideoFrame& new_frame) {
const int64_t time_now = TickTime::MillisecondTimestamp();
const int64_t time_now = rtc::TimeMillis();
// Drop old frames only when there are other frames in the queue, otherwise, a
// really slow system never renders any frames.
@ -74,7 +74,7 @@ uint32_t VideoRenderFrames::TimeToNextFrameRelease() {
}
const int64_t time_to_release = incoming_frames_.front().render_time_ms() -
render_delay_ms_ -
TickTime::MillisecondTimestamp();
rtc::TimeMillis();
return time_to_release < 0 ? 0u : static_cast<uint32_t>(time_to_release);
}

1
webrtc/modules/audio_coding/acm2/acm_receiver.cc
View File

@ -26,7 +26,6 @@
#include "webrtc/modules/audio_coding/acm2/call_statistics.h"
#include "webrtc/modules/audio_coding/neteq/include/neteq.h"
#include "webrtc/system_wrappers/include/clock.h"
#include "webrtc/system_wrappers/include/tick_util.h"
#include "webrtc/system_wrappers/include/trace.h"
namespace webrtc {

6
webrtc/modules/audio_coding/test/APITest.cc
View File

@ -21,13 +21,13 @@
#include "testing/gtest/include/gtest/gtest.h"
#include "webrtc/base/platform_thread.h"
#include "webrtc/base/timeutils.h"
#include "webrtc/common.h"
#include "webrtc/common_types.h"
#include "webrtc/engine_configurations.h"
#include "webrtc/modules/audio_coding/acm2/acm_common_defs.h"
#include "webrtc/modules/audio_coding/test/utility.h"
#include "webrtc/system_wrappers/include/event_wrapper.h"
#include "webrtc/system_wrappers/include/tick_util.h"
#include "webrtc/system_wrappers/include/trace.h"
#include "webrtc/test/testsupport/fileutils.h"
@ -560,7 +560,7 @@ void APITest::Perform() {
// Keep main thread waiting for sender/receiver
// threads to complete
EventWrapper* completeEvent = EventWrapper::Create();
uint64_t startTime = TickTime::MillisecondTimestamp();
uint64_t startTime = rtc::TimeMillis();
uint64_t currentTime;
// Run test in 2 minutes (120000 ms).
do {
@ -570,7 +570,7 @@ void APITest::Perform() {
}
//fflush(stderr);
completeEvent->Wait(50);
currentTime = TickTime::MillisecondTimestamp();
currentTime = rtc::TimeMillis();
} while ((currentTime - startTime) < 120000);
//completeEvent->Wait(0xFFFFFFFF);

8
webrtc/modules/audio_coding/test/Channel.cc
View File

@ -14,7 +14,7 @@
#include <iostream>
#include "webrtc/base/format_macros.h"
#include "webrtc/system_wrappers/include/tick_util.h"
#include "webrtc/base/timeutils.h"
namespace webrtc {
@ -234,7 +234,7 @@ Channel::Channel(int16_t chID)
_lastFrameSizeSample(0),
_packetLoss(0),
_useFECTestWithPacketLoss(false),
_beginTime(TickTime::MillisecondTimestamp()),
_beginTime(rtc::TimeMillis()),
_totalBytes(0),
external_send_timestamp_(-1),
external_sequence_number_(-1),
@ -286,7 +286,7 @@ void Channel::ResetStats() {
_payloadStats[n].frameSizeStats[k].totalEncodedSamples = 0;
}
}
_beginTime = TickTime::MillisecondTimestamp();
_beginTime = rtc::TimeMillis();
_totalBytes = 0;
_channelCritSect.Leave();
}
@ -411,7 +411,7 @@ uint32_t Channel::LastInTimestamp() {
double Channel::BitRate() {
double rate;
uint64_t currTime = TickTime::MillisecondTimestamp();
uint64_t currTime = rtc::TimeMillis();
_channelCritSect.Enter();
rate = ((double) _totalBytes * 8.0) / (double) (currTime - _beginTime);
_channelCritSect.Leave();

1
webrtc/modules/audio_coding/test/iSACTest.cc
View File

@ -26,7 +26,6 @@
#include "webrtc/modules/audio_coding/acm2/acm_common_defs.h"
#include "webrtc/modules/audio_coding/test/utility.h"
#include "webrtc/system_wrappers/include/event_wrapper.h"
#include "webrtc/system_wrappers/include/tick_util.h"
#include "webrtc/system_wrappers/include/trace.h"
#include "webrtc/test/testsupport/fileutils.h"

17
webrtc/modules/audio_conference_mixer/source/time_scheduler.cc
View File

@ -8,6 +8,7 @@
* be found in the AUTHORS file in the root of the source tree.
*/
#include "webrtc/base/timeutils.h"
#include "webrtc/modules/audio_conference_mixer/source/time_scheduler.h"
#include "webrtc/system_wrappers/include/critical_section_wrapper.h"
@ -17,7 +18,7 @@ TimeScheduler::TimeScheduler(const int64_t periodicityInMs)
_isStarted(false),
_lastPeriodMark(),
_periodicityInMs(periodicityInMs),
_periodicityInTicks(TickTime::MillisecondsToTicks(periodicityInMs)),
_periodicityInTicks(periodicityInMs * rtc::kNumNanosecsPerMillisec),
_missedPeriods(0)
{
}
@ -33,7 +34,7 @@ int32_t TimeScheduler::UpdateScheduler()
if(!_isStarted)
{
_isStarted = true;
_lastPeriodMark = TickTime::Now();
_lastPeriodMark = rtc::TimeNanos();
return 0;
}
// Don't perform any calculations until the debt of pending periods have
@ -45,9 +46,9 @@ int32_t TimeScheduler::UpdateScheduler()
}
// Calculate the time that has past since previous call to this function.
TickTime tickNow = TickTime::Now();
TickInterval amassedTicks = tickNow - _lastPeriodMark;
int64_t amassedMs = amassedTicks.Milliseconds();
int64_t tickNow = rtc::TimeNanos();
int64_t amassedTicks = tickNow - _lastPeriodMark;
int64_t amassedMs = amassedTicks / rtc::kNumNanosecsPerMillisec;
// Calculate the number of periods the time that has passed correspond to.
int64_t periodsToClaim = amassedMs / _periodicityInMs;
@ -89,10 +90,10 @@ int32_t TimeScheduler::TimeToNextUpdate(
// Calculate the time (in ms) that has past since last call to
// UpdateScheduler()
TickTime tickNow = TickTime::Now();
TickInterval ticksSinceLastUpdate = tickNow - _lastPeriodMark;
int64_t tickNow = rtc::TimeNanos();
int64_t ticksSinceLastUpdate = tickNow - _lastPeriodMark;
const int64_t millisecondsSinceLastUpdate =
ticksSinceLastUpdate.Milliseconds();
ticksSinceLastUpdate / rtc::kNumNanosecsPerMillisec;
updateTimeInMS = _periodicityInMs - millisecondsSinceLastUpdate;
updateTimeInMS = (updateTimeInMS < 0) ? 0 : updateTimeInMS;

4
webrtc/modules/audio_conference_mixer/source/time_scheduler.h
View File

@ -15,8 +15,6 @@
#ifndef WEBRTC_MODULES_AUDIO_CONFERENCE_MIXER_SOURCE_TIME_SCHEDULER_H_
#define WEBRTC_MODULES_AUDIO_CONFERENCE_MIXER_SOURCE_TIME_SCHEDULER_H_
#include "webrtc/system_wrappers/include/tick_util.h"
namespace webrtc {
class CriticalSectionWrapper;
class TimeScheduler
@ -36,7 +34,7 @@ private:
CriticalSectionWrapper* _crit;
bool _isStarted;
TickTime _lastPeriodMark;
int64_t _lastPeriodMark; // In ns
int64_t _periodicityInMs;
int64_t _periodicityInTicks;

8
webrtc/modules/audio_device/audio_device_impl.cc
View File

@ -9,11 +9,11 @@
*/
#include "webrtc/base/refcount.h"
#include "webrtc/base/timeutils.h"
#include "webrtc/base/trace_event.h"
#include "webrtc/common_audio/signal_processing/include/signal_processing_library.h"
#include "webrtc/modules/audio_device/audio_device_config.h"
#include "webrtc/modules/audio_device/audio_device_impl.h"
#include "webrtc/system_wrappers/include/tick_util.h"
#include <assert.h>
#include <string.h>
@ -123,7 +123,7 @@ AudioDeviceModuleImpl::AudioDeviceModuleImpl(const int32_t id, const AudioLayer
_ptrAudioDevice(NULL),
_id(id),
_platformAudioLayer(audioLayer),
_lastProcessTime(TickTime::MillisecondTimestamp()),
_lastProcessTime(rtc::TimeMillis()),
_platformType(kPlatformNotSupported),
_initialized(false),
_lastError(kAdmErrNone)
@ -407,7 +407,7 @@ AudioDeviceModuleImpl::~AudioDeviceModuleImpl()
int64_t AudioDeviceModuleImpl::TimeUntilNextProcess()
{
int64_t now = TickTime::MillisecondTimestamp();
int64_t now = rtc::TimeMillis();
int64_t deltaProcess = kAdmMaxIdleTimeProcess - (now - _lastProcessTime);
return deltaProcess;
}
@ -422,7 +422,7 @@ int64_t AudioDeviceModuleImpl::TimeUntilNextProcess()
void AudioDeviceModuleImpl::Process()
{
_lastProcessTime = TickTime::MillisecondTimestamp();
_lastProcessTime = rtc::TimeMillis();
// kPlayoutWarning
if (_ptrAudioDevice->PlayoutWarning())

6
webrtc/modules/audio_device/win/audio_device_wave_win.cc
View File

@ -8,11 +8,11 @@
* be found in the AUTHORS file in the root of the source tree.
*/
#include "webrtc/base/timeutils.h"
#include "webrtc/modules/audio_device/audio_device_config.h"
#include "webrtc/modules/audio_device/win/audio_device_wave_win.h"
#include "webrtc/system_wrappers/include/event_wrapper.h"
#include "webrtc/system_wrappers/include/tick_util.h"
#include "webrtc/system_wrappers/include/trace.h"
#include <windows.h>
@ -206,7 +206,7 @@ int32_t AudioDeviceWindowsWave::Init()
return 0;
}
const uint32_t nowTime(TickTime::MillisecondTimestamp());
const uint32_t nowTime(rtc::TimeMillis());
_recordedBytes = 0;
_prevRecByteCheckTime = nowTime;
@ -3038,7 +3038,7 @@ bool AudioDeviceWindowsWave::ThreadProcess()
return true;
}
time = TickTime::MillisecondTimestamp();
time = rtc::TimeMillis();
if (_startPlay)
{

14
webrtc/modules/audio_processing/test/audio_file_processor.h
View File

@ -16,11 +16,11 @@
#include <memory>
#include <vector>
#include "webrtc/base/timeutils.h"
#include "webrtc/common_audio/channel_buffer.h"
#include "webrtc/common_audio/wav_file.h"
#include "webrtc/modules/audio_processing/include/audio_processing.h"
#include "webrtc/modules/audio_processing/test/test_utils.h"
#include "webrtc/system_wrappers/include/tick_util.h"
#ifdef WEBRTC_ANDROID_PLATFORM_BUILD
#include "external/webrtc/webrtc/modules/audio_processing/debug.pb.h"
@ -33,9 +33,9 @@ namespace webrtc {
// Holds a few statistics about a series of TickIntervals.
struct TickIntervalStats {
TickIntervalStats() : min(std::numeric_limits<int64_t>::max()) {}
TickInterval sum;
TickInterval max;
TickInterval min;
int64_t sum;
int64_t max;
int64_t min;
};
// Interface for processing an input file with an AudioProcessing instance and
@ -60,10 +60,10 @@ class AudioFileProcessor {
class ScopedTimer {
public:
explicit ScopedTimer(TickIntervalStats* proc_time)
: proc_time_(proc_time), start_time_(TickTime::Now()) {}
: proc_time_(proc_time), start_time_(rtc::TimeNanos()) {}
~ScopedTimer() {
TickInterval interval = TickTime::Now() - start_time_;
int64_t interval = rtc::TimeNanos() - start_time_;
proc_time_->sum += interval;
proc_time_->max = std::max(proc_time_->max, interval);
proc_time_->min = std::min(proc_time_->min, interval);
@ -71,7 +71,7 @@ class AudioFileProcessor {
private:
TickIntervalStats* const proc_time_;
TickTime start_time_;
int64_t start_time_;
};
TickIntervalStats* mutable_proc_time() { return &proc_time_; }

8
webrtc/modules/audio_processing/test/audioproc_float.cc
View File

@ -25,7 +25,6 @@
#include "webrtc/modules/audio_processing/test/audio_file_processor.h"
#include "webrtc/modules/audio_processing/test/protobuf_utils.h"
#include "webrtc/modules/audio_processing/test/test_utils.h"
#include "webrtc/system_wrappers/include/tick_util.h"
#include "webrtc/test/testsupport/trace_to_stderr.h"
namespace {
@ -167,13 +166,14 @@ int main(int argc, char* argv[]) {
if (FLAGS_perf) {
const auto& proc_time = processor->proc_time();
int64_t exec_time_us = proc_time.sum.Microseconds();
int64_t exec_time_us = proc_time.sum / rtc::kNumNanosecsPerMicrosec;
printf(
"\nExecution time: %.3f s, File time: %.2f s\n"
"Time per chunk (mean, max, min):\n%.0f us, %.0f us, %.0f us\n",
exec_time_us * 1e-6, num_chunks * 1.f / kChunksPerSecond,
exec_time_us * 1.f / num_chunks, 1.f * proc_time.max.Microseconds(),
1.f * proc_time.min.Microseconds());
exec_time_us * 1.f / num_chunks,
1.f * proc_time.max / rtc::kNumNanosecsPerMicrosec,
1.f * proc_time.min / rtc::kNumNanosecsPerMicrosec);
}
return 0;

78
webrtc/modules/audio_processing/test/process_test.cc
View File

@ -19,13 +19,13 @@
#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
@ -562,7 +562,7 @@ void void_main(int argc, char* argv[]) {
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;
@ -573,8 +573,8 @@ void void_main(int argc, char* argv[]) {
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;
@ -676,7 +676,7 @@ void void_main(int argc, char* argv[]) {
}
if (perf_testing) {
t0 = TickTime::Now();
t0 = rtc::TimeNanos();
}
if (msg.has_data()) {
@ -692,14 +692,15 @@ void void_main(int argc, char* argv[]) {
}
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;
}
}
@ -737,7 +738,7 @@ void void_main(int argc, char* argv[]) {
}
if (perf_testing) {
t0 = TickTime::Now();
t0 = rtc::TimeNanos();
}
ASSERT_EQ(apm->kNoError,
@ -795,14 +796,15 @@ void void_main(int argc, char* argv[]) {
}
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;
}
}
@ -925,21 +927,22 @@ void void_main(int argc, char* argv[]) {
}
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;
}
}
@ -982,7 +985,7 @@ void void_main(int argc, char* argv[]) {
}
if (perf_testing) {
t0 = TickTime::Now();
t0 = rtc::TimeNanos();
}
const int capture_level_in = capture_level;
@ -1030,14 +1033,15 @@ void void_main(int argc, char* argv[]) {
}
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;
}
}
@ -1130,7 +1134,7 @@ void void_main(int argc, char* argv[]) {
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),"

12
webrtc/modules/desktop_capture/mac/full_screen_chrome_window_detector.cc
View File

@ -15,6 +15,7 @@
#include <string>
#include "webrtc/base/macutils.h"
#include "webrtc/base/timeutils.h"
#include "webrtc/modules/desktop_capture/mac/window_list_utils.h"
#include "webrtc/system_wrappers/include/logging.h"
@ -141,7 +142,7 @@ bool IsChromeWindow(CGWindowID id) {
} // namespace
FullScreenChromeWindowDetector::FullScreenChromeWindowDetector()
: ref_count_(0) {}
: ref_count_(0), last_update_time_ns_(0) {}
FullScreenChromeWindowDetector::~FullScreenChromeWindowDetector() {}
@ -161,10 +162,7 @@ CGWindowID FullScreenChromeWindowDetector::FindFullScreenWindow(
if (static_cast<CGWindowID>(it->id) != full_screen_window_id)
continue;
int64_t time_interval =
(TickTime::Now() - last_udpate_time_).Milliseconds();
LOG(LS_WARNING) << "The full-screen window exists in the list, "
<< "which was updated " << time_interval << "ms ago.";
LOG(LS_WARNING) << "The full-screen window exists in the list.";
return kCGNullWindowID;
}
@ -174,7 +172,7 @@ CGWindowID FullScreenChromeWindowDetector::FindFullScreenWindow(
void FullScreenChromeWindowDetector::UpdateWindowListIfNeeded(
CGWindowID original_window) {
if (IsChromeWindow(original_window) &&
(TickTime::Now() - last_udpate_time_).Milliseconds()
(rtc::TimeNanos() - last_update_time_ns_) / rtc::kNumNanosecsPerMillisec
> kUpdateIntervalMs) {
previous_window_list_.clear();
previous_window_list_.swap(current_window_list_);
@ -186,7 +184,7 @@ void FullScreenChromeWindowDetector::UpdateWindowListIfNeeded(
}
GetWindowList(&current_window_list_);
last_udpate_time_ = TickTime::Now();
last_update_time_ns_ = rtc::TimeNanos();
}
}

3
webrtc/modules/desktop_capture/mac/full_screen_chrome_window_detector.h
View File

@ -16,7 +16,6 @@
#include "webrtc/base/constructormagic.h"
#include "webrtc/modules/desktop_capture/window_capturer.h"
#include "webrtc/system_wrappers/include/atomic32.h"
#include "webrtc/system_wrappers/include/tick_util.h"
namespace webrtc {
@ -60,7 +59,7 @@ class FullScreenChromeWindowDetector {
// full-screen window exists in the list) if Capture() is called too soon.
WindowCapturer::WindowList current_window_list_;
WindowCapturer::WindowList previous_window_list_;
TickTime last_udpate_time_;
int64_t last_update_time_ns_;
RTC_DISALLOW_COPY_AND_ASSIGN(FullScreenChromeWindowDetector);
};

7
webrtc/modules/desktop_capture/screen_capturer_mac.mm
View File

@ -25,6 +25,7 @@
#include "webrtc/base/checks.h"
#include "webrtc/base/constructormagic.h"
#include "webrtc/base/macutils.h"
#include "webrtc/base/timeutils.h"
#include "webrtc/modules/desktop_capture/desktop_capture_options.h"
#include "webrtc/modules/desktop_capture/desktop_frame.h"
#include "webrtc/modules/desktop_capture/desktop_geometry.h"
@ -36,7 +37,6 @@
#include "webrtc/modules/desktop_capture/screen_capturer_helper.h"
#include "webrtc/modules/desktop_capture/shared_desktop_frame.h"
#include "webrtc/system_wrappers/include/logging.h"
#include "webrtc/system_wrappers/include/tick_util.h"
namespace webrtc {
@ -384,7 +384,7 @@ void ScreenCapturerMac::Start(Callback* callback) {
}
void ScreenCapturerMac::Capture(const DesktopRegion& region_to_capture) {
TickTime capture_start_time = TickTime::Now();
int64_t capture_start_time_nanos = rtc::TimeNanos();
queue_.MoveToNextFrame();
RTC_DCHECK(!queue_.current_frame() || !queue_.current_frame()->IsShared());
@ -448,7 +448,8 @@ void ScreenCapturerMac::Capture(const DesktopRegion& region_to_capture) {
desktop_config_monitor_->Unlock();
new_frame->set_capture_time_ms(
(TickTime::Now() - capture_start_time).Milliseconds());
(rtc::TimeNanos() - capture_start_time_nanos) /
rtc::kNumNanosecsPerMillisec);
callback_->OnCaptureCompleted(new_frame);
}

7
webrtc/modules/desktop_capture/screen_capturer_x11.cc
View File

@ -22,6 +22,7 @@
#include "webrtc/base/checks.h"
#include "webrtc/base/constructormagic.h"
#include "webrtc/base/timeutils.h"
#include "webrtc/modules/desktop_capture/desktop_capture_options.h"
#include "webrtc/modules/desktop_capture/desktop_frame.h"
#include "webrtc/modules/desktop_capture/differ.h"
@ -30,7 +31,6 @@
#include "webrtc/modules/desktop_capture/shared_desktop_frame.h"
#include "webrtc/modules/desktop_capture/x11/x_server_pixel_buffer.h"
#include "webrtc/system_wrappers/include/logging.h"
#include "webrtc/system_wrappers/include/tick_util.h"
namespace webrtc {
namespace {
@ -236,7 +236,7 @@ void ScreenCapturerLinux::Start(Callback* callback) {
}
void ScreenCapturerLinux::Capture(const DesktopRegion& region) {
TickTime capture_start_time = TickTime::Now();
int64_t capture_start_time_nanos = rtc::TimeNanos();
queue_.MoveToNextFrame();
RTC_DCHECK(!queue_.current_frame() || !queue_.current_frame()->IsShared());
@ -277,7 +277,8 @@ void ScreenCapturerLinux::Capture(const DesktopRegion& region) {
DesktopFrame* result = CaptureScreen();
last_invalid_region_ = result->updated_region();
result->set_capture_time_ms(
(TickTime::Now() - capture_start_time).Milliseconds());
(rtc::TimeNanos() - capture_start_time_nanos) /
rtc::kNumNanosecsPerMillisec);
callback_->OnCaptureCompleted(result);
}

7
webrtc/modules/desktop_capture/win/screen_capturer_win_gdi.cc
View File

@ -15,6 +15,7 @@
#include <utility>
#include "webrtc/base/checks.h"
#include "webrtc/base/timeutils.h"
#include "webrtc/modules/desktop_capture/desktop_capture_options.h"
#include "webrtc/modules/desktop_capture/desktop_frame.h"
#include "webrtc/modules/desktop_capture/desktop_frame_win.h"
@ -25,7 +26,6 @@
#include "webrtc/modules/desktop_capture/win/desktop.h"
#include "webrtc/modules/desktop_capture/win/screen_capture_utils.h"
#include "webrtc/system_wrappers/include/logging.h"
#include "webrtc/system_wrappers/include/tick_util.h"
namespace webrtc {
@ -79,7 +79,7 @@ void ScreenCapturerWinGdi::SetSharedMemoryFactory(
}
void ScreenCapturerWinGdi::Capture(const DesktopRegion& region) {
TickTime capture_start_time = TickTime::Now();
int64_t capture_start_time_nanos = rtc::TimeNanos();
queue_.MoveToNextFrame();
RTC_DCHECK(!queue_.current_frame() || !queue_.current_frame()->IsShared());
@ -137,7 +137,8 @@ void ScreenCapturerWinGdi::Capture(const DesktopRegion& region) {
frame->mutable_updated_region()->Clear();
helper_.TakeInvalidRegion(frame->mutable_updated_region());
frame->set_capture_time_ms(
(TickTime::Now() - capture_start_time).Milliseconds());
(rtc::TimeNanos() - capture_start_time_nanos) /
rtc::kNumNanosecsPerMillisec);
callback_->OnCaptureCompleted(frame);
}

7
webrtc/modules/desktop_capture/win/screen_capturer_win_magnifier.cc
View File

@ -14,6 +14,7 @@
#include <utility>
#include "webrtc/base/timeutils.h"
#include "webrtc/modules/desktop_capture/desktop_capture_options.h"
#include "webrtc/modules/desktop_capture/desktop_frame.h"
#include "webrtc/modules/desktop_capture/desktop_frame_win.h"
@ -24,7 +25,6 @@
#include "webrtc/modules/desktop_capture/win/desktop.h"
#include "webrtc/modules/desktop_capture/win/screen_capture_utils.h"
#include "webrtc/system_wrappers/include/logging.h"
#include "webrtc/system_wrappers/include/tick_util.h"
namespace webrtc {
@ -87,7 +87,7 @@ void ScreenCapturerWinMagnifier::SetSharedMemoryFactory(
}
void ScreenCapturerWinMagnifier::Capture(const DesktopRegion& region) {
TickTime capture_start_time = TickTime::Now();
int64_t capture_start_time_nanos = rtc::TimeNanos();
queue_.MoveToNextFrame();
@ -168,7 +168,8 @@ void ScreenCapturerWinMagnifier::Capture(const DesktopRegion& region) {
frame->mutable_updated_region()->Clear();
helper_.TakeInvalidRegion(frame->mutable_updated_region());
frame->set_capture_time_ms(
(TickTime::Now() - capture_start_time).Milliseconds());
(rtc::TimeNanos() - capture_start_time_nanos) /
rtc::kNumNanosecsPerMillisec);
callback_->OnCaptureCompleted(frame);
}

1
webrtc/modules/desktop_capture/window_capturer_mac.mm
View File

@ -24,7 +24,6 @@
#include "webrtc/modules/desktop_capture/mac/full_screen_chrome_window_detector.h"
#include "webrtc/modules/desktop_capture/mac/window_list_utils.h"
#include "webrtc/system_wrappers/include/logging.h"
#include "webrtc/system_wrappers/include/tick_util.h"
namespace webrtc {

1
webrtc/modules/media_file/media_file_impl.cc
View File

@ -14,7 +14,6 @@
#include "webrtc/modules/media_file/media_file_impl.h"
#include "webrtc/system_wrappers/include/critical_section_wrapper.h"
#include "webrtc/system_wrappers/include/file_wrapper.h"
#include "webrtc/system_wrappers/include/tick_util.h"
#include "webrtc/system_wrappers/include/trace.h"
namespace webrtc {

8
webrtc/modules/rtp_rtcp/source/rtp_sender.cc
View File

@ -17,6 +17,7 @@
#include "webrtc/base/checks.h"
#include "webrtc/base/logging.h"
#include "webrtc/base/trace_event.h"
#include "webrtc/base/timeutils.h"
#include "webrtc/call.h"
#include "webrtc/call/rtc_event_log.h"
#include "webrtc/modules/rtp_rtcp/include/rtp_cvo.h"
@ -24,7 +25,6 @@
#include "webrtc/modules/rtp_rtcp/source/rtp_sender_audio.h"
#include "webrtc/modules/rtp_rtcp/source/rtp_sender_video.h"
#include "webrtc/modules/rtp_rtcp/source/time_util.h"
#include "webrtc/system_wrappers/include/tick_util.h"
namespace webrtc {
@ -116,10 +116,8 @@ RTPSender::RTPSender(
RtcEventLog* event_log,
SendPacketObserver* send_packet_observer)
: clock_(clock),
// TODO(holmer): Remove this conversion when we remove the use of
// TickTime.
clock_delta_ms_(clock_->TimeInMilliseconds() -
TickTime::MillisecondTimestamp()),
// TODO(holmer): Remove this conversion?
clock_delta_ms_(clock_->TimeInMilliseconds() - rtc::TimeMillis()),
random_(clock_->TimeInMicroseconds()),
bitrates_(bitrate_callback),
total_bitrate_sent_(clock, bitrates_.total_bitrate_observer()),

6
webrtc/modules/rtp_rtcp/source/rtp_sender_audio.cc
View File

@ -13,10 +13,10 @@
#include <string.h>
#include "webrtc/base/logging.h"
#include "webrtc/base/timeutils.h"
#include "webrtc/base/trace_event.h"
#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
#include "webrtc/modules/rtp_rtcp/source/byte_io.h"
#include "webrtc/system_wrappers/include/tick_util.h"
namespace webrtc {
@ -351,7 +351,7 @@ int32_t RTPSenderAudio::SendAudio(FrameType frameType,
_rtpSender->SequenceNumber());
int32_t send_result = _rtpSender->SendToNetwork(
dataBuffer, payloadSize, rtpHeaderLength,
TickTime::MillisecondTimestamp(), kAllowRetransmission,
rtc::TimeMillis(), kAllowRetransmission,
RtpPacketSender::kHighPriority);
if (first_packet_sent_()) {
LOG(LS_INFO) << "First audio RTP packet sent to pacer";
@ -450,7 +450,7 @@ int32_t RTPSenderAudio::SendTelephoneEventPacket(bool ended,
"Audio::SendTelephoneEvent", "timestamp",
dtmfTimeStamp, "seqnum", _rtpSender->SequenceNumber());
retVal = _rtpSender->SendToNetwork(
dtmfbuffer, 4, 12, TickTime::MillisecondTimestamp(),
dtmfbuffer, 4, 12, rtc::TimeMillis(),
kAllowRetransmission, RtpPacketSender::kHighPriority);
sendCount--;
} while (sendCount > 0 && retVal == 0);

5
webrtc/modules/rtp_rtcp/source/ssrc_database.cc
View File

@ -9,9 +9,8 @@
*/
#include "webrtc/modules/rtp_rtcp/source/ssrc_database.h"
#include "webrtc/base/timeutils.h"
#include "webrtc/base/checks.h"
#include "webrtc/system_wrappers/include/tick_util.h"
namespace webrtc {
@ -45,7 +44,7 @@ void SSRCDatabase::ReturnSSRC(uint32_t ssrc) {
ssrcs_.erase(ssrc);
}
SSRCDatabase::SSRCDatabase() : random_(TickTime::Now().Ticks()) {}
SSRCDatabase::SSRCDatabase() : random_(rtc::TimeMicros()) {}
SSRCDatabase::~SSRCDatabase() {}

4
webrtc/modules/utility/include/file_recorder.h
View File

@ -15,7 +15,6 @@
#include "webrtc/engine_configurations.h"
#include "webrtc/modules/include/module_common_types.h"
#include "webrtc/modules/media_file/media_file_defines.h"
#include "webrtc/system_wrappers/include/tick_util.h"
#include "webrtc/typedefs.h"
#include "webrtc/video_frame.h"
@ -58,8 +57,7 @@ public:
// Write frame to file. Frame should contain 10ms of un-ecoded audio data.
virtual int32_t RecordAudioToFile(
const AudioFrame& frame,
const TickTime* playoutTS = NULL) = 0;
const AudioFrame& frame) = 0;
// Open/create the file specified by fileName for writing audio/video data
// (relative path is allowed). audioCodecInst specifies the encoding of the

1
webrtc/modules/utility/source/file_player_impl.h
View File

@ -19,7 +19,6 @@
#include "webrtc/modules/utility/include/file_player.h"
#include "webrtc/modules/utility/source/coder.h"
#include "webrtc/system_wrappers/include/critical_section_wrapper.h"
#include "webrtc/system_wrappers/include/tick_util.h"
#include "webrtc/typedefs.h"
namespace webrtc {

3
webrtc/modules/utility/source/file_recorder_impl.cc
View File

@ -130,8 +130,7 @@ bool FileRecorderImpl::IsRecording() const
}
int32_t FileRecorderImpl::RecordAudioToFile(
const AudioFrame& incomingAudioFrame,
const TickTime* playoutTS)
const AudioFrame& incomingAudioFrame)
{
if (codec_info_.plfreq == 0)
{

5
webrtc/modules/utility/source/file_recorder_impl.h
View File

@ -27,7 +27,6 @@
#include "webrtc/modules/utility/include/file_recorder.h"
#include "webrtc/modules/utility/source/coder.h"
#include "webrtc/system_wrappers/include/event_wrapper.h"
#include "webrtc/system_wrappers/include/tick_util.h"
#include "webrtc/typedefs.h"
namespace webrtc {
@ -58,9 +57,7 @@ public:
int32_t StopRecording() override;
bool IsRecording() const override;
int32_t codec_info(CodecInst& codecInst) const override;
int32_t RecordAudioToFile(
const AudioFrame& frame,
const TickTime* playoutTS = NULL) override;
int32_t RecordAudioToFile(const AudioFrame& frame) override;
int32_t StartRecordingVideoFile(
const char* fileName,
const CodecInst& audioCodecInst,

8
webrtc/modules/utility/source/process_thread_impl.cc
View File

@ -11,9 +11,9 @@
#include "webrtc/modules/utility/source/process_thread_impl.h"
#include "webrtc/base/checks.h"
#include "webrtc/base/timeutils.h"
#include "webrtc/modules/include/module.h"
#include "webrtc/system_wrappers/include/logging.h"
#include "webrtc/system_wrappers/include/tick_util.h"
namespace webrtc {
namespace {
@ -188,7 +188,7 @@ bool ProcessThreadImpl::Run(void* obj) {
}
bool ProcessThreadImpl::Process() {
int64_t now = TickTime::MillisecondTimestamp();
int64_t now = rtc::TimeMillis();
int64_t next_checkpoint = now + (1000 * 60);
{
@ -209,7 +209,7 @@ bool ProcessThreadImpl::Process() {
// Use a new 'now' reference to calculate when the next callback
// should occur. We'll continue to use 'now' above for the baseline
// of calculating how long we should wait, to reduce variance.
int64_t new_now = TickTime::MillisecondTimestamp();
int64_t new_now = rtc::TimeMillis();
m.next_callback = GetNextCallbackTime(m.module, new_now);
}
@ -227,7 +227,7 @@ bool ProcessThreadImpl::Process() {
}
}
int64_t time_to_wait = next_checkpoint - TickTime::MillisecondTimestamp();
int64_t time_to_wait = next_checkpoint - rtc::TimeMillis();
if (time_to_wait > 0)
wake_up_->Wait(static_cast<unsigned long>(time_to_wait));

4
webrtc/modules/utility/source/process_thread_impl_unittest.cc
View File

@ -13,9 +13,9 @@
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "webrtc/base/timeutils.h"
#include "webrtc/modules/include/module.h"
#include "webrtc/modules/utility/source/process_thread_impl.h"
#include "webrtc/system_wrappers/include/tick_util.h"
namespace webrtc {
@ -51,7 +51,7 @@ ACTION_P(Increment, counter) {
}
ACTION_P(SetTimestamp, ptr) {
*ptr = TickTime::MillisecondTimestamp();
*ptr = rtc::TimeMillis();
}
TEST(ProcessThreadImpl, StartStop) {

29
webrtc/modules/video_capture/test/video_capture_unittest.cc
View File

@ -16,19 +16,18 @@
#include "testing/gtest/include/gtest/gtest.h"
#include "webrtc/base/scoped_ref_ptr.h"
#include "webrtc/base/timeutils.h"
#include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
#include "webrtc/modules/utility/include/process_thread.h"
#include "webrtc/modules/video_capture/video_capture.h"
#include "webrtc/modules/video_capture/video_capture_factory.h"
#include "webrtc/system_wrappers/include/critical_section_wrapper.h"
#include "webrtc/system_wrappers/include/sleep.h"
#include "webrtc/system_wrappers/include/tick_util.h"
#include "webrtc/video_frame.h"
using webrtc::CriticalSectionWrapper;
using webrtc::CriticalSectionScoped;
using webrtc::SleepMs;
using webrtc::TickTime;
using webrtc::VideoCaptureAlarm;
using webrtc::VideoCaptureCapability;
using webrtc::VideoCaptureDataCallback;
@ -40,8 +39,8 @@ using webrtc::VideoCaptureModule;
#define WAIT_(ex, timeout, res) \
do { \
res = (ex); \
int64_t start = TickTime::MillisecondTimestamp(); \
while (!res && TickTime::MillisecondTimestamp() < start + timeout) { \
int64_t start = rtc::TimeMillis(); \
while (!res && rtc::TimeMillis() < start + timeout) { \
SleepMs(5); \
res = (ex); \
} \
@ -118,8 +117,8 @@ class TestVideoCaptureCallback : public VideoCaptureDataCallback {
#endif
// RenderTimstamp should be the time now.
EXPECT_TRUE(
videoFrame.render_time_ms() >= TickTime::MillisecondTimestamp()-30 &&
videoFrame.render_time_ms() <= TickTime::MillisecondTimestamp());
videoFrame.render_time_ms() >= rtc::TimeMillis()-30 &&
videoFrame.render_time_ms() <= rtc::TimeMillis());
if ((videoFrame.render_time_ms() >
last_render_time_ms_ + (1000 * 1.1) / capability_.maxFPS &&
@ -277,7 +276,7 @@ class VideoCaptureTest : public testing::Test {
#endif
TEST_F(VideoCaptureTest, MAYBE_CreateDelete) {
for (int i = 0; i < 5; ++i) {
int64_t start_time = TickTime::MillisecondTimestamp();
int64_t start_time = rtc::TimeMillis();
TestVideoCaptureCallback capture_observer;
rtc::scoped_refptr<VideoCaptureModule> module(
OpenVideoCaptureDevice(0, &capture_observer));
@ -296,19 +295,19 @@ TEST_F(VideoCaptureTest, MAYBE_CreateDelete) {
ASSERT_NO_FATAL_FAILURE(StartCapture(module.get(), capability));
// Less than 4s to start the camera.
EXPECT_LE(TickTime::MillisecondTimestamp() - start_time, 4000);
EXPECT_LE(rtc::TimeMillis() - start_time, 4000);
// Make sure 5 frames are captured.
EXPECT_TRUE_WAIT(capture_observer.incoming_frames() >= 5, kTimeOut);
EXPECT_GE(capture_observer.capture_delay(), 0);
int64_t stop_time = TickTime::MillisecondTimestamp();
int64_t stop_time = rtc::TimeMillis();
EXPECT_EQ(0, module->StopCapture());
EXPECT_FALSE(module->CaptureStarted());
// Less than 3s to stop the camera.
EXPECT_LE(TickTime::MillisecondTimestamp() - stop_time, 3000);
EXPECT_LE(rtc::TimeMillis() - stop_time, 3000);
}
}
@ -492,10 +491,10 @@ TEST_F(VideoCaptureExternalTest, TestExternalCapture) {
#define MAYBE_FrameRate FrameRate
#endif
TEST_F(VideoCaptureExternalTest, MAYBE_FrameRate) {
int64_t testTime = 3;
TickTime startTime = TickTime::Now();
uint64_t testTime = 3 * rtc::kNumNanosecsPerSec;
uint64_t startTime = rtc::TimeNanos();
while ((TickTime::Now() - startTime).Milliseconds() < testTime * 1000) {
while ((rtc::TimeNanos() - startTime) < testTime) {
size_t length = webrtc::CalcBufferSize(webrtc::kI420,
test_frame_.width(),
test_frame_.height());
@ -510,8 +509,8 @@ TEST_F(VideoCaptureExternalTest, MAYBE_FrameRate) {
SleepMs(500);
EXPECT_EQ(webrtc::Raised, capture_feedback_.alarm());
startTime = TickTime::Now();
while ((TickTime::Now() - startTime).Milliseconds() < testTime * 1000) {
startTime = rtc::TimeNanos();
while ((rtc::TimeNanos() - startTime) < testTime) {
size_t length = webrtc::CalcBufferSize(webrtc::kI420,
test_frame_.width(),
test_frame_.height());

52
webrtc/modules/video_capture/video_capture_impl.cc
View File

@ -13,6 +13,7 @@
#include <stdlib.h>
#include "webrtc/base/refcount.h"
#include "webrtc/base/timeutils.h"
#include "webrtc/base/trace_event.h"
#include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
#include "webrtc/modules/include/module_common_types.h"
@ -20,7 +21,6 @@
#include "webrtc/system_wrappers/include/clock.h"
#include "webrtc/system_wrappers/include/critical_section_wrapper.h"
#include "webrtc/system_wrappers/include/logging.h"
#include "webrtc/system_wrappers/include/tick_util.h"
namespace webrtc {
namespace videocapturemodule {
@ -85,7 +85,8 @@ int64_t VideoCaptureImpl::TimeUntilNextProcess()
CriticalSectionScoped cs(&_callBackCs);
const int64_t kProcessIntervalMs = 300;
return kProcessIntervalMs -
(TickTime::Now() - _lastProcessTime).Milliseconds();
(rtc::TimeNanos() - _lastProcessTimeNanos) /
rtc::kNumNanosecsPerMillisec;
}
// Process any pending tasks such as timeouts
@ -93,12 +94,12 @@ void VideoCaptureImpl::Process()
{
CriticalSectionScoped cs(&_callBackCs);
const TickTime now = TickTime::Now();
_lastProcessTime = TickTime::Now();
const int64_t now_ns = rtc::TimeNanos();
_lastProcessTimeNanos = rtc::TimeNanos();
// Handle No picture alarm
if (_lastProcessFrameCount.Ticks() == _incomingFrameTimes[0].Ticks() &&
if (_lastProcessFrameTimeNanos == _incomingFrameTimesNanos[0] &&
_captureAlarm != Raised)
{
if (_noPictureAlarmCallBack && _captureCallBack)
@ -107,7 +108,7 @@ void VideoCaptureImpl::Process()
_captureCallBack->OnNoPictureAlarm(_id, _captureAlarm);
}
}
else if (_lastProcessFrameCount.Ticks() != _incomingFrameTimes[0].Ticks() &&
else if (_lastProcessFrameTimeNanos != _incomingFrameTimesNanos[0] &&
_captureAlarm != Cleared)
{
if (_noPictureAlarmCallBack && _captureCallBack)
@ -119,19 +120,21 @@ void VideoCaptureImpl::Process()
}
// Handle frame rate callback
if ((now - _lastFrameRateCallbackTime).Milliseconds()
if ((now_ns - _lastFrameRateCallbackTimeNanos) /
rtc::kNumNanosecsPerMillisec
> kFrameRateCallbackInterval)
{
if (_frameRateCallBack && _captureCallBack)
{
const uint32_t frameRate = CalculateFrameRate(now);
const uint32_t frameRate = CalculateFrameRate(now_ns);
_captureCallBack->OnCaptureFrameRate(_id, frameRate);
}
_lastFrameRateCallbackTime = now; // Can be set by EnableFrameRateCallback
// Can be set by EnableFrameRateCallback
_lastFrameRateCallbackTimeNanos = now_ns;
}
_lastProcessFrameCount = _incomingFrameTimes[0];
_lastProcessFrameTimeNanos = _incomingFrameTimesNanos[0];
}
VideoCaptureImpl::VideoCaptureImpl(const int32_t id)
@ -141,15 +144,15 @@ VideoCaptureImpl::VideoCaptureImpl(const int32_t id)
_captureDelay(0),
_requestedCapability(),
_callBackCs(*CriticalSectionWrapper::CreateCriticalSection()),
_lastProcessTime(TickTime::Now()),
_lastFrameRateCallbackTime(TickTime::Now()),
_lastProcessTimeNanos(rtc::TimeNanos()),
_lastFrameRateCallbackTimeNanos(rtc::TimeNanos()),
_frameRateCallBack(false),
_noPictureAlarmCallBack(false),
_captureAlarm(Cleared),
_setCaptureDelay(0),
_dataCallBack(NULL),
_captureCallBack(NULL),
_lastProcessFrameCount(TickTime::Now()),
_lastProcessFrameTimeNanos(rtc::TimeNanos()),
_rotateFrame(kVideoRotation_0),
apply_rotation_(false) {
_requestedCapability.width = kDefaultWidth;
@ -157,7 +160,7 @@ VideoCaptureImpl::VideoCaptureImpl(const int32_t id)
_requestedCapability.maxFPS = 30;
_requestedCapability.rawType = kVideoI420;
_requestedCapability.codecType = kVideoCodecUnknown;
memset(_incomingFrameTimes, 0, sizeof(_incomingFrameTimes));
memset(_incomingFrameTimesNanos, 0, sizeof(_incomingFrameTimesNanos));
}
VideoCaptureImpl::~VideoCaptureImpl()
@ -295,7 +298,7 @@ int32_t VideoCaptureImpl::IncomingFrame(
_captureFrame.set_rotation(kVideoRotation_0);
}
_captureFrame.set_ntp_time_ms(captureTime);
_captureFrame.set_render_time_ms(TickTime::MillisecondTimestamp());
_captureFrame.set_render_time_ms(rtc::TimeMillis());
DeliverCapturedFrame(_captureFrame);
}
@ -321,7 +324,7 @@ void VideoCaptureImpl::EnableFrameRateCallback(const bool enable) {
_frameRateCallBack = enable;
if (enable)
{
_lastFrameRateCallbackTime = TickTime::Now();
_lastFrameRateCallbackTimeNanos = rtc::TimeNanos();
}
}
@ -341,7 +344,7 @@ void VideoCaptureImpl::EnableNoPictureAlarm(const bool enable) {
void VideoCaptureImpl::UpdateFrameCount()
{
if (_incomingFrameTimes[0].MicrosecondTimestamp() == 0)
if (_incomingFrameTimesNanos[0] / rtc::kNumNanosecsPerMicrosec == 0)
{
// first no shift
}
@ -350,20 +353,22 @@ void VideoCaptureImpl::UpdateFrameCount()
// shift
for (int i = (kFrameRateCountHistorySize - 2); i >= 0; i--)
{
_incomingFrameTimes[i + 1] = _incomingFrameTimes[i];
_incomingFrameTimesNanos[i + 1] = _incomingFrameTimesNanos[i];
}
}
_incomingFrameTimes[0] = TickTime::Now();
_incomingFrameTimesNanos[0] = rtc::TimeNanos();
}
uint32_t VideoCaptureImpl::CalculateFrameRate(const TickTime& now)
uint32_t VideoCaptureImpl::CalculateFrameRate(int64_t now_ns)
{
int32_t num = 0;
int32_t nrOfFrames = 0;
for (num = 1; num < (kFrameRateCountHistorySize - 1); num++)
{
if (_incomingFrameTimes[num].Ticks() <= 0
|| (now - _incomingFrameTimes[num]).Milliseconds() > kFrameRateHistoryWindowMs) // don't use data older than 2sec
if (_incomingFrameTimesNanos[num] <= 0 ||
(now_ns - _incomingFrameTimesNanos[num]) /
rtc::kNumNanosecsPerMillisec >
kFrameRateHistoryWindowMs) // don't use data older than 2sec
{
break;
}
@ -374,7 +379,8 @@ uint32_t VideoCaptureImpl::CalculateFrameRate(const TickTime& now)
}
if (num > 1)
{
int64_t diff = (now - _incomingFrameTimes[num - 1]).Milliseconds();
int64_t diff = (now_ns - _incomingFrameTimesNanos[num - 1]) /
rtc::kNumNanosecsPerMillisec;
if (diff > 0)
{
return uint32_t((nrOfFrames * 1000.0f / diff) + 0.5f);

14
webrtc/modules/video_capture/video_capture_impl.h
View File

@ -20,7 +20,6 @@
#include "webrtc/common_video/rotation.h"
#include "webrtc/modules/video_capture/video_capture.h"
#include "webrtc/modules/video_capture/video_capture_config.h"
#include "webrtc/system_wrappers/include/tick_util.h"
#include "webrtc/video_frame.h"
namespace webrtc
@ -116,12 +115,14 @@ protected:
VideoCaptureCapability _requestedCapability; // Should be set by platform dependent code in StartCapture.
private:
void UpdateFrameCount();
uint32_t CalculateFrameRate(const TickTime& now);
uint32_t CalculateFrameRate(int64_t now_ns);
CriticalSectionWrapper& _callBackCs;
TickTime _lastProcessTime; // last time the module process function was called.
TickTime _lastFrameRateCallbackTime; // last time the frame rate callback function was called.
// last time the module process function was called.
int64_t _lastProcessTimeNanos;
// last time the frame rate callback function was called.
int64_t _lastFrameRateCallbackTimeNanos;
bool _frameRateCallBack; // true if EnableFrameRateCallback
bool _noPictureAlarmCallBack; //true if EnableNoPictureAlarm
VideoCaptureAlarm _captureAlarm; // current value of the noPictureAlarm
@ -130,8 +131,9 @@ private:
VideoCaptureDataCallback* _dataCallBack;
VideoCaptureFeedBack* _captureCallBack;
TickTime _lastProcessFrameCount;
TickTime _incomingFrameTimes[kFrameRateCountHistorySize];// timestamp for local captured frames
int64_t _lastProcessFrameTimeNanos;
// timestamp for local captured frames
int64_t _incomingFrameTimesNanos[kFrameRateCountHistorySize];
VideoRotation _rotateFrame; // Set if the frame should be rotated by the
// capture module.

20
webrtc/modules/video_coding/codecs/test/videoprocessor.cc
View File

@ -17,6 +17,7 @@
#include <memory>
#include <vector>
#include "webrtc/base/timeutils.h"
#include "webrtc/system_wrappers/include/cpu_info.h"
namespace webrtc {
@ -198,7 +199,7 @@ bool VideoProcessorImpl::ProcessFrame(int frame_number) {
// Ensure we have a new statistics data object we can fill:
FrameStatistic& stat = stats_->NewFrame(frame_number);
encode_start_ = TickTime::Now();
encode_start_ns_ = rtc::TimeNanos();
// Use the frame number as "timestamp" to identify frames
source_frame_.set_timestamp(frame_number);
@ -248,11 +249,11 @@ void VideoProcessorImpl::FrameEncoded(
encoded_frame_type_ = encoded_image._frameType;
TickTime encode_stop = TickTime::Now();
int64_t encode_stop_ns = rtc::TimeNanos();
int frame_number = encoded_image._timeStamp;
FrameStatistic& stat = stats_->stats_[frame_number];
stat.encode_time_in_us =
GetElapsedTimeMicroseconds(encode_start_, encode_stop);
GetElapsedTimeMicroseconds(encode_start_ns_, encode_stop_ns);
stat.encoding_successful = true;
stat.encoded_frame_length_in_bytes = encoded_image._length;
stat.frame_number = encoded_image._timeStamp;
@ -299,7 +300,7 @@ void VideoProcessorImpl::FrameEncoded(
// Keep track of if frames are lost due to packet loss so we can tell
// this to the encoder (this is handled by the RTP logic in the full stack)
decode_start_ = TickTime::Now();
decode_start_ns_ = rtc::TimeNanos();
// TODO(kjellander): Pass fragmentation header to the decoder when
// CL 172001 has been submitted and PacketManipulator supports this.
int32_t decode_result =
@ -315,12 +316,12 @@ void VideoProcessorImpl::FrameEncoded(
}
void VideoProcessorImpl::FrameDecoded(const VideoFrame& image) {
TickTime decode_stop = TickTime::Now();
int64_t decode_stop_ns = rtc::TimeNanos();
int frame_number = image.timestamp();
// Report stats
FrameStatistic& stat = stats_->stats_[frame_number];
stat.decode_time_in_us =
GetElapsedTimeMicroseconds(decode_start_, decode_stop);
GetElapsedTimeMicroseconds(decode_start_ns_, decode_stop_ns);
stat.decoding_successful = true;
// Check for resize action (either down or up):
@ -378,10 +379,9 @@ void VideoProcessorImpl::FrameDecoded(const VideoFrame& image) {
}
}
int VideoProcessorImpl::GetElapsedTimeMicroseconds(
const webrtc::TickTime& start,
const webrtc::TickTime& stop) {
uint64_t encode_time = (stop - start).Microseconds();
int VideoProcessorImpl::GetElapsedTimeMicroseconds(int64_t start,
int64_t stop) {
uint64_t encode_time = (stop - start) / rtc::kNumNanosecsPerMicrosec;
assert(encode_time <
static_cast<unsigned int>(std::numeric_limits<int>::max()));
return static_cast<int>(encode_time);

8
webrtc/modules/video_coding/codecs/test/videoprocessor.h
View File

@ -19,7 +19,6 @@
#include "webrtc/modules/video_coding/include/video_codec_interface.h"
#include "webrtc/modules/video_coding/codecs/test/packet_manipulator.h"
#include "webrtc/modules/video_coding/codecs/test/stats.h"
#include "webrtc/system_wrappers/include/tick_util.h"
#include "webrtc/test/testsupport/frame_reader.h"
#include "webrtc/test/testsupport/frame_writer.h"
#include "webrtc/video_frame.h"
@ -179,8 +178,7 @@ class VideoProcessorImpl : public VideoProcessor {
void FrameDecoded(const webrtc::VideoFrame& image);
// Used for getting a 32-bit integer representing time
// (checks the size is within signed 32-bit bounds before casting it)
int GetElapsedTimeMicroseconds(const webrtc::TickTime& start,
const webrtc::TickTime& stop);
int GetElapsedTimeMicroseconds(int64_t start, int64_t stop);
// Updates the encoder with the target bit rate and the frame rate.
void SetRates(int bit_rate, int frame_rate) override;
// Return the size of the encoded frame in bytes.
@ -225,8 +223,8 @@ class VideoProcessorImpl : public VideoProcessor {
// Statistics
double bit_rate_factor_; // multiply frame length with this to get bit rate
webrtc::TickTime encode_start_;
webrtc::TickTime decode_start_;
int64_t encode_start_ns_;
int64_t decode_start_ns_;
// Callback class required to implement according to the VideoEncoder API.
class VideoProcessorEncodeCompleteCallback

10
webrtc/modules/video_coding/codecs/vp8/test/vp8_impl_unittest.cc
View File

@ -14,9 +14,9 @@
#include "testing/gtest/include/gtest/gtest.h"
#include "webrtc/base/checks.h"
#include "webrtc/base/timeutils.h"
#include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
#include "webrtc/modules/video_coding/codecs/vp8/include/vp8.h"
#include "webrtc/system_wrappers/include/tick_util.h"
#include "webrtc/test/testsupport/fileutils.h"
namespace webrtc {
@ -159,8 +159,8 @@ class TestVp8Impl : public ::testing::Test {
}
size_t WaitForEncodedFrame() const {
int64_t startTime = TickTime::MillisecondTimestamp();
while (TickTime::MillisecondTimestamp() - startTime < kMaxWaitEncTimeMs) {
int64_t startTime = rtc::TimeMillis();
while (rtc::TimeMillis() - startTime < kMaxWaitEncTimeMs) {
if (encode_complete_callback_->EncodeComplete()) {
return encoded_frame_._length;
}
@ -169,8 +169,8 @@ class TestVp8Impl : public ::testing::Test {
}
size_t WaitForDecodedFrame() const {
int64_t startTime = TickTime::MillisecondTimestamp();
while (TickTime::MillisecondTimestamp() - startTime < kMaxWaitDecTimeMs) {
int64_t startTime = rtc::TimeMillis();
while (rtc::TimeMillis() - startTime < kMaxWaitDecTimeMs) {
if (decode_complete_callback_->DecodeComplete()) {
return CalcBufferSize(kI420, decoded_frame_.width(),
decoded_frame_.height());

4
webrtc/modules/video_coding/codecs/vp8/vp8_impl.cc
View File

@ -20,6 +20,7 @@
#include "libyuv/convert.h" // NOLINT
#include "webrtc/base/checks.h"
#include "webrtc/base/timeutils.h"
#include "webrtc/base/trace_event.h"
#include "webrtc/common_types.h"
#include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
@ -29,7 +30,6 @@
#include "webrtc/modules/video_coding/codecs/vp8/screenshare_layers.h"
#include "webrtc/modules/video_coding/codecs/vp8/temporal_layers.h"
#include "webrtc/system_wrappers/include/clock.h"
#include "webrtc/system_wrappers/include/tick_util.h"
namespace webrtc {
namespace {
@ -166,7 +166,7 @@ VP8EncoderImpl::VP8EncoderImpl()
tl1_frame_dropper_(kTl1MaxTimeToDropFrames),
key_frame_request_(kMaxSimulcastStreams, false),
quality_scaler_enabled_(false) {
uint32_t seed = static_cast<uint32_t>(TickTime::MillisecondTimestamp());
uint32_t seed = rtc::Time32();
srand(seed);
picture_id_.reserve(kMaxSimulcastStreams);

6
webrtc/modules/video_coding/codecs/vp8/vp8_sequence_coder.cc
View File

@ -12,10 +12,10 @@
#include "testing/gtest/include/gtest/gtest.h"
#include "webrtc/base/checks.h"
#include "webrtc/base/timeutils.h"
#include "webrtc/common_video/include/video_image.h"
#include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
#include "webrtc/modules/video_coding/codecs/vp8/include/vp8.h"
#include "webrtc/system_wrappers/include/tick_util.h"
#include "webrtc/test/testsupport/fileutils.h"
#include "webrtc/test/testsupport/metrics/video_metrics.h"
#include "webrtc/tools/simple_command_line_parser.h"
@ -158,7 +158,7 @@ int SequenceCoder(webrtc::test::CommandLineParser* parser) {
decoder->RegisterDecodeCompleteCallback(&decoder_callback);
// Read->Encode->Decode sequence.
// num_frames = -1 implies unlimited encoding (entire sequence).
int64_t starttime = webrtc::TickTime::MillisecondTimestamp();
int64_t starttime = rtc::TimeMillis();
int frame_cnt = 1;
int frames_processed = 0;
input_frame.CreateEmptyFrame(width, height, width, half_width, half_width);
@ -176,7 +176,7 @@ int SequenceCoder(webrtc::test::CommandLineParser* parser) {
++frame_cnt;
}
printf("\nProcessed %d frames\n", frames_processed);
int64_t endtime = webrtc::TickTime::MillisecondTimestamp();
int64_t endtime = rtc::TimeMillis();
int64_t totalExecutionTime = endtime - starttime;
printf("Total execution time: %.2lf ms\n",
static_cast<double>(totalExecutionTime));

4
webrtc/modules/video_coding/codecs/vp9/vp9_impl.cc
View File

@ -22,13 +22,13 @@
#include "vpx/vp8dx.h"
#include "webrtc/base/checks.h"
#include "webrtc/base/timeutils.h"
#include "webrtc/base/keep_ref_until_done.h"
#include "webrtc/base/logging.h"
#include "webrtc/base/trace_event.h"
#include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
#include "webrtc/modules/include/module_common_types.h"
#include "webrtc/modules/video_coding/codecs/vp9/screenshare_layers.h"
#include "webrtc/system_wrappers/include/tick_util.h"
namespace webrtc {
@ -77,7 +77,7 @@ VP9EncoderImpl::VP9EncoderImpl()
// Use two spatial when screensharing with flexible mode.
spatial_layer_(new ScreenshareLayersVP9(2)) {
memset(&codec_, 0, sizeof(codec_));
uint32_t seed = static_cast<uint32_t>(TickTime::MillisecondTimestamp());
uint32_t seed = rtc::Time32();
srand(seed);
}

4
webrtc/modules/video_coding/utility/ivf_file_writer_unittest.cc
View File

@ -14,8 +14,8 @@
#include "testing/gtest/include/gtest/gtest.h"
#include "webrtc/base/logging.h"
#include "webrtc/base/timeutils.h"
#include "webrtc/modules/rtp_rtcp/source/byte_io.h"
#include "webrtc/system_wrappers/include/tick_util.h"
#include "webrtc/test/testsupport/fileutils.h"
namespace webrtc {
@ -30,7 +30,7 @@ class IvfFileWriterTest : public ::testing::Test {
protected:
void SetUp() override {
const int64_t start_id =
reinterpret_cast<int64_t>(this) ^ TickTime::MicrosecondTimestamp();
reinterpret_cast<int64_t>(this) ^ rtc::TimeMicros();
int64_t id = start_id;
do {
std::ostringstream oss;

1
webrtc/modules/video_processing/content_analysis.cc
View File

@ -13,7 +13,6 @@
#include <stdlib.h>
#include "webrtc/system_wrappers/include/cpu_features_wrapper.h"
#include "webrtc/system_wrappers/include/tick_util.h"
namespace webrtc {

12
webrtc/modules/video_processing/test/video_processing_unittest.cc
View File

@ -15,8 +15,8 @@
#include <memory>
#include <string>
#include "webrtc/base/timeutils.h"
#include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
#include "webrtc/system_wrappers/include/tick_util.h"
#include "webrtc/test/testsupport/fileutils.h"
namespace webrtc {
@ -144,11 +144,12 @@ TEST_F(VideoProcessingTest, Resampler) {
for (uint32_t run_idx = 0; run_idx < NumRuns; run_idx++) {
// Initiate test timer.
const TickTime time_start = TickTime::Now();
const int64_t time_start = rtc::TimeNanos();
// Init the sourceFrame with a timestamp.
video_frame_.set_render_time_ms(time_start.MillisecondTimestamp());
video_frame_.set_timestamp(time_start.MillisecondTimestamp() * 90);
int64_t time_start_ms = time_start / rtc::kNumNanosecsPerMillisec;
video_frame_.set_render_time_ms(time_start_ms);
video_frame_.set_timestamp(time_start_ms * 90);
// Test scaling to different sizes: source is of |width|/|height| = 352/288.
// Pure scaling:
@ -191,7 +192,8 @@ TEST_F(VideoProcessingTest, Resampler) {
TestSize(video_frame_, cropped_source_frame, 281, 175, 29.3, vp_);
// Stop timer.
const int64_t runtime = (TickTime::Now() - time_start).Microseconds();
const int64_t runtime =
(rtc::TimeNanos() - time_start) / rtc::kNumNanosecsPerMicrosec;
if (runtime < min_runtime || run_idx == 0) {
min_runtime = runtime;
}

8
webrtc/modules/video_processing/video_decimator.cc
View File

@ -9,9 +9,9 @@
*/
#include "webrtc/base/checks.h"
#include "webrtc/base/timeutils.h"
#include "webrtc/modules/video_processing/include/video_processing.h"
#include "webrtc/modules/video_processing/video_decimator.h"
#include "webrtc/system_wrappers/include/tick_util.h"
#define VD_MIN(a, b) ((a) < (b)) ? (a) : (b)
@ -95,7 +95,7 @@ bool VPMVideoDecimator::DropFrame() {
}
uint32_t VPMVideoDecimator::GetDecimatedFrameRate() {
ProcessIncomingframe_rate(TickTime::MillisecondTimestamp());
ProcessIncomingframe_rate(rtc::TimeMillis());
if (!enable_temporal_decimation_) {
return static_cast<uint32_t>(incoming_frame_rate_ + 0.5f);
}
@ -104,12 +104,12 @@ uint32_t VPMVideoDecimator::GetDecimatedFrameRate() {
}
uint32_t VPMVideoDecimator::Inputframe_rate() {
ProcessIncomingframe_rate(TickTime::MillisecondTimestamp());
ProcessIncomingframe_rate(rtc::TimeMillis());
return static_cast<uint32_t>(incoming_frame_rate_ + 0.5f);
}
void VPMVideoDecimator::UpdateIncomingframe_rate() {
int64_t now = TickTime::MillisecondTimestamp();
int64_t now = rtc::TimeMillis();
if (incoming_frame_times_[0] == 0) {
// First no shift.
} else {

2
webrtc/system_wrappers/BUILD.gn
View File

@ -34,7 +34,6 @@ static_library("system_wrappers") {
"include/static_instance.h",
"include/stl_util.h",
"include/stringize_macros.h",
"include/tick_util.h",
"include/timestamp_extrapolator.h",
"include/trace.h",
"include/utf_util_win.h",
@ -65,7 +64,6 @@ static_library("system_wrappers") {
"source/rw_lock_winxp_win.h",
"source/sleep.cc",
"source/sort.cc",
"source/tick_util.cc",
"source/timestamp_extrapolator.cc",
"source/trace_impl.cc",
"source/trace_impl.h",

190
webrtc/system_wrappers/include/tick_util.h
View File

@ -1,190 +0,0 @@
/*
* 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.
*/
// System independant wrapper for polling elapsed time in ms and us.
// The implementation works in the tick domain which can be mapped over to the
// time domain.
#ifndef WEBRTC_SYSTEM_WRAPPERS_INCLUDE_TICK_UTIL_H_
#define WEBRTC_SYSTEM_WRAPPERS_INCLUDE_TICK_UTIL_H_
#if _WIN32
// Note: The Windows header must always be included before mmsystem.h
#include <windows.h>
#include <mmsystem.h>
#elif WEBRTC_LINUX
#include <time.h>
#elif WEBRTC_MAC
#include <mach/mach_time.h>
#include <string.h>
#else
#include <sys/time.h>
#include <time.h>
#endif
#include "webrtc/typedefs.h"
namespace webrtc {
class TickInterval;
// Class representing the current time.
class TickTime {
public:
TickTime();
explicit TickTime(int64_t ticks);
// Current time in the tick domain.
static TickTime Now();
// Now in the time domain in ms.
static int64_t MillisecondTimestamp();
// Now in the time domain in us.
static int64_t MicrosecondTimestamp();
// Returns the number of ticks in the tick domain.
int64_t Ticks() const;
static int64_t MillisecondsToTicks(const int64_t ms);
static int64_t TicksToMilliseconds(const int64_t ticks);
static int64_t TicksToMicroseconds(const int64_t ticks);
// Returns a TickTime that is ticks later than the passed TickTime.
friend TickTime operator+(const TickTime lhs, const int64_t ticks);
TickTime& operator+=(const int64_t& ticks);
// Returns a TickInterval that is the difference in ticks beween rhs and lhs.
friend TickInterval operator-(const TickTime& lhs, const TickTime& rhs);
private:
static int64_t QueryOsForTicks();
int64_t ticks_;
};
// Represents a time delta in ticks.
class TickInterval {
public:
TickInterval();
explicit TickInterval(int64_t interval);
int64_t Milliseconds() const;
int64_t Microseconds() const;
// Returns the sum of two TickIntervals as a TickInterval.
friend TickInterval operator+(const TickInterval& lhs,
const TickInterval& rhs);
TickInterval& operator+=(const TickInterval& rhs);
// Returns a TickInterval corresponding to rhs - lhs.
friend TickInterval operator-(const TickInterval& lhs,
const TickInterval& rhs);
TickInterval& operator-=(const TickInterval& rhs);
friend bool operator>(const TickInterval& lhs, const TickInterval& rhs);
friend bool operator<=(const TickInterval& lhs, const TickInterval& rhs);
friend bool operator<(const TickInterval& lhs, const TickInterval& rhs);
friend bool operator>=(const TickInterval& lhs, const TickInterval& rhs);
private:
friend class TickTime;
friend TickInterval operator-(const TickTime& lhs, const TickTime& rhs);
private:
int64_t interval_;
};
inline int64_t TickInterval::Milliseconds() const {
return TickTime::TicksToMilliseconds(interval_);
}
inline int64_t TickInterval::Microseconds() const {
return TickTime::TicksToMicroseconds(interval_);
}
inline TickInterval operator+(const TickInterval& lhs,
const TickInterval& rhs) {
return TickInterval(lhs.interval_ + rhs.interval_);
}
inline TickInterval operator-(const TickInterval& lhs,
const TickInterval& rhs) {
return TickInterval(lhs.interval_ - rhs.interval_);
}
inline TickInterval operator-(const TickTime& lhs, const TickTime& rhs) {
return TickInterval(lhs.ticks_ - rhs.ticks_);
}
inline TickTime operator+(const TickTime lhs, const int64_t ticks) {
TickTime time = lhs;
time.ticks_ += ticks;
return time;
}
inline bool operator>(const TickInterval& lhs, const TickInterval& rhs) {
return lhs.interval_ > rhs.interval_;
}
inline bool operator<=(const TickInterval& lhs, const TickInterval& rhs) {
return lhs.interval_ <= rhs.interval_;
}
inline bool operator<(const TickInterval& lhs, const TickInterval& rhs) {
return lhs.interval_ <= rhs.interval_;
}
inline bool operator>=(const TickInterval& lhs, const TickInterval& rhs) {
return lhs.interval_ >= rhs.interval_;
}
inline TickTime::TickTime()
: ticks_(0) {
}
inline TickTime::TickTime(int64_t ticks)
: ticks_(ticks) {
}
inline TickTime TickTime::Now() {
return TickTime(QueryOsForTicks());
}
inline int64_t TickTime::Ticks() const {
return ticks_;
}
inline TickTime& TickTime::operator+=(const int64_t& ticks) {
ticks_ += ticks;
return *this;
}
inline TickInterval::TickInterval() : interval_(0) {
}
inline TickInterval::TickInterval(const int64_t interval)
: interval_(interval) {
}
inline TickInterval& TickInterval::operator+=(const TickInterval& rhs) {
interval_ += rhs.interval_;
return *this;
}
inline TickInterval& TickInterval::operator-=(const TickInterval& rhs) {
interval_ -= rhs.interval_;
return *this;
}
} // namespace webrtc
#endif // WEBRTC_SYSTEM_WRAPPERS_INCLUDE_TICK_UTIL_H_

6
webrtc/system_wrappers/source/clock.cc
View File

@ -20,8 +20,8 @@
#endif
#include "webrtc/base/criticalsection.h"
#include "webrtc/base/timeutils.h"
#include "webrtc/system_wrappers/include/rw_lock_wrapper.h"
#include "webrtc/system_wrappers/include/tick_util.h"
namespace webrtc {
@ -37,13 +37,13 @@ class RealTimeClock : public Clock {
// Return a timestamp in milliseconds relative to some arbitrary source; the
// source is fixed for this clock.
int64_t TimeInMilliseconds() const override {
return TickTime::MillisecondTimestamp();
return rtc::TimeMillis();
}
// Return a timestamp in microseconds relative to some arbitrary source; the
// source is fixed for this clock.
int64_t TimeInMicroseconds() const override {
return TickTime::MicrosecondTimestamp();
return rtc::TimeMicros();
}
// Retrieve an NTP absolute timestamp in seconds and fractions of a second.

6
webrtc/system_wrappers/source/condition_variable_unittest.cc
View File

@ -17,8 +17,8 @@
#include "testing/gtest/include/gtest/gtest.h"
#include "webrtc/base/platform_thread.h"
#include "webrtc/base/timeutils.h"
#include "webrtc/system_wrappers/include/critical_section_wrapper.h"
#include "webrtc/system_wrappers/include/tick_util.h"
#include "webrtc/system_wrappers/include/trace.h"
namespace webrtc {
@ -191,9 +191,9 @@ TEST(CondVarWaitTest, WaitingWaits) {
InitializeCriticalSection(&crit_sect);
ConditionVariableEventWin cond_var;
EnterCriticalSection(&crit_sect);
int64_t start_ms = TickTime::MillisecondTimestamp();
int64_t start_ms = rtc::TimeMillis();
EXPECT_FALSE(cond_var.SleepCS(&crit_sect, kVeryShortWaitMs));
int64_t end_ms = TickTime::MillisecondTimestamp();
int64_t end_ms = rtc::TimeMillis();
EXPECT_LE(start_ms + kVeryShortWaitMs, end_ms)
<< "actual elapsed:" << end_ms - start_ms;
LeaveCriticalSection(&crit_sect);

42
webrtc/system_wrappers/source/tick_util.cc
View File

@ -1,42 +0,0 @@
/*
* 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 "webrtc/system_wrappers/include/tick_util.h"
#include "webrtc/base/timeutils.h"
namespace webrtc {
int64_t TickTime::MillisecondTimestamp() {
return TicksToMilliseconds(TickTime::Now().Ticks());
}
int64_t TickTime::MicrosecondTimestamp() {
return TicksToMicroseconds(TickTime::Now().Ticks());
}
int64_t TickTime::MillisecondsToTicks(const int64_t ms) {
return ms * rtc::kNumNanosecsPerMillisec;
}
int64_t TickTime::TicksToMilliseconds(const int64_t ticks) {
return ticks / rtc::kNumNanosecsPerMillisec;
}
int64_t TickTime::TicksToMicroseconds(const int64_t ticks) {
return ticks / rtc::kNumNanosecsPerMicrosec;
}
// Gets the native system tick count, converted to nanoseconds.
int64_t TickTime::QueryOsForTicks() {
return rtc::TimeNanos();
}
} // namespace webrtc

2
webrtc/system_wrappers/system_wrappers.gyp
View File

@ -42,7 +42,6 @@
'include/static_instance.h',
'include/stl_util.h',
'include/stringize_macros.h',
'include/tick_util.h',
'include/timestamp_extrapolator.h',
'include/trace.h',
'include/utf_util_win.h',
@ -77,7 +76,6 @@
'source/rw_lock_winxp_win.h',
'source/sleep.cc',
'source/sort.cc',
'source/tick_util.cc',
'source/timestamp_extrapolator.cc',
'source/trace_impl.cc',
'source/trace_impl.h',

10
webrtc/system_wrappers/test/TestSort/TestSort.cc
View File

@ -13,8 +13,8 @@
#include <algorithm>
#include "webrtc/base/timeutils.h"
#include "webrtc/system_wrappers/include/sort.h"
#include "webrtc/system_wrappers/include/tick_util.h"
// Excellent work polluting the global namespace Visual Studio...
#undef max
@ -144,7 +144,7 @@ void RunSortTest(webrtc::Type sortType, bool keySort)
printf("Running %s Sort() tests...\n", TypeEnumToString(sortType));
}
TickInterval accTicks;
int64_t accTicks;
for (int i = 0; i < NumOfTests; i++)
{
for (int j = 0; j < DataLength; j++)
@ -159,7 +159,7 @@ void RunSortTest(webrtc::Type sortType, bool keySort)
memcpy(keyRef, key, sizeof(key));
retVal = 0;
TickTime t0 = TickTime::Now();
int64_t t0 = rtc::TimeNanos();
if (keySort)
{
retVal = webrtc::KeySort(data, key, DataLength, sizeof(LotsOfData<KeyType>),
@ -176,7 +176,7 @@ void RunSortTest(webrtc::Type sortType, bool keySort)
//std::sort(key, key + DataLength);
//qsort(key, DataLength, sizeof(KeyType), Compare<KeyType>);
}
TickTime t1 = TickTime::Now();
int64_t t1 = rtc::TimeNanos();
accTicks += (t1 - t0);
if (retVal != 0)
@ -236,7 +236,7 @@ void RunSortTest(webrtc::Type sortType, bool keySort)
printf("Compliance test passed over %d iterations\n", NumOfTests);
int64_t executeTime = accTicks.Milliseconds();
int64_t executeTime = accTicks / rtc::kNumNanosecsPerMillisec;
printf("Execute time: %.2f s\n\n", (float)executeTime / 1000);
}

1
webrtc/video/call_stats.cc
View File

@ -16,7 +16,6 @@
#include "webrtc/base/constructormagic.h"
#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
#include "webrtc/system_wrappers/include/metrics.h"
#include "webrtc/system_wrappers/include/tick_util.h"
namespace webrtc {
namespace {

1
webrtc/video/call_stats_unittest.cc
View File

@ -15,7 +15,6 @@
#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
#include "webrtc/system_wrappers/include/metrics.h"
#include "webrtc/system_wrappers/include/tick_util.h"
#include "webrtc/test/histogram.h"
#include "webrtc/video/call_stats.h"

1
webrtc/video/rtp_stream_receiver.cc
View File

@ -25,7 +25,6 @@
#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h"
#include "webrtc/modules/video_coding/video_coding_impl.h"
#include "webrtc/system_wrappers/include/metrics.h"
#include "webrtc/system_wrappers/include/tick_util.h"
#include "webrtc/system_wrappers/include/timestamp_extrapolator.h"
#include "webrtc/system_wrappers/include/trace.h"
#include "webrtc/video/receive_statistics_proxy.h"

1
webrtc/video/video_stream_decoder.h
View File

@ -21,7 +21,6 @@
#include "webrtc/base/scoped_ref_ptr.h"
#include "webrtc/modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h"
#include "webrtc/modules/video_coding/include/video_coding_defines.h"
#include "webrtc/system_wrappers/include/tick_util.h"
#include "webrtc/typedefs.h"
#include "webrtc/video/vie_sync_module.h"

8
webrtc/video/vie_encoder.cc
View File

@ -17,11 +17,11 @@
#include "webrtc/base/checks.h"
#include "webrtc/base/logging.h"
#include "webrtc/base/trace_event.h"
#include "webrtc/base/timeutils.h"
#include "webrtc/modules/pacing/paced_sender.h"
#include "webrtc/modules/video_coding/include/video_coding.h"
#include "webrtc/modules/video_coding/include/video_coding_defines.h"
#include "webrtc/system_wrappers/include/metrics.h"
#include "webrtc/system_wrappers/include/tick_util.h"
#include "webrtc/video/overuse_frame_detector.h"
#include "webrtc/video/send_statistics_proxy.h"
#include "webrtc/video_frame.h"
@ -208,7 +208,7 @@ int ViEEncoder::GetPaddingNeededBps() const {
// The amount of padding should decay to zero if no frames are being
// captured/encoded unless a min-transmit bitrate is used.
int64_t now_ms = TickTime::MillisecondTimestamp();
int64_t now_ms = rtc::TimeMillis();
if (now_ms - time_of_last_frame_activity_ms > kStopPaddingThresholdMs)
pad_up_to_bitrate_bps = 0;
@ -257,7 +257,7 @@ void ViEEncoder::EncodeVideoFrame(const VideoFrame& video_frame) {
VideoCodecType codec_type;
{
rtc::CritScope lock(&data_cs_);
time_of_last_frame_activity_ms_ = TickTime::MillisecondTimestamp();
time_of_last_frame_activity_ms_ = rtc::TimeMillis();
if (EncoderPaused()) {
TraceFrameDropStart();
return;
@ -333,7 +333,7 @@ int32_t ViEEncoder::Encoded(const EncodedImage& encoded_image,
const RTPFragmentationHeader* fragmentation) {
{
rtc::CritScope lock(&data_cs_);
time_of_last_frame_activity_ms_ = TickTime::MillisecondTimestamp();
time_of_last_frame_activity_ms_ = rtc::TimeMillis();
}
if (stats_proxy_) {
stats_proxy_->OnSendEncodedImage(encoded_image, codec_specific_info);

1
webrtc/video/vie_remb.cc
View File

@ -16,7 +16,6 @@
#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h"
#include "webrtc/modules/utility/include/process_thread.h"
#include "webrtc/system_wrappers/include/tick_util.h"
#include "webrtc/system_wrappers/include/trace.h"
namespace webrtc {

1
webrtc/video/vie_remb_unittest.cc
View File

@ -16,7 +16,6 @@
#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h"
#include "webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h"
#include "webrtc/modules/utility/include/mock/mock_process_thread.h"
#include "webrtc/system_wrappers/include/tick_util.h"
#include "webrtc/video/vie_remb.h"
using ::testing::_;

8
webrtc/video/vie_sync_module.cc
View File

@ -12,6 +12,7 @@
#include "webrtc/base/checks.h"
#include "webrtc/base/logging.h"
#include "webrtc/base/timeutils.h"
#include "webrtc/base/trace_event.h"
#include "webrtc/modules/rtp_rtcp/include/rtp_receiver.h"
#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h"
@ -55,7 +56,7 @@ ViESyncModule::ViESyncModule(vcm::VideoReceiver* video_receiver)
video_rtp_rtcp_(nullptr),
voe_channel_id_(-1),
voe_sync_interface_(nullptr),
last_sync_time_(TickTime::Now()),
last_sync_time_(rtc::TimeNanos()),
sync_() {}
ViESyncModule::~ViESyncModule() {
@ -84,12 +85,13 @@ void ViESyncModule::ConfigureSync(int voe_channel_id,
int64_t ViESyncModule::TimeUntilNextProcess() {
const int64_t kSyncIntervalMs = 1000;
return kSyncIntervalMs - (TickTime::Now() - last_sync_time_).Milliseconds();
return kSyncIntervalMs -
(rtc::TimeNanos() - last_sync_time_) / rtc::kNumNanosecsPerMillisec;
}
void ViESyncModule::Process() {
rtc::CritScope lock(&data_cs_);
last_sync_time_ = TickTime::Now();
last_sync_time_ = rtc::TimeNanos();
const int current_video_delay_ms = video_receiver_->Delay();

3
webrtc/video/vie_sync_module.h
View File

@ -18,7 +18,6 @@
#include "webrtc/base/criticalsection.h"
#include "webrtc/modules/include/module.h"
#include "webrtc/system_wrappers/include/tick_util.h"
#include "webrtc/video/stream_synchronization.h"
#include "webrtc/voice_engine/include/voe_video_sync.h"
@ -61,7 +60,7 @@ class ViESyncModule : public Module {
RtpRtcp* video_rtp_rtcp_;
int voe_channel_id_;
VoEVideoSync* voe_sync_interface_;
TickTime last_sync_time_;
int64_t last_sync_time_;
std::unique_ptr<StreamSynchronization> sync_;
StreamSynchronization::Measurements audio_measurement_;
StreamSynchronization::Measurements video_measurement_;

8
webrtc/voice_engine/monitor_module.cc
View File

@ -8,7 +8,7 @@
* be found in the AUTHORS file in the root of the source tree.
*/
#include "webrtc/system_wrappers/include/tick_util.h"
#include "webrtc/base/timeutils.h"
#include "webrtc/voice_engine/monitor_module.h"
namespace webrtc {
@ -17,7 +17,7 @@ namespace voe {
MonitorModule::MonitorModule() :
_observerPtr(NULL),
_lastProcessTime(TickTime::MillisecondTimestamp())
_lastProcessTime(rtc::TimeMillis())
{
}
@ -52,7 +52,7 @@ MonitorModule::DeRegisterObserver()
int64_t
MonitorModule::TimeUntilNextProcess()
{
int64_t now = TickTime::MillisecondTimestamp();
int64_t now = rtc::TimeMillis();
const int64_t kAverageProcessUpdateTimeMs = 1000;
return kAverageProcessUpdateTimeMs - (now - _lastProcessTime);
}
@ -60,7 +60,7 @@ MonitorModule::TimeUntilNextProcess()
void
MonitorModule::Process()
{
_lastProcessTime = TickTime::MillisecondTimestamp();
_lastProcessTime = rtc::TimeMillis();
rtc::CritScope lock(&_callbackCritSect);
if (_observerPtr)
{