1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
|
// Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "media/cast/rtp_sender/rtp_packetizer/rtp_packetizer.h"
#include "base/memory/scoped_ptr.h"
#include "base/test/simple_test_tick_clock.h"
#include "media/cast/cast_config.h"
#include "media/cast/pacing/paced_sender.h"
#include "media/cast/rtp_common/rtp_defines.h"
#include "media/cast/rtp_sender/packet_storage/packet_storage.h"
#include "media/cast/rtp_sender/rtp_packetizer/test/rtp_header_parser.h"
#include "testing/gmock/include/gmock/gmock.h"
namespace media {
namespace cast {
static const int kPayload = 127;
static const uint32 kTimestampMs = 10;
static const uint16 kSeqNum = 33;
static const int kMaxPacketLength = 1500;
static const int kSsrc = 0x12345;
static const unsigned int kFrameSize = 5000;
static const int kMaxPacketStorageTimeMs = 300;
class TestRtpPacketTransport : public PacedPacketSender {
public:
explicit TestRtpPacketTransport(RtpPacketizerConfig config)
: config_(config),
sequence_number_(kSeqNum),
packets_sent_(0),
expected_number_of_packets_(0),
expected_packet_id_(0),
expected_frame_id_(0) {}
void VerifyRtpHeader(const RtpCastHeader& rtp_header) {
VerifyCommonRtpHeader(rtp_header);
VerifyCastRtpHeader(rtp_header);
}
void VerifyCommonRtpHeader(const RtpCastHeader& rtp_header) {
EXPECT_EQ(expected_number_of_packets_ == packets_sent_,
rtp_header.webrtc.header.markerBit);
EXPECT_EQ(kPayload, rtp_header.webrtc.header.payloadType);
EXPECT_EQ(sequence_number_, rtp_header.webrtc.header.sequenceNumber);
EXPECT_EQ(kTimestampMs * 90, rtp_header.webrtc.header.timestamp);
EXPECT_EQ(config_.ssrc, rtp_header.webrtc.header.ssrc);
EXPECT_EQ(0, rtp_header.webrtc.header.numCSRCs);
}
void VerifyCastRtpHeader(const RtpCastHeader& rtp_header) {
EXPECT_FALSE(rtp_header.is_key_frame);
EXPECT_EQ(expected_frame_id_, rtp_header.frame_id);
EXPECT_EQ(expected_packet_id_, rtp_header.packet_id);
EXPECT_EQ(expected_number_of_packets_ - 1, rtp_header.max_packet_id);
EXPECT_TRUE(rtp_header.is_reference);
EXPECT_EQ(expected_frame_id_ - 1u, rtp_header.reference_frame_id);
}
virtual bool SendPackets(const PacketList& packets) OVERRIDE {
EXPECT_EQ(expected_number_of_packets_, static_cast<int>(packets.size()));
PacketList::const_iterator it = packets.begin();
for (; it != packets.end(); ++it) {
++packets_sent_;
RtpHeaderParser parser(it->data(), it->size());
RtpCastHeader rtp_header;
parser.Parse(&rtp_header);
VerifyRtpHeader(rtp_header);
++sequence_number_;
++expected_packet_id_;
}
return true;
}
virtual bool ResendPackets(const PacketList& packets) OVERRIDE {
EXPECT_TRUE(false);
return false;
}
virtual bool SendRtcpPacket(const std::vector<uint8>& packet) OVERRIDE {
EXPECT_TRUE(false);
return false;
}
void SetExpectedNumberOfPackets(int num) {
expected_number_of_packets_ = num;
}
RtpPacketizerConfig config_;
uint32 sequence_number_;
int packets_sent_;
int expected_number_of_packets_;
// Assuming packets arrive in sequence.
int expected_packet_id_;
uint32 expected_frame_id_;
};
class RtpPacketizerTest : public ::testing::Test {
protected:
RtpPacketizerTest()
:video_frame_(),
packet_storage_(&testing_clock_, kMaxPacketStorageTimeMs) {
config_.sequence_number = kSeqNum;
config_.ssrc = kSsrc;
config_.payload_type = kPayload;
config_.max_payload_length = kMaxPacketLength;
transport_.reset(new TestRtpPacketTransport(config_));
rtp_packetizer_.reset(
new RtpPacketizer(transport_.get(), &packet_storage_, config_));
}
virtual ~RtpPacketizerTest() {}
virtual void SetUp() {
video_frame_.key_frame = false;
video_frame_.frame_id = 0;
video_frame_.last_referenced_frame_id = kStartFrameId;
video_frame_.data.assign(kFrameSize, 123);
}
base::SimpleTestTickClock testing_clock_;
scoped_ptr<RtpPacketizer> rtp_packetizer_;
RtpPacketizerConfig config_;
scoped_ptr<TestRtpPacketTransport> transport_;
EncodedVideoFrame video_frame_;
PacketStorage packet_storage_;
};
TEST_F(RtpPacketizerTest, SendStandardPackets) {
int expected_num_of_packets = kFrameSize / kMaxPacketLength + 1;
transport_->SetExpectedNumberOfPackets(expected_num_of_packets);
base::TimeTicks time;
time += base::TimeDelta::FromMilliseconds(kTimestampMs);
rtp_packetizer_->IncomingEncodedVideoFrame(&video_frame_, time);
}
TEST_F(RtpPacketizerTest, Stats) {
EXPECT_FALSE(rtp_packetizer_->send_packets_count());
EXPECT_FALSE(rtp_packetizer_->send_octet_count());
// Insert packets at varying lengths.
int expected_num_of_packets = kFrameSize / kMaxPacketLength + 1;
transport_->SetExpectedNumberOfPackets(expected_num_of_packets);
testing_clock_.Advance(base::TimeDelta::FromMilliseconds(kTimestampMs));
rtp_packetizer_->IncomingEncodedVideoFrame(&video_frame_,
testing_clock_.NowTicks());
EXPECT_EQ(expected_num_of_packets, rtp_packetizer_->send_packets_count());
EXPECT_EQ(kFrameSize, rtp_packetizer_->send_octet_count());
}
} // namespace cast
} // namespace media
|
