1 // libjingle
2 // Copyright 2010 Google Inc.
3 //
4 // Redistribution and use in source and binary forms, with or without
5 // modification, are permitted provided that the following conditions are met:
6 //
7 // 1. Redistributions of source code must retain the above copyright notice,
8 // this list of conditions and the following disclaimer.
9 // 2. Redistributions in binary form must reproduce the above copyright notice,
10 // this list of conditions and the following disclaimer in the documentation
11 // and/or other materials provided with the distribution.
12 // 3. The name of the author may not be used to endorse or promote products
13 // derived from this software without specific prior written permission.
14 //
15 // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
16 // WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
17 // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
18 // EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
19 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
20 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
21 // OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
22 // WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
23 // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
24 // ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25
26 #include <string>
27
28 #include "talk/base/bytebuffer.h"
29 #include "talk/base/fileutils.h"
30 #include "talk/base/gunit.h"
31 #include "talk/base/pathutils.h"
32 #include "talk/base/thread.h"
33 #include "talk/media/base/fakemediaengine.h"
34 #include "talk/media/base/rtpdump.h"
35 #include "talk/media/base/testutils.h"
36 #include "talk/p2p/base/fakesession.h"
37 #include "talk/session/media/channel.h"
38 #include "talk/session/media/mediarecorder.h"
39
40 namespace cricket {
41
Open(const std::string & path)42 talk_base::StreamInterface* Open(const std::string& path) {
43 return talk_base::Filesystem::OpenFile(
44 talk_base::Pathname(path), "wb");
45 }
46
47 /////////////////////////////////////////////////////////////////////////
48 // Test RtpDumpSink
49 /////////////////////////////////////////////////////////////////////////
50 class RtpDumpSinkTest : public testing::Test {
51 public:
SetUp()52 virtual void SetUp() {
53 EXPECT_TRUE(talk_base::Filesystem::GetTemporaryFolder(path_, true, NULL));
54 path_.SetFilename("sink-test.rtpdump");
55 sink_.reset(new RtpDumpSink(Open(path_.pathname())));
56
57 for (int i = 0; i < ARRAY_SIZE(rtp_buf_); ++i) {
58 RtpTestUtility::kTestRawRtpPackets[i].WriteToByteBuffer(
59 RtpTestUtility::kDefaultSsrc, &rtp_buf_[i]);
60 }
61 }
62
TearDown()63 virtual void TearDown() {
64 stream_.reset();
65 EXPECT_TRUE(talk_base::Filesystem::DeleteFile(path_));
66 }
67
68 protected:
OnRtpPacket(const RawRtpPacket & raw)69 void OnRtpPacket(const RawRtpPacket& raw) {
70 talk_base::ByteBuffer buf;
71 raw.WriteToByteBuffer(RtpTestUtility::kDefaultSsrc, &buf);
72 sink_->OnPacket(buf.Data(), buf.Length(), false);
73 }
74
ReadPacket(RtpDumpPacket * packet)75 talk_base::StreamResult ReadPacket(RtpDumpPacket* packet) {
76 if (!stream_.get()) {
77 sink_.reset(); // This will close the file. So we can read it.
78 stream_.reset(talk_base::Filesystem::OpenFile(path_, "rb"));
79 reader_.reset(new RtpDumpReader(stream_.get()));
80 }
81 return reader_->ReadPacket(packet);
82 }
83
84 talk_base::Pathname path_;
85 talk_base::scoped_ptr<RtpDumpSink> sink_;
86 talk_base::ByteBuffer rtp_buf_[3];
87 talk_base::scoped_ptr<talk_base::StreamInterface> stream_;
88 talk_base::scoped_ptr<RtpDumpReader> reader_;
89 };
90
TEST_F(RtpDumpSinkTest,TestRtpDumpSink)91 TEST_F(RtpDumpSinkTest, TestRtpDumpSink) {
92 // By default, the sink is disabled. The 1st packet is not written.
93 EXPECT_FALSE(sink_->IsEnabled());
94 sink_->set_packet_filter(PF_ALL);
95 OnRtpPacket(RtpTestUtility::kTestRawRtpPackets[0]);
96
97 // Enable the sink. The 2nd packet is written.
98 EXPECT_TRUE(sink_->Enable(true));
99 EXPECT_TRUE(sink_->IsEnabled());
100 EXPECT_TRUE(talk_base::Filesystem::IsFile(path_.pathname()));
101 OnRtpPacket(RtpTestUtility::kTestRawRtpPackets[1]);
102
103 // Disable the sink. The 3rd packet is not written.
104 EXPECT_TRUE(sink_->Enable(false));
105 EXPECT_FALSE(sink_->IsEnabled());
106 OnRtpPacket(RtpTestUtility::kTestRawRtpPackets[2]);
107
108 // Read the recorded file and verify it contains only the 2nd packet.
109 RtpDumpPacket packet;
110 EXPECT_EQ(talk_base::SR_SUCCESS, ReadPacket(&packet));
111 EXPECT_TRUE(RtpTestUtility::VerifyPacket(
112 &packet, &RtpTestUtility::kTestRawRtpPackets[1], false));
113 EXPECT_EQ(talk_base::SR_EOS, ReadPacket(&packet));
114 }
115
TEST_F(RtpDumpSinkTest,TestRtpDumpSinkMaxSize)116 TEST_F(RtpDumpSinkTest, TestRtpDumpSinkMaxSize) {
117 EXPECT_TRUE(sink_->Enable(true));
118 sink_->set_packet_filter(PF_ALL);
119 sink_->SetMaxSize(strlen(RtpDumpFileHeader::kFirstLine) +
120 RtpDumpFileHeader::kHeaderLength +
121 RtpDumpPacket::kHeaderLength +
122 RtpTestUtility::kTestRawRtpPackets[0].size());
123 OnRtpPacket(RtpTestUtility::kTestRawRtpPackets[0]);
124
125 // Exceed the limit size: the 2nd and 3rd packets are not written.
126 OnRtpPacket(RtpTestUtility::kTestRawRtpPackets[1]);
127 OnRtpPacket(RtpTestUtility::kTestRawRtpPackets[2]);
128
129 // Read the recorded file and verify that it contains only the first packet.
130 RtpDumpPacket packet;
131 EXPECT_EQ(talk_base::SR_SUCCESS, ReadPacket(&packet));
132 EXPECT_TRUE(RtpTestUtility::VerifyPacket(
133 &packet, &RtpTestUtility::kTestRawRtpPackets[0], false));
134 EXPECT_EQ(talk_base::SR_EOS, ReadPacket(&packet));
135 }
136
TEST_F(RtpDumpSinkTest,TestRtpDumpSinkFilter)137 TEST_F(RtpDumpSinkTest, TestRtpDumpSinkFilter) {
138 // The default filter is PF_NONE.
139 EXPECT_EQ(PF_NONE, sink_->packet_filter());
140
141 // Set to PF_RTPHEADER before enable.
142 sink_->set_packet_filter(PF_RTPHEADER);
143 EXPECT_EQ(PF_RTPHEADER, sink_->packet_filter());
144 EXPECT_TRUE(sink_->Enable(true));
145 // We dump only the header of the first packet.
146 OnRtpPacket(RtpTestUtility::kTestRawRtpPackets[0]);
147
148 // Set the filter to PF_RTPPACKET. We dump all the second packet.
149 sink_->set_packet_filter(PF_RTPPACKET);
150 EXPECT_EQ(PF_RTPPACKET, sink_->packet_filter());
151 OnRtpPacket(RtpTestUtility::kTestRawRtpPackets[1]);
152
153 // Set the filter to PF_NONE. We do not dump the third packet.
154 sink_->set_packet_filter(PF_NONE);
155 EXPECT_EQ(PF_NONE, sink_->packet_filter());
156 OnRtpPacket(RtpTestUtility::kTestRawRtpPackets[2]);
157
158 // Read the recorded file and verify the header of the first packet and
159 // the whole packet for the second packet.
160 RtpDumpPacket packet;
161 EXPECT_EQ(talk_base::SR_SUCCESS, ReadPacket(&packet));
162 EXPECT_TRUE(RtpTestUtility::VerifyPacket(
163 &packet, &RtpTestUtility::kTestRawRtpPackets[0], true));
164 EXPECT_EQ(talk_base::SR_SUCCESS, ReadPacket(&packet));
165 EXPECT_TRUE(RtpTestUtility::VerifyPacket(
166 &packet, &RtpTestUtility::kTestRawRtpPackets[1], false));
167 EXPECT_EQ(talk_base::SR_EOS, ReadPacket(&packet));
168 }
169
170 /////////////////////////////////////////////////////////////////////////
171 // Test MediaRecorder
172 /////////////////////////////////////////////////////////////////////////
TestMediaRecorder(BaseChannel * channel,FakeVideoMediaChannel * video_media_channel,int filter)173 void TestMediaRecorder(BaseChannel* channel,
174 FakeVideoMediaChannel* video_media_channel,
175 int filter) {
176 // Create media recorder.
177 talk_base::scoped_ptr<MediaRecorder> recorder(new MediaRecorder);
178 // Fail to EnableChannel before AddChannel.
179 EXPECT_FALSE(recorder->EnableChannel(channel, true, true, SINK_PRE_CRYPTO));
180 EXPECT_FALSE(channel->HasSendSinks(SINK_PRE_CRYPTO));
181 EXPECT_FALSE(channel->HasRecvSinks(SINK_PRE_CRYPTO));
182 EXPECT_FALSE(channel->HasSendSinks(SINK_POST_CRYPTO));
183 EXPECT_FALSE(channel->HasRecvSinks(SINK_POST_CRYPTO));
184
185 // Add the channel to the recorder.
186 talk_base::Pathname path;
187 EXPECT_TRUE(talk_base::Filesystem::GetTemporaryFolder(path, true, NULL));
188 path.SetFilename("send.rtpdump");
189 std::string send_file = path.pathname();
190 path.SetFilename("recv.rtpdump");
191 std::string recv_file = path.pathname();
192 if (video_media_channel) {
193 EXPECT_TRUE(recorder->AddChannel(static_cast<VideoChannel*>(channel),
194 Open(send_file), Open(recv_file), filter));
195 } else {
196 EXPECT_TRUE(recorder->AddChannel(static_cast<VoiceChannel*>(channel),
197 Open(send_file), Open(recv_file), filter));
198 }
199
200 // Enable recording only the sent media.
201 EXPECT_TRUE(recorder->EnableChannel(channel, true, false, SINK_PRE_CRYPTO));
202 EXPECT_TRUE(channel->HasSendSinks(SINK_PRE_CRYPTO));
203 EXPECT_FALSE(channel->HasRecvSinks(SINK_POST_CRYPTO));
204 EXPECT_FALSE(channel->HasSendSinks(SINK_POST_CRYPTO));
205 EXPECT_FALSE(channel->HasRecvSinks(SINK_POST_CRYPTO));
206 if (video_media_channel) {
207 EXPECT_TRUE_WAIT(video_media_channel->sent_intra_frame(), 100);
208 }
209
210 // Enable recording only the received meida.
211 EXPECT_TRUE(recorder->EnableChannel(channel, false, true, SINK_PRE_CRYPTO));
212 EXPECT_FALSE(channel->HasSendSinks(SINK_PRE_CRYPTO));
213 EXPECT_TRUE(channel->HasRecvSinks(SINK_PRE_CRYPTO));
214 if (video_media_channel) {
215 EXPECT_TRUE(video_media_channel->requested_intra_frame());
216 }
217
218 // Enable recording both the sent and the received video.
219 EXPECT_TRUE(recorder->EnableChannel(channel, true, true, SINK_PRE_CRYPTO));
220 EXPECT_TRUE(channel->HasSendSinks(SINK_PRE_CRYPTO));
221 EXPECT_TRUE(channel->HasRecvSinks(SINK_PRE_CRYPTO));
222
223 // Enable recording only headers.
224 if (video_media_channel) {
225 video_media_channel->set_sent_intra_frame(false);
226 video_media_channel->set_requested_intra_frame(false);
227 }
228 EXPECT_TRUE(recorder->EnableChannel(channel, true, true, SINK_PRE_CRYPTO));
229 EXPECT_TRUE(channel->HasSendSinks(SINK_PRE_CRYPTO));
230 EXPECT_TRUE(channel->HasRecvSinks(SINK_PRE_CRYPTO));
231 if (video_media_channel) {
232 if ((filter & PF_RTPPACKET) == PF_RTPPACKET) {
233 // If record the whole RTP packet, trigers FIR.
234 EXPECT_TRUE(video_media_channel->requested_intra_frame());
235 EXPECT_TRUE(video_media_channel->sent_intra_frame());
236 } else {
237 // If record only the RTP header, does not triger FIR.
238 EXPECT_FALSE(video_media_channel->requested_intra_frame());
239 EXPECT_FALSE(video_media_channel->sent_intra_frame());
240 }
241 }
242
243 // Remove the voice channel from the recorder.
244 recorder->RemoveChannel(channel, SINK_PRE_CRYPTO);
245 EXPECT_FALSE(channel->HasSendSinks(SINK_PRE_CRYPTO));
246 EXPECT_FALSE(channel->HasRecvSinks(SINK_PRE_CRYPTO));
247
248 // Delete all files.
249 recorder.reset();
250 EXPECT_TRUE(talk_base::Filesystem::DeleteFile(send_file));
251 EXPECT_TRUE(talk_base::Filesystem::DeleteFile(recv_file));
252 }
253
254 // Fisrt start recording header and then start recording media. Verify that
255 // differnt files are created for header and media.
TestRecordHeaderAndMedia(BaseChannel * channel,FakeVideoMediaChannel * video_media_channel)256 void TestRecordHeaderAndMedia(BaseChannel* channel,
257 FakeVideoMediaChannel* video_media_channel) {
258 // Create RTP header recorder.
259 talk_base::scoped_ptr<MediaRecorder> header_recorder(new MediaRecorder);
260
261 talk_base::Pathname path;
262 EXPECT_TRUE(talk_base::Filesystem::GetTemporaryFolder(path, true, NULL));
263 path.SetFilename("send-header.rtpdump");
264 std::string send_header_file = path.pathname();
265 path.SetFilename("recv-header.rtpdump");
266 std::string recv_header_file = path.pathname();
267 if (video_media_channel) {
268 EXPECT_TRUE(header_recorder->AddChannel(
269 static_cast<VideoChannel*>(channel),
270 Open(send_header_file), Open(recv_header_file), PF_RTPHEADER));
271 } else {
272 EXPECT_TRUE(header_recorder->AddChannel(
273 static_cast<VoiceChannel*>(channel),
274 Open(send_header_file), Open(recv_header_file), PF_RTPHEADER));
275 }
276
277 // Enable recording both sent and received.
278 EXPECT_TRUE(
279 header_recorder->EnableChannel(channel, true, true, SINK_POST_CRYPTO));
280 EXPECT_TRUE(channel->HasSendSinks(SINK_POST_CRYPTO));
281 EXPECT_TRUE(channel->HasRecvSinks(SINK_POST_CRYPTO));
282 EXPECT_FALSE(channel->HasSendSinks(SINK_PRE_CRYPTO));
283 EXPECT_FALSE(channel->HasRecvSinks(SINK_PRE_CRYPTO));
284 if (video_media_channel) {
285 EXPECT_FALSE(video_media_channel->sent_intra_frame());
286 EXPECT_FALSE(video_media_channel->requested_intra_frame());
287 }
288
289 // Verify that header files are created.
290 EXPECT_TRUE(talk_base::Filesystem::IsFile(send_header_file));
291 EXPECT_TRUE(talk_base::Filesystem::IsFile(recv_header_file));
292
293 // Create RTP header recorder.
294 talk_base::scoped_ptr<MediaRecorder> recorder(new MediaRecorder);
295 path.SetFilename("send.rtpdump");
296 std::string send_file = path.pathname();
297 path.SetFilename("recv.rtpdump");
298 std::string recv_file = path.pathname();
299 if (video_media_channel) {
300 EXPECT_TRUE(recorder->AddChannel(
301 static_cast<VideoChannel*>(channel),
302 Open(send_file), Open(recv_file), PF_RTPPACKET));
303 } else {
304 EXPECT_TRUE(recorder->AddChannel(
305 static_cast<VoiceChannel*>(channel),
306 Open(send_file), Open(recv_file), PF_RTPPACKET));
307 }
308
309 // Enable recording both sent and received.
310 EXPECT_TRUE(recorder->EnableChannel(channel, true, true, SINK_PRE_CRYPTO));
311 EXPECT_TRUE(channel->HasSendSinks(SINK_POST_CRYPTO));
312 EXPECT_TRUE(channel->HasRecvSinks(SINK_POST_CRYPTO));
313 EXPECT_TRUE(channel->HasSendSinks(SINK_PRE_CRYPTO));
314 EXPECT_TRUE(channel->HasRecvSinks(SINK_PRE_CRYPTO));
315 if (video_media_channel) {
316 EXPECT_TRUE_WAIT(video_media_channel->sent_intra_frame(), 100);
317 EXPECT_TRUE(video_media_channel->requested_intra_frame());
318 }
319
320 // Verify that media files are created.
321 EXPECT_TRUE(talk_base::Filesystem::IsFile(send_file));
322 EXPECT_TRUE(talk_base::Filesystem::IsFile(recv_file));
323
324 // Delete all files.
325 header_recorder.reset();
326 recorder.reset();
327 EXPECT_TRUE(talk_base::Filesystem::DeleteFile(send_header_file));
328 EXPECT_TRUE(talk_base::Filesystem::DeleteFile(recv_header_file));
329 EXPECT_TRUE(talk_base::Filesystem::DeleteFile(send_file));
330 EXPECT_TRUE(talk_base::Filesystem::DeleteFile(recv_file));
331 }
332
TEST(MediaRecorderTest,TestMediaRecorderVoiceChannel)333 TEST(MediaRecorderTest, TestMediaRecorderVoiceChannel) {
334 // Create the voice channel.
335 FakeSession session(true);
336 FakeMediaEngine media_engine;
337 VoiceChannel channel(talk_base::Thread::Current(), &media_engine,
338 new FakeVoiceMediaChannel(NULL), &session, "", false);
339 EXPECT_TRUE(channel.Init());
340 TestMediaRecorder(&channel, NULL, PF_RTPPACKET);
341 TestMediaRecorder(&channel, NULL, PF_RTPHEADER);
342 TestRecordHeaderAndMedia(&channel, NULL);
343 }
344
TEST(MediaRecorderTest,TestMediaRecorderVideoChannel)345 TEST(MediaRecorderTest, TestMediaRecorderVideoChannel) {
346 // Create the video channel.
347 FakeSession session(true);
348 FakeMediaEngine media_engine;
349 FakeVideoMediaChannel* media_channel = new FakeVideoMediaChannel(NULL);
350 VideoChannel channel(talk_base::Thread::Current(), &media_engine,
351 media_channel, &session, "", false, NULL);
352 EXPECT_TRUE(channel.Init());
353 TestMediaRecorder(&channel, media_channel, PF_RTPPACKET);
354 TestMediaRecorder(&channel, media_channel, PF_RTPHEADER);
355 TestRecordHeaderAndMedia(&channel, media_channel);
356 }
357
358 } // namespace cricket
359