src/third_party/webrtc/modules/audio_coding/neteq/tools/packet_unittest.cc

   1 /*
   2  *  Copyright (c) 2014 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 test Packet class.
  12
  13 #include "webrtc/modules/audio_coding/neteq/tools/packet.h"
  14
  15 #include "testing/gtest/include/gtest/gtest.h"
  16
  17 namespace webrtc {
  18 namespace test {
  19
  20 namespace {
  21 const int kHeaderLengthBytes = 12;
  22
  23 void MakeRtpHeader(int payload_type,
  24                    int seq_number,
  25                    uint32_t timestamp,
  26                    uint32_t ssrc,
  27                    uint8_t* rtp_data) {
  28   rtp_data[0] = 0x80;
  29   rtp_data[1] = payload_type & 0xFF;
  30   rtp_data[2] = (seq_number >> 8) & 0xFF;
  31   rtp_data[3] = (seq_number) & 0xFF;
  32   rtp_data[4] = (timestamp >> 24) & 0xFF;
  33   rtp_data[5] = (timestamp >> 16) & 0xFF;
  34   rtp_data[6] = (timestamp >> 8) & 0xFF;
  35   rtp_data[7] = timestamp & 0xFF;
  36   rtp_data[8] = (ssrc >> 24) & 0xFF;
  37   rtp_data[9] = (ssrc >> 16) & 0xFF;
  38   rtp_data[10] = (ssrc >> 8) & 0xFF;
  39   rtp_data[11] = ssrc & 0xFF;
  40 }
  41 }  // namespace
  42
  43 TEST(TestPacket, RegularPacket) {
  44   const size_t kPacketLengthBytes = 100;
  45   uint8_t* packet_memory = new uint8_t[kPacketLengthBytes];
  46   const uint8_t kPayloadType = 17;
  47   const uint16_t kSequenceNumber = 4711;
  48   const uint32_t kTimestamp = 47114711;
  49   const uint32_t kSsrc = 0x12345678;
  50   MakeRtpHeader(
  51       kPayloadType, kSequenceNumber, kTimestamp, kSsrc, packet_memory);
  52   const double kPacketTime = 1.0;
  53   // Hand over ownership of |packet_memory| to |packet|.
  54   Packet packet(packet_memory, kPacketLengthBytes, kPacketTime);
  55   ASSERT_TRUE(packet.valid_header());
  56   EXPECT_EQ(kPayloadType, packet.header().payloadType);
  57   EXPECT_EQ(kSequenceNumber, packet.header().sequenceNumber);
  58   EXPECT_EQ(kTimestamp, packet.header().timestamp);
  59   EXPECT_EQ(kSsrc, packet.header().ssrc);
  60   EXPECT_EQ(0, packet.header().numCSRCs);
  61   EXPECT_EQ(kPacketLengthBytes, packet.packet_length_bytes());
  62   EXPECT_EQ(kPacketLengthBytes - kHeaderLengthBytes,
  63             packet.payload_length_bytes());
  64   EXPECT_EQ(kPacketLengthBytes, packet.virtual_packet_length_bytes());
  65   EXPECT_EQ(kPacketLengthBytes - kHeaderLengthBytes,
  66             packet.virtual_payload_length_bytes());
  67   EXPECT_EQ(kPacketTime, packet.time_ms());
  68 }
  69
  70 TEST(TestPacket, DummyPacket) {
  71   const size_t kPacketLengthBytes = kHeaderLengthBytes;  // Only RTP header.
  72   const size_t kVirtualPacketLengthBytes = 100;
  73   uint8_t* packet_memory = new uint8_t[kPacketLengthBytes];
  74   const uint8_t kPayloadType = 17;
  75   const uint16_t kSequenceNumber = 4711;
  76   const uint32_t kTimestamp = 47114711;
  77   const uint32_t kSsrc = 0x12345678;
  78   MakeRtpHeader(
  79       kPayloadType, kSequenceNumber, kTimestamp, kSsrc, packet_memory);
  80   const double kPacketTime = 1.0;
  81   // Hand over ownership of |packet_memory| to |packet|.
  82   Packet packet(packet_memory,
  83                 kPacketLengthBytes,
  84                 kVirtualPacketLengthBytes,
  85                 kPacketTime);
  86   ASSERT_TRUE(packet.valid_header());
  87   EXPECT_EQ(kPayloadType, packet.header().payloadType);
  88   EXPECT_EQ(kSequenceNumber, packet.header().sequenceNumber);
  89   EXPECT_EQ(kTimestamp, packet.header().timestamp);
  90   EXPECT_EQ(kSsrc, packet.header().ssrc);
  91   EXPECT_EQ(0, packet.header().numCSRCs);
  92   EXPECT_EQ(kPacketLengthBytes, packet.packet_length_bytes());
  93   EXPECT_EQ(kPacketLengthBytes - kHeaderLengthBytes,
  94             packet.payload_length_bytes());
  95   EXPECT_EQ(kVirtualPacketLengthBytes, packet.virtual_packet_length_bytes());
  96   EXPECT_EQ(kVirtualPacketLengthBytes - kHeaderLengthBytes,
  97             packet.virtual_payload_length_bytes());
  98   EXPECT_EQ(kPacketTime, packet.time_ms());
  99 }
 100
 101 namespace {
 102 // Writes one RED block header starting at |rtp_data|, according to RFC 2198.
 103 // returns the number of bytes written (1 or 4).
 104 //
 105 // Format if |last_payoad| is false:
 106 // 0                   1                    2                   3
 107 // 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
 108 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 109 // |1|   block PT  |  timestamp offset         |   block length    |
 110 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 111 //
 112 // Format if |last_payoad| is true:
 113 // 0 1 2 3 4 5 6 7
 114 // +-+-+-+-+-+-+-+-+
 115 // |0|   Block PT  |
 116 // +-+-+-+-+-+-+-+-+
 117
 118 int MakeRedHeader(int payload_type,
 119                   uint32_t timestamp_offset,
 120                   int block_length,
 121                   bool last_payload,
 122                   uint8_t* rtp_data) {
 123   rtp_data[0] = 0x80 | (payload_type & 0x7F);  // Set the first bit to 1.
 124   if (last_payload) {
 125     rtp_data[0] &= 0x7F;  // Reset the first but to 0 to indicate last block.
 126     return 1;
 127   }
 128   rtp_data[1] = timestamp_offset >> 6;
 129   rtp_data[2] = (timestamp_offset & 0x3F) << 2;
 130   rtp_data[2] |= block_length >> 8;
 131   rtp_data[3] = block_length & 0xFF;
 132   return 4;
 133 }
 134 }  // namespace
 135
 136 TEST(TestPacket, RED) {
 137   const size_t kPacketLengthBytes = 100;
 138   uint8_t* packet_memory = new uint8_t[kPacketLengthBytes];
 139   const uint8_t kRedPayloadType = 17;
 140   const uint16_t kSequenceNumber = 4711;
 141   const uint32_t kTimestamp = 47114711;
 142   const uint32_t kSsrc = 0x12345678;
 143   MakeRtpHeader(
 144       kRedPayloadType, kSequenceNumber, kTimestamp, kSsrc, packet_memory);
 145   // Create four RED headers.
 146   // Payload types are just the same as the block index the offset is 100 times
 147   // the block index.
 148   const int kRedBlocks = 4;
 149   uint8_t* payload_ptr =
 150       &packet_memory[kHeaderLengthBytes];  // First byte after header.
 151   for (int i = 0; i < kRedBlocks; ++i) {
 152     int payload_type = i;
 153     // Offset value is not used for the last block.
 154     uint32_t timestamp_offset = 100 * i;
 155     int block_length = 10 * i;
 156     bool last_block = (i == kRedBlocks - 1) ? true : false;
 157     payload_ptr += MakeRedHeader(
 158         payload_type, timestamp_offset, block_length, last_block, payload_ptr);
 159   }
 160   const double kPacketTime = 1.0;
 161   // Hand over ownership of |packet_memory| to |packet|.
 162   Packet packet(packet_memory, kPacketLengthBytes, kPacketTime);
 163   ASSERT_TRUE(packet.valid_header());
 164   EXPECT_EQ(kRedPayloadType, packet.header().payloadType);
 165   EXPECT_EQ(kSequenceNumber, packet.header().sequenceNumber);
 166   EXPECT_EQ(kTimestamp, packet.header().timestamp);
 167   EXPECT_EQ(kSsrc, packet.header().ssrc);
 168   EXPECT_EQ(0, packet.header().numCSRCs);
 169   EXPECT_EQ(kPacketLengthBytes, packet.packet_length_bytes());
 170   EXPECT_EQ(kPacketLengthBytes - kHeaderLengthBytes,
 171             packet.payload_length_bytes());
 172   EXPECT_EQ(kPacketLengthBytes, packet.virtual_packet_length_bytes());
 173   EXPECT_EQ(kPacketLengthBytes - kHeaderLengthBytes,
 174             packet.virtual_payload_length_bytes());
 175   EXPECT_EQ(kPacketTime, packet.time_ms());
 176   std::list<RTPHeader*> red_headers;
 177   EXPECT_TRUE(packet.ExtractRedHeaders(&red_headers));
 178   EXPECT_EQ(kRedBlocks, static_cast<int>(red_headers.size()));
 179   int block_index = 0;
 180   for (std::list<RTPHeader*>::reverse_iterator it = red_headers.rbegin();
 181        it != red_headers.rend();
 182        ++it) {
 183     // Reading list from the back, since the extraction puts the main payload
 184     // (which is the last one on wire) first.
 185     RTPHeader* red_block = *it;
 186     EXPECT_EQ(block_index, red_block->payloadType);
 187     EXPECT_EQ(kSequenceNumber, red_block->sequenceNumber);
 188     if (block_index == kRedBlocks - 1) {
 189       // Last block has zero offset per definition.
 190       EXPECT_EQ(kTimestamp, red_block->timestamp);
 191     } else {
 192       EXPECT_EQ(kTimestamp - 100 * block_index, red_block->timestamp);
 193     }
 194     EXPECT_EQ(kSsrc, red_block->ssrc);
 195     EXPECT_EQ(0, red_block->numCSRCs);
 196     ++block_index;
 197   }
 198   Packet::DeleteRedHeaders(&red_headers);
 199 }
 200
 201 }  // namespace test
 202 }  // namespace webrtc