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

Delete all stats-related logic from VCMJitterBuffer.

Browse Source 
Bug: webrtc:7408
Change-Id: I0347746f8c6cd2d8fb4b2daa61d4e3ef8f550b77
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/129930
Commit-Queue: Niels Moller <nisse@webrtc.org>
Reviewed-by: Philip Eliasson <philipel@webrtc.org>
Reviewed-by: Åsa Persson <asapersson@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#27338}
This commit is contained in:
Niels Möller
2019-03-28 12:56:30 +01:00
committed by Commit Bot
parent f49429d507
commit 20393ee9b7
3 changed files with 0 additions and 180 deletions
Download Patch File Download Diff File Expand all files Collapse all files

82
modules/video_coding/jitter_buffer.cc
View File

@ -26,10 +26,8 @@
#include "rtc_base/checks.h" #include "rtc_base/checks.h"
#include "rtc_base/logging.h" #include "rtc_base/logging.h"
#include "rtc_base/system/fallthrough.h" #include "rtc_base/system/fallthrough.h"
#include "rtc_base/trace_event.h"
#include "system_wrappers/include/clock.h" #include "system_wrappers/include/clock.h"
#include "system_wrappers/include/field_trial.h" #include "system_wrappers/include/field_trial.h"
#include "system_wrappers/include/metrics.h"
namespace webrtc { namespace webrtc {
// Interval for updating SS data. // Interval for updating SS data.
@ -109,8 +107,6 @@ void FrameList::CleanUpOldOrEmptyFrames(VCMDecodingState* decoding_state,
break; break;
} }
free_frames->push_back(oldest_frame); free_frames->push_back(oldest_frame);
TRACE_EVENT_INSTANT1("webrtc", "JB::OldOrEmptyFrameDropped", "timestamp",
oldest_frame->Timestamp());
erase(begin()); erase(begin());
} }
} }
@ -242,8 +238,6 @@ VCMJitterBuffer::VCMJitterBuffer(Clock* clock,
num_consecutive_old_packets_(0), num_consecutive_old_packets_(0),
num_packets_(0), num_packets_(0),
num_duplicated_packets_(0), num_duplicated_packets_(0),
num_discarded_packets_(0),
time_first_packet_ms_(0),
jitter_estimate_(clock), jitter_estimate_(clock),
inter_frame_delay_(clock_->TimeInMilliseconds()), inter_frame_delay_(clock_->TimeInMilliseconds()),
rtt_ms_(kDefaultRtt), rtt_ms_(kDefaultRtt),
@ -277,34 +271,6 @@ VCMJitterBuffer::~VCMJitterBuffer() {
} }
} }
void VCMJitterBuffer::UpdateHistograms() {
if (num_packets_ <= 0 || !running_) {
return;
}
int64_t elapsed_sec =
(clock_->TimeInMilliseconds() - time_first_packet_ms_) / 1000;
if (elapsed_sec < metrics::kMinRunTimeInSeconds) {
return;
}
RTC_HISTOGRAM_PERCENTAGE("WebRTC.Video.DiscardedPacketsInPercent",
num_discarded_packets_ * 100 / num_packets_);
RTC_HISTOGRAM_PERCENTAGE("WebRTC.Video.DuplicatedPacketsInPercent",
num_duplicated_packets_ * 100 / num_packets_);
int total_frames =
receive_statistics_.key_frames + receive_statistics_.delta_frames;
if (total_frames > 0) {
RTC_HISTOGRAM_COUNTS_100(
"WebRTC.Video.CompleteFramesReceivedPerSecond",
static_cast<int>((total_frames / elapsed_sec) + 0.5f));
RTC_HISTOGRAM_COUNTS_1000(
"WebRTC.Video.KeyFramesReceivedInPermille",
static_cast<int>(
(receive_statistics_.key_frames * 1000.0f / total_frames) + 0.5f));
}
}
void VCMJitterBuffer::Start() { void VCMJitterBuffer::Start() {
rtc::CritScope cs(&crit_sect_); rtc::CritScope cs(&crit_sect_);
running_ = true; running_ = true;
@ -313,13 +279,10 @@ void VCMJitterBuffer::Start() {
incoming_bit_count_ = 0; incoming_bit_count_ = 0;
incoming_bit_rate_ = 0; incoming_bit_rate_ = 0;
time_last_incoming_frame_count_ = clock_->TimeInMilliseconds(); time_last_incoming_frame_count_ = clock_->TimeInMilliseconds();
receive_statistics_ = FrameCounts();
num_consecutive_old_packets_ = 0; num_consecutive_old_packets_ = 0;
num_packets_ = 0; num_packets_ = 0;
num_duplicated_packets_ = 0; num_duplicated_packets_ = 0;
num_discarded_packets_ = 0;
time_first_packet_ms_ = 0;
// Start in a non-signaled state. // Start in a non-signaled state.
waiting_for_completion_.frame_size = 0; waiting_for_completion_.frame_size = 0;
@ -335,7 +298,6 @@ void VCMJitterBuffer::Start() {
void VCMJitterBuffer::Stop() { void VCMJitterBuffer::Stop() {
rtc::CritScope cs(&crit_sect_); rtc::CritScope cs(&crit_sect_);
UpdateHistograms();
running_ = false; running_ = false;
last_decoded_state_.Reset(); last_decoded_state_.Reset();
@ -364,12 +326,6 @@ void VCMJitterBuffer::Flush() {
missing_sequence_numbers_.clear(); missing_sequence_numbers_.clear();
} }
// Get received key and delta frames
FrameCounts VCMJitterBuffer::FrameStatistics() const {
rtc::CritScope cs(&crit_sect_);
return receive_statistics_;
}
int VCMJitterBuffer::num_packets() const { int VCMJitterBuffer::num_packets() const {
rtc::CritScope cs(&crit_sect_); rtc::CritScope cs(&crit_sect_);
return num_packets_; return num_packets_;
@ -380,11 +336,6 @@ int VCMJitterBuffer::num_duplicated_packets() const {
return num_duplicated_packets_; return num_duplicated_packets_;
} }
int VCMJitterBuffer::num_discarded_packets() const {
rtc::CritScope cs(&crit_sect_);
return num_discarded_packets_;
}
// Calculate framerate and bitrate. // Calculate framerate and bitrate.
void VCMJitterBuffer::IncomingRateStatistics(unsigned int* framerate, void VCMJitterBuffer::IncomingRateStatistics(unsigned int* framerate,
unsigned int* bitrate) { unsigned int* bitrate) {
@ -508,7 +459,6 @@ VCMEncodedFrame* VCMJitterBuffer::ExtractAndSetDecode(uint32_t timestamp) {
else else
return NULL; return NULL;
} }
TRACE_EVENT_ASYNC_STEP0("webrtc", "Video", timestamp, "Extract");
// Frame pulled out from jitter buffer, update the jitter estimate. // Frame pulled out from jitter buffer, update the jitter estimate.
const bool retransmitted = (frame->GetNackCount() > 0); const bool retransmitted = (frame->GetNackCount() > 0);
if (retransmitted) { if (retransmitted) {
@ -601,14 +551,10 @@ VCMFrameBufferEnum VCMJitterBuffer::InsertPacket(const VCMPacket& packet,
rtc::CritScope cs(&crit_sect_); rtc::CritScope cs(&crit_sect_);
++num_packets_; ++num_packets_;
if (num_packets_ == 1) {
time_first_packet_ms_ = clock_->TimeInMilliseconds();
}
// Does this packet belong to an old frame? // Does this packet belong to an old frame?
if (last_decoded_state_.IsOldPacket(&packet)) { if (last_decoded_state_.IsOldPacket(&packet)) {
// Account only for media packets. // Account only for media packets.
if (packet.sizeBytes > 0) { if (packet.sizeBytes > 0) {
num_discarded_packets_++;
num_consecutive_old_packets_++; num_consecutive_old_packets_++;
} }
// Update last decoded sequence number if the packet arrived late and // Update last decoded sequence number if the packet arrived late and
@ -673,11 +619,6 @@ VCMFrameBufferEnum VCMJitterBuffer::InsertPacket(const VCMPacket& packet,
VCMFrameBufferEnum buffer_state = VCMFrameBufferEnum buffer_state =
frame->InsertPacket(packet, now_ms, frame_data); frame->InsertPacket(packet, now_ms, frame_data);
if (previous_state != kStateComplete) {
TRACE_EVENT_ASYNC_BEGIN1("webrtc", "Video", frame->Timestamp(), "timestamp",
frame->Timestamp());
}
if (buffer_state > 0) { if (buffer_state > 0) {
incoming_bit_count_ += packet.sizeBytes << 3; incoming_bit_count_ += packet.sizeBytes << 3;
if (first_packet_since_reset_) { if (first_packet_since_reset_) {
@ -1084,7 +1025,6 @@ bool VCMJitterBuffer::TryToIncreaseJitterBufferSize() {
return false; return false;
free_frames_.push_back(new VCMFrameBuffer()); free_frames_.push_back(new VCMFrameBuffer());
++max_number_of_frames_; ++max_number_of_frames_;
TRACE_COUNTER1("webrtc", "JBMaxFrames", max_number_of_frames_);
return true; return true;
} }
@ -1104,7 +1044,6 @@ bool VCMJitterBuffer::RecycleFramesUntilKeyFrame() {
&key_frame_it, &free_frames_); &key_frame_it, &free_frames_);
key_frame_found = key_frame_it != decodable_frames_.end(); key_frame_found = key_frame_it != decodable_frames_.end();
} }
TRACE_EVENT_INSTANT0("webrtc", "JB::RecycleFramesUntilKeyFrame");
if (key_frame_found) { if (key_frame_found) {
RTC_LOG(LS_INFO) << "Found key frame while dropping frames."; RTC_LOG(LS_INFO) << "Found key frame while dropping frames.";
// Reset last decoded state to make sure the next frame decoded is a key // Reset last decoded state to make sure the next frame decoded is a key
@ -1123,27 +1062,6 @@ bool VCMJitterBuffer::RecycleFramesUntilKeyFrame() {
// Must be called under the critical section |crit_sect_|. // Must be called under the critical section |crit_sect_|.
void VCMJitterBuffer::CountFrame(const VCMFrameBuffer& frame) { void VCMJitterBuffer::CountFrame(const VCMFrameBuffer& frame) {
incoming_frame_count_++; incoming_frame_count_++;
if (frame.FrameType() == VideoFrameType::kVideoFrameKey) {
TRACE_EVENT_ASYNC_STEP0("webrtc", "Video", frame.Timestamp(),
"KeyComplete");
} else {
TRACE_EVENT_ASYNC_STEP0("webrtc", "Video", frame.Timestamp(),
"DeltaComplete");
}
// Update receive statistics. We count all layers, thus when you use layers
// adding all key and delta frames might differ from frame count.
if (frame.IsSessionComplete()) {
if (frame.FrameType() == VideoFrameType::kVideoFrameKey) {
++receive_statistics_.key_frames;
if (receive_statistics_.key_frames == 1) {
RTC_LOG(LS_INFO) << "Received first complete key frame";
}
} else {
++receive_statistics_.delta_frames;
}
}
} }
void VCMJitterBuffer::UpdateAveragePacketsPerFrame(int current_number_packets) { void VCMJitterBuffer::UpdateAveragePacketsPerFrame(int current_number_packets) {

15
modules/video_coding/jitter_buffer.h
View File

@ -125,19 +125,12 @@ class VCMJitterBuffer {
// Empty the jitter buffer of all its data. // Empty the jitter buffer of all its data.
void Flush(); void Flush();
// Get the number of received frames, by type, since the jitter buffer
// was started.
FrameCounts FrameStatistics() const;
// Gets number of packets received. // Gets number of packets received.
int num_packets() const; int num_packets() const;
// Gets number of duplicated packets received. // Gets number of duplicated packets received.
int num_duplicated_packets() const; int num_duplicated_packets() const;
// Gets number of packets discarded by the jitter buffer.
int num_discarded_packets() const;
// Statistics, Calculate frame and bit rates. // Statistics, Calculate frame and bit rates.
void IncomingRateStatistics(unsigned int* framerate, unsigned int* bitrate); void IncomingRateStatistics(unsigned int* framerate, unsigned int* bitrate);
@ -295,8 +288,6 @@ class VCMJitterBuffer {
uint16_t EstimatedLowSequenceNumber(const VCMFrameBuffer& frame) const; uint16_t EstimatedLowSequenceNumber(const VCMFrameBuffer& frame) const;
void UpdateHistograms() RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_sect_);
// Reset frame buffer and return it to free_frames_. // Reset frame buffer and return it to free_frames_.
void RecycleFrameBuffer(VCMFrameBuffer* frame) void RecycleFrameBuffer(VCMFrameBuffer* frame)
RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_sect_); RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_sect_);
@ -315,8 +306,6 @@ class VCMJitterBuffer {
VCMDecodingState last_decoded_state_ RTC_GUARDED_BY(crit_sect_); VCMDecodingState last_decoded_state_ RTC_GUARDED_BY(crit_sect_);
bool first_packet_since_reset_; bool first_packet_since_reset_;
// Frame counts for each type (key, delta, ...)
FrameCounts receive_statistics_;
// Latest calculated frame rates of incoming stream. // Latest calculated frame rates of incoming stream.
unsigned int incoming_frame_rate_; unsigned int incoming_frame_rate_;
unsigned int incoming_frame_count_; unsigned int incoming_frame_count_;
@ -329,10 +318,6 @@ class VCMJitterBuffer {
int num_packets_ RTC_GUARDED_BY(crit_sect_); int num_packets_ RTC_GUARDED_BY(crit_sect_);
// Number of duplicated packets received. // Number of duplicated packets received.
int num_duplicated_packets_ RTC_GUARDED_BY(crit_sect_); int num_duplicated_packets_ RTC_GUARDED_BY(crit_sect_);
// Number of packets discarded by the jitter buffer.
int num_discarded_packets_ RTC_GUARDED_BY(crit_sect_);
// Time when first packet is received.
int64_t time_first_packet_ms_ RTC_GUARDED_BY(crit_sect_);
// Jitter estimation. // Jitter estimation.
// Filter for estimating jitter. // Filter for estimating jitter.

83
modules/video_coding/jitter_buffer_unittest.cc
View File

@ -452,43 +452,6 @@ TEST_F(TestBasicJitterBuffer, SinglePacketFrame) {
jitter_buffer_->ReleaseFrame(frame_out); jitter_buffer_->ReleaseFrame(frame_out);
} }
TEST_F(TestBasicJitterBuffer, VerifyHistogramStats) {
metrics::Reset();
// Always start with a complete key frame when not allowing errors.
packet_->frameType = VideoFrameType::kVideoFrameKey;
packet_->video_header.is_first_packet_in_frame = true;
packet_->markerBit = true;
packet_->timestamp += 123 * 90;
// Insert single packet frame to the jitter buffer and get a frame.
bool retransmitted = false;
EXPECT_EQ(kCompleteSession,
jitter_buffer_->InsertPacket(*packet_, &retransmitted));
VCMEncodedFrame* frame_out = DecodeCompleteFrame();
CheckOutFrame(frame_out, size_, false);
EXPECT_EQ(VideoFrameType::kVideoFrameKey, frame_out->FrameType());
jitter_buffer_->ReleaseFrame(frame_out);
// Verify that histograms are updated when the jitter buffer is stopped.
clock_->AdvanceTimeMilliseconds(metrics::kMinRunTimeInSeconds * 1000);
jitter_buffer_->Stop();
EXPECT_EQ(1, metrics::NumEvents("WebRTC.Video.DiscardedPacketsInPercent", 0));
EXPECT_EQ(1,
metrics::NumEvents("WebRTC.Video.DuplicatedPacketsInPercent", 0));
EXPECT_EQ(
1, metrics::NumSamples("WebRTC.Video.CompleteFramesReceivedPerSecond"));
EXPECT_EQ(
1, metrics::NumEvents("WebRTC.Video.KeyFramesReceivedInPermille", 1000));
// Verify that histograms are not updated if stop is called again.
jitter_buffer_->Stop();
EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.DiscardedPacketsInPercent"));
EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.DuplicatedPacketsInPercent"));
EXPECT_EQ(
1, metrics::NumSamples("WebRTC.Video.CompleteFramesReceivedPerSecond"));
EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.KeyFramesReceivedInPermille"));
}
TEST_F(TestBasicJitterBuffer, DualPacketFrame) { TEST_F(TestBasicJitterBuffer, DualPacketFrame) {
packet_->frameType = VideoFrameType::kVideoFrameKey; packet_->frameType = VideoFrameType::kVideoFrameKey;
packet_->video_header.is_first_packet_in_frame = true; packet_->video_header.is_first_packet_in_frame = true;
@ -1711,52 +1674,6 @@ TEST_F(TestRunningJitterBuffer, EmptyPackets) {
EXPECT_FALSE(request_key_frame); EXPECT_FALSE(request_key_frame);
} }
TEST_F(TestRunningJitterBuffer, StatisticsTest) {
FrameCounts frame_stats(jitter_buffer_->FrameStatistics());
EXPECT_EQ(0, frame_stats.delta_frames);
EXPECT_EQ(0, frame_stats.key_frames);
uint32_t framerate = 0;
uint32_t bitrate = 0;
jitter_buffer_->IncomingRateStatistics(&framerate, &bitrate);
EXPECT_EQ(0u, framerate);
EXPECT_EQ(0u, bitrate);
// Insert a couple of key and delta frames.
InsertFrame(VideoFrameType::kVideoFrameKey);
InsertFrame(VideoFrameType::kVideoFrameDelta);
InsertFrame(VideoFrameType::kVideoFrameDelta);
InsertFrame(VideoFrameType::kVideoFrameKey);
InsertFrame(VideoFrameType::kVideoFrameDelta);
// Decode some of them to make sure the statistics doesn't depend on frames
// being decoded.
EXPECT_TRUE(DecodeCompleteFrame());
EXPECT_TRUE(DecodeCompleteFrame());
frame_stats = jitter_buffer_->FrameStatistics();
EXPECT_EQ(3, frame_stats.delta_frames);
EXPECT_EQ(2, frame_stats.key_frames);
// Insert 20 more frames to get estimates of bitrate and framerate over
// 1 second.
for (int i = 0; i < 20; ++i) {
InsertFrame(VideoFrameType::kVideoFrameDelta);
}
jitter_buffer_->IncomingRateStatistics(&framerate, &bitrate);
// TODO(holmer): The current implementation returns the average of the last
// two framerate calculations, which is why it takes two calls to reach the
// actual framerate. This should be fixed.
EXPECT_EQ(kDefaultFrameRate / 2u, framerate);
EXPECT_EQ(kDefaultBitrateKbps, bitrate);
// Insert 25 more frames to get estimates of bitrate and framerate over
// 2 seconds.
for (int i = 0; i < 25; ++i) {
InsertFrame(VideoFrameType::kVideoFrameDelta);
}
jitter_buffer_->IncomingRateStatistics(&framerate, &bitrate);
EXPECT_EQ(kDefaultFrameRate, framerate);
EXPECT_EQ(kDefaultBitrateKbps, bitrate);
}
TEST_F(TestRunningJitterBuffer, SkipToKeyFrame) { TEST_F(TestRunningJitterBuffer, SkipToKeyFrame) {
// Insert delta frames. // Insert delta frames.
EXPECT_GE(InsertFrames(5, VideoFrameType::kVideoFrameDelta), kNoError); EXPECT_GE(InsertFrames(5, VideoFrameType::kVideoFrameDelta), kNoError);