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 <set> 29 30#include "talk/media/base/filemediaengine.h" 31#include "talk/media/base/rtpdump.h" 32#include "talk/media/base/streamparams.h" 33#include "talk/media/base/testutils.h" 34#include "webrtc/base/buffer.h" 35#include "webrtc/base/gunit.h" 36#include "webrtc/base/helpers.h" 37#include "webrtc/base/pathutils.h" 38#include "webrtc/base/stream.h" 39 40namespace cricket { 41 42static const int kWaitTimeMs = 100; 43static const std::string kFakeFileName = "foobar"; 44 45////////////////////////////////////////////////////////////////////////////// 46// Media channel sends RTP packets via NetworkInterface. Rather than sending 47// packets to the network, FileNetworkInterface writes packets to a stream and 48// feeds packets back to the channel via OnPacketReceived. 49////////////////////////////////////////////////////////////////////////////// 50class FileNetworkInterface : public MediaChannel::NetworkInterface { 51 public: 52 FileNetworkInterface(rtc::StreamInterface* output, MediaChannel* ch) 53 : media_channel_(ch), 54 num_sent_packets_(0) { 55 if (output) { 56 dump_writer_.reset(new RtpDumpWriter(output)); 57 } 58 } 59 60 // Implement pure virtual methods of NetworkInterface. 61 virtual bool SendPacket(rtc::Buffer* packet, 62 rtc::DiffServCodePoint dscp) { 63 if (!packet) return false; 64 65 if (media_channel_) { 66 media_channel_->OnPacketReceived(packet, rtc::PacketTime()); 67 } 68 if (dump_writer_.get() && 69 rtc::SR_SUCCESS != dump_writer_->WriteRtpPacket( 70 packet->data(), packet->length())) { 71 return false; 72 } 73 74 ++num_sent_packets_; 75 return true; 76 } 77 78 virtual bool SendRtcp(rtc::Buffer* packet, 79 rtc::DiffServCodePoint dscp) { return false; } 80 virtual int SetOption(MediaChannel::NetworkInterface::SocketType type, 81 rtc::Socket::Option opt, int option) { 82 return 0; 83 } 84 virtual void SetDefaultDSCPCode(rtc::DiffServCodePoint dscp) {} 85 86 size_t num_sent_packets() const { return num_sent_packets_; } 87 88 private: 89 MediaChannel* media_channel_; 90 rtc::scoped_ptr<RtpDumpWriter> dump_writer_; 91 size_t num_sent_packets_; 92 93 DISALLOW_COPY_AND_ASSIGN(FileNetworkInterface); 94}; 95 96class FileMediaEngineTest : public testing::Test { 97 public: 98 virtual void SetUp() { 99 setup_ok_ = true; 100 setup_ok_ &= GetTempFilename(&voice_input_filename_); 101 setup_ok_ &= GetTempFilename(&voice_output_filename_); 102 setup_ok_ &= GetTempFilename(&video_input_filename_); 103 setup_ok_ &= GetTempFilename(&video_output_filename_); 104 } 105 virtual void TearDown() { 106 // Force to close the dump files, if opened. 107 voice_channel_.reset(); 108 video_channel_.reset(); 109 110 DeleteTempFile(voice_input_filename_); 111 DeleteTempFile(voice_output_filename_); 112 DeleteTempFile(video_input_filename_); 113 DeleteTempFile(video_output_filename_); 114 } 115 116 protected: 117 bool CreateEngineAndChannels(const std::string& voice_in, 118 const std::string& voice_out, 119 const std::string& video_in, 120 const std::string& video_out, 121 size_t ssrc_count) { 122 // Force to close the dump files, if opened. 123 voice_channel_.reset(); 124 video_channel_.reset(); 125 126 bool ret = setup_ok_; 127 if (!voice_in.empty()) { 128 ret &= WriteTestPacketsToFile(voice_in, ssrc_count); 129 } 130 if (!video_in.empty()) { 131 ret &= WriteTestPacketsToFile(video_in, ssrc_count); 132 } 133 134 engine_.reset(new FileMediaEngine); 135 engine_->set_voice_input_filename(voice_in); 136 engine_->set_voice_output_filename(voice_out); 137 engine_->set_video_input_filename(video_in); 138 engine_->set_video_output_filename(video_out); 139 engine_->set_rtp_sender_thread(rtc::Thread::Current()); 140 141 voice_channel_.reset(engine_->CreateChannel()); 142 video_channel_.reset(engine_->CreateVideoChannel(NULL)); 143 144 return ret; 145 } 146 147 bool GetTempFilename(std::string* filename) { 148 rtc::Pathname temp_path; 149 if (!rtc::Filesystem::GetTemporaryFolder(temp_path, true, NULL)) { 150 return false; 151 } 152 temp_path.SetPathname( 153 rtc::Filesystem::TempFilename(temp_path, "fme-test-")); 154 155 if (filename) { 156 *filename = temp_path.pathname(); 157 } 158 return true; 159 } 160 161 bool WriteTestPacketsToFile(const std::string& filename, size_t ssrc_count) { 162 rtc::scoped_ptr<rtc::StreamInterface> stream( 163 rtc::Filesystem::OpenFile(rtc::Pathname(filename), "wb")); 164 bool ret = (NULL != stream.get()); 165 RtpDumpWriter writer(stream.get()); 166 167 for (size_t i = 0; i < ssrc_count; ++i) { 168 ret &= RtpTestUtility::WriteTestPackets( 169 RtpTestUtility::GetTestPacketCount(), false, 170 static_cast<uint32>(RtpTestUtility::kDefaultSsrc + i), 171 &writer); 172 } 173 return ret; 174 } 175 176 void DeleteTempFile(std::string filename) { 177 rtc::Pathname pathname(filename); 178 if (rtc::Filesystem::IsFile(rtc::Pathname(pathname))) { 179 rtc::Filesystem::DeleteFile(pathname); 180 } 181 } 182 183 bool GetSsrcAndPacketCounts(rtc::StreamInterface* stream, 184 size_t* ssrc_count, size_t* packet_count) { 185 rtc::scoped_ptr<RtpDumpReader> reader(new RtpDumpReader(stream)); 186 size_t count = 0; 187 RtpDumpPacket packet; 188 std::set<uint32> ssrcs; 189 while (rtc::SR_SUCCESS == reader->ReadPacket(&packet)) { 190 count++; 191 uint32 ssrc; 192 if (!packet.GetRtpSsrc(&ssrc)) { 193 return false; 194 } 195 ssrcs.insert(ssrc); 196 } 197 if (ssrc_count) { 198 *ssrc_count = ssrcs.size(); 199 } 200 if (packet_count) { 201 *packet_count = count; 202 } 203 return true; 204 } 205 206 static const uint32 kWaitTimeout = 3000; 207 bool setup_ok_; 208 std::string voice_input_filename_; 209 std::string voice_output_filename_; 210 std::string video_input_filename_; 211 std::string video_output_filename_; 212 rtc::scoped_ptr<FileMediaEngine> engine_; 213 rtc::scoped_ptr<VoiceMediaChannel> voice_channel_; 214 rtc::scoped_ptr<VideoMediaChannel> video_channel_; 215}; 216 217TEST_F(FileMediaEngineTest, TestDefaultImplementation) { 218 EXPECT_TRUE(CreateEngineAndChannels("", "", "", "", 1)); 219 EXPECT_TRUE(engine_->Init(rtc::Thread::Current())); 220 EXPECT_EQ(0, engine_->GetCapabilities()); 221 EXPECT_TRUE(NULL == voice_channel_.get()); 222 EXPECT_TRUE(NULL == video_channel_.get()); 223 EXPECT_TRUE(NULL == engine_->CreateSoundclip()); 224 cricket::AudioOptions audio_options; 225 EXPECT_TRUE(engine_->SetAudioOptions(audio_options)); 226 VideoEncoderConfig video_encoder_config; 227 EXPECT_TRUE(engine_->SetDefaultVideoEncoderConfig(video_encoder_config)); 228 EXPECT_TRUE(engine_->SetSoundDevices(NULL, NULL)); 229 EXPECT_TRUE(engine_->SetVideoCaptureDevice(NULL)); 230 EXPECT_TRUE(engine_->SetOutputVolume(0)); 231 EXPECT_EQ(0, engine_->GetInputLevel()); 232 EXPECT_TRUE(engine_->SetLocalMonitor(true)); 233 EXPECT_TRUE(engine_->SetVideoCapture(true)); 234 EXPECT_EQ(0U, engine_->audio_codecs().size()); 235 EXPECT_EQ(0U, engine_->video_codecs().size()); 236 AudioCodec voice_codec; 237 EXPECT_TRUE(engine_->FindAudioCodec(voice_codec)); 238 VideoCodec video_codec; 239 EXPECT_TRUE(engine_->FindVideoCodec(video_codec)); 240 engine_->Terminate(); 241} 242 243// Test that when file path is not pointing to a valid stream file, the channel 244// creation function should fail and return NULL. 245TEST_F(FileMediaEngineTest, TestBadFilePath) { 246 engine_.reset(new FileMediaEngine); 247 engine_->set_voice_input_filename(kFakeFileName); 248 engine_->set_video_input_filename(kFakeFileName); 249 EXPECT_TRUE(engine_->CreateChannel() == NULL); 250 EXPECT_TRUE(engine_->CreateVideoChannel(NULL) == NULL); 251} 252 253TEST_F(FileMediaEngineTest, TestCodecs) { 254 EXPECT_TRUE(CreateEngineAndChannels("", "", "", "", 1)); 255 std::vector<AudioCodec> voice_codecs = engine_->audio_codecs(); 256 std::vector<VideoCodec> video_codecs = engine_->video_codecs(); 257 EXPECT_EQ(0U, voice_codecs.size()); 258 EXPECT_EQ(0U, video_codecs.size()); 259 260 AudioCodec voice_codec(103, "ISAC", 16000, 0, 1, 0); 261 voice_codecs.push_back(voice_codec); 262 engine_->set_voice_codecs(voice_codecs); 263 voice_codecs = engine_->audio_codecs(); 264 ASSERT_EQ(1U, voice_codecs.size()); 265 EXPECT_EQ(voice_codec, voice_codecs[0]); 266 267 VideoCodec video_codec(96, "H264-SVC", 320, 240, 30, 0); 268 video_codecs.push_back(video_codec); 269 engine_->set_video_codecs(video_codecs); 270 video_codecs = engine_->video_codecs(); 271 ASSERT_EQ(1U, video_codecs.size()); 272 EXPECT_EQ(video_codec, video_codecs[0]); 273} 274 275// Test that the capabilities and channel creation of the Filemedia engine 276// depend on the stream parameters passed to its constructor. 277TEST_F(FileMediaEngineTest, TestGetCapabilities) { 278 EXPECT_TRUE(CreateEngineAndChannels(voice_input_filename_, "", "", "", 1)); 279 EXPECT_EQ(AUDIO_SEND, engine_->GetCapabilities()); 280 EXPECT_TRUE(NULL != voice_channel_.get()); 281 EXPECT_TRUE(NULL == video_channel_.get()); 282 283 EXPECT_TRUE(CreateEngineAndChannels(voice_input_filename_, 284 voice_output_filename_, "", "", 1)); 285 EXPECT_EQ(AUDIO_SEND | AUDIO_RECV, engine_->GetCapabilities()); 286 EXPECT_TRUE(NULL != voice_channel_.get()); 287 EXPECT_TRUE(NULL == video_channel_.get()); 288 289 EXPECT_TRUE(CreateEngineAndChannels("", "", video_input_filename_, "", 1)); 290 EXPECT_EQ(VIDEO_SEND, engine_->GetCapabilities()); 291 EXPECT_TRUE(NULL == voice_channel_.get()); 292 EXPECT_TRUE(NULL != video_channel_.get()); 293 294 EXPECT_TRUE(CreateEngineAndChannels(voice_input_filename_, 295 voice_output_filename_, 296 video_input_filename_, 297 video_output_filename_, 298 1)); 299 EXPECT_EQ(AUDIO_SEND | AUDIO_RECV | VIDEO_SEND | VIDEO_RECV, 300 engine_->GetCapabilities()); 301 EXPECT_TRUE(NULL != voice_channel_.get()); 302 EXPECT_TRUE(NULL != video_channel_.get()); 303} 304 305// FileVideoChannel is the same as FileVoiceChannel in terms of receiving and 306// sending the RTP packets. We therefore test only FileVoiceChannel. 307 308// Test that SetSend() controls whether a voice channel sends RTP packets. 309TEST_F(FileMediaEngineTest, TestVoiceChannelSetSend) { 310 EXPECT_TRUE(CreateEngineAndChannels(voice_input_filename_, 311 voice_output_filename_, "", "", 1)); 312 EXPECT_TRUE(NULL != voice_channel_.get()); 313 rtc::MemoryStream net_dump; 314 FileNetworkInterface net_interface(&net_dump, voice_channel_.get()); 315 voice_channel_->SetInterface(&net_interface); 316 317 // The channel is not sending yet. 318 rtc::Thread::Current()->ProcessMessages(kWaitTimeMs); 319 EXPECT_EQ(0U, net_interface.num_sent_packets()); 320 321 // The channel starts sending. 322 voice_channel_->SetSend(SEND_MICROPHONE); 323 EXPECT_TRUE_WAIT(net_interface.num_sent_packets() >= 1U, kWaitTimeout); 324 325 // The channel stops sending. 326 voice_channel_->SetSend(SEND_NOTHING); 327 // Wait until packets are all delivered. 328 rtc::Thread::Current()->ProcessMessages(kWaitTimeMs); 329 size_t old_number = net_interface.num_sent_packets(); 330 rtc::Thread::Current()->ProcessMessages(kWaitTimeMs); 331 EXPECT_EQ(old_number, net_interface.num_sent_packets()); 332 333 // The channel starts sending again. 334 voice_channel_->SetSend(SEND_MICROPHONE); 335 EXPECT_TRUE_WAIT(net_interface.num_sent_packets() > old_number, kWaitTimeout); 336 337 // When the function exits, the net_interface object is released. The sender 338 // thread may call net_interface to send packets, which results in a segment 339 // fault. We hence stop sending and wait until all packets are delivered 340 // before we exit this function. 341 voice_channel_->SetSend(SEND_NOTHING); 342 rtc::Thread::Current()->ProcessMessages(kWaitTimeMs); 343} 344 345// Test the sender thread of the channel. The sender sends RTP packets 346// continuously with proper sequence number, timestamp, and payload. 347TEST_F(FileMediaEngineTest, TestVoiceChannelSenderThread) { 348 EXPECT_TRUE(CreateEngineAndChannels(voice_input_filename_, 349 voice_output_filename_, "", "", 1)); 350 EXPECT_TRUE(NULL != voice_channel_.get()); 351 rtc::MemoryStream net_dump; 352 FileNetworkInterface net_interface(&net_dump, voice_channel_.get()); 353 voice_channel_->SetInterface(&net_interface); 354 355 voice_channel_->SetSend(SEND_MICROPHONE); 356 // Wait until the number of sent packets is no less than 2 * kPacketNumber. 357 EXPECT_TRUE_WAIT( 358 net_interface.num_sent_packets() >= 359 2 * RtpTestUtility::GetTestPacketCount(), 360 kWaitTimeout); 361 voice_channel_->SetSend(SEND_NOTHING); 362 // Wait until packets are all delivered. 363 rtc::Thread::Current()->ProcessMessages(kWaitTimeMs); 364 EXPECT_TRUE(RtpTestUtility::VerifyTestPacketsFromStream( 365 2 * RtpTestUtility::GetTestPacketCount(), &net_dump, 366 RtpTestUtility::kDefaultSsrc)); 367 368 // Each sent packet is dumped to net_dump and is also feed to the channel 369 // via OnPacketReceived, which in turn writes the packets into voice_output_. 370 // We next verify the packets in voice_output_. 371 voice_channel_.reset(); // Force to close the files. 372 rtc::scoped_ptr<rtc::StreamInterface> voice_output_; 373 voice_output_.reset(rtc::Filesystem::OpenFile( 374 rtc::Pathname(voice_output_filename_), "rb")); 375 EXPECT_TRUE(voice_output_.get() != NULL); 376 EXPECT_TRUE(RtpTestUtility::VerifyTestPacketsFromStream( 377 2 * RtpTestUtility::GetTestPacketCount(), voice_output_.get(), 378 RtpTestUtility::kDefaultSsrc)); 379} 380 381// Test that we can specify the ssrc for outgoing RTP packets. 382TEST_F(FileMediaEngineTest, TestVoiceChannelSendSsrc) { 383 EXPECT_TRUE(CreateEngineAndChannels(voice_input_filename_, 384 voice_output_filename_, "", "", 1)); 385 EXPECT_TRUE(NULL != voice_channel_.get()); 386 const uint32 send_ssrc = RtpTestUtility::kDefaultSsrc + 1; 387 voice_channel_->AddSendStream(StreamParams::CreateLegacy(send_ssrc)); 388 389 rtc::MemoryStream net_dump; 390 FileNetworkInterface net_interface(&net_dump, voice_channel_.get()); 391 voice_channel_->SetInterface(&net_interface); 392 393 voice_channel_->SetSend(SEND_MICROPHONE); 394 // Wait until the number of sent packets is no less than 2 * kPacketNumber. 395 EXPECT_TRUE_WAIT( 396 net_interface.num_sent_packets() >= 397 2 * RtpTestUtility::GetTestPacketCount(), 398 kWaitTimeout); 399 voice_channel_->SetSend(SEND_NOTHING); 400 // Wait until packets are all delivered. 401 rtc::Thread::Current()->ProcessMessages(kWaitTimeMs); 402 EXPECT_TRUE(RtpTestUtility::VerifyTestPacketsFromStream( 403 2 * RtpTestUtility::GetTestPacketCount(), &net_dump, send_ssrc)); 404 405 // Each sent packet is dumped to net_dump and is also feed to the channel 406 // via OnPacketReceived, which in turn writes the packets into voice_output_. 407 // We next verify the packets in voice_output_. 408 voice_channel_.reset(); // Force to close the files. 409 rtc::scoped_ptr<rtc::StreamInterface> voice_output_; 410 voice_output_.reset(rtc::Filesystem::OpenFile( 411 rtc::Pathname(voice_output_filename_), "rb")); 412 EXPECT_TRUE(voice_output_.get() != NULL); 413 EXPECT_TRUE(RtpTestUtility::VerifyTestPacketsFromStream( 414 2 * RtpTestUtility::GetTestPacketCount(), voice_output_.get(), 415 send_ssrc)); 416} 417 418// Test the sender thread of the channel, where the input rtpdump has two SSRCs. 419TEST_F(FileMediaEngineTest, TestVoiceChannelSenderThreadTwoSsrcs) { 420 EXPECT_TRUE(CreateEngineAndChannels(voice_input_filename_, 421 voice_output_filename_, "", "", 2)); 422 // Verify that voice_input_filename_ contains 2 * 423 // RtpTestUtility::GetTestPacketCount() packets 424 // with different SSRCs. 425 rtc::scoped_ptr<rtc::StreamInterface> input_stream( 426 rtc::Filesystem::OpenFile( 427 rtc::Pathname(voice_input_filename_), "rb")); 428 ASSERT_TRUE(NULL != input_stream.get()); 429 size_t ssrc_count; 430 size_t packet_count; 431 EXPECT_TRUE(GetSsrcAndPacketCounts(input_stream.get(), &ssrc_count, 432 &packet_count)); 433 EXPECT_EQ(2U, ssrc_count); 434 EXPECT_EQ(2 * RtpTestUtility::GetTestPacketCount(), packet_count); 435 input_stream.reset(); 436 437 // Send 2 * RtpTestUtility::GetTestPacketCount() packets and verify that all 438 // these packets have the same SSRCs (that is, the packets with different 439 // SSRCs are skipped by the filemediaengine). 440 EXPECT_TRUE(NULL != voice_channel_.get()); 441 rtc::MemoryStream net_dump; 442 FileNetworkInterface net_interface(&net_dump, voice_channel_.get()); 443 voice_channel_->SetInterface(&net_interface); 444 voice_channel_->SetSend(SEND_MICROPHONE); 445 EXPECT_TRUE_WAIT( 446 net_interface.num_sent_packets() >= 447 2 * RtpTestUtility::GetTestPacketCount(), 448 kWaitTimeout); 449 voice_channel_->SetSend(SEND_NOTHING); 450 // Wait until packets are all delivered. 451 rtc::Thread::Current()->ProcessMessages(kWaitTimeMs); 452 net_dump.Rewind(); 453 EXPECT_TRUE(GetSsrcAndPacketCounts(&net_dump, &ssrc_count, &packet_count)); 454 EXPECT_EQ(1U, ssrc_count); 455 EXPECT_GE(packet_count, 2 * RtpTestUtility::GetTestPacketCount()); 456} 457 458// Test SendIntraFrame() and RequestIntraFrame() of video channel. 459TEST_F(FileMediaEngineTest, TestVideoChannelIntraFrame) { 460 EXPECT_TRUE(CreateEngineAndChannels("", "", video_input_filename_, 461 video_output_filename_, 1)); 462 EXPECT_TRUE(NULL != video_channel_.get()); 463 EXPECT_FALSE(video_channel_->SendIntraFrame()); 464 EXPECT_FALSE(video_channel_->RequestIntraFrame()); 465} 466 467} // namespace cricket 468