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>
14#include <sstream>
15
16#include "gflags/gflags.h"
17#include "testing/gtest/include/gtest/gtest.h"
18
19#include "webrtc/call.h"
20#include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
21#include "webrtc/modules/rtp_rtcp/interface/rtp_header_parser.h"
22#include "webrtc/system_wrappers/interface/clock.h"
23#include "webrtc/system_wrappers/interface/scoped_ptr.h"
24#include "webrtc/system_wrappers/interface/sleep.h"
25#include "webrtc/test/encoder_settings.h"
26#include "webrtc/test/null_transport.h"
27#include "webrtc/test/rtp_file_reader.h"
28#include "webrtc/test/run_loop.h"
29#include "webrtc/test/run_test.h"
30#include "webrtc/test/video_capturer.h"
31#include "webrtc/test/video_renderer.h"
32#include "webrtc/typedefs.h"
33
34namespace webrtc {
35namespace flags {
36
37// TODO(pbos): Multiple receivers.
38
39// Flag for payload type.
40static bool ValidatePayloadType(const char* flagname, int32_t payload_type) {
41  return payload_type > 0 && payload_type <= 127;
42}
43DEFINE_int32(payload_type, 0, "Payload type");
44static int PayloadType() { return static_cast<int>(FLAGS_payload_type); }
45static const bool payload_dummy =
46    google::RegisterFlagValidator(&FLAGS_payload_type, &ValidatePayloadType);
47
48// Flag for SSRC.
49static bool ValidateSsrc(const char* flagname, uint64_t ssrc) {
50  return ssrc > 0 && ssrc <= 0xFFFFFFFFu;
51}
52
53DEFINE_uint64(ssrc, 0, "Incoming SSRC");
54static uint32_t Ssrc() { return static_cast<uint32_t>(FLAGS_ssrc); }
55static const bool ssrc_dummy =
56    google::RegisterFlagValidator(&FLAGS_ssrc, &ValidateSsrc);
57
58static bool ValidateOptionalPayloadType(const char* flagname,
59                                        int32_t payload_type) {
60  return payload_type == -1 || ValidatePayloadType(flagname, payload_type);
61}
62
63// Flag for RED payload type.
64DEFINE_int32(red_payload_type, -1, "RED payload type");
65static int RedPayloadType() {
66  return static_cast<int>(FLAGS_red_payload_type);
67}
68static const bool red_dummy =
69    google::RegisterFlagValidator(&FLAGS_red_payload_type,
70                                  &ValidateOptionalPayloadType);
71
72// Flag for ULPFEC payload type.
73DEFINE_int32(fec_payload_type, -1, "ULPFEC payload type");
74static int FecPayloadType() {
75  return static_cast<int>(FLAGS_fec_payload_type);
76}
77static const bool fec_dummy =
78    google::RegisterFlagValidator(&FLAGS_fec_payload_type,
79                                  &ValidateOptionalPayloadType);
80
81// Flag for abs-send-time id.
82static bool ValidateRtpHeaderExtensionId(const char* flagname,
83                                         int32_t extension_id) {
84  return extension_id >= -1 || extension_id < 15;
85}
86DEFINE_int32(abs_send_time_id, -1, "RTP extension ID for abs-send-time");
87static int AbsSendTimeId() { return static_cast<int>(FLAGS_abs_send_time_id); }
88static const bool abs_send_time_dummy =
89    google::RegisterFlagValidator(&FLAGS_abs_send_time_id,
90                                  &ValidateRtpHeaderExtensionId);
91
92// Flag for transmission-offset id.
93DEFINE_int32(transmission_offset_id,
94             -1,
95             "RTP extension ID for transmission-offset");
96static int TransmissionOffsetId() {
97  return static_cast<int>(FLAGS_transmission_offset_id);
98}
99static const bool timestamp_offset_dummy =
100    google::RegisterFlagValidator(&FLAGS_transmission_offset_id,
101                                  &ValidateRtpHeaderExtensionId);
102
103// Flag for rtpdump input file.
104bool ValidateInputFilenameNotEmpty(const char* flagname,
105                                   const std::string& string) {
106  return string != "";
107}
108DEFINE_string(input_file, "", "input file");
109static std::string InputFile() {
110  return static_cast<std::string>(FLAGS_input_file);
111}
112static const bool input_file_dummy =
113    google::RegisterFlagValidator(&FLAGS_input_file,
114                                  &ValidateInputFilenameNotEmpty);
115
116// Flag for raw output files.
117DEFINE_string(out_base, "", "Basename (excluding .yuv) for raw output");
118static std::string OutBase() {
119  return static_cast<std::string>(FLAGS_out_base);
120}
121
122// Flag for video codec.
123DEFINE_string(codec, "VP8", "Video codec");
124static std::string Codec() { return static_cast<std::string>(FLAGS_codec); }
125
126}  // namespace flags
127
128static const uint32_t kReceiverLocalSsrc = 0x123456;
129
130class FileRenderPassthrough : public VideoRenderer {
131 public:
132  FileRenderPassthrough(const std::string& basename, VideoRenderer* renderer)
133      : basename_(basename),
134        renderer_(renderer),
135        file_(NULL),
136        count_(0),
137        last_width_(0),
138        last_height_(0) {}
139
140  ~FileRenderPassthrough() {
141    if (file_ != NULL)
142      fclose(file_);
143  }
144
145 private:
146  virtual void RenderFrame(const I420VideoFrame& video_frame,
147                           int time_to_render_ms) OVERRIDE {
148    if (renderer_ != NULL)
149      renderer_->RenderFrame(video_frame, time_to_render_ms);
150    if (basename_ == "")
151      return;
152    if (last_width_ != video_frame.width() ||
153        last_height_ != video_frame.height()) {
154      if (file_ != NULL)
155        fclose(file_);
156      std::stringstream filename;
157      filename << basename_;
158      if (++count_ > 1)
159        filename << '-' << count_;
160      filename << '_' << video_frame.width() << 'x' << video_frame.height()
161               << ".yuv";
162      file_ = fopen(filename.str().c_str(), "wb");
163      if (file_ == NULL) {
164        fprintf(stderr,
165                "Couldn't open file for writing: %s\n",
166                filename.str().c_str());
167      }
168    }
169    last_width_ = video_frame.width();
170    last_height_ = video_frame.height();
171    if (file_ == NULL)
172      return;
173    PrintI420VideoFrame(video_frame, file_);
174  }
175
176  const std::string basename_;
177  VideoRenderer* const renderer_;
178  FILE* file_;
179  size_t count_;
180  int last_width_;
181  int last_height_;
182};
183
184void RtpReplay() {
185  scoped_ptr<test::VideoRenderer> playback_video(test::VideoRenderer::Create(
186      "Playback Video", 640, 480));
187  FileRenderPassthrough file_passthrough(flags::OutBase(),
188                                         playback_video.get());
189
190  // TODO(pbos): Might be good to have a transport that prints keyframe requests
191  //             etc.
192  test::NullTransport transport;
193  Call::Config call_config(&transport);
194  scoped_ptr<Call> call(Call::Create(call_config));
195
196  VideoReceiveStream::Config receive_config;
197  receive_config.rtp.remote_ssrc = flags::Ssrc();
198  receive_config.rtp.local_ssrc = kReceiverLocalSsrc;
199  receive_config.rtp.fec.ulpfec_payload_type = flags::FecPayloadType();
200  receive_config.rtp.fec.red_payload_type = flags::RedPayloadType();
201  receive_config.rtp.nack.rtp_history_ms = 1000;
202  if (flags::TransmissionOffsetId() != -1) {
203    receive_config.rtp.extensions.push_back(
204        RtpExtension(RtpExtension::kTOffset, flags::TransmissionOffsetId()));
205  }
206  if (flags::AbsSendTimeId() != -1) {
207    receive_config.rtp.extensions.push_back(
208        RtpExtension(RtpExtension::kAbsSendTime, flags::AbsSendTimeId()));
209  }
210  receive_config.renderer = &file_passthrough;
211
212  VideoSendStream::Config::EncoderSettings encoder_settings;
213  encoder_settings.payload_name = flags::Codec();
214  encoder_settings.payload_type = flags::PayloadType();
215  VideoCodec codec = test::CreateDecoderVideoCodec(encoder_settings);
216  receive_config.codecs.push_back(codec);
217
218  VideoReceiveStream* receive_stream =
219      call->CreateVideoReceiveStream(receive_config);
220
221  scoped_ptr<test::RtpFileReader> rtp_reader(test::RtpFileReader::Create(
222      test::RtpFileReader::kRtpDump, flags::InputFile()));
223  if (rtp_reader.get() == NULL) {
224    rtp_reader.reset(test::RtpFileReader::Create(test::RtpFileReader::kPcap,
225                                                 flags::InputFile()));
226    if (rtp_reader.get() == NULL) {
227      fprintf(stderr,
228              "Couldn't open input file as either a rtpdump or .pcap. Note "
229              "that .pcapng is not supported.\n");
230      return;
231    }
232  }
233  receive_stream->Start();
234
235  uint32_t last_time_ms = 0;
236  int num_packets = 0;
237  std::map<uint32_t, int> unknown_packets;
238  while (true) {
239    test::RtpFileReader::Packet packet;
240    if (!rtp_reader->NextPacket(&packet))
241      break;
242    ++num_packets;
243    switch (call->Receiver()->DeliverPacket(packet.data, packet.length)) {
244      case PacketReceiver::DELIVERY_OK:
245        break;
246      case PacketReceiver::DELIVERY_UNKNOWN_SSRC: {
247        RTPHeader header;
248        scoped_ptr<RtpHeaderParser> parser(RtpHeaderParser::Create());
249        parser->Parse(packet.data, packet.length, &header);
250        if (unknown_packets[header.ssrc] == 0)
251          fprintf(stderr, "Unknown SSRC: %u!\n", header.ssrc);
252        ++unknown_packets[header.ssrc];
253        break;
254      }
255      case PacketReceiver::DELIVERY_PACKET_ERROR:
256        fprintf(stderr, "Packet error, corrupt packets or incorrect setup?\n");
257        break;
258    }
259    if (last_time_ms != 0 && last_time_ms != packet.time_ms) {
260      SleepMs(packet.time_ms - last_time_ms);
261    }
262    last_time_ms = packet.time_ms;
263  }
264  fprintf(stderr, "num_packets: %d\n", num_packets);
265
266  for (std::map<uint32_t, int>::const_iterator it = unknown_packets.begin();
267       it != unknown_packets.end();
268       ++it) {
269    fprintf(
270        stderr, "Packets for unknown ssrc '%u': %d\n", it->first, it->second);
271  }
272
273  call->DestroyVideoReceiveStream(receive_stream);
274}
275}  // namespace webrtc
276
277int main(int argc, char* argv[]) {
278  ::testing::InitGoogleTest(&argc, argv);
279  google::ParseCommandLineFlags(&argc, &argv, true);
280
281  webrtc::test::RunTest(webrtc::RtpReplay);
282  return 0;
283}
284