1/*
2 * libjingle
3 * Copyright 2004 Google Inc.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
7 *
8 *  1. Redistributions of source code must retain the above copyright notice,
9 *     this list of conditions and the following disclaimer.
10 *  2. Redistributions in binary form must reproduce the above copyright notice,
11 *     this list of conditions and the following disclaimer in the documentation
12 *     and/or other materials provided with the distribution.
13 *  3. The name of the author may not be used to endorse or promote products
14 *     derived from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
19 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
20 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
22 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
23 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
24 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
25 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28#include <string>
29
30#include "talk/media/base/rtpdump.h"
31#include "talk/media/base/rtputils.h"
32#include "talk/media/base/testutils.h"
33#include "webrtc/base/bytebuffer.h"
34#include "webrtc/base/gunit.h"
35#include "webrtc/base/thread.h"
36
37namespace cricket {
38
39static const uint32 kTestSsrc = 1;
40
41// Test that we read the correct header fields from the RTP/RTCP packet.
42TEST(RtpDumpTest, ReadRtpDumpPacket) {
43  rtc::ByteBuffer rtp_buf;
44  RtpTestUtility::kTestRawRtpPackets[0].WriteToByteBuffer(kTestSsrc, &rtp_buf);
45  RtpDumpPacket rtp_packet(rtp_buf.Data(), rtp_buf.Length(), 0, false);
46
47  int type;
48  int seq_num;
49  uint32 ts;
50  uint32 ssrc;
51  EXPECT_FALSE(rtp_packet.is_rtcp());
52  EXPECT_TRUE(rtp_packet.IsValidRtpPacket());
53  EXPECT_FALSE(rtp_packet.IsValidRtcpPacket());
54  EXPECT_TRUE(rtp_packet.GetRtpPayloadType(&type));
55  EXPECT_EQ(0, type);
56  EXPECT_TRUE(rtp_packet.GetRtpSeqNum(&seq_num));
57  EXPECT_EQ(0, seq_num);
58  EXPECT_TRUE(rtp_packet.GetRtpTimestamp(&ts));
59  EXPECT_EQ(0U, ts);
60  EXPECT_TRUE(rtp_packet.GetRtpSsrc(&ssrc));
61  EXPECT_EQ(kTestSsrc, ssrc);
62  EXPECT_FALSE(rtp_packet.GetRtcpType(&type));
63
64  rtc::ByteBuffer rtcp_buf;
65  RtpTestUtility::kTestRawRtcpPackets[0].WriteToByteBuffer(&rtcp_buf);
66  RtpDumpPacket rtcp_packet(rtcp_buf.Data(), rtcp_buf.Length(), 0, true);
67
68  EXPECT_TRUE(rtcp_packet.is_rtcp());
69  EXPECT_FALSE(rtcp_packet.IsValidRtpPacket());
70  EXPECT_TRUE(rtcp_packet.IsValidRtcpPacket());
71  EXPECT_TRUE(rtcp_packet.GetRtcpType(&type));
72  EXPECT_EQ(0, type);
73}
74
75// Test that we read only the RTP dump file.
76TEST(RtpDumpTest, ReadRtpDumpFile) {
77  RtpDumpPacket packet;
78  rtc::MemoryStream stream;
79  RtpDumpWriter writer(&stream);
80  rtc::scoped_ptr<RtpDumpReader> reader;
81
82  // Write a RTP packet to the stream, which is a valid RTP dump. Next, we will
83  // change the first line to make the RTP dump valid or invalid.
84  ASSERT_TRUE(RtpTestUtility::WriteTestPackets(1, false, kTestSsrc, &writer));
85  stream.Rewind();
86  reader.reset(new RtpDumpReader(&stream));
87  EXPECT_EQ(rtc::SR_SUCCESS, reader->ReadPacket(&packet));
88
89  // The first line is correct.
90  stream.Rewind();
91  const char new_line[] = "#!rtpplay1.0 1.1.1.1/1\n";
92  EXPECT_EQ(rtc::SR_SUCCESS,
93            stream.WriteAll(new_line, strlen(new_line), NULL, NULL));
94  stream.Rewind();
95  reader.reset(new RtpDumpReader(&stream));
96  EXPECT_EQ(rtc::SR_SUCCESS, reader->ReadPacket(&packet));
97
98  // The first line is not correct: not started with #!rtpplay1.0.
99  stream.Rewind();
100  const char new_line2[] = "#!rtpplaz1.0 0.0.0.0/0\n";
101  EXPECT_EQ(rtc::SR_SUCCESS,
102            stream.WriteAll(new_line2, strlen(new_line2), NULL, NULL));
103  stream.Rewind();
104  reader.reset(new RtpDumpReader(&stream));
105  EXPECT_EQ(rtc::SR_ERROR, reader->ReadPacket(&packet));
106
107  // The first line is not correct: no port.
108  stream.Rewind();
109  const char new_line3[] = "#!rtpplay1.0 0.0.0.0//\n";
110  EXPECT_EQ(rtc::SR_SUCCESS,
111            stream.WriteAll(new_line3, strlen(new_line3), NULL, NULL));
112  stream.Rewind();
113  reader.reset(new RtpDumpReader(&stream));
114  EXPECT_EQ(rtc::SR_ERROR, reader->ReadPacket(&packet));
115}
116
117// Test that we read the same RTP packets that rtp dump writes.
118TEST(RtpDumpTest, WriteReadSameRtp) {
119  rtc::MemoryStream stream;
120  RtpDumpWriter writer(&stream);
121  ASSERT_TRUE(RtpTestUtility::WriteTestPackets(
122      RtpTestUtility::GetTestPacketCount(), false, kTestSsrc, &writer));
123  EXPECT_TRUE(RtpTestUtility::VerifyTestPacketsFromStream(
124      RtpTestUtility::GetTestPacketCount(), &stream, kTestSsrc));
125
126  // Check stream has only RtpTestUtility::GetTestPacketCount() packets.
127  RtpDumpPacket packet;
128  RtpDumpReader reader(&stream);
129  for (size_t i = 0; i < RtpTestUtility::GetTestPacketCount(); ++i) {
130    EXPECT_EQ(rtc::SR_SUCCESS, reader.ReadPacket(&packet));
131    uint32 ssrc;
132    EXPECT_TRUE(GetRtpSsrc(&packet.data[0], packet.data.size(), &ssrc));
133    EXPECT_EQ(kTestSsrc, ssrc);
134  }
135  // No more packets to read.
136  EXPECT_EQ(rtc::SR_EOS, reader.ReadPacket(&packet));
137
138  // Rewind the stream and read again with a specified ssrc.
139  stream.Rewind();
140  RtpDumpReader reader_w_ssrc(&stream);
141  const uint32 send_ssrc = kTestSsrc + 1;
142  reader_w_ssrc.SetSsrc(send_ssrc);
143  for (size_t i = 0; i < RtpTestUtility::GetTestPacketCount(); ++i) {
144    EXPECT_EQ(rtc::SR_SUCCESS, reader_w_ssrc.ReadPacket(&packet));
145    EXPECT_FALSE(packet.is_rtcp());
146    EXPECT_EQ(packet.original_data_len, packet.data.size());
147    uint32 ssrc;
148    EXPECT_TRUE(GetRtpSsrc(&packet.data[0], packet.data.size(), &ssrc));
149    EXPECT_EQ(send_ssrc, ssrc);
150  }
151  // No more packets to read.
152  EXPECT_EQ(rtc::SR_EOS, reader_w_ssrc.ReadPacket(&packet));
153}
154
155// Test that we read the same RTCP packets that rtp dump writes.
156TEST(RtpDumpTest, WriteReadSameRtcp) {
157  rtc::MemoryStream stream;
158  RtpDumpWriter writer(&stream);
159  ASSERT_TRUE(RtpTestUtility::WriteTestPackets(
160      RtpTestUtility::GetTestPacketCount(), true, kTestSsrc, &writer));
161  EXPECT_TRUE(RtpTestUtility::VerifyTestPacketsFromStream(
162      RtpTestUtility::GetTestPacketCount(), &stream, kTestSsrc));
163
164  // Check stream has only RtpTestUtility::GetTestPacketCount() packets.
165  RtpDumpPacket packet;
166  RtpDumpReader reader(&stream);
167  reader.SetSsrc(kTestSsrc + 1);  // Does not affect RTCP packet.
168  for (size_t i = 0; i < RtpTestUtility::GetTestPacketCount(); ++i) {
169    EXPECT_EQ(rtc::SR_SUCCESS, reader.ReadPacket(&packet));
170    EXPECT_TRUE(packet.is_rtcp());
171    EXPECT_EQ(0U, packet.original_data_len);
172  }
173  // No more packets to read.
174  EXPECT_EQ(rtc::SR_EOS, reader.ReadPacket(&packet));
175}
176
177// Test dumping only RTP packet headers.
178TEST(RtpDumpTest, WriteReadRtpHeadersOnly) {
179  rtc::MemoryStream stream;
180  RtpDumpWriter writer(&stream);
181  writer.set_packet_filter(PF_RTPHEADER);
182
183  // Write some RTP and RTCP packets. RTP packets should only have headers;
184  // RTCP packets should be eaten.
185  ASSERT_TRUE(RtpTestUtility::WriteTestPackets(
186      RtpTestUtility::GetTestPacketCount(), false, kTestSsrc, &writer));
187  ASSERT_TRUE(RtpTestUtility::WriteTestPackets(
188      RtpTestUtility::GetTestPacketCount(), true, kTestSsrc, &writer));
189  stream.Rewind();
190
191  // Check that only RTP packet headers are present.
192  RtpDumpPacket packet;
193  RtpDumpReader reader(&stream);
194  for (size_t i = 0; i < RtpTestUtility::GetTestPacketCount(); ++i) {
195    EXPECT_EQ(rtc::SR_SUCCESS, reader.ReadPacket(&packet));
196    EXPECT_FALSE(packet.is_rtcp());
197    size_t len = 0;
198    packet.GetRtpHeaderLen(&len);
199    EXPECT_EQ(len, packet.data.size());
200    EXPECT_GT(packet.original_data_len, packet.data.size());
201  }
202  // No more packets to read.
203  EXPECT_EQ(rtc::SR_EOS, reader.ReadPacket(&packet));
204}
205
206// Test dumping only RTCP packets.
207TEST(RtpDumpTest, WriteReadRtcpOnly) {
208  rtc::MemoryStream stream;
209  RtpDumpWriter writer(&stream);
210  writer.set_packet_filter(PF_RTCPPACKET);
211
212  // Write some RTP and RTCP packets. RTP packets should be eaten.
213  ASSERT_TRUE(RtpTestUtility::WriteTestPackets(
214      RtpTestUtility::GetTestPacketCount(), false, kTestSsrc, &writer));
215  ASSERT_TRUE(RtpTestUtility::WriteTestPackets(
216      RtpTestUtility::GetTestPacketCount(), true, kTestSsrc, &writer));
217  stream.Rewind();
218
219  // Check that only RTCP packets are present.
220  RtpDumpPacket packet;
221  RtpDumpReader reader(&stream);
222  for (size_t i = 0; i < RtpTestUtility::GetTestPacketCount(); ++i) {
223    EXPECT_EQ(rtc::SR_SUCCESS, reader.ReadPacket(&packet));
224    EXPECT_TRUE(packet.is_rtcp());
225    EXPECT_EQ(0U, packet.original_data_len);
226  }
227  // No more packets to read.
228  EXPECT_EQ(rtc::SR_EOS, reader.ReadPacket(&packet));
229}
230
231// Test that RtpDumpLoopReader reads RTP packets continously and the elapsed
232// time, the sequence number, and timestamp are maintained properly.
233TEST(RtpDumpTest, LoopReadRtp) {
234  rtc::MemoryStream stream;
235  RtpDumpWriter writer(&stream);
236  ASSERT_TRUE(RtpTestUtility::WriteTestPackets(
237      RtpTestUtility::GetTestPacketCount(), false, kTestSsrc, &writer));
238  EXPECT_TRUE(RtpTestUtility::VerifyTestPacketsFromStream(
239      3 * RtpTestUtility::GetTestPacketCount(), &stream, kTestSsrc));
240}
241
242// Test that RtpDumpLoopReader reads RTCP packets continously and the elapsed
243// time is maintained properly.
244TEST(RtpDumpTest, LoopReadRtcp) {
245  rtc::MemoryStream stream;
246  RtpDumpWriter writer(&stream);
247  ASSERT_TRUE(RtpTestUtility::WriteTestPackets(
248      RtpTestUtility::GetTestPacketCount(), true, kTestSsrc, &writer));
249  EXPECT_TRUE(RtpTestUtility::VerifyTestPacketsFromStream(
250      3 * RtpTestUtility::GetTestPacketCount(), &stream, kTestSsrc));
251}
252
253// Test that RtpDumpLoopReader reads continously from stream with a single RTP
254// packets.
255TEST(RtpDumpTest, LoopReadSingleRtp) {
256  rtc::MemoryStream stream;
257  RtpDumpWriter writer(&stream);
258  ASSERT_TRUE(RtpTestUtility::WriteTestPackets(1, false, kTestSsrc, &writer));
259
260  // The regular reader can read only one packet.
261  RtpDumpPacket packet;
262  stream.Rewind();
263  RtpDumpReader reader(&stream);
264  EXPECT_EQ(rtc::SR_SUCCESS, reader.ReadPacket(&packet));
265  EXPECT_EQ(rtc::SR_EOS, reader.ReadPacket(&packet));
266
267  // The loop reader reads three packets from the input stream.
268  stream.Rewind();
269  RtpDumpLoopReader loop_reader(&stream);
270  EXPECT_EQ(rtc::SR_SUCCESS, loop_reader.ReadPacket(&packet));
271  EXPECT_EQ(rtc::SR_SUCCESS, loop_reader.ReadPacket(&packet));
272  EXPECT_EQ(rtc::SR_SUCCESS, loop_reader.ReadPacket(&packet));
273}
274
275// Test that RtpDumpLoopReader reads continously from stream with a single RTCP
276// packets.
277TEST(RtpDumpTest, LoopReadSingleRtcp) {
278  rtc::MemoryStream stream;
279  RtpDumpWriter writer(&stream);
280  ASSERT_TRUE(RtpTestUtility::WriteTestPackets(1, true, kTestSsrc, &writer));
281
282  // The regular reader can read only one packet.
283  RtpDumpPacket packet;
284  stream.Rewind();
285  RtpDumpReader reader(&stream);
286  EXPECT_EQ(rtc::SR_SUCCESS, reader.ReadPacket(&packet));
287  EXPECT_EQ(rtc::SR_EOS, reader.ReadPacket(&packet));
288
289  // The loop reader reads three packets from the input stream.
290  stream.Rewind();
291  RtpDumpLoopReader loop_reader(&stream);
292  EXPECT_EQ(rtc::SR_SUCCESS, loop_reader.ReadPacket(&packet));
293  EXPECT_EQ(rtc::SR_SUCCESS, loop_reader.ReadPacket(&packet));
294  EXPECT_EQ(rtc::SR_SUCCESS, loop_reader.ReadPacket(&packet));
295}
296
297}  // namespace cricket
298