blob: 736db449cc054fba943e6ae12af22e8dae253700 [file] [log] [blame]
pbos@webrtc.org4b5625e2014-08-06 16:26:56 +00001/*
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#include <stdio.h>
12
13#include <map>
kwiberg27f982b2016-03-01 11:52:33 -080014#include <memory>
pbos@webrtc.org4b5625e2014-08-06 16:26:56 +000015#include <sstream>
16
17#include "gflags/gflags.h"
ilnikd60d06a2017-04-05 03:02:20 -070018#include "webrtc/api/video_codecs/video_decoder.h"
ossuf515ab82016-12-07 04:52:58 -080019#include "webrtc/call/call.h"
pbos@webrtc.org4b5625e2014-08-06 16:26:56 +000020#include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
stefan64427e52016-12-20 07:26:58 -080021#include "webrtc/logging/rtc_event_log/rtc_event_log.h"
Henrik Kjellanderff761fb2015-11-04 08:31:52 +010022#include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h"
Edward Lemurc20978e2017-07-06 19:44:34 +020023#include "webrtc/rtc_base/checks.h"
Henrik Kjellander98f53512015-10-28 18:17:40 +010024#include "webrtc/system_wrappers/include/clock.h"
25#include "webrtc/system_wrappers/include/sleep.h"
ilnik863f03b2017-07-11 02:38:36 -070026#include "webrtc/test/call_test.h"
pbos@webrtc.org4b5625e2014-08-06 16:26:56 +000027#include "webrtc/test/encoder_settings.h"
stefan@webrtc.org48ac2262015-03-02 16:18:56 +000028#include "webrtc/test/fake_decoder.h"
kwibergac9f8762016-09-30 22:29:43 -070029#include "webrtc/test/gtest.h"
30#include "webrtc/test/null_transport.h"
pbos@webrtc.org4b5625e2014-08-06 16:26:56 +000031#include "webrtc/test/rtp_file_reader.h"
32#include "webrtc/test/run_loop.h"
33#include "webrtc/test/run_test.h"
34#include "webrtc/test/video_capturer.h"
35#include "webrtc/test/video_renderer.h"
36#include "webrtc/typedefs.h"
37
38namespace webrtc {
39namespace flags {
40
41// TODO(pbos): Multiple receivers.
42
43// Flag for payload type.
44static bool ValidatePayloadType(const char* flagname, int32_t payload_type) {
45 return payload_type > 0 && payload_type <= 127;
46}
ilnik863f03b2017-07-11 02:38:36 -070047DEFINE_int32(payload_type, test::CallTest::kPayloadTypeVP8, "Payload type");
pbos@webrtc.org4b5625e2014-08-06 16:26:56 +000048static int PayloadType() { return static_cast<int>(FLAGS_payload_type); }
49static const bool payload_dummy =
50 google::RegisterFlagValidator(&FLAGS_payload_type, &ValidatePayloadType);
51
ilnik863f03b2017-07-11 02:38:36 -070052DEFINE_int32(payload_type_rtx,
53 test::CallTest::kSendRtxPayloadType,
54 "RTX payload type");
55static int PayloadTypeRtx() {
56 return static_cast<int>(FLAGS_payload_type_rtx);
57}
58static const bool payload_rtx_dummy =
59 google::RegisterFlagValidator(&FLAGS_payload_type_rtx,
60 &ValidatePayloadType);
61
pbos@webrtc.org4b5625e2014-08-06 16:26:56 +000062// Flag for SSRC.
63static bool ValidateSsrc(const char* flagname, uint64_t ssrc) {
64 return ssrc > 0 && ssrc <= 0xFFFFFFFFu;
65}
66
ilnik863f03b2017-07-11 02:38:36 -070067DEFINE_uint64(ssrc, test::CallTest::kVideoSendSsrcs[0], "Incoming SSRC");
pbos@webrtc.org4b5625e2014-08-06 16:26:56 +000068static uint32_t Ssrc() { return static_cast<uint32_t>(FLAGS_ssrc); }
69static const bool ssrc_dummy =
70 google::RegisterFlagValidator(&FLAGS_ssrc, &ValidateSsrc);
71
ilnik863f03b2017-07-11 02:38:36 -070072DEFINE_uint64(ssrc_rtx, test::CallTest::kSendRtxSsrcs[0], "Incoming RTX SSRC");
73static uint32_t SsrcRtx() {
74 return static_cast<uint32_t>(FLAGS_ssrc_rtx);
75}
76static const bool ssrc_rtx_dummy =
77 google::RegisterFlagValidator(&FLAGS_ssrc_rtx, &ValidateSsrc);
78
pbos@webrtc.org4b5625e2014-08-06 16:26:56 +000079static bool ValidateOptionalPayloadType(const char* flagname,
80 int32_t payload_type) {
81 return payload_type == -1 || ValidatePayloadType(flagname, payload_type);
82}
83
84// Flag for RED payload type.
pbos@webrtc.orge8c84bf2014-08-07 14:42:45 +000085DEFINE_int32(red_payload_type, -1, "RED payload type");
pbos@webrtc.org4b5625e2014-08-06 16:26:56 +000086static int RedPayloadType() {
87 return static_cast<int>(FLAGS_red_payload_type);
88}
89static const bool red_dummy =
90 google::RegisterFlagValidator(&FLAGS_red_payload_type,
91 &ValidateOptionalPayloadType);
92
93// Flag for ULPFEC payload type.
pbos@webrtc.orge8c84bf2014-08-07 14:42:45 +000094DEFINE_int32(fec_payload_type, -1, "ULPFEC payload type");
pbos@webrtc.org4b5625e2014-08-06 16:26:56 +000095static int FecPayloadType() {
96 return static_cast<int>(FLAGS_fec_payload_type);
97}
98static const bool fec_dummy =
99 google::RegisterFlagValidator(&FLAGS_fec_payload_type,
100 &ValidateOptionalPayloadType);
101
102// Flag for abs-send-time id.
103static bool ValidateRtpHeaderExtensionId(const char* flagname,
104 int32_t extension_id) {
105 return extension_id >= -1 || extension_id < 15;
106}
pbos@webrtc.orge8c84bf2014-08-07 14:42:45 +0000107DEFINE_int32(abs_send_time_id, -1, "RTP extension ID for abs-send-time");
pbos@webrtc.org4b5625e2014-08-06 16:26:56 +0000108static int AbsSendTimeId() { return static_cast<int>(FLAGS_abs_send_time_id); }
109static const bool abs_send_time_dummy =
110 google::RegisterFlagValidator(&FLAGS_abs_send_time_id,
111 &ValidateRtpHeaderExtensionId);
112
113// Flag for transmission-offset id.
114DEFINE_int32(transmission_offset_id,
115 -1,
pbos@webrtc.orge8c84bf2014-08-07 14:42:45 +0000116 "RTP extension ID for transmission-offset");
pbos@webrtc.org4b5625e2014-08-06 16:26:56 +0000117static int TransmissionOffsetId() {
118 return static_cast<int>(FLAGS_transmission_offset_id);
119}
120static const bool timestamp_offset_dummy =
121 google::RegisterFlagValidator(&FLAGS_transmission_offset_id,
122 &ValidateRtpHeaderExtensionId);
123
124// Flag for rtpdump input file.
pbos@webrtc.orge8c84bf2014-08-07 14:42:45 +0000125bool ValidateInputFilenameNotEmpty(const char* flagname,
126 const std::string& string) {
pbosbb36fdf2015-07-09 07:48:14 -0700127 return !string.empty();
pbos@webrtc.orge8c84bf2014-08-07 14:42:45 +0000128}
stefan@webrtc.org48ac2262015-03-02 16:18:56 +0000129
pbos@webrtc.orge8c84bf2014-08-07 14:42:45 +0000130DEFINE_string(input_file, "", "input file");
pbos@webrtc.org4b5625e2014-08-06 16:26:56 +0000131static std::string InputFile() {
132 return static_cast<std::string>(FLAGS_input_file);
133}
pbos@webrtc.orge8c84bf2014-08-07 14:42:45 +0000134static const bool input_file_dummy =
135 google::RegisterFlagValidator(&FLAGS_input_file,
136 &ValidateInputFilenameNotEmpty);
pbos@webrtc.org4b5625e2014-08-06 16:26:56 +0000137
138// Flag for raw output files.
pbos@webrtc.orge8c84bf2014-08-07 14:42:45 +0000139DEFINE_string(out_base, "", "Basename (excluding .yuv) for raw output");
pbos@webrtc.org4b5625e2014-08-06 16:26:56 +0000140static std::string OutBase() {
141 return static_cast<std::string>(FLAGS_out_base);
142}
143
stefan@webrtc.org48ac2262015-03-02 16:18:56 +0000144DEFINE_string(decoder_bitstream_filename, "", "Decoder bitstream output file");
145static std::string DecoderBitstreamFilename() {
146 return static_cast<std::string>(FLAGS_decoder_bitstream_filename);
147}
148
pbos@webrtc.org4b5625e2014-08-06 16:26:56 +0000149// Flag for video codec.
pbos@webrtc.orge8c84bf2014-08-07 14:42:45 +0000150DEFINE_string(codec, "VP8", "Video codec");
pbos@webrtc.org4b5625e2014-08-06 16:26:56 +0000151static std::string Codec() { return static_cast<std::string>(FLAGS_codec); }
152
153} // namespace flags
154
155static const uint32_t kReceiverLocalSsrc = 0x123456;
156
nisse7ade7b32016-03-23 04:48:10 -0700157class FileRenderPassthrough : public rtc::VideoSinkInterface<VideoFrame> {
pbos@webrtc.org4b5625e2014-08-06 16:26:56 +0000158 public:
nisse7ade7b32016-03-23 04:48:10 -0700159 FileRenderPassthrough(const std::string& basename,
160 rtc::VideoSinkInterface<VideoFrame>* renderer)
pbos@webrtc.org4b5625e2014-08-06 16:26:56 +0000161 : basename_(basename),
162 renderer_(renderer),
pbos@webrtc.org2b4ce3a2015-03-23 13:12:24 +0000163 file_(nullptr),
pbos@webrtc.org4b5625e2014-08-06 16:26:56 +0000164 count_(0),
165 last_width_(0),
166 last_height_(0) {}
167
168 ~FileRenderPassthrough() {
Peter Boström74f6e9e2016-04-04 17:56:10 +0200169 if (file_)
pbos@webrtc.org4b5625e2014-08-06 16:26:56 +0000170 fclose(file_);
171 }
172
173 private:
nisseeb83a1a2016-03-21 01:27:56 -0700174 void OnFrame(const VideoFrame& video_frame) override {
Peter Boström74f6e9e2016-04-04 17:56:10 +0200175 if (renderer_)
nisseeb83a1a2016-03-21 01:27:56 -0700176 renderer_->OnFrame(video_frame);
pbosbb36fdf2015-07-09 07:48:14 -0700177 if (basename_.empty())
pbos@webrtc.org4b5625e2014-08-06 16:26:56 +0000178 return;
179 if (last_width_ != video_frame.width() ||
180 last_height_ != video_frame.height()) {
Peter Boström74f6e9e2016-04-04 17:56:10 +0200181 if (file_)
pbos@webrtc.org4b5625e2014-08-06 16:26:56 +0000182 fclose(file_);
183 std::stringstream filename;
184 filename << basename_;
185 if (++count_ > 1)
186 filename << '-' << count_;
187 filename << '_' << video_frame.width() << 'x' << video_frame.height()
188 << ".yuv";
189 file_ = fopen(filename.str().c_str(), "wb");
Peter Boström74f6e9e2016-04-04 17:56:10 +0200190 if (!file_) {
pbos@webrtc.org4b5625e2014-08-06 16:26:56 +0000191 fprintf(stderr,
192 "Couldn't open file for writing: %s\n",
193 filename.str().c_str());
194 }
195 }
196 last_width_ = video_frame.width();
197 last_height_ = video_frame.height();
Peter Boström74f6e9e2016-04-04 17:56:10 +0200198 if (!file_)
pbos@webrtc.org4b5625e2014-08-06 16:26:56 +0000199 return;
Miguel Casas-Sanchez47650702015-05-29 17:21:40 -0700200 PrintVideoFrame(video_frame, file_);
pbos@webrtc.org4b5625e2014-08-06 16:26:56 +0000201 }
202
203 const std::string basename_;
nisse7ade7b32016-03-23 04:48:10 -0700204 rtc::VideoSinkInterface<VideoFrame>* const renderer_;
pbos@webrtc.org4b5625e2014-08-06 16:26:56 +0000205 FILE* file_;
206 size_t count_;
207 int last_width_;
208 int last_height_;
209};
210
stefan@webrtc.org48ac2262015-03-02 16:18:56 +0000211class DecoderBitstreamFileWriter : public EncodedFrameObserver {
212 public:
213 explicit DecoderBitstreamFileWriter(const char* filename)
214 : file_(fopen(filename, "wb")) {
Peter Boström74f6e9e2016-04-04 17:56:10 +0200215 RTC_DCHECK(file_);
stefan@webrtc.org48ac2262015-03-02 16:18:56 +0000216 }
217 ~DecoderBitstreamFileWriter() { fclose(file_); }
218
219 virtual void EncodedFrameCallback(const EncodedFrame& encoded_frame) {
220 fwrite(encoded_frame.data_, 1, encoded_frame.length_, file_);
221 }
222
223 private:
224 FILE* file_;
225};
226
pbos@webrtc.org4b5625e2014-08-06 16:26:56 +0000227void RtpReplay() {
kwiberg27f982b2016-03-01 11:52:33 -0800228 std::unique_ptr<test::VideoRenderer> playback_video(
kwiberg@webrtc.org00b8f6b2015-02-26 14:34:55 +0000229 test::VideoRenderer::Create("Playback Video", 640, 480));
pbos@webrtc.org4b5625e2014-08-06 16:26:56 +0000230 FileRenderPassthrough file_passthrough(flags::OutBase(),
231 playback_video.get());
232
stefan64427e52016-12-20 07:26:58 -0800233 webrtc::RtcEventLogNullImpl event_log;
234 std::unique_ptr<Call> call(Call::Create(Call::Config(&event_log)));
pbos@webrtc.org4b5625e2014-08-06 16:26:56 +0000235
solenberg4fbae2b2015-08-28 04:07:10 -0700236 test::NullTransport transport;
237 VideoReceiveStream::Config receive_config(&transport);
pbos@webrtc.org4b5625e2014-08-06 16:26:56 +0000238 receive_config.rtp.remote_ssrc = flags::Ssrc();
239 receive_config.rtp.local_ssrc = kReceiverLocalSsrc;
ilnik863f03b2017-07-11 02:38:36 -0700240 receive_config.rtp.rtx_ssrc = flags::SsrcRtx();
241 receive_config.rtp.rtx_payload_types[flags::PayloadType()] =
242 flags::PayloadTypeRtx();
brandtrb5f2c3f2016-10-04 23:28:39 -0700243 receive_config.rtp.ulpfec.ulpfec_payload_type = flags::FecPayloadType();
244 receive_config.rtp.ulpfec.red_payload_type = flags::RedPayloadType();
pbos@webrtc.org4b5625e2014-08-06 16:26:56 +0000245 receive_config.rtp.nack.rtp_history_ms = 1000;
246 if (flags::TransmissionOffsetId() != -1) {
isheriff6f8d6862016-05-26 11:24:55 -0700247 receive_config.rtp.extensions.push_back(RtpExtension(
248 RtpExtension::kTimestampOffsetUri, flags::TransmissionOffsetId()));
pbos@webrtc.org4b5625e2014-08-06 16:26:56 +0000249 }
250 if (flags::AbsSendTimeId() != -1) {
251 receive_config.rtp.extensions.push_back(
isheriff6f8d6862016-05-26 11:24:55 -0700252 RtpExtension(RtpExtension::kAbsSendTimeUri, flags::AbsSendTimeId()));
pbos@webrtc.org4b5625e2014-08-06 16:26:56 +0000253 }
254 receive_config.renderer = &file_passthrough;
255
256 VideoSendStream::Config::EncoderSettings encoder_settings;
257 encoder_settings.payload_name = flags::Codec();
258 encoder_settings.payload_type = flags::PayloadType();
stefan@webrtc.org48ac2262015-03-02 16:18:56 +0000259 VideoReceiveStream::Decoder decoder;
kwiberg27f982b2016-03-01 11:52:33 -0800260 std::unique_ptr<DecoderBitstreamFileWriter> bitstream_writer;
pbosbb36fdf2015-07-09 07:48:14 -0700261 if (!flags::DecoderBitstreamFilename().empty()) {
stefan@webrtc.org48ac2262015-03-02 16:18:56 +0000262 bitstream_writer.reset(new DecoderBitstreamFileWriter(
263 flags::DecoderBitstreamFilename().c_str()));
264 receive_config.pre_decode_callback = bitstream_writer.get();
265 }
266 decoder = test::CreateMatchingDecoder(encoder_settings);
pbosbb36fdf2015-07-09 07:48:14 -0700267 if (!flags::DecoderBitstreamFilename().empty()) {
stefan@webrtc.org48ac2262015-03-02 16:18:56 +0000268 // Replace with a null decoder if we're writing the bitstream to a file
269 // instead.
270 delete decoder.decoder;
271 decoder.decoder = new test::FakeNullDecoder();
272 }
pbos@webrtc.org776e6f22014-10-29 15:28:39 +0000273 receive_config.decoders.push_back(decoder);
pbos@webrtc.org4b5625e2014-08-06 16:26:56 +0000274
275 VideoReceiveStream* receive_stream =
Tommi733b5472016-06-10 17:58:01 +0200276 call->CreateVideoReceiveStream(std::move(receive_config));
pbos@webrtc.org4b5625e2014-08-06 16:26:56 +0000277
kwiberg27f982b2016-03-01 11:52:33 -0800278 std::unique_ptr<test::RtpFileReader> rtp_reader(test::RtpFileReader::Create(
pbos@webrtc.org4b5625e2014-08-06 16:26:56 +0000279 test::RtpFileReader::kRtpDump, flags::InputFile()));
Peter Boström74f6e9e2016-04-04 17:56:10 +0200280 if (!rtp_reader) {
pbos@webrtc.org4b5625e2014-08-06 16:26:56 +0000281 rtp_reader.reset(test::RtpFileReader::Create(test::RtpFileReader::kPcap,
282 flags::InputFile()));
Peter Boström74f6e9e2016-04-04 17:56:10 +0200283 if (!rtp_reader) {
pbos@webrtc.org4b5625e2014-08-06 16:26:56 +0000284 fprintf(stderr,
285 "Couldn't open input file as either a rtpdump or .pcap. Note "
stefan@webrtc.org48ac2262015-03-02 16:18:56 +0000286 "that .pcapng is not supported.\nTrying to interpret the file as "
287 "length/packet interleaved.\n");
288 rtp_reader.reset(test::RtpFileReader::Create(
289 test::RtpFileReader::kLengthPacketInterleaved, flags::InputFile()));
Peter Boström74f6e9e2016-04-04 17:56:10 +0200290 if (!rtp_reader) {
stefan@webrtc.org48ac2262015-03-02 16:18:56 +0000291 fprintf(stderr,
292 "Unable to open input file with any supported format\n");
293 return;
294 }
pbos@webrtc.org4b5625e2014-08-06 16:26:56 +0000295 }
296 }
297 receive_stream->Start();
298
299 uint32_t last_time_ms = 0;
300 int num_packets = 0;
pbos@webrtc.orge8c84bf2014-08-07 14:42:45 +0000301 std::map<uint32_t, int> unknown_packets;
pbos@webrtc.org4b5625e2014-08-06 16:26:56 +0000302 while (true) {
henrik.lundin@webrtc.org91d928e2014-11-26 15:50:30 +0000303 test::RtpPacket packet;
pbos@webrtc.org4b5625e2014-08-06 16:26:56 +0000304 if (!rtp_reader->NextPacket(&packet))
305 break;
306 ++num_packets;
nissee5ad5ca2017-03-29 23:57:43 -0700307 switch (call->Receiver()->DeliverPacket(
308 webrtc::MediaType::VIDEO, packet.data, packet.length, PacketTime())) {
pbos@webrtc.org4b5625e2014-08-06 16:26:56 +0000309 case PacketReceiver::DELIVERY_OK:
310 break;
311 case PacketReceiver::DELIVERY_UNKNOWN_SSRC: {
312 RTPHeader header;
kwiberg27f982b2016-03-01 11:52:33 -0800313 std::unique_ptr<RtpHeaderParser> parser(RtpHeaderParser::Create());
pbos@webrtc.org4b5625e2014-08-06 16:26:56 +0000314 parser->Parse(packet.data, packet.length, &header);
pbos@webrtc.orge8c84bf2014-08-07 14:42:45 +0000315 if (unknown_packets[header.ssrc] == 0)
316 fprintf(stderr, "Unknown SSRC: %u!\n", header.ssrc);
317 ++unknown_packets[header.ssrc];
pbos@webrtc.org4b5625e2014-08-06 16:26:56 +0000318 break;
319 }
philipp.hancke7b589602017-01-26 04:54:04 -0800320 case PacketReceiver::DELIVERY_PACKET_ERROR: {
pbos@webrtc.org4b5625e2014-08-06 16:26:56 +0000321 fprintf(stderr, "Packet error, corrupt packets or incorrect setup?\n");
philipp.hancke7b589602017-01-26 04:54:04 -0800322 RTPHeader header;
323 std::unique_ptr<RtpHeaderParser> parser(RtpHeaderParser::Create());
324 parser->Parse(packet.data, packet.length, &header);
sprang3dbfac32017-06-29 07:42:18 -0700325 fprintf(stderr, "Packet len=%zu pt=%u seq=%u ts=%u ssrc=0x%8x\n",
sprang168794c2017-07-06 04:38:06 -0700326 packet.length, header.payloadType, header.sequenceNumber,
327 header.timestamp, header.ssrc);
pbos@webrtc.org4b5625e2014-08-06 16:26:56 +0000328 break;
philipp.hancke7b589602017-01-26 04:54:04 -0800329 }
pbos@webrtc.org4b5625e2014-08-06 16:26:56 +0000330 }
331 if (last_time_ms != 0 && last_time_ms != packet.time_ms) {
332 SleepMs(packet.time_ms - last_time_ms);
333 }
334 last_time_ms = packet.time_ms;
335 }
336 fprintf(stderr, "num_packets: %d\n", num_packets);
337
pbos@webrtc.orge8c84bf2014-08-07 14:42:45 +0000338 for (std::map<uint32_t, int>::const_iterator it = unknown_packets.begin();
339 it != unknown_packets.end();
340 ++it) {
341 fprintf(
342 stderr, "Packets for unknown ssrc '%u': %d\n", it->first, it->second);
343 }
344
pbos@webrtc.org4b5625e2014-08-06 16:26:56 +0000345 call->DestroyVideoReceiveStream(receive_stream);
pbos@webrtc.org776e6f22014-10-29 15:28:39 +0000346
347 delete decoder.decoder;
pbos@webrtc.org4b5625e2014-08-06 16:26:56 +0000348}
349} // namespace webrtc
350
351int main(int argc, char* argv[]) {
352 ::testing::InitGoogleTest(&argc, argv);
353 google::ParseCommandLineFlags(&argc, &argv, true);
354
355 webrtc::test::RunTest(webrtc::RtpReplay);
356 return 0;
357}