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
|
/*
* Copyright (c) 2022 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include "modules/audio_coding/neteq/packet_arrival_history.h"
#include <algorithm>
#include "api/neteq/tick_timer.h"
namespace webrtc {
PacketArrivalHistory::PacketArrivalHistory(int window_size_ms)
: window_size_ms_(window_size_ms) {}
void PacketArrivalHistory::Insert(uint32_t rtp_timestamp,
int64_t arrival_time_ms) {
RTC_DCHECK(sample_rate_khz_ > 0);
int64_t unwrapped_rtp_timestamp = timestamp_unwrapper_.Unwrap(rtp_timestamp);
if (!newest_rtp_timestamp_ ||
unwrapped_rtp_timestamp > *newest_rtp_timestamp_) {
newest_rtp_timestamp_ = unwrapped_rtp_timestamp;
}
history_.emplace_back(unwrapped_rtp_timestamp / sample_rate_khz_,
arrival_time_ms);
MaybeUpdateCachedArrivals(history_.back());
while (history_.front().rtp_timestamp_ms + window_size_ms_ <
unwrapped_rtp_timestamp / sample_rate_khz_) {
if (&history_.front() == min_packet_arrival_) {
min_packet_arrival_ = nullptr;
}
if (&history_.front() == max_packet_arrival_) {
max_packet_arrival_ = nullptr;
}
history_.pop_front();
}
if (!min_packet_arrival_ || !max_packet_arrival_) {
for (const PacketArrival& packet : history_) {
MaybeUpdateCachedArrivals(packet);
}
}
}
void PacketArrivalHistory::MaybeUpdateCachedArrivals(
const PacketArrival& packet_arrival) {
if (!min_packet_arrival_ || packet_arrival <= *min_packet_arrival_) {
min_packet_arrival_ = &packet_arrival;
}
if (!max_packet_arrival_ || packet_arrival >= *max_packet_arrival_) {
max_packet_arrival_ = &packet_arrival;
}
}
void PacketArrivalHistory::Reset() {
history_.clear();
min_packet_arrival_ = nullptr;
max_packet_arrival_ = nullptr;
timestamp_unwrapper_.Reset();
newest_rtp_timestamp_ = absl::nullopt;
}
int PacketArrivalHistory::GetDelayMs(uint32_t rtp_timestamp,
int64_t time_ms) const {
RTC_DCHECK(sample_rate_khz_ > 0);
int64_t unwrapped_rtp_timestamp_ms =
timestamp_unwrapper_.PeekUnwrap(rtp_timestamp) / sample_rate_khz_;
PacketArrival packet(unwrapped_rtp_timestamp_ms, time_ms);
return GetPacketArrivalDelayMs(packet);
}
int PacketArrivalHistory::GetMaxDelayMs() const {
if (!max_packet_arrival_) {
return 0;
}
return GetPacketArrivalDelayMs(*max_packet_arrival_);
}
bool PacketArrivalHistory::IsNewestRtpTimestamp(uint32_t rtp_timestamp) const {
if (!newest_rtp_timestamp_) {
return false;
}
int64_t unwrapped_rtp_timestamp =
timestamp_unwrapper_.PeekUnwrap(rtp_timestamp);
return unwrapped_rtp_timestamp == *newest_rtp_timestamp_;
}
int PacketArrivalHistory::GetPacketArrivalDelayMs(
const PacketArrival& packet_arrival) const {
if (!min_packet_arrival_) {
return 0;
}
return std::max(static_cast<int>(packet_arrival.arrival_time_ms -
min_packet_arrival_->arrival_time_ms -
(packet_arrival.rtp_timestamp_ms -
min_packet_arrival_->rtp_timestamp_ms)),
0);
}
} // namespace webrtc
|
