blob: 80408c3e136bdcbc9b0c94692e84fffa81a2abfa [file] [log] [blame]
/*
* 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 "call/flexfec_receive_stream.h"
#include <cstdint>
#include <memory>
#include <vector>
#include "api/array_view.h"
#include "api/call/transport.h"
#include "api/rtp_headers.h"
#include "api/rtp_parameters.h"
#include "call/flexfec_receive_stream_impl.h"
#include "call/rtp_stream_receiver_controller.h"
#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
#include "modules/rtp_rtcp/mocks/mock_recovered_packet_receiver.h"
#include "modules/rtp_rtcp/mocks/mock_rtcp_rtt_stats.h"
#include "modules/rtp_rtcp/source/byte_io.h"
#include "modules/rtp_rtcp/source/rtp_header_extensions.h"
#include "modules/rtp_rtcp/source/rtp_packet_received.h"
#include "modules/utility/include/mock/mock_process_thread.h"
#include "test/gmock.h"
#include "test/gtest.h"
#include "test/mock_transport.h"
namespace webrtc {
namespace {
using ::testing::_;
constexpr uint8_t kFlexfecPlType = 118;
constexpr uint8_t kFlexfecSsrc[] = {0x00, 0x00, 0x00, 0x01};
constexpr uint8_t kMediaSsrc[] = {0x00, 0x00, 0x00, 0x02};
FlexfecReceiveStream::Config CreateDefaultConfig(
Transport* rtcp_send_transport) {
FlexfecReceiveStream::Config config(rtcp_send_transport);
config.payload_type = kFlexfecPlType;
config.remote_ssrc = ByteReader<uint32_t>::ReadBigEndian(kFlexfecSsrc);
config.protected_media_ssrcs = {
ByteReader<uint32_t>::ReadBigEndian(kMediaSsrc)};
EXPECT_TRUE(config.IsCompleteAndEnabled());
return config;
}
RtpPacketReceived ParsePacket(rtc::ArrayView<const uint8_t> packet) {
RtpPacketReceived parsed_packet(nullptr);
EXPECT_TRUE(parsed_packet.Parse(packet));
return parsed_packet;
}
} // namespace
TEST(FlexfecReceiveStreamConfigTest, IsCompleteAndEnabled) {
MockTransport rtcp_send_transport;
FlexfecReceiveStream::Config config(&rtcp_send_transport);
config.local_ssrc = 18374743;
config.rtcp_mode = RtcpMode::kCompound;
config.transport_cc = true;
config.rtp_header_extensions.emplace_back(TransportSequenceNumber::kUri, 7);
EXPECT_FALSE(config.IsCompleteAndEnabled());
config.payload_type = 123;
EXPECT_FALSE(config.IsCompleteAndEnabled());
config.remote_ssrc = 238423838;
EXPECT_FALSE(config.IsCompleteAndEnabled());
config.protected_media_ssrcs.push_back(138989393);
EXPECT_TRUE(config.IsCompleteAndEnabled());
config.protected_media_ssrcs.push_back(33423423);
EXPECT_FALSE(config.IsCompleteAndEnabled());
}
class FlexfecReceiveStreamTest : public ::testing::Test {
protected:
FlexfecReceiveStreamTest()
: config_(CreateDefaultConfig(&rtcp_send_transport_)) {
EXPECT_CALL(process_thread_, RegisterModule(_, _)).Times(1);
receive_stream_ = std::make_unique<FlexfecReceiveStreamImpl>(
Clock::GetRealTimeClock(), config_, &recovered_packet_receiver_,
&rtt_stats_, &process_thread_);
receive_stream_->RegisterWithTransport(&rtp_stream_receiver_controller_);
}
~FlexfecReceiveStreamTest() {
EXPECT_CALL(process_thread_, DeRegisterModule(_)).Times(1);
receive_stream_->UnregisterFromTransport();
}
MockTransport rtcp_send_transport_;
FlexfecReceiveStream::Config config_;
MockRecoveredPacketReceiver recovered_packet_receiver_;
MockRtcpRttStats rtt_stats_;
MockProcessThread process_thread_;
RtpStreamReceiverController rtp_stream_receiver_controller_;
std::unique_ptr<FlexfecReceiveStreamImpl> receive_stream_;
};
TEST_F(FlexfecReceiveStreamTest, ConstructDestruct) {}
// 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_F(FlexfecReceiveStreamTest, RecoversPacket) {
constexpr uint8_t kFlexfecSeqNum[] = {0x00, 0x01};
constexpr uint8_t kFlexfecTs[] = {0x00, 0x11, 0x22, 0x33};
constexpr uint8_t kMediaPlType = 107;
constexpr uint8_t kMediaSeqNum[] = {0x00, 0x02};
constexpr uint8_t kMediaTs[] = {0xaa, 0xbb, 0xcc, 0xdd};
// 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
::testing::StrictMock<MockRecoveredPacketReceiver> recovered_packet_receiver;
EXPECT_CALL(process_thread_, RegisterModule(_, _)).Times(1);
FlexfecReceiveStreamImpl receive_stream(Clock::GetRealTimeClock(), config_,
&recovered_packet_receiver,
&rtt_stats_, &process_thread_);
receive_stream.RegisterWithTransport(&rtp_stream_receiver_controller_);
EXPECT_CALL(recovered_packet_receiver,
OnRecoveredPacket(_, kRtpHeaderSize + kPayloadLength[1]));
receive_stream.OnRtpPacket(ParsePacket(kFlexfecPacket));
// Tear-down
EXPECT_CALL(process_thread_, DeRegisterModule(_)).Times(1);
receive_stream.UnregisterFromTransport();
}
} // namespace webrtc