src/third_party/libjingle/source/talk/media/base/rtpdataengine_unittest.cc

   1 /*
   2  * libjingle
   3  * Copyright 2012 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/constants.h"
  31 #include "talk/media/base/fakenetworkinterface.h"
  32 #include "talk/media/base/rtpdataengine.h"
  33 #include "talk/media/base/rtputils.h"
  34 #include "webrtc/base/buffer.h"
  35 #include "webrtc/base/gunit.h"
  36 #include "webrtc/base/helpers.h"
  37 #include "webrtc/base/scoped_ptr.h"
  38 #include "webrtc/base/ssladapter.h"
  39 #include "webrtc/base/timing.h"
  40
  41 class FakeTiming : public rtc::Timing {
  42  public:
  43   FakeTiming() : now_(0.0) {}
  44
  45   virtual double TimerNow() {
  46     return now_;
  47   }
  48
  49   void set_now(double now) {
  50     now_ = now;
  51   }
  52
  53  private:
  54   double now_;
  55 };
  56
  57 class FakeDataReceiver : public sigslot::has_slots<> {
  58  public:
  59   FakeDataReceiver() : has_received_data_(false) {}
  60
  61   void OnDataReceived(
  62       const cricket::ReceiveDataParams& params,
  63       const char* data, size_t len) {
  64     has_received_data_ = true;
  65     last_received_data_ = std::string(data, len);
  66     last_received_data_len_ = len;
  67     last_received_data_params_ = params;
  68   }
  69
  70   bool has_received_data() const { return has_received_data_; }
  71   std::string last_received_data() const { return last_received_data_; }
  72   size_t last_received_data_len() const { return last_received_data_len_; }
  73   cricket::ReceiveDataParams last_received_data_params() const {
  74     return last_received_data_params_;
  75   }
  76
  77  private:
  78   bool has_received_data_;
  79   std::string last_received_data_;
  80   size_t last_received_data_len_;
  81   cricket::ReceiveDataParams last_received_data_params_;
  82 };
  83
  84 class RtpDataMediaChannelTest : public testing::Test {
  85  protected:
  86   virtual void SetUp() {
  87     // Seed needed for each test to satisfy expectations.
  88     iface_.reset(new cricket::FakeNetworkInterface());
  89     timing_ = new FakeTiming();
  90     dme_.reset(CreateEngine(timing_));
  91     receiver_.reset(new FakeDataReceiver());
  92   }
  93
  94   void SetNow(double now) {
  95     timing_->set_now(now);
  96   }
  97
  98   cricket::RtpDataEngine* CreateEngine(FakeTiming* timing) {
  99     cricket::RtpDataEngine* dme = new cricket::RtpDataEngine();
 100     dme->SetTiming(timing);
 101     return dme;
 102   }
 103
 104   cricket::RtpDataMediaChannel* CreateChannel() {
 105     return CreateChannel(dme_.get());
 106   }
 107
 108   cricket::RtpDataMediaChannel* CreateChannel(cricket::RtpDataEngine* dme) {
 109     cricket::RtpDataMediaChannel* channel =
 110         static_cast<cricket::RtpDataMediaChannel*>(dme->CreateChannel(
 111             cricket::DCT_RTP));
 112     channel->SetInterface(iface_.get());
 113     channel->SignalDataReceived.connect(
 114         receiver_.get(), &FakeDataReceiver::OnDataReceived);
 115     return channel;
 116   }
 117
 118   FakeDataReceiver* receiver() {
 119     return receiver_.get();
 120   }
 121
 122   bool HasReceivedData() {
 123     return receiver_->has_received_data();
 124   }
 125
 126   std::string GetReceivedData() {
 127     return receiver_->last_received_data();
 128   }
 129
 130   size_t GetReceivedDataLen() {
 131     return receiver_->last_received_data_len();
 132   }
 133
 134   cricket::ReceiveDataParams GetReceivedDataParams() {
 135     return receiver_->last_received_data_params();
 136   }
 137
 138   bool HasSentData(int count) {
 139     return (iface_->NumRtpPackets() > count);
 140   }
 141
 142   std::string GetSentData(int index) {
 143     // Assume RTP header of length 12
 144     rtc::scoped_ptr<const rtc::Buffer> packet(
 145         iface_->GetRtpPacket(index));
 146     if (packet->length() > 12) {
 147       return std::string(packet->data() + 12, packet->length() - 12);
 148     } else {
 149       return "";
 150     }
 151   }
 152
 153   cricket::RtpHeader GetSentDataHeader(int index) {
 154     rtc::scoped_ptr<const rtc::Buffer> packet(
 155         iface_->GetRtpPacket(index));
 156     cricket::RtpHeader header;
 157     GetRtpHeader(packet->data(), packet->length(), &header);
 158     return header;
 159   }
 160
 161  private:
 162   rtc::scoped_ptr<cricket::RtpDataEngine> dme_;
 163   // Timing passed into dme_.  Owned by dme_;
 164   FakeTiming* timing_;
 165   rtc::scoped_ptr<cricket::FakeNetworkInterface> iface_;
 166   rtc::scoped_ptr<FakeDataReceiver> receiver_;
 167 };
 168
 169 TEST_F(RtpDataMediaChannelTest, SetUnknownCodecs) {
 170   rtc::scoped_ptr<cricket::RtpDataMediaChannel> dmc(CreateChannel());
 171
 172   cricket::DataCodec known_codec;
 173   known_codec.id = 103;
 174   known_codec.name = "google-data";
 175   cricket::DataCodec unknown_codec;
 176   unknown_codec.id = 104;
 177   unknown_codec.name = "unknown-data";
 178
 179   std::vector<cricket::DataCodec> known_codecs;
 180   known_codecs.push_back(known_codec);
 181
 182   std::vector<cricket::DataCodec> unknown_codecs;
 183   unknown_codecs.push_back(unknown_codec);
 184
 185   std::vector<cricket::DataCodec> mixed_codecs;
 186   mixed_codecs.push_back(known_codec);
 187   mixed_codecs.push_back(unknown_codec);
 188
 189   EXPECT_TRUE(dmc->SetSendCodecs(known_codecs));
 190   EXPECT_FALSE(dmc->SetSendCodecs(unknown_codecs));
 191   EXPECT_TRUE(dmc->SetSendCodecs(mixed_codecs));
 192   EXPECT_TRUE(dmc->SetRecvCodecs(known_codecs));
 193   EXPECT_FALSE(dmc->SetRecvCodecs(unknown_codecs));
 194   EXPECT_FALSE(dmc->SetRecvCodecs(mixed_codecs));
 195 }
 196
 197 TEST_F(RtpDataMediaChannelTest, AddRemoveSendStream) {
 198   rtc::scoped_ptr<cricket::RtpDataMediaChannel> dmc(CreateChannel());
 199
 200   cricket::StreamParams stream1;
 201   stream1.add_ssrc(41);
 202   EXPECT_TRUE(dmc->AddSendStream(stream1));
 203   cricket::StreamParams stream2;
 204   stream2.add_ssrc(42);
 205   EXPECT_TRUE(dmc->AddSendStream(stream2));
 206
 207   EXPECT_TRUE(dmc->RemoveSendStream(41));
 208   EXPECT_TRUE(dmc->RemoveSendStream(42));
 209   EXPECT_FALSE(dmc->RemoveSendStream(43));
 210 }
 211
 212 TEST_F(RtpDataMediaChannelTest, AddRemoveRecvStream) {
 213   rtc::scoped_ptr<cricket::RtpDataMediaChannel> dmc(CreateChannel());
 214
 215   cricket::StreamParams stream1;
 216   stream1.add_ssrc(41);
 217   EXPECT_TRUE(dmc->AddRecvStream(stream1));
 218   cricket::StreamParams stream2;
 219   stream2.add_ssrc(42);
 220   EXPECT_TRUE(dmc->AddRecvStream(stream2));
 221   EXPECT_FALSE(dmc->AddRecvStream(stream2));
 222
 223   EXPECT_TRUE(dmc->RemoveRecvStream(41));
 224   EXPECT_TRUE(dmc->RemoveRecvStream(42));
 225 }
 226
 227 TEST_F(RtpDataMediaChannelTest, SendData) {
 228   rtc::scoped_ptr<cricket::RtpDataMediaChannel> dmc(CreateChannel());
 229
 230   cricket::SendDataParams params;
 231   params.ssrc = 42;
 232   unsigned char data[] = "food";
 233   rtc::Buffer payload(data, 4);
 234   unsigned char padded_data[] = {
 235     0x00, 0x00, 0x00, 0x00,
 236     'f', 'o', 'o', 'd',
 237   };
 238   cricket::SendDataResult result;
 239
 240   // Not sending
 241   EXPECT_FALSE(dmc->SendData(params, payload, &result));
 242   EXPECT_EQ(cricket::SDR_ERROR, result);
 243   EXPECT_FALSE(HasSentData(0));
 244   ASSERT_TRUE(dmc->SetSend(true));
 245
 246   // Unknown stream name.
 247   EXPECT_FALSE(dmc->SendData(params, payload, &result));
 248   EXPECT_EQ(cricket::SDR_ERROR, result);
 249   EXPECT_FALSE(HasSentData(0));
 250
 251   cricket::StreamParams stream;
 252   stream.add_ssrc(42);
 253   ASSERT_TRUE(dmc->AddSendStream(stream));
 254
 255   // Unknown codec;
 256   EXPECT_FALSE(dmc->SendData(params, payload, &result));
 257   EXPECT_EQ(cricket::SDR_ERROR, result);
 258   EXPECT_FALSE(HasSentData(0));
 259
 260   cricket::DataCodec codec;
 261   codec.id = 103;
 262   codec.name = cricket::kGoogleRtpDataCodecName;
 263   std::vector<cricket::DataCodec> codecs;
 264   codecs.push_back(codec);
 265   ASSERT_TRUE(dmc->SetSendCodecs(codecs));
 266
 267   // Length too large;
 268   std::string x10000(10000, 'x');
 269   EXPECT_FALSE(dmc->SendData(
 270       params, rtc::Buffer(x10000.data(), x10000.length()), &result));
 271   EXPECT_EQ(cricket::SDR_ERROR, result);
 272   EXPECT_FALSE(HasSentData(0));
 273
 274   // Finally works!
 275   EXPECT_TRUE(dmc->SendData(params, payload, &result));
 276   EXPECT_EQ(cricket::SDR_SUCCESS, result);
 277   ASSERT_TRUE(HasSentData(0));
 278   EXPECT_EQ(sizeof(padded_data), GetSentData(0).length());
 279   EXPECT_EQ(0, memcmp(
 280       padded_data, GetSentData(0).data(), sizeof(padded_data)));
 281   cricket::RtpHeader header0 = GetSentDataHeader(0);
 282   EXPECT_NE(0, header0.seq_num);
 283   EXPECT_NE(0U, header0.timestamp);
 284   EXPECT_EQ(header0.ssrc, 42U);
 285   EXPECT_EQ(header0.payload_type, 103);
 286
 287   // Should bump timestamp by 180000 because the clock rate is 90khz.
 288   SetNow(2);
 289
 290   EXPECT_TRUE(dmc->SendData(params, payload, &result));
 291   ASSERT_TRUE(HasSentData(1));
 292   EXPECT_EQ(sizeof(padded_data), GetSentData(1).length());
 293   EXPECT_EQ(0, memcmp(
 294       padded_data, GetSentData(1).data(), sizeof(padded_data)));
 295   cricket::RtpHeader header1 = GetSentDataHeader(1);
 296   EXPECT_EQ(header1.ssrc, 42U);
 297   EXPECT_EQ(header1.payload_type, 103);
 298   EXPECT_EQ(static_cast<uint16>(header0.seq_num + 1),
 299             static_cast<uint16>(header1.seq_num));
 300   EXPECT_EQ(header0.timestamp + 180000, header1.timestamp);
 301 }
 302
 303 TEST_F(RtpDataMediaChannelTest, SendDataMultipleClocks) {
 304   // Timings owned by RtpDataEngines.
 305   FakeTiming* timing1 = new FakeTiming();
 306   rtc::scoped_ptr<cricket::RtpDataEngine> dme1(CreateEngine(timing1));
 307   rtc::scoped_ptr<cricket::RtpDataMediaChannel> dmc1(
 308       CreateChannel(dme1.get()));
 309   FakeTiming* timing2 = new FakeTiming();
 310   rtc::scoped_ptr<cricket::RtpDataEngine> dme2(CreateEngine(timing2));
 311   rtc::scoped_ptr<cricket::RtpDataMediaChannel> dmc2(
 312       CreateChannel(dme2.get()));
 313
 314   ASSERT_TRUE(dmc1->SetSend(true));
 315   ASSERT_TRUE(dmc2->SetSend(true));
 316
 317   cricket::StreamParams stream1;
 318   stream1.add_ssrc(41);
 319   ASSERT_TRUE(dmc1->AddSendStream(stream1));
 320   cricket::StreamParams stream2;
 321   stream2.add_ssrc(42);
 322   ASSERT_TRUE(dmc2->AddSendStream(stream2));
 323
 324   cricket::DataCodec codec;
 325   codec.id = 103;
 326   codec.name = cricket::kGoogleRtpDataCodecName;
 327   std::vector<cricket::DataCodec> codecs;
 328   codecs.push_back(codec);
 329   ASSERT_TRUE(dmc1->SetSendCodecs(codecs));
 330   ASSERT_TRUE(dmc2->SetSendCodecs(codecs));
 331
 332   cricket::SendDataParams params1;
 333   params1.ssrc = 41;
 334   cricket::SendDataParams params2;
 335   params2.ssrc = 42;
 336
 337   unsigned char data[] = "foo";
 338   rtc::Buffer payload(data, 3);
 339   cricket::SendDataResult result;
 340
 341   EXPECT_TRUE(dmc1->SendData(params1, payload, &result));
 342   EXPECT_TRUE(dmc2->SendData(params2, payload, &result));
 343
 344   // Should bump timestamp by 90000 because the clock rate is 90khz.
 345   timing1->set_now(1);
 346   // Should bump timestamp by 180000 because the clock rate is 90khz.
 347   timing2->set_now(2);
 348
 349   EXPECT_TRUE(dmc1->SendData(params1, payload, &result));
 350   EXPECT_TRUE(dmc2->SendData(params2, payload, &result));
 351
 352   ASSERT_TRUE(HasSentData(3));
 353   cricket::RtpHeader header1a = GetSentDataHeader(0);
 354   cricket::RtpHeader header2a = GetSentDataHeader(1);
 355   cricket::RtpHeader header1b = GetSentDataHeader(2);
 356   cricket::RtpHeader header2b = GetSentDataHeader(3);
 357
 358   EXPECT_EQ(static_cast<uint16>(header1a.seq_num + 1),
 359             static_cast<uint16>(header1b.seq_num));
 360   EXPECT_EQ(header1a.timestamp + 90000, header1b.timestamp);
 361   EXPECT_EQ(static_cast<uint16>(header2a.seq_num + 1),
 362             static_cast<uint16>(header2b.seq_num));
 363   EXPECT_EQ(header2a.timestamp + 180000, header2b.timestamp);
 364 }
 365
 366 TEST_F(RtpDataMediaChannelTest, SendDataRate) {
 367   rtc::scoped_ptr<cricket::RtpDataMediaChannel> dmc(CreateChannel());
 368
 369   ASSERT_TRUE(dmc->SetSend(true));
 370
 371   cricket::DataCodec codec;
 372   codec.id = 103;
 373   codec.name = cricket::kGoogleRtpDataCodecName;
 374   std::vector<cricket::DataCodec> codecs;
 375   codecs.push_back(codec);
 376   ASSERT_TRUE(dmc->SetSendCodecs(codecs));
 377
 378   cricket::StreamParams stream;
 379   stream.add_ssrc(42);
 380   ASSERT_TRUE(dmc->AddSendStream(stream));
 381
 382   cricket::SendDataParams params;
 383   params.ssrc = 42;
 384   unsigned char data[] = "food";
 385   rtc::Buffer payload(data, 4);
 386   cricket::SendDataResult result;
 387
 388   // With rtp overhead of 32 bytes, each one of our packets is 36
 389   // bytes, or 288 bits.  So, a limit of 872bps will allow 3 packets,
 390   // but not four.
 391   dmc->SetMaxSendBandwidth(872);
 392
 393   EXPECT_TRUE(dmc->SendData(params, payload, &result));
 394   EXPECT_TRUE(dmc->SendData(params, payload, &result));
 395   EXPECT_TRUE(dmc->SendData(params, payload, &result));
 396   EXPECT_FALSE(dmc->SendData(params, payload, &result));
 397   EXPECT_FALSE(dmc->SendData(params, payload, &result));
 398
 399   SetNow(0.9);
 400   EXPECT_FALSE(dmc->SendData(params, payload, &result));
 401
 402   SetNow(1.1);
 403   EXPECT_TRUE(dmc->SendData(params, payload, &result));
 404   EXPECT_TRUE(dmc->SendData(params, payload, &result));
 405   SetNow(1.9);
 406   EXPECT_TRUE(dmc->SendData(params, payload, &result));
 407
 408   SetNow(2.2);
 409   EXPECT_TRUE(dmc->SendData(params, payload, &result));
 410   EXPECT_TRUE(dmc->SendData(params, payload, &result));
 411   EXPECT_TRUE(dmc->SendData(params, payload, &result));
 412   EXPECT_FALSE(dmc->SendData(params, payload, &result));
 413 }
 414
 415 TEST_F(RtpDataMediaChannelTest, ReceiveData) {
 416   // PT= 103, SN=2, TS=3, SSRC = 4, data = "abcde"
 417   unsigned char data[] = {
 418     0x80, 0x67, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x2A,
 419     0x00, 0x00, 0x00, 0x00,
 420     'a', 'b', 'c', 'd', 'e'
 421   };
 422   rtc::Buffer packet(data, sizeof(data));
 423
 424   rtc::scoped_ptr<cricket::RtpDataMediaChannel> dmc(CreateChannel());
 425
 426   // SetReceived not called.
 427   dmc->OnPacketReceived(&packet, rtc::PacketTime());
 428   EXPECT_FALSE(HasReceivedData());
 429
 430   dmc->SetReceive(true);
 431
 432   // Unknown payload id
 433   dmc->OnPacketReceived(&packet, rtc::PacketTime());
 434   EXPECT_FALSE(HasReceivedData());
 435
 436   cricket::DataCodec codec;
 437   codec.id = 103;
 438   codec.name = cricket::kGoogleRtpDataCodecName;
 439   std::vector<cricket::DataCodec> codecs;
 440   codecs.push_back(codec);
 441   ASSERT_TRUE(dmc->SetRecvCodecs(codecs));
 442
 443   // Unknown stream
 444   dmc->OnPacketReceived(&packet, rtc::PacketTime());
 445   EXPECT_FALSE(HasReceivedData());
 446
 447   cricket::StreamParams stream;
 448   stream.add_ssrc(42);
 449   ASSERT_TRUE(dmc->AddRecvStream(stream));
 450
 451   // Finally works!
 452   dmc->OnPacketReceived(&packet, rtc::PacketTime());
 453   EXPECT_TRUE(HasReceivedData());
 454   EXPECT_EQ("abcde", GetReceivedData());
 455   EXPECT_EQ(5U, GetReceivedDataLen());
 456 }
 457
 458 TEST_F(RtpDataMediaChannelTest, InvalidRtpPackets) {
 459   unsigned char data[] = {
 460     0x80, 0x65, 0x00, 0x02
 461   };
 462   rtc::Buffer packet(data, sizeof(data));
 463
 464   rtc::scoped_ptr<cricket::RtpDataMediaChannel> dmc(CreateChannel());
 465
 466   // Too short
 467   dmc->OnPacketReceived(&packet, rtc::PacketTime());
 468   EXPECT_FALSE(HasReceivedData());
 469 }