RtpPacketReceiver base class and OnRtpPacket, with a pre-parsed RTP packet.

webrtc/call/flexfec_receive_stream_impl.h

 /*
  *  Copyright (c) 2016 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.
  */
 
 #ifndef WEBRTC_CALL_FLEXFEC_RECEIVE_STREAM_IMPL_H_
 #define WEBRTC_CALL_FLEXFEC_RECEIVE_STREAM_IMPL_H_
 
 #include <memory>
 
 #include "webrtc/base/criticalsection.h"
 #include "webrtc/call/flexfec_receive_stream.h"
+#include "webrtc/call/rtp_packet_receiver.h"
 
 namespace webrtc {
 
 class FlexfecReceiver;
 class ProcessThread;
 class ReceiveStatistics;
 class RecoveredPacketReceiver;
 class RtcpRttStats;
 class RtpPacketReceived;
 class RtpRtcp;
 
-class FlexfecReceiveStreamImpl : public FlexfecReceiveStream {
+class FlexfecReceiveStreamImpl
+    : public FlexfecReceiveStream,
+      public RtpPacketReceiver {
  public:
   FlexfecReceiveStreamImpl(const Config& config,
                            RecoveredPacketReceiver* recovered_packet_receiver,
                            RtcpRttStats* rtt_stats,
                            ProcessThread* process_thread);
   ~FlexfecReceiveStreamImpl() override;
 
   const Config& GetConfig() const { return config_; }
 
-  bool AddAndProcessReceivedPacket(const RtpPacketReceived& packet);
+  // Implements RtpPacketReceiver
+  bool OnRtpPacket(const RtpPacketReceived& packet) override;
+  const RtpConfig& rtp_config() const override;
 
   // Implements FlexfecReceiveStream.
   void Start() override;
   void Stop() override;
   Stats GetStats() const override;
 
  private:
   // Config.
   const Config config_;
+  const RtpConfig rtp_config_;

[brandtr, 2017/02/09 14:51:55]

The information in |rtp_config_| is completely based on the information in
|config_|, so it feels a bit weird to save both. But on the other hand, you
probably don't want to create a new RtpConfig for every packet being parsed in
Call.

If it makes it simpler, I'm fine with changing the structure of
FlexfecReceiveStream::Config to be more similar with
{Audio,Video}ReceiveStream::Config. Then functions accessing the fields could be
templatized.

Another idea would be to move the RTP stuff in
{Audio,Video,Flexfec}ReceiveStream::Config to the RtpConfig, and then
WebRtcVideoChannel2 would populate that struct. The different stream objects
have slightly different fields in the RTP substructs, however.

[nisse-webrtc, 2017/02/09 16:20:48]

I agree. Main show stopper at the moment is the different representation of the
rtp extensions. 

Maybe we can unify this later. But on the other hand, purpose is different, one
struct is public and intended for applications to configure things, the other is
intended to be precisely what's needed in the rtp receive logic, and we probably
don't want to expose that. Could put a layer of accessor function on top, of
course, and let applications use those.
No, if we unify, we should make sure the rtp_config things is a substruct of
*StreamConfig, so one can just return a pointer to it.
Worth exploring, but I think it's a little premature.

   bool started_ GUARDED_BY(crit_);
   rtc::CriticalSection crit_;
 
   // Erasure code interfacing.
   const std::unique_ptr<FlexfecReceiver> receiver_;
 
   // RTCP reporting.
   const std::unique_ptr<ReceiveStatistics> rtp_receive_statistics_;
   const std::unique_ptr<RtpRtcp> rtp_rtcp_;
   ProcessThread* process_thread_;
 };
 
 }  // namespace webrtc
 
 #endif  // WEBRTC_CALL_FLEXFEC_RECEIVE_STREAM_IMPL_H_