blob: cd961382e962fee987c45a6e0378f850f1fe4b29 [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 "rtc_base/thread.h"
#include "test/gmock.h"
#include "test/gtest.h"
#include "test/mock_transport.h"
namespace webrtc {
namespace {
using ::testing::_;
using ::testing::Eq;
using ::testing::Property;
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.rtp.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.rtp.local_ssrc = 18374743;
config.rtcp_mode = RtcpMode::kCompound;
EXPECT_FALSE(config.IsCompleteAndEnabled());
config.payload_type = 123;
EXPECT_FALSE(config.IsCompleteAndEnabled());
config.rtp.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_)) {
receive_stream_ = std::make_unique<FlexfecReceiveStreamImpl>(
Clock::GetRealTimeClock(), config_, &recovered_packet_receiver_,
&rtt_stats_);
receive_stream_->RegisterWithTransport(&rtp_stream_receiver_controller_);
}
~FlexfecReceiveStreamTest() {
receive_stream_->UnregisterFromTransport();
}
rtc::AutoThread main_thread_;
MockTransport rtcp_send_transport_;
FlexfecReceiveStream::Config config_;
MockRecoveredPacketReceiver recovered_packet_receiver_;
MockRtcpRttStats rtt_stats_;
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
EXPECT_CALL(recovered_packet_receiver_,
OnRecoveredPacket(Property(&RtpPacketReceived::payload_size,
Eq(kPayloadLength[1]))));
receive_stream_->OnRtpPacket(ParsePacket(kFlexfecPacket));
// Tear-down
receive_stream_->UnregisterFromTransport();
}
} // namespace webrtc