src/third_party/webrtc/modules/audio_coding/neteq/payload_splitter_unittest.cc

   1 /*
   2  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
   3  *
   4  *  Use of this source code is governed by a BSD-style license
   5  *  that can be found in the LICENSE file in the root of the source
   6  *  tree. An additional intellectual property rights grant can be found
   7  *  in the file PATENTS.  All contributing project authors may
   8  *  be found in the AUTHORS file in the root of the source tree.
   9  */
  10
  11 // Unit tests for PayloadSplitter class.
  12
  13 #include "webrtc/modules/audio_coding/neteq/payload_splitter.h"
  14
  15 #include <assert.h>
  16
  17 #include <utility>  // pair
  18
  19 #include "gtest/gtest.h"
  20 #include "webrtc/modules/audio_coding/neteq/mock/mock_decoder_database.h"
  21 #include "webrtc/modules/audio_coding/neteq/packet.h"
  22 #include "webrtc/system_wrappers/interface/scoped_ptr.h"
  23
  24 using ::testing::Return;
  25 using ::testing::ReturnNull;
  26
  27 namespace webrtc {
  28
  29 static const int kRedPayloadType = 100;
  30 static const int kPayloadLength = 10;
  31 static const int kRedHeaderLength = 4;  // 4 bytes RED header.
  32 static const uint16_t kSequenceNumber = 0;
  33 static const uint32_t kBaseTimestamp = 0x12345678;
  34
  35 // RED headers (according to RFC 2198):
  36 //
  37 //    0                   1                   2                   3
  38 //    0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
  39 //   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  40 //   |F|   block PT  |  timestamp offset         |   block length    |
  41 //   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  42 //
  43 // Last RED header:
  44 //    0 1 2 3 4 5 6 7
  45 //   +-+-+-+-+-+-+-+-+
  46 //   |0|   Block PT  |
  47 //   +-+-+-+-+-+-+-+-+
  48
  49 // Creates a RED packet, with |num_payloads| payloads, with payload types given
  50 // by the values in array |payload_types| (which must be of length
  51 // |num_payloads|). Each redundant payload is |timestamp_offset| samples
  52 // "behind" the the previous payload.
  53 Packet* CreateRedPayload(int num_payloads,
  54                          uint8_t* payload_types,
  55                          int timestamp_offset) {
  56   Packet* packet = new Packet;
  57   packet->header.payloadType = kRedPayloadType;
  58   packet->header.timestamp = kBaseTimestamp;
  59   packet->header.sequenceNumber = kSequenceNumber;
  60   packet->payload_length = (kPayloadLength + 1) +
  61       (num_payloads - 1) * (kPayloadLength + kRedHeaderLength);
  62   uint8_t* payload = new uint8_t[packet->payload_length];
  63   uint8_t* payload_ptr = payload;
  64   for (int i = 0; i < num_payloads; ++i) {
  65     // Write the RED headers.
  66     if (i == num_payloads - 1) {
  67       // Special case for last payload.
  68       *payload_ptr = payload_types[i] & 0x7F;  // F = 0;
  69       ++payload_ptr;
  70       break;
  71     }
  72     *payload_ptr = payload_types[i] & 0x7F;
  73     // Not the last block; set F = 1.
  74     *payload_ptr |= 0x80;
  75     ++payload_ptr;
  76     int this_offset = (num_payloads - i - 1) * timestamp_offset;
  77     *payload_ptr = this_offset >> 6;
  78     ++payload_ptr;
  79     assert(kPayloadLength <= 1023);  // Max length described by 10 bits.
  80     *payload_ptr = ((this_offset & 0x3F) << 2) | (kPayloadLength >> 8);
  81     ++payload_ptr;
  82     *payload_ptr = kPayloadLength & 0xFF;
  83     ++payload_ptr;
  84   }
  85   for (int i = 0; i < num_payloads; ++i) {
  86     // Write |i| to all bytes in each payload.
  87     memset(payload_ptr, i, kPayloadLength);
  88     payload_ptr += kPayloadLength;
  89   }
  90   packet->payload = payload;
  91   return packet;
  92 }
  93
  94
  95 // A possible Opus packet that contains FEC is the following.
  96 // The frame is 20 ms in duration.
  97 //
  98 // 0                   1                   2                   3
  99 // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
 100 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 101 // |0|0|0|0|1|0|0|0|x|1|x|x|x|x|x|x|x|                             |
 102 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+                             |
 103 // |                    Compressed frame 1 (N-2 bytes)...          :
 104 // :                                                               |
 105 // |                                                               |
 106 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 107 Packet* CreateOpusFecPacket(uint8_t payload_type, int payload_length,
 108                             uint8_t payload_value) {
 109   Packet* packet = new Packet;
 110   packet->header.payloadType = payload_type;
 111   packet->header.timestamp = kBaseTimestamp;
 112   packet->header.sequenceNumber = kSequenceNumber;
 113   packet->payload_length = payload_length;
 114   uint8_t* payload = new uint8_t[packet->payload_length];
 115   payload[0] = 0x08;
 116   payload[1] = 0x40;
 117   memset(&payload[2], payload_value, payload_length - 2);
 118   packet->payload = payload;
 119   return packet;
 120 }
 121
 122 // Create a packet with all payload bytes set to |payload_value|.
 123 Packet* CreatePacket(uint8_t payload_type, int payload_length,
 124                      uint8_t payload_value) {
 125   Packet* packet = new Packet;
 126   packet->header.payloadType = payload_type;
 127   packet->header.timestamp = kBaseTimestamp;
 128   packet->header.sequenceNumber = kSequenceNumber;
 129   packet->payload_length = payload_length;
 130   uint8_t* payload = new uint8_t[packet->payload_length];
 131   memset(payload, payload_value, payload_length);
 132   packet->payload = payload;
 133   return packet;
 134 }
 135
 136 // Checks that |packet| has the attributes given in the remaining parameters.
 137 void VerifyPacket(const Packet* packet,
 138                   int payload_length,
 139                   uint8_t payload_type,
 140                   uint16_t sequence_number,
 141                   uint32_t timestamp,
 142                   uint8_t payload_value,
 143                   bool primary = true) {
 144   EXPECT_EQ(payload_length, packet->payload_length);
 145   EXPECT_EQ(payload_type, packet->header.payloadType);
 146   EXPECT_EQ(sequence_number, packet->header.sequenceNumber);
 147   EXPECT_EQ(timestamp, packet->header.timestamp);
 148   EXPECT_EQ(primary, packet->primary);
 149   ASSERT_FALSE(packet->payload == NULL);
 150   for (int i = 0; i < packet->payload_length; ++i) {
 151     EXPECT_EQ(payload_value, packet->payload[i]);
 152   }
 153 }
 154
 155 // Start of test definitions.
 156
 157 TEST(PayloadSplitter, CreateAndDestroy) {
 158   PayloadSplitter* splitter = new PayloadSplitter;
 159   delete splitter;
 160 }
 161
 162 // Packet A is split into A1 and A2.
 163 TEST(RedPayloadSplitter, OnePacketTwoPayloads) {
 164   uint8_t payload_types[] = {0, 0};
 165   const int kTimestampOffset = 160;
 166   Packet* packet = CreateRedPayload(2, payload_types, kTimestampOffset);
 167   PacketList packet_list;
 168   packet_list.push_back(packet);
 169   PayloadSplitter splitter;
 170   EXPECT_EQ(PayloadSplitter::kOK, splitter.SplitRed(&packet_list));
 171   ASSERT_EQ(2u, packet_list.size());
 172   // Check first packet. The first in list should always be the primary payload.
 173   packet = packet_list.front();
 174   VerifyPacket(packet, kPayloadLength, payload_types[1], kSequenceNumber,
 175                kBaseTimestamp, 1, true);
 176   delete [] packet->payload;
 177   delete packet;
 178   packet_list.pop_front();
 179   // Check second packet.
 180   packet = packet_list.front();
 181   VerifyPacket(packet, kPayloadLength, payload_types[0], kSequenceNumber,
 182                kBaseTimestamp - kTimestampOffset, 0, false);
 183   delete [] packet->payload;
 184   delete packet;
 185 }
 186
 187 // Packets A and B are not split at all. Only the RED header in each packet is
 188 // removed.
 189 TEST(RedPayloadSplitter, TwoPacketsOnePayload) {
 190   uint8_t payload_types[] = {0};
 191   const int kTimestampOffset = 160;
 192   // Create first packet, with a single RED payload.
 193   Packet* packet = CreateRedPayload(1, payload_types, kTimestampOffset);
 194   PacketList packet_list;
 195   packet_list.push_back(packet);
 196   // Create second packet, with a single RED payload.
 197   packet = CreateRedPayload(1, payload_types, kTimestampOffset);
 198   // Manually change timestamp and sequence number of second packet.
 199   packet->header.timestamp += kTimestampOffset;
 200   packet->header.sequenceNumber++;
 201   packet_list.push_back(packet);
 202   PayloadSplitter splitter;
 203   EXPECT_EQ(PayloadSplitter::kOK, splitter.SplitRed(&packet_list));
 204   ASSERT_EQ(2u, packet_list.size());
 205   // Check first packet.
 206   packet = packet_list.front();
 207   VerifyPacket(packet, kPayloadLength, payload_types[0], kSequenceNumber,
 208                kBaseTimestamp, 0, true);
 209   delete [] packet->payload;
 210   delete packet;
 211   packet_list.pop_front();
 212   // Check second packet.
 213   packet = packet_list.front();
 214   VerifyPacket(packet, kPayloadLength, payload_types[0], kSequenceNumber + 1,
 215                kBaseTimestamp + kTimestampOffset, 0, true);
 216   delete [] packet->payload;
 217   delete packet;
 218 }
 219
 220 // Packets A and B are split into packets A1, A2, A3, B1, B2, B3, with
 221 // attributes as follows:
 222 //
 223 //                  A1*   A2    A3    B1*   B2    B3
 224 // Payload type     0     1     2     0     1     2
 225 // Timestamp        b     b-o   b-2o  b+o   b     b-o
 226 // Sequence number  0     0     0     1     1     1
 227 //
 228 // b = kBaseTimestamp, o = kTimestampOffset, * = primary.
 229 TEST(RedPayloadSplitter, TwoPacketsThreePayloads) {
 230   uint8_t payload_types[] = {2, 1, 0};  // Primary is the last one.
 231   const int kTimestampOffset = 160;
 232   // Create first packet, with 3 RED payloads.
 233   Packet* packet = CreateRedPayload(3, payload_types, kTimestampOffset);
 234   PacketList packet_list;
 235   packet_list.push_back(packet);
 236   // Create first packet, with 3 RED payloads.
 237   packet = CreateRedPayload(3, payload_types, kTimestampOffset);
 238   // Manually change timestamp and sequence number of second packet.
 239   packet->header.timestamp += kTimestampOffset;
 240   packet->header.sequenceNumber++;
 241   packet_list.push_back(packet);
 242   PayloadSplitter splitter;
 243   EXPECT_EQ(PayloadSplitter::kOK, splitter.SplitRed(&packet_list));
 244   ASSERT_EQ(6u, packet_list.size());
 245   // Check first packet, A1.
 246   packet = packet_list.front();
 247   VerifyPacket(packet, kPayloadLength, payload_types[2], kSequenceNumber,
 248                kBaseTimestamp, 2, true);
 249   delete [] packet->payload;
 250   delete packet;
 251   packet_list.pop_front();
 252   // Check second packet, A2.
 253   packet = packet_list.front();
 254   VerifyPacket(packet, kPayloadLength, payload_types[1], kSequenceNumber,
 255                kBaseTimestamp - kTimestampOffset, 1, false);
 256   delete [] packet->payload;
 257   delete packet;
 258   packet_list.pop_front();
 259   // Check third packet, A3.
 260   packet = packet_list.front();
 261   VerifyPacket(packet, kPayloadLength, payload_types[0], kSequenceNumber,
 262                kBaseTimestamp - 2 * kTimestampOffset, 0, false);
 263   delete [] packet->payload;
 264   delete packet;
 265   packet_list.pop_front();
 266   // Check fourth packet, B1.
 267   packet = packet_list.front();
 268   VerifyPacket(packet, kPayloadLength, payload_types[2], kSequenceNumber + 1,
 269                kBaseTimestamp + kTimestampOffset, 2, true);
 270   delete [] packet->payload;
 271   delete packet;
 272   packet_list.pop_front();
 273   // Check fifth packet, B2.
 274   packet = packet_list.front();
 275   VerifyPacket(packet, kPayloadLength, payload_types[1], kSequenceNumber + 1,
 276                kBaseTimestamp, 1, false);
 277   delete [] packet->payload;
 278   delete packet;
 279   packet_list.pop_front();
 280   // Check sixth packet, B3.
 281   packet = packet_list.front();
 282   VerifyPacket(packet, kPayloadLength, payload_types[0], kSequenceNumber + 1,
 283                kBaseTimestamp - kTimestampOffset, 0, false);
 284   delete [] packet->payload;
 285   delete packet;
 286 }
 287
 288 // Creates a list with 4 packets with these payload types:
 289 // 0 = CNGnb
 290 // 1 = PCMu
 291 // 2 = DTMF (AVT)
 292 // 3 = iLBC
 293 // We expect the method CheckRedPayloads to discard the iLBC packet, since it
 294 // is a non-CNG, non-DTMF payload of another type than the first speech payload
 295 // found in the list (which is PCMu).
 296 TEST(RedPayloadSplitter, CheckRedPayloads) {
 297   PacketList packet_list;
 298   for (int i = 0; i <= 3; ++i) {
 299     // Create packet with payload type |i|, payload length 10 bytes, all 0.
 300     Packet* packet = CreatePacket(i, 10, 0);
 301     packet_list.push_back(packet);
 302   }
 303
 304   // Use a real DecoderDatabase object here instead of a mock, since it is
 305   // easier to just register the payload types and let the actual implementation
 306   // do its job.
 307   DecoderDatabase decoder_database;
 308   decoder_database.RegisterPayload(0, kDecoderCNGnb);
 309   decoder_database.RegisterPayload(1, kDecoderPCMu);
 310   decoder_database.RegisterPayload(2, kDecoderAVT);
 311   decoder_database.RegisterPayload(3, kDecoderILBC);
 312
 313   PayloadSplitter splitter;
 314   splitter.CheckRedPayloads(&packet_list, decoder_database);
 315
 316   ASSERT_EQ(3u, packet_list.size());  // Should have dropped the last packet.
 317   // Verify packets. The loop verifies that payload types 0, 1, and 2 are in the
 318   // list.
 319   for (int i = 0; i <= 2; ++i) {
 320     Packet* packet = packet_list.front();
 321     VerifyPacket(packet, 10, i, kSequenceNumber, kBaseTimestamp, 0, true);
 322     delete [] packet->payload;
 323     delete packet;
 324     packet_list.pop_front();
 325   }
 326   EXPECT_TRUE(packet_list.empty());
 327 }
 328
 329 // Packet A is split into A1, A2 and A3. But the length parameter is off, so
 330 // the last payloads should be discarded.
 331 TEST(RedPayloadSplitter, WrongPayloadLength) {
 332   uint8_t payload_types[] = {0, 0, 0};
 333   const int kTimestampOffset = 160;
 334   Packet* packet = CreateRedPayload(3, payload_types, kTimestampOffset);
 335   // Manually tamper with the payload length of the packet.
 336   // This is one byte too short for the second payload (out of three).
 337   // We expect only the first payload to be returned.
 338   packet->payload_length -= kPayloadLength + 1;
 339   PacketList packet_list;
 340   packet_list.push_back(packet);
 341   PayloadSplitter splitter;
 342   EXPECT_EQ(PayloadSplitter::kRedLengthMismatch,
 343             splitter.SplitRed(&packet_list));
 344   ASSERT_EQ(1u, packet_list.size());
 345   // Check first packet.
 346   packet = packet_list.front();
 347   VerifyPacket(packet, kPayloadLength, payload_types[0], kSequenceNumber,
 348                kBaseTimestamp - 2 * kTimestampOffset, 0, false);
 349   delete [] packet->payload;
 350   delete packet;
 351   packet_list.pop_front();
 352 }
 353
 354 // Test that iSAC, iSAC-swb, RED, DTMF, CNG, and "Arbitrary" payloads do not
 355 // get split.
 356 TEST(AudioPayloadSplitter, NonSplittable) {
 357   // Set up packets with different RTP payload types. The actual values do not
 358   // matter, since we are mocking the decoder database anyway.
 359   PacketList packet_list;
 360   for (int i = 0; i < 6; ++i) {
 361     // Let the payload type be |i|, and the payload value 10 * |i|.
 362     packet_list.push_back(CreatePacket(i, kPayloadLength, 10 * i));
 363   }
 364
 365   MockDecoderDatabase decoder_database;
 366   // Tell the mock decoder database to return DecoderInfo structs with different
 367   // codec types.
 368   // Use scoped pointers to avoid having to delete them later.
 369   scoped_ptr<DecoderDatabase::DecoderInfo> info0(
 370       new DecoderDatabase::DecoderInfo(kDecoderISAC, 16000, NULL, false));
 371   EXPECT_CALL(decoder_database, GetDecoderInfo(0))
 372       .WillRepeatedly(Return(info0.get()));
 373   scoped_ptr<DecoderDatabase::DecoderInfo> info1(
 374       new DecoderDatabase::DecoderInfo(kDecoderISACswb, 32000, NULL, false));
 375   EXPECT_CALL(decoder_database, GetDecoderInfo(1))
 376       .WillRepeatedly(Return(info1.get()));
 377   scoped_ptr<DecoderDatabase::DecoderInfo> info2(
 378       new DecoderDatabase::DecoderInfo(kDecoderRED, 8000, NULL, false));
 379   EXPECT_CALL(decoder_database, GetDecoderInfo(2))
 380       .WillRepeatedly(Return(info2.get()));
 381   scoped_ptr<DecoderDatabase::DecoderInfo> info3(
 382       new DecoderDatabase::DecoderInfo(kDecoderAVT, 8000, NULL, false));
 383   EXPECT_CALL(decoder_database, GetDecoderInfo(3))
 384       .WillRepeatedly(Return(info3.get()));
 385   scoped_ptr<DecoderDatabase::DecoderInfo> info4(
 386       new DecoderDatabase::DecoderInfo(kDecoderCNGnb, 8000, NULL, false));
 387   EXPECT_CALL(decoder_database, GetDecoderInfo(4))
 388       .WillRepeatedly(Return(info4.get()));
 389   scoped_ptr<DecoderDatabase::DecoderInfo> info5(
 390       new DecoderDatabase::DecoderInfo(kDecoderArbitrary, 8000, NULL, false));
 391   EXPECT_CALL(decoder_database, GetDecoderInfo(5))
 392       .WillRepeatedly(Return(info5.get()));
 393
 394   PayloadSplitter splitter;
 395   EXPECT_EQ(0, splitter.SplitAudio(&packet_list, decoder_database));
 396   EXPECT_EQ(6u, packet_list.size());
 397
 398   // Check that all payloads are intact.
 399   uint8_t payload_type = 0;
 400   PacketList::iterator it = packet_list.begin();
 401   while (it != packet_list.end()) {
 402     VerifyPacket((*it), kPayloadLength, payload_type, kSequenceNumber,
 403                  kBaseTimestamp, 10 * payload_type);
 404     ++payload_type;
 405     delete [] (*it)->payload;
 406     delete (*it);
 407     it = packet_list.erase(it);
 408   }
 409
 410   // The destructor is called when decoder_database goes out of scope.
 411   EXPECT_CALL(decoder_database, Die());
 412 }
 413
 414 // Test unknown payload type.
 415 TEST(AudioPayloadSplitter, UnknownPayloadType) {
 416   PacketList packet_list;
 417   static const uint8_t kPayloadType = 17;  // Just a random number.
 418   int kPayloadLengthBytes = 4711;  // Random number.
 419   packet_list.push_back(CreatePacket(kPayloadType, kPayloadLengthBytes, 0));
 420
 421   MockDecoderDatabase decoder_database;
 422   // Tell the mock decoder database to return NULL when asked for decoder info.
 423   // This signals that the decoder database does not recognize the payload type.
 424   EXPECT_CALL(decoder_database, GetDecoderInfo(kPayloadType))
 425       .WillRepeatedly(ReturnNull());
 426
 427   PayloadSplitter splitter;
 428   EXPECT_EQ(PayloadSplitter::kUnknownPayloadType,
 429             splitter.SplitAudio(&packet_list, decoder_database));
 430   EXPECT_EQ(1u, packet_list.size());
 431
 432
 433   // Delete the packets and payloads to avoid having the test leak memory.
 434   PacketList::iterator it = packet_list.begin();
 435   while (it != packet_list.end()) {
 436     delete [] (*it)->payload;
 437     delete (*it);
 438     it = packet_list.erase(it);
 439   }
 440
 441   // The destructor is called when decoder_database goes out of scope.
 442   EXPECT_CALL(decoder_database, Die());
 443 }
 444
 445 class SplitBySamplesTest : public ::testing::TestWithParam<NetEqDecoder> {
 446  protected:
 447   virtual void SetUp() {
 448     decoder_type_ = GetParam();
 449     switch (decoder_type_) {
 450       case kDecoderPCMu:
 451       case kDecoderPCMa:
 452         bytes_per_ms_ = 8;
 453         samples_per_ms_ = 8;
 454         break;
 455       case kDecoderPCMu_2ch:
 456       case kDecoderPCMa_2ch:
 457         bytes_per_ms_ = 2 * 8;
 458         samples_per_ms_ = 8;
 459         break;
 460       case kDecoderG722:
 461         bytes_per_ms_ = 8;
 462         samples_per_ms_ = 16;
 463         break;
 464       case kDecoderPCM16B:
 465         bytes_per_ms_ = 16;
 466         samples_per_ms_ = 8;
 467         break;
 468       case kDecoderPCM16Bwb:
 469         bytes_per_ms_ = 32;
 470         samples_per_ms_ = 16;
 471         break;
 472       case kDecoderPCM16Bswb32kHz:
 473         bytes_per_ms_ = 64;
 474         samples_per_ms_ = 32;
 475         break;
 476       case kDecoderPCM16Bswb48kHz:
 477         bytes_per_ms_ = 96;
 478         samples_per_ms_ = 48;
 479         break;
 480       case kDecoderPCM16B_2ch:
 481         bytes_per_ms_ = 2 * 16;
 482         samples_per_ms_ = 8;
 483         break;
 484       case kDecoderPCM16Bwb_2ch:
 485         bytes_per_ms_ = 2 * 32;
 486         samples_per_ms_ = 16;
 487         break;
 488       case kDecoderPCM16Bswb32kHz_2ch:
 489         bytes_per_ms_ = 2 * 64;
 490         samples_per_ms_ = 32;
 491         break;
 492       case kDecoderPCM16Bswb48kHz_2ch:
 493         bytes_per_ms_ = 2 * 96;
 494         samples_per_ms_ = 48;
 495         break;
 496       case kDecoderPCM16B_5ch:
 497         bytes_per_ms_ = 5 * 16;
 498         samples_per_ms_ = 8;
 499         break;
 500       default:
 501         assert(false);
 502         break;
 503     }
 504   }
 505   int bytes_per_ms_;
 506   int samples_per_ms_;
 507   NetEqDecoder decoder_type_;
 508 };
 509
 510 // Test splitting sample-based payloads.
 511 TEST_P(SplitBySamplesTest, PayloadSizes) {
 512   PacketList packet_list;
 513   static const uint8_t kPayloadType = 17;  // Just a random number.
 514   for (int payload_size_ms = 10; payload_size_ms <= 60; payload_size_ms += 10) {
 515     // The payload values are set to be the same as the payload_size, so that
 516     // one can distinguish from which packet the split payloads come from.
 517     int payload_size_bytes = payload_size_ms * bytes_per_ms_;
 518     packet_list.push_back(CreatePacket(kPayloadType, payload_size_bytes,
 519                                        payload_size_ms));
 520   }
 521
 522   MockDecoderDatabase decoder_database;
 523   // Tell the mock decoder database to return DecoderInfo structs with different
 524   // codec types.
 525   // Use scoped pointers to avoid having to delete them later.
 526   // (Sample rate is set to 8000 Hz, but does not matter.)
 527   scoped_ptr<DecoderDatabase::DecoderInfo> info(
 528       new DecoderDatabase::DecoderInfo(decoder_type_, 8000, NULL, false));
 529   EXPECT_CALL(decoder_database, GetDecoderInfo(kPayloadType))
 530       .WillRepeatedly(Return(info.get()));
 531
 532   PayloadSplitter splitter;
 533   EXPECT_EQ(0, splitter.SplitAudio(&packet_list, decoder_database));
 534   // The payloads are expected to be split as follows:
 535   // 10 ms -> 10 ms
 536   // 20 ms -> 20 ms
 537   // 30 ms -> 30 ms
 538   // 40 ms -> 20 + 20 ms
 539   // 50 ms -> 25 + 25 ms
 540   // 60 ms -> 30 + 30 ms
 541   int expected_size_ms[] = {10, 20, 30, 20, 20, 25, 25, 30, 30};
 542   int expected_payload_value[] = {10, 20, 30, 40, 40, 50, 50, 60, 60};
 543   int expected_timestamp_offset_ms[] = {0, 0, 0, 0, 20, 0, 25, 0, 30};
 544   size_t expected_num_packets =
 545       sizeof(expected_size_ms) / sizeof(expected_size_ms[0]);
 546   EXPECT_EQ(expected_num_packets, packet_list.size());
 547
 548   PacketList::iterator it = packet_list.begin();
 549   int i = 0;
 550   while (it != packet_list.end()) {
 551     int length_bytes = expected_size_ms[i] * bytes_per_ms_;
 552     uint32_t expected_timestamp = kBaseTimestamp +
 553         expected_timestamp_offset_ms[i] * samples_per_ms_;
 554     VerifyPacket((*it), length_bytes, kPayloadType, kSequenceNumber,
 555                  expected_timestamp, expected_payload_value[i]);
 556     delete [] (*it)->payload;
 557     delete (*it);
 558     it = packet_list.erase(it);
 559     ++i;
 560   }
 561
 562   // The destructor is called when decoder_database goes out of scope.
 563   EXPECT_CALL(decoder_database, Die());
 564 }
 565
 566 INSTANTIATE_TEST_CASE_P(
 567     PayloadSplitter, SplitBySamplesTest,
 568     ::testing::Values(kDecoderPCMu, kDecoderPCMa, kDecoderPCMu_2ch,
 569                       kDecoderPCMa_2ch, kDecoderG722, kDecoderPCM16B,
 570                       kDecoderPCM16Bwb, kDecoderPCM16Bswb32kHz,
 571                       kDecoderPCM16Bswb48kHz, kDecoderPCM16B_2ch,
 572                       kDecoderPCM16Bwb_2ch, kDecoderPCM16Bswb32kHz_2ch,
 573                       kDecoderPCM16Bswb48kHz_2ch, kDecoderPCM16B_5ch));
 574
 575
 576 class SplitIlbcTest : public ::testing::TestWithParam<std::pair<int, int> > {
 577  protected:
 578   virtual void SetUp() {
 579     const std::pair<int, int> parameters = GetParam();
 580     num_frames_ = parameters.first;
 581     frame_length_ms_ = parameters.second;
 582     frame_length_bytes_ = (frame_length_ms_ == 20) ? 38 : 50;
 583   }
 584   size_t num_frames_;
 585   int frame_length_ms_;
 586   int frame_length_bytes_;
 587 };
 588
 589 // Test splitting sample-based payloads.
 590 TEST_P(SplitIlbcTest, NumFrames) {
 591   PacketList packet_list;
 592   static const uint8_t kPayloadType = 17;  // Just a random number.
 593   const int frame_length_samples = frame_length_ms_ * 8;
 594   int payload_length_bytes = frame_length_bytes_ * num_frames_;
 595   Packet* packet = CreatePacket(kPayloadType, payload_length_bytes, 0);
 596   // Fill payload with increasing integers {0, 1, 2, ...}.
 597   for (int i = 0; i < packet->payload_length; ++i) {
 598     packet->payload[i] = static_cast<uint8_t>(i);
 599   }
 600   packet_list.push_back(packet);
 601
 602   MockDecoderDatabase decoder_database;
 603   // Tell the mock decoder database to return DecoderInfo structs with different
 604   // codec types.
 605   // Use scoped pointers to avoid having to delete them later.
 606   scoped_ptr<DecoderDatabase::DecoderInfo> info(
 607       new DecoderDatabase::DecoderInfo(kDecoderILBC, 8000, NULL, false));
 608   EXPECT_CALL(decoder_database, GetDecoderInfo(kPayloadType))
 609       .WillRepeatedly(Return(info.get()));
 610
 611   PayloadSplitter splitter;
 612   EXPECT_EQ(0, splitter.SplitAudio(&packet_list, decoder_database));
 613   EXPECT_EQ(num_frames_, packet_list.size());
 614
 615   PacketList::iterator it = packet_list.begin();
 616   int frame_num = 0;
 617   uint8_t payload_value = 0;
 618   while (it != packet_list.end()) {
 619     Packet* packet = (*it);
 620     EXPECT_EQ(kBaseTimestamp + frame_length_samples * frame_num,
 621               packet->header.timestamp);
 622     EXPECT_EQ(frame_length_bytes_, packet->payload_length);
 623     EXPECT_EQ(kPayloadType, packet->header.payloadType);
 624     EXPECT_EQ(kSequenceNumber, packet->header.sequenceNumber);
 625     EXPECT_EQ(true, packet->primary);
 626     ASSERT_FALSE(packet->payload == NULL);
 627     for (int i = 0; i < packet->payload_length; ++i) {
 628       EXPECT_EQ(payload_value, packet->payload[i]);
 629       ++payload_value;
 630     }
 631     delete [] (*it)->payload;
 632     delete (*it);
 633     it = packet_list.erase(it);
 634     ++frame_num;
 635   }
 636
 637   // The destructor is called when decoder_database goes out of scope.
 638   EXPECT_CALL(decoder_database, Die());
 639 }
 640
 641 // Test 1 through 5 frames of 20 and 30 ms size.
 642 // Also test the maximum number of frames in one packet for 20 and 30 ms.
 643 // The maximum is defined by the largest payload length that can be uniquely
 644 // resolved to a frame size of either 38 bytes (20 ms) or 50 bytes (30 ms).
 645 INSTANTIATE_TEST_CASE_P(
 646     PayloadSplitter, SplitIlbcTest,
 647     ::testing::Values(std::pair<int, int>(1, 20),  // 1 frame, 20 ms.
 648                       std::pair<int, int>(2, 20),  // 2 frames, 20 ms.
 649                       std::pair<int, int>(3, 20),  // And so on.
 650                       std::pair<int, int>(4, 20),
 651                       std::pair<int, int>(5, 20),
 652                       std::pair<int, int>(24, 20),
 653                       std::pair<int, int>(1, 30),
 654                       std::pair<int, int>(2, 30),
 655                       std::pair<int, int>(3, 30),
 656                       std::pair<int, int>(4, 30),
 657                       std::pair<int, int>(5, 30),
 658                       std::pair<int, int>(18, 30)));
 659
 660 // Test too large payload size.
 661 TEST(IlbcPayloadSplitter, TooLargePayload) {
 662   PacketList packet_list;
 663   static const uint8_t kPayloadType = 17;  // Just a random number.
 664   int kPayloadLengthBytes = 950;
 665   Packet* packet = CreatePacket(kPayloadType, kPayloadLengthBytes, 0);
 666   packet_list.push_back(packet);
 667
 668   MockDecoderDatabase decoder_database;
 669   scoped_ptr<DecoderDatabase::DecoderInfo> info(
 670       new DecoderDatabase::DecoderInfo(kDecoderILBC, 8000, NULL, false));
 671   EXPECT_CALL(decoder_database, GetDecoderInfo(kPayloadType))
 672       .WillRepeatedly(Return(info.get()));
 673
 674   PayloadSplitter splitter;
 675   EXPECT_EQ(PayloadSplitter::kTooLargePayload,
 676             splitter.SplitAudio(&packet_list, decoder_database));
 677   EXPECT_EQ(1u, packet_list.size());
 678
 679   // Delete the packets and payloads to avoid having the test leak memory.
 680   PacketList::iterator it = packet_list.begin();
 681   while (it != packet_list.end()) {
 682     delete [] (*it)->payload;
 683     delete (*it);
 684     it = packet_list.erase(it);
 685   }
 686
 687   // The destructor is called when decoder_database goes out of scope.
 688   EXPECT_CALL(decoder_database, Die());
 689 }
 690
 691 // Payload not an integer number of frames.
 692 TEST(IlbcPayloadSplitter, UnevenPayload) {
 693   PacketList packet_list;
 694   static const uint8_t kPayloadType = 17;  // Just a random number.
 695   int kPayloadLengthBytes = 39;  // Not an even number of frames.
 696   Packet* packet = CreatePacket(kPayloadType, kPayloadLengthBytes, 0);
 697   packet_list.push_back(packet);
 698
 699   MockDecoderDatabase decoder_database;
 700   scoped_ptr<DecoderDatabase::DecoderInfo> info(
 701       new DecoderDatabase::DecoderInfo(kDecoderILBC, 8000, NULL, false));
 702   EXPECT_CALL(decoder_database, GetDecoderInfo(kPayloadType))
 703       .WillRepeatedly(Return(info.get()));
 704
 705   PayloadSplitter splitter;
 706   EXPECT_EQ(PayloadSplitter::kFrameSplitError,
 707             splitter.SplitAudio(&packet_list, decoder_database));
 708   EXPECT_EQ(1u, packet_list.size());
 709
 710   // Delete the packets and payloads to avoid having the test leak memory.
 711   PacketList::iterator it = packet_list.begin();
 712   while (it != packet_list.end()) {
 713     delete [] (*it)->payload;
 714     delete (*it);
 715     it = packet_list.erase(it);
 716   }
 717
 718   // The destructor is called when decoder_database goes out of scope.
 719   EXPECT_CALL(decoder_database, Die());
 720 }
 721
 722 TEST(FecPayloadSplitter, MixedPayload) {
 723   PacketList packet_list;
 724   DecoderDatabase decoder_database;
 725
 726   decoder_database.RegisterPayload(0, kDecoderOpus);
 727   decoder_database.RegisterPayload(1, kDecoderPCMu);
 728
 729   Packet* packet = CreateOpusFecPacket(0, 10, 0xFF);
 730   packet_list.push_back(packet);
 731
 732   packet = CreatePacket(0, 10, 0); // Non-FEC Opus payload.
 733   packet_list.push_back(packet);
 734
 735   packet = CreatePacket(1, 10, 0); // Non-Opus payload.
 736   packet_list.push_back(packet);
 737
 738   PayloadSplitter splitter;
 739   EXPECT_EQ(PayloadSplitter::kOK,
 740             splitter.SplitFec(&packet_list, &decoder_database));
 741   EXPECT_EQ(4u, packet_list.size());
 742
 743   // Check first packet.
 744   packet = packet_list.front();
 745   EXPECT_EQ(0, packet->header.payloadType);
 746   EXPECT_EQ(kBaseTimestamp - 20 * 48, packet->header.timestamp);
 747   EXPECT_EQ(10, packet->payload_length);
 748   EXPECT_FALSE(packet->primary);
 749   delete [] packet->payload;
 750   delete packet;
 751   packet_list.pop_front();
 752
 753   // Check second packet.
 754   packet = packet_list.front();
 755   EXPECT_EQ(0, packet->header.payloadType);
 756   EXPECT_EQ(kBaseTimestamp, packet->header.timestamp);
 757   EXPECT_EQ(10, packet->payload_length);
 758   EXPECT_TRUE(packet->primary);
 759   delete [] packet->payload;
 760   delete packet;
 761   packet_list.pop_front();
 762
 763   // Check third packet.
 764   packet = packet_list.front();
 765   VerifyPacket(packet, 10, 0, kSequenceNumber, kBaseTimestamp, 0, true);
 766   delete [] packet->payload;
 767   delete packet;
 768   packet_list.pop_front();
 769
 770   // Check fourth packet.
 771   packet = packet_list.front();
 772   VerifyPacket(packet, 10, 1, kSequenceNumber, kBaseTimestamp, 0, true);
 773   delete [] packet->payload;
 774   delete packet;
 775 }
 776
 777 }  // namespace webrtc