diff --git a/video/stream_synchronization.cc b/video/stream_synchronization.cc index 493ed33b1d..159eb7a1ab 100644 --- a/video/stream_synchronization.cc +++ b/video/stream_synchronization.cc @@ -10,7 +10,6 @@ #include "video/stream_synchronization.h" -#include #include #include @@ -36,7 +35,6 @@ bool StreamSynchronization::ComputeRelativeDelay( const Measurements& audio_measurement, const Measurements& video_measurement, int* relative_delay_ms) { - assert(relative_delay_ms); int64_t audio_last_capture_time_ms; if (!audio_measurement.rtp_to_ntp.Estimate(audio_measurement.latest_timestamp, &audio_last_capture_time_ms)) { @@ -66,14 +64,14 @@ bool StreamSynchronization::ComputeDelays(int relative_delay_ms, int current_audio_delay_ms, int* total_audio_delay_target_ms, int* total_video_delay_target_ms) { - assert(total_audio_delay_target_ms && total_video_delay_target_ms); - int current_video_delay_ms = *total_video_delay_target_ms; + RTC_LOG(LS_VERBOSE) << "Audio delay: " << current_audio_delay_ms << " current diff: " << relative_delay_ms << " for stream " << audio_stream_id_; - // Calculate the difference between the lowest possible video delay and - // the current audio delay. + + // Calculate the difference between the lowest possible video delay and the + // current audio delay. int current_diff_ms = current_video_delay_ms - current_audio_delay_ms + relative_delay_ms; @@ -95,82 +93,77 @@ bool StreamSynchronization::ComputeDelays(int relative_delay_ms, if (diff_ms > 0) { // The minimum video delay is longer than the current audio delay. // We need to decrease extra video delay, or add extra audio delay. - if (channel_delay_.extra_video_delay_ms > base_target_delay_ms_) { + if (video_delay_.extra_ms > base_target_delay_ms_) { // We have extra delay added to ViE. Reduce this delay before adding // extra delay to VoE. - channel_delay_.extra_video_delay_ms -= diff_ms; - channel_delay_.extra_audio_delay_ms = base_target_delay_ms_; - } else { // channel_delay_.extra_video_delay_ms > 0 + video_delay_.extra_ms -= diff_ms; + audio_delay_.extra_ms = base_target_delay_ms_; + } else { // video_delay_.extra_ms > 0 // We have no extra video delay to remove, increase the audio delay. - channel_delay_.extra_audio_delay_ms += diff_ms; - channel_delay_.extra_video_delay_ms = base_target_delay_ms_; + audio_delay_.extra_ms += diff_ms; + video_delay_.extra_ms = base_target_delay_ms_; } } else { // if (diff_ms > 0) // The video delay is lower than the current audio delay. // We need to decrease extra audio delay, or add extra video delay. - if (channel_delay_.extra_audio_delay_ms > base_target_delay_ms_) { + if (audio_delay_.extra_ms > base_target_delay_ms_) { // We have extra delay in VoiceEngine. // Start with decreasing the voice delay. // Note: diff_ms is negative; add the negative difference. - channel_delay_.extra_audio_delay_ms += diff_ms; - channel_delay_.extra_video_delay_ms = base_target_delay_ms_; - } else { // channel_delay_.extra_audio_delay_ms > base_target_delay_ms_ + audio_delay_.extra_ms += diff_ms; + video_delay_.extra_ms = base_target_delay_ms_; + } else { // audio_delay_.extra_ms > base_target_delay_ms_ // We have no extra delay in VoiceEngine, increase the video delay. // Note: diff_ms is negative; subtract the negative difference. - channel_delay_.extra_video_delay_ms -= diff_ms; // X - (-Y) = X + Y. - channel_delay_.extra_audio_delay_ms = base_target_delay_ms_; + video_delay_.extra_ms -= diff_ms; // X - (-Y) = X + Y. + audio_delay_.extra_ms = base_target_delay_ms_; } } // Make sure that video is never below our target. - channel_delay_.extra_video_delay_ms = - std::max(channel_delay_.extra_video_delay_ms, base_target_delay_ms_); + video_delay_.extra_ms = + std::max(video_delay_.extra_ms, base_target_delay_ms_); int new_video_delay_ms; - if (channel_delay_.extra_video_delay_ms > base_target_delay_ms_) { - new_video_delay_ms = channel_delay_.extra_video_delay_ms; + if (video_delay_.extra_ms > base_target_delay_ms_) { + new_video_delay_ms = video_delay_.extra_ms; } else { // No change to the extra video delay. We are changing audio and we only // allow to change one at the time. - new_video_delay_ms = channel_delay_.last_video_delay_ms; + new_video_delay_ms = video_delay_.last_ms; } // Make sure that we don't go below the extra video delay. - new_video_delay_ms = - std::max(new_video_delay_ms, channel_delay_.extra_video_delay_ms); + new_video_delay_ms = std::max(new_video_delay_ms, video_delay_.extra_ms); // Verify we don't go above the maximum allowed video delay. new_video_delay_ms = std::min(new_video_delay_ms, base_target_delay_ms_ + kMaxDeltaDelayMs); int new_audio_delay_ms; - if (channel_delay_.extra_audio_delay_ms > base_target_delay_ms_) { - new_audio_delay_ms = channel_delay_.extra_audio_delay_ms; + if (audio_delay_.extra_ms > base_target_delay_ms_) { + new_audio_delay_ms = audio_delay_.extra_ms; } else { - // No change to the audio delay. We are changing video and we only - // allow to change one at the time. - new_audio_delay_ms = channel_delay_.last_audio_delay_ms; + // No change to the audio delay. We are changing video and we only allow to + // change one at the time. + new_audio_delay_ms = audio_delay_.last_ms; } // Make sure that we don't go below the extra audio delay. - new_audio_delay_ms = - std::max(new_audio_delay_ms, channel_delay_.extra_audio_delay_ms); + new_audio_delay_ms = std::max(new_audio_delay_ms, audio_delay_.extra_ms); // Verify we don't go above the maximum allowed audio delay. new_audio_delay_ms = std::min(new_audio_delay_ms, base_target_delay_ms_ + kMaxDeltaDelayMs); - // Remember our last audio and video delays. - channel_delay_.last_video_delay_ms = new_video_delay_ms; - channel_delay_.last_audio_delay_ms = new_audio_delay_ms; + video_delay_.last_ms = new_video_delay_ms; + audio_delay_.last_ms = new_audio_delay_ms; RTC_LOG(LS_VERBOSE) << "Sync video delay " << new_video_delay_ms << " for video stream " << video_stream_id_ - << " and audio delay " - << channel_delay_.extra_audio_delay_ms + << " and audio delay " << audio_delay_.extra_ms << " for audio stream " << audio_stream_id_; - // Return values. *total_video_delay_target_ms = new_video_delay_ms; *total_audio_delay_target_ms = new_audio_delay_ms; return true; @@ -178,16 +171,14 @@ bool StreamSynchronization::ComputeDelays(int relative_delay_ms, void StreamSynchronization::SetTargetBufferingDelay(int target_delay_ms) { // Initial extra delay for audio (accounting for existing extra delay). - channel_delay_.extra_audio_delay_ms += - target_delay_ms - base_target_delay_ms_; - channel_delay_.last_audio_delay_ms += target_delay_ms - base_target_delay_ms_; + audio_delay_.extra_ms += target_delay_ms - base_target_delay_ms_; + audio_delay_.last_ms += target_delay_ms - base_target_delay_ms_; // The video delay is compared to the last value (and how much we can update // is limited by that as well). - channel_delay_.last_video_delay_ms += target_delay_ms - base_target_delay_ms_; + video_delay_.last_ms += target_delay_ms - base_target_delay_ms_; - channel_delay_.extra_video_delay_ms += - target_delay_ms - base_target_delay_ms_; + video_delay_.extra_ms += target_delay_ms - base_target_delay_ms_; // Video is already delayed by the desired amount. base_target_delay_ms_ = target_delay_ms; diff --git a/video/stream_synchronization.h b/video/stream_synchronization.h index 9050d22acc..5f7ca6ac5b 100644 --- a/video/stream_synchronization.h +++ b/video/stream_synchronization.h @@ -30,28 +30,28 @@ class StreamSynchronization { bool ComputeDelays(int relative_delay_ms, int current_audio_delay_ms, - int* extra_audio_delay_ms, + int* total_audio_delay_target_ms, int* total_video_delay_target_ms); - // On success |relative_delay| contains the number of milliseconds later video - // is rendered relative audio. If audio is played back later than video a - // |relative_delay| will be negative. + // On success |relative_delay_ms| contains the number of milliseconds later + // video is rendered relative audio. If audio is played back later than video + // |relative_delay_ms| will be negative. static bool ComputeRelativeDelay(const Measurements& audio_measurement, const Measurements& video_measurement, int* relative_delay_ms); - // Set target buffering delay - All audio and video will be delayed by at - // least target_delay_ms. + + // Set target buffering delay. Audio and video will be delayed by at least + // |target_delay_ms|. void SetTargetBufferingDelay(int target_delay_ms); private: struct SynchronizationDelays { - int extra_video_delay_ms = 0; - int last_video_delay_ms = 0; - int extra_audio_delay_ms = 0; - int last_audio_delay_ms = 0; + int extra_ms = 0; + int last_ms = 0; }; - SynchronizationDelays channel_delay_; + SynchronizationDelays audio_delay_; + SynchronizationDelays video_delay_; const int video_stream_id_; const int audio_stream_id_; int base_target_delay_ms_;