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 | |
| 13 | #include <map> |
kwiberg | 27f982b | 2016-03-01 11:52:33 -0800 | [diff] [blame] | 14 | #include <memory> |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 15 | #include <sstream> |
| 16 | |
| 17 | #include "gflags/gflags.h" |
ilnik | d60d06a | 2017-04-05 03:02:20 -0700 | [diff] [blame] | 18 | #include "webrtc/api/video_codecs/video_decoder.h" |
ossu | f515ab8 | 2016-12-07 04:52:58 -0800 | [diff] [blame] | 19 | #include "webrtc/call/call.h" |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 20 | #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h" |
stefan | 64427e5 | 2016-12-20 07:26:58 -0800 | [diff] [blame] | 21 | #include "webrtc/logging/rtc_event_log/rtc_event_log.h" |
Henrik Kjellander | ff761fb | 2015-11-04 08:31:52 +0100 | [diff] [blame] | 22 | #include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h" |
Edward Lemur | c20978e | 2017-07-06 19:44:34 +0200 | [diff] [blame] | 23 | #include "webrtc/rtc_base/checks.h" |
Henrik Kjellander | 98f5351 | 2015-10-28 18:17:40 +0100 | [diff] [blame] | 24 | #include "webrtc/system_wrappers/include/clock.h" |
| 25 | #include "webrtc/system_wrappers/include/sleep.h" |
ilnik | 863f03b | 2017-07-11 02:38:36 -0700 | [diff] [blame^] | 26 | #include "webrtc/test/call_test.h" |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 27 | #include "webrtc/test/encoder_settings.h" |
stefan@webrtc.org | 48ac226 | 2015-03-02 16:18:56 +0000 | [diff] [blame] | 28 | #include "webrtc/test/fake_decoder.h" |
kwiberg | ac9f876 | 2016-09-30 22:29:43 -0700 | [diff] [blame] | 29 | #include "webrtc/test/gtest.h" |
| 30 | #include "webrtc/test/null_transport.h" |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 31 | #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 | |
| 38 | namespace webrtc { |
| 39 | namespace flags { |
| 40 | |
| 41 | // TODO(pbos): Multiple receivers. |
| 42 | |
| 43 | // Flag for payload type. |
| 44 | static bool ValidatePayloadType(const char* flagname, int32_t payload_type) { |
| 45 | return payload_type > 0 && payload_type <= 127; |
| 46 | } |
ilnik | 863f03b | 2017-07-11 02:38:36 -0700 | [diff] [blame^] | 47 | DEFINE_int32(payload_type, test::CallTest::kPayloadTypeVP8, "Payload type"); |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 48 | static int PayloadType() { return static_cast<int>(FLAGS_payload_type); } |
| 49 | static const bool payload_dummy = |
| 50 | google::RegisterFlagValidator(&FLAGS_payload_type, &ValidatePayloadType); |
| 51 | |
ilnik | 863f03b | 2017-07-11 02:38:36 -0700 | [diff] [blame^] | 52 | DEFINE_int32(payload_type_rtx, |
| 53 | test::CallTest::kSendRtxPayloadType, |
| 54 | "RTX payload type"); |
| 55 | static int PayloadTypeRtx() { |
| 56 | return static_cast<int>(FLAGS_payload_type_rtx); |
| 57 | } |
| 58 | static const bool payload_rtx_dummy = |
| 59 | google::RegisterFlagValidator(&FLAGS_payload_type_rtx, |
| 60 | &ValidatePayloadType); |
| 61 | |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 62 | // Flag for SSRC. |
| 63 | static bool ValidateSsrc(const char* flagname, uint64_t ssrc) { |
| 64 | return ssrc > 0 && ssrc <= 0xFFFFFFFFu; |
| 65 | } |
| 66 | |
ilnik | 863f03b | 2017-07-11 02:38:36 -0700 | [diff] [blame^] | 67 | DEFINE_uint64(ssrc, test::CallTest::kVideoSendSsrcs[0], "Incoming SSRC"); |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 68 | static uint32_t Ssrc() { return static_cast<uint32_t>(FLAGS_ssrc); } |
| 69 | static const bool ssrc_dummy = |
| 70 | google::RegisterFlagValidator(&FLAGS_ssrc, &ValidateSsrc); |
| 71 | |
ilnik | 863f03b | 2017-07-11 02:38:36 -0700 | [diff] [blame^] | 72 | DEFINE_uint64(ssrc_rtx, test::CallTest::kSendRtxSsrcs[0], "Incoming RTX SSRC"); |
| 73 | static uint32_t SsrcRtx() { |
| 74 | return static_cast<uint32_t>(FLAGS_ssrc_rtx); |
| 75 | } |
| 76 | static const bool ssrc_rtx_dummy = |
| 77 | google::RegisterFlagValidator(&FLAGS_ssrc_rtx, &ValidateSsrc); |
| 78 | |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 79 | static 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.org | e8c84bf | 2014-08-07 14:42:45 +0000 | [diff] [blame] | 85 | DEFINE_int32(red_payload_type, -1, "RED payload type"); |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 86 | static int RedPayloadType() { |
| 87 | return static_cast<int>(FLAGS_red_payload_type); |
| 88 | } |
| 89 | static const bool red_dummy = |
| 90 | google::RegisterFlagValidator(&FLAGS_red_payload_type, |
| 91 | &ValidateOptionalPayloadType); |
| 92 | |
| 93 | // Flag for ULPFEC payload type. |
pbos@webrtc.org | e8c84bf | 2014-08-07 14:42:45 +0000 | [diff] [blame] | 94 | DEFINE_int32(fec_payload_type, -1, "ULPFEC payload type"); |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 95 | static int FecPayloadType() { |
| 96 | return static_cast<int>(FLAGS_fec_payload_type); |
| 97 | } |
| 98 | static const bool fec_dummy = |
| 99 | google::RegisterFlagValidator(&FLAGS_fec_payload_type, |
| 100 | &ValidateOptionalPayloadType); |
| 101 | |
| 102 | // Flag for abs-send-time id. |
| 103 | static bool ValidateRtpHeaderExtensionId(const char* flagname, |
| 104 | int32_t extension_id) { |
| 105 | return extension_id >= -1 || extension_id < 15; |
| 106 | } |
pbos@webrtc.org | e8c84bf | 2014-08-07 14:42:45 +0000 | [diff] [blame] | 107 | DEFINE_int32(abs_send_time_id, -1, "RTP extension ID for abs-send-time"); |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 108 | static int AbsSendTimeId() { return static_cast<int>(FLAGS_abs_send_time_id); } |
| 109 | static const bool abs_send_time_dummy = |
| 110 | google::RegisterFlagValidator(&FLAGS_abs_send_time_id, |
| 111 | &ValidateRtpHeaderExtensionId); |
| 112 | |
| 113 | // Flag for transmission-offset id. |
| 114 | DEFINE_int32(transmission_offset_id, |
| 115 | -1, |
pbos@webrtc.org | e8c84bf | 2014-08-07 14:42:45 +0000 | [diff] [blame] | 116 | "RTP extension ID for transmission-offset"); |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 117 | static int TransmissionOffsetId() { |
| 118 | return static_cast<int>(FLAGS_transmission_offset_id); |
| 119 | } |
| 120 | static const bool timestamp_offset_dummy = |
| 121 | google::RegisterFlagValidator(&FLAGS_transmission_offset_id, |
| 122 | &ValidateRtpHeaderExtensionId); |
| 123 | |
| 124 | // Flag for rtpdump input file. |
pbos@webrtc.org | e8c84bf | 2014-08-07 14:42:45 +0000 | [diff] [blame] | 125 | bool ValidateInputFilenameNotEmpty(const char* flagname, |
| 126 | const std::string& string) { |
pbos | bb36fdf | 2015-07-09 07:48:14 -0700 | [diff] [blame] | 127 | return !string.empty(); |
pbos@webrtc.org | e8c84bf | 2014-08-07 14:42:45 +0000 | [diff] [blame] | 128 | } |
stefan@webrtc.org | 48ac226 | 2015-03-02 16:18:56 +0000 | [diff] [blame] | 129 | |
pbos@webrtc.org | e8c84bf | 2014-08-07 14:42:45 +0000 | [diff] [blame] | 130 | DEFINE_string(input_file, "", "input file"); |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 131 | static std::string InputFile() { |
| 132 | return static_cast<std::string>(FLAGS_input_file); |
| 133 | } |
pbos@webrtc.org | e8c84bf | 2014-08-07 14:42:45 +0000 | [diff] [blame] | 134 | static const bool input_file_dummy = |
| 135 | google::RegisterFlagValidator(&FLAGS_input_file, |
| 136 | &ValidateInputFilenameNotEmpty); |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 137 | |
| 138 | // Flag for raw output files. |
pbos@webrtc.org | e8c84bf | 2014-08-07 14:42:45 +0000 | [diff] [blame] | 139 | DEFINE_string(out_base, "", "Basename (excluding .yuv) for raw output"); |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 140 | static std::string OutBase() { |
| 141 | return static_cast<std::string>(FLAGS_out_base); |
| 142 | } |
| 143 | |
stefan@webrtc.org | 48ac226 | 2015-03-02 16:18:56 +0000 | [diff] [blame] | 144 | DEFINE_string(decoder_bitstream_filename, "", "Decoder bitstream output file"); |
| 145 | static std::string DecoderBitstreamFilename() { |
| 146 | return static_cast<std::string>(FLAGS_decoder_bitstream_filename); |
| 147 | } |
| 148 | |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 149 | // Flag for video codec. |
pbos@webrtc.org | e8c84bf | 2014-08-07 14:42:45 +0000 | [diff] [blame] | 150 | DEFINE_string(codec, "VP8", "Video codec"); |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 151 | static std::string Codec() { return static_cast<std::string>(FLAGS_codec); } |
| 152 | |
| 153 | } // namespace flags |
| 154 | |
| 155 | static const uint32_t kReceiverLocalSsrc = 0x123456; |
| 156 | |
nisse | 7ade7b3 | 2016-03-23 04:48:10 -0700 | [diff] [blame] | 157 | class FileRenderPassthrough : public rtc::VideoSinkInterface<VideoFrame> { |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 158 | public: |
nisse | 7ade7b3 | 2016-03-23 04:48:10 -0700 | [diff] [blame] | 159 | FileRenderPassthrough(const std::string& basename, |
| 160 | rtc::VideoSinkInterface<VideoFrame>* renderer) |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 161 | : basename_(basename), |
| 162 | renderer_(renderer), |
pbos@webrtc.org | 2b4ce3a | 2015-03-23 13:12:24 +0000 | [diff] [blame] | 163 | file_(nullptr), |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 164 | count_(0), |
| 165 | last_width_(0), |
| 166 | last_height_(0) {} |
| 167 | |
| 168 | ~FileRenderPassthrough() { |
Peter Boström | 74f6e9e | 2016-04-04 17:56:10 +0200 | [diff] [blame] | 169 | if (file_) |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 170 | fclose(file_); |
| 171 | } |
| 172 | |
| 173 | private: |
nisse | eb83a1a | 2016-03-21 01:27:56 -0700 | [diff] [blame] | 174 | void OnFrame(const VideoFrame& video_frame) override { |
Peter Boström | 74f6e9e | 2016-04-04 17:56:10 +0200 | [diff] [blame] | 175 | if (renderer_) |
nisse | eb83a1a | 2016-03-21 01:27:56 -0700 | [diff] [blame] | 176 | renderer_->OnFrame(video_frame); |
pbos | bb36fdf | 2015-07-09 07:48:14 -0700 | [diff] [blame] | 177 | if (basename_.empty()) |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 178 | return; |
| 179 | if (last_width_ != video_frame.width() || |
| 180 | last_height_ != video_frame.height()) { |
Peter Boström | 74f6e9e | 2016-04-04 17:56:10 +0200 | [diff] [blame] | 181 | if (file_) |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 182 | 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öm | 74f6e9e | 2016-04-04 17:56:10 +0200 | [diff] [blame] | 190 | if (!file_) { |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 191 | 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öm | 74f6e9e | 2016-04-04 17:56:10 +0200 | [diff] [blame] | 198 | if (!file_) |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 199 | return; |
Miguel Casas-Sanchez | 4765070 | 2015-05-29 17:21:40 -0700 | [diff] [blame] | 200 | PrintVideoFrame(video_frame, file_); |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 201 | } |
| 202 | |
| 203 | const std::string basename_; |
nisse | 7ade7b3 | 2016-03-23 04:48:10 -0700 | [diff] [blame] | 204 | rtc::VideoSinkInterface<VideoFrame>* const renderer_; |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 205 | FILE* file_; |
| 206 | size_t count_; |
| 207 | int last_width_; |
| 208 | int last_height_; |
| 209 | }; |
| 210 | |
stefan@webrtc.org | 48ac226 | 2015-03-02 16:18:56 +0000 | [diff] [blame] | 211 | class DecoderBitstreamFileWriter : public EncodedFrameObserver { |
| 212 | public: |
| 213 | explicit DecoderBitstreamFileWriter(const char* filename) |
| 214 | : file_(fopen(filename, "wb")) { |
Peter Boström | 74f6e9e | 2016-04-04 17:56:10 +0200 | [diff] [blame] | 215 | RTC_DCHECK(file_); |
stefan@webrtc.org | 48ac226 | 2015-03-02 16:18:56 +0000 | [diff] [blame] | 216 | } |
| 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.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 227 | void RtpReplay() { |
kwiberg | 27f982b | 2016-03-01 11:52:33 -0800 | [diff] [blame] | 228 | std::unique_ptr<test::VideoRenderer> playback_video( |
kwiberg@webrtc.org | 00b8f6b | 2015-02-26 14:34:55 +0000 | [diff] [blame] | 229 | test::VideoRenderer::Create("Playback Video", 640, 480)); |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 230 | FileRenderPassthrough file_passthrough(flags::OutBase(), |
| 231 | playback_video.get()); |
| 232 | |
stefan | 64427e5 | 2016-12-20 07:26:58 -0800 | [diff] [blame] | 233 | webrtc::RtcEventLogNullImpl event_log; |
| 234 | std::unique_ptr<Call> call(Call::Create(Call::Config(&event_log))); |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 235 | |
solenberg | 4fbae2b | 2015-08-28 04:07:10 -0700 | [diff] [blame] | 236 | test::NullTransport transport; |
| 237 | VideoReceiveStream::Config receive_config(&transport); |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 238 | receive_config.rtp.remote_ssrc = flags::Ssrc(); |
| 239 | receive_config.rtp.local_ssrc = kReceiverLocalSsrc; |
ilnik | 863f03b | 2017-07-11 02:38:36 -0700 | [diff] [blame^] | 240 | receive_config.rtp.rtx_ssrc = flags::SsrcRtx(); |
| 241 | receive_config.rtp.rtx_payload_types[flags::PayloadType()] = |
| 242 | flags::PayloadTypeRtx(); |
brandtr | b5f2c3f | 2016-10-04 23:28:39 -0700 | [diff] [blame] | 243 | receive_config.rtp.ulpfec.ulpfec_payload_type = flags::FecPayloadType(); |
| 244 | receive_config.rtp.ulpfec.red_payload_type = flags::RedPayloadType(); |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 245 | receive_config.rtp.nack.rtp_history_ms = 1000; |
| 246 | if (flags::TransmissionOffsetId() != -1) { |
isheriff | 6f8d686 | 2016-05-26 11:24:55 -0700 | [diff] [blame] | 247 | receive_config.rtp.extensions.push_back(RtpExtension( |
| 248 | RtpExtension::kTimestampOffsetUri, flags::TransmissionOffsetId())); |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 249 | } |
| 250 | if (flags::AbsSendTimeId() != -1) { |
| 251 | receive_config.rtp.extensions.push_back( |
isheriff | 6f8d686 | 2016-05-26 11:24:55 -0700 | [diff] [blame] | 252 | RtpExtension(RtpExtension::kAbsSendTimeUri, flags::AbsSendTimeId())); |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 253 | } |
| 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.org | 48ac226 | 2015-03-02 16:18:56 +0000 | [diff] [blame] | 259 | VideoReceiveStream::Decoder decoder; |
kwiberg | 27f982b | 2016-03-01 11:52:33 -0800 | [diff] [blame] | 260 | std::unique_ptr<DecoderBitstreamFileWriter> bitstream_writer; |
pbos | bb36fdf | 2015-07-09 07:48:14 -0700 | [diff] [blame] | 261 | if (!flags::DecoderBitstreamFilename().empty()) { |
stefan@webrtc.org | 48ac226 | 2015-03-02 16:18:56 +0000 | [diff] [blame] | 262 | 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); |
pbos | bb36fdf | 2015-07-09 07:48:14 -0700 | [diff] [blame] | 267 | if (!flags::DecoderBitstreamFilename().empty()) { |
stefan@webrtc.org | 48ac226 | 2015-03-02 16:18:56 +0000 | [diff] [blame] | 268 | // 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.org | 776e6f2 | 2014-10-29 15:28:39 +0000 | [diff] [blame] | 273 | receive_config.decoders.push_back(decoder); |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 274 | |
| 275 | VideoReceiveStream* receive_stream = |
Tommi | 733b547 | 2016-06-10 17:58:01 +0200 | [diff] [blame] | 276 | call->CreateVideoReceiveStream(std::move(receive_config)); |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 277 | |
kwiberg | 27f982b | 2016-03-01 11:52:33 -0800 | [diff] [blame] | 278 | std::unique_ptr<test::RtpFileReader> rtp_reader(test::RtpFileReader::Create( |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 279 | test::RtpFileReader::kRtpDump, flags::InputFile())); |
Peter Boström | 74f6e9e | 2016-04-04 17:56:10 +0200 | [diff] [blame] | 280 | if (!rtp_reader) { |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 281 | rtp_reader.reset(test::RtpFileReader::Create(test::RtpFileReader::kPcap, |
| 282 | flags::InputFile())); |
Peter Boström | 74f6e9e | 2016-04-04 17:56:10 +0200 | [diff] [blame] | 283 | if (!rtp_reader) { |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 284 | fprintf(stderr, |
| 285 | "Couldn't open input file as either a rtpdump or .pcap. Note " |
stefan@webrtc.org | 48ac226 | 2015-03-02 16:18:56 +0000 | [diff] [blame] | 286 | "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öm | 74f6e9e | 2016-04-04 17:56:10 +0200 | [diff] [blame] | 290 | if (!rtp_reader) { |
stefan@webrtc.org | 48ac226 | 2015-03-02 16:18:56 +0000 | [diff] [blame] | 291 | fprintf(stderr, |
| 292 | "Unable to open input file with any supported format\n"); |
| 293 | return; |
| 294 | } |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 295 | } |
| 296 | } |
| 297 | receive_stream->Start(); |
| 298 | |
| 299 | uint32_t last_time_ms = 0; |
| 300 | int num_packets = 0; |
pbos@webrtc.org | e8c84bf | 2014-08-07 14:42:45 +0000 | [diff] [blame] | 301 | std::map<uint32_t, int> unknown_packets; |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 302 | while (true) { |
henrik.lundin@webrtc.org | 91d928e | 2014-11-26 15:50:30 +0000 | [diff] [blame] | 303 | test::RtpPacket packet; |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 304 | if (!rtp_reader->NextPacket(&packet)) |
| 305 | break; |
| 306 | ++num_packets; |
nisse | e5ad5ca | 2017-03-29 23:57:43 -0700 | [diff] [blame] | 307 | switch (call->Receiver()->DeliverPacket( |
| 308 | webrtc::MediaType::VIDEO, packet.data, packet.length, PacketTime())) { |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 309 | case PacketReceiver::DELIVERY_OK: |
| 310 | break; |
| 311 | case PacketReceiver::DELIVERY_UNKNOWN_SSRC: { |
| 312 | RTPHeader header; |
kwiberg | 27f982b | 2016-03-01 11:52:33 -0800 | [diff] [blame] | 313 | std::unique_ptr<RtpHeaderParser> parser(RtpHeaderParser::Create()); |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 314 | parser->Parse(packet.data, packet.length, &header); |
pbos@webrtc.org | e8c84bf | 2014-08-07 14:42:45 +0000 | [diff] [blame] | 315 | if (unknown_packets[header.ssrc] == 0) |
| 316 | fprintf(stderr, "Unknown SSRC: %u!\n", header.ssrc); |
| 317 | ++unknown_packets[header.ssrc]; |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 318 | break; |
| 319 | } |
philipp.hancke | 7b58960 | 2017-01-26 04:54:04 -0800 | [diff] [blame] | 320 | case PacketReceiver::DELIVERY_PACKET_ERROR: { |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 321 | fprintf(stderr, "Packet error, corrupt packets or incorrect setup?\n"); |
philipp.hancke | 7b58960 | 2017-01-26 04:54:04 -0800 | [diff] [blame] | 322 | RTPHeader header; |
| 323 | std::unique_ptr<RtpHeaderParser> parser(RtpHeaderParser::Create()); |
| 324 | parser->Parse(packet.data, packet.length, &header); |
sprang | 3dbfac3 | 2017-06-29 07:42:18 -0700 | [diff] [blame] | 325 | fprintf(stderr, "Packet len=%zu pt=%u seq=%u ts=%u ssrc=0x%8x\n", |
sprang | 168794c | 2017-07-06 04:38:06 -0700 | [diff] [blame] | 326 | packet.length, header.payloadType, header.sequenceNumber, |
| 327 | header.timestamp, header.ssrc); |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 328 | break; |
philipp.hancke | 7b58960 | 2017-01-26 04:54:04 -0800 | [diff] [blame] | 329 | } |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 330 | } |
| 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.org | e8c84bf | 2014-08-07 14:42:45 +0000 | [diff] [blame] | 338 | 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.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 345 | call->DestroyVideoReceiveStream(receive_stream); |
pbos@webrtc.org | 776e6f2 | 2014-10-29 15:28:39 +0000 | [diff] [blame] | 346 | |
| 347 | delete decoder.decoder; |
pbos@webrtc.org | 4b5625e | 2014-08-06 16:26:56 +0000 | [diff] [blame] | 348 | } |
| 349 | } // namespace webrtc |
| 350 | |
| 351 | int 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 | } |