Add a FlexfecReceiver class.

webrtc/modules/rtp_rtcp/include/flexfec_receiver.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_RECEIVER_H_
+#define WEBRTC_MODULES_RTP_RTCP_INCLUDE_FLEXFEC_RECEIVER_H_
+
+#include <memory>
+
+#include "webrtc/base/basictypes.h"
+#include "webrtc/modules/rtp_rtcp/include/fec_receiver.h"
+
+namespace webrtc {
+
+// Callback interface for packets recovered by FlexFEC.

[brandtr, 2016/10/05 13:15:54]

This interface is a subset of the RtpData interface:
https://cs.chromium.org/chromium/src/third_party/webrtc/modules/rtp_rtcp/incl...

I'm open for suggestions on how to/if we should harmonize these interfaces.

(In a followup CL, I will add this interface to internal::Call. It seems like a
bad idea to add a null implementation of OnReceivedPayloadData to Call, just to
be able to reuse the RtpData interface.)

[stefan-webrtc, 2016/10/05 14:45:59]

Fine with me to have a new interface.

[brandtr, 2016/10/06 08:38:57]

Acknowledged.

+class RecoveredPacketReceiver {
+ public:
+  virtual ~RecoveredPacketReceiver();

[danilchap, 2016/10/05 14:32:04]

if you do no plan to delete RecoveredPacketReceiver having pointer to abstract
class, you might want to hide destructor into protected section. (that would be
an additional signal callback passed without ownership)

Also, in this case (pure interface, no members) it is ok to have destructor
implementation in the .h file.

[brandtr, 2016/10/06 08:38:57]

Good idea, done!

+
+  virtual bool OnRecoveredPacket(const uint8_t* packet, size_t length) = 0;
+};
+
+class FlexfecReceiver {
+ public:
+  static std::unique_ptr<FlexfecReceiver> Create(
+      uint32_t flexfec_ssrc,
+      uint32_t protected_media_ssrc,
+      RecoveredPacketReceiver* callback);
+  virtual ~FlexfecReceiver();
+
+  // Inserts a received packet (can be either media or FlexFEC) into the
+  // internal buffer.
+  virtual bool AddReceivedPacket(const uint8_t* packet,
+                                 size_t packet_length) = 0;
+
+  // Sends the received packets to the erasure code and returns all
+  // recovered media packets through the callback.
+  virtual bool ProcessReceivedPackets() = 0;

[stefan-webrtc, 2016/10/05 14:45:59]

Is it worth having this method, or should we simply always process if we have
received a packet?

[brandtr, 2016/10/06 08:38:57]

Currently, we always process whenever we receive a packet. I've simplified the
public interface to make this clear.

+
+  // Returns a counter describing the added and recovered packets.
+  virtual FecPacketCounter GetPacketCounter() const = 0;
+};
+
+}  // namespace webrtc
+
+#endif  // WEBRTC_MODULES_RTP_RTCP_INCLUDE_FLEXFEC_RECEIVER_H_