src/third_party/webrtc/modules/rtp_rtcp/source/rtp_utility_unittest.cc

   1 /*
   2  *  Copyright (c) 2011 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 /*
  12  * This file conatins unit tests for the RtpUtility.
  13  */
  14
  15 #include "testing/gtest/include/gtest/gtest.h"
  16 #include "webrtc/modules/rtp_rtcp/source/rtp_format_vp8.h"
  17 #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h"
  18 #include "webrtc/typedefs.h"
  19
  20 namespace webrtc {
  21
  22 using RtpUtility::RTPPayloadParser;
  23 using RtpUtility::RTPPayload;
  24 using RtpUtility::RTPPayloadVP8;
  25
  26 // Payload descriptor
  27 //       0 1 2 3 4 5 6 7
  28 //      +-+-+-+-+-+-+-+-+
  29 //      |X|R|N|S|PartID | (REQUIRED)
  30 //      +-+-+-+-+-+-+-+-+
  31 // X:   |I|L|T|K|  RSV  | (OPTIONAL)
  32 //      +-+-+-+-+-+-+-+-+
  33 // I:   |   PictureID   | (OPTIONAL)
  34 //      +-+-+-+-+-+-+-+-+
  35 // L:   |   TL0PICIDX   | (OPTIONAL)
  36 //      +-+-+-+-+-+-+-+-+
  37 // T/K: |TID:Y| KEYIDX  | (OPTIONAL)
  38 //      +-+-+-+-+-+-+-+-+
  39 //
  40 // Payload header
  41 //       0 1 2 3 4 5 6 7
  42 //      +-+-+-+-+-+-+-+-+
  43 //      |Size0|H| VER |P|
  44 //      +-+-+-+-+-+-+-+-+
  45 //      |     Size1     |
  46 //      +-+-+-+-+-+-+-+-+
  47 //      |     Size2     |
  48 //      +-+-+-+-+-+-+-+-+
  49 //      | Bytes 4..N of |
  50 //      | VP8 payload   |
  51 //      :               :
  52 //      +-+-+-+-+-+-+-+-+
  53 //      | OPTIONAL RTP  |
  54 //      | padding       |
  55 //      :               :
  56 //      +-+-+-+-+-+-+-+-+
  57
  58 void VerifyBasicHeader(const RTPPayloadVP8 &header,
  59                        bool N, bool S, int PartID) {
  60   EXPECT_EQ(N, header.nonReferenceFrame);
  61   EXPECT_EQ(S, header.beginningOfPartition);
  62   EXPECT_EQ(PartID, header.partitionID);
  63 }
  64
  65 void VerifyExtensions(const RTPPayloadVP8 &header,
  66                       bool I, bool L, bool T, bool K) {
  67   EXPECT_EQ(I, header.hasPictureID);
  68   EXPECT_EQ(L, header.hasTl0PicIdx);
  69   EXPECT_EQ(T, header.hasTID);
  70   EXPECT_EQ(K, header.hasKeyIdx);
  71 }
  72
  73 TEST(ParseVP8Test, BasicHeader) {
  74   uint8_t payload[4] = {0};
  75   payload[0] = 0x14;  // Binary 0001 0100; S = 1, PartID = 4.
  76   payload[1] = 0x01;  // P frame.
  77
  78   RTPPayloadParser rtpPayloadParser(kRtpVideoVp8, payload, 4);
  79
  80   RTPPayload parsedPacket;
  81   ASSERT_TRUE(rtpPayloadParser.Parse(parsedPacket));
  82
  83   EXPECT_EQ(RtpUtility::kPFrame, parsedPacket.frameType);
  84   EXPECT_EQ(kRtpVideoVp8, parsedPacket.type);
  85
  86   VerifyBasicHeader(parsedPacket.info.VP8, 0 /*N*/, 1 /*S*/, 4 /*PartID*/);
  87   VerifyExtensions(parsedPacket.info.VP8, 0 /*I*/, 0 /*L*/, 0 /*T*/, 0 /*K*/);
  88
  89   EXPECT_EQ(payload + 1, parsedPacket.info.VP8.data);
  90   EXPECT_EQ(4 - 1, parsedPacket.info.VP8.dataLength);
  91 }
  92
  93 TEST(ParseVP8Test, PictureID) {
  94   uint8_t payload[10] = {0};
  95   payload[0] = 0xA0;
  96   payload[1] = 0x80;
  97   payload[2] = 17;
  98
  99   RTPPayloadParser rtpPayloadParser(kRtpVideoVp8, payload, 10);
 100
 101   RTPPayload parsedPacket;
 102   ASSERT_TRUE(rtpPayloadParser.Parse(parsedPacket));
 103
 104   EXPECT_EQ(RtpUtility::kPFrame, parsedPacket.frameType);
 105   EXPECT_EQ(kRtpVideoVp8, parsedPacket.type);
 106
 107   VerifyBasicHeader(parsedPacket.info.VP8, 1 /*N*/, 0 /*S*/, 0 /*PartID*/);
 108   VerifyExtensions(parsedPacket.info.VP8, 1 /*I*/, 0 /*L*/, 0 /*T*/, 0 /*K*/);
 109
 110   EXPECT_EQ(17, parsedPacket.info.VP8.pictureID);
 111
 112   EXPECT_EQ(payload + 3, parsedPacket.info.VP8.data);
 113   EXPECT_EQ(10 - 3, parsedPacket.info.VP8.dataLength);
 114
 115
 116   // Re-use payload, but change to long PictureID.
 117   payload[2] = 0x80 | 17;
 118   payload[3] = 17;
 119   RTPPayloadParser rtpPayloadParser2(kRtpVideoVp8, payload, 10);
 120
 121   ASSERT_TRUE(rtpPayloadParser2.Parse(parsedPacket));
 122
 123   VerifyBasicHeader(parsedPacket.info.VP8, 1 /*N*/, 0 /*S*/, 0 /*PartID*/);
 124   VerifyExtensions(parsedPacket.info.VP8, 1 /*I*/, 0 /*L*/, 0 /*T*/, 0 /*K*/);
 125
 126   EXPECT_EQ((17<<8) + 17, parsedPacket.info.VP8.pictureID);
 127
 128   EXPECT_EQ(payload + 4, parsedPacket.info.VP8.data);
 129   EXPECT_EQ(10 - 4, parsedPacket.info.VP8.dataLength);
 130 }
 131
 132 TEST(ParseVP8Test, Tl0PicIdx) {
 133   uint8_t payload[13] = {0};
 134   payload[0] = 0x90;
 135   payload[1] = 0x40;
 136   payload[2] = 17;
 137
 138   RTPPayloadParser rtpPayloadParser(kRtpVideoVp8, payload, 13);
 139
 140   RTPPayload parsedPacket;
 141   ASSERT_TRUE(rtpPayloadParser.Parse(parsedPacket));
 142
 143   EXPECT_EQ(RtpUtility::kIFrame, parsedPacket.frameType);
 144   EXPECT_EQ(kRtpVideoVp8, parsedPacket.type);
 145
 146   VerifyBasicHeader(parsedPacket.info.VP8, 0 /*N*/, 1 /*S*/, 0 /*PartID*/);
 147   VerifyExtensions(parsedPacket.info.VP8, 0 /*I*/, 1 /*L*/, 0 /*T*/, 0 /*K*/);
 148
 149   EXPECT_EQ(17, parsedPacket.info.VP8.tl0PicIdx);
 150
 151   EXPECT_EQ(payload + 3, parsedPacket.info.VP8.data);
 152   EXPECT_EQ(13 - 3, parsedPacket.info.VP8.dataLength);
 153 }
 154
 155 TEST(ParseVP8Test, TIDAndLayerSync) {
 156   uint8_t payload[10] = {0};
 157   payload[0] = 0x88;
 158   payload[1] = 0x20;
 159   payload[2] = 0x80;  // TID(2) + LayerSync(false)
 160
 161   RTPPayloadParser rtpPayloadParser(kRtpVideoVp8, payload, 10);
 162
 163   RTPPayload parsedPacket;
 164   ASSERT_TRUE(rtpPayloadParser.Parse(parsedPacket));
 165
 166   EXPECT_EQ(RtpUtility::kPFrame, parsedPacket.frameType);
 167   EXPECT_EQ(kRtpVideoVp8, parsedPacket.type);
 168
 169   VerifyBasicHeader(parsedPacket.info.VP8, 0 /*N*/, 0 /*S*/, 8 /*PartID*/);
 170   VerifyExtensions(parsedPacket.info.VP8, 0 /*I*/, 0 /*L*/, 1 /*T*/, 0 /*K*/);
 171
 172   EXPECT_EQ(2, parsedPacket.info.VP8.tID);
 173   EXPECT_FALSE(parsedPacket.info.VP8.layerSync);
 174
 175   EXPECT_EQ(payload + 3, parsedPacket.info.VP8.data);
 176   EXPECT_EQ(10 - 3, parsedPacket.info.VP8.dataLength);
 177 }
 178
 179 TEST(ParseVP8Test, KeyIdx) {
 180   uint8_t payload[10] = {0};
 181   payload[0] = 0x88;
 182   payload[1] = 0x10;  // K = 1.
 183   payload[2] = 0x11;  // KEYIDX = 17 decimal.
 184
 185   RTPPayloadParser rtpPayloadParser(kRtpVideoVp8, payload, 10);
 186
 187   RTPPayload parsedPacket;
 188   ASSERT_TRUE(rtpPayloadParser.Parse(parsedPacket));
 189
 190   EXPECT_EQ(RtpUtility::kPFrame, parsedPacket.frameType);
 191   EXPECT_EQ(kRtpVideoVp8, parsedPacket.type);
 192
 193   VerifyBasicHeader(parsedPacket.info.VP8, 0 /*N*/, 0 /*S*/, 8 /*PartID*/);
 194   VerifyExtensions(parsedPacket.info.VP8, 0 /*I*/, 0 /*L*/, 0 /*T*/, 1 /*K*/);
 195
 196   EXPECT_EQ(17, parsedPacket.info.VP8.keyIdx);
 197
 198   EXPECT_EQ(payload + 3, parsedPacket.info.VP8.data);
 199   EXPECT_EQ(10 - 3, parsedPacket.info.VP8.dataLength);
 200 }
 201
 202 TEST(ParseVP8Test, MultipleExtensions) {
 203   uint8_t payload[10] = {0};
 204   payload[0] = 0x88;
 205   payload[1] = 0x80 | 0x40 | 0x20 | 0x10;
 206   payload[2] = 0x80 | 17;    // PictureID, high 7 bits.
 207   payload[3] = 17;           // PictureID, low 8 bits.
 208   payload[4] = 42;           // Tl0PicIdx.
 209   payload[5] = 0x40 | 0x20 | 0x11;  // TID(1) + LayerSync(true) + KEYIDX(17).
 210
 211   RTPPayloadParser rtpPayloadParser(kRtpVideoVp8, payload, 10);
 212
 213   RTPPayload parsedPacket;
 214   ASSERT_TRUE(rtpPayloadParser.Parse(parsedPacket));
 215
 216   EXPECT_EQ(RtpUtility::kPFrame, parsedPacket.frameType);
 217   EXPECT_EQ(kRtpVideoVp8, parsedPacket.type);
 218
 219   VerifyBasicHeader(parsedPacket.info.VP8, 0 /*N*/, 0 /*S*/, 8 /*PartID*/);
 220   VerifyExtensions(parsedPacket.info.VP8, 1 /*I*/, 1 /*L*/, 1 /*T*/, 1 /*K*/);
 221
 222   EXPECT_EQ((17<<8) + 17, parsedPacket.info.VP8.pictureID);
 223   EXPECT_EQ(42, parsedPacket.info.VP8.tl0PicIdx);
 224   EXPECT_EQ(1, parsedPacket.info.VP8.tID);
 225   EXPECT_EQ(17, parsedPacket.info.VP8.keyIdx);
 226
 227   EXPECT_EQ(payload + 6, parsedPacket.info.VP8.data);
 228   EXPECT_EQ(10 - 6, parsedPacket.info.VP8.dataLength);
 229 }
 230
 231 TEST(ParseVP8Test, TooShortHeader) {
 232   uint8_t payload[4] = {0};
 233   payload[0] = 0x88;
 234   payload[1] = 0x80 | 0x40 | 0x20 | 0x10;  // All extensions are enabled...
 235   payload[2] = 0x80 | 17;  // ... but only 2 bytes PictureID is provided.
 236   payload[3] = 17;  // PictureID, low 8 bits.
 237
 238   RTPPayloadParser rtpPayloadParser(kRtpVideoVp8, payload, 4);
 239
 240   RTPPayload parsedPacket;
 241   EXPECT_FALSE(rtpPayloadParser.Parse(parsedPacket));
 242 }
 243
 244 TEST(ParseVP8Test, TestWithPacketizer) {
 245   uint8_t payload[10] = {0};
 246   uint8_t packet[20] = {0};
 247   RTPVideoHeaderVP8 inputHeader;
 248   inputHeader.nonReference = true;
 249   inputHeader.pictureId = 300;
 250   inputHeader.temporalIdx = 1;
 251   inputHeader.layerSync = false;
 252   inputHeader.tl0PicIdx = kNoTl0PicIdx;  // Disable.
 253   inputHeader.keyIdx = 31;
 254   RtpPacketizerVp8 packetizer(inputHeader, 20);
 255   packetizer.SetPayloadData(payload, 10, NULL);
 256   bool last;
 257   size_t send_bytes;
 258   ASSERT_TRUE(packetizer.NextPacket(packet, &send_bytes, &last));
 259   ASSERT_TRUE(last);
 260
 261   RTPPayloadParser rtpPayloadParser(kRtpVideoVp8, packet, send_bytes);
 262
 263   RTPPayload parsedPacket;
 264   ASSERT_TRUE(rtpPayloadParser.Parse(parsedPacket));
 265
 266   EXPECT_EQ(RtpUtility::kIFrame, parsedPacket.frameType);
 267   EXPECT_EQ(kRtpVideoVp8, parsedPacket.type);
 268
 269   VerifyBasicHeader(parsedPacket.info.VP8,
 270                     inputHeader.nonReference /*N*/,
 271                     1 /*S*/,
 272                     0 /*PartID*/);
 273   VerifyExtensions(parsedPacket.info.VP8,
 274                    1 /*I*/,
 275                    0 /*L*/,
 276                    1 /*T*/,
 277                    1 /*K*/);
 278
 279   EXPECT_EQ(inputHeader.pictureId, parsedPacket.info.VP8.pictureID);
 280   EXPECT_EQ(inputHeader.temporalIdx, parsedPacket.info.VP8.tID);
 281   EXPECT_EQ(inputHeader.layerSync, parsedPacket.info.VP8.layerSync);
 282   EXPECT_EQ(inputHeader.keyIdx, parsedPacket.info.VP8.keyIdx);
 283
 284   EXPECT_EQ(packet + 5, parsedPacket.info.VP8.data);
 285   EXPECT_EQ(send_bytes - 5, parsedPacket.info.VP8.dataLength);
 286 }
 287
 288 }  // namespace