blob: 416cdd8ea51e67d6920e7299c1bb6d038726dcfa (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
|
// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "media/cast/net/rtp/receiver_stats.h"
#include "base/logging.h"
#include "media/cast/net/rtp/rtp_receiver_defines.h"
namespace media {
namespace cast {
static const uint32 kMaxSequenceNumber = 65536;
ReceiverStats::ReceiverStats(base::TickClock* clock)
: clock_(clock),
min_sequence_number_(0),
max_sequence_number_(0),
total_number_packets_(0),
sequence_number_cycles_(0),
interval_min_sequence_number_(0),
interval_number_packets_(0),
interval_wrap_count_(0) {}
ReceiverStats::~ReceiverStats() {}
void ReceiverStats::GetStatistics(uint8* fraction_lost,
uint32* cumulative_lost,
uint32* extended_high_sequence_number,
uint32* jitter) {
// Compute losses.
if (interval_number_packets_ == 0) {
*fraction_lost = 0;
} else {
int diff = 0;
if (interval_wrap_count_ == 0) {
diff = max_sequence_number_ - interval_min_sequence_number_ + 1;
} else {
diff = kMaxSequenceNumber * (interval_wrap_count_ - 1) +
(max_sequence_number_ - interval_min_sequence_number_ +
kMaxSequenceNumber + 1);
}
if (diff < 1) {
*fraction_lost = 0;
} else {
float tmp_ratio =
(1 - static_cast<float>(interval_number_packets_) / abs(diff));
*fraction_lost = static_cast<uint8>(256 * tmp_ratio);
}
}
int expected_packets_num = max_sequence_number_ - min_sequence_number_ + 1;
if (total_number_packets_ == 0) {
*cumulative_lost = 0;
} else if (sequence_number_cycles_ == 0) {
*cumulative_lost = expected_packets_num - total_number_packets_;
} else {
*cumulative_lost =
kMaxSequenceNumber * (sequence_number_cycles_ - 1) +
(expected_packets_num - total_number_packets_ + kMaxSequenceNumber);
}
// Extended high sequence number consists of the highest seq number and the
// number of cycles (wrap).
*extended_high_sequence_number =
(sequence_number_cycles_ << 16) + max_sequence_number_;
*jitter = static_cast<uint32>(std::abs(jitter_.InMillisecondsRoundedUp()));
// Reset interval values.
interval_min_sequence_number_ = 0;
interval_number_packets_ = 0;
interval_wrap_count_ = 0;
}
void ReceiverStats::UpdateStatistics(const RtpCastHeader& header) {
const uint16 new_seq_num = header.sequence_number;
if (interval_number_packets_ == 0) {
// First packet in the interval.
interval_min_sequence_number_ = new_seq_num;
}
if (total_number_packets_ == 0) {
// First incoming packet.
min_sequence_number_ = new_seq_num;
max_sequence_number_ = new_seq_num;
}
if (IsNewerSequenceNumber(new_seq_num, max_sequence_number_)) {
// Check wrap.
if (new_seq_num < max_sequence_number_) {
++sequence_number_cycles_;
++interval_wrap_count_;
}
max_sequence_number_ = new_seq_num;
}
// Compute Jitter.
base::TimeTicks now = clock_->NowTicks();
base::TimeDelta delta_new_timestamp =
base::TimeDelta::FromMilliseconds(header.rtp_timestamp);
if (total_number_packets_ > 0) {
// Update jitter.
base::TimeDelta delta =
(now - last_received_packet_time_) -
((delta_new_timestamp - last_received_timestamp_) / 90);
jitter_ += (delta - jitter_) / 16;
}
last_received_timestamp_ = delta_new_timestamp;
last_received_packet_time_ = now;
// Increment counters.
++total_number_packets_;
++interval_number_packets_;
}
} // namespace cast
} // namespace media
|
