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
|
// 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 <gtest/gtest.h>
#include "base/memory/scoped_ptr.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"
namespace media {
namespace cast {
static const int kPayload = 127;
static const uint32 kTimestamp = 10;
static const uint16 kSeqNum = 33;
static const int kTimeOffset = 22222;
static const int kMaxPacketLength = 1500;
static const bool kMarkerBit = true;
static const int kSsrc = 0x12345;
static const uint8 kFrameId = 1;
static const unsigned int kFrameSize = 5000;
static const int kTotalHeaderLength = 19;
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) {}
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(kTimestamp * 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) {
// TODO(mikhal)
}
virtual bool SendPacket(const std::vector<uint8>& packet,
int num_packets) OVERRIDE {
EXPECT_EQ(expected_number_of_packets_, num_packets);
++packets_sent_;
RtpHeaderParser parser(packet.data(), packet.size());
RtpCastHeader rtp_header;
parser.Parse(&rtp_header);
VerifyRtpHeader(rtp_header);
++sequence_number_;
return true;
}
virtual bool ResendPacket(const std::vector<uint8>& packet,
int num_of_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_;
};
class RtpPacketizerTest : public ::testing::Test {
protected:
RtpPacketizerTest()
:video_frame_(),
packet_storage_(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_));
}
~RtpPacketizerTest() {}
void SetUp() {
video_frame_.key_frame = false;
video_frame_.frame_id = kFrameId;
video_frame_.last_referenced_frame_id = kFrameId - 1;
video_frame_.data.assign(kFrameSize, 123);
}
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);
rtp_packetizer_->IncomingEncodedVideoFrame(video_frame_, kTimestamp);
}
TEST_F(RtpPacketizerTest, Stats) {
EXPECT_FALSE(rtp_packetizer_->send_packets_count());
EXPECT_FALSE(rtp_packetizer_->send_octet_count());
// Insert packets at varying lengths.
unsigned int expected_num_of_packets = kFrameSize / kMaxPacketLength + 1;
transport_->SetExpectedNumberOfPackets(expected_num_of_packets);
rtp_packetizer_->IncomingEncodedVideoFrame(video_frame_, kTimestamp);
EXPECT_EQ(expected_num_of_packets, rtp_packetizer_->send_packets_count());
EXPECT_EQ(kFrameSize, rtp_packetizer_->send_octet_count());
}
} // namespace cast
} // namespace media
|
