1 /*
2 * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
11 #include "webrtc/modules/rtp_rtcp/source/packet_loss_stats.h"
12
13 #include <vector>
14
15 #include "webrtc/base/checks.h"
16
17 // After this many packets are added, adding additional packets will cause the
18 // oldest packets to be pruned from the buffer.
19 static const int kBufferSize = 100;
20
21 namespace webrtc {
22
PacketLossStats()23 PacketLossStats::PacketLossStats()
24 : single_loss_historic_count_(0),
25 multiple_loss_historic_event_count_(0),
26 multiple_loss_historic_packet_count_(0) {
27 }
28
AddLostPacket(uint16_t sequence_number)29 void PacketLossStats::AddLostPacket(uint16_t sequence_number) {
30 // Detect sequence number wrap around.
31 if (!lost_packets_buffer_.empty() &&
32 static_cast<int>(*(lost_packets_buffer_.rbegin())) - sequence_number
33 > 0x8000) {
34 // The buffer contains large numbers and this is a small number.
35 lost_packets_wrapped_buffer_.insert(sequence_number);
36 } else {
37 lost_packets_buffer_.insert(sequence_number);
38 }
39 if (lost_packets_wrapped_buffer_.size() + lost_packets_buffer_.size()
40 > kBufferSize || (!lost_packets_wrapped_buffer_.empty() &&
41 *(lost_packets_wrapped_buffer_.rbegin()) > 0x4000)) {
42 PruneBuffer();
43 }
44 }
45
GetSingleLossCount() const46 int PacketLossStats::GetSingleLossCount() const {
47 int single_loss_count, unused1, unused2;
48 ComputeLossCounts(&single_loss_count, &unused1, &unused2);
49 return single_loss_count;
50 }
51
GetMultipleLossEventCount() const52 int PacketLossStats::GetMultipleLossEventCount() const {
53 int event_count, unused1, unused2;
54 ComputeLossCounts(&unused1, &event_count, &unused2);
55 return event_count;
56 }
57
GetMultipleLossPacketCount() const58 int PacketLossStats::GetMultipleLossPacketCount() const {
59 int packet_count, unused1, unused2;
60 ComputeLossCounts(&unused1, &unused2, &packet_count);
61 return packet_count;
62 }
63
ComputeLossCounts(int * out_single_loss_count,int * out_multiple_loss_event_count,int * out_multiple_loss_packet_count) const64 void PacketLossStats::ComputeLossCounts(
65 int* out_single_loss_count,
66 int* out_multiple_loss_event_count,
67 int* out_multiple_loss_packet_count) const {
68 *out_single_loss_count = single_loss_historic_count_;
69 *out_multiple_loss_event_count = multiple_loss_historic_event_count_;
70 *out_multiple_loss_packet_count = multiple_loss_historic_packet_count_;
71 if (lost_packets_buffer_.empty()) {
72 RTC_DCHECK(lost_packets_wrapped_buffer_.empty());
73 return;
74 }
75 uint16_t last_num = 0;
76 int sequential_count = 0;
77 std::vector<const std::set<uint16_t>*> buffers;
78 buffers.push_back(&lost_packets_buffer_);
79 buffers.push_back(&lost_packets_wrapped_buffer_);
80 for (auto buffer : buffers) {
81 for (auto it = buffer->begin(); it != buffer->end(); ++it) {
82 uint16_t current_num = *it;
83 if (sequential_count > 0 && current_num != ((last_num + 1) & 0xFFFF)) {
84 if (sequential_count == 1) {
85 (*out_single_loss_count)++;
86 } else {
87 (*out_multiple_loss_event_count)++;
88 *out_multiple_loss_packet_count += sequential_count;
89 }
90 sequential_count = 0;
91 }
92 sequential_count++;
93 last_num = current_num;
94 }
95 }
96 if (sequential_count == 1) {
97 (*out_single_loss_count)++;
98 } else if (sequential_count > 1) {
99 (*out_multiple_loss_event_count)++;
100 *out_multiple_loss_packet_count += sequential_count;
101 }
102 }
103
PruneBuffer()104 void PacketLossStats::PruneBuffer() {
105 // Remove the oldest lost packet and any contiguous packets and move them
106 // into the historic counts.
107 auto it = lost_packets_buffer_.begin();
108 uint16_t last_removed = 0;
109 int remove_count = 0;
110 // Count adjacent packets and continue counting if it is wrap around by
111 // swapping in the wrapped buffer and letting our value wrap as well.
112 while (remove_count == 0 || (!lost_packets_buffer_.empty() &&
113 *it == ((last_removed + 1) & 0xFFFF))) {
114 last_removed = *it;
115 remove_count++;
116 auto to_erase = it++;
117 lost_packets_buffer_.erase(to_erase);
118 if (lost_packets_buffer_.empty()) {
119 lost_packets_buffer_.swap(lost_packets_wrapped_buffer_);
120 it = lost_packets_buffer_.begin();
121 }
122 }
123 if (remove_count > 1) {
124 multiple_loss_historic_event_count_++;
125 multiple_loss_historic_packet_count_ += remove_count;
126 } else {
127 single_loss_historic_count_++;
128 }
129 // Continue pruning if the wrapped buffer is beyond a threshold and there are
130 // things left in the pre-wrapped buffer.
131 if (!lost_packets_wrapped_buffer_.empty() &&
132 *(lost_packets_wrapped_buffer_.rbegin()) > 0x4000) {
133 PruneBuffer();
134 }
135 }
136
137 } // namespace webrtc
138