Revert "With these changes we will assume that the capture time of a frame is based on NTP time. This makes the interface of video engine more well defined and makes it easier and cleaner to handle user provided capture timestamps."
This reverts commit 4954b3650192d78037714138a5c519ef08f2670e.
Reverts r3799
TBR=pbos@webrtc.org
Review URL: https://webrtc-codereview.appspot.com/1308004
git-svn-id: http://webrtc.googlecode.com/svn/trunk@3802 4adac7df-926f-26a2-2b94-8c16560cd09d
diff --git a/webrtc/modules/remote_bitrate_estimator/rtp_to_ntp.cc b/webrtc/modules/remote_bitrate_estimator/rtp_to_ntp.cc
index 5ed38c9..642c02d 100644
--- a/webrtc/modules/remote_bitrate_estimator/rtp_to_ntp.cc
+++ b/webrtc/modules/remote_bitrate_estimator/rtp_to_ntp.cc
@@ -8,9 +8,7 @@
* be found in the AUTHORS file in the root of the source tree.
*/
-#include "webrtc/modules/remote_bitrate_estimator/include/rtp_to_ntp.h"
-
-#include "webrtc/system_wrappers/interface/clock.h"
+#include "modules/remote_bitrate_estimator/include/rtp_to_ntp.h"
#include <assert.h>
@@ -59,6 +57,12 @@
return true;
}
+// Converts an NTP timestamp to a millisecond timestamp.
+int64_t NtpToMs(uint32_t ntp_secs, uint32_t ntp_frac) {
+ const double ntp_frac_ms = static_cast<double>(ntp_frac) / kNtpFracPerMs;
+ return ntp_secs * 1000 + ntp_frac_ms + 0.5;
+}
+
// Converts |rtp_timestamp| to the NTP time base using the NTP and RTP timestamp
// pairs in |rtcp|. The converted timestamp is returned in
// |rtp_timestamp_in_ms|. This function compensates for wrap arounds in RTP
@@ -67,10 +71,10 @@
const synchronization::RtcpList& rtcp,
int64_t* rtp_timestamp_in_ms) {
assert(rtcp.size() == 2);
- int64_t rtcp_ntp_ms_new = Clock::NtpToMs(rtcp.front().ntp_secs,
- rtcp.front().ntp_frac);
- int64_t rtcp_ntp_ms_old = Clock::NtpToMs(rtcp.back().ntp_secs,
- rtcp.back().ntp_frac);
+ int64_t rtcp_ntp_ms_new = synchronization::NtpToMs(rtcp.front().ntp_secs,
+ rtcp.front().ntp_frac);
+ int64_t rtcp_ntp_ms_old = synchronization::NtpToMs(rtcp.back().ntp_secs,
+ rtcp.back().ntp_frac);
int64_t rtcp_timestamp_new = rtcp.front().rtp_timestamp;
int64_t rtcp_timestamp_old = rtcp.back().rtp_timestamp;
if (!CompensateForWrapAround(rtcp_timestamp_new,
diff --git a/webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h b/webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h
index 779f0d5..3855204 100644
--- a/webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h
+++ b/webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h
@@ -880,6 +880,13 @@
***************************************************************************/
/*
+ * Set the estimated camera delay in MS
+ *
+ * return -1 on failure else 0
+ */
+ virtual int32_t SetCameraDelay(const int32_t delayMS) = 0;
+
+ /*
* Set the target send bitrate
*/
virtual void SetTargetSendBitrate(const uint32_t bitrate) = 0;
diff --git a/webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h b/webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h
index 8ee4c56..76cc316 100644
--- a/webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h
+++ b/webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h
@@ -265,6 +265,8 @@
int32_t(bool& enable, uint8_t& ID));
MOCK_METHOD1(SetAudioLevel,
int32_t(const uint8_t level_dBov));
+ MOCK_METHOD1(SetCameraDelay,
+ int32_t(const int32_t delayMS));
MOCK_METHOD1(SetTargetSendBitrate,
void(const uint32_t bitrate));
MOCK_METHOD3(SetGenericFECStatus,
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc b/webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc
index ddd8e337..d6bf092 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc
@@ -512,8 +512,8 @@
_clock->CurrentNtp(lastReceivedRRNTPsecs, lastReceivedRRNTPfrac);
// time when we received this in MS
- uint32_t receiveTimeMS = Clock::NtpToMs(lastReceivedRRNTPsecs,
- lastReceivedRRNTPfrac);
+ uint32_t receiveTimeMS = ModuleRTPUtility::ConvertNTPTimeToMS(
+ lastReceivedRRNTPsecs, lastReceivedRRNTPfrac);
// Estimate RTT
uint32_t d = (delaySinceLastSendReport & 0x0000ffff) * 1000;
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_sender.cc b/webrtc/modules/rtp_rtcp/source/rtcp_sender.cc
index c333186..ef97f85 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_sender.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_sender.cc
@@ -91,6 +91,8 @@
_reportBlocks(),
_csrcCNAMEs(),
+ _cameraDelayMS(0),
+
_lastSendReport(),
_lastRTCPTime(),
@@ -168,6 +170,7 @@
start_timestamp_ = -1;
_SSRC = 0;
_remoteSSRC = 0;
+ _cameraDelayMS = 0;
_sequenceNumberFIR = 0;
_tmmbr_Send = 0;
_packetOH_Send = 0;
@@ -348,7 +351,7 @@
last_rtp_timestamp_ = rtp_timestamp;
if (capture_time_ms < 0) {
// We don't currently get a capture time from VoiceEngine.
- last_frame_capture_time_ms_ = _clock->CurrentNtpInMilliseconds();
+ last_frame_capture_time_ms_ = _clock->TimeInMilliseconds();
} else {
last_frame_capture_time_ms_ = capture_time_ms;
}
@@ -377,6 +380,19 @@
return 0;
}
+int32_t
+RTCPSender::SetCameraDelay(const int32_t delayMS)
+{
+ CriticalSectionScoped lock(_criticalSectionRTCPSender);
+ if(delayMS > 1000 || delayMS < -1000)
+ {
+ WEBRTC_TRACE(kTraceError, kTraceRtpRtcp, _id, "%s invalid argument, delay can't be larger than 1 sec", __FUNCTION__);
+ return -1;
+ }
+ _cameraDelayMS = delayMS;
+ return 0;
+}
+
int32_t RTCPSender::CNAME(char cName[RTCP_CNAME_SIZE]) {
assert(cName);
CriticalSectionScoped lock(_criticalSectionRTCPSender);
@@ -609,13 +625,25 @@
_lastRTCPTime[i+1] =_lastRTCPTime[i];
}
- _lastRTCPTime[0] = Clock::NtpToMs(NTPsec, NTPfrac);
+ _lastRTCPTime[0] = ModuleRTPUtility::ConvertNTPTimeToMS(NTPsec, NTPfrac);
_lastSendReport[0] = (NTPsec << 16) + (NTPfrac >> 16);
- if (!RtpTimestampNow(NTPsec, NTPfrac, &RTPtime)) {
- RTPtime = 0;
+ uint32_t freqHz = 90000; // For video
+ if(_audio) {
+ freqHz = _rtpRtcp.CurrentSendFrequencyHz();
}
+ // The timestamp of this RTCP packet should be estimated as the timestamp of
+ // the frame being captured at this moment. We are calculating that
+ // timestamp as the last frame's timestamp + the time since the last frame
+ // was captured.
+ {
+ // Needs protection since this method is called on the process thread.
+ CriticalSectionScoped lock(_criticalSectionRTCPSender);
+ RTPtime = start_timestamp_ + last_rtp_timestamp_ + (
+ _clock->TimeInMilliseconds() - last_frame_capture_time_ms_) *
+ (freqHz / 1000);
+ }
// Add sender data
// Save for our length field
@@ -655,24 +683,6 @@
return 0;
}
-bool RTCPSender::RtpTimestampNow(uint32_t ntp_secs_now, uint32_t ntp_fracs_now,
- uint32_t* timestamp_now) const {
- if (last_frame_capture_time_ms_ < 0) {
- return false;
- }
- uint32_t freq_khz = 90; // Default for video.
- if(_audio) {
- freq_khz = _rtpRtcp.CurrentSendFrequencyHz() / 1000;
- }
- // The timestamp of this RTCP packet should be estimated as the timestamp of
- // the frame being captured at this moment. We are calculating that
- // timestamp as the last frame's timestamp + the time since the last frame
- // was captured.
- *timestamp_now = start_timestamp_ + last_rtp_timestamp_ +
- (Clock::NtpToMs(ntp_secs_now, ntp_fracs_now) -
- last_frame_capture_time_ms_) * freq_khz;
- return true;
-}
int32_t RTCPSender::BuildSDEC(uint8_t* rtcpbuffer,
uint32_t& pos) {
@@ -2081,7 +2091,7 @@
}
if (received) {
// answer to the one that sends to me
- _lastRTCPTime[0] = Clock::NtpToMs(NTPsec, NTPfrac);
+ _lastRTCPTime[0] = ModuleRTPUtility::ConvertNTPTimeToMS(NTPsec, NTPfrac);
// Remote SSRC
ModuleRTPUtility::AssignUWord32ToBuffer(rtcpbuffer+pos, _remoteSSRC);
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_sender.h b/webrtc/modules/rtp_rtcp/source/rtcp_sender.h
index 5a0c58f..014b975 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_sender.h
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_sender.h
@@ -72,6 +72,8 @@
int32_t SetRemoteSSRC( const uint32_t ssrc);
+ int32_t SetCameraDelay(const int32_t delayMS);
+
int32_t CNAME(char cName[RTCP_CNAME_SIZE]);
int32_t SetCNAME(const char cName[RTCP_CNAME_SIZE]);
@@ -195,9 +197,6 @@
const uint16_t* nackList,
std::string* nackString);
- bool RtpTimestampNow(uint32_t ntp_secs_now, uint32_t ntp_fracs_now,
- uint32_t* timestamp_now) const;
-
private:
int32_t _id;
const bool _audio;
@@ -230,6 +229,8 @@
std::map<uint32_t, RTCPReportBlock*> _reportBlocks;
std::map<uint32_t, RTCPUtility::RTCPCnameInformation*> _csrcCNAMEs;
+ int32_t _cameraDelayMS;
+
// Sent
uint32_t _lastSendReport[RTCP_NUMBER_OF_SR]; // allow packet loss and RTT above 1 sec
uint32_t _lastRTCPTime[RTCP_NUMBER_OF_SR];
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
index bc08bc9..1597ab2 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
@@ -1811,6 +1811,30 @@
return rtcp_sender_.SendRTCP(kRtcpSli, 0, 0, false, picture_id);
}
+int32_t ModuleRtpRtcpImpl::SetCameraDelay(const int32_t delay_ms) {
+ WEBRTC_TRACE(kTraceModuleCall,
+ kTraceRtpRtcp,
+ id_,
+ "SetCameraDelay(%d)",
+ delay_ms);
+ const bool default_instance(child_modules_.empty() ? false : true);
+
+ if (default_instance) {
+ CriticalSectionScoped lock(critical_section_module_ptrs_.get());
+
+ std::list<ModuleRtpRtcpImpl*>::iterator it = child_modules_.begin();
+ while (it != child_modules_.end()) {
+ RtpRtcp* module = *it;
+ if (module) {
+ module->SetCameraDelay(delay_ms);
+ }
+ it++;
+ }
+ return 0;
+ }
+ return rtcp_sender_.SetCameraDelay(delay_ms);
+}
+
int32_t ModuleRtpRtcpImpl::SetGenericFECStatus(
const bool enable,
const uint8_t payload_type_red,
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h
index ef6ac83..3d0be8b 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h
+++ b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h
@@ -390,6 +390,8 @@
// Send a request for a keyframe.
virtual int32_t RequestKeyFrame();
+ virtual int32_t SetCameraDelay(const int32_t delay_ms);
+
virtual void SetTargetSendBitrate(const uint32_t bitrate);
virtual int32_t SetGenericFECStatus(
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_sender.cc b/webrtc/modules/rtp_rtcp/source/rtp_sender.cc
index be358ba..9c5cfe0 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_sender.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_sender.cc
@@ -609,7 +609,7 @@
WebRtcRTPHeader rtp_header;
rtp_parser.Parse(rtp_header);
- int64_t diff_ms = clock_->CurrentNtpInMilliseconds() - capture_time_ms;
+ int64_t diff_ms = clock_->TimeInMilliseconds() - capture_time_ms;
if (UpdateTransmissionTimeOffset(data_buffer, length, rtp_header, diff_ms)) {
// Update stored packet in case of receiving a re-transmission request.
packet_history_->ReplaceRTPHeader(data_buffer,
@@ -645,9 +645,9 @@
// TODO(holmer): This should be changed all over Video Engine so that negative
// time is consider invalid, while 0 is considered a valid time.
if (capture_time_ms > 0) {
- int64_t diff_ms = clock_->CurrentNtpInMilliseconds() - capture_time_ms;
+ int64_t time_now = clock_->TimeInMilliseconds();
UpdateTransmissionTimeOffset(buffer, payload_length + rtp_header_length,
- rtp_header, diff_ms);
+ rtp_header, time_now - capture_time_ms);
}
// Used for NACK and to spread out the transmission of packets.
if (packet_history_->PutRTPPacket(buffer, rtp_header_length + payload_length,
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_utility.cc b/webrtc/modules/rtp_rtcp/source/rtp_utility.cc
index 3d31f68..c9af76c 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_utility.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_utility.cc
@@ -74,6 +74,14 @@
return NTPsec * freq + tmp;
}
+uint32_t ConvertNTPTimeToMS(uint32_t NTPsec, uint32_t NTPfrac) {
+ int freq = 1000;
+ float ftemp = (float)NTPfrac / (float)NTP_FRAC;
+ uint32_t tmp = (uint32_t)(ftemp * freq);
+ uint32_t MStime = NTPsec * freq + tmp;
+ return MStime;
+}
+
bool OldTimestamp(uint32_t newTimestamp,
uint32_t existingTimestamp,
bool* wrapped) {
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_utility.h b/webrtc/modules/rtp_rtcp/source/rtp_utility.h
index 6c6e9b8..7614ca6 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_utility.h
+++ b/webrtc/modules/rtp_rtcp/source/rtp_utility.h
@@ -70,6 +70,11 @@
uint32_t NTPfrac,
uint32_t freq);
+ // Return the time in milliseconds corresponding to the specified
+ // NTP timestamp.
+ uint32_t ConvertNTPTimeToMS(uint32_t NTPsec,
+ uint32_t NTPfrac);
+
uint32_t pow2(uint8_t exp);
// Returns a pointer to the payload data given a packet.
diff --git a/webrtc/modules/video_capture/video_capture_impl.cc b/webrtc/modules/video_capture/video_capture_impl.cc
index 3dd57cf..4976237 100644
--- a/webrtc/modules/video_capture/video_capture_impl.cc
+++ b/webrtc/modules/video_capture/video_capture_impl.cc
@@ -10,7 +10,6 @@
#include "video_capture_impl.h"
-#include "clock.h"
#include "common_video/libyuv/include/webrtc_libyuv.h"
#include "critical_section_wrapper.h"
#include "module_common_types.h"
@@ -197,8 +196,7 @@
captureFrame.set_render_time_ms(capture_time);
}
else {
- captureFrame.set_render_time_ms(
- Clock::GetRealTimeClock()->CurrentNtpInMilliseconds());
+ captureFrame.set_render_time_ms(TickTime::MillisecondTimestamp());
}
if (captureFrame.render_time_ms() == last_capture_time_) {
diff --git a/webrtc/system_wrappers/interface/clock.h b/webrtc/system_wrappers/interface/clock.h
index 177e18f..7a946d9 100644
--- a/webrtc/system_wrappers/interface/clock.h
+++ b/webrtc/system_wrappers/interface/clock.h
@@ -34,15 +34,9 @@
// source is fixed for this clock.
virtual int64_t TimeInMicroseconds() = 0;
- // Retrieve an NTP absolute timestamp in seconds and fractions of a second.
+ // Retrieve an NTP absolute timestamp.
virtual void CurrentNtp(uint32_t& seconds, uint32_t& fractions) = 0;
- // Retrieve an NTP absolute timestamp in milliseconds.
- virtual int64_t CurrentNtpInMilliseconds() = 0;
-
- // Converts an NTP timestamp to a millisecond timestamp.
- static int64_t NtpToMs(uint32_t seconds, uint32_t fractions);
-
// Returns an instance of the real-time system clock implementation.
static Clock* GetRealTimeClock();
};
@@ -61,12 +55,9 @@
// source is fixed for this clock.
virtual int64_t TimeInMicroseconds();
- // Retrieve an NTP absolute timestamp in milliseconds.
+ // Retrieve an NTP absolute timestamp.
virtual void CurrentNtp(uint32_t& seconds, uint32_t& fractions);
- // Converts an NTP timestamp to a millisecond timestamp.
- virtual int64_t CurrentNtpInMilliseconds();
-
// Advance the simulated clock with a given number of milliseconds or
// microseconds.
void AdvanceTimeMilliseconds(int64_t milliseconds);
diff --git a/webrtc/system_wrappers/source/clock.cc b/webrtc/system_wrappers/source/clock.cc
index 9b017b8..8085e56 100644
--- a/webrtc/system_wrappers/source/clock.cc
+++ b/webrtc/system_wrappers/source/clock.cc
@@ -23,14 +23,6 @@
namespace webrtc {
-const double kNtpFracPerMs = 4.294967296E6;
-
-int64_t Clock::NtpToMs(uint32_t ntp_secs, uint32_t ntp_frac) {
- const double ntp_frac_ms = static_cast<double>(ntp_frac) / kNtpFracPerMs;
- return 1000 * static_cast<int64_t>(ntp_secs) +
- static_cast<int64_t>(ntp_frac_ms + 0.5);
-}
-
#if defined(_WIN32)
struct reference_point {
@@ -136,42 +128,6 @@
virtual int64_t TimeInMicroseconds() {
return TickTime::MicrosecondTimestamp();
}
-
- // Retrieve an NTP absolute timestamp in seconds and fractions of a second.
- virtual void CurrentNtp(uint32_t& seconds, uint32_t& fractions) {
- timeval tv = CurrentTimeVal();
- double microseconds_in_seconds;
- Adjust(tv, &seconds, µseconds_in_seconds);
- fractions = static_cast<uint32_t>(
- microseconds_in_seconds * kMagicNtpFractionalUnit + 0.5);
- }
-
- // Retrieve an NTP absolute timestamp in milliseconds.
- virtual int64_t CurrentNtpInMilliseconds() {
- timeval tv = CurrentTimeVal();
- uint32_t seconds;
- double microseconds_in_seconds;
- Adjust(tv, &seconds, µseconds_in_seconds);
- return 1000 * static_cast<int64_t>(seconds) +
- static_cast<int64_t>(1000.0 * microseconds_in_seconds + 0.5);
- }
-
- protected:
- virtual timeval CurrentTimeVal() const = 0;
-
- static void Adjust(const timeval& tv, uint32_t* adjusted_s,
- double* adjusted_us_in_s) {
- *adjusted_s = tv.tv_sec + kNtpJan1970;
- *adjusted_us_in_s = tv.tv_usec / 1e6;
-
- if (*adjusted_us_in_s >= 1) {
- *adjusted_us_in_s -= 1;
- ++*adjusted_s;
- } else if (*adjusted_us_in_s < -1) {
- *adjusted_us_in_s += 1;
- --*adjusted_s;
- }
- }
};
#if defined(_WIN32)
@@ -182,8 +138,8 @@
virtual ~WindowsRealTimeClock() {}
- protected:
- timeval CurrentTimeVal() const {
+ // Retrieve an NTP absolute timestamp.
+ virtual void CurrentNtp(uint32_t& seconds, uint32_t& fractions) {
const uint64_t FILETIME_1970 = 0x019db1ded53e8000;
FILETIME StartTime;
@@ -191,20 +147,35 @@
struct timeval tv;
// We can't use query performance counter since they can change depending on
- // speed stepping.
+ // speed steping
get_time(_helpTimer, StartTime);
Time = (((uint64_t) StartTime.dwHighDateTime) << 32) +
(uint64_t) StartTime.dwLowDateTime;
- // Convert the hecto-nano second time to tv format.
+ // Convert the hecto-nano second time to tv format
Time -= FILETIME_1970;
tv.tv_sec = (uint32_t)(Time / (uint64_t)10000000);
tv.tv_usec = (uint32_t)((Time % (uint64_t)10000000) / 10);
- return tv;
+
+ double dtemp;
+
+ seconds = tv.tv_sec + kNtpJan1970;
+ dtemp = tv.tv_usec / 1e6;
+
+ if (dtemp >= 1) {
+ dtemp -= 1;
+ seconds++;
+ } else if (dtemp < -1) {
+ dtemp += 1;
+ seconds--;
+ }
+ dtemp *= kMagicNtpFractionalUnit;
+ fractions = (uint32_t)dtemp;
}
+ private:
WindowsHelpTimer* _helpTimer;
};
@@ -215,14 +186,26 @@
virtual ~UnixRealTimeClock() {}
- protected:
- timeval CurrentTimeVal() const {
+ // Retrieve an NTP absolute timestamp.
+ virtual void CurrentNtp(uint32_t& seconds, uint32_t& fractions) {
+ double dtemp;
struct timeval tv;
struct timezone tz;
- tz.tz_minuteswest = 0;
+ tz.tz_minuteswest = 0;
tz.tz_dsttime = 0;
gettimeofday(&tv, &tz);
- return tv;
+
+ seconds = tv.tv_sec + kNtpJan1970;
+ dtemp = tv.tv_usec / 1e6;
+ if (dtemp >= 1) {
+ dtemp -= 1;
+ seconds++;
+ } else if (dtemp < -1) {
+ dtemp += 1;
+ seconds--;
+ }
+ dtemp *= kMagicNtpFractionalUnit;
+ fractions = (uint32_t)dtemp;
}
};
#endif
@@ -264,10 +247,6 @@
kMagicNtpFractionalUnit / 1000);
}
-int64_t SimulatedClock::CurrentNtpInMilliseconds() {
- return TimeInMilliseconds() + 1000 * static_cast<int64_t>(kNtpJan1970);
-}
-
void SimulatedClock::AdvanceTimeMilliseconds(int64_t milliseconds) {
AdvanceTimeMicroseconds(1000 * milliseconds);
}
diff --git a/webrtc/system_wrappers/source/clock_unittest.cc b/webrtc/system_wrappers/source/clock_unittest.cc
deleted file mode 100644
index 67d699e..0000000
--- a/webrtc/system_wrappers/source/clock_unittest.cc
+++ /dev/null
@@ -1,26 +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/interface/clock.h"
-
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace webrtc {
-
-TEST(ClockTest, NtpTime) {
- Clock* clock = Clock::GetRealTimeClock();
- uint32_t seconds;
- uint32_t fractions;
- clock->CurrentNtp(seconds, fractions);
- int64_t milliseconds = clock->CurrentNtpInMilliseconds();
- EXPECT_GE(milliseconds, Clock::NtpToMs(seconds, fractions));
- EXPECT_NEAR(milliseconds, Clock::NtpToMs(seconds, fractions), 5);
-}
-} // namespace webrtc
diff --git a/webrtc/system_wrappers/source/system_wrappers_tests.gyp b/webrtc/system_wrappers/source/system_wrappers_tests.gyp
index f036731..fd1db25 100644
--- a/webrtc/system_wrappers/source/system_wrappers_tests.gyp
+++ b/webrtc/system_wrappers/source/system_wrappers_tests.gyp
@@ -19,7 +19,6 @@
],
'sources': [
'aligned_malloc_unittest.cc',
- 'clock_unittest.cc',
'condition_variable_unittest.cc',
'critical_section_unittest.cc',
'event_tracer_unittest.cc',
diff --git a/webrtc/video_engine/vie_encoder.cc b/webrtc/video_engine/vie_encoder.cc
index 3f672ba..c647d7a 100644
--- a/webrtc/video_engine/vie_encoder.cc
+++ b/webrtc/video_engine/vie_encoder.cc
@@ -608,6 +608,7 @@
ViEId(engine_id_, channel_id_), "%s: %u", __FUNCTION__,
frame_delay);
+ default_rtp_rtcp_->SetCameraDelay(frame_delay);
file_recorder_.SetFrameDelay(frame_delay);
}