Note: We no longer publish the latest version of our code here. We primarily use a kumc-bmi github organization. The heron ETL repository, in particular, is not public. Peers in the informatics community should see MultiSiteDev for details on requesting access.

source: webrtc/webrtc/modules/rtp_rtcp/test/testAPI/test_api_video.cc @ 0:4bda6873e34c

pub_scrub_3792 tip
Last change on this file since 0:4bda6873e34c was 0:4bda6873e34c, checked in by Michael Prittie <mprittie@…>, 6 years ago

Scrubbed password for publication.

File size: 7.3 KB
Line 
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#include <stdlib.h>
12
13#include <algorithm>
14#include <vector>
15
16#include "testing/gtest/include/gtest/gtest.h"
17#include "webrtc/common_types.h"
18#include "webrtc/modules/rtp_rtcp/interface/rtp_payload_registry.h"
19#include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h"
20#include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h"
21#include "webrtc/modules/rtp_rtcp/source/rtp_receiver_video.h"
22#include "webrtc/modules/rtp_rtcp/source/rtp_utility.h"
23#include "webrtc/modules/rtp_rtcp/test/testAPI/test_api.h"
24
25namespace webrtc {
26
27class RtpRtcpVideoTest : public ::testing::Test {
28 protected:
29  RtpRtcpVideoTest()
30      : test_id_(123),
31        rtp_payload_registry_(0, RTPPayloadStrategy::CreateStrategy(false)),
32        test_ssrc_(3456),
33        test_timestamp_(4567),
34        test_sequence_number_(2345),
35        fake_clock(123456) {
36  }
37  ~RtpRtcpVideoTest() {}
38
39  virtual void SetUp() {
40    transport_ = new LoopBackTransport();
41    receiver_ = new TestRtpReceiver();
42    receive_statistics_.reset(ReceiveStatistics::Create(&fake_clock));
43    RtpRtcp::Configuration configuration;
44    configuration.id = test_id_;
45    configuration.audio = false;
46    configuration.clock = &fake_clock;
47    configuration.outgoing_transport = transport_;
48
49    video_module_ = RtpRtcp::CreateRtpRtcp(configuration);
50    rtp_receiver_.reset(RtpReceiver::CreateVideoReceiver(
51        test_id_, &fake_clock, receiver_, NULL, &rtp_payload_registry_));
52
53    EXPECT_EQ(0, video_module_->SetRTCPStatus(kRtcpCompound));
54    EXPECT_EQ(0, video_module_->SetSSRC(test_ssrc_));
55    rtp_receiver_->SetNACKStatus(kNackRtcp);
56    EXPECT_EQ(0, video_module_->SetStorePacketsStatus(true, 600));
57    EXPECT_EQ(0, video_module_->SetSendingStatus(true));
58
59    transport_->SetSendModule(video_module_, &rtp_payload_registry_,
60                              rtp_receiver_.get(), receive_statistics_.get());
61
62    VideoCodec video_codec;
63    memset(&video_codec, 0, sizeof(video_codec));
64    video_codec.plType = 123;
65    memcpy(video_codec.plName, "I420", 5);
66
67    EXPECT_EQ(0, video_module_->RegisterSendPayload(video_codec));
68    EXPECT_EQ(0, rtp_receiver_->RegisterReceivePayload(video_codec.plName,
69                                                       video_codec.plType,
70                                                       90000,
71                                                       0,
72                                                       video_codec.maxBitrate));
73
74    payload_data_length_ = sizeof(video_frame_);
75
76    for (int n = 0; n < payload_data_length_; n++) {
77      video_frame_[n] = n%10;
78    }
79  }
80
81  int32_t BuildRTPheader(uint8_t* dataBuffer,
82                               uint32_t timestamp,
83                               uint32_t sequence_number) {
84    dataBuffer[0] = static_cast<uint8_t>(0x80);  // version 2
85    dataBuffer[1] = static_cast<uint8_t>(kPayloadType);
86    ModuleRTPUtility::AssignUWord16ToBuffer(dataBuffer + 2,
87                                                    sequence_number);
88    ModuleRTPUtility::AssignUWord32ToBuffer(dataBuffer + 4, timestamp);
89    ModuleRTPUtility::AssignUWord32ToBuffer(dataBuffer + 8,
90                                                    0x1234);  // SSRC.
91    int32_t rtpHeaderLength = 12;
92    return rtpHeaderLength;
93  }
94
95  int PaddingPacket(uint8_t* buffer,
96                    uint32_t timestamp,
97                    uint32_t sequence_number,
98                    int32_t bytes) {
99    // Max in the RFC 3550 is 255 bytes, we limit it to be modulus 32 for SRTP.
100    int max_length = 224;
101
102    int padding_bytes_in_packet = max_length;
103    if (bytes < max_length) {
104      padding_bytes_in_packet = (bytes + 16) & 0xffe0;  // Keep our modulus 32.
105    }
106    // Correct seq num, timestamp and payload type.
107    int header_length = BuildRTPheader(buffer, timestamp,
108                                       sequence_number);
109    buffer[0] |= 0x20;  // Set padding bit.
110    int32_t* data =
111        reinterpret_cast<int32_t*>(&(buffer[header_length]));
112
113    // Fill data buffer with random data.
114    for (int j = 0; j < (padding_bytes_in_packet >> 2); j++) {
115      data[j] = rand();  // NOLINT
116    }
117    // Set number of padding bytes in the last byte of the packet.
118    buffer[header_length + padding_bytes_in_packet - 1] =
119        padding_bytes_in_packet;
120    return padding_bytes_in_packet + header_length;
121  }
122
123  virtual void TearDown() {
124    delete video_module_;
125    delete transport_;
126    delete receiver_;
127  }
128
129  int test_id_;
130  scoped_ptr<ReceiveStatistics> receive_statistics_;
131  RTPPayloadRegistry rtp_payload_registry_;
132  scoped_ptr<RtpReceiver> rtp_receiver_;
133  RtpRtcp* video_module_;
134  LoopBackTransport* transport_;
135  TestRtpReceiver* receiver_;
136  uint32_t test_ssrc_;
137  uint32_t test_timestamp_;
138  uint16_t test_sequence_number_;
139  uint8_t  video_frame_[65000];
140  int payload_data_length_;
141  SimulatedClock fake_clock;
142  enum { kPayloadType = 100 };
143};
144
145TEST_F(RtpRtcpVideoTest, BasicVideo) {
146  uint32_t timestamp = 3000;
147  EXPECT_EQ(0, video_module_->SendOutgoingData(kVideoFrameDelta, 123,
148                                               timestamp,
149                                               timestamp / 90,
150                                               video_frame_,
151                                               payload_data_length_));
152}
153
154TEST_F(RtpRtcpVideoTest, PaddingOnlyFrames) {
155  const int kPadSize = 255;
156  uint8_t padding_packet[kPadSize];
157  uint32_t seq_num = 0;
158  uint32_t timestamp = 3000;
159  VideoCodec codec;
160  codec.codecType = kVideoCodecVP8;
161  codec.plType = kPayloadType;
162  strncpy(codec.plName, "VP8", 4);
163  EXPECT_EQ(0, rtp_receiver_->RegisterReceivePayload(codec.plName,
164                                                     codec.plType,
165                                                     90000,
166                                                     0,
167                                                     codec.maxBitrate));
168  for (int frame_idx = 0; frame_idx < 10; ++frame_idx) {
169    for (int packet_idx = 0; packet_idx < 5; ++packet_idx) {
170      int packet_size = PaddingPacket(padding_packet, timestamp, seq_num,
171                                      kPadSize);
172      ++seq_num;
173      RTPHeader header;
174      scoped_ptr<RtpHeaderParser> parser(RtpHeaderParser::Create());
175      EXPECT_TRUE(parser->Parse(padding_packet, packet_size, &header));
176      PayloadUnion payload_specific;
177      EXPECT_TRUE(rtp_payload_registry_.GetPayloadSpecifics(header.payloadType,
178                                                           &payload_specific));
179      const uint8_t* payload = padding_packet + header.headerLength;
180      const int payload_length = packet_size - header.headerLength;
181      EXPECT_TRUE(rtp_receiver_->IncomingRtpPacket(header, payload,
182                                                   payload_length,
183                                                   payload_specific, true));
184      EXPECT_EQ(0, receiver_->payload_size());
185      EXPECT_EQ(payload_length, receiver_->rtp_header().header.paddingLength);
186    }
187    timestamp += 3000;
188    fake_clock.AdvanceTimeMilliseconds(33);
189  }
190}
191
192}  // namespace webrtc
Note: See TracBrowser for help on using the repository browser.