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

Refactored ViESyncModule.

Browse Source 
Only style changes, will follow up with references/ptrs.

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

git-svn-id: http://webrtc.googlecode.com/svn/trunk@1068 4adac7df-926f-26a2-2b94-8c16560cd09d
This commit is contained in:
mflodman@webrtc.org 2011-11-30 18:31:36 +00:00
parent 68f2168978
commit 511f82eee9
2 changed files with 302 additions and 344 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

539
src/video_engine/vie_sync_module.cc
View File

@ -9,324 +9,291 @@
*/
#include "vie_sync_module.h"
#include "critical_section_wrapper.h"
#include "voe_video_sync.h"
#include "rtp_rtcp.h"
#include "trace.h"
#include "video_coding.h"
#include "voe_video_sync.h"
namespace webrtc {
enum { kSyncInterval = 1000};
enum { kMaxVideoDiffMs = 80 };
enum { kMaxAudioDiffMs = 80 };
enum { kMaxDelay = 1500 };
ViESyncModule::ViESyncModule(int id, VideoCodingModule& vcm,
RtpRtcp& rtcpModule)
: _dataCritsect(*CriticalSectionWrapper::CreateCriticalSection()), _id(id),
_vcm(vcm), _rtcpModule(rtcpModule), _voiceChannelId(-1),
_voiceSyncInterface(NULL), _lastSyncTime(TickTime::Now())
{
RtpRtcp& rtcp_module)
: data_critsect_(*CriticalSectionWrapper::CreateCriticalSection()),
id_(id),
vcm_(vcm),
rtcp_module_(rtcp_module),
voe_channel_id_(-1),
voe_sync_interface_(NULL),
last_sync_time_(TickTime::Now()) {
}
ViESyncModule::~ViESyncModule()
{
delete &_dataCritsect;
ViESyncModule::~ViESyncModule() {
delete &data_critsect_;
}
int ViESyncModule::SetVoiceChannel(int voiceChannelId,
VoEVideoSync* veSyncInterface)
{
CriticalSectionScoped cs(_dataCritsect);
_voiceChannelId = voiceChannelId;
_voiceSyncInterface = veSyncInterface;
_rtcpModule.DeRegisterSyncModule();
int ViESyncModule::SetVoiceChannel(int voe_channel_id,
VoEVideoSync* voe_sync_interface) {
CriticalSectionScoped cs(data_critsect_);
voe_channel_id_ = voe_channel_id;
voe_sync_interface_ = voe_sync_interface;
rtcp_module_.DeRegisterSyncModule();
if (!veSyncInterface)
{
_voiceChannelId = -1;
if (voiceChannelId >= 0) // trying to set a voice channel but no interface exist
{
return -1;
}
return 0;
if (!voe_sync_interface) {
voe_channel_id_ = -1;
if (voe_channel_id >= 0) {
// Trying to set a voice channel but no interface exist.
return -1;
}
RtpRtcp* voiceRTPRTCP = NULL;
veSyncInterface->GetRtpRtcp(_voiceChannelId, voiceRTPRTCP);
return _rtcpModule.RegisterSyncModule(voiceRTPRTCP);
return 0;
}
RtpRtcp* voe_rtp_rtcp = NULL;
voe_sync_interface->GetRtpRtcp(voe_channel_id_, voe_rtp_rtcp);
return rtcp_module_.RegisterSyncModule(voe_rtp_rtcp);
}
int ViESyncModule::VoiceChannel()
{
return _voiceChannelId;
int ViESyncModule::VoiceChannel() {
return voe_channel_id_;
}
// ----------------------------------------------------------------------------
// SetNetworkDelay
//
// Set how long time in ms voice is ahead of video when received on the network.
// Positive means audio is ahead of video.
// ----------------------------------------------------------------------------
void ViESyncModule::SetNetworkDelay(int networkDelay)
{
_channelDelay.networkDelay = networkDelay;
void ViESyncModule::SetNetworkDelay(int network_delay) {
channel_delay_.network_delay = network_delay;
}
// Implements Module
WebRtc_Word32 ViESyncModule::Version(WebRtc_Word8* version,
WebRtc_UWord32& remainingBufferInBytes,
WebRtc_UWord32& position) const
{
if (version == NULL)
{
WEBRTC_TRACE(webrtc::kTraceWarning, webrtc::kTraceVideo, -1,
"Invalid in argument to ViESyncModule Version()");
return -1;
}
WebRtc_Word8 ourVersion[] = "ViESyncModule 1.1.0";
WebRtc_UWord32 ourLength = (WebRtc_UWord32) strlen(ourVersion);
if (remainingBufferInBytes < ourLength + 1)
{
return -1;
}
memcpy(version, ourVersion, ourLength);
version[ourLength] = '\0'; // null terminaion
remainingBufferInBytes -= (ourLength + 1);
position += (ourLength + 1);
WebRtc_UWord32& remaining_buffer_in_bytes,
WebRtc_UWord32& position) const {
if (version == NULL) {
WEBRTC_TRACE(webrtc::kTraceWarning, webrtc::kTraceVideo, -1,
"Invalid in argument to ViESyncModule Version()");
return -1;
}
WebRtc_Word8 our_version[] = "ViESyncModule 1.1.0";
WebRtc_UWord32 our_length = (WebRtc_UWord32) strlen(our_version);
if (remaining_buffer_in_bytes < our_length + 1) {
return -1;
}
memcpy(version, our_version, our_length);
version[our_length] = '\0';
remaining_buffer_in_bytes -= (our_length + 1);
position += (our_length + 1);
return 0;
}
WebRtc_Word32 ViESyncModule::ChangeUniqueId(const WebRtc_Word32 id) {
id_ = id;
return 0;
}
WebRtc_Word32 ViESyncModule::TimeUntilNextProcess() {
return (WebRtc_Word32)(kSyncInterval -
(TickTime::Now() - last_sync_time_).Milliseconds());
}
WebRtc_Word32 ViESyncModule::Process() {
CriticalSectionScoped cs(data_critsect_);
last_sync_time_ = TickTime::Now();
int total_video_delay_target_ms = vcm_.Delay();
WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideo, id_,
"Video delay (JB + decoder) is %d ms",
total_video_delay_target_ms);
if (voe_channel_id_ == -1) {
return 0;
}
}
WebRtc_Word32 ViESyncModule::ChangeUniqueId(const WebRtc_Word32 id)
{
_id = id;
int current_audio_delay_ms = 0;
if (voe_sync_interface_->GetDelayEstimate(voe_channel_id_,
current_audio_delay_ms) != 0) {
// Could not get VoE delay value, probably not a valid channel Id.
WEBRTC_TRACE(webrtc::kTraceStream, webrtc::kTraceVideo, id_,
"%s: VE_GetDelayEstimate error for voice_channel %d",
__FUNCTION__, total_video_delay_target_ms, voe_channel_id_);
return 0;
}
}
WebRtc_Word32 ViESyncModule::TimeUntilNextProcess()
{
return (WebRtc_Word32) (kSyncInterval - (TickTime::Now()
- _lastSyncTime).Milliseconds());
}
int current_diff_ms = 0;
// Total video delay.
int video_delay_ms = 0;
// VoiceEngine report delay estimates even when not started, ignore if the
// reported value is lower than 40 ms.
if (current_audio_delay_ms < 40) {
WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideo, id_,
"A/V Sync: Audio delay < 40, skipping.");
return 0;
}
// Do the lip sync.
WebRtc_Word32 ViESyncModule::Process()
{
CriticalSectionScoped cs(_dataCritsect);
_lastSyncTime = TickTime::Now();
WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideo, id_,
"Audio delay is: %d for voice channel: %d",
current_audio_delay_ms, voe_channel_id_);
WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideo, id_,
"Network delay diff is: %d for voice channel: %d",
channel_delay_.network_delay, voe_channel_id_);
// Calculate the difference between the lowest possible video delay and
// the current audio delay.
current_diff_ms = total_video_delay_target_ms - current_audio_delay_ms +
channel_delay_.network_delay;
WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideo, id_,
"Current diff is: %d for audio channel: %d",
current_diff_ms, voe_channel_id_);
int totalVideoDelayTargetMS = _vcm.Delay();
WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideo, _id,
"Video delay (JB + decoder) is %d ms", totalVideoDelayTargetMS);
if (current_diff_ms > 0) {
// The minimum video delay is longer than the current audio delay.
// We need to decrease extra video delay, if we have added extra delay
// earlier, or add extra audio delay.
if (channel_delay_.extra_video_delay_ms > 0) {
// We have extra delay added to ViE. Reduce this delay before adding
// extra delay to VoE.
if (_voiceChannelId != -1)
{
// Get //Sync start
int currentAudioDelayMS = 0;
if (_voiceSyncInterface->GetDelayEstimate(_voiceChannelId,
currentAudioDelayMS) != 0)
{
// Could not get VoE delay value, probably not a valid channel Id.
WEBRTC_TRACE(webrtc::kTraceStream, webrtc::kTraceVideo, _id,
"%s: VE_GetDelayEstimate error for voiceChannel %d",
__FUNCTION__, totalVideoDelayTargetMS, _voiceChannelId);
return 0;
// This is the desired delay, we can't reduce more than this.
video_delay_ms = total_video_delay_target_ms;
// Check that we don't reduce the delay more than what is allowed.
if (video_delay_ms <
channel_delay_.last_video_delay_ms - kMaxVideoDiffMs) {
video_delay_ms =
channel_delay_.last_video_delay_ms - kMaxVideoDiffMs;
channel_delay_.extra_video_delay_ms =
video_delay_ms - total_video_delay_target_ms;
} else {
channel_delay_.extra_video_delay_ms = 0;
}
channel_delay_.last_video_delay_ms = video_delay_ms;
channel_delay_.last_video_delay_ms = -1;
channel_delay_.extra_audio_delay_ms = 0;
} else { // channel_delay_.extra_video_delay_ms > 0
// We have no extra video delay to remove, increase the audio delay.
if (channel_delay_.last_video_delay_ms >= 0) {
// We have increased the audio delay earlier, increase it even more.
int audio_diff_ms = current_diff_ms / 2;
if (audio_diff_ms > kMaxAudioDiffMs) {
// We only allow a maximum change of KMaxAudioDiffMS for audio
// due to NetEQ maximum changes.
audio_diff_ms = kMaxAudioDiffMs;
}
int currentDiffMS = 0;
int videoDelayMS = 0; // Total video delay
if (currentAudioDelayMS > 40) // Voice Engine report delay estimates even when not started. Ignore
{
// Increase the audio delay
channel_delay_.extra_audio_delay_ms += audio_diff_ms;
WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideo, _id,
"Audio delay is: %d for voice channel: %d",
currentAudioDelayMS, _voiceChannelId);
WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideo, _id,
"Network delay diff is: %d for voice channel: %d",
_channelDelay.networkDelay, _voiceChannelId);
// Calculate the diff between the lowest possible
// video delay and the current audio delay
currentDiffMS = totalVideoDelayTargetMS - currentAudioDelayMS
+ _channelDelay.networkDelay;
WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideo, _id,
"Current diff is: %d for audio channel: %d",
currentDiffMS, _voiceChannelId);
if (currentDiffMS > 0)
{
// The minimum video delay is longer than the current audio delay.
// We need to decrease extra video delay, if we have added extra delay
// earlier, or add extra audio delay.
if (_channelDelay.extraVideoDelayMS > 0)
{
// We have extra delay added to ViE.
// Reduce this delay before adding delay to VE.
// This is the desired delay, we can't reduce more than this.
videoDelayMS = totalVideoDelayTargetMS;
// Check we don't reduce the delay too much
if (videoDelayMS < _channelDelay.lastVideoDelayMS
- kMaxVideoDiffMS)
{
// Too large step...
videoDelayMS = _channelDelay.lastVideoDelayMS
- kMaxVideoDiffMS;
_channelDelay.extraVideoDelayMS = videoDelayMS
- totalVideoDelayTargetMS;
} else
{
_channelDelay.extraVideoDelayMS = 0;
}
_channelDelay.lastVideoDelayMS = videoDelayMS;
_channelDelay.lastSyncDelay = -1;
_channelDelay.extraAudioDelayMS = 0;
} else
{
// We have no extra video delay to remove.
// Increase the audio delay
if (_channelDelay.lastSyncDelay >= 0)
{
// We have increased the audio delay earlier,
// increase it even more.
int audioDiffMS = currentDiffMS / 2;
if (audioDiffMS > kMaxAudioDiffMS)
{
// We only allow a maximum change of KMaxAudioDiffMS for audio
// due to NetEQ maximum changes.
audioDiffMS = kMaxAudioDiffMS;
}
// Increase the audio delay
_channelDelay.extraAudioDelayMS += audioDiffMS;
// Don't set a too high delay.
if (_channelDelay.extraAudioDelayMS > kMaxDelay)
{
_channelDelay.extraAudioDelayMS = kMaxDelay;
}
// Don't add any extra video delay.
videoDelayMS = totalVideoDelayTargetMS;
_channelDelay.extraVideoDelayMS = 0;
_channelDelay.lastVideoDelayMS = videoDelayMS;
_channelDelay.lastSyncDelay = 1;
} else // lastSyncDelay < 0
{
// First time after a delay change, don't add any extra delay.
// This is to not toggle back and forth too much.
_channelDelay.extraAudioDelayMS = 0;
// Set minimum video delay
videoDelayMS = totalVideoDelayTargetMS;
_channelDelay.extraVideoDelayMS = 0;
_channelDelay.lastVideoDelayMS = videoDelayMS;
_channelDelay.lastSyncDelay = 0;
}
}
} else // if (currentDiffMS > 0)
{
// The minimum video delay is lower than the current audio delay.
// We need to decrease possible extra audio delay, or
// add extra video delay.
if (_channelDelay.extraAudioDelayMS > 0)
{
// We have extra delay in VoiceEngine
// Start with decreasing the voice delay
int audioDiffMS = currentDiffMS / 2; // This is a negative value
if (audioDiffMS < -1 * kMaxAudioDiffMS)
{
// Don't change the delay too much at once.
audioDiffMS = -1 * kMaxAudioDiffMS;
}
_channelDelay.extraAudioDelayMS += audioDiffMS; // Add the negative change...
if (_channelDelay.extraAudioDelayMS < 0)
{
// Negative values not allowed
_channelDelay.extraAudioDelayMS = 0;
_channelDelay.lastSyncDelay = 0;
} else
{
// There is more audio delay to use for the next round.
_channelDelay.lastSyncDelay = 1;
}
// Keep the video delay at the minimum values.
videoDelayMS = totalVideoDelayTargetMS;
_channelDelay.extraVideoDelayMS = 0;
_channelDelay.lastVideoDelayMS = videoDelayMS;
} else
{
// We have no extra delay in VoiceEngine
// Increase the video delay
_channelDelay.extraAudioDelayMS = 0;
// Make the diff positive
int videoDiffMS = -1 * currentDiffMS;
// This is the desired delay we want
videoDelayMS = totalVideoDelayTargetMS + videoDiffMS;
if (videoDelayMS > _channelDelay.lastVideoDelayMS)
{
if (videoDelayMS > _channelDelay.lastVideoDelayMS
+ kMaxVideoDiffMS)
{
// Don't increase the delay too much at once
videoDelayMS = _channelDelay.lastVideoDelayMS
+ kMaxVideoDiffMS;
}
// Verify we don't go above the maximum allowed delay
if (videoDelayMS > kMaxDelay)
{
videoDelayMS = kMaxDelay;
}
} else
{
if (videoDelayMS < _channelDelay.lastVideoDelayMS
- kMaxVideoDiffMS)
{
// Don't decrease the delay too much at once
videoDelayMS = _channelDelay.lastVideoDelayMS
- kMaxVideoDiffMS;
}
// Verify we don't go below the minimum delay
if (videoDelayMS < totalVideoDelayTargetMS)
{
videoDelayMS = totalVideoDelayTargetMS;
}
}
// Store the values
_channelDelay.extraVideoDelayMS = videoDelayMS
- totalVideoDelayTargetMS;
_channelDelay.lastVideoDelayMS = videoDelayMS;
_channelDelay.lastSyncDelay = -1;
}
}
// Don't set a too high delay.
if (channel_delay_.extra_audio_delay_ms > kMaxDelay) {
channel_delay_.extra_audio_delay_ms = kMaxDelay;
}
WEBRTC_TRACE(
webrtc::kTraceInfo,
webrtc::kTraceVideo,
_id,
"Sync video delay %d ms for video channel and audio delay %d for audio channel %d",
videoDelayMS, _channelDelay.extraAudioDelayMS,
_voiceChannelId);
// Don't add any extra video delay.
video_delay_ms = total_video_delay_target_ms;
channel_delay_.extra_video_delay_ms = 0;
channel_delay_.last_video_delay_ms = video_delay_ms;
// Set the extra audio delay
if (_voiceSyncInterface->SetMinimumPlayoutDelay(_voiceChannelId,
_channelDelay.extraAudioDelayMS) == -1)
{
WEBRTC_TRACE(webrtc::kTraceDebug, webrtc::kTraceVideo, _id,
"Error setting voice delay");
}
// sanity
// negative not valid
if (videoDelayMS < 0)
{
videoDelayMS = 0;
}
totalVideoDelayTargetMS = (totalVideoDelayTargetMS > videoDelayMS) ?
totalVideoDelayTargetMS : videoDelayMS;
_vcm.SetMinimumPlayoutDelay(totalVideoDelayTargetMS);
WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideo, _id,
"New Video delay target is: %d", totalVideoDelayTargetMS);
channel_delay_.last_video_delay_ms = 1;
} else { // channel_delay_.last_video_delay_ms >= 0
// First time after a delay change, don't add any extra delay.
// This is to not toggle back and forth too much.
channel_delay_.extra_audio_delay_ms = 0;
// Set minimum video delay
video_delay_ms = total_video_delay_target_ms;
channel_delay_.extra_video_delay_ms = 0;
channel_delay_.last_video_delay_ms = video_delay_ms;
channel_delay_.last_video_delay_ms = 0;
}
}
return 0;
} else { // if (current_diffMS > 0)
// The minimum video delay is lower than the current audio delay.
// We need to decrease possible extra audio delay, or
// add extra video delay.
if (channel_delay_.extra_audio_delay_ms > 0) {
// We have extra delay in VoiceEngine
// Start with decreasing the voice delay
int audio_diff_ms = current_diff_ms / 2;
if (audio_diff_ms < -1 * kMaxAudioDiffMs) {
// Don't change the delay too much at once.
audio_diff_ms = -1 * kMaxAudioDiffMs;
}
// Add the negative difference.
channel_delay_.extra_audio_delay_ms += audio_diff_ms;
if (channel_delay_.extra_audio_delay_ms < 0) {
// Negative values not allowed.
channel_delay_.extra_audio_delay_ms = 0;
channel_delay_.last_video_delay_ms = 0;
} else {
// There is more audio delay to use for the next round.
channel_delay_.last_video_delay_ms = 1;
}
// Keep the video delay at the minimum values.
video_delay_ms = total_video_delay_target_ms;
channel_delay_.extra_video_delay_ms = 0;
channel_delay_.last_video_delay_ms = video_delay_ms;
} else { // channel_delay_.extra_audio_delay_ms > 0
// We have no extra delay in VoiceEngine, increase the video delay.
channel_delay_.extra_audio_delay_ms = 0;
// Make the difference positive.
int video_diff_ms = -1 * current_diff_ms;
// This is the desired delay.
video_delay_ms = total_video_delay_target_ms + video_diff_ms;
if (video_delay_ms > channel_delay_.last_video_delay_ms) {
if (video_delay_ms >
channel_delay_.last_video_delay_ms + kMaxVideoDiffMs) {
// Don't increase the delay too much at once
video_delay_ms =
channel_delay_.last_video_delay_ms + kMaxVideoDiffMs;
}
// Verify we don't go above the maximum allowed delay
if (video_delay_ms > kMaxDelay) {
video_delay_ms = kMaxDelay;
}
} else {
if (video_delay_ms <
channel_delay_.last_video_delay_ms - kMaxVideoDiffMs) {
// Don't decrease the delay too much at once
video_delay_ms =
channel_delay_.last_video_delay_ms - kMaxVideoDiffMs;
}
// Verify we don't go below the minimum delay
if (video_delay_ms < total_video_delay_target_ms) {
video_delay_ms = total_video_delay_target_ms;
}
}
// Store the values
channel_delay_.extra_video_delay_ms =
video_delay_ms - total_video_delay_target_ms;
channel_delay_.last_video_delay_ms = video_delay_ms;
channel_delay_.last_video_delay_ms = -1;
}
}
WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideo, id_,
"Sync video delay %d ms for video channel and audio delay %d for audio "
"channel %d",
video_delay_ms, channel_delay_.extra_audio_delay_ms, voe_channel_id_);
// Set the extra audio delay.synchronization
if (voe_sync_interface_->SetMinimumPlayoutDelay(
voe_channel_id_, channel_delay_.extra_audio_delay_ms) == -1) {
WEBRTC_TRACE(webrtc::kTraceDebug, webrtc::kTraceVideo, id_,
"Error setting voice delay");
}
if (video_delay_ms < 0) {
video_delay_ms = 0;
}
total_video_delay_target_ms =
(total_video_delay_target_ms > video_delay_ms) ?
total_video_delay_target_ms : video_delay_ms;
vcm_.SetMinimumPlayoutDelay(total_video_delay_target_ms);
WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideo, id_,
"New Video delay target is: %d", total_video_delay_target_ms);
return 0;
}
} // namespace webrtc
} // namespace webrtc

107
src/video_engine/vie_sync_module.h
View File

@ -8,77 +8,68 @@
* be found in the AUTHORS file in the root of the source tree.
*/
/*
* vie_sync_module.h
* Responsible for doing Audio/Video sync
*/
// ViESyncModule is responsible for synchronization audio and video for a given
// VoE and ViE channel couple.
#ifndef WEBRTC_VIDEO_ENGINE_MAIN_SOURCE_VIE_SYNC_MODULE_H_
#define WEBRTC_VIDEO_ENGINE_MAIN_SOURCE_VIE_SYNC_MODULE_H_
#ifndef WEBRTC_VIDEO_ENGINE_VIE_SYNC_MODULE_H_
#define WEBRTC_VIDEO_ENGINE_VIE_SYNC_MODULE_H_
#include "module.h"
#include "tick_util.h"
namespace webrtc
{
namespace webrtc {
class CriticalSectionWrapper;
class RtpRtcp;
class VideoCodingModule;
class VoEVideoSync;
class ViESyncModule : public Module {
public:
ViESyncModule(int id, VideoCodingModule& vcm, RtpRtcp& rtcp_module);
~ViESyncModule();
class ViESyncModule : public Module
{
public:
enum { kSyncInterval = 1000};
enum { kMaxVideoDiffMS = 80 }; // Video sync
enum { kMaxAudioDiffMS = 80 }; // Video sync
enum { kMaxDelay = 1500 }; // Video sync
int SetVoiceChannel(int voe_channel_id, VoEVideoSync* voe_sync_interface);
int VoiceChannel();
ViESyncModule(int id, VideoCodingModule& vcm,
RtpRtcp& rtcpModule);
~ViESyncModule();
int SetVoiceChannel(int voiceChannelId, VoEVideoSync* voiceSyncInterface);
int VoiceChannel();
void SetNetworkDelay(int networkDelay);
// Set how long time, in ms, voice is ahead of video when received on the
// network. Positive value means audio is ahead of video.
void SetNetworkDelay(int network_delay);
// Implements Module
virtual WebRtc_Word32 Version(WebRtc_Word8* version,
WebRtc_UWord32& remainingBufferInBytes,
WebRtc_UWord32& position) const;
// Implements Module.
virtual WebRtc_Word32 Version(WebRtc_Word8* version,
WebRtc_UWord32& remaining_buffer_in_bytes,
WebRtc_UWord32& position) const;
virtual WebRtc_Word32 ChangeUniqueId(const WebRtc_Word32 id);
virtual WebRtc_Word32 TimeUntilNextProcess();
virtual WebRtc_Word32 Process();
virtual WebRtc_Word32 ChangeUniqueId(const WebRtc_Word32 id);
virtual WebRtc_Word32 TimeUntilNextProcess();
virtual WebRtc_Word32 Process();
private:
// Critical sections
CriticalSectionWrapper& _dataCritsect;
int _id;
VideoCodingModule& _vcm;
RtpRtcp& _rtcpModule;
int _voiceChannelId;
VoEVideoSync* _voiceSyncInterface;
TickTime _lastSyncTime;
struct ViESyncDelay
{
ViESyncDelay()
{
extraVideoDelayMS = 0;
lastVideoDelayMS = 0;
extraAudioDelayMS = 0;
lastSyncDelay = 0;
networkDelay = 120;
}
int extraVideoDelayMS;
int lastVideoDelayMS;
int extraAudioDelayMS; //audioDelayMS;
int lastSyncDelay;
int networkDelay;
};
ViESyncDelay _channelDelay;
private:
CriticalSectionWrapper& data_critsect_;
int id_;
VideoCodingModule& vcm_;
RtpRtcp& rtcp_module_;
int voe_channel_id_;
VoEVideoSync* voe_sync_interface_;
TickTime last_sync_time_;
struct ViESyncDelay {
ViESyncDelay() {
extra_video_delay_ms = 0;
last_video_delay_ms = 0;
extra_audio_delay_ms = 0;
last_sync_delay = 0;
network_delay = 120;
}
int extra_video_delay_ms;
int last_video_delay_ms;
int extra_audio_delay_ms;
int last_sync_delay;
int network_delay;
};
ViESyncDelay channel_delay_;
};
} // namespace webrtc
#endif // WEBRTC_VIDEO_ENGINE_MAIN_SOURCE_VIE_SYNC_MODULE_H_
} // namespace webrtc
#endif // WEBRTC_VIDEO_ENGINE_VIE_SYNC_MODULE_H_