eec21bdae3
This CL removes copy and assign support from Buffer and changes various parameters from Buffer to CopyOnWriteBuffer so they can be passed along and copied without actually copying the underlying data. With this changed some parameters to be "const" and fixed an issue when creating a CopyOnWriteBuffer with empty data. BUG=webrtc:5155 Review URL: https://codereview.webrtc.org/1823503002 Cr-Commit-Position: refs/heads/master@{#12062}
461 lines
14 KiB
C++
461 lines
14 KiB
C++
/*
|
|
* Copyright (c) 2012 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 <memory>
|
|
#include <string>
|
|
|
|
#include "webrtc/base/copyonwritebuffer.h"
|
|
#include "webrtc/base/gunit.h"
|
|
#include "webrtc/base/helpers.h"
|
|
#include "webrtc/base/ssladapter.h"
|
|
#include "webrtc/base/timing.h"
|
|
#include "webrtc/media/base/fakenetworkinterface.h"
|
|
#include "webrtc/media/base/mediaconstants.h"
|
|
#include "webrtc/media/base/rtpdataengine.h"
|
|
#include "webrtc/media/base/rtputils.h"
|
|
|
|
class FakeTiming : public rtc::Timing {
|
|
public:
|
|
FakeTiming() : now_(0.0) {}
|
|
|
|
virtual double TimerNow() {
|
|
return now_;
|
|
}
|
|
|
|
void set_now(double now) {
|
|
now_ = now;
|
|
}
|
|
|
|
private:
|
|
double now_;
|
|
};
|
|
|
|
class FakeDataReceiver : public sigslot::has_slots<> {
|
|
public:
|
|
FakeDataReceiver() : has_received_data_(false) {}
|
|
|
|
void OnDataReceived(
|
|
const cricket::ReceiveDataParams& params,
|
|
const char* data, size_t len) {
|
|
has_received_data_ = true;
|
|
last_received_data_ = std::string(data, len);
|
|
last_received_data_len_ = len;
|
|
last_received_data_params_ = params;
|
|
}
|
|
|
|
bool has_received_data() const { return has_received_data_; }
|
|
std::string last_received_data() const { return last_received_data_; }
|
|
size_t last_received_data_len() const { return last_received_data_len_; }
|
|
cricket::ReceiveDataParams last_received_data_params() const {
|
|
return last_received_data_params_;
|
|
}
|
|
|
|
private:
|
|
bool has_received_data_;
|
|
std::string last_received_data_;
|
|
size_t last_received_data_len_;
|
|
cricket::ReceiveDataParams last_received_data_params_;
|
|
};
|
|
|
|
class RtpDataMediaChannelTest : public testing::Test {
|
|
protected:
|
|
virtual void SetUp() {
|
|
// Seed needed for each test to satisfy expectations.
|
|
iface_.reset(new cricket::FakeNetworkInterface());
|
|
timing_ = new FakeTiming();
|
|
dme_.reset(CreateEngine(timing_));
|
|
receiver_.reset(new FakeDataReceiver());
|
|
}
|
|
|
|
void SetNow(double now) {
|
|
timing_->set_now(now);
|
|
}
|
|
|
|
cricket::RtpDataEngine* CreateEngine(FakeTiming* timing) {
|
|
cricket::RtpDataEngine* dme = new cricket::RtpDataEngine();
|
|
dme->SetTiming(timing);
|
|
return dme;
|
|
}
|
|
|
|
cricket::RtpDataMediaChannel* CreateChannel() {
|
|
return CreateChannel(dme_.get());
|
|
}
|
|
|
|
cricket::RtpDataMediaChannel* CreateChannel(cricket::RtpDataEngine* dme) {
|
|
cricket::RtpDataMediaChannel* channel =
|
|
static_cast<cricket::RtpDataMediaChannel*>(dme->CreateChannel(
|
|
cricket::DCT_RTP));
|
|
channel->SetInterface(iface_.get());
|
|
channel->SignalDataReceived.connect(
|
|
receiver_.get(), &FakeDataReceiver::OnDataReceived);
|
|
return channel;
|
|
}
|
|
|
|
FakeDataReceiver* receiver() {
|
|
return receiver_.get();
|
|
}
|
|
|
|
bool HasReceivedData() {
|
|
return receiver_->has_received_data();
|
|
}
|
|
|
|
std::string GetReceivedData() {
|
|
return receiver_->last_received_data();
|
|
}
|
|
|
|
size_t GetReceivedDataLen() {
|
|
return receiver_->last_received_data_len();
|
|
}
|
|
|
|
cricket::ReceiveDataParams GetReceivedDataParams() {
|
|
return receiver_->last_received_data_params();
|
|
}
|
|
|
|
bool HasSentData(int count) {
|
|
return (iface_->NumRtpPackets() > count);
|
|
}
|
|
|
|
std::string GetSentData(int index) {
|
|
// Assume RTP header of length 12
|
|
std::unique_ptr<const rtc::CopyOnWriteBuffer> packet(
|
|
iface_->GetRtpPacket(index));
|
|
if (packet->size() > 12) {
|
|
return std::string(packet->data<char>() + 12, packet->size() - 12);
|
|
} else {
|
|
return "";
|
|
}
|
|
}
|
|
|
|
cricket::RtpHeader GetSentDataHeader(int index) {
|
|
std::unique_ptr<const rtc::CopyOnWriteBuffer> packet(
|
|
iface_->GetRtpPacket(index));
|
|
cricket::RtpHeader header;
|
|
GetRtpHeader(packet->data(), packet->size(), &header);
|
|
return header;
|
|
}
|
|
|
|
private:
|
|
std::unique_ptr<cricket::RtpDataEngine> dme_;
|
|
// Timing passed into dme_. Owned by dme_;
|
|
FakeTiming* timing_;
|
|
std::unique_ptr<cricket::FakeNetworkInterface> iface_;
|
|
std::unique_ptr<FakeDataReceiver> receiver_;
|
|
};
|
|
|
|
TEST_F(RtpDataMediaChannelTest, SetUnknownCodecs) {
|
|
std::unique_ptr<cricket::RtpDataMediaChannel> dmc(CreateChannel());
|
|
|
|
cricket::DataCodec known_codec;
|
|
known_codec.id = 103;
|
|
known_codec.name = "google-data";
|
|
cricket::DataCodec unknown_codec;
|
|
unknown_codec.id = 104;
|
|
unknown_codec.name = "unknown-data";
|
|
|
|
cricket::DataSendParameters send_parameters_known;
|
|
send_parameters_known.codecs.push_back(known_codec);
|
|
cricket::DataRecvParameters recv_parameters_known;
|
|
recv_parameters_known.codecs.push_back(known_codec);
|
|
|
|
cricket::DataSendParameters send_parameters_unknown;
|
|
send_parameters_unknown.codecs.push_back(unknown_codec);
|
|
cricket::DataRecvParameters recv_parameters_unknown;
|
|
recv_parameters_unknown.codecs.push_back(unknown_codec);
|
|
|
|
cricket::DataSendParameters send_parameters_mixed;
|
|
send_parameters_mixed.codecs.push_back(known_codec);
|
|
send_parameters_mixed.codecs.push_back(unknown_codec);
|
|
cricket::DataRecvParameters recv_parameters_mixed;
|
|
recv_parameters_mixed.codecs.push_back(known_codec);
|
|
recv_parameters_mixed.codecs.push_back(unknown_codec);
|
|
|
|
EXPECT_TRUE(dmc->SetSendParameters(send_parameters_known));
|
|
EXPECT_FALSE(dmc->SetSendParameters(send_parameters_unknown));
|
|
EXPECT_TRUE(dmc->SetSendParameters(send_parameters_mixed));
|
|
EXPECT_TRUE(dmc->SetRecvParameters(recv_parameters_known));
|
|
EXPECT_FALSE(dmc->SetRecvParameters(recv_parameters_unknown));
|
|
EXPECT_FALSE(dmc->SetRecvParameters(recv_parameters_mixed));
|
|
}
|
|
|
|
TEST_F(RtpDataMediaChannelTest, AddRemoveSendStream) {
|
|
std::unique_ptr<cricket::RtpDataMediaChannel> dmc(CreateChannel());
|
|
|
|
cricket::StreamParams stream1;
|
|
stream1.add_ssrc(41);
|
|
EXPECT_TRUE(dmc->AddSendStream(stream1));
|
|
cricket::StreamParams stream2;
|
|
stream2.add_ssrc(42);
|
|
EXPECT_TRUE(dmc->AddSendStream(stream2));
|
|
|
|
EXPECT_TRUE(dmc->RemoveSendStream(41));
|
|
EXPECT_TRUE(dmc->RemoveSendStream(42));
|
|
EXPECT_FALSE(dmc->RemoveSendStream(43));
|
|
}
|
|
|
|
TEST_F(RtpDataMediaChannelTest, AddRemoveRecvStream) {
|
|
std::unique_ptr<cricket::RtpDataMediaChannel> dmc(CreateChannel());
|
|
|
|
cricket::StreamParams stream1;
|
|
stream1.add_ssrc(41);
|
|
EXPECT_TRUE(dmc->AddRecvStream(stream1));
|
|
cricket::StreamParams stream2;
|
|
stream2.add_ssrc(42);
|
|
EXPECT_TRUE(dmc->AddRecvStream(stream2));
|
|
EXPECT_FALSE(dmc->AddRecvStream(stream2));
|
|
|
|
EXPECT_TRUE(dmc->RemoveRecvStream(41));
|
|
EXPECT_TRUE(dmc->RemoveRecvStream(42));
|
|
}
|
|
|
|
TEST_F(RtpDataMediaChannelTest, SendData) {
|
|
std::unique_ptr<cricket::RtpDataMediaChannel> dmc(CreateChannel());
|
|
|
|
cricket::SendDataParams params;
|
|
params.ssrc = 42;
|
|
unsigned char data[] = "food";
|
|
rtc::CopyOnWriteBuffer payload(data, 4);
|
|
unsigned char padded_data[] = {
|
|
0x00, 0x00, 0x00, 0x00,
|
|
'f', 'o', 'o', 'd',
|
|
};
|
|
cricket::SendDataResult result;
|
|
|
|
// Not sending
|
|
EXPECT_FALSE(dmc->SendData(params, payload, &result));
|
|
EXPECT_EQ(cricket::SDR_ERROR, result);
|
|
EXPECT_FALSE(HasSentData(0));
|
|
ASSERT_TRUE(dmc->SetSend(true));
|
|
|
|
// Unknown stream name.
|
|
EXPECT_FALSE(dmc->SendData(params, payload, &result));
|
|
EXPECT_EQ(cricket::SDR_ERROR, result);
|
|
EXPECT_FALSE(HasSentData(0));
|
|
|
|
cricket::StreamParams stream;
|
|
stream.add_ssrc(42);
|
|
ASSERT_TRUE(dmc->AddSendStream(stream));
|
|
|
|
// Unknown codec;
|
|
EXPECT_FALSE(dmc->SendData(params, payload, &result));
|
|
EXPECT_EQ(cricket::SDR_ERROR, result);
|
|
EXPECT_FALSE(HasSentData(0));
|
|
|
|
cricket::DataCodec codec;
|
|
codec.id = 103;
|
|
codec.name = cricket::kGoogleRtpDataCodecName;
|
|
cricket::DataSendParameters parameters;
|
|
parameters.codecs.push_back(codec);
|
|
ASSERT_TRUE(dmc->SetSendParameters(parameters));
|
|
|
|
// Length too large;
|
|
std::string x10000(10000, 'x');
|
|
EXPECT_FALSE(dmc->SendData(
|
|
params, rtc::CopyOnWriteBuffer(x10000.data(), x10000.length()), &result));
|
|
EXPECT_EQ(cricket::SDR_ERROR, result);
|
|
EXPECT_FALSE(HasSentData(0));
|
|
|
|
// Finally works!
|
|
EXPECT_TRUE(dmc->SendData(params, payload, &result));
|
|
EXPECT_EQ(cricket::SDR_SUCCESS, result);
|
|
ASSERT_TRUE(HasSentData(0));
|
|
EXPECT_EQ(sizeof(padded_data), GetSentData(0).length());
|
|
EXPECT_EQ(0, memcmp(
|
|
padded_data, GetSentData(0).data(), sizeof(padded_data)));
|
|
cricket::RtpHeader header0 = GetSentDataHeader(0);
|
|
EXPECT_NE(0, header0.seq_num);
|
|
EXPECT_NE(0U, header0.timestamp);
|
|
EXPECT_EQ(header0.ssrc, 42U);
|
|
EXPECT_EQ(header0.payload_type, 103);
|
|
|
|
// Should bump timestamp by 180000 because the clock rate is 90khz.
|
|
SetNow(2);
|
|
|
|
EXPECT_TRUE(dmc->SendData(params, payload, &result));
|
|
ASSERT_TRUE(HasSentData(1));
|
|
EXPECT_EQ(sizeof(padded_data), GetSentData(1).length());
|
|
EXPECT_EQ(0, memcmp(
|
|
padded_data, GetSentData(1).data(), sizeof(padded_data)));
|
|
cricket::RtpHeader header1 = GetSentDataHeader(1);
|
|
EXPECT_EQ(header1.ssrc, 42U);
|
|
EXPECT_EQ(header1.payload_type, 103);
|
|
EXPECT_EQ(static_cast<uint16_t>(header0.seq_num + 1),
|
|
static_cast<uint16_t>(header1.seq_num));
|
|
EXPECT_EQ(header0.timestamp + 180000, header1.timestamp);
|
|
}
|
|
|
|
TEST_F(RtpDataMediaChannelTest, SendDataMultipleClocks) {
|
|
// Timings owned by RtpDataEngines.
|
|
FakeTiming* timing1 = new FakeTiming();
|
|
std::unique_ptr<cricket::RtpDataEngine> dme1(CreateEngine(timing1));
|
|
std::unique_ptr<cricket::RtpDataMediaChannel> dmc1(
|
|
CreateChannel(dme1.get()));
|
|
FakeTiming* timing2 = new FakeTiming();
|
|
std::unique_ptr<cricket::RtpDataEngine> dme2(CreateEngine(timing2));
|
|
std::unique_ptr<cricket::RtpDataMediaChannel> dmc2(
|
|
CreateChannel(dme2.get()));
|
|
|
|
ASSERT_TRUE(dmc1->SetSend(true));
|
|
ASSERT_TRUE(dmc2->SetSend(true));
|
|
|
|
cricket::StreamParams stream1;
|
|
stream1.add_ssrc(41);
|
|
ASSERT_TRUE(dmc1->AddSendStream(stream1));
|
|
cricket::StreamParams stream2;
|
|
stream2.add_ssrc(42);
|
|
ASSERT_TRUE(dmc2->AddSendStream(stream2));
|
|
|
|
cricket::DataCodec codec;
|
|
codec.id = 103;
|
|
codec.name = cricket::kGoogleRtpDataCodecName;
|
|
cricket::DataSendParameters parameters;
|
|
parameters.codecs.push_back(codec);
|
|
ASSERT_TRUE(dmc1->SetSendParameters(parameters));
|
|
ASSERT_TRUE(dmc2->SetSendParameters(parameters));
|
|
|
|
cricket::SendDataParams params1;
|
|
params1.ssrc = 41;
|
|
cricket::SendDataParams params2;
|
|
params2.ssrc = 42;
|
|
|
|
unsigned char data[] = "foo";
|
|
rtc::CopyOnWriteBuffer payload(data, 3);
|
|
cricket::SendDataResult result;
|
|
|
|
EXPECT_TRUE(dmc1->SendData(params1, payload, &result));
|
|
EXPECT_TRUE(dmc2->SendData(params2, payload, &result));
|
|
|
|
// Should bump timestamp by 90000 because the clock rate is 90khz.
|
|
timing1->set_now(1);
|
|
// Should bump timestamp by 180000 because the clock rate is 90khz.
|
|
timing2->set_now(2);
|
|
|
|
EXPECT_TRUE(dmc1->SendData(params1, payload, &result));
|
|
EXPECT_TRUE(dmc2->SendData(params2, payload, &result));
|
|
|
|
ASSERT_TRUE(HasSentData(3));
|
|
cricket::RtpHeader header1a = GetSentDataHeader(0);
|
|
cricket::RtpHeader header2a = GetSentDataHeader(1);
|
|
cricket::RtpHeader header1b = GetSentDataHeader(2);
|
|
cricket::RtpHeader header2b = GetSentDataHeader(3);
|
|
|
|
EXPECT_EQ(static_cast<uint16_t>(header1a.seq_num + 1),
|
|
static_cast<uint16_t>(header1b.seq_num));
|
|
EXPECT_EQ(header1a.timestamp + 90000, header1b.timestamp);
|
|
EXPECT_EQ(static_cast<uint16_t>(header2a.seq_num + 1),
|
|
static_cast<uint16_t>(header2b.seq_num));
|
|
EXPECT_EQ(header2a.timestamp + 180000, header2b.timestamp);
|
|
}
|
|
|
|
TEST_F(RtpDataMediaChannelTest, SendDataRate) {
|
|
std::unique_ptr<cricket::RtpDataMediaChannel> dmc(CreateChannel());
|
|
|
|
ASSERT_TRUE(dmc->SetSend(true));
|
|
|
|
cricket::DataCodec codec;
|
|
codec.id = 103;
|
|
codec.name = cricket::kGoogleRtpDataCodecName;
|
|
cricket::DataSendParameters parameters;
|
|
parameters.codecs.push_back(codec);
|
|
ASSERT_TRUE(dmc->SetSendParameters(parameters));
|
|
|
|
cricket::StreamParams stream;
|
|
stream.add_ssrc(42);
|
|
ASSERT_TRUE(dmc->AddSendStream(stream));
|
|
|
|
cricket::SendDataParams params;
|
|
params.ssrc = 42;
|
|
unsigned char data[] = "food";
|
|
rtc::CopyOnWriteBuffer payload(data, 4);
|
|
cricket::SendDataResult result;
|
|
|
|
// With rtp overhead of 32 bytes, each one of our packets is 36
|
|
// bytes, or 288 bits. So, a limit of 872bps will allow 3 packets,
|
|
// but not four.
|
|
parameters.max_bandwidth_bps = 872;
|
|
ASSERT_TRUE(dmc->SetSendParameters(parameters));
|
|
|
|
EXPECT_TRUE(dmc->SendData(params, payload, &result));
|
|
EXPECT_TRUE(dmc->SendData(params, payload, &result));
|
|
EXPECT_TRUE(dmc->SendData(params, payload, &result));
|
|
EXPECT_FALSE(dmc->SendData(params, payload, &result));
|
|
EXPECT_FALSE(dmc->SendData(params, payload, &result));
|
|
|
|
SetNow(0.9);
|
|
EXPECT_FALSE(dmc->SendData(params, payload, &result));
|
|
|
|
SetNow(1.1);
|
|
EXPECT_TRUE(dmc->SendData(params, payload, &result));
|
|
EXPECT_TRUE(dmc->SendData(params, payload, &result));
|
|
SetNow(1.9);
|
|
EXPECT_TRUE(dmc->SendData(params, payload, &result));
|
|
|
|
SetNow(2.2);
|
|
EXPECT_TRUE(dmc->SendData(params, payload, &result));
|
|
EXPECT_TRUE(dmc->SendData(params, payload, &result));
|
|
EXPECT_TRUE(dmc->SendData(params, payload, &result));
|
|
EXPECT_FALSE(dmc->SendData(params, payload, &result));
|
|
}
|
|
|
|
TEST_F(RtpDataMediaChannelTest, ReceiveData) {
|
|
// PT= 103, SN=2, TS=3, SSRC = 4, data = "abcde"
|
|
unsigned char data[] = {
|
|
0x80, 0x67, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x2A,
|
|
0x00, 0x00, 0x00, 0x00,
|
|
'a', 'b', 'c', 'd', 'e'
|
|
};
|
|
rtc::CopyOnWriteBuffer packet(data, sizeof(data));
|
|
|
|
std::unique_ptr<cricket::RtpDataMediaChannel> dmc(CreateChannel());
|
|
|
|
// SetReceived not called.
|
|
dmc->OnPacketReceived(&packet, rtc::PacketTime());
|
|
EXPECT_FALSE(HasReceivedData());
|
|
|
|
dmc->SetReceive(true);
|
|
|
|
// Unknown payload id
|
|
dmc->OnPacketReceived(&packet, rtc::PacketTime());
|
|
EXPECT_FALSE(HasReceivedData());
|
|
|
|
cricket::DataCodec codec;
|
|
codec.id = 103;
|
|
codec.name = cricket::kGoogleRtpDataCodecName;
|
|
cricket::DataRecvParameters parameters;
|
|
parameters.codecs.push_back(codec);
|
|
ASSERT_TRUE(dmc->SetRecvParameters(parameters));
|
|
|
|
// Unknown stream
|
|
dmc->OnPacketReceived(&packet, rtc::PacketTime());
|
|
EXPECT_FALSE(HasReceivedData());
|
|
|
|
cricket::StreamParams stream;
|
|
stream.add_ssrc(42);
|
|
ASSERT_TRUE(dmc->AddRecvStream(stream));
|
|
|
|
// Finally works!
|
|
dmc->OnPacketReceived(&packet, rtc::PacketTime());
|
|
EXPECT_TRUE(HasReceivedData());
|
|
EXPECT_EQ("abcde", GetReceivedData());
|
|
EXPECT_EQ(5U, GetReceivedDataLen());
|
|
}
|
|
|
|
TEST_F(RtpDataMediaChannelTest, InvalidRtpPackets) {
|
|
unsigned char data[] = {
|
|
0x80, 0x65, 0x00, 0x02
|
|
};
|
|
rtc::CopyOnWriteBuffer packet(data, sizeof(data));
|
|
|
|
std::unique_ptr<cricket::RtpDataMediaChannel> dmc(CreateChannel());
|
|
|
|
// Too short
|
|
dmc->OnPacketReceived(&packet, rtc::PacketTime());
|
|
EXPECT_FALSE(HasReceivedData());
|
|
}
|