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

Add send frame rate statistics callback

Browse Source 
BUG=2235
R=mflodman@webrtc.org, pbos@webrtc.org, stefan@webrtc.org

Review URL: https://webrtc-codereview.appspot.com/4479005

git-svn-id: http://webrtc.googlecode.com/svn/trunk@5213 4adac7df-926f-26a2-2b94-8c16560cd09d
This commit is contained in:
sprang@webrtc.org
2013-12-04 15:09:27 +00:00
parent 9e5b0342f6
commit 71f055fb41
17 changed files with 205 additions and 107 deletions
Download Patch File Download Diff File Expand all files Collapse all files

33
webrtc/modules/video_coding/main/source/encoded_frame.cc
View File

@ -174,33 +174,16 @@ VCMEncodedFrame::VerifyAndAllocate(const uint32_t minimumSize)
webrtc::FrameType VCMEncodedFrame::ConvertFrameType(VideoFrameType frameType)
{
switch(frameType)
{
switch(frameType) {
case kKeyFrame:
{
return kVideoFrameKey;
}
return kVideoFrameKey;
case kDeltaFrame:
{
return kVideoFrameDelta;
}
case kGoldenFrame:
{
return kVideoFrameGolden;
}
case kAltRefFrame:
{
return kVideoFrameAltRef;
}
return kVideoFrameDelta;
case kSkipFrame:
{
return kFrameEmpty;
}
return kFrameEmpty;
default:
{
return kVideoFrameDelta;
}
}
return kVideoFrameDelta;
}
}
VideoFrameType VCMEncodedFrame::ConvertFrameType(webrtc::FrameType frame_type) {
@ -209,10 +192,6 @@ VideoFrameType VCMEncodedFrame::ConvertFrameType(webrtc::FrameType frame_type) {
return kKeyFrame;
case kVideoFrameDelta:
return kDeltaFrame;
case kVideoFrameGolden:
return kGoldenFrame;
case kVideoFrameAltRef:
return kAltRefFrame;
default:
assert(false);
return kDeltaFrame;

36
webrtc/modules/video_coding/main/source/jitter_buffer.cc
View File

@ -147,7 +147,6 @@ VCMJitterBuffer::VCMJitterBuffer(Clock* clock,
incomplete_frames_(),
last_decoded_state_(),
first_packet_since_reset_(true),
receive_statistics_(),
incoming_frame_rate_(0),
incoming_frame_count_(0),
time_last_incoming_frame_count_(0),
@ -172,7 +171,6 @@ VCMJitterBuffer::VCMJitterBuffer(Clock* clock,
average_packets_per_frame_(0.0f),
frame_counter_(0) {
memset(frame_buffers_, 0, sizeof(frame_buffers_));
memset(receive_statistics_, 0, sizeof(receive_statistics_));
for (int i = 0; i < kStartNumberOfFrames; i++) {
frame_buffers_[i] = new VCMFrameBuffer();
@ -218,8 +216,7 @@ void VCMJitterBuffer::CopyFrom(const VCMJitterBuffer& rhs) {
assert(max_nack_list_size_ == rhs.max_nack_list_size_);
assert(max_packet_age_to_nack_ == rhs.max_packet_age_to_nack_);
assert(max_incomplete_time_ms_ == rhs.max_incomplete_time_ms_);
memcpy(receive_statistics_, rhs.receive_statistics_,
sizeof(receive_statistics_));
receive_statistics_ = rhs.receive_statistics_;
nack_seq_nums_.resize(rhs.nack_seq_nums_.size());
missing_sequence_numbers_ = rhs.missing_sequence_numbers_;
latest_received_sequence_number_ = rhs.latest_received_sequence_number_;
@ -264,7 +261,7 @@ void VCMJitterBuffer::Start() {
incoming_bit_count_ = 0;
incoming_bit_rate_ = 0;
time_last_incoming_frame_count_ = clock_->TimeInMilliseconds();
memset(receive_statistics_, 0, sizeof(receive_statistics_));
receive_statistics_.clear();
num_consecutive_old_frames_ = 0;
num_consecutive_old_packets_ = 0;
@ -336,13 +333,9 @@ void VCMJitterBuffer::Flush() {
}
// Get received key and delta frames
void VCMJitterBuffer::FrameStatistics(uint32_t* received_delta_frames,
uint32_t* received_key_frames) const {
assert(received_delta_frames);
assert(received_key_frames);
std::map<FrameType, uint32_t> VCMJitterBuffer::FrameStatistics() const {
CriticalSectionScoped cs(crit_sect_);
*received_delta_frames = receive_statistics_[1] + receive_statistics_[3];
*received_key_frames = receive_statistics_[0] + receive_statistics_[2];
return receive_statistics_;
}
int VCMJitterBuffer::num_discarded_packets() const {
@ -1206,26 +1199,7 @@ void VCMJitterBuffer::CountFrame(const VCMFrameBuffer& frame) {
// 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()) {
switch (frame.FrameType()) {
case kVideoFrameKey: {
receive_statistics_[0]++;
break;
}
case kVideoFrameDelta: {
receive_statistics_[1]++;
break;
}
case kVideoFrameGolden: {
receive_statistics_[2]++;
break;
}
case kVideoFrameAltRef: {
receive_statistics_[3]++;
break;
}
default:
assert(false);
}
++receive_statistics_[frame.FrameType()];
}
}

9
webrtc/modules/video_coding/main/source/jitter_buffer.h
View File

@ -98,10 +98,9 @@ class VCMJitterBuffer {
// Empty the jitter buffer of all its data.
void Flush();
// Get the number of received key and delta frames since the jitter buffer
// Get the number of received frames, by type, since the jitter buffer
// was started.
void FrameStatistics(uint32_t* received_delta_frames,
uint32_t* received_key_frames) const;
std::map<FrameType, uint32_t> FrameStatistics() const;
// The number of packets discarded by the jitter buffer because the decoder
// won't be able to decode them.
@ -297,8 +296,8 @@ class VCMJitterBuffer {
bool first_packet_since_reset_;
// Statistics.
// Frame counter for each type (key, delta, golden, key-delta).
unsigned int receive_statistics_[4];
// Frame counts for each type (key, delta, ...)
std::map<FrameType, uint32_t> receive_statistics_;
// Latest calculated frame rates of incoming stream.
unsigned int incoming_frame_rate_;
unsigned int incoming_frame_count_;

14
webrtc/modules/video_coding/main/source/jitter_buffer_unittest.cc
View File

@ -1632,11 +1632,9 @@ TEST_F(TestRunningJitterBuffer, EmptyPackets) {
}
TEST_F(TestRunningJitterBuffer, StatisticsTest) {
uint32_t num_delta_frames = 0;
uint32_t num_key_frames = 0;
jitter_buffer_->FrameStatistics(&num_delta_frames, &num_key_frames);
EXPECT_EQ(0u, num_delta_frames);
EXPECT_EQ(0u, num_key_frames);
std::map<FrameType, uint32_t> frame_stats(jitter_buffer_->FrameStatistics());
EXPECT_EQ(0u, frame_stats[kVideoFrameDelta]);
EXPECT_EQ(0u, frame_stats[kVideoFrameKey]);
uint32_t framerate = 0;
uint32_t bitrate = 0;
@ -1654,9 +1652,9 @@ TEST_F(TestRunningJitterBuffer, StatisticsTest) {
// being decoded.
EXPECT_TRUE(DecodeCompleteFrame());
EXPECT_TRUE(DecodeCompleteFrame());
jitter_buffer_->FrameStatistics(&num_delta_frames, &num_key_frames);
EXPECT_EQ(3u, num_delta_frames);
EXPECT_EQ(2u, num_key_frames);
frame_stats = jitter_buffer_->FrameStatistics();
EXPECT_EQ(3u, frame_stats[kVideoFrameDelta]);
EXPECT_EQ(2u, frame_stats[kVideoFrameKey]);
// Insert 20 more frames to get estimates of bitrate and framerate over
// 1 second.

3
webrtc/modules/video_coding/main/source/media_optimization.cc
View File

@ -291,8 +291,7 @@ int32_t MediaOptimization::UpdateWithEncodedData(int encoded_length,
UpdateSentBitrate(now_ms);
UpdateSentFramerate();
if (encoded_length > 0) {
const bool delta_frame = (encoded_frame_type != kVideoFrameKey &&
encoded_frame_type != kVideoFrameGolden);
const bool delta_frame = (encoded_frame_type != kVideoFrameKey);
frame_dropper_->Fill(encoded_length, delta_frame);
if (max_payload_size_ > 0 && encoded_length > 0) {

5
webrtc/modules/video_coding/main/source/receiver.cc
View File

@ -238,8 +238,9 @@ void VCMReceiver::ReceiveStatistics(uint32_t* bitrate,
void VCMReceiver::ReceivedFrameCount(VCMFrameCount* frame_count) const {
assert(frame_count);
jitter_buffer_.FrameStatistics(&frame_count->numDeltaFrames,
&frame_count->numKeyFrames);
std::map<FrameType, uint32_t> counts(jitter_buffer_.FrameStatistics());
frame_count->numDeltaFrames = counts[kVideoFrameDelta];
frame_count->numKeyFrames = counts[kVideoFrameKey];
}
uint32_t VCMReceiver::DiscardedPackets() const {