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
Download Patch File Download Diff File Expand all files Collapse all files

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;