blob: a5eafae4e7dafdccb4a794f38a8869b47cfade34 [file] [log] [blame]
/*
* Copyright (c) 2014 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include <stdio.h>
#include <fstream>
#include <map>
#include <memory>
#include <sstream>
#include "api/video_codecs/video_decoder.h"
#include "call/call.h"
#include "common_video/libyuv/include/webrtc_libyuv.h"
#include "logging/rtc_event_log/rtc_event_log.h"
#include "modules/rtp_rtcp/include/rtp_header_parser.h"
#include "rtc_base/checks.h"
#include "rtc_base/file.h"
#include "rtc_base/flags.h"
#include "rtc_base/json.h"
#include "rtc_base/string_to_number.h"
#include "rtc_base/timeutils.h"
#include "system_wrappers/include/clock.h"
#include "system_wrappers/include/sleep.h"
#include "test/call_test.h"
#include "test/encoder_settings.h"
#include "test/fake_decoder.h"
#include "test/gtest.h"
#include "test/null_transport.h"
#include "test/rtp_file_reader.h"
#include "test/run_loop.h"
#include "test/run_test.h"
#include "test/test_video_capturer.h"
#include "test/testsupport/frame_writer.h"
#include "test/video_renderer.h"
namespace {
static bool ValidatePayloadType(int32_t payload_type) {
return payload_type > 0 && payload_type <= 127;
}
static bool ValidateSsrc(const char* ssrc_string) {
return rtc::StringToNumber<uint32_t>(ssrc_string).has_value();
}
static bool ValidateOptionalPayloadType(int32_t payload_type) {
return payload_type == -1 || ValidatePayloadType(payload_type);
}
static bool ValidateRtpHeaderExtensionId(int32_t extension_id) {
return extension_id >= -1 && extension_id < 15;
}
bool ValidateInputFilenameNotEmpty(const std::string& string) {
return !string.empty();
}
} // namespace
namespace webrtc {
namespace flags {
// TODO(pbos): Multiple receivers.
// Flag for payload type.
DEFINE_int(media_payload_type,
test::CallTest::kPayloadTypeVP8,
"Media payload type");
static int MediaPayloadType() {
return static_cast<int>(FLAG_media_payload_type);
}
// Flag for RED payload type.
DEFINE_int(red_payload_type,
test::CallTest::kRedPayloadType,
"RED payload type");
static int RedPayloadType() {
return static_cast<int>(FLAG_red_payload_type);
}
// Flag for ULPFEC payload type.
DEFINE_int(ulpfec_payload_type,
test::CallTest::kUlpfecPayloadType,
"ULPFEC payload type");
static int UlpfecPayloadType() {
return static_cast<int>(FLAG_ulpfec_payload_type);
}
DEFINE_int(media_payload_type_rtx,
test::CallTest::kSendRtxPayloadType,
"Media over RTX payload type");
static int MediaPayloadTypeRtx() {
return static_cast<int>(FLAG_media_payload_type_rtx);
}
DEFINE_int(red_payload_type_rtx,
test::CallTest::kRtxRedPayloadType,
"RED over RTX payload type");
static int RedPayloadTypeRtx() {
return static_cast<int>(FLAG_red_payload_type_rtx);
}
// Flag for SSRC.
const std::string& DefaultSsrc() {
static const std::string ssrc =
std::to_string(test::CallTest::kVideoSendSsrcs[0]);
return ssrc;
}
DEFINE_string(ssrc, DefaultSsrc().c_str(), "Incoming SSRC");
static uint32_t Ssrc() {
return rtc::StringToNumber<uint32_t>(FLAG_ssrc).value();
}
const std::string& DefaultSsrcRtx() {
static const std::string ssrc_rtx =
std::to_string(test::CallTest::kSendRtxSsrcs[0]);
return ssrc_rtx;
}
DEFINE_string(ssrc_rtx, DefaultSsrcRtx().c_str(), "Incoming RTX SSRC");
static uint32_t SsrcRtx() {
return rtc::StringToNumber<uint32_t>(FLAG_ssrc_rtx).value();
}
// Flag for abs-send-time id.
DEFINE_int(abs_send_time_id, -1, "RTP extension ID for abs-send-time");
static int AbsSendTimeId() {
return static_cast<int>(FLAG_abs_send_time_id);
}
// Flag for transmission-offset id.
DEFINE_int(transmission_offset_id,
-1,
"RTP extension ID for transmission-offset");
static int TransmissionOffsetId() {
return static_cast<int>(FLAG_transmission_offset_id);
}
// Flag for rtpdump input file.
DEFINE_string(input_file, "", "input file");
static std::string InputFile() {
return static_cast<std::string>(FLAG_input_file);
}
DEFINE_string(config_file, "", "config file");
static std::string ConfigFile() {
return static_cast<std::string>(FLAG_config_file);
}
// Flag for raw output files.
DEFINE_string(out_base, "", "Basename (excluding .jpg) for raw output");
static std::string OutBase() {
return static_cast<std::string>(FLAG_out_base);
}
DEFINE_string(decoder_bitstream_filename, "", "Decoder bitstream output file");
static std::string DecoderBitstreamFilename() {
return static_cast<std::string>(FLAG_decoder_bitstream_filename);
}
// Flag for video codec.
DEFINE_string(codec, "VP8", "Video codec");
static std::string Codec() {
return static_cast<std::string>(FLAG_codec);
}
DEFINE_bool(help, false, "Print this message.");
} // namespace flags
static const uint32_t kReceiverLocalSsrc = 0x123456;
class FileRenderPassthrough : public rtc::VideoSinkInterface<VideoFrame> {
public:
FileRenderPassthrough(const std::string& basename,
rtc::VideoSinkInterface<VideoFrame>* renderer)
: basename_(basename), renderer_(renderer), file_(nullptr), count_(0) {}
~FileRenderPassthrough() {
if (file_)
fclose(file_);
}
private:
void OnFrame(const VideoFrame& video_frame) override {
if (renderer_)
renderer_->OnFrame(video_frame);
if (basename_.empty())
return;
std::stringstream filename;
filename << basename_ << count_++ << "_" << video_frame.timestamp()
<< ".jpg";
test::JpegFrameWriter frame_writer(filename.str());
RTC_CHECK(frame_writer.WriteFrame(video_frame, 100));
}
const std::string basename_;
rtc::VideoSinkInterface<VideoFrame>* const renderer_;
FILE* file_;
size_t count_;
};
class DecoderBitstreamFileWriter : public test::FakeDecoder {
public:
explicit DecoderBitstreamFileWriter(const char* filename)
: file_(fopen(filename, "wb")) {
RTC_DCHECK(file_);
}
~DecoderBitstreamFileWriter() { fclose(file_); }
int32_t Decode(const EncodedImage& encoded_frame,
bool /* missing_frames */,
const CodecSpecificInfo* /* codec_specific_info */,
int64_t /* render_time_ms */) override {
if (fwrite(encoded_frame._buffer, 1, encoded_frame._length, file_)
< encoded_frame._length) {
RTC_LOG_ERR(LS_ERROR) << "fwrite of encoded frame failed.";
return WEBRTC_VIDEO_CODEC_ERROR;
}
return WEBRTC_VIDEO_CODEC_OK;
}
private:
FILE* file_;
};
// Deserializes a JSON representation of the VideoReceiveStream::Config back
// into a valid object. This will not initialize the decoders or the renderer.
class VideoReceiveStreamConfigDeserializer final {
public:
static VideoReceiveStream::Config Deserialize(webrtc::Transport* transport,
const Json::Value& json) {
auto receive_config = VideoReceiveStream::Config(transport);
for (const auto decoder_json : json["decoders"]) {
VideoReceiveStream::Decoder decoder;
decoder.video_format =
SdpVideoFormat(decoder_json["payload_name"].asString());
decoder.payload_type = decoder_json["payload_type"].asInt64();
for (const auto& params_json : decoder_json["codec_params"]) {
std::vector<std::string> members = params_json.getMemberNames();
RTC_CHECK_EQ(members.size(), 1);
decoder.video_format.parameters[members[0]] =
params_json[members[0]].asString();
}
receive_config.decoders.push_back(decoder);
}
receive_config.render_delay_ms = json["render_delay_ms"].asInt64();
receive_config.target_delay_ms = json["target_delay_ms"].asInt64();
receive_config.rtp.remote_ssrc = json["remote_ssrc"].asInt64();
receive_config.rtp.local_ssrc = json["local_ssrc"].asInt64();
receive_config.rtp.rtcp_mode =
json["rtcp_mode"].asString() == "RtcpMode::kCompound"
? RtcpMode::kCompound
: RtcpMode::kReducedSize;
receive_config.rtp.remb = json["remb"].asBool();
receive_config.rtp.transport_cc = json["transport_cc"].asBool();
receive_config.rtp.nack.rtp_history_ms =
json["nack"]["rtp_history_ms"].asInt64();
receive_config.rtp.ulpfec_payload_type =
json["ulpfec_payload_type"].asInt64();
receive_config.rtp.red_payload_type = json["red_payload_type"].asInt64();
receive_config.rtp.rtx_ssrc = json["rtx_ssrc"].asInt64();
for (const auto& pl_json : json["rtx_payload_types"]) {
std::vector<std::string> members = pl_json.getMemberNames();
RTC_CHECK_EQ(members.size(), 1);
Json::Value rtx_payload_type = pl_json[members[0]];
receive_config.rtp.rtx_associated_payload_types[std::stoi(members[0])] =
rtx_payload_type.asInt64();
}
for (const auto& ext_json : json["extensions"]) {
receive_config.rtp.extensions.emplace_back(ext_json["uri"].asString(),
ext_json["id"].asInt64(),
ext_json["encrypt"].asBool());
}
return receive_config;
}
};
// The RtpReplayer is responsible for parsing the configuration provided by the
// user, setting up the windows, recieve streams and decoders and then replaying
// the provided RTP dump.
class RtpReplayer final {
public:
// Replay a rtp dump with an optional json configuration.
static void Replay(const std::string& replay_config_path,
const std::string& rtp_dump_path) {
webrtc::RtcEventLogNullImpl event_log;
Call::Config call_config(&event_log);
std::unique_ptr<Call> call(Call::Create(std::move(call_config)));
std::unique_ptr<StreamState> stream_state;
// Attempt to load the configuration
if (replay_config_path.empty()) {
stream_state = ConfigureFromFlags(rtp_dump_path, call.get());
} else {
stream_state = ConfigureFromFile(replay_config_path, call.get());
}
if (stream_state == nullptr) {
return;
}
// Attempt to create an RtpReader from the input file.
std::unique_ptr<test::RtpFileReader> rtp_reader =
CreateRtpReader(rtp_dump_path);
if (rtp_reader == nullptr) {
return;
}
// Start replaying the provided stream now that it has been configured.
for (const auto& receive_stream : stream_state->receive_streams) {
receive_stream->Start();
}
ReplayPackets(call.get(), rtp_reader.get());
for (const auto& receive_stream : stream_state->receive_streams) {
call->DestroyVideoReceiveStream(receive_stream);
}
}
private:
// Holds all the shared memory structures required for a recieve stream. This
// structure is used to prevent members being deallocated before the replay
// has been finished.
struct StreamState {
test::NullTransport transport;
std::vector<std::unique_ptr<rtc::VideoSinkInterface<VideoFrame>>> sinks;
std::vector<VideoReceiveStream*> receive_streams;
};
// Loads multiple configurations from the provided configuration file.
static std::unique_ptr<StreamState> ConfigureFromFile(
const std::string& config_path,
Call* call) {
auto stream_state = absl::make_unique<StreamState>();
// Parse the configuration file.
std::ifstream config_file(config_path);
std::stringstream raw_json_buffer;
raw_json_buffer << config_file.rdbuf();
std::string raw_json = raw_json_buffer.str();
Json::Reader json_reader;
Json::Value json_configs;
if (!json_reader.parse(raw_json, json_configs)) {
fprintf(stderr, "Error parsing JSON config\n");
fprintf(stderr, "%s\n", json_reader.getFormatedErrorMessages().c_str());
return nullptr;
}
size_t config_count = 0;
for (const auto& json : json_configs) {
// Create the configuration and parse the JSON into the config.
auto receive_config = VideoReceiveStreamConfigDeserializer::Deserialize(
&(stream_state->transport), json);
// Instantiate the underlying decoder.
for (auto& decoder : receive_config.decoders) {
decoder.decoder = test::CreateMatchingDecoder(decoder.payload_type,
decoder.video_format.name)
.decoder;
}
// Create a window for this config.
std::stringstream window_title;
window_title << "Playback Video (" << config_count++ << ")";
stream_state->sinks.emplace_back(
test::VideoRenderer::Create(window_title.str().c_str(), 640, 480));
// Create a receive stream for this config.
receive_config.renderer = stream_state->sinks.back().get();
stream_state->receive_streams.emplace_back(
call->CreateVideoReceiveStream(std::move(receive_config)));
}
return stream_state;
}
// Loads the base configuration from flags passed in on the commandline.
static std::unique_ptr<StreamState> ConfigureFromFlags(
const std::string& rtp_dump_path,
Call* call) {
auto stream_state = absl::make_unique<StreamState>();
// Create the video renderers. We must add both to the stream state to keep
// them from deallocating.
std::stringstream window_title;
window_title << "Playback Video (" << rtp_dump_path << ")";
std::unique_ptr<test::VideoRenderer> playback_video(
test::VideoRenderer::Create(window_title.str().c_str(), 640, 480));
auto file_passthrough = absl::make_unique<FileRenderPassthrough>(
flags::OutBase(), playback_video.get());
stream_state->sinks.push_back(std::move(playback_video));
stream_state->sinks.push_back(std::move(file_passthrough));
// Setup the configuration from the flags.
VideoReceiveStream::Config receive_config(&(stream_state->transport));
receive_config.rtp.remote_ssrc = flags::Ssrc();
receive_config.rtp.local_ssrc = kReceiverLocalSsrc;
receive_config.rtp.rtx_ssrc = flags::SsrcRtx();
receive_config.rtp
.rtx_associated_payload_types[flags::MediaPayloadTypeRtx()] =
flags::MediaPayloadType();
receive_config.rtp
.rtx_associated_payload_types[flags::RedPayloadTypeRtx()] =
flags::RedPayloadType();
receive_config.rtp.ulpfec_payload_type = flags::UlpfecPayloadType();
receive_config.rtp.red_payload_type = flags::RedPayloadType();
receive_config.rtp.nack.rtp_history_ms = 1000;
if (flags::TransmissionOffsetId() != -1) {
receive_config.rtp.extensions.push_back(RtpExtension(
RtpExtension::kTimestampOffsetUri, flags::TransmissionOffsetId()));
}
if (flags::AbsSendTimeId() != -1) {
receive_config.rtp.extensions.push_back(
RtpExtension(RtpExtension::kAbsSendTimeUri, flags::AbsSendTimeId()));
}
receive_config.renderer = stream_state->sinks.back().get();
// Setup the receiving stream
VideoReceiveStream::Decoder decoder;
decoder =
test::CreateMatchingDecoder(flags::MediaPayloadType(), flags::Codec());
if (!flags::DecoderBitstreamFilename().empty()) {
// Replace decoder with file writer if we're writing the bitstream to a
// file instead.
delete decoder.decoder;
decoder.decoder = new DecoderBitstreamFileWriter(
flags::DecoderBitstreamFilename().c_str());
}
receive_config.decoders.push_back(decoder);
stream_state->receive_streams.emplace_back(
call->CreateVideoReceiveStream(std::move(receive_config)));
return stream_state;
}
static std::unique_ptr<test::RtpFileReader> CreateRtpReader(
const std::string& rtp_dump_path) {
std::unique_ptr<test::RtpFileReader> rtp_reader(test::RtpFileReader::Create(
test::RtpFileReader::kRtpDump, rtp_dump_path));
if (!rtp_reader) {
rtp_reader.reset(test::RtpFileReader::Create(test::RtpFileReader::kPcap,
rtp_dump_path));
if (!rtp_reader) {
fprintf(
stderr,
"Couldn't open input file as either a rtpdump or .pcap. Note "
"that .pcapng is not supported.\nTrying to interpret the file as "
"length/packet interleaved.\n");
rtp_reader.reset(test::RtpFileReader::Create(
test::RtpFileReader::kLengthPacketInterleaved, rtp_dump_path));
if (!rtp_reader) {
fprintf(stderr,
"Unable to open input file with any supported format\n");
return nullptr;
}
}
}
return rtp_reader;
}
static void ReplayPackets(Call* call, test::RtpFileReader* rtp_reader) {
int64_t replay_start_ms = -1;
int num_packets = 0;
std::map<uint32_t, int> unknown_packets;
while (true) {
int64_t now_ms = rtc::TimeMillis();
if (replay_start_ms == -1) {
replay_start_ms = now_ms;
}
test::RtpPacket packet;
if (!rtp_reader->NextPacket(&packet)) {
break;
}
int64_t deliver_in_ms = replay_start_ms + packet.time_ms - now_ms;
if (deliver_in_ms > 0) {
SleepMs(deliver_in_ms);
}
++num_packets;
switch (call->Receiver()->DeliverPacket(
webrtc::MediaType::VIDEO,
rtc::CopyOnWriteBuffer(packet.data, packet.length),
/* packet_time_us */ -1)) {
case PacketReceiver::DELIVERY_OK:
break;
case PacketReceiver::DELIVERY_UNKNOWN_SSRC: {
RTPHeader header;
std::unique_ptr<RtpHeaderParser> parser(RtpHeaderParser::Create());
parser->Parse(packet.data, packet.length, &header);
if (unknown_packets[header.ssrc] == 0)
fprintf(stderr, "Unknown SSRC: %u!\n", header.ssrc);
++unknown_packets[header.ssrc];
break;
}
case PacketReceiver::DELIVERY_PACKET_ERROR: {
fprintf(stderr,
"Packet error, corrupt packets or incorrect setup?\n");
RTPHeader header;
std::unique_ptr<RtpHeaderParser> parser(RtpHeaderParser::Create());
parser->Parse(packet.data, packet.length, &header);
fprintf(stderr, "Packet len=%zu pt=%u seq=%u ts=%u ssrc=0x%8x\n",
packet.length, header.payloadType, header.sequenceNumber,
header.timestamp, header.ssrc);
break;
}
}
}
fprintf(stderr, "num_packets: %d\n", num_packets);
for (std::map<uint32_t, int>::const_iterator it = unknown_packets.begin();
it != unknown_packets.end(); ++it) {
fprintf(stderr, "Packets for unknown ssrc '%u': %d\n", it->first,
it->second);
}
}
}; // class RtpReplayer
void RtpReplay() {
RtpReplayer::Replay(flags::ConfigFile(), flags::InputFile());
}
} // namespace webrtc
int main(int argc, char* argv[]) {
::testing::InitGoogleTest(&argc, argv);
if (rtc::FlagList::SetFlagsFromCommandLine(&argc, argv, true)) {
return 1;
}
if (webrtc::flags::FLAG_help) {
rtc::FlagList::Print(nullptr, false);
return 0;
}
RTC_CHECK(ValidatePayloadType(webrtc::flags::FLAG_media_payload_type));
RTC_CHECK(ValidatePayloadType(webrtc::flags::FLAG_media_payload_type_rtx));
RTC_CHECK(ValidateOptionalPayloadType(webrtc::flags::FLAG_red_payload_type));
RTC_CHECK(
ValidateOptionalPayloadType(webrtc::flags::FLAG_red_payload_type_rtx));
RTC_CHECK(
ValidateOptionalPayloadType(webrtc::flags::FLAG_ulpfec_payload_type));
RTC_CHECK(ValidateSsrc(webrtc::flags::FLAG_ssrc));
RTC_CHECK(ValidateSsrc(webrtc::flags::FLAG_ssrc_rtx));
RTC_CHECK(ValidateRtpHeaderExtensionId(webrtc::flags::FLAG_abs_send_time_id));
RTC_CHECK(
ValidateRtpHeaderExtensionId(webrtc::flags::FLAG_transmission_offset_id));
RTC_CHECK(ValidateInputFilenameNotEmpty(webrtc::flags::FLAG_input_file));
webrtc::test::RunTest(webrtc::RtpReplay);
return 0;
}