pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 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 | #include <stdio.h> |
| 12 | |
Benjamin Wright | 90ab76d | 2018-08-23 11:33:29 -0700 | [diff] [blame] | 13 | #include <fstream> |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 14 | #include <map> |
kwiberg | 27f982b | 2016-03-01 11:52:33 -0800 | [diff] [blame] | 15 | #include <memory> |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 16 | |
Steve Anton | 40d5533 | 2019-01-07 10:21:47 -0800 | [diff] [blame] | 17 | #include "absl/memory/memory.h" |
Danil Chapovalov | 99b71df | 2018-10-26 15:57:48 +0200 | [diff] [blame] | 18 | #include "api/test/video/function_video_decoder_factory.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 19 | #include "api/video_codecs/video_decoder.h" |
| 20 | #include "call/call.h" |
| 21 | #include "common_video/libyuv/include/webrtc_libyuv.h" |
| 22 | #include "logging/rtc_event_log/rtc_event_log.h" |
Steve Anton | 10542f2 | 2019-01-11 09:11:00 -0800 | [diff] [blame] | 23 | #include "media/engine/internal_decoder_factory.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 24 | #include "modules/rtp_rtcp/include/rtp_header_parser.h" |
| 25 | #include "rtc_base/checks.h" |
| 26 | #include "rtc_base/flags.h" |
| 27 | #include "rtc_base/string_to_number.h" |
Sam Zackrisson | b45bdb5 | 2018-10-02 16:25:59 +0200 | [diff] [blame] | 28 | #include "rtc_base/strings/json.h" |
Steve Anton | 10542f2 | 2019-01-11 09:11:00 -0800 | [diff] [blame] | 29 | #include "rtc_base/time_utils.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 30 | #include "system_wrappers/include/clock.h" |
| 31 | #include "system_wrappers/include/sleep.h" |
Benjamin Wright | 8efafdf | 2019-01-11 10:48:42 -0800 | [diff] [blame] | 32 | #include "test/call_config_utils.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 33 | #include "test/call_test.h" |
| 34 | #include "test/encoder_settings.h" |
| 35 | #include "test/fake_decoder.h" |
| 36 | #include "test/gtest.h" |
| 37 | #include "test/null_transport.h" |
| 38 | #include "test/rtp_file_reader.h" |
| 39 | #include "test/run_loop.h" |
| 40 | #include "test/run_test.h" |
Sebastian Jansson | f1f363f | 2018-08-13 14:24:58 +0200 | [diff] [blame] | 41 | #include "test/test_video_capturer.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 42 | #include "test/testsupport/frame_writer.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 43 | #include "test/video_renderer.h" |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 44 | |
oprypin | 6e09d87 | 2017-08-31 03:21:39 -0700 | [diff] [blame] | 45 | namespace { |
| 46 | |
| 47 | static bool ValidatePayloadType(int32_t payload_type) { |
| 48 | return payload_type > 0 && payload_type <= 127; |
| 49 | } |
| 50 | |
| 51 | static bool ValidateSsrc(const char* ssrc_string) { |
| 52 | return rtc::StringToNumber<uint32_t>(ssrc_string).has_value(); |
| 53 | } |
| 54 | |
| 55 | static bool ValidateOptionalPayloadType(int32_t payload_type) { |
| 56 | return payload_type == -1 || ValidatePayloadType(payload_type); |
| 57 | } |
| 58 | |
| 59 | static bool ValidateRtpHeaderExtensionId(int32_t extension_id) { |
| 60 | return extension_id >= -1 && extension_id < 15; |
| 61 | } |
| 62 | |
| 63 | bool ValidateInputFilenameNotEmpty(const std::string& string) { |
| 64 | return !string.empty(); |
| 65 | } |
| 66 | |
| 67 | } // namespace |
| 68 | |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 69 | namespace webrtc { |
| 70 | namespace flags { |
| 71 | |
| 72 | // TODO(pbos): Multiple receivers. |
| 73 | |
| 74 | // Flag for payload type. |
Mirko Bonadei | 2dfa998 | 2018-10-18 11:35:32 +0200 | [diff] [blame] | 75 | WEBRTC_DEFINE_int(media_payload_type, |
| 76 | test::CallTest::kPayloadTypeVP8, |
| 77 | "Media payload type"); |
philipel | 752968e | 2017-12-05 12:40:28 +0100 | [diff] [blame] | 78 | static int MediaPayloadType() { |
| 79 | return static_cast<int>(FLAG_media_payload_type); |
| 80 | } |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 81 | |
philipel | 752968e | 2017-12-05 12:40:28 +0100 | [diff] [blame] | 82 | // Flag for RED payload type. |
Mirko Bonadei | 2dfa998 | 2018-10-18 11:35:32 +0200 | [diff] [blame] | 83 | WEBRTC_DEFINE_int(red_payload_type, |
| 84 | test::CallTest::kRedPayloadType, |
| 85 | "RED payload type"); |
philipel | 752968e | 2017-12-05 12:40:28 +0100 | [diff] [blame] | 86 | static int RedPayloadType() { |
| 87 | return static_cast<int>(FLAG_red_payload_type); |
| 88 | } |
| 89 | |
| 90 | // Flag for ULPFEC payload type. |
Mirko Bonadei | 2dfa998 | 2018-10-18 11:35:32 +0200 | [diff] [blame] | 91 | WEBRTC_DEFINE_int(ulpfec_payload_type, |
| 92 | test::CallTest::kUlpfecPayloadType, |
| 93 | "ULPFEC payload type"); |
philipel | 752968e | 2017-12-05 12:40:28 +0100 | [diff] [blame] | 94 | static int UlpfecPayloadType() { |
| 95 | return static_cast<int>(FLAG_ulpfec_payload_type); |
| 96 | } |
| 97 | |
Mirko Bonadei | 2dfa998 | 2018-10-18 11:35:32 +0200 | [diff] [blame] | 98 | WEBRTC_DEFINE_int(media_payload_type_rtx, |
| 99 | test::CallTest::kSendRtxPayloadType, |
| 100 | "Media over RTX payload type"); |
philipel | 752968e | 2017-12-05 12:40:28 +0100 | [diff] [blame] | 101 | static int MediaPayloadTypeRtx() { |
| 102 | return static_cast<int>(FLAG_media_payload_type_rtx); |
| 103 | } |
| 104 | |
Mirko Bonadei | 2dfa998 | 2018-10-18 11:35:32 +0200 | [diff] [blame] | 105 | WEBRTC_DEFINE_int(red_payload_type_rtx, |
| 106 | test::CallTest::kRtxRedPayloadType, |
| 107 | "RED over RTX payload type"); |
philipel | 752968e | 2017-12-05 12:40:28 +0100 | [diff] [blame] | 108 | static int RedPayloadTypeRtx() { |
| 109 | return static_cast<int>(FLAG_red_payload_type_rtx); |
ilnik | 863f03b | 2017-07-11 02:38:36 -0700 | [diff] [blame] | 110 | } |
ilnik | 863f03b | 2017-07-11 02:38:36 -0700 | [diff] [blame] | 111 | |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 112 | // Flag for SSRC. |
oprypin | 6e09d87 | 2017-08-31 03:21:39 -0700 | [diff] [blame] | 113 | const std::string& DefaultSsrc() { |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 114 | static const std::string ssrc = |
| 115 | std::to_string(test::CallTest::kVideoSendSsrcs[0]); |
oprypin | 6e09d87 | 2017-08-31 03:21:39 -0700 | [diff] [blame] | 116 | return ssrc; |
| 117 | } |
Mirko Bonadei | 2dfa998 | 2018-10-18 11:35:32 +0200 | [diff] [blame] | 118 | WEBRTC_DEFINE_string(ssrc, DefaultSsrc().c_str(), "Incoming SSRC"); |
oprypin | 6e09d87 | 2017-08-31 03:21:39 -0700 | [diff] [blame] | 119 | static uint32_t Ssrc() { |
| 120 | return rtc::StringToNumber<uint32_t>(FLAG_ssrc).value(); |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 121 | } |
| 122 | |
oprypin | 6e09d87 | 2017-08-31 03:21:39 -0700 | [diff] [blame] | 123 | const std::string& DefaultSsrcRtx() { |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 124 | static const std::string ssrc_rtx = |
| 125 | std::to_string(test::CallTest::kSendRtxSsrcs[0]); |
oprypin | 6e09d87 | 2017-08-31 03:21:39 -0700 | [diff] [blame] | 126 | return ssrc_rtx; |
| 127 | } |
Mirko Bonadei | 2dfa998 | 2018-10-18 11:35:32 +0200 | [diff] [blame] | 128 | WEBRTC_DEFINE_string(ssrc_rtx, DefaultSsrcRtx().c_str(), "Incoming RTX SSRC"); |
ilnik | 863f03b | 2017-07-11 02:38:36 -0700 | [diff] [blame] | 129 | static uint32_t SsrcRtx() { |
oprypin | 6e09d87 | 2017-08-31 03:21:39 -0700 | [diff] [blame] | 130 | return rtc::StringToNumber<uint32_t>(FLAG_ssrc_rtx).value(); |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 131 | } |
| 132 | |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 133 | // Flag for abs-send-time id. |
Mirko Bonadei | 2dfa998 | 2018-10-18 11:35:32 +0200 | [diff] [blame] | 134 | WEBRTC_DEFINE_int(abs_send_time_id, -1, "RTP extension ID for abs-send-time"); |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 135 | static int AbsSendTimeId() { |
| 136 | return static_cast<int>(FLAG_abs_send_time_id); |
| 137 | } |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 138 | |
| 139 | // Flag for transmission-offset id. |
Mirko Bonadei | 2dfa998 | 2018-10-18 11:35:32 +0200 | [diff] [blame] | 140 | WEBRTC_DEFINE_int(transmission_offset_id, |
| 141 | -1, |
| 142 | "RTP extension ID for transmission-offset"); |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 143 | static int TransmissionOffsetId() { |
oprypin | 6e09d87 | 2017-08-31 03:21:39 -0700 | [diff] [blame] | 144 | return static_cast<int>(FLAG_transmission_offset_id); |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 145 | } |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 146 | |
| 147 | // Flag for rtpdump input file. |
Mirko Bonadei | 2dfa998 | 2018-10-18 11:35:32 +0200 | [diff] [blame] | 148 | WEBRTC_DEFINE_string(input_file, "", "input file"); |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 149 | static std::string InputFile() { |
oprypin | 6e09d87 | 2017-08-31 03:21:39 -0700 | [diff] [blame] | 150 | return static_cast<std::string>(FLAG_input_file); |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 151 | } |
| 152 | |
Mirko Bonadei | 2dfa998 | 2018-10-18 11:35:32 +0200 | [diff] [blame] | 153 | WEBRTC_DEFINE_string(config_file, "", "config file"); |
Benjamin Wright | 90ab76d | 2018-08-23 11:33:29 -0700 | [diff] [blame] | 154 | static std::string ConfigFile() { |
| 155 | return static_cast<std::string>(FLAG_config_file); |
| 156 | } |
| 157 | |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 158 | // Flag for raw output files. |
Mirko Bonadei | 2dfa998 | 2018-10-18 11:35:32 +0200 | [diff] [blame] | 159 | WEBRTC_DEFINE_string(out_base, "", "Basename (excluding .jpg) for raw output"); |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 160 | static std::string OutBase() { |
oprypin | 6e09d87 | 2017-08-31 03:21:39 -0700 | [diff] [blame] | 161 | return static_cast<std::string>(FLAG_out_base); |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 162 | } |
| 163 | |
Mirko Bonadei | 2dfa998 | 2018-10-18 11:35:32 +0200 | [diff] [blame] | 164 | WEBRTC_DEFINE_string(decoder_bitstream_filename, |
| 165 | "", |
| 166 | "Decoder bitstream output file"); |
stefan@webrtc.org | 48ac226 | 2015-03-02 16:18:56 +0000 | [diff] [blame] | 167 | static std::string DecoderBitstreamFilename() { |
oprypin | 6e09d87 | 2017-08-31 03:21:39 -0700 | [diff] [blame] | 168 | return static_cast<std::string>(FLAG_decoder_bitstream_filename); |
stefan@webrtc.org | 48ac226 | 2015-03-02 16:18:56 +0000 | [diff] [blame] | 169 | } |
| 170 | |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 171 | // Flag for video codec. |
Mirko Bonadei | 2dfa998 | 2018-10-18 11:35:32 +0200 | [diff] [blame] | 172 | WEBRTC_DEFINE_string(codec, "VP8", "Video codec"); |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 173 | static std::string Codec() { |
| 174 | return static_cast<std::string>(FLAG_codec); |
| 175 | } |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 176 | |
Mirko Bonadei | 2dfa998 | 2018-10-18 11:35:32 +0200 | [diff] [blame] | 177 | WEBRTC_DEFINE_bool(help, false, "Print this message."); |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 178 | } // namespace flags |
| 179 | |
| 180 | static const uint32_t kReceiverLocalSsrc = 0x123456; |
| 181 | |
nisse | 7ade7b3 | 2016-03-23 04:48:10 -0700 | [diff] [blame] | 182 | class FileRenderPassthrough : public rtc::VideoSinkInterface<VideoFrame> { |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 183 | public: |
nisse | 7ade7b3 | 2016-03-23 04:48:10 -0700 | [diff] [blame] | 184 | FileRenderPassthrough(const std::string& basename, |
| 185 | rtc::VideoSinkInterface<VideoFrame>* renderer) |
philipel | 99b6345 | 2017-08-25 07:24:21 -0700 | [diff] [blame] | 186 | : basename_(basename), renderer_(renderer), file_(nullptr), count_(0) {} |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 187 | |
Mirko Bonadei | fe055c1 | 2019-01-29 22:53:28 +0100 | [diff] [blame] | 188 | ~FileRenderPassthrough() override { |
Peter Boström | 74f6e9e | 2016-04-04 17:56:10 +0200 | [diff] [blame] | 189 | if (file_) |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 190 | fclose(file_); |
| 191 | } |
| 192 | |
| 193 | private: |
nisse | eb83a1a | 2016-03-21 01:27:56 -0700 | [diff] [blame] | 194 | void OnFrame(const VideoFrame& video_frame) override { |
Peter Boström | 74f6e9e | 2016-04-04 17:56:10 +0200 | [diff] [blame] | 195 | if (renderer_) |
nisse | eb83a1a | 2016-03-21 01:27:56 -0700 | [diff] [blame] | 196 | renderer_->OnFrame(video_frame); |
philipel | 99b6345 | 2017-08-25 07:24:21 -0700 | [diff] [blame] | 197 | |
pbos | bb36fdf | 2015-07-09 07:48:14 -0700 | [diff] [blame] | 198 | if (basename_.empty()) |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 199 | return; |
philipel | 99b6345 | 2017-08-25 07:24:21 -0700 | [diff] [blame] | 200 | |
| 201 | std::stringstream filename; |
| 202 | filename << basename_ << count_++ << "_" << video_frame.timestamp() |
| 203 | << ".jpg"; |
| 204 | |
philipel | 99b6345 | 2017-08-25 07:24:21 -0700 | [diff] [blame] | 205 | test::JpegFrameWriter frame_writer(filename.str()); |
| 206 | RTC_CHECK(frame_writer.WriteFrame(video_frame, 100)); |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 207 | } |
| 208 | |
| 209 | const std::string basename_; |
nisse | 7ade7b3 | 2016-03-23 04:48:10 -0700 | [diff] [blame] | 210 | rtc::VideoSinkInterface<VideoFrame>* const renderer_; |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 211 | FILE* file_; |
| 212 | size_t count_; |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 213 | }; |
| 214 | |
Niels Möller | f88a22c | 2018-06-19 17:05:03 +0200 | [diff] [blame] | 215 | class DecoderBitstreamFileWriter : public test::FakeDecoder { |
stefan@webrtc.org | 48ac226 | 2015-03-02 16:18:56 +0000 | [diff] [blame] | 216 | public: |
| 217 | explicit DecoderBitstreamFileWriter(const char* filename) |
| 218 | : file_(fopen(filename, "wb")) { |
Peter Boström | 74f6e9e | 2016-04-04 17:56:10 +0200 | [diff] [blame] | 219 | RTC_DCHECK(file_); |
stefan@webrtc.org | 48ac226 | 2015-03-02 16:18:56 +0000 | [diff] [blame] | 220 | } |
Mirko Bonadei | fe055c1 | 2019-01-29 22:53:28 +0100 | [diff] [blame] | 221 | ~DecoderBitstreamFileWriter() override { fclose(file_); } |
stefan@webrtc.org | 48ac226 | 2015-03-02 16:18:56 +0000 | [diff] [blame] | 222 | |
Niels Möller | f88a22c | 2018-06-19 17:05:03 +0200 | [diff] [blame] | 223 | int32_t Decode(const EncodedImage& encoded_frame, |
Benjamin Wright | 8efafdf | 2019-01-11 10:48:42 -0800 | [diff] [blame] | 224 | bool /* missing_frames */, |
Benjamin Wright | 8efafdf | 2019-01-11 10:48:42 -0800 | [diff] [blame] | 225 | int64_t /* render_time_ms */) override { |
Niels Möller | 77536a2 | 2019-01-15 08:50:01 +0100 | [diff] [blame] | 226 | if (fwrite(encoded_frame.data(), 1, encoded_frame.size(), file_) < |
| 227 | encoded_frame.size()) { |
Niels Möller | f88a22c | 2018-06-19 17:05:03 +0200 | [diff] [blame] | 228 | RTC_LOG_ERR(LS_ERROR) << "fwrite of encoded frame failed."; |
| 229 | return WEBRTC_VIDEO_CODEC_ERROR; |
| 230 | } |
| 231 | return WEBRTC_VIDEO_CODEC_OK; |
stefan@webrtc.org | 48ac226 | 2015-03-02 16:18:56 +0000 | [diff] [blame] | 232 | } |
| 233 | |
| 234 | private: |
| 235 | FILE* file_; |
| 236 | }; |
| 237 | |
Benjamin Wright | 90ab76d | 2018-08-23 11:33:29 -0700 | [diff] [blame] | 238 | // The RtpReplayer is responsible for parsing the configuration provided by the |
| 239 | // user, setting up the windows, recieve streams and decoders and then replaying |
| 240 | // the provided RTP dump. |
| 241 | class RtpReplayer final { |
| 242 | public: |
| 243 | // Replay a rtp dump with an optional json configuration. |
| 244 | static void Replay(const std::string& replay_config_path, |
| 245 | const std::string& rtp_dump_path) { |
| 246 | webrtc::RtcEventLogNullImpl event_log; |
| 247 | Call::Config call_config(&event_log); |
Mirko Bonadei | 05cf6be | 2019-01-31 21:38:12 +0100 | [diff] [blame] | 248 | std::unique_ptr<Call> call(Call::Create(call_config)); |
Benjamin Wright | 90ab76d | 2018-08-23 11:33:29 -0700 | [diff] [blame] | 249 | std::unique_ptr<StreamState> stream_state; |
| 250 | // Attempt to load the configuration |
| 251 | if (replay_config_path.empty()) { |
| 252 | stream_state = ConfigureFromFlags(rtp_dump_path, call.get()); |
| 253 | } else { |
| 254 | stream_state = ConfigureFromFile(replay_config_path, call.get()); |
| 255 | } |
| 256 | if (stream_state == nullptr) { |
| 257 | return; |
| 258 | } |
| 259 | // Attempt to create an RtpReader from the input file. |
| 260 | std::unique_ptr<test::RtpFileReader> rtp_reader = |
| 261 | CreateRtpReader(rtp_dump_path); |
| 262 | if (rtp_reader == nullptr) { |
| 263 | return; |
| 264 | } |
| 265 | // Start replaying the provided stream now that it has been configured. |
| 266 | for (const auto& receive_stream : stream_state->receive_streams) { |
| 267 | receive_stream->Start(); |
| 268 | } |
| 269 | ReplayPackets(call.get(), rtp_reader.get()); |
| 270 | for (const auto& receive_stream : stream_state->receive_streams) { |
| 271 | call->DestroyVideoReceiveStream(receive_stream); |
| 272 | } |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 273 | } |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 274 | |
Benjamin Wright | 90ab76d | 2018-08-23 11:33:29 -0700 | [diff] [blame] | 275 | private: |
| 276 | // Holds all the shared memory structures required for a recieve stream. This |
| 277 | // structure is used to prevent members being deallocated before the replay |
| 278 | // has been finished. |
| 279 | struct StreamState { |
| 280 | test::NullTransport transport; |
| 281 | std::vector<std::unique_ptr<rtc::VideoSinkInterface<VideoFrame>>> sinks; |
| 282 | std::vector<VideoReceiveStream*> receive_streams; |
Niels Möller | cbcbc22 | 2018-09-28 09:07:24 +0200 | [diff] [blame] | 283 | std::unique_ptr<VideoDecoderFactory> decoder_factory; |
Benjamin Wright | 90ab76d | 2018-08-23 11:33:29 -0700 | [diff] [blame] | 284 | }; |
| 285 | |
| 286 | // Loads multiple configurations from the provided configuration file. |
| 287 | static std::unique_ptr<StreamState> ConfigureFromFile( |
| 288 | const std::string& config_path, |
| 289 | Call* call) { |
| 290 | auto stream_state = absl::make_unique<StreamState>(); |
| 291 | // Parse the configuration file. |
| 292 | std::ifstream config_file(config_path); |
| 293 | std::stringstream raw_json_buffer; |
| 294 | raw_json_buffer << config_file.rdbuf(); |
| 295 | std::string raw_json = raw_json_buffer.str(); |
| 296 | Json::Reader json_reader; |
| 297 | Json::Value json_configs; |
| 298 | if (!json_reader.parse(raw_json, json_configs)) { |
| 299 | fprintf(stderr, "Error parsing JSON config\n"); |
| 300 | fprintf(stderr, "%s\n", json_reader.getFormatedErrorMessages().c_str()); |
| 301 | return nullptr; |
| 302 | } |
| 303 | |
Niels Möller | cbcbc22 | 2018-09-28 09:07:24 +0200 | [diff] [blame] | 304 | stream_state->decoder_factory = absl::make_unique<InternalDecoderFactory>(); |
Benjamin Wright | 90ab76d | 2018-08-23 11:33:29 -0700 | [diff] [blame] | 305 | size_t config_count = 0; |
| 306 | for (const auto& json : json_configs) { |
| 307 | // Create the configuration and parse the JSON into the config. |
Benjamin Wright | 8efafdf | 2019-01-11 10:48:42 -0800 | [diff] [blame] | 308 | auto receive_config = |
| 309 | ParseVideoReceiveStreamJsonConfig(&(stream_state->transport), json); |
Benjamin Wright | 90ab76d | 2018-08-23 11:33:29 -0700 | [diff] [blame] | 310 | // Instantiate the underlying decoder. |
| 311 | for (auto& decoder : receive_config.decoders) { |
Niels Möller | cbcbc22 | 2018-09-28 09:07:24 +0200 | [diff] [blame] | 312 | decoder = test::CreateMatchingDecoder(decoder.payload_type, |
| 313 | decoder.video_format.name); |
| 314 | decoder.decoder_factory = stream_state->decoder_factory.get(); |
Benjamin Wright | 90ab76d | 2018-08-23 11:33:29 -0700 | [diff] [blame] | 315 | } |
| 316 | // Create a window for this config. |
| 317 | std::stringstream window_title; |
| 318 | window_title << "Playback Video (" << config_count++ << ")"; |
| 319 | stream_state->sinks.emplace_back( |
| 320 | test::VideoRenderer::Create(window_title.str().c_str(), 640, 480)); |
| 321 | // Create a receive stream for this config. |
| 322 | receive_config.renderer = stream_state->sinks.back().get(); |
| 323 | stream_state->receive_streams.emplace_back( |
| 324 | call->CreateVideoReceiveStream(std::move(receive_config))); |
| 325 | } |
| 326 | return stream_state; |
stefan@webrtc.org | 48ac226 | 2015-03-02 16:18:56 +0000 | [diff] [blame] | 327 | } |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 328 | |
Benjamin Wright | 90ab76d | 2018-08-23 11:33:29 -0700 | [diff] [blame] | 329 | // Loads the base configuration from flags passed in on the commandline. |
| 330 | static std::unique_ptr<StreamState> ConfigureFromFlags( |
| 331 | const std::string& rtp_dump_path, |
| 332 | Call* call) { |
| 333 | auto stream_state = absl::make_unique<StreamState>(); |
| 334 | // Create the video renderers. We must add both to the stream state to keep |
| 335 | // them from deallocating. |
| 336 | std::stringstream window_title; |
| 337 | window_title << "Playback Video (" << rtp_dump_path << ")"; |
| 338 | std::unique_ptr<test::VideoRenderer> playback_video( |
| 339 | test::VideoRenderer::Create(window_title.str().c_str(), 640, 480)); |
| 340 | auto file_passthrough = absl::make_unique<FileRenderPassthrough>( |
| 341 | flags::OutBase(), playback_video.get()); |
| 342 | stream_state->sinks.push_back(std::move(playback_video)); |
| 343 | stream_state->sinks.push_back(std::move(file_passthrough)); |
| 344 | // Setup the configuration from the flags. |
| 345 | VideoReceiveStream::Config receive_config(&(stream_state->transport)); |
| 346 | receive_config.rtp.remote_ssrc = flags::Ssrc(); |
| 347 | receive_config.rtp.local_ssrc = kReceiverLocalSsrc; |
| 348 | receive_config.rtp.rtx_ssrc = flags::SsrcRtx(); |
| 349 | receive_config.rtp |
| 350 | .rtx_associated_payload_types[flags::MediaPayloadTypeRtx()] = |
| 351 | flags::MediaPayloadType(); |
| 352 | receive_config.rtp |
| 353 | .rtx_associated_payload_types[flags::RedPayloadTypeRtx()] = |
| 354 | flags::RedPayloadType(); |
| 355 | receive_config.rtp.ulpfec_payload_type = flags::UlpfecPayloadType(); |
| 356 | receive_config.rtp.red_payload_type = flags::RedPayloadType(); |
| 357 | receive_config.rtp.nack.rtp_history_ms = 1000; |
| 358 | if (flags::TransmissionOffsetId() != -1) { |
| 359 | receive_config.rtp.extensions.push_back(RtpExtension( |
| 360 | RtpExtension::kTimestampOffsetUri, flags::TransmissionOffsetId())); |
| 361 | } |
| 362 | if (flags::AbsSendTimeId() != -1) { |
| 363 | receive_config.rtp.extensions.push_back( |
| 364 | RtpExtension(RtpExtension::kAbsSendTimeUri, flags::AbsSendTimeId())); |
| 365 | } |
| 366 | receive_config.renderer = stream_state->sinks.back().get(); |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 367 | |
Benjamin Wright | 90ab76d | 2018-08-23 11:33:29 -0700 | [diff] [blame] | 368 | // Setup the receiving stream |
| 369 | VideoReceiveStream::Decoder decoder; |
| 370 | decoder = |
| 371 | test::CreateMatchingDecoder(flags::MediaPayloadType(), flags::Codec()); |
Niels Möller | cbcbc22 | 2018-09-28 09:07:24 +0200 | [diff] [blame] | 372 | if (flags::DecoderBitstreamFilename().empty()) { |
| 373 | stream_state->decoder_factory = |
| 374 | absl::make_unique<InternalDecoderFactory>(); |
| 375 | } else { |
Benjamin Wright | 90ab76d | 2018-08-23 11:33:29 -0700 | [diff] [blame] | 376 | // Replace decoder with file writer if we're writing the bitstream to a |
| 377 | // file instead. |
Niels Möller | cbcbc22 | 2018-09-28 09:07:24 +0200 | [diff] [blame] | 378 | stream_state->decoder_factory = |
| 379 | absl::make_unique<test::FunctionVideoDecoderFactory>([]() { |
| 380 | return absl::make_unique<DecoderBitstreamFileWriter>( |
| 381 | flags::DecoderBitstreamFilename().c_str()); |
| 382 | }); |
Benjamin Wright | 90ab76d | 2018-08-23 11:33:29 -0700 | [diff] [blame] | 383 | } |
Niels Möller | cbcbc22 | 2018-09-28 09:07:24 +0200 | [diff] [blame] | 384 | decoder.decoder_factory = stream_state->decoder_factory.get(); |
Benjamin Wright | 90ab76d | 2018-08-23 11:33:29 -0700 | [diff] [blame] | 385 | receive_config.decoders.push_back(decoder); |
| 386 | |
| 387 | stream_state->receive_streams.emplace_back( |
| 388 | call->CreateVideoReceiveStream(std::move(receive_config))); |
| 389 | return stream_state; |
| 390 | } |
| 391 | |
| 392 | static std::unique_ptr<test::RtpFileReader> CreateRtpReader( |
| 393 | const std::string& rtp_dump_path) { |
| 394 | std::unique_ptr<test::RtpFileReader> rtp_reader(test::RtpFileReader::Create( |
| 395 | test::RtpFileReader::kRtpDump, rtp_dump_path)); |
Peter Boström | 74f6e9e | 2016-04-04 17:56:10 +0200 | [diff] [blame] | 396 | if (!rtp_reader) { |
Benjamin Wright | 90ab76d | 2018-08-23 11:33:29 -0700 | [diff] [blame] | 397 | rtp_reader.reset(test::RtpFileReader::Create(test::RtpFileReader::kPcap, |
| 398 | rtp_dump_path)); |
Peter Boström | 74f6e9e | 2016-04-04 17:56:10 +0200 | [diff] [blame] | 399 | if (!rtp_reader) { |
Benjamin Wright | 90ab76d | 2018-08-23 11:33:29 -0700 | [diff] [blame] | 400 | fprintf( |
| 401 | stderr, |
| 402 | "Couldn't open input file as either a rtpdump or .pcap. Note " |
| 403 | "that .pcapng is not supported.\nTrying to interpret the file as " |
| 404 | "length/packet interleaved.\n"); |
| 405 | rtp_reader.reset(test::RtpFileReader::Create( |
| 406 | test::RtpFileReader::kLengthPacketInterleaved, rtp_dump_path)); |
| 407 | if (!rtp_reader) { |
| 408 | fprintf(stderr, |
| 409 | "Unable to open input file with any supported format\n"); |
| 410 | return nullptr; |
| 411 | } |
stefan@webrtc.org | 48ac226 | 2015-03-02 16:18:56 +0000 | [diff] [blame] | 412 | } |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 413 | } |
Benjamin Wright | 90ab76d | 2018-08-23 11:33:29 -0700 | [diff] [blame] | 414 | return rtp_reader; |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 415 | } |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 416 | |
Benjamin Wright | 90ab76d | 2018-08-23 11:33:29 -0700 | [diff] [blame] | 417 | static void ReplayPackets(Call* call, test::RtpFileReader* rtp_reader) { |
| 418 | int64_t replay_start_ms = -1; |
| 419 | int num_packets = 0; |
| 420 | std::map<uint32_t, int> unknown_packets; |
| 421 | while (true) { |
| 422 | int64_t now_ms = rtc::TimeMillis(); |
| 423 | if (replay_start_ms == -1) { |
| 424 | replay_start_ms = now_ms; |
| 425 | } |
philipel | 02f0396 | 2018-01-11 17:28:35 +0100 | [diff] [blame] | 426 | |
Benjamin Wright | 90ab76d | 2018-08-23 11:33:29 -0700 | [diff] [blame] | 427 | test::RtpPacket packet; |
| 428 | if (!rtp_reader->NextPacket(&packet)) { |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 429 | break; |
| 430 | } |
Benjamin Wright | 90ab76d | 2018-08-23 11:33:29 -0700 | [diff] [blame] | 431 | |
| 432 | int64_t deliver_in_ms = replay_start_ms + packet.time_ms - now_ms; |
| 433 | if (deliver_in_ms > 0) { |
| 434 | SleepMs(deliver_in_ms); |
| 435 | } |
| 436 | |
| 437 | ++num_packets; |
| 438 | switch (call->Receiver()->DeliverPacket( |
| 439 | webrtc::MediaType::VIDEO, |
| 440 | rtc::CopyOnWriteBuffer(packet.data, packet.length), |
| 441 | /* packet_time_us */ -1)) { |
| 442 | case PacketReceiver::DELIVERY_OK: |
| 443 | break; |
| 444 | case PacketReceiver::DELIVERY_UNKNOWN_SSRC: { |
| 445 | RTPHeader header; |
| 446 | std::unique_ptr<RtpHeaderParser> parser(RtpHeaderParser::Create()); |
| 447 | parser->Parse(packet.data, packet.length, &header); |
| 448 | if (unknown_packets[header.ssrc] == 0) |
| 449 | fprintf(stderr, "Unknown SSRC: %u!\n", header.ssrc); |
| 450 | ++unknown_packets[header.ssrc]; |
| 451 | break; |
| 452 | } |
| 453 | case PacketReceiver::DELIVERY_PACKET_ERROR: { |
| 454 | fprintf(stderr, |
| 455 | "Packet error, corrupt packets or incorrect setup?\n"); |
| 456 | RTPHeader header; |
| 457 | std::unique_ptr<RtpHeaderParser> parser(RtpHeaderParser::Create()); |
| 458 | parser->Parse(packet.data, packet.length, &header); |
| 459 | fprintf(stderr, "Packet len=%zu pt=%u seq=%u ts=%u ssrc=0x%8x\n", |
| 460 | packet.length, header.payloadType, header.sequenceNumber, |
| 461 | header.timestamp, header.ssrc); |
| 462 | break; |
| 463 | } |
philipp.hancke | 7b58960 | 2017-01-26 04:54:04 -0800 | [diff] [blame] | 464 | } |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 465 | } |
Benjamin Wright | 90ab76d | 2018-08-23 11:33:29 -0700 | [diff] [blame] | 466 | fprintf(stderr, "num_packets: %d\n", num_packets); |
| 467 | |
| 468 | for (std::map<uint32_t, int>::const_iterator it = unknown_packets.begin(); |
| 469 | it != unknown_packets.end(); ++it) { |
| 470 | fprintf(stderr, "Packets for unknown ssrc '%u': %d\n", it->first, |
| 471 | it->second); |
| 472 | } |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 473 | } |
Benjamin Wright | 90ab76d | 2018-08-23 11:33:29 -0700 | [diff] [blame] | 474 | }; // class RtpReplayer |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 475 | |
Benjamin Wright | 90ab76d | 2018-08-23 11:33:29 -0700 | [diff] [blame] | 476 | void RtpReplay() { |
| 477 | RtpReplayer::Replay(flags::ConfigFile(), flags::InputFile()); |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 478 | } |
Benjamin Wright | 90ab76d | 2018-08-23 11:33:29 -0700 | [diff] [blame] | 479 | |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 480 | } // namespace webrtc |
| 481 | |
| 482 | int main(int argc, char* argv[]) { |
| 483 | ::testing::InitGoogleTest(&argc, argv); |
oprypin | 6e09d87 | 2017-08-31 03:21:39 -0700 | [diff] [blame] | 484 | if (rtc::FlagList::SetFlagsFromCommandLine(&argc, argv, true)) { |
| 485 | return 1; |
| 486 | } |
| 487 | if (webrtc::flags::FLAG_help) { |
| 488 | rtc::FlagList::Print(nullptr, false); |
| 489 | return 0; |
| 490 | } |
| 491 | |
philipel | 752968e | 2017-12-05 12:40:28 +0100 | [diff] [blame] | 492 | RTC_CHECK(ValidatePayloadType(webrtc::flags::FLAG_media_payload_type)); |
| 493 | RTC_CHECK(ValidatePayloadType(webrtc::flags::FLAG_media_payload_type_rtx)); |
| 494 | RTC_CHECK(ValidateOptionalPayloadType(webrtc::flags::FLAG_red_payload_type)); |
| 495 | RTC_CHECK( |
| 496 | ValidateOptionalPayloadType(webrtc::flags::FLAG_red_payload_type_rtx)); |
| 497 | RTC_CHECK( |
| 498 | ValidateOptionalPayloadType(webrtc::flags::FLAG_ulpfec_payload_type)); |
oprypin | 6e09d87 | 2017-08-31 03:21:39 -0700 | [diff] [blame] | 499 | RTC_CHECK(ValidateSsrc(webrtc::flags::FLAG_ssrc)); |
| 500 | RTC_CHECK(ValidateSsrc(webrtc::flags::FLAG_ssrc_rtx)); |
oprypin | 6e09d87 | 2017-08-31 03:21:39 -0700 | [diff] [blame] | 501 | RTC_CHECK(ValidateRtpHeaderExtensionId(webrtc::flags::FLAG_abs_send_time_id)); |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 502 | RTC_CHECK( |
| 503 | ValidateRtpHeaderExtensionId(webrtc::flags::FLAG_transmission_offset_id)); |
oprypin | 6e09d87 | 2017-08-31 03:21:39 -0700 | [diff] [blame] | 504 | RTC_CHECK(ValidateInputFilenameNotEmpty(webrtc::flags::FLAG_input_file)); |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 505 | |
| 506 | webrtc::test::RunTest(webrtc::RtpReplay); |
| 507 | return 0; |
| 508 | } |