Add FlexfecSender.

webrtc/modules/rtp_rtcp/include/flexfec_sender.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_MODULES_RTP_RTCP_INCLUDE_FLEXFEC_SENDER_H_
+#define WEBRTC_MODULES_RTP_RTCP_INCLUDE_FLEXFEC_SENDER_H_
+
+#include <memory>
+#include <vector>
+
+#include "webrtc/config.h"
+#include "webrtc/base/basictypes.h"
+#include "webrtc/modules/include/module_common_types.h"
+#include "webrtc/modules/rtp_rtcp/source/rtp_packet_to_send.h"

[brandtr, 2016/10/20 13:19:42]

I guess the RtpPacket classes will become "public" when the packetization module
project is done?

[danilchap, 2016/10/20 15:12:57]

Either it will go into /include/ of some module (rtp_rtcp or new one) or all rtp
specific code (including this FlexfecSender) will gather inside rtp_rtcp.
Either way this include should be fine.

[brandtr, 2016/10/24 12:52:07]

Right. But in the latter case (all RTP code in the rtp_rtcp module), this
interface will still be included from outside the rtp_rtcp module. Specifically,
either from VideoSendStream (with current design) or from PacedSender (with
future design). Or do you mean that even those classes would be part of the
expanded rtp_rtcp module?

[danilchap, 2016/10/24 13:40:31]

In the latter case:
If paced sender would be designed just for rtp packets, it will make sense to
move it into rtp_rtcp.
If paced sender would be for generic packets, it will make sense to update
current interface to return rtc::CopyOnWriteBuffer instead of RtpPacketToSend.
(this case is behind two large ifs, so it is preliminary to make changes for it)

[brandtr, 2016/10/24 14:16:30]

Got it!

+#include "webrtc/system_wrappers/include/clock.h"
+
+namespace webrtc {
+
+// TODO(brandtr): Update this interface when FlexfecSender is hooked up
+// to PacedSender.
+class FlexfecSender {

[danilchap, 2016/10/20 15:12:57]

this class doesn't send anything, it only generates fec packets.
Does name reflect future plans, i.e. do you plan to emit packets via some kind
of transport?

[brandtr, 2016/10/24 12:52:07]

If your definition of "sending packets" is "emitting packets through a
transport", then no, this class does not currently send packets. The purpose of
this class is to obtain RTP media packets, decide when it's time to generate FEC
packets, and then forward the generated FEC packets to some other class that
will push them to the network.

Currently, I'm reusing parts of the RTPSender pipeline for the latter stages
(forwarding the FEC packets to the network). The reason is that then I can
easily reuse our current logic for setting the FEC rates, which happens through
RTPSender. In the future, FlexfecSender will be connected to PacedSender and the
API will change: the PacedSender will issue a call to FlexfecSender when it's
time to generate FEC, and FlexfecSender will forward generated FlexFEC packets
(with a suitable FEC rate) directly to a transport. So then, yes, this class
will "send" packets.

[danilchap, 2016/10/24 13:40:31]

Since it plan to put packet to transport itself, 'Sender' is proper name.
My view that generator/sender hints interface: You give something to generator,
then you need take result back. (current interface)
If you give something to sender, you may forget about it - class will forward it
somewhere else eventually. (that what you plan)

[brandtr, 2016/10/24 14:16:30]

Makes sense! So I should probably rename ProducerFec -> UlpfecGenerator.

+ public:
+  static std::unique_ptr<FlexfecSender> Create(
+      int flexfec_payload_type,
+      uint32_t flexfec_ssrc,
+      uint32_t protected_media_ssrc,
+      std::vector<RtpExtension> rtp_header_extensions,
+      Clock* clock);
+  virtual ~FlexfecSender() = default;
+
+  // Sets the FEC rate, max frames sent before FEC packets are sent,
+  // and what type of generator matrices are used.
+  virtual void SetFecParameters(const FecProtectionParams* params) = 0;

[danilchap, 2016/10/20 15:12:57]

may be pass by const& (since internally it is assumed to be not null and not
stored by pointer)

[brandtr, 2016/10/24 12:52:07]

Agree. I just replicated the interface from ProducerFec here.

+
+  // Adds a media packet to the internal buffer. When enough media packets
+  // have been added, the FEC packets are generated and stored internally.
+  // These FEC packets are then obtained by calling GetFecPackets().
+  virtual int AddRtpPacketAndGenerateFec(RtpPacketToSend* packet) = 0;

[danilchap, 2016/10/20 15:12:57]

what does this function return?

[brandtr, 2016/10/24 12:52:07]

Added description. Also made parameter const& based on other comment.

+
+  // Returns true if there are generated FEC packets available.
+  virtual bool FecAvailable() const = 0;
+
+  // Returns generated FlexFEC packets.
+  virtual std::vector<std::unique_ptr<RtpPacketToSend>> GetFecPackets() = 0;
+
+  // Returns the overhead, per packet, for FlexFEC.
+  virtual size_t MaxPacketOverhead() const = 0;
+};
+
+}  // namespace webrtc
+
+#endif  // WEBRTC_MODULES_RTP_RTCP_INCLUDE_FLEXFEC_SENDER_H_