generic-library/webrtc
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Revert "Inject TickTimeInterface into VCM and tests"

Browse Source 
This CL reverts r1220.

Review URL: http://webrtc-codereview.appspot.com/336002

git-svn-id: http://webrtc.googlecode.com/svn/trunk@1235 4adac7df-926f-26a2-2b94-8c16560cd09d
This commit is contained in:
henrik.lundin@webrtc.org 2011-12-19 17:55:45 +00:00
parent e32c08a5a6
commit 303158588b
45 changed files with 295 additions and 329 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/modules/video_coding/main/interface/video_coding.h
View File

@ -18,7 +18,6 @@
namespace webrtc
{
class TickTimeInterface;
class VideoEncoder;
class VideoDecoder;
struct CodecSpecificInfo;
@ -28,9 +27,6 @@ class VideoCodingModule : public Module
public:
static VideoCodingModule* Create(const WebRtc_Word32 id);
static VideoCodingModule* Create(const WebRtc_Word32 id,
TickTimeInterface* clock);
static void Destroy(VideoCodingModule* module);
// Get number of supported codecs

1
src/modules/video_coding/main/source/content_metrics_processing.cc
View File

@ -9,6 +9,7 @@
*/
#include "content_metrics_processing.h"
#include "tick_time.h"
#include "module_common_types.h"
#include "video_coding_defines.h"

13
src/modules/video_coding/main/source/generic_decoder.cc
View File

@ -12,15 +12,13 @@
#include "trace.h"
#include "generic_decoder.h"
#include "internal_defines.h"
#include "tick_time_interface.h"
#include "tick_time.h"
namespace webrtc {
VCMDecodedFrameCallback::VCMDecodedFrameCallback(VCMTiming& timing,
TickTimeInterface* clock)
VCMDecodedFrameCallback::VCMDecodedFrameCallback(VCMTiming& timing)
:
_critSect(CriticalSectionWrapper::CreateCriticalSection()),
_clock(clock),
_receiveCallback(NULL),
_timing(timing),
_timestampMap(kDecoderFrameMemoryLength)
@ -55,7 +53,7 @@ WebRtc_Word32 VCMDecodedFrameCallback::Decoded(RawImage& decodedImage)
_timing.StopDecodeTimer(
decodedImage._timeStamp,
frameInfo->decodeStartTimeMs,
_clock->MillisecondTimestamp());
VCMTickTime::MillisecondTimestamp());
if (_receiveCallback != NULL)
{
@ -148,8 +146,7 @@ WebRtc_Word32 VCMGenericDecoder::InitDecode(const VideoCodec* settings,
return _decoder.InitDecode(settings, numberOfCores);
}
WebRtc_Word32 VCMGenericDecoder::Decode(const VCMEncodedFrame& frame,
int64_t nowMs)
WebRtc_Word32 VCMGenericDecoder::Decode(const VCMEncodedFrame& frame)
{
if (_requireKeyFrame &&
!_keyFrameDecoded &&
@ -160,7 +157,7 @@ WebRtc_Word32 VCMGenericDecoder::Decode(const VCMEncodedFrame& frame,
// before we can decode delta frames.
return VCM_CODEC_ERROR;
}
_frameInfos[_nextFrameInfoIdx].decodeStartTimeMs = nowMs;
_frameInfos[_nextFrameInfoIdx].decodeStartTimeMs = VCMTickTime::MillisecondTimestamp();
_frameInfos[_nextFrameInfoIdx].renderTimeMs = frame.RenderTimeMs();
_callback->Map(frame.TimeStamp(), &_frameInfos[_nextFrameInfoIdx]);

5
src/modules/video_coding/main/source/generic_decoder.h
View File

@ -34,7 +34,7 @@ struct VCMFrameInformation
class VCMDecodedFrameCallback : public DecodedImageCallback
{
public:
VCMDecodedFrameCallback(VCMTiming& timing, TickTimeInterface* clock);
VCMDecodedFrameCallback(VCMTiming& timing);
virtual ~VCMDecodedFrameCallback();
void SetUserReceiveCallback(VCMReceiveCallback* receiveCallback);
@ -49,7 +49,6 @@ public:
private:
CriticalSectionWrapper* _critSect;
TickTimeInterface* _clock;
VideoFrame _frame;
VCMReceiveCallback* _receiveCallback;
VCMTiming& _timing;
@ -77,7 +76,7 @@ public:
*
* inputVideoBuffer reference to encoded video frame
*/
WebRtc_Word32 Decode(const VCMEncodedFrame& inputFrame, int64_t nowMs);
WebRtc_Word32 Decode(const VCMEncodedFrame& inputFrame);
/**
* Free the decoder memory

16
src/modules/video_coding/main/source/inter_frame_delay.cc
View File

@ -9,19 +9,20 @@
*/
#include "inter_frame_delay.h"
#include "tick_time.h"
namespace webrtc {
VCMInterFrameDelay::VCMInterFrameDelay(int64_t currentWallClock)
VCMInterFrameDelay::VCMInterFrameDelay()
{
Reset(currentWallClock);
Reset();
}
// Resets the delay estimate
void
VCMInterFrameDelay::Reset(int64_t currentWallClock)
VCMInterFrameDelay::Reset()
{
_zeroWallClock = currentWallClock;
_zeroWallClock = VCMTickTime::MillisecondTimestamp();
_wrapArounds = 0;
_prevWallClock = 0;
_prevTimestamp = 0;
@ -33,8 +34,13 @@ VCMInterFrameDelay::Reset(int64_t currentWallClock)
bool
VCMInterFrameDelay::CalculateDelay(WebRtc_UWord32 timestamp,
WebRtc_Word64 *delay,
int64_t currentWallClock)
WebRtc_Word64 currentWallClock /* = -1 */)
{
if (currentWallClock <= -1)
{
currentWallClock = VCMTickTime::MillisecondTimestamp();
}
if (_prevWallClock == 0)
{
// First set of data, initialization, wait for next frame

6
src/modules/video_coding/main/source/inter_frame_delay.h
View File

@ -19,10 +19,10 @@ namespace webrtc
class VCMInterFrameDelay
{
public:
VCMInterFrameDelay(int64_t currentWallClock);
VCMInterFrameDelay();
// Resets the estimate. Zeros are given as parameters.
void Reset(int64_t currentWallClock);
void Reset();
// Calculates the delay of a frame with the given timestamp.
// This method is called when the frame is complete.
@ -35,7 +35,7 @@ public:
// Return value : true if OK, false when reordered timestamps
bool CalculateDelay(WebRtc_UWord32 timestamp,
WebRtc_Word64 *delay,
int64_t currentWallClock);
WebRtc_Word64 currentWallClock = -1);
// Returns the current difference between incoming timestamps
//

24
src/modules/video_coding/main/source/jitter_buffer.cc
View File

@ -20,7 +20,7 @@
#include "event.h"
#include "trace.h"
#include "modules/video_coding/main/source/tick_time_interface.h"
#include "tick_time.h"
#include "list_wrapper.h"
#include <cassert>
@ -57,13 +57,10 @@ VCMJitterBuffer::CompleteDecodableKeyFrameCriteria(VCMFrameBuffer* frame,
}
// Constructor
VCMJitterBuffer::VCMJitterBuffer(TickTimeInterface* clock,
WebRtc_Word32 vcmId,
WebRtc_Word32 receiverId,
VCMJitterBuffer::VCMJitterBuffer(WebRtc_Word32 vcmId, WebRtc_Word32 receiverId,
bool master) :
_vcmId(vcmId),
_receiverId(receiverId),
_clock(clock),
_running(false),
_critSect(CriticalSectionWrapper::CreateCriticalSection()),
_master(master),
@ -84,7 +81,6 @@ VCMJitterBuffer::VCMJitterBuffer(TickTimeInterface* clock,
_numConsecutiveOldPackets(0),
_discardedPackets(0),
_jitterEstimate(vcmId, receiverId),
_delayEstimate(_clock->MillisecondTimestamp()),
_rttMs(0),
_nackMode(kNoNack),
_lowRttNackThresholdMs(-1),
@ -184,7 +180,7 @@ VCMJitterBuffer::Start()
_incomingFrameCount = 0;
_incomingFrameRate = 0;
_incomingBitCount = 0;
_timeLastIncomingFrameCount = _clock->MillisecondTimestamp();
_timeLastIncomingFrameCount = VCMTickTime::MillisecondTimestamp();
memset(_receiveStatistics, 0, sizeof(_receiveStatistics));
_numConsecutiveOldFrames = 0;
@ -266,7 +262,7 @@ VCMJitterBuffer::FlushInternal()
// Also reset the jitter and delay estimates
_jitterEstimate.Reset();
_delayEstimate.Reset(_clock->MillisecondTimestamp());
_delayEstimate.Reset();
_waitingForCompletion.frameSize = 0;
_waitingForCompletion.timestamp = 0;
@ -606,7 +602,7 @@ WebRtc_Word32
VCMJitterBuffer::GetUpdate(WebRtc_UWord32& frameRate, WebRtc_UWord32& bitRate)
{
CriticalSectionScoped cs(_critSect);
const WebRtc_Word64 now = _clock->MillisecondTimestamp();
const WebRtc_Word64 now = VCMTickTime::MillisecondTimestamp();
WebRtc_Word64 diff = now - _timeLastIncomingFrameCount;
if (diff < 1000 && _incomingFrameRate > 0 && _incomingBitRate > 0)
{
@ -661,7 +657,7 @@ VCMJitterBuffer::GetUpdate(WebRtc_UWord32& frameRate, WebRtc_UWord32& bitRate)
else
{
// No frames since last call
_timeLastIncomingFrameCount = _clock->MillisecondTimestamp();
_timeLastIncomingFrameCount = VCMTickTime::MillisecondTimestamp();
frameRate = 0;
bitRate = 0;
_incomingBitRate = 0;
@ -702,7 +698,7 @@ VCMJitterBuffer::GetCompleteFrameForDecoding(WebRtc_UWord32 maxWaitTimeMS)
_critSect->Leave();
return NULL;
}
const WebRtc_Word64 endWaitTimeMs = _clock->MillisecondTimestamp()
const WebRtc_Word64 endWaitTimeMs = VCMTickTime::MillisecondTimestamp()
+ maxWaitTimeMS;
WebRtc_Word64 waitTimeMs = maxWaitTimeMS;
while (waitTimeMs > 0)
@ -731,7 +727,7 @@ VCMJitterBuffer::GetCompleteFrameForDecoding(WebRtc_UWord32 maxWaitTimeMS)
if (oldestFrame == NULL)
{
waitTimeMs = endWaitTimeMs -
_clock->MillisecondTimestamp();
VCMTickTime::MillisecondTimestamp();
}
else
{
@ -1518,7 +1514,7 @@ VCMFrameBufferEnum
VCMJitterBuffer::InsertPacket(VCMEncodedFrame* buffer, const VCMPacket& packet)
{
CriticalSectionScoped cs(_critSect);
WebRtc_Word64 nowMs = _clock->MillisecondTimestamp();
WebRtc_Word64 nowMs = VCMTickTime::MillisecondTimestamp();
VCMFrameBufferEnum bufferReturn = kSizeError;
VCMFrameBufferEnum ret = kSizeError;
VCMFrameBuffer* frame = static_cast<VCMFrameBuffer*>(buffer);
@ -1529,7 +1525,7 @@ VCMJitterBuffer::InsertPacket(VCMEncodedFrame* buffer, const VCMPacket& packet)
{
// Now it's time to start estimating jitter
// reset the delay estimate.
_delayEstimate.Reset(_clock->MillisecondTimestamp());
_delayEstimate.Reset();
_firstPacket = false;
}

5
src/modules/video_coding/main/source/jitter_buffer.h
View File

@ -33,7 +33,6 @@ enum VCMNackMode
};
// forward declarations
class TickTimeInterface;
class VCMFrameBuffer;
class VCMPacket;
class VCMEncodedFrame;
@ -50,8 +49,7 @@ public:
class VCMJitterBuffer
{
public:
VCMJitterBuffer(TickTimeInterface* clock,
WebRtc_Word32 vcmId = -1,
VCMJitterBuffer(WebRtc_Word32 vcmId = -1,
WebRtc_Word32 receiverId = -1,
bool master = true);
virtual ~VCMJitterBuffer();
@ -193,7 +191,6 @@ private:
WebRtc_Word32 _vcmId;
WebRtc_Word32 _receiverId;
TickTimeInterface* _clock;
// If we are running (have started) or not
bool _running;
CriticalSectionWrapper* _critSect;

2
src/modules/video_coding/main/source/jitter_estimator.cc
View File

@ -12,8 +12,8 @@
#include "internal_defines.h"
#include "jitter_estimator.h"
#include "rtt_filter.h"
#include "tick_time.h"
#include <assert.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>

41
src/modules/video_coding/main/source/media_opt_util.cc
View File

@ -551,7 +551,7 @@ VCMFecMethod::UpdateParameters(const VCMProtectionParameters* parameters)
return true;
}
VCMLossProtectionLogic::VCMLossProtectionLogic(int64_t nowMs):
VCMLossProtectionLogic::VCMLossProtectionLogic():
_selectedMethod(NULL),
_currentParameters(),
_rtt(0),
@ -572,7 +572,7 @@ _boostRateKey(2),
_codecWidth(0),
_codecHeight(0)
{
Reset(nowMs);
Reset();
}
VCMLossProtectionLogic::~VCMLossProtectionLogic()
@ -661,13 +661,13 @@ VCMLossProtectionLogic::UpdateResidualPacketLoss(float residualPacketLoss)
}
void
VCMLossProtectionLogic::UpdateLossPr(WebRtc_UWord8 lossPr255,
int64_t nowMs)
VCMLossProtectionLogic::UpdateLossPr(WebRtc_UWord8 lossPr255)
{
UpdateMaxLossHistory(lossPr255, nowMs);
_lossPr255.Apply(static_cast<float> (nowMs - _lastPrUpdateT),
const WebRtc_Word64 now = VCMTickTime::MillisecondTimestamp();
UpdateMaxLossHistory(lossPr255, now);
_lossPr255.Apply(static_cast<float> (now - _lastPrUpdateT),
static_cast<float> (lossPr255));
_lastPrUpdateT = nowMs;
_lastPrUpdateT = now;
_lossPr = _lossPr255.Value() / 255.0f;
}
@ -741,14 +741,14 @@ VCMLossProtectionLogic::MaxFilteredLossPr(WebRtc_Word64 nowMs) const
}
WebRtc_UWord8
VCMLossProtectionLogic::FilteredLoss(int64_t nowMs) const
VCMLossProtectionLogic::FilteredLoss() const
{
if (_selectedMethod != NULL &&
(_selectedMethod->Type() == kFec ||
_selectedMethod->Type() == kNackFec))
{
// Take the windowed max of the received loss.
return MaxFilteredLossPr(nowMs);
return MaxFilteredLossPr(VCMTickTime::MillisecondTimestamp());
}
else
{
@ -770,19 +770,21 @@ VCMLossProtectionLogic::UpdateBitRate(float bitRate)
}
void
VCMLossProtectionLogic::UpdatePacketsPerFrame(float nPackets, int64_t nowMs)
VCMLossProtectionLogic::UpdatePacketsPerFrame(float nPackets)
{
_packetsPerFrame.Apply(static_cast<float>(nowMs - _lastPacketPerFrameUpdateT),
const WebRtc_Word64 now = VCMTickTime::MillisecondTimestamp();
_packetsPerFrame.Apply(static_cast<float>(now - _lastPacketPerFrameUpdateT),
nPackets);
_lastPacketPerFrameUpdateT = nowMs;
_lastPacketPerFrameUpdateT = now;
}
void
VCMLossProtectionLogic::UpdatePacketsPerFrameKey(float nPackets, int64_t nowMs)
VCMLossProtectionLogic::UpdatePacketsPerFrameKey(float nPackets)
{
_packetsPerFrameKey.Apply(static_cast<float>(nowMs -
const WebRtc_Word64 now = VCMTickTime::MillisecondTimestamp();
_packetsPerFrameKey.Apply(static_cast<float>(now -
_lastPacketPerFrameUpdateTKey), nPackets);
_lastPacketPerFrameUpdateTKey = nowMs;
_lastPacketPerFrameUpdateTKey = now;
}
void
@ -834,11 +836,12 @@ VCMLossProtectionLogic::SelectedType() const
}
void
VCMLossProtectionLogic::Reset(int64_t nowMs)
VCMLossProtectionLogic::Reset()
{
_lastPrUpdateT = nowMs;
_lastPacketPerFrameUpdateT = nowMs;
_lastPacketPerFrameUpdateTKey = nowMs;
const WebRtc_Word64 now = VCMTickTime::MillisecondTimestamp();
_lastPrUpdateT = now;
_lastPacketPerFrameUpdateT = now;
_lastPacketPerFrameUpdateTKey = now;
_lossPr255.Reset(0.9999f);
_packetsPerFrame.Reset(0.9999f);
_fecRateDelta = _fecRateKey = 0;

13
src/modules/video_coding/main/source/media_opt_util.h
View File

@ -15,6 +15,7 @@
#include "trace.h"
#include "exp_filter.h"
#include "internal_defines.h"
#include "tick_time.h"
#include "qm_select.h"
#include <cmath>
@ -211,7 +212,7 @@ private:
class VCMLossProtectionLogic
{
public:
VCMLossProtectionLogic(int64_t nowMs);
VCMLossProtectionLogic();
~VCMLossProtectionLogic();
// Set the protection method to be used
@ -250,7 +251,7 @@ public:
// Input:
// - lossPr255 : The packet loss probability [0, 255],
// reported by RTCP.
void UpdateLossPr(WebRtc_UWord8 lossPr255, int64_t nowMs);
void UpdateLossPr(WebRtc_UWord8 lossPr255);
// Update the filtered packet loss.
//
@ -269,13 +270,13 @@ public:
//
// Input:
// - nPackets : Number of packets in the latest sent frame.
void UpdatePacketsPerFrame(float nPackets, int64_t nowMs);
void UpdatePacketsPerFrame(float nPackets);
// Update the number of packets per frame estimate, for key frames
//
// Input:
// - nPackets : umber of packets in the latest sent frame.
void UpdatePacketsPerFrameKey(float nPackets, int64_t nowMs);
void UpdatePacketsPerFrameKey(float nPackets);
// Update the keyFrameSize estimate
//
@ -323,9 +324,9 @@ public:
// Returns the filtered loss probability in the interval [0, 255].
//
// Return value : The filtered loss probability
WebRtc_UWord8 FilteredLoss(int64_t nowMs) const;
WebRtc_UWord8 FilteredLoss() const;
void Reset(int64_t nowMs);
void Reset();
void Release();

36
src/modules/video_coding/main/source/media_optimization.cc
View File

@ -12,14 +12,11 @@
#include "content_metrics_processing.h"
#include "frame_dropper.h"
#include "qm_select.h"
#include "modules/video_coding/main/source/tick_time_interface.h"
namespace webrtc {
VCMMediaOptimization::VCMMediaOptimization(WebRtc_Word32 id,
TickTimeInterface* clock):
VCMMediaOptimization::VCMMediaOptimization(WebRtc_Word32 id):
_id(id),
_clock(clock),
_maxBitRate(0),
_sendCodecType(kVideoCodecUnknown),
_codecWidth(0),
@ -45,7 +42,7 @@ _lastChangeTime(0)
memset(_incomingFrameTimes, -1, sizeof(_incomingFrameTimes));
_frameDropper = new VCMFrameDropper(_id);
_lossProtLogic = new VCMLossProtectionLogic(_clock->MillisecondTimestamp());
_lossProtLogic = new VCMLossProtectionLogic();
_content = new VCMContentMetricsProcessing();
_qmResolution = new VCMQmResolution();
}
@ -65,12 +62,12 @@ VCMMediaOptimization::Reset()
memset(_incomingFrameTimes, -1, sizeof(_incomingFrameTimes));
InputFrameRate(); // Resets _incomingFrameRate
_frameDropper->Reset();
_lossProtLogic->Reset(_clock->MillisecondTimestamp());
_lossProtLogic->Reset();
_frameDropper->SetRates(0, 0);
_content->Reset();
_qmResolution->Reset();
_lossProtLogic->UpdateFrameRate(_incomingFrameRate);
_lossProtLogic->Reset(_clock->MillisecondTimestamp());
_lossProtLogic->Reset();
_sendStatisticsZeroEncode = 0;
_targetBitRate = 0;
_codecWidth = 0;
@ -96,7 +93,7 @@ VCMMediaOptimization::SetTargetRates(WebRtc_UWord32 bitRate,
{
VCMProtectionMethod *selectedMethod = _lossProtLogic->SelectedMethod();
_lossProtLogic->UpdateBitRate(static_cast<float>(bitRate));
_lossProtLogic->UpdateLossPr(fractionLost, _clock->MillisecondTimestamp());
_lossProtLogic->UpdateLossPr(fractionLost);
_lossProtLogic->UpdateRtt(roundTripTimeMs);
_lossProtLogic->UpdateResidualPacketLoss(static_cast<float>(fractionLost));
@ -119,8 +116,7 @@ VCMMediaOptimization::SetTargetRates(WebRtc_UWord32 bitRate,
// average or max filter may be used.
// We should think about which filter is appropriate for low/high bit rates,
// low/high loss rates, etc.
WebRtc_UWord8 packetLossEnc = _lossProtLogic->FilteredLoss(
_clock->MillisecondTimestamp());
WebRtc_UWord8 packetLossEnc = _lossProtLogic->FilteredLoss();
// For now use the filtered loss for computing the robustness settings
_lossProtLogic->UpdateFilteredLossPr(packetLossEnc);
@ -257,7 +253,7 @@ VCMMediaOptimization::SetEncodingData(VideoCodecType sendCodecType, WebRtc_Word3
// has changed. If native dimension values have changed, then either user
// initiated change, or QM initiated change. Will be able to determine only
// after the processing of the first frame.
_lastChangeTime = _clock->MillisecondTimestamp();
_lastChangeTime = VCMTickTime::MillisecondTimestamp();
_content->Reset();
_content->UpdateFrameRate(frameRate);
@ -340,7 +336,7 @@ VCMMediaOptimization::SentFrameRate()
float
VCMMediaOptimization::SentBitRate()
{
UpdateBitRateEstimate(-1, _clock->MillisecondTimestamp());
UpdateBitRateEstimate(-1, VCMTickTime::MillisecondTimestamp());
return _avgSentBitRateBps / 1000.0f;
}
@ -355,7 +351,7 @@ VCMMediaOptimization::UpdateWithEncodedData(WebRtc_Word32 encodedLength,
FrameType encodedFrameType)
{
// look into the ViE version - debug mode - needs also number of layers.
UpdateBitRateEstimate(encodedLength, _clock->MillisecondTimestamp());
UpdateBitRateEstimate(encodedLength, VCMTickTime::MillisecondTimestamp());
if(encodedLength > 0)
{
const bool deltaFrame = (encodedFrameType != kVideoFrameKey &&
@ -368,13 +364,11 @@ VCMMediaOptimization::UpdateWithEncodedData(WebRtc_Word32 encodedLength,
static_cast<float>(_maxPayloadSize);
if (deltaFrame)
{
_lossProtLogic->UpdatePacketsPerFrame(
minPacketsPerFrame, _clock->MillisecondTimestamp());
_lossProtLogic->UpdatePacketsPerFrame(minPacketsPerFrame);
}
else
{
_lossProtLogic->UpdatePacketsPerFrameKey(
minPacketsPerFrame, _clock->MillisecondTimestamp());
_lossProtLogic->UpdatePacketsPerFrameKey(minPacketsPerFrame);
}
if (_enableQm)
@ -525,7 +519,7 @@ VCMMediaOptimization::SelectQuality()
_qmResolution->ResetRates();
// Reset counters
_lastQMUpdateTime = _clock->MillisecondTimestamp();
_lastQMUpdateTime = VCMTickTime::MillisecondTimestamp();
// Reset content metrics
_content->Reset();
@ -548,7 +542,7 @@ VCMMediaOptimization::checkStatusForQMchange()
// (to sample the metrics) from the event lastChangeTime
// lastChangeTime is the time where user changed the size/rate/frame rate
// (via SetEncodingData)
WebRtc_Word64 now = _clock->MillisecondTimestamp();
WebRtc_Word64 now = VCMTickTime::MillisecondTimestamp();
if ((now - _lastQMUpdateTime) < kQmMinIntervalMs ||
(now - _lastChangeTime) < kQmMinIntervalMs)
{
@ -618,7 +612,7 @@ VCMMediaOptimization::QMUpdate(VCMResolutionScale* qm)
void
VCMMediaOptimization::UpdateIncomingFrameRate()
{
WebRtc_Word64 now = _clock->MillisecondTimestamp();
WebRtc_Word64 now = VCMTickTime::MillisecondTimestamp();
if (_incomingFrameTimes[0] == 0)
{
// first no shift
@ -670,7 +664,7 @@ VCMMediaOptimization::ProcessIncomingFrameRate(WebRtc_Word64 now)
WebRtc_UWord32
VCMMediaOptimization::InputFrameRate()
{
ProcessIncomingFrameRate(_clock->MillisecondTimestamp());
ProcessIncomingFrameRate(VCMTickTime::MillisecondTimestamp());
return WebRtc_UWord32 (_incomingFrameRate + 0.5f);
}

5
src/modules/video_coding/main/source/media_optimization.h
View File

@ -24,7 +24,6 @@ namespace webrtc
enum { kBitrateMaxFrameSamples = 60 };
enum { kBitrateAverageWinMs = 1000 };
class TickTimeInterface;
class VCMContentMetricsProcessing;
class VCMFrameDropper;
@ -39,7 +38,7 @@ struct VCMEncodedFrameSample
class VCMMediaOptimization
{
public:
VCMMediaOptimization(WebRtc_Word32 id, TickTimeInterface* clock);
VCMMediaOptimization(WebRtc_Word32 id);
~VCMMediaOptimization(void);
/*
* Reset the Media Optimization module
@ -163,7 +162,7 @@ private:
enum { kFrameHistoryWinMs = 2000};
WebRtc_Word32 _id;
TickTimeInterface* _clock;
WebRtc_Word32 _maxBitRate;
VideoCodecType _sendCodecType;
WebRtc_UWord16 _codecWidth;

28
src/modules/video_coding/main/source/receiver.cc
View File

@ -13,7 +13,7 @@
#include "encoded_frame.h"
#include "internal_defines.h"
#include "media_opt_util.h"
#include "tick_time_interface.h"
#include "tick_time.h"
#include "trace.h"
#include "video_coding.h"
@ -22,17 +22,15 @@
namespace webrtc {
VCMReceiver::VCMReceiver(VCMTiming& timing,
TickTimeInterface* clock,
WebRtc_Word32 vcmId,
WebRtc_Word32 receiverId,
bool master)
:
_critSect(CriticalSectionWrapper::CreateCriticalSection()),
_vcmId(vcmId),
_clock(clock),
_receiverId(receiverId),
_master(master),
_jitterBuffer(_clock, vcmId, receiverId, master),
_jitterBuffer(vcmId, receiverId, master),
_timing(timing),
_renderWaitEvent(*new VCMEvent()),
_state(kPassive)
@ -120,10 +118,10 @@ VCMReceiver::InsertPacket(const VCMPacket& packet,
VCMId(_vcmId, _receiverId),
"Packet seqNo %u of frame %u at %u",
packet.seqNum, packet.timestamp,
MaskWord64ToUWord32(_clock->MillisecondTimestamp()));
MaskWord64ToUWord32(VCMTickTime::MillisecondTimestamp()));
}
const WebRtc_Word64 nowMs = _clock->MillisecondTimestamp();
const WebRtc_Word64 nowMs = VCMTickTime::MillisecondTimestamp();
WebRtc_Word64 renderTimeMs = _timing.RenderTimeMs(packet.timestamp, nowMs);
@ -132,7 +130,7 @@ VCMReceiver::InsertPacket(const VCMPacket& packet,
// Render time error. Assume that this is due to some change in
// the incoming video stream and reset the JB and the timing.
_jitterBuffer.Flush();
_timing.Reset(_clock->MillisecondTimestamp());
_timing.Reset();
return VCM_FLUSH_INDICATOR;
}
else if (renderTimeMs < nowMs - kMaxVideoDelayMs)
@ -141,7 +139,7 @@ VCMReceiver::InsertPacket(const VCMPacket& packet,
"This frame should have been rendered more than %u ms ago."
"Flushing jitter buffer and resetting timing.", kMaxVideoDelayMs);
_jitterBuffer.Flush();
_timing.Reset(_clock->MillisecondTimestamp());
_timing.Reset();
return VCM_FLUSH_INDICATOR;
}
else if (_timing.TargetVideoDelay() > kMaxVideoDelayMs)
@ -150,14 +148,14 @@ VCMReceiver::InsertPacket(const VCMPacket& packet,
"More than %u ms target delay. Flushing jitter buffer and resetting timing.",
kMaxVideoDelayMs);
_jitterBuffer.Flush();
_timing.Reset(_clock->MillisecondTimestamp());
_timing.Reset();
return VCM_FLUSH_INDICATOR;
}
// First packet received belonging to this frame.
if (buffer->Length() == 0)
{
const WebRtc_Word64 nowMs = _clock->MillisecondTimestamp();
const WebRtc_Word64 nowMs = VCMTickTime::MillisecondTimestamp();
if (_master)
{
// Only trace the primary receiver to make it possible to parse and plot the trace file.
@ -201,7 +199,7 @@ VCMReceiver::FrameForDecoding(WebRtc_UWord16 maxWaitTimeMs, WebRtc_Word64& nextR
// is thread-safe.
FrameType incomingFrameType = kVideoFrameDelta;
nextRenderTimeMs = -1;
const WebRtc_Word64 startTimeMs = _clock->MillisecondTimestamp();
const WebRtc_Word64 startTimeMs = VCMTickTime::MillisecondTimestamp();
WebRtc_Word64 ret = _jitterBuffer.GetNextTimeStamp(maxWaitTimeMs,
incomingFrameType,
nextRenderTimeMs);
@ -217,7 +215,7 @@ VCMReceiver::FrameForDecoding(WebRtc_UWord16 maxWaitTimeMs, WebRtc_Word64& nextR
_timing.UpdateCurrentDelay(timeStamp);
const WebRtc_Word32 tempWaitTime = maxWaitTimeMs -
static_cast<WebRtc_Word32>(_clock->MillisecondTimestamp() - startTimeMs);
static_cast<WebRtc_Word32>(VCMTickTime::MillisecondTimestamp() - startTimeMs);
WebRtc_UWord16 newMaxWaitTime = static_cast<WebRtc_UWord16>(VCM_MAX(tempWaitTime, 0));
VCMEncodedFrame* frame = NULL;
@ -258,7 +256,7 @@ VCMReceiver::FrameForDecoding(WebRtc_UWord16 maxWaitTimeMs,
{
// How long can we wait until we must decode the next frame
WebRtc_UWord32 waitTimeMs = _timing.MaxWaitingTime(nextRenderTimeMs,
_clock->MillisecondTimestamp());
VCMTickTime::MillisecondTimestamp());
// Try to get a complete frame from the jitter buffer
VCMEncodedFrame* frame = _jitterBuffer.GetCompleteFrameForDecoding(0);
@ -298,7 +296,7 @@ VCMReceiver::FrameForDecoding(WebRtc_UWord16 maxWaitTimeMs,
{
// Get an incomplete frame
if (_timing.MaxWaitingTime(nextRenderTimeMs,
_clock->MillisecondTimestamp()) > 0)
VCMTickTime::MillisecondTimestamp()) > 0)
{
// Still time to wait for a complete frame
return NULL;
@ -330,7 +328,7 @@ VCMReceiver::FrameForRendering(WebRtc_UWord16 maxWaitTimeMs,
// as possible before giving the frame to the decoder, which will render the frame as soon
// as it has been decoded.
WebRtc_UWord32 waitTimeMs = _timing.MaxWaitingTime(nextRenderTimeMs,
_clock->MillisecondTimestamp());
VCMTickTime::MillisecondTimestamp());
if (maxWaitTimeMs < waitTimeMs)
{
// If we're not allowed to wait until the frame is supposed to be rendered

3
src/modules/video_coding/main/source/receiver.h
View File

@ -13,7 +13,6 @@
#include "critical_section_wrapper.h"
#include "jitter_buffer.h"
#include "modules/video_coding/main/source/tick_time_interface.h"
#include "timing.h"
#include "packet.h"
@ -41,7 +40,6 @@ class VCMReceiver
{
public:
VCMReceiver(VCMTiming& timing,
TickTimeInterface* clock,
WebRtc_Word32 vcmId = -1,
WebRtc_Word32 receiverId = -1,
bool master = true);
@ -85,7 +83,6 @@ private:
CriticalSectionWrapper* _critSect;
WebRtc_Word32 _vcmId;
TickTimeInterface* _clock;
WebRtc_Word32 _receiverId;
bool _master;
VCMJitterBuffer _jitterBuffer;

55
src/modules/video_coding/main/source/tick_time.h Normal file
View File

@ -0,0 +1,55 @@
/*
* Copyright (c) 2011 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.
*/
#ifndef WEBRTC_MODULES_VIDEO_CODING_TICK_TIME_H_
#define WEBRTC_MODULES_VIDEO_CODING_TICK_TIME_H_
#include "tick_util.h"
#include <assert.h>
namespace webrtc
{
//#define TICK_TIME_DEBUG
class VCMTickTime : public TickTime
{
#ifdef TICK_TIME_DEBUG
public:
/*
* Get current time
*/
static TickTime Now() { assert(false); };
/*
* Get time in milli seconds
*/
static WebRtc_Word64 MillisecondTimestamp() { return _timeNowDebug; };
/*
* Get time in micro seconds
*/
static WebRtc_Word64 MicrosecondTimestamp() { return _timeNowDebug * 1000LL; };
static void IncrementDebugClock() { _timeNowDebug++; };
private:
static WebRtc_Word64 _timeNowDebug;
#else
public:
static void IncrementDebugClock() { assert(false); };
#endif
};
} // namespace webrtc
#endif // WEBRTC_MODULES_VIDEO_CODING_TICK_TIME_H_

11
src/modules/video_coding/main/source/timestamp_extrapolator.cc
View File

@ -9,20 +9,17 @@
*/
#include "internal_defines.h"
#include "modules/video_coding/main/source/tick_time_interface.h"
#include "timestamp_extrapolator.h"
#include "tick_time.h"
#include "trace.h"
namespace webrtc {
VCMTimestampExtrapolator::VCMTimestampExtrapolator(TickTimeInterface* clock,
WebRtc_Word32 vcmId,
WebRtc_Word32 id)
VCMTimestampExtrapolator::VCMTimestampExtrapolator(WebRtc_Word32 vcmId, WebRtc_Word32 id)
:
_rwLock(RWLockWrapper::CreateRWLock()),
_vcmId(vcmId),
_id(id),
_clock(clock),
_startMs(0),
_firstTimestamp(0),
_wrapArounds(0),
@ -38,7 +35,7 @@ _accDrift(6600), // in timestamp ticks, i.e. 15 ms
_accMaxError(7000),
_P11(1e10)
{
Reset(_clock->MillisecondTimestamp());
Reset(VCMTickTime::MillisecondTimestamp());
}
VCMTimestampExtrapolator::~VCMTimestampExtrapolator()
@ -56,7 +53,7 @@ VCMTimestampExtrapolator::Reset(const WebRtc_Word64 nowMs /* = -1 */)
}
else
{
_startMs = _clock->MillisecondTimestamp();
_startMs = VCMTickTime::MillisecondTimestamp();
}
_prevMs = _startMs;
_firstTimestamp = 0;

7
src/modules/video_coding/main/source/timestamp_extrapolator.h
View File

@ -17,14 +17,10 @@
namespace webrtc
{
class TickTimeInterface;
class VCMTimestampExtrapolator
{
public:
VCMTimestampExtrapolator(TickTimeInterface* clock,
WebRtc_Word32 vcmId = 0,
WebRtc_Word32 receiverId = 0);
VCMTimestampExtrapolator(WebRtc_Word32 vcmId = 0, WebRtc_Word32 receiverId = 0);
~VCMTimestampExtrapolator();
void Update(WebRtc_Word64 tMs, WebRtc_UWord32 ts90khz, bool trace = true);
WebRtc_UWord32 ExtrapolateTimestamp(WebRtc_Word64 tMs) const;
@ -37,7 +33,6 @@ private:
RWLockWrapper* _rwLock;
WebRtc_Word32 _vcmId;
WebRtc_Word32 _id;
TickTimeInterface* _clock;
bool _trace;
double _w[2];
double _P[2][2];

8
src/modules/video_coding/main/source/timing.cc
View File

@ -16,14 +16,10 @@
namespace webrtc {
VCMTiming::VCMTiming(TickTimeInterface* clock,
WebRtc_Word32 vcmId,
WebRtc_Word32 timingId,
VCMTiming* masterTiming)
VCMTiming::VCMTiming(WebRtc_Word32 vcmId, WebRtc_Word32 timingId, VCMTiming* masterTiming)
:
_critSect(CriticalSectionWrapper::CreateCriticalSection()),
_vcmId(vcmId),
_clock(clock),
_timingId(timingId),
_master(false),
_tsExtrapolator(),
@ -37,7 +33,7 @@ _prevFrameTimestamp(0)
if (masterTiming == NULL)
{
_master = true;
_tsExtrapolator = new VCMTimestampExtrapolator(_clock, vcmId, timingId);
_tsExtrapolator = new VCMTimestampExtrapolator(vcmId, timingId);
}
else
{

5
src/modules/video_coding/main/source/timing.h
View File

@ -18,7 +18,6 @@
namespace webrtc
{
class TickTimeInterface;
class VCMTimestampExtrapolator;
class VCMTiming
@ -26,8 +25,7 @@ class VCMTiming
public:
// The primary timing component should be passed
// if this is the dual timing component.
VCMTiming(TickTimeInterface* clock,
WebRtc_Word32 vcmId = 0,
VCMTiming(WebRtc_Word32 vcmId = 0,
WebRtc_Word32 timingId = 0,
VCMTiming* masterTiming = NULL);
~VCMTiming();
@ -94,7 +92,6 @@ protected:
private:
CriticalSectionWrapper* _critSect;
WebRtc_Word32 _vcmId;
TickTimeInterface* _clock;
WebRtc_Word32 _timingId;
bool _master;
VCMTimestampExtrapolator* _tsExtrapolator;

1
src/modules/video_coding/main/source/video_coding.gypi
View File

@ -63,6 +63,7 @@
'receiver.h',
'rtt_filter.h',
'session_info.h',
'tick_time.h',
'tick_time_interface.h',
'timestamp_extrapolator.h',
'timestamp_map.h',

55
src/modules/video_coding/main/source/video_coding_impl.cc
View File

@ -15,7 +15,6 @@
#include "packet.h"
#include "trace.h"
#include "video_codec_interface.h"
#include "modules/video_coding/main/source/tick_time_interface.h"
namespace webrtc
{
@ -34,30 +33,26 @@ VCMProcessTimer::TimeUntilProcess() const
{
return static_cast<WebRtc_UWord32>(
VCM_MAX(static_cast<WebRtc_Word64>(_periodMs) -
(_clock->MillisecondTimestamp() - _latestMs), 0));
(VCMTickTime::MillisecondTimestamp() - _latestMs), 0));
}
void
VCMProcessTimer::Processed()
{
_latestMs = _clock->MillisecondTimestamp();
_latestMs = VCMTickTime::MillisecondTimestamp();
}
VideoCodingModuleImpl::VideoCodingModuleImpl(const WebRtc_Word32 id,
TickTimeInterface* clock,
bool delete_clock_on_destroy)
VideoCodingModuleImpl::VideoCodingModuleImpl(const WebRtc_Word32 id)
:
_id(id),
clock_(clock),
delete_clock_on_destroy_(delete_clock_on_destroy),
_receiveCritSect(CriticalSectionWrapper::CreateCriticalSection()),
_receiverInited(false),
_timing(clock_, id, 1),
_dualTiming(clock_, id, 2, &_timing),
_receiver(_timing, clock_, id, 1),
_dualReceiver(_dualTiming, clock_, id, 2, false),
_decodedFrameCallback(_timing, clock_),
_dualDecodedFrameCallback(_dualTiming, clock_),
_timing(id, 1),
_dualTiming(id, 2, &_timing),
_receiver(_timing, id, 1),
_dualReceiver(_dualTiming, id, 2, false),
_decodedFrameCallback(_timing),
_dualDecodedFrameCallback(_dualTiming),
_frameTypeCallback(NULL),
_frameStorageCallback(NULL),
_receiveStatsCallback(NULL),
@ -72,18 +67,17 @@ _scheduleKeyRequest(false),
_sendCritSect(CriticalSectionWrapper::CreateCriticalSection()),
_encoder(),
_encodedFrameCallback(),
_mediaOpt(id, clock_),
_mediaOpt(id),
_sendCodecType(kVideoCodecUnknown),
_sendStatsCallback(NULL),
_encoderInputFile(NULL),
_codecDataBase(id),
_receiveStatsTimer(1000, clock_),
_sendStatsTimer(1000, clock_),
_retransmissionTimer(10, clock_),
_keyRequestTimer(500, clock_)
_receiveStatsTimer(1000),
_sendStatsTimer(1000),
_retransmissionTimer(10),
_keyRequestTimer(500)
{
assert(clock_);
for (int i = 0; i < kMaxSimulcastStreams; i++)
{
_nextFrameType[i] = kVideoFrameDelta;
@ -104,7 +98,6 @@ VideoCodingModuleImpl::~VideoCodingModuleImpl()
}
delete _receiveCritSect;
delete _sendCritSect;
if (delete_clock_on_destroy_) delete clock_;
#ifdef DEBUG_DECODER_BIT_STREAM
fclose(_bitStreamBeforeDecoder);
#endif
@ -120,18 +113,7 @@ VideoCodingModule::Create(const WebRtc_Word32 id)
webrtc::kTraceVideoCoding,
VCMId(id),
"VideoCodingModule::Create()");
return new VideoCodingModuleImpl(id, new TickTimeInterface(), true);
}
VideoCodingModule*
VideoCodingModule::Create(const WebRtc_Word32 id, TickTimeInterface* clock)
{
WEBRTC_TRACE(webrtc::kTraceModuleCall,
webrtc::kTraceVideoCoding,
VCMId(id),
"VideoCodingModule::Create()");
assert(clock);
return new VideoCodingModuleImpl(id, clock, false);
return new VideoCodingModuleImpl(id);
}
void
@ -1103,7 +1085,7 @@ VideoCodingModuleImpl::Decode(WebRtc_UWord16 maxWaitTimeMs)
// If this frame was too late, we should adjust the delay accordingly
_timing.UpdateCurrentDelay(frame->RenderTimeMs(),
clock_->MillisecondTimestamp());
VCMTickTime::MillisecondTimestamp());
#ifdef DEBUG_DECODER_BIT_STREAM
if (_bitStreamBeforeDecoder != NULL)
@ -1220,8 +1202,7 @@ VideoCodingModuleImpl::DecodeDualFrame(WebRtc_UWord16 maxWaitTimeMs)
"Decoding frame %u with dual decoder",
dualFrame->TimeStamp());
// Decode dualFrame and try to catch up
WebRtc_Word32 ret = _dualDecoder->Decode(*dualFrame,
clock_->MillisecondTimestamp());
WebRtc_Word32 ret = _dualDecoder->Decode(*dualFrame);
if (ret != WEBRTC_VIDEO_CODEC_OK)
{
WEBRTC_TRACE(webrtc::kTraceWarning,
@ -1269,7 +1250,7 @@ VideoCodingModuleImpl::Decode(const VCMEncodedFrame& frame)
return VCM_NO_CODEC_REGISTERED;
}
// Decode a frame
WebRtc_Word32 ret = _decoder->Decode(frame, clock_->MillisecondTimestamp());
WebRtc_Word32 ret = _decoder->Decode(frame);
// Check for failed decoding, run frame type request callback if needed.
if (ret < 0)

14
src/modules/video_coding/main/source/video_coding_impl.h
View File

@ -21,7 +21,6 @@
#include "generic_decoder.h"
#include "generic_encoder.h"
#include "media_optimization.h"
#include "modules/video_coding/main/source/tick_time_interface.h"
#include <stdio.h>
@ -31,16 +30,13 @@ namespace webrtc
class VCMProcessTimer
{
public:
VCMProcessTimer(WebRtc_UWord32 periodMs, TickTimeInterface* clock)
: _clock(clock),
_periodMs(periodMs),
_latestMs(_clock->MillisecondTimestamp()) {}
VCMProcessTimer(WebRtc_UWord32 periodMs) :
_periodMs(periodMs), _latestMs(VCMTickTime::MillisecondTimestamp()) {}
WebRtc_UWord32 Period() const;
WebRtc_UWord32 TimeUntilProcess() const;
void Processed();
private:
TickTimeInterface* _clock;
WebRtc_UWord32 _periodMs;
WebRtc_Word64 _latestMs;
};
@ -57,9 +53,7 @@ enum VCMKeyRequestMode
class VideoCodingModuleImpl : public VideoCodingModule
{
public:
VideoCodingModuleImpl(const WebRtc_Word32 id,
TickTimeInterface* clock,
bool delete_clock_on_destroy);
VideoCodingModuleImpl(const WebRtc_Word32 id);
virtual ~VideoCodingModuleImpl();
@ -265,8 +259,6 @@ protected:
private:
WebRtc_Word32 _id;
TickTimeInterface* clock_;
bool delete_clock_on_destroy_;
CriticalSectionWrapper* _receiveCritSect;
bool _receiverInited;
VCMTiming _timing;

22
src/modules/video_coding/main/test/decode_from_storage_test.cc
View File

@ -12,9 +12,9 @@
#include "video_coding.h"
#include "rtp_rtcp.h"
#include "trace.h"
#include "tick_time.h"
#include "../source/event.h"
#include "rtp_player.h"
#include "modules/video_coding/main/source/mock/fake_tick_time_interface.h"
using namespace webrtc;
@ -35,8 +35,8 @@ private:
int DecodeFromStorageTest(CmdArgs& args)
{
// Make sure this test isn't executed without simulated events.
#if !defined(EVENT_DEBUG)
// Make sure this test isn't executed without simulated clocks
#if !defined(TICK_TIME_DEBUG) || !defined(EVENT_DEBUG)
return -1;
#endif
// BEGIN Settings
@ -64,10 +64,8 @@ int DecodeFromStorageTest(CmdArgs& args)
Trace::SetLevelFilter(webrtc::kTraceAll);
FakeTickTime clock(0);
// TODO(hlundin): This test was not verified after changing to FakeTickTime.
VideoCodingModule* vcm = VideoCodingModule::Create(1, &clock);
VideoCodingModule* vcmPlayback = VideoCodingModule::Create(2, &clock);
VideoCodingModule* vcm = VideoCodingModule::Create(1);
VideoCodingModule* vcmPlayback = VideoCodingModule::Create(2);
FrameStorageCallback storageCallback(vcmPlayback);
RtpDataCallback dataCallback(vcm);
WebRtc_Word32 ret = vcm->InitializeReceiver();
@ -82,7 +80,7 @@ int DecodeFromStorageTest(CmdArgs& args)
}
vcm->RegisterFrameStorageCallback(&storageCallback);
vcmPlayback->RegisterReceiveCallback(&receiveCallback);
RTPPlayer rtpStream(rtpFilename.c_str(), &dataCallback, &clock);
RTPPlayer rtpStream(rtpFilename.c_str(), &dataCallback);
ListWrapper payloadTypes;
payloadTypes.PushFront(new PayloadCodecTuple(VCM_VP8_PAYLOAD_TYPE, "VP8", kVideoCodecVP8));
@ -126,9 +124,9 @@ int DecodeFromStorageTest(CmdArgs& args)
ret = 0;
// RTP stream main loop
while ((ret = rtpStream.NextPacket(clock.MillisecondTimestamp())) == 0)
while ((ret = rtpStream.NextPacket(VCMTickTime::MillisecondTimestamp())) == 0)
{
if (clock.MillisecondTimestamp() % 5 == 0)
if (VCMTickTime::MillisecondTimestamp() % 5 == 0)
{
ret = vcm->Decode();
if (ret < 0)
@ -140,11 +138,11 @@ int DecodeFromStorageTest(CmdArgs& args)
{
vcm->Process();
}
if (MAX_RUNTIME_MS > -1 && clock.MillisecondTimestamp() >= MAX_RUNTIME_MS)
if (MAX_RUNTIME_MS > -1 && VCMTickTime::MillisecondTimestamp() >= MAX_RUNTIME_MS)
{
break;
}
clock.IncrementDebugClock(1);
VCMTickTime::IncrementDebugClock();
}
switch (ret)

30
src/modules/video_coding/main/test/generic_codec_test.cc
View File

@ -11,11 +11,11 @@
#include "generic_codec_test.h"
#include <cmath>
#include <stdio.h>
#include "tick_time.h"
#include "../source/event.h"
#include "rtp_rtcp.h"
#include "module_common_types.h"
#include "test_macros.h"
#include "modules/video_coding/main/source/mock/fake_tick_time_interface.h"
using namespace webrtc;
@ -23,13 +23,12 @@ enum { kMaxWaitEncTimeMs = 100 };
int GenericCodecTest::RunTest(CmdArgs& args)
{
#if !defined(EVENT_DEBUG)
printf("\n\nEnable debug events to run this test!\n\n");
#if !defined(TICK_TIME_DEBUG) || !defined(EVENT_DEBUG)
printf("\n\nEnable debug time to run this test!\n\n");
return -1;
#endif
FakeTickTime clock(0);
VideoCodingModule* vcm = VideoCodingModule::Create(1, &clock);
GenericCodecTest* get = new GenericCodecTest(vcm, &clock);
VideoCodingModule* vcm = VideoCodingModule::Create(1);
GenericCodecTest* get = new GenericCodecTest(vcm);
Trace::CreateTrace();
Trace::SetTraceFile(
(test::OutputPath() + "genericCodecTestTrace.txt").c_str());
@ -41,8 +40,7 @@ int GenericCodecTest::RunTest(CmdArgs& args)
return 0;
}
GenericCodecTest::GenericCodecTest(VideoCodingModule* vcm, FakeTickTime* clock):
_clock(clock),
GenericCodecTest::GenericCodecTest(VideoCodingModule* vcm):
_vcm(vcm),
_width(0),
_height(0),
@ -309,7 +307,7 @@ GenericCodecTest::Perform(CmdArgs& args)
_vcm->SetChannelParameters((WebRtc_UWord32)_bitRate, 0, 20);
_frameCnt = 0;
totalBytes = 0;
startTime = _clock->MicrosecondTimestamp();
startTime = VCMTickTime::MicrosecondTimestamp();
_encodeCompleteCallback->Initialize();
sendStats.SetTargetFrameRate(static_cast<WebRtc_UWord32>(_frameRate));
_vcm->RegisterSendStatisticsCallback(&sendStats);
@ -333,7 +331,7 @@ GenericCodecTest::Perform(CmdArgs& args)
//currentTime = VCMTickTime::MillisecondTimestamp();//clock()/(double)CLOCKS_PER_SEC;
if (_frameCnt == _frameRate)// @ 1sec
{
oneSecTime = _clock->MicrosecondTimestamp();
oneSecTime = VCMTickTime::MicrosecondTimestamp();
totalBytesOneSec = _encodeCompleteCallback->EncodedBytes();//totalBytes;
}
TEST(_vcm->TimeUntilNextProcess() >= 0);
@ -343,7 +341,7 @@ GenericCodecTest::Perform(CmdArgs& args)
// estimating rates
// complete sequence
// bit rate assumes input frame rate is as specified
currentTime = _clock->MicrosecondTimestamp();
currentTime = VCMTickTime::MicrosecondTimestamp();
totalBytes = _encodeCompleteCallback->EncodedBytes();
actualBitrate = (float)(8.0/1000)*(totalBytes / (_frameCnt / _frameRate));
@ -516,8 +514,8 @@ GenericCodecTest::Print()
float
GenericCodecTest::WaitForEncodedFrame() const
{
WebRtc_Word64 startTime = _clock->MillisecondTimestamp();
while (_clock->MillisecondTimestamp() - startTime < kMaxWaitEncTimeMs*10)
WebRtc_Word64 startTime = TickTime::MillisecondTimestamp();
while (TickTime::MillisecondTimestamp() - startTime < kMaxWaitEncTimeMs*10)
{
if (_encodeCompleteCallback->EncodeComplete())
{
@ -530,7 +528,11 @@ GenericCodecTest::WaitForEncodedFrame() const
void
GenericCodecTest::IncrementDebugClock(float frameRate)
{
_clock->IncrementDebugClock(1000/frameRate);
for (int t= 0; t < 1000/frameRate; t++)
{
VCMTickTime::IncrementDebugClock();
}
return;
}
int

6
src/modules/video_coding/main/test/generic_codec_test.h
View File

@ -31,13 +31,10 @@ namespace webrtc {
int VCMGenericCodecTest(CmdArgs& args);
class FakeTickTime;
class GenericCodecTest
{
public:
GenericCodecTest(webrtc::VideoCodingModule* vcm,
webrtc::FakeTickTime* clock);
GenericCodecTest(webrtc::VideoCodingModule* vcm);
~GenericCodecTest();
static int RunTest(CmdArgs& args);
WebRtc_Word32 Perform(CmdArgs& args);
@ -49,7 +46,6 @@ private:
WebRtc_Word32 TearDown();
void IncrementDebugClock(float frameRate);
webrtc::FakeTickTime* _clock;
webrtc::VideoCodingModule* _vcm;
webrtc::VideoCodec _sendCodec;
webrtc::VideoCodec _receiveCodec;

11
src/modules/video_coding/main/test/jitter_buffer_test.cc
View File

@ -19,10 +19,10 @@
#include "jitter_estimate_test.h"
#include "jitter_estimator.h"
#include "media_opt_util.h"
#include "modules/video_coding/main/source/tick_time_interface.h"
#include "packet.h"
#include "test_util.h"
#include "test_macros.h"
#include "tick_time.h"
using namespace webrtc;
@ -92,11 +92,10 @@ int CheckOutFrame(VCMEncodedFrame* frameOut, unsigned int size, bool startCode)
int JitterBufferTest(CmdArgs& args)
{
// Don't run these tests with debug event.
#if defined(EVENT_DEBUG)
// Don't run these tests with debug time
#if defined(TICK_TIME_DEBUG) || defined(EVENT_DEBUG)
return -1;
#endif
TickTimeInterface clock;
// Start test
WebRtc_UWord16 seqNum = 1234;
@ -115,7 +114,7 @@ int JitterBufferTest(CmdArgs& args)
packet.seqNum = seqNum;
packet.payloadType = 126;
seqNum++;
fb->InsertPacket(packet, clock.MillisecondTimestamp(), false, 0);
fb->InsertPacket(packet, VCMTickTime::MillisecondTimestamp(), false, 0);
TEST(frameList.Insert(fb) == 0);
}
VCMFrameListItem* item = NULL;
@ -136,7 +135,7 @@ int JitterBufferTest(CmdArgs& args)
//printf("DONE timestamp ordered frame list\n");
VCMJitterBuffer jb(&clock);
VCMJitterBuffer jb;
seqNum = 1234;
timeStamp = 123*90;

1
src/modules/video_coding/main/test/jitter_estimate_test.cc
View File

@ -11,6 +11,7 @@
#include <stdio.h>
#include <ctime>
#include "JitterEstimateTest.h"
#include "tick_time.h"
using namespace webrtc;

11
src/modules/video_coding/main/test/media_opt_test.cc
View File

@ -34,9 +34,8 @@ int MediaOptTest::RunTest(int testNum, CmdArgs& args)
Trace::CreateTrace();
Trace::SetTraceFile((test::OutputPath() + "mediaOptTestTrace.txt").c_str());
Trace::SetLevelFilter(webrtc::kTraceAll);
TickTimeInterface clock;
VideoCodingModule* vcm = VideoCodingModule::Create(1, &clock);
MediaOptTest* mot = new MediaOptTest(vcm, &clock);
VideoCodingModule* vcm = VideoCodingModule::Create(1);
MediaOptTest* mot = new MediaOptTest(vcm);
if (testNum == 0)
{ // regular
mot->Setup(0, args);
@ -67,9 +66,8 @@ int MediaOptTest::RunTest(int testNum, CmdArgs& args)
}
MediaOptTest::MediaOptTest(VideoCodingModule* vcm, TickTimeInterface* clock):
MediaOptTest::MediaOptTest(VideoCodingModule* vcm):
_vcm(vcm),
_clock(clock),
_width(0),
_height(0),
_lengthSourceFrame(0),
@ -281,8 +279,7 @@ MediaOptTest::Perform()
encodeCompleteCallback->SetCodecType(ConvertCodecType(_codecName.c_str()));
encodeCompleteCallback->SetFrameDimensions(_width, _height);
// frame ready to be sent to network
RTPSendCompleteCallback* outgoingTransport =
new RTPSendCompleteCallback(_rtp, _clock);
RTPSendCompleteCallback* outgoingTransport = new RTPSendCompleteCallback(_rtp);
_rtp->RegisterSendTransport(outgoingTransport);
//FrameReceiveCallback
VCMDecodeCompleteCallback receiveCallback(_decodedFile);

4
src/modules/video_coding/main/test/media_opt_test.h
View File

@ -31,8 +31,7 @@
class MediaOptTest
{
public:
MediaOptTest(webrtc::VideoCodingModule* vcm,
webrtc::TickTimeInterface* clock);
MediaOptTest(webrtc::VideoCodingModule* vcm);
~MediaOptTest();
static int RunTest(int testNum, CmdArgs& args);
@ -52,7 +51,6 @@ private:
webrtc::VideoCodingModule* _vcm;
webrtc::RtpRtcp* _rtp;
webrtc::TickTimeInterface* _clock;
std::string _inname;
std::string _outname;
std::string _actualSourcename;

6
src/modules/video_coding/main/test/mt_rx_tx_test.cc
View File

@ -170,8 +170,7 @@ int MTRxTxTest(CmdArgs& args)
TEST(rtp->SetGenericFECStatus(fecEnabled, VCM_RED_PAYLOAD_TYPE, VCM_ULPFEC_PAYLOAD_TYPE) == 0);
//VCM
TickTimeInterface clock;
VideoCodingModule* vcm = VideoCodingModule::Create(1, &clock);
VideoCodingModule* vcm = VideoCodingModule::Create(1);
if (vcm->InitializeReceiver() < 0)
{
return -1;
@ -216,8 +215,7 @@ int MTRxTxTest(CmdArgs& args)
encodeCompleteCallback->SetCodecType(ConvertCodecType(args.codecName.c_str()));
encodeCompleteCallback->SetFrameDimensions(width, height);
// frame ready to be sent to network
RTPSendCompleteCallback* outgoingTransport =
new RTPSendCompleteCallback(rtp, &clock, "dump.rtp");
RTPSendCompleteCallback* outgoingTransport = new RTPSendCompleteCallback(rtp, "dump.rtp");
rtp->RegisterSendTransport(outgoingTransport);
// FrameReceiveCallback
VCMDecodeCompleteCallback receiveCallback(decodedFile);

10
src/modules/video_coding/main/test/mt_test_common.cc
View File

@ -12,15 +12,13 @@
#include <cmath>
#include "modules/video_coding/main/source/tick_time_interface.h"
#include "rtp_dump.h"
namespace webrtc {
TransportCallback::TransportCallback(webrtc::RtpRtcp* rtp,
TickTimeInterface* clock,
const char* filename):
RTPSendCompleteCallback(rtp, clock, filename)
RTPSendCompleteCallback(rtp, filename)
{
//
}
@ -51,8 +49,7 @@ TransportCallback::SendPacket(int channel, const void *data, int len)
transmitPacket = PacketLoss();
}
TickTimeInterface clock;
int64_t now = clock.MillisecondTimestamp();
WebRtc_UWord64 now = VCMTickTime::MillisecondTimestamp();
// Insert outgoing packet into list
if (transmitPacket)
{
@ -76,8 +73,7 @@ TransportCallback::TransportPackets()
{
// Are we ready to send packets to the receiver?
rtpPacket* packet = NULL;
TickTimeInterface clock;
int64_t now = clock.MillisecondTimestamp();
WebRtc_UWord64 now = VCMTickTime::MillisecondTimestamp();
while (!_rtpPackets.Empty())
{

2
src/modules/video_coding/main/test/mt_test_common.h
View File

@ -47,7 +47,7 @@ class TransportCallback:public RTPSendCompleteCallback
{
public:
// constructor input: (receive side) rtp module to send encoded data to
TransportCallback(webrtc::RtpRtcp* rtp, TickTimeInterface* clock,
TransportCallback(webrtc::RtpRtcp* rtp,
const char* filename = NULL);
virtual ~TransportCallback();
// Add packets to list

28
src/modules/video_coding/main/test/normal_test.cc
View File

@ -17,10 +17,10 @@
#include "../source/event.h"
#include "common_types.h"
#include "modules/video_coding/main/source/mock/fake_tick_time_interface.h"
#include "test_callbacks.h"
#include "test_macros.h"
#include "test_util.h"
#include "tick_time.h"
#include "trace.h"
#include "testsupport/metrics/video_metrics.h"
@ -28,22 +28,20 @@ using namespace webrtc;
int NormalTest::RunTest(CmdArgs& args)
{
#if defined(EVENT_DEBUG)
// Don't run this test with debug time
#if defined(TICK_TIME_DEBUG) || defined(EVENT_DEBUG)
printf("SIMULATION TIME\n");
TickTimeInterface* clock = new FakeTickTime(0);
#else
printf("REAL-TIME\n");
TickTimeInterface* clock = new TickTimeInterface;
#endif
Trace::CreateTrace();
Trace::SetTraceFile(
(test::OutputPath() + "VCMNormalTestTrace.txt").c_str());
Trace::SetLevelFilter(webrtc::kTraceAll);
VideoCodingModule* vcm = VideoCodingModule::Create(1, clock);
NormalTest VCMNTest(vcm, clock);
VideoCodingModule* vcm = VideoCodingModule::Create(1);
NormalTest VCMNTest(vcm);
VCMNTest.Perform(args);
VideoCodingModule::Destroy(vcm);
delete clock;
Trace::ReturnTrace();
return 0;
}
@ -184,9 +182,8 @@ VCMNTDecodeCompleCallback::DecodedBytes()
//VCM Normal Test Class implementation
NormalTest::NormalTest(VideoCodingModule* vcm, TickTimeInterface* clock)
NormalTest::NormalTest(VideoCodingModule* vcm)
:
_clock(clock),
_vcm(vcm),
_sumEncBytes(0),
_timeStamp(0),
@ -284,8 +281,8 @@ NormalTest::Perform(CmdArgs& args)
while (feof(_sourceFile) == 0)
{
#if !defined(EVENT_DEBUG)
WebRtc_Word64 processStartTime = _clock->MillisecondTimestamp();
#if !(defined(TICK_TIME_DEBUG) || defined(EVENT_DEBUG))
WebRtc_Word64 processStartTime = VCMTickTime::MillisecondTimestamp();
#endif
TEST(fread(tmpBuffer, 1, _lengthSourceFrame, _sourceFile) > 0 ||
feof(_sourceFile));
@ -317,10 +314,13 @@ NormalTest::Perform(CmdArgs& args)
_vcm->Process();
}
WebRtc_UWord32 framePeriod = static_cast<WebRtc_UWord32>(1000.0f/static_cast<float>(_sendCodec.maxFramerate) + 0.5f);
#if defined(EVENT_DEBUG)
static_cast<FakeTickTime*>(_clock)->IncrementDebugClock(framePeriod);
#if defined(TICK_TIME_DEBUG) || defined(EVENT_DEBUG)
for (unsigned int i=0; i < framePeriod; i++)
{
VCMTickTime::IncrementDebugClock();
}
#else
WebRtc_Word64 timeSpent = _clock->MillisecondTimestamp() - processStartTime;
WebRtc_Word64 timeSpent = VCMTickTime::MillisecondTimestamp() - processStartTime;
if (timeSpent < framePeriod)
{
waitEvent->Wait(framePeriod - timeSpent);

4
src/modules/video_coding/main/test/normal_test.h
View File

@ -83,8 +83,7 @@ private:
class NormalTest
{
public:
NormalTest(webrtc::VideoCodingModule* vcm,
webrtc::TickTimeInterface* clock);
NormalTest(webrtc::VideoCodingModule* vcm);
~NormalTest();
static int RunTest(CmdArgs& args);
WebRtc_Word32 Perform(CmdArgs& args);
@ -106,7 +105,6 @@ protected:
// calculating pipeline delay, and decoding time
void FrameDecoded(WebRtc_UWord32 timeStamp);
webrtc::TickTimeInterface* _clock;
webrtc::VideoCodingModule* _vcm;
webrtc::VideoCodec _sendCodec;
webrtc::VideoCodec _receiveCodec;

15
src/modules/video_coding/main/test/quality_modes_test.cc
View File

@ -15,7 +15,6 @@
#include <time.h>
#include "../source/event.h"
#include "modules/video_coding/main/source/tick_time_interface.h"
#include "test_callbacks.h"
#include "test_macros.h"
#include "testsupport/metrics/video_metrics.h"
@ -25,22 +24,20 @@ using namespace webrtc;
int qualityModeTest()
{
// Don't run this test with debug events.
#if defined(EVENT_DEBUG)
// Don't run this test with debug time
#if defined(TICK_TIME_DEBUG) || defined(EVENT_DEBUG)
return -1;
#endif
TickTimeInterface clock;
VideoCodingModule* vcm = VideoCodingModule::Create(1, &clock);
QualityModesTest QMTest(vcm, &clock);
VideoCodingModule* vcm = VideoCodingModule::Create(1);
QualityModesTest QMTest(vcm);
QMTest.Perform();
VideoCodingModule::Destroy(vcm);
return 0;
}
QualityModesTest::QualityModesTest(VideoCodingModule* vcm,
TickTimeInterface* clock):
NormalTest(vcm, clock),
QualityModesTest::QualityModesTest(VideoCodingModule *vcm):
NormalTest(vcm),
_vpm()
{
//

3
src/modules/video_coding/main/test/quality_modes_test.h
View File

@ -20,8 +20,7 @@ int qualityModeTest();
class QualityModesTest : public NormalTest
{
public:
QualityModesTest(webrtc::VideoCodingModule* vcm,
webrtc::TickTimeInterface* clock);
QualityModesTest(webrtc::VideoCodingModule* vcm);
virtual ~QualityModesTest();
WebRtc_Word32 Perform();

8
src/modules/video_coding/main/test/receiver_timing_tests.cc
View File

@ -11,6 +11,7 @@
#include "receiver_tests.h"
#include "video_coding.h"
#include "trace.h"
#include "tick_time.h"
#include "../source/event.h"
#include "../source/internal_defines.h"
#include "timing.h"
@ -48,8 +49,8 @@ public:
int ReceiverTimingTests(CmdArgs& args)
{
// Make sure this test is never executed with simulated events.
#if defined(EVENT_DEBUG)
// Make sure this test is never executed with simulated clocks
#if defined(TICK_TIME_DEBUG) || defined(EVENT_DEBUG)
return -1;
#endif
@ -61,8 +62,7 @@ int ReceiverTimingTests(CmdArgs& args)
// A static random seed
srand(0);
TickTimeInterface clock;
VCMTiming timing(&clock);
VCMTiming timing;
float clockInMs = 0.0;
WebRtc_UWord32 waitTime = 0;
WebRtc_UWord32 jitterDelayMs = 0;

27
src/modules/video_coding/main/test/rtp_player.cc
View File

@ -20,8 +20,8 @@
#include "../source/internal_defines.h"
#include "gtest/gtest.h"
#include "modules/video_coding/main/source/tick_time_interface.h"
#include "rtp_rtcp.h"
#include "tick_time.h"
using namespace webrtc;
@ -82,9 +82,7 @@ WebRtc_UWord32 LostPackets::AddPacket(WebRtc_UWord8* rtpData, WebRtc_UWord16 rtp
return 0;
}
WebRtc_UWord32 LostPackets::SetResendTime(WebRtc_UWord16 sequenceNumber,
WebRtc_Word64 resendTime,
WebRtc_Word64 nowMs)
WebRtc_UWord32 LostPackets::SetResendTime(WebRtc_UWord16 sequenceNumber, WebRtc_Word64 resendTime)
{
CriticalSectionScoped cs(_critSect);
ListItem* item = First();
@ -92,6 +90,7 @@ WebRtc_UWord32 LostPackets::SetResendTime(WebRtc_UWord16 sequenceNumber,
{
RawRtpPacket* packet = static_cast<RawRtpPacket*>(item->GetItem());
const WebRtc_UWord16 seqNo = (packet->rtpData[2] << 8) + packet->rtpData[3];
const WebRtc_Word64 nowMs = VCMTickTime::MillisecondTimestamp();
if (sequenceNumber == seqNo && packet->resendTimeMs + 10 < nowMs)
{
if (_debugFile != NULL)
@ -124,21 +123,18 @@ WebRtc_UWord32 LostPackets::NumberOfPacketsToResend() const
return count;
}
void LostPackets::ResentPacket(WebRtc_UWord16 seqNo, WebRtc_Word64 nowMs)
void LostPackets::ResentPacket(WebRtc_UWord16 seqNo)
{
CriticalSectionScoped cs(_critSect);
if (_debugFile != NULL)
{
fprintf(_debugFile, "Resent %u at %u\n", seqNo,
MaskWord64ToUWord32(nowMs));
MaskWord64ToUWord32(VCMTickTime::MillisecondTimestamp()));
}
}
RTPPlayer::RTPPlayer(const char* filename,
RtpData* callback,
TickTimeInterface* clock)
RTPPlayer::RTPPlayer(const char* filename, RtpData* callback)
:
_clock(clock),
_rtpModule(*RtpRtcp::CreateRtpRtcp(1, false)),
_nextRtpTime(0),
_dataCallback(callback),
@ -276,7 +272,7 @@ WebRtc_Word32 RTPPlayer::ReadHeader()
WebRtc_UWord32 RTPPlayer::TimeUntilNextPacket() const
{
WebRtc_Word64 timeLeft = (_nextRtpTime - _firstPacketRtpTime) - (_clock->MillisecondTimestamp() - _firstPacketTimeMs);
WebRtc_Word64 timeLeft = (_nextRtpTime - _firstPacketRtpTime) - (VCMTickTime::MillisecondTimestamp() - _firstPacketTimeMs);
if (timeLeft < 0)
{
return 0;
@ -309,8 +305,7 @@ WebRtc_Word32 RTPPlayer::NextPacket(const WebRtc_Word64 timeNow)
_resendPacketCount++;
if (ret > 0)
{
_lostPackets.ResentPacket(seqNo,
_clock->MillisecondTimestamp());
_lostPackets.ResentPacket(seqNo);
}
else if (ret < 0)
{
@ -332,7 +327,7 @@ WebRtc_Word32 RTPPlayer::NextPacket(const WebRtc_Word64 timeNow)
if (_firstPacket)
{
_firstPacketRtpTime = static_cast<WebRtc_Word64>(_nextRtpTime);
_firstPacketTimeMs = _clock->MillisecondTimestamp();
_firstPacketTimeMs = VCMTickTime::MillisecondTimestamp();
}
if (_reordering && _reorderBuffer == NULL)
{
@ -452,9 +447,7 @@ WebRtc_Word32 RTPPlayer::ResendPackets(const WebRtc_UWord16* sequenceNumbers, We
}
for (int i=0; i < length; i++)
{
_lostPackets.SetResendTime(sequenceNumbers[i],
_clock->MillisecondTimestamp() + _rttMs,
_clock->MillisecondTimestamp());
_lostPackets.SetResendTime(sequenceNumbers[i], VCMTickTime::MillisecondTimestamp() + _rttMs);
}
return 0;
}

12
src/modules/video_coding/main/test/rtp_player.h
View File

@ -16,7 +16,6 @@
#include "list_wrapper.h"
#include "critical_section_wrapper.h"
#include "video_coding_defines.h"
#include "modules/video_coding/main/source/tick_time_interface.h"
#include <stdio.h>
#include <string>
@ -43,12 +42,10 @@ public:
~LostPackets();
WebRtc_UWord32 AddPacket(WebRtc_UWord8* rtpData, WebRtc_UWord16 rtpLen);
WebRtc_UWord32 SetResendTime(WebRtc_UWord16 sequenceNumber,
WebRtc_Word64 resendTime,
WebRtc_Word64 nowMs);
WebRtc_UWord32 SetResendTime(WebRtc_UWord16 sequenceNumber, WebRtc_Word64 resendTime);
WebRtc_UWord32 TotalNumberOfLosses() const { return _lossCount; };
WebRtc_UWord32 NumberOfPacketsToResend() const;
void ResentPacket(WebRtc_UWord16 seqNo, WebRtc_Word64 nowMs);
void ResentPacket(WebRtc_UWord16 seqNo);
void Lock() {_critSect->Enter();};
void Unlock() {_critSect->Leave();};
private:
@ -69,9 +66,7 @@ struct PayloadCodecTuple
class RTPPlayer : public webrtc::VCMPacketRequestCallback
{
public:
RTPPlayer(const char* filename,
webrtc::RtpData* callback,
webrtc::TickTimeInterface* clock);
RTPPlayer(const char* filename, webrtc::RtpData* callback);
virtual ~RTPPlayer();
WebRtc_Word32 Initialize(const webrtc::ListWrapper& payloadList);
@ -86,7 +81,6 @@ private:
WebRtc_Word32 SendPacket(WebRtc_UWord8* rtpData, WebRtc_UWord16 rtpLen);
WebRtc_Word32 ReadPacket(WebRtc_Word16* rtpdata, WebRtc_UWord32* offset);
WebRtc_Word32 ReadHeader();
webrtc::TickTimeInterface* _clock;
FILE* _rtpFile;
webrtc::RtpRtcp& _rtpModule;
WebRtc_UWord32 _nextRtpTime;

5
src/modules/video_coding/main/test/test_callbacks.cc
View File

@ -12,7 +12,6 @@
#include <cmath>
#include "modules/video_coding/main/source/tick_time_interface.h"
#include "rtp_dump.h"
#include "test_macros.h"
@ -200,9 +199,7 @@ VCMDecodeCompleteCallback::DecodedBytes()
}
RTPSendCompleteCallback::RTPSendCompleteCallback(RtpRtcp* rtp,
TickTimeInterface* clock,
const char* filename):
_clock(clock),
_sendCount(0),
_rtp(rtp),
_lossPct(0),
@ -254,7 +251,7 @@ RTPSendCompleteCallback::SendPacket(int channel, const void *data, int len)
bool transmitPacket = true;
transmitPacket = PacketLoss();
WebRtc_UWord64 now = _clock->MillisecondTimestamp();
WebRtc_UWord64 now = VCMTickTime::MillisecondTimestamp();
// Insert outgoing packet into list
if (transmitPacket)
{

4
src/modules/video_coding/main/test/test_callbacks.h
View File

@ -24,6 +24,7 @@
#include "module_common_types.h"
#include "rtp_rtcp.h"
#include "test_util.h"
#include "tick_time.h"
#include "trace.h"
#include "video_coding.h"
@ -156,7 +157,7 @@ class RTPSendCompleteCallback: public Transport
{
public:
// Constructor input: (receive side) rtp module to send encoded data to
RTPSendCompleteCallback(RtpRtcp* rtp, TickTimeInterface* clock,
RTPSendCompleteCallback(RtpRtcp* rtp,
const char* filename = NULL);
virtual ~RTPSendCompleteCallback();
// Send Packet to receive side RTP module
@ -183,7 +184,6 @@ protected:
// Random uniform loss model
bool UnifomLoss(double lossPct);
TickTimeInterface* _clock;
WebRtc_UWord32 _sendCount;
RtpRtcp* _rtp;
double _lossPct;

10
src/modules/video_coding/main/test/tester_main.cc
View File

@ -27,10 +27,16 @@
using namespace webrtc;
/*
* Build with EVENT_DEBUG defined
* to build the tests with simulated events.
* Build with TICK_TIME_DEBUG and EVENT_DEBUG defined
* to build the tests with simulated clock.
*/
// TODO(holmer): How do we get debug time into the cmd line interface?
/* Debug time */
#if defined(TICK_TIME_DEBUG) && defined(EVENT_DEBUG)
WebRtc_Word64 VCMTickTime::_timeNowDebug = 0; // current time in ms
#endif
int vcmMacrosTests = 0;
int vcmMacrosErrors = 0;

19
src/modules/video_coding/main/test/video_rtp_play.cc
View File

@ -12,11 +12,11 @@
#include "video_coding.h"
#include "rtp_rtcp.h"
#include "trace.h"
#include "tick_time.h"
#include "../source/event.h"
#include "../source/internal_defines.h"
#include "test_macros.h"
#include "rtp_player.h"
#include "modules/video_coding/main/source/mock/fake_tick_time_interface.h"
#include <stdio.h>
#include <string.h>
@ -72,8 +72,8 @@ FrameReceiveCallback::FrameToRender(VideoFrame& videoFrame)
int RtpPlay(CmdArgs& args)
{
// Make sure this test isn't executed without simulated events.
#if !defined(EVENT_DEBUG)
// Make sure this test isn't executed without simulated clocks
#if !defined(TICK_TIME_DEBUG) || !defined(EVENT_DEBUG)
return -1;
#endif
// BEGIN Settings
@ -90,10 +90,9 @@ int RtpPlay(CmdArgs& args)
if (outFile == "")
outFile = test::OutputPath() + "RtpPlay_decoded.yuv";
FrameReceiveCallback receiveCallback(outFile);
FakeTickTime clock(0);
VideoCodingModule* vcm = VideoCodingModule::Create(1, &clock);
VideoCodingModule* vcm = VideoCodingModule::Create(1);
RtpDataCallback dataCallback(vcm);
RTPPlayer rtpStream(args.inputFile.c_str(), &dataCallback, &clock);
RTPPlayer rtpStream(args.inputFile.c_str(), &dataCallback);
ListWrapper payloadTypes;
@ -151,9 +150,9 @@ int RtpPlay(CmdArgs& args)
ret = 0;
// RTP stream main loop
while ((ret = rtpStream.NextPacket(clock.MillisecondTimestamp())) == 0)
while ((ret = rtpStream.NextPacket(VCMTickTime::MillisecondTimestamp())) == 0)
{
if (clock.MillisecondTimestamp() % 5 == 0)
if (VCMTickTime::MillisecondTimestamp() % 5 == 0)
{
ret = vcm->Decode();
if (ret < 0)
@ -166,11 +165,11 @@ int RtpPlay(CmdArgs& args)
{
vcm->Process();
}
if (MAX_RUNTIME_MS > -1 && clock.MillisecondTimestamp() >= MAX_RUNTIME_MS)
if (MAX_RUNTIME_MS > -1 && VCMTickTime::MillisecondTimestamp() >= MAX_RUNTIME_MS)
{
break;
}
clock.IncrementDebugClock(1);
VCMTickTime::IncrementDebugClock();
}
switch (ret)

14
src/modules/video_coding/main/test/video_rtp_play_mt.cc
View File

@ -14,6 +14,7 @@
#include "trace.h"
#include "thread_wrapper.h"
#include "../source/event.h"
#include "tick_time.h"
#include "test_macros.h"
#include "rtp_player.h"
@ -39,8 +40,8 @@ bool RtpReaderThread(void* obj)
SharedState* state = static_cast<SharedState*>(obj);
EventWrapper& waitEvent = *EventWrapper::Create();
// RTP stream main loop
TickTimeInterface clock;
if (state->_rtpPlayer.NextPacket(clock.MillisecondTimestamp()) < 0)
WebRtc_Word64 nowMs = VCMTickTime::MillisecondTimestamp();
if (state->_rtpPlayer.NextPacket(nowMs) < 0)
{
return false;
}
@ -59,8 +60,8 @@ bool DecodeThread(void* obj)
int RtpPlayMT(CmdArgs& args, int releaseTestNo, webrtc::VideoCodecType releaseTestVideoType)
{
// Don't run these tests with debug events.
#if defined(EVENT_DEBUG)
// Don't run these tests with debug time
#if defined(TICK_TIME_DEBUG) || defined(EVENT_DEBUG)
return -1;
#endif
@ -81,9 +82,8 @@ int RtpPlayMT(CmdArgs& args, int releaseTestNo, webrtc::VideoCodecType releaseTe
(protection == kProtectionDualDecoder ||
protection == kProtectionNack ||
kProtectionNackFEC));
TickTimeInterface clock;
VideoCodingModule* vcm =
VideoCodingModule::Create(1, &clock);
VideoCodingModule::Create(1);
RtpDataCallback dataCallback(vcm);
std::string rtpFilename;
rtpFilename = args.inputFile;
@ -136,7 +136,7 @@ int RtpPlayMT(CmdArgs& args, int releaseTestNo, webrtc::VideoCodecType releaseTe
}
printf("Watch %s to verify that the output is reasonable\n", outFilename.c_str());
}
RTPPlayer rtpStream(rtpFilename.c_str(), &dataCallback, &clock);
RTPPlayer rtpStream(rtpFilename.c_str(), &dataCallback);
ListWrapper payloadTypes;
payloadTypes.PushFront(new PayloadCodecTuple(VCM_VP8_PAYLOAD_TYPE,
"VP8", kVideoCodecVP8));