Base A/V synchronization on sync_labels.

webrtc/video/video_receive_stream.cc

 /*
  *  Copyright (c) 2013 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.
  */
 
@@ skipping 29 matching lines @@
   ss << "{decoders: [";
   for (size_t i = 0; i < decoders.size(); ++i) {
     ss << decoders[i].ToString();
     if (i != decoders.size() - 1)
       ss << ", ";
   }
   ss << ']';
   ss << ", rtp: " << rtp.ToString();
   ss << ", renderer: " << (renderer != nullptr ? "(renderer)" : "nullptr");
   ss << ", render_delay_ms: " << render_delay_ms;
-  ss << ", audio_channel_id: " << audio_channel_id;
+  if (!sync_group.empty())
+    ss << ", sync_group: " << sync_group;
   ss << ", pre_decode_callback: "
      << (pre_decode_callback != nullptr ? "(EncodedFrameObserver)" : "nullptr");
   ss << ", pre_render_callback: "
      << (pre_render_callback != nullptr ? "(I420FrameCallback)" : "nullptr");
   ss << ", target_delay_ms: " << target_delay_ms;
   ss << '}';
 
   return ss.str();
 }
 
@@ skipping 67 matching lines @@
                                        ChannelGroup* channel_group,
                                        int channel_id,
                                        const VideoReceiveStream::Config& config,
                                        newapi::Transport* transport,
                                        webrtc::VoiceEngine* voice_engine)
     : transport_adapter_(transport),
       encoded_frame_proxy_(config.pre_decode_callback),
       config_(config),
       clock_(Clock::GetRealTimeClock()),
       channel_group_(channel_group),
-      channel_id_(channel_id),
-      voe_sync_interface_(nullptr) {
+      channel_id_(channel_id) {
   CHECK(channel_group_->CreateReceiveChannel(channel_id_, 0, base_channel_id,
                                              &transport_adapter_, num_cpu_cores,
                                              true));
 
   vie_channel_ = channel_group_->GetChannel(channel_id_);
 
   // TODO(pbos): This is not fine grained enough...
   vie_channel_->SetProtectionMode(config_.rtp.nack.rtp_history_ms > 0, false,
                                   -1, -1);
   vie_channel_->SetKeyFrameRequestMethod(kKeyFrameReqPliRtcp);
@@ skipping 85 matching lines @@
     VideoCodec codec = CreateDecoderVideoCodec(decoder);
 
     CHECK_EQ(0, vie_channel_->SetReceiveCodec(codec));
   }
 
   incoming_video_stream_.reset(new IncomingVideoStream(0));
   incoming_video_stream_->SetExpectedRenderDelay(config.render_delay_ms);
   incoming_video_stream_->SetExternalCallback(this);
   vie_channel_->SetIncomingVideoStream(incoming_video_stream_.get());
 
-  if (voice_engine && config_.audio_channel_id != -1) {
-    voe_sync_interface_ = VoEVideoSync::GetInterface(voice_engine);
-    vie_channel_->SetVoiceChannel(config.audio_channel_id, voe_sync_interface_);
-  }
-
   if (config.pre_decode_callback)
     vie_channel_->RegisterPreDecodeImageCallback(&encoded_frame_proxy_);
   vie_channel_->RegisterPreRenderCallback(this);
 }
 
 VideoReceiveStream::~VideoReceiveStream() {
   incoming_video_stream_->Stop();
   vie_channel_->RegisterPreRenderCallback(nullptr);
   vie_channel_->RegisterPreDecodeImageCallback(nullptr);
 
   for (size_t i = 0; i < config_.decoders.size(); ++i)
     vie_channel_->DeRegisterExternalDecoder(config_.decoders[i].payload_type);
 
-  if (voe_sync_interface_ != nullptr) {
-    vie_channel_->SetVoiceChannel(-1, nullptr);
-    voe_sync_interface_->Release();
-  }
   vie_channel_->RegisterCodecObserver(nullptr);
   vie_channel_->RegisterReceiveChannelRtpStatisticsCallback(nullptr);
   vie_channel_->RegisterReceiveChannelRtcpStatisticsCallback(nullptr);
   vie_channel_->RegisterRtcpPacketTypeCounterObserver(nullptr);
   channel_group_->DeleteChannel(channel_id_);
 }
 
 void VideoReceiveStream::Start() {
   transport_adapter_.Enable();
   incoming_video_stream_->Start();
   vie_channel_->StartReceive();
 }
 
 void VideoReceiveStream::Stop() {
   incoming_video_stream_->Stop();
   vie_channel_->StopReceive();
   transport_adapter_.Disable();
 }
 
+void VideoReceiveStream::SetSyncChannel(VoiceEngine* voice_engine,
+                                        int audio_channel_id) {
+  if (voice_engine != nullptr && audio_channel_id != -1) {
+    VoEVideoSync* voe_sync_interface = VoEVideoSync::GetInterface(voice_engine);
+    vie_channel_->SetVoiceChannel(audio_channel_id, voe_sync_interface);
+    voe_sync_interface->Release();
+  } else {
+    vie_channel_->SetVoiceChannel(-1, nullptr);
+  }
+}
+
 VideoReceiveStream::Stats VideoReceiveStream::GetStats() const {
   return stats_proxy_->GetStats();
 }
 
 bool VideoReceiveStream::DeliverRtcp(const uint8_t* packet, size_t length) {
   return vie_channel_->ReceivedRTCPPacket(packet, length) == 0;
 }
 
 bool VideoReceiveStream::DeliverRtp(const uint8_t* packet, size_t length) {
   return vie_channel_->ReceivedRTPPacket(packet, length, PacketTime()) == 0;
@@ skipping 37 matching lines @@
     case newapi::kRtcpCompound:
       vie_channel_->SetRTCPMode(kRtcpCompound);
       break;
     case newapi::kRtcpReducedSize:
       vie_channel_->SetRTCPMode(kRtcpNonCompound);
       break;
   }
 }
 }  // namespace internal
 }  // namespace webrtc