Source code
Revision control
Copy as Markdown
Other Tools
/*
* Copyright (c) 2017 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 <algorithm>
#include <fstream>
#include <iostream>
#include <vector>
#include "api/array_view.h"
#include "modules/rtp_rtcp/source/byte_io.h"
#include "rtc_base/buffer.h"
namespace webrtc {
namespace test {
namespace {
constexpr size_t kRtpDumpHeaderLength = 8;
// Returns the next packet or an empty buffer if end of file was encountered.
rtc::Buffer ReadNextPacket(FILE* file) {
// Read the rtpdump header for the next packet.
rtc::Buffer buffer;
buffer.SetData(kRtpDumpHeaderLength, [&](rtc::ArrayView<uint8_t> x) {
return fread(x.data(), 1, x.size(), file);
});
if (buffer.size() != kRtpDumpHeaderLength) {
return rtc::Buffer();
}
// Get length field. This is the total length for this packet written to file,
// including the kRtpDumpHeaderLength bytes already read.
const uint16_t len = ByteReader<uint16_t>::ReadBigEndian(buffer.data());
RTC_CHECK_GE(len, kRtpDumpHeaderLength);
// Read remaining data from file directly into buffer.
buffer.AppendData(len - kRtpDumpHeaderLength, [&](rtc::ArrayView<uint8_t> x) {
return fread(x.data(), 1, x.size(), file);
});
if (buffer.size() != len) {
buffer.Clear();
}
return buffer;
}
struct PacketAndTime {
rtc::Buffer packet;
int time;
};
void WritePacket(const PacketAndTime& packet, FILE* file) {
// Write the first 4 bytes from the original packet.
const auto* payload_ptr = packet.packet.data();
RTC_CHECK_EQ(fwrite(payload_ptr, 4, 1, file), 1);
payload_ptr += 4;
// Convert the new time offset to network endian, and write to file.
uint8_t time[sizeof(uint32_t)];
ByteWriter<uint32_t, sizeof(uint32_t)>::WriteBigEndian(time, packet.time);
RTC_CHECK_EQ(fwrite(time, sizeof(uint32_t), 1, file), 1);
payload_ptr += 4; // Skip the old time in the original payload.
// Write the remaining part of the payload.
RTC_DCHECK_EQ(payload_ptr - packet.packet.data(), kRtpDumpHeaderLength);
RTC_CHECK_EQ(
fwrite(payload_ptr, packet.packet.size() - kRtpDumpHeaderLength, 1, file),
1);
}
int RunRtpJitter(int argc, char* argv[]) {
const std::string program_name = argv[0];
const std::string usage =
"Tool for alternating the arrival times in an RTP dump file.\n"
"Example usage:\n" +
program_name + " input.rtp arrival_times_ms.txt output.rtp\n\n";
if (argc != 4) {
printf("%s", usage.c_str());
return 1;
}
printf("Input RTP file: %s\n", argv[1]);
FILE* in_file = fopen(argv[1], "rb");
RTC_CHECK(in_file) << "Could not open file " << argv[1] << " for reading";
printf("Timing file: %s\n", argv[2]);
std::ifstream timing_file(argv[2]);
printf("Output file: %s\n", argv[3]);
FILE* out_file = fopen(argv[3], "wb");
RTC_CHECK(out_file) << "Could not open file " << argv[2] << " for writing";
// Copy the RTP file header to the output file.
char header_string[30];
RTC_CHECK(fgets(header_string, 30, in_file));
fprintf(out_file, "%s", header_string);
uint8_t file_header[16];
RTC_CHECK_EQ(fread(file_header, sizeof(file_header), 1, in_file), 1);
RTC_CHECK_EQ(fwrite(file_header, sizeof(file_header), 1, out_file), 1);
// Read all time values from the timing file. Store in a vector.
std::vector<int> new_arrival_times;
int new_time;
while (timing_file >> new_time) {
new_arrival_times.push_back(new_time);
}
// Read all packets from the input RTP file, but no more than the number of
// new time values. Store RTP packets together with new time values.
auto time_it = new_arrival_times.begin();
std::vector<PacketAndTime> packets;
while (1) {
auto packet = ReadNextPacket(in_file);
if (packet.empty() || time_it == new_arrival_times.end()) {
break;
}
packets.push_back({std::move(packet), *time_it});
++time_it;
}
// Sort on new time values.
std::sort(packets.begin(), packets.end(),
[](const PacketAndTime& a, const PacketAndTime& b) {
return a.time < b.time;
});
// Write packets to output file.
for (const auto& p : packets) {
WritePacket(p, out_file);
}
fclose(in_file);
fclose(out_file);
return 0;
}
} // namespace
} // namespace test
} // namespace webrtc
int main(int argc, char* argv[]) {
return webrtc::test::RunRtpJitter(argc, argv);
}