OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved. | 2 * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license | 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 | 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 | 6 * tree. An additional intellectual property rights grant can be found |
7 * in the file PATENTS. All contributing project authors may | 7 * in the file PATENTS. All contributing project authors may |
8 * be found in the AUTHORS file in the root of the source tree. | 8 * be found in the AUTHORS file in the root of the source tree. |
9 */ | 9 */ |
10 | 10 |
11 #include <map> | 11 #include <map> |
12 #include <memory> | 12 #include <memory> |
13 #include <string> | 13 #include <string> |
14 #include <utility> | 14 #include <utility> |
15 #include <vector> | 15 #include <vector> |
16 | 16 |
17 #include "webrtc/call/call.h" | 17 #include "webrtc/call/call.h" |
18 #include "webrtc/logging/rtc_event_log/rtc_event_log.h" | 18 #include "webrtc/logging/rtc_event_log/rtc_event_log.h" |
19 #include "webrtc/logging/rtc_event_log/rtc_event_log_parser.h" | 19 #include "webrtc/logging/rtc_event_log/rtc_event_log_parser.h" |
20 #include "webrtc/logging/rtc_event_log/rtc_event_log_unittest_helper.h" | 20 #include "webrtc/logging/rtc_event_log/rtc_event_log_unittest_helper.h" |
21 #include "webrtc/logging/rtc_event_log/rtc_stream_config.h" | 21 #include "webrtc/logging/rtc_event_log/rtc_stream_config.h" |
22 #include "webrtc/modules/audio_coding/audio_network_adaptor/include/audio_networ
k_adaptor.h" | 22 #include "webrtc/modules/audio_coding/audio_network_adaptor/include/audio_networ
k_adaptor.h" |
23 #include "webrtc/modules/remote_bitrate_estimator/include/bwe_defines.h" | 23 #include "webrtc/modules/remote_bitrate_estimator/include/bwe_defines.h" |
24 #include "webrtc/modules/rtp_rtcp/include/rtp_header_extension_map.h" | 24 #include "webrtc/modules/rtp_rtcp/include/rtp_header_extension_map.h" |
25 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet.h" | 25 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet.h" |
26 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sender_report.h" | 26 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sender_report.h" |
27 #include "webrtc/modules/rtp_rtcp/source/rtp_header_extensions.h" | 27 #include "webrtc/modules/rtp_rtcp/source/rtp_header_extensions.h" |
| 28 #include "webrtc/modules/rtp_rtcp/source/rtp_packet_received.h" |
28 #include "webrtc/modules/rtp_rtcp/source/rtp_packet_to_send.h" | 29 #include "webrtc/modules/rtp_rtcp/source/rtp_packet_to_send.h" |
29 #include "webrtc/rtc_base/buffer.h" | 30 #include "webrtc/rtc_base/buffer.h" |
30 #include "webrtc/rtc_base/checks.h" | 31 #include "webrtc/rtc_base/checks.h" |
31 #include "webrtc/rtc_base/fakeclock.h" | 32 #include "webrtc/rtc_base/fakeclock.h" |
| 33 #include "webrtc/rtc_base/ptr_util.h" |
32 #include "webrtc/rtc_base/random.h" | 34 #include "webrtc/rtc_base/random.h" |
33 #include "webrtc/test/gtest.h" | 35 #include "webrtc/test/gtest.h" |
34 #include "webrtc/test/testsupport/fileutils.h" | 36 #include "webrtc/test/testsupport/fileutils.h" |
35 | 37 |
36 // Files generated at build-time by the protobuf compiler. | 38 // Files generated at build-time by the protobuf compiler. |
37 #ifdef WEBRTC_ANDROID_PLATFORM_BUILD | 39 #ifdef WEBRTC_ANDROID_PLATFORM_BUILD |
38 #include "external/webrtc/webrtc/logging/rtc_event_log/rtc_event_log.pb.h" | 40 #include "external/webrtc/webrtc/logging/rtc_event_log/rtc_event_log.pb.h" |
39 #else | 41 #else |
40 #include "webrtc/logging/rtc_event_log/rtc_event_log.pb.h" | 42 #include "webrtc/logging/rtc_event_log/rtc_event_log.pb.h" |
41 #endif | 43 #endif |
42 | 44 |
43 namespace webrtc { | 45 namespace webrtc { |
44 | 46 |
45 namespace { | 47 namespace { |
46 | 48 |
| 49 const uint8_t kTransmissionTimeOffsetExtensionId = 1; |
| 50 const uint8_t kAbsoluteSendTimeExtensionId = 14; |
| 51 const uint8_t kTransportSequenceNumberExtensionId = 13; |
| 52 const uint8_t kAudioLevelExtensionId = 9; |
| 53 const uint8_t kVideoRotationExtensionId = 5; |
| 54 |
| 55 const uint8_t kExtensionIds[] = { |
| 56 kTransmissionTimeOffsetExtensionId, kAbsoluteSendTimeExtensionId, |
| 57 kTransportSequenceNumberExtensionId, kAudioLevelExtensionId, |
| 58 kVideoRotationExtensionId}; |
47 const RTPExtensionType kExtensionTypes[] = { | 59 const RTPExtensionType kExtensionTypes[] = { |
48 RTPExtensionType::kRtpExtensionTransmissionTimeOffset, | 60 RTPExtensionType::kRtpExtensionTransmissionTimeOffset, |
| 61 RTPExtensionType::kRtpExtensionAbsoluteSendTime, |
| 62 RTPExtensionType::kRtpExtensionTransportSequenceNumber, |
49 RTPExtensionType::kRtpExtensionAudioLevel, | 63 RTPExtensionType::kRtpExtensionAudioLevel, |
50 RTPExtensionType::kRtpExtensionAbsoluteSendTime, | 64 RTPExtensionType::kRtpExtensionVideoRotation}; |
51 RTPExtensionType::kRtpExtensionVideoRotation, | |
52 RTPExtensionType::kRtpExtensionTransportSequenceNumber}; | |
53 const char* kExtensionNames[] = { | 65 const char* kExtensionNames[] = { |
54 RtpExtension::kTimestampOffsetUri, RtpExtension::kAudioLevelUri, | 66 RtpExtension::kTimestampOffsetUri, RtpExtension::kAbsSendTimeUri, |
55 RtpExtension::kAbsSendTimeUri, RtpExtension::kVideoRotationUri, | 67 RtpExtension::kTransportSequenceNumberUri, RtpExtension::kAudioLevelUri, |
56 RtpExtension::kTransportSequenceNumberUri}; | 68 RtpExtension::kVideoRotationUri}; |
| 69 |
57 const size_t kNumExtensions = 5; | 70 const size_t kNumExtensions = 5; |
58 | 71 |
59 void PrintActualEvents(const ParsedRtcEventLog& parsed_log) { | 72 struct BweLossEvent { |
60 std::map<int, size_t> actual_event_counts; | 73 int32_t bitrate_bps; |
61 for (size_t i = 0; i < parsed_log.GetNumberOfEvents(); i++) { | 74 uint8_t fraction_loss; |
62 actual_event_counts[parsed_log.GetEventType(i)]++; | 75 int32_t total_packets; |
63 } | 76 }; |
64 printf("Actual events: "); | |
65 for (auto kv : actual_event_counts) { | |
66 printf("%d_count = %zu, ", kv.first, kv.second); | |
67 } | |
68 printf("\n"); | |
69 for (size_t i = 0; i < parsed_log.GetNumberOfEvents(); i++) { | |
70 printf("%4d ", parsed_log.GetEventType(i)); | |
71 } | |
72 printf("\n"); | |
73 } | |
74 | 77 |
75 void PrintExpectedEvents(size_t rtp_count, | |
76 size_t rtcp_count, | |
77 size_t playout_count, | |
78 size_t bwe_loss_count) { | |
79 printf( | |
80 "Expected events: rtp_count = %zu, rtcp_count = %zu," | |
81 "playout_count = %zu, bwe_loss_count = %zu\n", | |
82 rtp_count, rtcp_count, playout_count, bwe_loss_count); | |
83 size_t rtcp_index = 1, playout_index = 1, bwe_loss_index = 1; | |
84 printf("strt cfg cfg "); | |
85 for (size_t i = 1; i <= rtp_count; i++) { | |
86 printf(" rtp "); | |
87 if (i * rtcp_count >= rtcp_index * rtp_count) { | |
88 printf("rtcp "); | |
89 rtcp_index++; | |
90 } | |
91 if (i * playout_count >= playout_index * rtp_count) { | |
92 printf("play "); | |
93 playout_index++; | |
94 } | |
95 if (i * bwe_loss_count >= bwe_loss_index * rtp_count) { | |
96 printf("loss "); | |
97 bwe_loss_index++; | |
98 } | |
99 } | |
100 printf("end \n"); | |
101 } | |
102 } // namespace | 78 } // namespace |
103 | 79 |
104 /* | 80 RtpPacketToSend GenerateOutgoingRtpPacket( |
105 * Bit number i of extension_bitvector is set to indicate the | 81 const RtpHeaderExtensionMap* extensions, |
106 * presence of extension number i from kExtensionTypes / kExtensionNames. | 82 uint32_t csrcs_count, |
107 * The least significant bit extension_bitvector has number 0. | 83 size_t packet_size, |
108 */ | 84 Random* prng) { |
109 RtpPacketToSend GenerateRtpPacket(const RtpHeaderExtensionMap* extensions, | |
110 uint32_t csrcs_count, | |
111 size_t packet_size, | |
112 Random* prng) { | |
113 RTC_CHECK_GE(packet_size, 16 + 4 * csrcs_count + 4 * kNumExtensions); | 85 RTC_CHECK_GE(packet_size, 16 + 4 * csrcs_count + 4 * kNumExtensions); |
114 | 86 |
115 std::vector<uint32_t> csrcs; | 87 std::vector<uint32_t> csrcs; |
116 for (unsigned i = 0; i < csrcs_count; i++) { | 88 for (unsigned i = 0; i < csrcs_count; i++) { |
117 csrcs.push_back(prng->Rand<uint32_t>()); | 89 csrcs.push_back(prng->Rand<uint32_t>()); |
118 } | 90 } |
119 | 91 |
120 RtpPacketToSend rtp_packet(extensions, packet_size); | 92 RtpPacketToSend rtp_packet(extensions, packet_size); |
121 rtp_packet.SetPayloadType(prng->Rand(127)); | 93 rtp_packet.SetPayloadType(prng->Rand(127)); |
122 rtp_packet.SetMarker(prng->Rand<bool>()); | 94 rtp_packet.SetMarker(prng->Rand<bool>()); |
123 rtp_packet.SetSequenceNumber(prng->Rand<uint16_t>()); | 95 rtp_packet.SetSequenceNumber(prng->Rand<uint16_t>()); |
124 rtp_packet.SetSsrc(prng->Rand<uint32_t>()); | 96 rtp_packet.SetSsrc(prng->Rand<uint32_t>()); |
125 rtp_packet.SetTimestamp(prng->Rand<uint32_t>()); | 97 rtp_packet.SetTimestamp(prng->Rand<uint32_t>()); |
126 rtp_packet.SetCsrcs(csrcs); | 98 rtp_packet.SetCsrcs(csrcs); |
127 | 99 |
128 rtp_packet.SetExtension<TransmissionOffset>(prng->Rand(0x00ffffff)); | 100 rtp_packet.SetExtension<TransmissionOffset>(prng->Rand(0x00ffffff)); |
129 rtp_packet.SetExtension<AudioLevel>(prng->Rand<bool>(), prng->Rand(127)); | 101 rtp_packet.SetExtension<AudioLevel>(prng->Rand<bool>(), prng->Rand(127)); |
130 rtp_packet.SetExtension<AbsoluteSendTime>(prng->Rand(0x00ffffff)); | 102 rtp_packet.SetExtension<AbsoluteSendTime>(prng->Rand(0x00ffffff)); |
131 rtp_packet.SetExtension<VideoOrientation>(prng->Rand(2)); | 103 rtp_packet.SetExtension<VideoOrientation>(prng->Rand(2)); |
132 rtp_packet.SetExtension<TransportSequenceNumber>(prng->Rand<uint16_t>()); | 104 rtp_packet.SetExtension<TransportSequenceNumber>(prng->Rand<uint16_t>()); |
133 | 105 |
134 size_t payload_size = packet_size - rtp_packet.headers_size(); | 106 size_t payload_size = packet_size - rtp_packet.headers_size(); |
135 uint8_t* payload = rtp_packet.AllocatePayload(payload_size); | 107 uint8_t* payload = rtp_packet.AllocatePayload(payload_size); |
136 for (size_t i = 0; i < payload_size; i++) { | 108 for (size_t i = 0; i < payload_size; i++) { |
137 payload[i] = prng->Rand<uint8_t>(); | 109 payload[i] = prng->Rand<uint8_t>(); |
138 } | 110 } |
139 return rtp_packet; | 111 return rtp_packet; |
140 } | 112 } |
141 | 113 |
| 114 RtpPacketReceived GenerateIncomingRtpPacket( |
| 115 const RtpHeaderExtensionMap* extensions, |
| 116 uint32_t csrcs_count, |
| 117 size_t packet_size, |
| 118 Random* prng) { |
| 119 RtpPacketToSend packet_out = |
| 120 GenerateOutgoingRtpPacket(extensions, csrcs_count, packet_size, prng); |
| 121 RtpPacketReceived packet_in(extensions); |
| 122 packet_in.Parse(packet_out.data(), packet_out.size()); |
| 123 return packet_in; |
| 124 } |
| 125 |
142 rtc::Buffer GenerateRtcpPacket(Random* prng) { | 126 rtc::Buffer GenerateRtcpPacket(Random* prng) { |
143 rtcp::ReportBlock report_block; | 127 rtcp::ReportBlock report_block; |
144 report_block.SetMediaSsrc(prng->Rand<uint32_t>()); // Remote SSRC. | 128 report_block.SetMediaSsrc(prng->Rand<uint32_t>()); // Remote SSRC. |
145 report_block.SetFractionLost(prng->Rand(50)); | 129 report_block.SetFractionLost(prng->Rand(50)); |
146 | 130 |
147 rtcp::SenderReport sender_report; | 131 rtcp::SenderReport sender_report; |
148 sender_report.SetSenderSsrc(prng->Rand<uint32_t>()); | 132 sender_report.SetSenderSsrc(prng->Rand<uint32_t>()); |
149 sender_report.SetNtp(NtpTime(prng->Rand<uint32_t>(), prng->Rand<uint32_t>())); | 133 sender_report.SetNtp(NtpTime(prng->Rand<uint32_t>(), prng->Rand<uint32_t>())); |
150 sender_report.SetPacketCount(prng->Rand<uint32_t>()); | 134 sender_report.SetPacketCount(prng->Rand<uint32_t>()); |
151 sender_report.AddReportBlock(report_block); | 135 sender_report.AddReportBlock(report_block); |
152 | 136 |
153 return sender_report.Build(); | 137 return sender_report.Build(); |
154 } | 138 } |
155 | 139 |
156 void GenerateVideoReceiveConfig(uint32_t extensions_bitvector, | 140 void GenerateVideoReceiveConfig(const RtpHeaderExtensionMap& extensions, |
157 rtclog::StreamConfig* config, | 141 rtclog::StreamConfig* config, |
158 Random* prng) { | 142 Random* prng) { |
159 // Add SSRCs for the stream. | 143 // Add SSRCs for the stream. |
160 config->remote_ssrc = prng->Rand<uint32_t>(); | 144 config->remote_ssrc = prng->Rand<uint32_t>(); |
161 config->local_ssrc = prng->Rand<uint32_t>(); | 145 config->local_ssrc = prng->Rand<uint32_t>(); |
162 // Add extensions and settings for RTCP. | 146 // Add extensions and settings for RTCP. |
163 config->rtcp_mode = | 147 config->rtcp_mode = |
164 prng->Rand<bool>() ? RtcpMode::kCompound : RtcpMode::kReducedSize; | 148 prng->Rand<bool>() ? RtcpMode::kCompound : RtcpMode::kReducedSize; |
165 config->remb = prng->Rand<bool>(); | 149 config->remb = prng->Rand<bool>(); |
166 config->rtx_ssrc = prng->Rand<uint32_t>(); | 150 config->rtx_ssrc = prng->Rand<uint32_t>(); |
167 config->codecs.emplace_back(prng->Rand<bool>() ? "VP8" : "H264", | 151 config->codecs.emplace_back(prng->Rand<bool>() ? "VP8" : "H264", |
168 prng->Rand(1, 127), prng->Rand(1, 127)); | 152 prng->Rand(1, 127), prng->Rand(1, 127)); |
169 // Add header extensions. | 153 // Add header extensions. |
170 for (unsigned i = 0; i < kNumExtensions; i++) { | 154 for (unsigned i = 0; i < kNumExtensions; i++) { |
171 if (extensions_bitvector & (1u << i)) { | 155 uint8_t id = extensions.GetId(kExtensionTypes[i]); |
172 config->rtp_extensions.emplace_back(kExtensionNames[i], | 156 if (id != RtpHeaderExtensionMap::kInvalidId) { |
173 prng->Rand<int>()); | 157 config->rtp_extensions.emplace_back(kExtensionNames[i], id); |
174 } | 158 } |
175 } | 159 } |
176 } | 160 } |
177 | 161 |
178 void GenerateVideoSendConfig(uint32_t extensions_bitvector, | 162 void GenerateVideoSendConfig(const RtpHeaderExtensionMap& extensions, |
179 rtclog::StreamConfig* config, | 163 rtclog::StreamConfig* config, |
180 Random* prng) { | 164 Random* prng) { |
181 config->codecs.emplace_back(prng->Rand<bool>() ? "VP8" : "H264", | 165 config->codecs.emplace_back(prng->Rand<bool>() ? "VP8" : "H264", |
182 prng->Rand(1, 127), prng->Rand(1, 127)); | 166 prng->Rand(1, 127), prng->Rand(1, 127)); |
183 config->local_ssrc = prng->Rand<uint32_t>(); | 167 config->local_ssrc = prng->Rand<uint32_t>(); |
184 config->rtx_ssrc = prng->Rand<uint32_t>(); | 168 config->rtx_ssrc = prng->Rand<uint32_t>(); |
185 // Add header extensions. | 169 // Add header extensions. |
186 for (unsigned i = 0; i < kNumExtensions; i++) { | 170 for (unsigned i = 0; i < kNumExtensions; i++) { |
187 if (extensions_bitvector & (1u << i)) { | 171 uint8_t id = extensions.GetId(kExtensionTypes[i]); |
188 config->rtp_extensions.push_back( | 172 if (id != RtpHeaderExtensionMap::kInvalidId) { |
189 RtpExtension(kExtensionNames[i], prng->Rand<int>())); | 173 config->rtp_extensions.emplace_back(kExtensionNames[i], id); |
190 } | 174 } |
191 } | 175 } |
192 } | 176 } |
193 | 177 |
194 void GenerateAudioReceiveConfig(uint32_t extensions_bitvector, | 178 void GenerateAudioReceiveConfig(const RtpHeaderExtensionMap& extensions, |
195 rtclog::StreamConfig* config, | 179 rtclog::StreamConfig* config, |
196 Random* prng) { | 180 Random* prng) { |
197 // Add SSRCs for the stream. | 181 // Add SSRCs for the stream. |
198 config->remote_ssrc = prng->Rand<uint32_t>(); | 182 config->remote_ssrc = prng->Rand<uint32_t>(); |
199 config->local_ssrc = prng->Rand<uint32_t>(); | 183 config->local_ssrc = prng->Rand<uint32_t>(); |
200 // Add header extensions. | 184 // Add header extensions. |
201 for (unsigned i = 0; i < kNumExtensions; i++) { | 185 for (unsigned i = 0; i < kNumExtensions; i++) { |
202 if (extensions_bitvector & (1u << i)) { | 186 uint8_t id = extensions.GetId(kExtensionTypes[i]); |
203 config->rtp_extensions.push_back( | 187 if (id != RtpHeaderExtensionMap::kInvalidId) { |
204 RtpExtension(kExtensionNames[i], prng->Rand<int>())); | 188 config->rtp_extensions.emplace_back(kExtensionNames[i], id); |
205 } | 189 } |
206 } | 190 } |
207 } | 191 } |
208 | 192 |
209 void GenerateAudioSendConfig(uint32_t extensions_bitvector, | 193 void GenerateAudioSendConfig(const RtpHeaderExtensionMap& extensions, |
210 rtclog::StreamConfig* config, | 194 rtclog::StreamConfig* config, |
211 Random* prng) { | 195 Random* prng) { |
212 // Add SSRC to the stream. | 196 // Add SSRC to the stream. |
213 config->local_ssrc = prng->Rand<uint32_t>(); | 197 config->local_ssrc = prng->Rand<uint32_t>(); |
214 // Add header extensions. | 198 // Add header extensions. |
215 for (unsigned i = 0; i < kNumExtensions; i++) { | 199 for (unsigned i = 0; i < kNumExtensions; i++) { |
216 if (extensions_bitvector & (1u << i)) { | 200 uint8_t id = extensions.GetId(kExtensionTypes[i]); |
217 config->rtp_extensions.push_back( | 201 if (id != RtpHeaderExtensionMap::kInvalidId) { |
218 RtpExtension(kExtensionNames[i], prng->Rand<int>())); | 202 config->rtp_extensions.emplace_back(kExtensionNames[i], id); |
219 } | 203 } |
220 } | 204 } |
221 } | 205 } |
222 | 206 |
223 void GenerateAudioNetworkAdaptation(uint32_t extensions_bitvector, | 207 BweLossEvent GenerateBweLossEvent(Random* prng) { |
| 208 BweLossEvent loss_event; |
| 209 loss_event.bitrate_bps = prng->Rand(6000, 10000000); |
| 210 loss_event.fraction_loss = prng->Rand<uint8_t>(); |
| 211 loss_event.total_packets = prng->Rand(1, 1000); |
| 212 return loss_event; |
| 213 } |
| 214 |
| 215 void GenerateAudioNetworkAdaptation(const RtpHeaderExtensionMap& extensions, |
224 AudioEncoderRuntimeConfig* config, | 216 AudioEncoderRuntimeConfig* config, |
225 Random* prng) { | 217 Random* prng) { |
226 config->bitrate_bps = rtc::Optional<int>(prng->Rand(0, 3000000)); | 218 config->bitrate_bps = rtc::Optional<int>(prng->Rand(0, 3000000)); |
227 config->enable_fec = rtc::Optional<bool>(prng->Rand<bool>()); | 219 config->enable_fec = rtc::Optional<bool>(prng->Rand<bool>()); |
228 config->enable_dtx = rtc::Optional<bool>(prng->Rand<bool>()); | 220 config->enable_dtx = rtc::Optional<bool>(prng->Rand<bool>()); |
229 config->frame_length_ms = rtc::Optional<int>(prng->Rand(10, 120)); | 221 config->frame_length_ms = rtc::Optional<int>(prng->Rand(10, 120)); |
230 config->num_channels = rtc::Optional<size_t>(prng->Rand(1, 2)); | 222 config->num_channels = rtc::Optional<size_t>(prng->Rand(1, 2)); |
231 config->uplink_packet_loss_fraction = | 223 config->uplink_packet_loss_fraction = |
232 rtc::Optional<float>(prng->Rand<float>()); | 224 rtc::Optional<float>(prng->Rand<float>()); |
233 } | 225 } |
234 | 226 |
235 // Test for the RtcEventLog class. Dumps some RTP packets and other events | 227 // TODO(terelius): Merge with event type in parser once updated? |
236 // to disk, then reads them back to see if they match. | 228 enum class EventType { |
237 void LogSessionAndReadBack(size_t rtp_count, | 229 INCOMING_RTP = 1, |
238 size_t rtcp_count, | 230 OUTGOING_RTP = 2, |
239 size_t playout_count, | 231 INCOMING_RTCP = 3, |
240 size_t bwe_loss_count, | 232 OUTGOING_RTCP = 4, |
241 uint32_t extensions_bitvector, | 233 AUDIO_PLAYOUT = 5, |
242 uint32_t csrcs_count, | 234 BWE_LOSS_UPDATE = 6, |
243 unsigned int random_seed) { | 235 BWE_DELAY_UPDATE = 7, |
244 ASSERT_LE(rtcp_count, rtp_count); | 236 VIDEO_RECV_CONFIG = 8, |
245 ASSERT_LE(playout_count, rtp_count); | 237 VIDEO_SEND_CONFIG = 9, |
246 ASSERT_LE(bwe_loss_count, rtp_count); | 238 AUDIO_RECV_CONFIG = 10, |
247 std::vector<RtpPacketToSend> rtp_packets; | 239 AUDIO_SEND_CONFIG = 11, |
248 std::vector<rtc::Buffer> rtcp_packets; | 240 AUDIO_NETWORK_ADAPTATION = 12, |
| 241 BWE_PROBE_CLUSTER_CREATED = 13, |
| 242 BWE_PROBE_RESULT = 14, |
| 243 }; |
| 244 |
| 245 class SessionDescription { |
| 246 public: |
| 247 explicit SessionDescription(unsigned int random_seed) : prng(random_seed) {} |
| 248 void GenerateSessionDescription(size_t incoming_rtp_count, |
| 249 size_t outgoing_rtp_count, |
| 250 size_t incoming_rtcp_count, |
| 251 size_t outgoing_rtcp_count, |
| 252 size_t playout_count, |
| 253 size_t bwe_loss_count, |
| 254 size_t bwe_delay_count, |
| 255 const RtpHeaderExtensionMap& extensions, |
| 256 uint32_t csrcs_count); |
| 257 void WriteSession(); |
| 258 void ReadAndVerifySession(); |
| 259 void PrintExpectedEvents(); |
| 260 |
| 261 private: |
| 262 std::vector<RtpPacketReceived> incoming_rtp_packets; |
| 263 std::vector<RtpPacketToSend> outgoing_rtp_packets; |
| 264 std::vector<rtc::Buffer> incoming_rtcp_packets; |
| 265 std::vector<rtc::Buffer> outgoing_rtcp_packets; |
249 std::vector<uint32_t> playout_ssrcs; | 266 std::vector<uint32_t> playout_ssrcs; |
250 std::vector<std::pair<int32_t, uint8_t> > bwe_loss_updates; | 267 std::vector<BweLossEvent> bwe_loss_updates; |
251 | 268 std::vector<std::pair<int32_t, BandwidthUsage> > bwe_delay_updates; |
252 rtclog::StreamConfig receiver_config; | 269 std::vector<rtclog::StreamConfig> receiver_configs; |
253 rtclog::StreamConfig sender_config; | 270 std::vector<rtclog::StreamConfig> sender_configs; |
254 | 271 std::vector<EventType> event_types; |
255 Random prng(random_seed); | 272 Random prng; |
256 | 273 }; |
257 // Initialize rtp header extensions to be used in generated rtp packets. | 274 |
258 RtpHeaderExtensionMap extensions; | 275 void SessionDescription::GenerateSessionDescription( |
259 for (unsigned i = 0; i < kNumExtensions; i++) { | 276 size_t incoming_rtp_count, |
260 if (extensions_bitvector & (1u << i)) { | 277 size_t outgoing_rtp_count, |
261 extensions.Register(kExtensionTypes[i], i + 1); | 278 size_t incoming_rtcp_count, |
262 } | 279 size_t outgoing_rtcp_count, |
263 } | 280 size_t playout_count, |
264 // Create rtp_count RTP packets containing random data. | 281 size_t bwe_loss_count, |
265 for (size_t i = 0; i < rtp_count; i++) { | 282 size_t bwe_delay_count, |
| 283 const RtpHeaderExtensionMap& extensions, |
| 284 uint32_t csrcs_count) { |
| 285 // Create configuration for the video receive stream. |
| 286 receiver_configs.emplace_back(rtclog::StreamConfig()); |
| 287 GenerateVideoReceiveConfig(extensions, &receiver_configs.back(), &prng); |
| 288 event_types.push_back(EventType::VIDEO_RECV_CONFIG); |
| 289 |
| 290 // Create configuration for the video send stream. |
| 291 sender_configs.emplace_back(rtclog::StreamConfig()); |
| 292 GenerateVideoSendConfig(extensions, &sender_configs.back(), &prng); |
| 293 event_types.push_back(EventType::VIDEO_SEND_CONFIG); |
| 294 const size_t config_count = 2; |
| 295 |
| 296 // Create incoming and outgoing RTP packets containing random data. |
| 297 for (size_t i = 0; i < incoming_rtp_count; i++) { |
266 size_t packet_size = prng.Rand(1000, 1100); | 298 size_t packet_size = prng.Rand(1000, 1100); |
267 rtp_packets.push_back( | 299 incoming_rtp_packets.push_back(GenerateIncomingRtpPacket( |
268 GenerateRtpPacket(&extensions, csrcs_count, packet_size, &prng)); | 300 &extensions, csrcs_count, packet_size, &prng)); |
269 } | 301 event_types.push_back(EventType::INCOMING_RTP); |
270 // Create rtcp_count RTCP packets containing random data. | 302 } |
271 for (size_t i = 0; i < rtcp_count; i++) { | 303 for (size_t i = 0; i < outgoing_rtp_count; i++) { |
272 rtcp_packets.push_back(GenerateRtcpPacket(&prng)); | 304 size_t packet_size = prng.Rand(1000, 1100); |
273 } | 305 outgoing_rtp_packets.push_back(GenerateOutgoingRtpPacket( |
274 // Create playout_count random SSRCs to use when logging AudioPlayout events. | 306 &extensions, csrcs_count, packet_size, &prng)); |
| 307 event_types.push_back(EventType::OUTGOING_RTP); |
| 308 } |
| 309 // Create incoming and outgoing RTCP packets containing random data. |
| 310 for (size_t i = 0; i < incoming_rtcp_count; i++) { |
| 311 incoming_rtcp_packets.push_back(GenerateRtcpPacket(&prng)); |
| 312 event_types.push_back(EventType::INCOMING_RTCP); |
| 313 } |
| 314 for (size_t i = 0; i < outgoing_rtcp_count; i++) { |
| 315 outgoing_rtcp_packets.push_back(GenerateRtcpPacket(&prng)); |
| 316 event_types.push_back(EventType::OUTGOING_RTCP); |
| 317 } |
| 318 // Create random SSRCs to use when logging AudioPlayout events. |
275 for (size_t i = 0; i < playout_count; i++) { | 319 for (size_t i = 0; i < playout_count; i++) { |
276 playout_ssrcs.push_back(prng.Rand<uint32_t>()); | 320 playout_ssrcs.push_back(prng.Rand<uint32_t>()); |
277 } | 321 event_types.push_back(EventType::AUDIO_PLAYOUT); |
278 // Create bwe_loss_count random bitrate updates for LossBasedBwe. | 322 } |
| 323 // Create random bitrate updates for LossBasedBwe. |
279 for (size_t i = 0; i < bwe_loss_count; i++) { | 324 for (size_t i = 0; i < bwe_loss_count; i++) { |
280 bwe_loss_updates.push_back( | 325 bwe_loss_updates.push_back(GenerateBweLossEvent(&prng)); |
281 std::make_pair(prng.Rand<int32_t>(), prng.Rand<uint8_t>())); | 326 event_types.push_back(EventType::BWE_LOSS_UPDATE); |
282 } | 327 } |
283 // Create configurations for the video streams. | 328 // Create random bitrate updates for DelayBasedBwe. |
284 GenerateVideoReceiveConfig(extensions_bitvector, &receiver_config, &prng); | 329 for (size_t i = 0; i < bwe_delay_count; i++) { |
285 GenerateVideoSendConfig(extensions_bitvector, &sender_config, &prng); | 330 bwe_delay_updates.push_back(std::make_pair( |
286 const int config_count = 2; | 331 prng.Rand(6000, 10000000), prng.Rand<bool>() |
287 | 332 ? BandwidthUsage::kBwOverusing |
| 333 : BandwidthUsage::kBwUnderusing)); |
| 334 event_types.push_back(EventType::BWE_DELAY_UPDATE); |
| 335 } |
| 336 |
| 337 // Order the events randomly. The configurations are stored in a separate |
| 338 // buffer, so they might be written before any othe events. Hence, we can't |
| 339 // mix the config events with other events. |
| 340 for (size_t i = config_count; i < event_types.size(); i++) { |
| 341 size_t other = prng.Rand(static_cast<uint32_t>(i), |
| 342 static_cast<uint32_t>(event_types.size() - 1)); |
| 343 std::swap(event_types[i], event_types[other]); |
| 344 } |
| 345 } |
| 346 |
| 347 void SessionDescription::WriteSession() { |
288 // Find the name of the current test, in order to use it as a temporary | 348 // Find the name of the current test, in order to use it as a temporary |
289 // filename. | 349 // filename. |
290 auto test_info = ::testing::UnitTest::GetInstance()->current_test_info(); | 350 auto test_info = ::testing::UnitTest::GetInstance()->current_test_info(); |
291 const std::string temp_filename = | 351 const std::string temp_filename = |
292 test::OutputPath() + test_info->test_case_name() + test_info->name(); | 352 test::OutputPath() + test_info->test_case_name() + test_info->name(); |
293 | 353 |
| 354 rtc::ScopedFakeClock fake_clock; |
| 355 fake_clock.SetTimeMicros(prng.Rand<uint32_t>()); |
| 356 |
294 // When log_dumper goes out of scope, it causes the log file to be flushed | 357 // When log_dumper goes out of scope, it causes the log file to be flushed |
295 // to disk. | 358 // to disk. |
296 { | 359 std::unique_ptr<RtcEventLog> log_dumper(RtcEventLog::Create()); |
297 rtc::ScopedFakeClock fake_clock; | 360 |
298 fake_clock.SetTimeMicros(prng.Rand<uint32_t>()); | 361 size_t incoming_rtp_written = 0; |
299 std::unique_ptr<RtcEventLog> log_dumper(RtcEventLog::Create()); | 362 size_t outgoing_rtp_written = 0; |
300 log_dumper->LogVideoReceiveStreamConfig(receiver_config); | 363 size_t incoming_rtcp_written = 0; |
| 364 size_t outgoing_rtcp_written = 0; |
| 365 size_t playouts_written = 0; |
| 366 size_t bwe_loss_written = 0; |
| 367 size_t bwe_delay_written = 0; |
| 368 size_t recv_configs_written = 0; |
| 369 size_t send_configs_written = 0; |
| 370 |
| 371 for (size_t i = 0; i < event_types.size(); i++) { |
301 fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000)); | 372 fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000)); |
302 log_dumper->LogVideoSendStreamConfig(sender_config); | 373 if (i == event_types.size() / 2) |
303 fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000)); | 374 log_dumper->StartLogging(temp_filename, 10000000); |
304 size_t rtcp_index = 1; | 375 switch (event_types[i]) { |
305 size_t playout_index = 1; | 376 case EventType::INCOMING_RTP: |
306 size_t bwe_loss_index = 1; | 377 log_dumper->LogIncomingRtpHeader( |
307 for (size_t i = 1; i <= rtp_count; i++) { | 378 incoming_rtp_packets[incoming_rtp_written++]); |
308 log_dumper->LogRtpHeader( | 379 break; |
309 (i % 2 == 0) ? kIncomingPacket : kOutgoingPacket, | 380 case EventType::OUTGOING_RTP: |
310 rtp_packets[i - 1].data(), rtp_packets[i - 1].size()); | 381 log_dumper->LogOutgoingRtpHeader( |
311 fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000)); | 382 outgoing_rtp_packets[outgoing_rtp_written++], |
312 if (i * rtcp_count >= rtcp_index * rtp_count) { | 383 PacedPacketInfo::kNotAProbe); |
313 log_dumper->LogRtcpPacket( | 384 break; |
314 (rtcp_index % 2 == 0) ? kIncomingPacket : kOutgoingPacket, | 385 case EventType::INCOMING_RTCP: |
315 rtcp_packets[rtcp_index - 1].data(), | 386 log_dumper->LogIncomingRtcpPacket( |
316 rtcp_packets[rtcp_index - 1].size()); | 387 incoming_rtcp_packets[incoming_rtcp_written++]); |
317 rtcp_index++; | 388 break; |
318 fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000)); | 389 case EventType::OUTGOING_RTCP: |
319 } | 390 log_dumper->LogOutgoingRtcpPacket( |
320 if (i * playout_count >= playout_index * rtp_count) { | 391 outgoing_rtcp_packets[outgoing_rtcp_written++]); |
321 log_dumper->LogAudioPlayout(playout_ssrcs[playout_index - 1]); | 392 break; |
322 playout_index++; | 393 case EventType::AUDIO_PLAYOUT: |
323 fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000)); | 394 log_dumper->LogAudioPlayout(playout_ssrcs[playouts_written++]); |
324 } | 395 break; |
325 if (i * bwe_loss_count >= bwe_loss_index * rtp_count) { | 396 case EventType::BWE_LOSS_UPDATE: |
326 log_dumper->LogLossBasedBweUpdate( | 397 log_dumper->LogLossBasedBweUpdate( |
327 bwe_loss_updates[bwe_loss_index - 1].first, | 398 bwe_loss_updates[bwe_loss_written].bitrate_bps, |
328 bwe_loss_updates[bwe_loss_index - 1].second, i); | 399 bwe_loss_updates[bwe_loss_written].fraction_loss, |
329 bwe_loss_index++; | 400 bwe_loss_updates[bwe_loss_written].total_packets); |
330 fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000)); | 401 bwe_loss_written++; |
331 } | 402 break; |
332 if (i == rtp_count / 2) { | 403 case EventType::BWE_DELAY_UPDATE: |
333 log_dumper->StartLogging(temp_filename, 10000000); | 404 log_dumper->LogDelayBasedBweUpdate( |
334 fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000)); | 405 bwe_delay_updates[bwe_delay_written].first, |
335 } | 406 bwe_delay_updates[bwe_delay_written].second); |
336 } | 407 bwe_delay_written++; |
337 log_dumper->StopLogging(); | 408 break; |
338 } | 409 case EventType::VIDEO_RECV_CONFIG: |
| 410 log_dumper->LogVideoReceiveStreamConfig( |
| 411 receiver_configs[recv_configs_written++]); |
| 412 break; |
| 413 case EventType::VIDEO_SEND_CONFIG: |
| 414 log_dumper->LogVideoSendStreamConfig( |
| 415 sender_configs[send_configs_written++]); |
| 416 break; |
| 417 case EventType::AUDIO_RECV_CONFIG: |
| 418 // Not implemented |
| 419 RTC_NOTREACHED(); |
| 420 break; |
| 421 case EventType::AUDIO_SEND_CONFIG: |
| 422 // Not implemented |
| 423 RTC_NOTREACHED(); |
| 424 break; |
| 425 case EventType::AUDIO_NETWORK_ADAPTATION: |
| 426 // Not implemented |
| 427 RTC_NOTREACHED(); |
| 428 break; |
| 429 case EventType::BWE_PROBE_CLUSTER_CREATED: |
| 430 // Not implemented |
| 431 RTC_NOTREACHED(); |
| 432 break; |
| 433 case EventType::BWE_PROBE_RESULT: |
| 434 // Not implemented |
| 435 RTC_NOTREACHED(); |
| 436 break; |
| 437 } |
| 438 } |
| 439 |
| 440 log_dumper->StopLogging(); |
| 441 } |
| 442 |
| 443 // Read the file and verify that what we read back from the event log is the |
| 444 // same as what we wrote down. |
| 445 void SessionDescription::ReadAndVerifySession() { |
| 446 // Find the name of the current test, in order to use it as a temporary |
| 447 // filename. |
| 448 auto test_info = ::testing::UnitTest::GetInstance()->current_test_info(); |
| 449 const std::string temp_filename = |
| 450 test::OutputPath() + test_info->test_case_name() + test_info->name(); |
339 | 451 |
340 // Read the generated file from disk. | 452 // Read the generated file from disk. |
341 ParsedRtcEventLog parsed_log; | 453 ParsedRtcEventLog parsed_log; |
342 | |
343 ASSERT_TRUE(parsed_log.ParseFile(temp_filename)); | 454 ASSERT_TRUE(parsed_log.ParseFile(temp_filename)); |
344 | 455 EXPECT_GE(1000u, event_types.size() + |
345 // Verify that what we read back from the event log is the same as | 456 2); // The events must fit in the message queue. |
346 // what we wrote down. For RTCP we log the full packets, but for | 457 EXPECT_EQ(event_types.size() + 2, parsed_log.GetNumberOfEvents()); |
347 // RTP we should only log the header. | 458 |
348 const size_t event_count = config_count + playout_count + bwe_loss_count + | 459 size_t incoming_rtp_read = 0; |
349 rtcp_count + rtp_count + 2; | 460 size_t outgoing_rtp_read = 0; |
350 EXPECT_GE(1000u, event_count); // The events must fit in the message queue. | 461 size_t incoming_rtcp_read = 0; |
351 EXPECT_EQ(event_count, parsed_log.GetNumberOfEvents()); | 462 size_t outgoing_rtcp_read = 0; |
352 if (event_count != parsed_log.GetNumberOfEvents()) { | 463 size_t playouts_read = 0; |
353 // Print the expected and actual event types for easier debugging. | 464 size_t bwe_loss_read = 0; |
354 PrintActualEvents(parsed_log); | 465 size_t bwe_delay_read = 0; |
355 PrintExpectedEvents(rtp_count, rtcp_count, playout_count, bwe_loss_count); | 466 size_t recv_configs_read = 0; |
356 } | 467 size_t send_configs_read = 0; |
| 468 |
357 RtcEventLogTestHelper::VerifyLogStartEvent(parsed_log, 0); | 469 RtcEventLogTestHelper::VerifyLogStartEvent(parsed_log, 0); |
358 RtcEventLogTestHelper::VerifyVideoReceiveStreamConfig(parsed_log, 1, | 470 |
359 receiver_config); | 471 for (size_t i = 0; i < event_types.size(); i++) { |
360 RtcEventLogTestHelper::VerifyVideoSendStreamConfig(parsed_log, 2, | 472 switch (event_types[i]) { |
361 sender_config); | 473 case EventType::INCOMING_RTP: |
362 size_t event_index = config_count + 1; | 474 RtcEventLogTestHelper::VerifyRtpEvent( |
363 size_t rtcp_index = 1; | 475 parsed_log, i + 1, kIncomingPacket, |
364 size_t playout_index = 1; | 476 incoming_rtp_packets[incoming_rtp_read++]); |
365 size_t bwe_loss_index = 1; | 477 break; |
366 for (size_t i = 1; i <= rtp_count; i++) { | 478 case EventType::OUTGOING_RTP: |
367 RtcEventLogTestHelper::VerifyRtpEvent( | 479 RtcEventLogTestHelper::VerifyRtpEvent( |
368 parsed_log, event_index, | 480 parsed_log, i + 1, kOutgoingPacket, |
369 (i % 2 == 0) ? kIncomingPacket : kOutgoingPacket, | 481 outgoing_rtp_packets[outgoing_rtp_read++]); |
370 rtp_packets[i - 1].data(), rtp_packets[i - 1].headers_size(), | 482 break; |
371 rtp_packets[i - 1].size()); | 483 case EventType::INCOMING_RTCP: |
372 event_index++; | 484 RtcEventLogTestHelper::VerifyRtcpEvent( |
373 if (i * rtcp_count >= rtcp_index * rtp_count) { | 485 parsed_log, i + 1, kIncomingPacket, |
374 RtcEventLogTestHelper::VerifyRtcpEvent( | 486 incoming_rtcp_packets[incoming_rtcp_read].data(), |
375 parsed_log, event_index, | 487 incoming_rtcp_packets[incoming_rtcp_read].size()); |
376 rtcp_index % 2 == 0 ? kIncomingPacket : kOutgoingPacket, | 488 incoming_rtcp_read++; |
377 rtcp_packets[rtcp_index - 1].data(), | 489 break; |
378 rtcp_packets[rtcp_index - 1].size()); | 490 case EventType::OUTGOING_RTCP: |
379 event_index++; | 491 RtcEventLogTestHelper::VerifyRtcpEvent( |
380 rtcp_index++; | 492 parsed_log, i + 1, kOutgoingPacket, |
381 } | 493 outgoing_rtcp_packets[outgoing_rtcp_read].data(), |
382 if (i * playout_count >= playout_index * rtp_count) { | 494 outgoing_rtcp_packets[outgoing_rtcp_read].size()); |
383 RtcEventLogTestHelper::VerifyPlayoutEvent( | 495 outgoing_rtcp_read++; |
384 parsed_log, event_index, playout_ssrcs[playout_index - 1]); | 496 break; |
385 event_index++; | 497 case EventType::AUDIO_PLAYOUT: |
386 playout_index++; | 498 RtcEventLogTestHelper::VerifyPlayoutEvent( |
387 } | 499 parsed_log, i + 1, playout_ssrcs[playouts_read++]); |
388 if (i * bwe_loss_count >= bwe_loss_index * rtp_count) { | 500 break; |
389 RtcEventLogTestHelper::VerifyBweLossEvent( | 501 case EventType::BWE_LOSS_UPDATE: |
390 parsed_log, event_index, bwe_loss_updates[bwe_loss_index - 1].first, | 502 RtcEventLogTestHelper::VerifyBweLossEvent( |
391 bwe_loss_updates[bwe_loss_index - 1].second, i); | 503 parsed_log, i + 1, bwe_loss_updates[bwe_loss_read].bitrate_bps, |
392 event_index++; | 504 bwe_loss_updates[bwe_loss_read].fraction_loss, |
393 bwe_loss_index++; | 505 bwe_loss_updates[bwe_loss_read].total_packets); |
394 } | 506 bwe_loss_read++; |
395 } | 507 break; |
| 508 case EventType::BWE_DELAY_UPDATE: |
| 509 RtcEventLogTestHelper::VerifyBweDelayEvent( |
| 510 parsed_log, i + 1, bwe_delay_updates[bwe_delay_read].first, |
| 511 bwe_delay_updates[bwe_delay_read].second); |
| 512 bwe_delay_read++; |
| 513 break; |
| 514 case EventType::VIDEO_RECV_CONFIG: |
| 515 RtcEventLogTestHelper::VerifyVideoReceiveStreamConfig( |
| 516 parsed_log, i + 1, receiver_configs[recv_configs_read++]); |
| 517 break; |
| 518 case EventType::VIDEO_SEND_CONFIG: |
| 519 RtcEventLogTestHelper::VerifyVideoSendStreamConfig( |
| 520 parsed_log, i + 1, sender_configs[send_configs_read++]); |
| 521 break; |
| 522 case EventType::AUDIO_RECV_CONFIG: |
| 523 // Not implemented |
| 524 RTC_NOTREACHED(); |
| 525 break; |
| 526 case EventType::AUDIO_SEND_CONFIG: |
| 527 // Not implemented |
| 528 RTC_NOTREACHED(); |
| 529 break; |
| 530 case EventType::AUDIO_NETWORK_ADAPTATION: |
| 531 // Not implemented |
| 532 RTC_NOTREACHED(); |
| 533 break; |
| 534 case EventType::BWE_PROBE_CLUSTER_CREATED: |
| 535 // Not implemented |
| 536 RTC_NOTREACHED(); |
| 537 break; |
| 538 case EventType::BWE_PROBE_RESULT: |
| 539 // Not implemented |
| 540 RTC_NOTREACHED(); |
| 541 break; |
| 542 } |
| 543 } |
| 544 |
| 545 RtcEventLogTestHelper::VerifyLogEndEvent(parsed_log, |
| 546 parsed_log.GetNumberOfEvents() - 1); |
396 | 547 |
397 // Clean up temporary file - can be pretty slow. | 548 // Clean up temporary file - can be pretty slow. |
398 remove(temp_filename.c_str()); | 549 remove(temp_filename.c_str()); |
399 } | 550 } |
400 | 551 |
| 552 void SessionDescription::PrintExpectedEvents() { |
| 553 for (size_t i = 0; i < event_types.size(); i++) { |
| 554 switch (event_types[i]) { |
| 555 case EventType::INCOMING_RTP: |
| 556 printf("RTP(in) "); |
| 557 break; |
| 558 case EventType::OUTGOING_RTP: |
| 559 printf("RTP(out) "); |
| 560 break; |
| 561 case EventType::INCOMING_RTCP: |
| 562 printf("RTCP(in) "); |
| 563 break; |
| 564 case EventType::OUTGOING_RTCP: |
| 565 printf("RTCP(out) "); |
| 566 break; |
| 567 case EventType::AUDIO_PLAYOUT: |
| 568 printf("PLAYOUT "); |
| 569 break; |
| 570 case EventType::BWE_LOSS_UPDATE: |
| 571 printf("BWE_LOSS "); |
| 572 break; |
| 573 case EventType::BWE_DELAY_UPDATE: |
| 574 printf("BWE_DELAY "); |
| 575 break; |
| 576 case EventType::VIDEO_RECV_CONFIG: |
| 577 printf("VIDEO_RECV_CONFIG "); |
| 578 break; |
| 579 case EventType::VIDEO_SEND_CONFIG: |
| 580 printf("VIDEO_SEND_CONFIG "); |
| 581 break; |
| 582 case EventType::AUDIO_RECV_CONFIG: |
| 583 printf("AUDIO_RECV_CONFIG "); |
| 584 break; |
| 585 case EventType::AUDIO_SEND_CONFIG: |
| 586 printf("AUDIO_SEND_CONFIG "); |
| 587 break; |
| 588 case EventType::AUDIO_NETWORK_ADAPTATION: |
| 589 printf("ANA "); |
| 590 break; |
| 591 case EventType::BWE_PROBE_CLUSTER_CREATED: |
| 592 printf("BWE_PROBE_CREATED "); |
| 593 break; |
| 594 case EventType::BWE_PROBE_RESULT: |
| 595 printf("BWE_PROBE_RESULT "); |
| 596 break; |
| 597 } |
| 598 } |
| 599 printf("\n"); |
| 600 } |
| 601 |
| 602 void PrintActualEvents(const ParsedRtcEventLog& parsed_log) { |
| 603 for (size_t i = 0; i < parsed_log.GetNumberOfEvents(); i++) { |
| 604 switch (parsed_log.GetEventType(i)) { |
| 605 case ParsedRtcEventLog::EventType::UNKNOWN_EVENT: |
| 606 printf("UNKNOWN_EVENT "); |
| 607 break; |
| 608 case ParsedRtcEventLog::EventType::LOG_START: |
| 609 printf("LOG_START "); |
| 610 break; |
| 611 case ParsedRtcEventLog::EventType::LOG_END: |
| 612 printf("LOG_END "); |
| 613 break; |
| 614 case ParsedRtcEventLog::EventType::RTP_EVENT: |
| 615 printf("RTP_EVENT "); |
| 616 break; |
| 617 case ParsedRtcEventLog::EventType::RTCP_EVENT: |
| 618 printf("RTCP_EVENT "); |
| 619 break; |
| 620 case ParsedRtcEventLog::EventType::AUDIO_PLAYOUT_EVENT: |
| 621 printf("AUDIO_PLAYOUT_EVENT "); |
| 622 break; |
| 623 case ParsedRtcEventLog::EventType::LOSS_BASED_BWE_UPDATE: |
| 624 printf("LOSS_BASED_BWE_UPDATE "); |
| 625 break; |
| 626 case ParsedRtcEventLog::EventType::DELAY_BASED_BWE_UPDATE: |
| 627 printf("DELAY_BASED_BWE_UPDATE "); |
| 628 break; |
| 629 case ParsedRtcEventLog::EventType::VIDEO_RECEIVER_CONFIG_EVENT: |
| 630 printf("VIDEO_RECEIVER_CONFIG_EVET "); |
| 631 break; |
| 632 case ParsedRtcEventLog::EventType::VIDEO_SENDER_CONFIG_EVENT: |
| 633 printf("VIDEO_SENDER_CONFIG_EVENT "); |
| 634 break; |
| 635 case ParsedRtcEventLog::EventType::AUDIO_RECEIVER_CONFIG_EVENT: |
| 636 printf("AUDIO_RECEIVER_CONFIG_EVET "); |
| 637 break; |
| 638 case ParsedRtcEventLog::EventType::AUDIO_SENDER_CONFIG_EVENT: |
| 639 printf("AUDIO_SENDER_CONFIG_EVENT "); |
| 640 break; |
| 641 case ParsedRtcEventLog::EventType::AUDIO_NETWORK_ADAPTATION_EVENT: |
| 642 printf("AUDIO_NETWORK_ADAPTATION_EVENT "); |
| 643 break; |
| 644 case ParsedRtcEventLog::EventType::BWE_PROBE_CLUSTER_CREATED_EVENT: |
| 645 printf("BWE_PROBE_CLUSTER_CREATED_EVENT "); |
| 646 break; |
| 647 case ParsedRtcEventLog::EventType::BWE_PROBE_RESULT_EVENT: |
| 648 printf("BWE_PROBE_RESULT_EVENT "); |
| 649 break; |
| 650 } |
| 651 } |
| 652 printf("\n"); |
| 653 } |
| 654 |
401 TEST(RtcEventLogTest, LogSessionAndReadBack) { | 655 TEST(RtcEventLogTest, LogSessionAndReadBack) { |
402 // Log 5 RTP, 2 RTCP, 0 playout events and 0 BWE events | 656 RtpHeaderExtensionMap extensions; |
403 // with no header extensions or CSRCS. | 657 SessionDescription session(321 /*Random seed*/); |
404 LogSessionAndReadBack(5, 2, 0, 0, 0, 0, 321); | 658 session.GenerateSessionDescription(3, // Number of incoming RTP packets. |
405 | 659 2, // Number of outgoing RTP packets. |
406 // Enable AbsSendTime and TransportSequenceNumbers. | 660 1, // Number of incoming RTCP packets. |
407 uint32_t extensions = 0; | 661 1, // Number of outgoing RTCP packets. |
| 662 0, // Number of playout events. |
| 663 0, // Number of BWE loss events. |
| 664 0, // Number of BWE delay events. |
| 665 extensions, // No extensions. |
| 666 0); // Number of contributing sources. |
| 667 session.WriteSession(); |
| 668 session.ReadAndVerifySession(); |
| 669 } |
| 670 |
| 671 TEST(RtcEventLogTest, LogSessionAndReadBackWith2Extensions) { |
| 672 RtpHeaderExtensionMap extensions; |
| 673 extensions.Register(kRtpExtensionAbsoluteSendTime, |
| 674 kAbsoluteSendTimeExtensionId); |
| 675 extensions.Register(kRtpExtensionTransportSequenceNumber, |
| 676 kTransportSequenceNumberExtensionId); |
| 677 SessionDescription session(3141592653u /*Random seed*/); |
| 678 session.GenerateSessionDescription(4, 4, 1, 1, 0, 0, 0, extensions, 0); |
| 679 session.WriteSession(); |
| 680 session.ReadAndVerifySession(); |
| 681 } |
| 682 |
| 683 TEST(RtcEventLogTest, LogSessionAndReadBackWithAllExtensions) { |
| 684 RtpHeaderExtensionMap extensions; |
408 for (uint32_t i = 0; i < kNumExtensions; i++) { | 685 for (uint32_t i = 0; i < kNumExtensions; i++) { |
409 if (kExtensionTypes[i] == RTPExtensionType::kRtpExtensionAbsoluteSendTime || | 686 extensions.Register(kExtensionTypes[i], kExtensionIds[i]); |
410 kExtensionTypes[i] == | 687 } |
411 RTPExtensionType::kRtpExtensionTransportSequenceNumber) { | 688 SessionDescription session(2718281828u /*Random seed*/); |
412 extensions |= 1u << i; | 689 session.GenerateSessionDescription(5, 4, 1, 1, 3, 2, 2, extensions, 2); |
413 } | 690 session.WriteSession(); |
414 } | 691 session.ReadAndVerifySession(); |
415 LogSessionAndReadBack(8, 2, 0, 0, extensions, 0, 3141592653u); | 692 } |
416 | 693 |
417 extensions = (1u << kNumExtensions) - 1; // Enable all header extensions. | 694 TEST(RtcEventLogTest, LogSessionAndReadBackAllCombinations) { |
418 LogSessionAndReadBack(9, 2, 3, 2, extensions, 2, 2718281828u); | |
419 | |
420 // Try all combinations of header extensions and up to 2 CSRCS. | 695 // Try all combinations of header extensions and up to 2 CSRCS. |
421 for (extensions = 0; extensions < (1u << kNumExtensions); extensions++) { | 696 for (uint32_t extension_selection = 0; |
| 697 extension_selection < (1u << kNumExtensions); extension_selection++) { |
| 698 RtpHeaderExtensionMap extensions; |
| 699 for (uint32_t i = 0; i < kNumExtensions; i++) { |
| 700 if (extension_selection & (1u << i)) { |
| 701 extensions.Register(kExtensionTypes[i], kExtensionIds[i]); |
| 702 } |
| 703 } |
422 for (uint32_t csrcs_count = 0; csrcs_count < 3; csrcs_count++) { | 704 for (uint32_t csrcs_count = 0; csrcs_count < 3; csrcs_count++) { |
423 LogSessionAndReadBack(5 + extensions, // Number of RTP packets. | 705 SessionDescription session(extension_selection * 3 + csrcs_count + |
424 2 + csrcs_count, // Number of RTCP packets. | 706 1 /*Random seed*/); |
425 3 + csrcs_count, // Number of playout events. | 707 session.GenerateSessionDescription( |
426 1 + csrcs_count, // Number of BWE loss events. | 708 2 + extension_selection, // Number of incoming RTP packets. |
427 extensions, // Bit vector choosing extensions. | 709 2 + extension_selection, // Number of outgoing RTP packets. |
428 csrcs_count, // Number of contributing sources. | 710 1 + csrcs_count, // Number of incoming RTCP packets. |
429 extensions * 3 + csrcs_count + 1); // Random seed. | 711 1 + csrcs_count, // Number of outgoing RTCP packets. |
430 } | 712 3 + csrcs_count, // Number of playout events. |
431 } | 713 1 + csrcs_count, // Number of BWE loss events. |
432 } | 714 2 + csrcs_count, // Number of BWE delay events. |
| 715 extensions, // Bit vector choosing extensions. |
| 716 csrcs_count); // Number of contributing sources. |
| 717 session.WriteSession(); |
| 718 session.ReadAndVerifySession(); |
| 719 } |
| 720 } |
| 721 } |
433 | 722 |
434 TEST(RtcEventLogTest, LogEventAndReadBack) { | 723 TEST(RtcEventLogTest, LogEventAndReadBack) { |
435 Random prng(987654321); | 724 Random prng(987654321); |
436 | 725 |
437 // Create one RTP and one RTCP packet containing random data. | 726 // Create one RTP and one RTCP packet containing random data. |
438 size_t packet_size = prng.Rand(1000, 1100); | 727 size_t packet_size = prng.Rand(1000, 1100); |
439 RtpPacketToSend rtp_packet = | 728 RtpPacketReceived rtp_packet = |
440 GenerateRtpPacket(nullptr, 0, packet_size, &prng); | 729 GenerateIncomingRtpPacket(nullptr, 0, packet_size, &prng); |
441 rtc::Buffer rtcp_packet = GenerateRtcpPacket(&prng); | 730 rtc::Buffer rtcp_packet = GenerateRtcpPacket(&prng); |
442 | 731 |
443 // Find the name of the current test, in order to use it as a temporary | 732 // Find the name of the current test, in order to use it as a temporary |
444 // filename. | 733 // filename. |
445 auto test_info = ::testing::UnitTest::GetInstance()->current_test_info(); | 734 auto test_info = ::testing::UnitTest::GetInstance()->current_test_info(); |
446 const std::string temp_filename = | 735 const std::string temp_filename = |
447 test::OutputPath() + test_info->test_case_name() + test_info->name(); | 736 test::OutputPath() + test_info->test_case_name() + test_info->name(); |
448 | 737 |
449 // Add RTP, start logging, add RTCP and then stop logging | 738 // Add RTP, start logging, add RTCP and then stop logging |
450 rtc::ScopedFakeClock fake_clock; | 739 rtc::ScopedFakeClock fake_clock; |
451 fake_clock.SetTimeMicros(prng.Rand<uint32_t>()); | 740 fake_clock.SetTimeMicros(prng.Rand<uint32_t>()); |
452 std::unique_ptr<RtcEventLog> log_dumper(RtcEventLog::Create()); | 741 std::unique_ptr<RtcEventLog> log_dumper(RtcEventLog::Create()); |
453 | 742 |
454 log_dumper->LogRtpHeader(kIncomingPacket, rtp_packet.data(), | 743 log_dumper->LogIncomingRtpHeader(rtp_packet); |
455 rtp_packet.size()); | |
456 fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000)); | 744 fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000)); |
457 | 745 |
458 log_dumper->StartLogging(temp_filename, 10000000); | 746 log_dumper->StartLogging(temp_filename, 10000000); |
459 fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000)); | 747 fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000)); |
460 | 748 |
461 log_dumper->LogRtcpPacket(kOutgoingPacket, rtcp_packet.data(), | 749 log_dumper->LogOutgoingRtcpPacket(rtcp_packet); |
462 rtcp_packet.size()); | |
463 fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000)); | 750 fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000)); |
464 | 751 |
465 log_dumper->StopLogging(); | 752 log_dumper->StopLogging(); |
466 | 753 |
467 // Read the generated file from disk. | 754 // Read the generated file from disk. |
468 ParsedRtcEventLog parsed_log; | 755 ParsedRtcEventLog parsed_log; |
469 ASSERT_TRUE(parsed_log.ParseFile(temp_filename)); | 756 ASSERT_TRUE(parsed_log.ParseFile(temp_filename)); |
470 | 757 |
471 // Verify that what we read back from the event log is the same as | 758 // Verify that what we read back from the event log is the same as |
472 // what we wrote down. | 759 // what we wrote down. |
473 EXPECT_EQ(4u, parsed_log.GetNumberOfEvents()); | 760 EXPECT_EQ(4u, parsed_log.GetNumberOfEvents()); |
474 | 761 |
475 RtcEventLogTestHelper::VerifyLogStartEvent(parsed_log, 0); | 762 RtcEventLogTestHelper::VerifyLogStartEvent(parsed_log, 0); |
476 | 763 |
477 RtcEventLogTestHelper::VerifyRtpEvent( | 764 RtcEventLogTestHelper::VerifyRtpEvent(parsed_log, 1, kIncomingPacket, |
478 parsed_log, 1, kIncomingPacket, rtp_packet.data(), | 765 rtp_packet); |
479 rtp_packet.headers_size(), rtp_packet.size()); | |
480 | 766 |
481 RtcEventLogTestHelper::VerifyRtcpEvent( | 767 RtcEventLogTestHelper::VerifyRtcpEvent( |
482 parsed_log, 2, kOutgoingPacket, rtcp_packet.data(), rtcp_packet.size()); | 768 parsed_log, 2, kOutgoingPacket, rtcp_packet.data(), rtcp_packet.size()); |
483 | 769 |
484 RtcEventLogTestHelper::VerifyLogEndEvent(parsed_log, 3); | 770 RtcEventLogTestHelper::VerifyLogEndEvent(parsed_log, 3); |
485 | 771 |
486 // Clean up temporary file - can be pretty slow. | 772 // Clean up temporary file - can be pretty slow. |
487 remove(temp_filename.c_str()); | 773 remove(temp_filename.c_str()); |
488 } | 774 } |
489 | 775 |
(...skipping 224 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
714 RtcEventLogTestHelper::VerifyLogEndEvent(parsed_log, 4); | 1000 RtcEventLogTestHelper::VerifyLogEndEvent(parsed_log, 4); |
715 | 1001 |
716 // Clean up temporary file - can be pretty slow. | 1002 // Clean up temporary file - can be pretty slow. |
717 remove(temp_filename.c_str()); | 1003 remove(temp_filename.c_str()); |
718 } | 1004 } |
719 | 1005 |
720 class ConfigReadWriteTest { | 1006 class ConfigReadWriteTest { |
721 public: | 1007 public: |
722 ConfigReadWriteTest() : prng(987654321) {} | 1008 ConfigReadWriteTest() : prng(987654321) {} |
723 virtual ~ConfigReadWriteTest() {} | 1009 virtual ~ConfigReadWriteTest() {} |
724 virtual void GenerateConfig(uint32_t extensions_bitvector) = 0; | 1010 virtual void GenerateConfig(const RtpHeaderExtensionMap& extensions) = 0; |
725 virtual void VerifyConfig(const ParsedRtcEventLog& parsed_log, | 1011 virtual void VerifyConfig(const ParsedRtcEventLog& parsed_log, |
726 size_t index) = 0; | 1012 size_t index) = 0; |
727 virtual void LogConfig(RtcEventLog* event_log) = 0; | 1013 virtual void LogConfig(RtcEventLog* event_log) = 0; |
728 | 1014 |
729 void DoTest() { | 1015 void DoTest() { |
730 // Find the name of the current test, in order to use it as a temporary | 1016 // Find the name of the current test, in order to use it as a temporary |
731 // filename. | 1017 // filename. |
732 auto test_info = ::testing::UnitTest::GetInstance()->current_test_info(); | 1018 auto test_info = ::testing::UnitTest::GetInstance()->current_test_info(); |
733 const std::string temp_filename = | 1019 const std::string temp_filename = |
734 test::OutputPath() + test_info->test_case_name() + test_info->name(); | 1020 test::OutputPath() + test_info->test_case_name() + test_info->name(); |
735 | 1021 |
736 // Use all extensions. | 1022 // Use all extensions. |
737 uint32_t extensions_bitvector = (1u << kNumExtensions) - 1; | 1023 RtpHeaderExtensionMap extensions; |
738 GenerateConfig(extensions_bitvector); | 1024 for (uint32_t i = 0; i < kNumExtensions; i++) { |
| 1025 extensions.Register(kExtensionTypes[i], kExtensionIds[i]); |
| 1026 } |
| 1027 GenerateConfig(extensions); |
739 | 1028 |
740 // Log a single config event and stop logging. | 1029 // Log a single config event and stop logging. |
741 rtc::ScopedFakeClock fake_clock; | 1030 rtc::ScopedFakeClock fake_clock; |
742 fake_clock.SetTimeMicros(prng.Rand<uint32_t>()); | 1031 fake_clock.SetTimeMicros(prng.Rand<uint32_t>()); |
743 std::unique_ptr<RtcEventLog> log_dumper(RtcEventLog::Create()); | 1032 std::unique_ptr<RtcEventLog> log_dumper(RtcEventLog::Create()); |
744 | 1033 |
745 log_dumper->StartLogging(temp_filename, 10000000); | 1034 log_dumper->StartLogging(temp_filename, 10000000); |
746 LogConfig(log_dumper.get()); | 1035 LogConfig(log_dumper.get()); |
747 log_dumper->StopLogging(); | 1036 log_dumper->StopLogging(); |
748 | 1037 |
(...skipping 12 matching lines...) Expand all Loading... |
761 RtcEventLogTestHelper::VerifyLogEndEvent(parsed_log, 2); | 1050 RtcEventLogTestHelper::VerifyLogEndEvent(parsed_log, 2); |
762 | 1051 |
763 // Clean up temporary file - can be pretty slow. | 1052 // Clean up temporary file - can be pretty slow. |
764 remove(temp_filename.c_str()); | 1053 remove(temp_filename.c_str()); |
765 } | 1054 } |
766 Random prng; | 1055 Random prng; |
767 }; | 1056 }; |
768 | 1057 |
769 class AudioReceiveConfigReadWriteTest : public ConfigReadWriteTest { | 1058 class AudioReceiveConfigReadWriteTest : public ConfigReadWriteTest { |
770 public: | 1059 public: |
771 void GenerateConfig(uint32_t extensions_bitvector) override { | 1060 void GenerateConfig(const RtpHeaderExtensionMap& extensions) override { |
772 GenerateAudioReceiveConfig(extensions_bitvector, &config, &prng); | 1061 GenerateAudioReceiveConfig(extensions, &config, &prng); |
773 } | 1062 } |
774 void LogConfig(RtcEventLog* event_log) override { | 1063 void LogConfig(RtcEventLog* event_log) override { |
775 event_log->LogAudioReceiveStreamConfig(config); | 1064 event_log->LogAudioReceiveStreamConfig(config); |
776 } | 1065 } |
777 void VerifyConfig(const ParsedRtcEventLog& parsed_log, | 1066 void VerifyConfig(const ParsedRtcEventLog& parsed_log, |
778 size_t index) override { | 1067 size_t index) override { |
779 RtcEventLogTestHelper::VerifyAudioReceiveStreamConfig(parsed_log, index, | 1068 RtcEventLogTestHelper::VerifyAudioReceiveStreamConfig(parsed_log, index, |
780 config); | 1069 config); |
781 } | 1070 } |
782 rtclog::StreamConfig config; | 1071 rtclog::StreamConfig config; |
783 }; | 1072 }; |
784 | 1073 |
785 class AudioSendConfigReadWriteTest : public ConfigReadWriteTest { | 1074 class AudioSendConfigReadWriteTest : public ConfigReadWriteTest { |
786 public: | 1075 public: |
787 AudioSendConfigReadWriteTest() {} | 1076 AudioSendConfigReadWriteTest() {} |
788 void GenerateConfig(uint32_t extensions_bitvector) override { | 1077 void GenerateConfig(const RtpHeaderExtensionMap& extensions) override { |
789 GenerateAudioSendConfig(extensions_bitvector, &config, &prng); | 1078 GenerateAudioSendConfig(extensions, &config, &prng); |
790 } | 1079 } |
791 void LogConfig(RtcEventLog* event_log) override { | 1080 void LogConfig(RtcEventLog* event_log) override { |
792 event_log->LogAudioSendStreamConfig(config); | 1081 event_log->LogAudioSendStreamConfig(config); |
793 } | 1082 } |
794 void VerifyConfig(const ParsedRtcEventLog& parsed_log, | 1083 void VerifyConfig(const ParsedRtcEventLog& parsed_log, |
795 size_t index) override { | 1084 size_t index) override { |
796 RtcEventLogTestHelper::VerifyAudioSendStreamConfig(parsed_log, index, | 1085 RtcEventLogTestHelper::VerifyAudioSendStreamConfig(parsed_log, index, |
797 config); | 1086 config); |
798 } | 1087 } |
799 rtclog::StreamConfig config; | 1088 rtclog::StreamConfig config; |
800 }; | 1089 }; |
801 | 1090 |
802 class VideoReceiveConfigReadWriteTest : public ConfigReadWriteTest { | 1091 class VideoReceiveConfigReadWriteTest : public ConfigReadWriteTest { |
803 public: | 1092 public: |
804 VideoReceiveConfigReadWriteTest() {} | 1093 VideoReceiveConfigReadWriteTest() {} |
805 void GenerateConfig(uint32_t extensions_bitvector) override { | 1094 void GenerateConfig(const RtpHeaderExtensionMap& extensions) override { |
806 GenerateVideoReceiveConfig(extensions_bitvector, &config, &prng); | 1095 GenerateVideoReceiveConfig(extensions, &config, &prng); |
807 } | 1096 } |
808 void LogConfig(RtcEventLog* event_log) override { | 1097 void LogConfig(RtcEventLog* event_log) override { |
809 event_log->LogVideoReceiveStreamConfig(config); | 1098 event_log->LogVideoReceiveStreamConfig(config); |
810 } | 1099 } |
811 void VerifyConfig(const ParsedRtcEventLog& parsed_log, | 1100 void VerifyConfig(const ParsedRtcEventLog& parsed_log, |
812 size_t index) override { | 1101 size_t index) override { |
813 RtcEventLogTestHelper::VerifyVideoReceiveStreamConfig(parsed_log, index, | 1102 RtcEventLogTestHelper::VerifyVideoReceiveStreamConfig(parsed_log, index, |
814 config); | 1103 config); |
815 } | 1104 } |
816 rtclog::StreamConfig config; | 1105 rtclog::StreamConfig config; |
817 }; | 1106 }; |
818 | 1107 |
819 class VideoSendConfigReadWriteTest : public ConfigReadWriteTest { | 1108 class VideoSendConfigReadWriteTest : public ConfigReadWriteTest { |
820 public: | 1109 public: |
821 VideoSendConfigReadWriteTest() {} | 1110 VideoSendConfigReadWriteTest() {} |
822 void GenerateConfig(uint32_t extensions_bitvector) override { | 1111 void GenerateConfig(const RtpHeaderExtensionMap& extensions) override { |
823 GenerateVideoSendConfig(extensions_bitvector, &config, &prng); | 1112 GenerateVideoSendConfig(extensions, &config, &prng); |
824 } | 1113 } |
825 void LogConfig(RtcEventLog* event_log) override { | 1114 void LogConfig(RtcEventLog* event_log) override { |
826 event_log->LogVideoSendStreamConfig(config); | 1115 event_log->LogVideoSendStreamConfig(config); |
827 } | 1116 } |
828 void VerifyConfig(const ParsedRtcEventLog& parsed_log, | 1117 void VerifyConfig(const ParsedRtcEventLog& parsed_log, |
829 size_t index) override { | 1118 size_t index) override { |
830 RtcEventLogTestHelper::VerifyVideoSendStreamConfig(parsed_log, index, | 1119 RtcEventLogTestHelper::VerifyVideoSendStreamConfig(parsed_log, index, |
831 config); | 1120 config); |
832 } | 1121 } |
833 rtclog::StreamConfig config; | 1122 rtclog::StreamConfig config; |
834 }; | 1123 }; |
835 | 1124 |
836 class AudioNetworkAdaptationReadWriteTest : public ConfigReadWriteTest { | 1125 class AudioNetworkAdaptationReadWriteTest : public ConfigReadWriteTest { |
837 public: | 1126 public: |
838 void GenerateConfig(uint32_t extensions_bitvector) override { | 1127 void GenerateConfig(const RtpHeaderExtensionMap& extensions) override { |
839 GenerateAudioNetworkAdaptation(extensions_bitvector, &config, &prng); | 1128 GenerateAudioNetworkAdaptation(extensions, &config, &prng); |
840 } | 1129 } |
841 void LogConfig(RtcEventLog* event_log) override { | 1130 void LogConfig(RtcEventLog* event_log) override { |
842 event_log->LogAudioNetworkAdaptation(config); | 1131 event_log->LogAudioNetworkAdaptation(config); |
843 } | 1132 } |
844 void VerifyConfig(const ParsedRtcEventLog& parsed_log, | 1133 void VerifyConfig(const ParsedRtcEventLog& parsed_log, |
845 size_t index) override { | 1134 size_t index) override { |
846 RtcEventLogTestHelper::VerifyAudioNetworkAdaptation(parsed_log, index, | 1135 RtcEventLogTestHelper::VerifyAudioNetworkAdaptation(parsed_log, index, |
847 config); | 1136 config); |
848 } | 1137 } |
849 AudioEncoderRuntimeConfig config; | 1138 AudioEncoderRuntimeConfig config; |
(...skipping 18 matching lines...) Expand all Loading... |
868 VideoSendConfigReadWriteTest test; | 1157 VideoSendConfigReadWriteTest test; |
869 test.DoTest(); | 1158 test.DoTest(); |
870 } | 1159 } |
871 | 1160 |
872 TEST(RtcEventLogTest, LogAudioNetworkAdaptation) { | 1161 TEST(RtcEventLogTest, LogAudioNetworkAdaptation) { |
873 AudioNetworkAdaptationReadWriteTest test; | 1162 AudioNetworkAdaptationReadWriteTest test; |
874 test.DoTest(); | 1163 test.DoTest(); |
875 } | 1164 } |
876 | 1165 |
877 } // namespace webrtc | 1166 } // namespace webrtc |
OLD | NEW |