zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Get rid of packet loss related stuff from videoprocessor.

Browse Source 
This feature is not needed in video codec testing framework. In WebRTC
video codecs never deal with packet loss. Packet loss is handled by
jitter buffer which prevents passing of incomplete frames to decoder.

Bug: webrtc:8768
Change-Id: I211cf51d913bec6a1f935e30691661d428ebd3b6
Reviewed-on: https://webrtc-review.googlesource.com/40740
Commit-Queue: Sergey Silkin <ssilkin@webrtc.org>
Reviewed-by: Stefan Holmer <stefan@webrtc.org>
Reviewed-by: Rasmus Brandt <brandtr@webrtc.org>
Reviewed-by: Åsa Persson <asapersson@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#21722}
This commit is contained in:
Sergey Silkin
2018-01-22 15:49:55 +01:00
committed by Commit Bot
parent e93de5ff70
commit 1723cf9fa2
17 changed files with 13 additions and 687 deletions
Download Patch File Download Diff File Expand all files Collapse all files

63
modules/video_coding/codecs/test/videoprocessor.cc
View File

@ -97,7 +97,6 @@ void ExtractBufferWithSize(const VideoFrame& image,
VideoProcessor::VideoProcessor(webrtc::VideoEncoder* encoder,
webrtc::VideoDecoder* decoder,
FrameReader* analysis_frame_reader,
PacketManipulator* packet_manipulator,
const TestConfig& config,
Stats* stats,
IvfFileWriter* encoded_frame_writer,
@ -108,7 +107,6 @@ VideoProcessor::VideoProcessor(webrtc::VideoEncoder* encoder,
bitrate_allocator_(CreateBitrateAllocator(&config_)),
encode_callback_(this),
decode_callback_(this),
packet_manipulator_(packet_manipulator),
analysis_frame_reader_(analysis_frame_reader),
encoded_frame_writer_(encoded_frame_writer),
decoded_frame_writer_(decoded_frame_writer),
@ -117,12 +115,10 @@ VideoProcessor::VideoProcessor(webrtc::VideoEncoder* encoder,
last_decoded_frame_num_(0),
num_encoded_frames_(0),
num_decoded_frames_(0),
first_key_frame_has_been_excluded_(false),
last_decoded_frame_buffer_(analysis_frame_reader->FrameLength()),
stats_(stats) {
RTC_DCHECK(encoder);
RTC_DCHECK(decoder);
RTC_DCHECK(packet_manipulator);
RTC_DCHECK(analysis_frame_reader);
RTC_DCHECK(stats);
@ -133,11 +129,10 @@ VideoProcessor::VideoProcessor(webrtc::VideoEncoder* encoder,
WEBRTC_VIDEO_CODEC_OK);
// Initialize the encoder and decoder.
RTC_CHECK_EQ(
encoder_->InitEncode(&config_.codec_settings,
static_cast<int>(config_.NumberOfCores()),
config_.networking_config.max_payload_size_in_bytes),
WEBRTC_VIDEO_CODEC_OK);
RTC_CHECK_EQ(encoder_->InitEncode(&config_.codec_settings,
static_cast<int>(config_.NumberOfCores()),
config_.max_payload_size_bytes),
WEBRTC_VIDEO_CODEC_OK);
RTC_CHECK_EQ(decoder_->InitDecode(&config_.codec_settings,
static_cast<int>(config_.NumberOfCores())),
WEBRTC_VIDEO_CODEC_OK);
@ -218,13 +213,6 @@ void VideoProcessor::FrameEncoded(webrtc::VideoCodecType codec,
RTC_CHECK_GT(frame_number, last_encoded_frame_num_);
}
// Check for dropped frames.
bool last_frame_missing = false;
if (frame_number > 0) {
const FrameStatistic* last_encoded_frame_stat =
stats_->GetFrame(last_encoded_frame_num_);
last_frame_missing = (last_encoded_frame_stat->manipulated_length == 0);
}
last_encoded_frame_num_ = frame_number;
// Update frame statistics.
@ -237,32 +225,13 @@ void VideoProcessor::FrameEncoded(webrtc::VideoCodecType codec,
frame_stat->qp = encoded_image.qp_;
frame_stat->target_bitrate_kbps =
bitrate_allocation_.GetSpatialLayerSum(0) / 1000;
frame_stat->total_packets =
encoded_image._length / config_.networking_config.packet_size_in_bytes +
1;
frame_stat->max_nalu_size_bytes = GetMaxNaluSizeBytes(encoded_image, config_);
// Make a raw copy of |encoded_image| to feed to the decoder.
size_t copied_buffer_size = encoded_image._length +
EncodedImage::GetBufferPaddingBytes(codec);
std::unique_ptr<uint8_t[]> copied_buffer(new uint8_t[copied_buffer_size]);
memcpy(copied_buffer.get(), encoded_image._buffer, encoded_image._length);
EncodedImage copied_image = encoded_image;
copied_image._size = copied_buffer_size;
copied_image._buffer = copied_buffer.get();
// Simulate packet loss.
if (!ExcludeFrame(copied_image)) {
frame_stat->packets_dropped =
packet_manipulator_->ManipulatePackets(&copied_image);
}
frame_stat->manipulated_length = copied_image._length;
// For the highest measurement accuracy of the decode time, the start/stop
// time recordings should wrap the Decode call as tightly as possible.
frame_stat->decode_start_ns = rtc::TimeNanos();
frame_stat->decode_return_code =
decoder_->Decode(copied_image, last_frame_missing, nullptr);
decoder_->Decode(encoded_image, false, nullptr);
if (encoded_frame_writer_) {
RTC_CHECK(encoded_frame_writer_->WriteFrame(encoded_image, codec));
@ -337,27 +306,5 @@ void VideoProcessor::WriteDecodedFrameToFile(rtc::Buffer* buffer) {
RTC_CHECK(decoded_frame_writer_->WriteFrame(buffer->data()));
}
bool VideoProcessor::ExcludeFrame(const EncodedImage& encoded_image) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_);
if (encoded_image._frameType != kVideoFrameKey) {
return false;
}
bool exclude_frame = false;
switch (config_.exclude_frame_types) {
case kExcludeOnlyFirstKeyFrame:
if (!first_key_frame_has_been_excluded_) {
first_key_frame_has_been_excluded_ = true;
exclude_frame = true;
}
break;
case kExcludeAllKeyFrames:
exclude_frame = true;
break;
default:
RTC_NOTREACHED();
}
return exclude_frame;
}
} // namespace test
} // namespace webrtc