Add FlexfecReceiveStream.

webrtc/call/flexfec_receive_stream_unittest.cc

+/*
+ *  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.
+ */
+
+#include "webrtc/base/basictypes.h"
+#include "webrtc/call/flexfec_receive_stream.h"
+#include "webrtc/modules/rtp_rtcp/include/flexfec_receiver.h"
+#include "webrtc/modules/rtp_rtcp/source/byte_io.h"
+#include "webrtc/modules/rtp_rtcp/mocks/mock_recovered_packet_receiver.h"
+#include "webrtc/test/gmock.h"
+#include "webrtc/test/gtest.h"
+
+namespace webrtc {
+
+TEST(FlexfecReceiveStreamTest, ConstructDestruct) {
+  FlexfecReceiveStream::Config config;
+  config.flexfec_payload_type = 118;
+  config.flexfec_ssrc = 424223;
+  config.protected_media_ssrcs = {912512};
+  MockRecoveredPacketReceiver callback;
+
+  internal::FlexfecReceiveStream receive_stream(config, &callback);
+}
+
+TEST(FlexfecReceiveStreamTest, StartStop) {
+  FlexfecReceiveStream::Config config;
+  config.flexfec_payload_type = 118;
+  config.flexfec_ssrc = 1652392;
+  config.protected_media_ssrcs = {23300443};
+  MockRecoveredPacketReceiver callback;
+  internal::FlexfecReceiveStream receive_stream(config, &callback);
+
+  receive_stream.Start();
+  receive_stream.Stop();
+}
+
+TEST(FlexfecReceiveStreamTest, DoesNotProcessPacketWhenNoMediaSsrcGiven) {
+  FlexfecReceiveStream::Config config;
+  config.flexfec_payload_type = 118;
+  config.flexfec_ssrc = 424223;
+  config.protected_media_ssrcs = {};
+  MockRecoveredPacketReceiver callback;
+  internal::FlexfecReceiveStream receive_stream(config, &callback);
+  const uint8_t packet[] = {0x00, 0x11, 0x22, 0x33};
+  const size_t packet_length = sizeof(packet);
+
+  EXPECT_FALSE(
+      receive_stream.AddAndProcessReceivedPacket(packet, packet_length));
+}
+
+// TODO(brandtr): Remove when we support multistream protection.
+TEST(FlexfecReceiveStreamTest, CannotProtectMultipleMediaStreams) {
+  FlexfecReceiveStream::Config config;
+  config.flexfec_payload_type = 118;
+  config.flexfec_ssrc = 424223;
+  config.protected_media_ssrcs = {123, 456};
+  MockRecoveredPacketReceiver callback;
+  internal::FlexfecReceiveStream receive_stream(config, &callback);
+
+  ASSERT_EQ(1U, receive_stream.config().protected_media_ssrcs.size());
+  EXPECT_EQ(config.protected_media_ssrcs[0],
+            receive_stream.config().protected_media_ssrcs[0]);
+}
+
+// Create a FlexFEC packet that protects a single media packet and ensure
+// that the callback is called. Correctness of recovery is checked in the
+// FlexfecReceiver unit tests.
+TEST(FlexfecReceiveStreamTest, RecoversPacketWhenStarted) {
+  constexpr uint8_t kFlexfecPlType = 118;
+  constexpr uint8_t kFlexfecSeqNum[] = {0x00, 0x01};
+  constexpr uint8_t kFlexfecTs[] = {0x00, 0x11, 0x22, 0x33};
+  constexpr uint8_t kFlexfecSsrc[] = {0x00, 0x00, 0x00, 0x01};
+  constexpr uint8_t kMediaPlType = 107;
+  constexpr uint8_t kMediaSeqNum[] = {0x00, 0x02};
+  constexpr uint8_t kMediaTs[] = {0xaa, 0xbb, 0xcc, 0xdd};
+  constexpr uint8_t kMediaSsrc[] = {0x00, 0x00, 0x00, 0x02};
+
+  // This packet mask protects a single media packet, i.e., the FlexFEC payload
+  // is a copy of that media packet. When inserted in the FlexFEC pipeline,
+  // it will thus trivially recover the lost media packet.
+  constexpr uint8_t kKBit0 = 1 << 7;
+  constexpr uint8_t kFlexfecPktMask[] = {kKBit0 | 0x00, 0x01};
+  constexpr uint8_t kPayloadLength[] = {0x00, 0x04};
+  constexpr uint8_t kSsrcCount = 1;
+  constexpr uint8_t kReservedBits = 0x00;
+  constexpr uint8_t kPayloadBits = 0x00;
+  // clang-format off
+  constexpr uint8_t kFlexfecPacket[] = {
+      // RTP header.
+      0x80,            kFlexfecPlType,  kFlexfecSeqNum[0],  kFlexfecSeqNum[1],
+      kFlexfecTs[0],   kFlexfecTs[1],   kFlexfecTs[2],      kFlexfecTs[3],
+      kFlexfecSsrc[0], kFlexfecSsrc[1], kFlexfecSsrc[2],    kFlexfecSsrc[3],
+      // FlexFEC header.
+      0x00,            kMediaPlType,    kPayloadLength[0],  kPayloadLength[1],
+      kMediaTs[0],     kMediaTs[1],     kMediaTs[2],        kMediaTs[3],
+      kSsrcCount,      kReservedBits,   kReservedBits,      kReservedBits,
+      kMediaSsrc[0],   kMediaSsrc[1],   kMediaSsrc[2],      kMediaSsrc[3],
+      kMediaSeqNum[0], kMediaSeqNum[1], kFlexfecPktMask[0], kFlexfecPktMask[1],
+      // FEC payload.
+      kPayloadBits,    kPayloadBits,    kPayloadBits,       kPayloadBits};
+  // clang-format on
+  constexpr size_t kFlexfecPacketLength = sizeof(kFlexfecPacket);
+
+  FlexfecReceiveStream::Config config;
+  config.flexfec_payload_type = kFlexfecPlType;
+  config.flexfec_ssrc = ByteReader<uint32_t>::ReadBigEndian(kFlexfecSsrc);
+  config.protected_media_ssrcs = {
+      ByteReader<uint32_t>::ReadBigEndian(kMediaSsrc)};
+  testing::StrictMock<MockRecoveredPacketReceiver> recovered_packet_receiver;
+  internal::FlexfecReceiveStream receive_stream(config,
+                                                &recovered_packet_receiver);
+
+  // Do not call back before being started.
+  receive_stream.AddAndProcessReceivedPacket(kFlexfecPacket,
+                                             kFlexfecPacketLength);
+
+  // Call back after being started.
+  receive_stream.Start();
+  EXPECT_CALL(
+      recovered_packet_receiver,
+      OnRecoveredPacket(::testing::_, kRtpHeaderSize + kPayloadLength[1]));
+  receive_stream.AddAndProcessReceivedPacket(kFlexfecPacket,
+                                             kFlexfecPacketLength);
+}
+
+}  // namespace webrtc