Protected streams report RTP messages directly to the FlexFec streams

webrtc/video/rtp_video_stream_receiver.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/rtp_video_stream_receiver.h"
 
+#include <algorithm>
 #include <utility>
 #include <vector>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/location.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/common_types.h"
 #include "webrtc/config.h"
 #include "webrtc/media/base/mediaconstants.h"
 #include "webrtc/modules/pacing/packet_router.h"
@@ skipping 161 matching lines @@
         new NackModule(clock_, nack_sender, keyframe_request_sender));
     process_thread_->RegisterModule(nack_module_.get(), RTC_FROM_HERE);
   }
 
   packet_buffer_ = video_coding::PacketBuffer::Create(
       clock_, kPacketBufferStartSize, kPacketBufferMaxSixe, this);
   reference_finder_.reset(new video_coding::RtpFrameReferenceFinder(this));
 }
 
 RtpVideoStreamReceiver::~RtpVideoStreamReceiver() {
+  RTC_DCHECK(secondary_sinks_.empty());
+
   if (nack_module_) {
     process_thread_->DeRegisterModule(nack_module_.get());
   }
 
   process_thread_->DeRegisterModule(rtp_rtcp_.get());
 
   packet_router_->RemoveReceiveRtpModule(rtp_rtcp_.get());
   UpdateHistograms();
 }
 
@@ skipping 150 matching lines @@
   ReceivePacket(packet.data(), packet.size(), header, in_order);
   // Update receive statistics after ReceivePacket.
   // Receive statistics will be reset if the payload type changes (make sure
   // that the first packet is included in the stats).
   if (!packet.recovered()) {
     // TODO(nisse): We should pass a recovered flag to stats, to aid
     // fixing bug bugs.webrtc.org/6339.
     rtp_receive_statistics_->IncomingPacket(
         header, packet.size(), IsPacketRetransmitted(header, in_order));
   }
+
+  for (auto* secondary_sink : secondary_sinks_) {
+    secondary_sink->OnRtpPacket(packet);

[danilchap, 2017/07/19 12:07:25]

can recovered packet trigger secondary_sink? should it?

[eladalon, 2017/07/21 14:42:08]

* This is in line with the behavior before this CL, where OnRtpPacket() got
triggered on those very sinks. The only difference here is that before it got
triggered from within RtpDemuxer, and now it's triggered from an intermediary
(RtpVideoStreamReceiver) which was itself triggered by RtpDemuxer.
* Please see here
https://codereview.webrtc.org/2974453002/diff/20001/webrtc/modules/rtp_rtcp/s...,
where I have a TODO in place for this general issue:
  // TODO(eladalon): Consider using packet.recovered() to avoid processing
  // recovered packets here.
* In either case, IMHO handling this issue had better be done in a separate CL
which would be based on top of this one. It would (1) keep the CLs small and
manageable, (2) allow partial rollback and (3) unblock other CLs which depends
on this CL, but not on the recovery issue.

+  }
+}
+
+void RtpVideoStreamReceiver::AddSecondarySink(RtpPacketSinkInterface* sink) {
+  RTC_DCHECK(std::find(secondary_sinks_.cbegin(), secondary_sinks_.cend(),
+                       sink) == secondary_sinks_.cend());
+  secondary_sinks_.push_back(sink);
+}
+
+void RtpVideoStreamReceiver::RemoveSecondarySink(
+    const RtpPacketSinkInterface* sink) {
+  auto it = std::find(secondary_sinks_.begin(), secondary_sinks_.end(), sink);
+  if (it == secondary_sinks_.end()) {
+    // We might be rolling-back a call whose setup failed mid-way. In such a
+    // case, it's simpler to remove "everything" rather than remember what
+    // has already been added.
+    LOG(LS_WARNING) << "Removal of unknown sink (" << sink << ").";
+    return;
+  }
+  secondary_sinks_.erase(it);
 }
 
 int32_t RtpVideoStreamReceiver::RequestKeyFrame() {
   return rtp_rtcp_->RequestKeyFrame();
 }
 
 bool RtpVideoStreamReceiver::IsUlpfecEnabled() const {
   return config_.rtp.ulpfec.ulpfec_payload_type != -1;
 }
 
@@ skipping 306 matching lines @@
     return;
 
   if (!sprop_decoder.DecodeSprop(sprop_base64_it->second.c_str()))
     return;
 
   tracker_.InsertSpsPpsNalus(sprop_decoder.sps_nalu(),
                              sprop_decoder.pps_nalu());
 }
 
 }  // namespace webrtc