Stop using VoEVideoSync in Call/VideoReceiveStream.

webrtc/video/stream_synchronization.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "webrtc/video/stream_synchronization.h"
 
 #include <assert.h>
 #include <math.h>
 #include <stdlib.h>
 
 #include <algorithm>
 
 #include "webrtc/base/logging.h"
 
 namespace webrtc {
 
 static const int kMaxChangeMs = 80;
 static const int kMaxDeltaDelayMs = 10000;
 static const int kFilterLength = 4;
 // Minimum difference between audio and video to warrant a change.
 static const int kMinDeltaMs = 30;
 
-StreamSynchronization::StreamSynchronization(uint32_t video_primary_ssrc,
-                                             int audio_channel_id)
-    : video_primary_ssrc_(video_primary_ssrc),
-      audio_channel_id_(audio_channel_id),
+StreamSynchronization::StreamSynchronization(int video_stream_id,
+                                             int audio_stream_id)
+    : video_stream_id_(video_stream_id),
+      audio_stream_id_(audio_stream_id),
       base_target_delay_ms_(0),
       avg_diff_ms_(0) {
 }
 
 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;
@@ skipping 22 matching lines @@
 
 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;
   LOG(LS_VERBOSE) << "Audio delay: " << current_audio_delay_ms
                   << " current diff: " << relative_delay_ms
-                  << " for channel " << audio_channel_id_;
+                  << " for stream " << audio_stream_id_;
   // 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;
 
   avg_diff_ms_ = ((kFilterLength - 1) * avg_diff_ms_ +
       current_diff_ms) / kFilterLength;
   if (abs(avg_diff_ms_) < kMinDeltaMs) {
     // Don't adjust if the diff is within our margin.
     return false;
@@ skipping 73 matching lines @@
 
   // 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;
 
   LOG(LS_VERBOSE) << "Sync video delay " << new_video_delay_ms
-                  << " for video primary SSRC " << video_primary_ssrc_
+                  << " for video stream " << video_stream_id_
                   << " and audio delay " << channel_delay_.extra_audio_delay_ms
-                  << " for audio channel " << audio_channel_id_;
+                  << " 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;
 }
 
 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_;
 
   // 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_;
 
   channel_delay_.extra_video_delay_ms +=
       target_delay_ms - base_target_delay_ms_;
 
   // Video is already delayed by the desired amount.
   base_target_delay_ms_ = target_delay_ms;
 }
 
 }  // namespace webrtc