1 // Copyright 2014 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "media/cast/logging/receiver_time_offset_estimator_impl.h"
6
7 #include <stdint.h>
8
9 #include <memory>
10 #include <utility>
11
12 #include "base/memory/ref_counted.h"
13 #include "base/test/simple_test_tick_clock.h"
14 #include "base/time/tick_clock.h"
15 #include "media/base/fake_single_thread_task_runner.h"
16 #include "media/cast/cast_environment.h"
17 #include "media/cast/logging/logging_defines.h"
18 #include "testing/gtest/include/gtest/gtest.h"
19
20 namespace media {
21 namespace cast {
22
23 class ReceiverTimeOffsetEstimatorImplTest : public ::testing::Test {
24 protected:
ReceiverTimeOffsetEstimatorImplTest()25 ReceiverTimeOffsetEstimatorImplTest()
26 : task_runner_(new FakeSingleThreadTaskRunner(&sender_clock_)),
27 cast_environment_(new CastEnvironment(&sender_clock_,
28 task_runner_,
29 task_runner_,
30 task_runner_)) {
31 cast_environment_->logger()->Subscribe(&estimator_);
32 }
33
~ReceiverTimeOffsetEstimatorImplTest()34 ~ReceiverTimeOffsetEstimatorImplTest() override {
35 cast_environment_->logger()->Unsubscribe(&estimator_);
36 }
37
AdvanceClocks(base::TimeDelta time)38 void AdvanceClocks(base::TimeDelta time) {
39 task_runner_->Sleep(time);
40 receiver_clock_.Advance(time);
41 }
42
43 base::SimpleTestTickClock sender_clock_;
44 scoped_refptr<FakeSingleThreadTaskRunner> task_runner_;
45 scoped_refptr<CastEnvironment> cast_environment_;
46 base::SimpleTestTickClock receiver_clock_;
47 ReceiverTimeOffsetEstimatorImpl estimator_;
48 };
49
50 // Suppose the true offset is 100ms.
51 // Event A occurred at sender time 20ms.
52 // Event B occurred at receiver time 130ms. (sender time 30ms)
53 // Event C occurred at sender time 60ms.
54 // Then the bound after all 3 events have arrived is [130-60=70, 130-20=110].
TEST_F(ReceiverTimeOffsetEstimatorImplTest,EstimateOffset)55 TEST_F(ReceiverTimeOffsetEstimatorImplTest, EstimateOffset) {
56 int64_t true_offset_ms = 100;
57 receiver_clock_.Advance(base::TimeDelta::FromMilliseconds(true_offset_ms));
58
59 base::TimeDelta lower_bound;
60 base::TimeDelta upper_bound;
61
62 EXPECT_FALSE(estimator_.GetReceiverOffsetBounds(&lower_bound, &upper_bound));
63
64 const RtpTimeTicks rtp_timestamp;
65 FrameId frame_id = FrameId::first();
66
67 AdvanceClocks(base::TimeDelta::FromMilliseconds(20));
68
69 std::unique_ptr<FrameEvent> encode_event(new FrameEvent());
70 encode_event->timestamp = sender_clock_.NowTicks();
71 encode_event->type = FRAME_ENCODED;
72 encode_event->media_type = VIDEO_EVENT;
73 encode_event->rtp_timestamp = rtp_timestamp;
74 encode_event->frame_id = frame_id;
75 encode_event->size = 1234;
76 encode_event->key_frame = true;
77 encode_event->target_bitrate = 5678;
78 encode_event->encoder_cpu_utilization = 9.10;
79 encode_event->idealized_bitrate_utilization = 11.12;
80 cast_environment_->logger()->DispatchFrameEvent(std::move(encode_event));
81
82 std::unique_ptr<PacketEvent> send_event(new PacketEvent());
83 send_event->timestamp = sender_clock_.NowTicks();
84 send_event->type = PACKET_SENT_TO_NETWORK;
85 send_event->media_type = VIDEO_EVENT;
86 send_event->rtp_timestamp = rtp_timestamp;
87 send_event->frame_id = frame_id;
88 send_event->packet_id = 56;
89 send_event->max_packet_id = 78;
90 send_event->size = 1500;
91 cast_environment_->logger()->DispatchPacketEvent(std::move(send_event));
92
93 EXPECT_FALSE(estimator_.GetReceiverOffsetBounds(&lower_bound, &upper_bound));
94
95 AdvanceClocks(base::TimeDelta::FromMilliseconds(10));
96 std::unique_ptr<FrameEvent> ack_sent_event(new FrameEvent());
97 ack_sent_event->timestamp = receiver_clock_.NowTicks();
98 ack_sent_event->type = FRAME_ACK_SENT;
99 ack_sent_event->media_type = VIDEO_EVENT;
100 ack_sent_event->rtp_timestamp = rtp_timestamp;
101 ack_sent_event->frame_id = frame_id;
102 cast_environment_->logger()->DispatchFrameEvent(std::move(ack_sent_event));
103
104 std::unique_ptr<PacketEvent> receive_event(new PacketEvent());
105 receive_event->timestamp = receiver_clock_.NowTicks();
106 receive_event->type = PACKET_RECEIVED;
107 receive_event->media_type = VIDEO_EVENT;
108 receive_event->rtp_timestamp = rtp_timestamp;
109 receive_event->frame_id = frame_id;
110 receive_event->packet_id = 56;
111 receive_event->max_packet_id = 78;
112 receive_event->size = 1500;
113 cast_environment_->logger()->DispatchPacketEvent(std::move(receive_event));
114
115 EXPECT_FALSE(estimator_.GetReceiverOffsetBounds(&lower_bound, &upper_bound));
116
117 AdvanceClocks(base::TimeDelta::FromMilliseconds(30));
118 std::unique_ptr<FrameEvent> ack_event(new FrameEvent());
119 ack_event->timestamp = sender_clock_.NowTicks();
120 ack_event->type = FRAME_ACK_RECEIVED;
121 ack_event->media_type = VIDEO_EVENT;
122 ack_event->rtp_timestamp = rtp_timestamp;
123 ack_event->frame_id = frame_id;
124 cast_environment_->logger()->DispatchFrameEvent(std::move(ack_event));
125
126 EXPECT_TRUE(estimator_.GetReceiverOffsetBounds(&lower_bound, &upper_bound));
127
128 int64_t lower_bound_ms = lower_bound.InMilliseconds();
129 int64_t upper_bound_ms = upper_bound.InMilliseconds();
130 EXPECT_EQ(70, lower_bound_ms);
131 EXPECT_EQ(110, upper_bound_ms);
132 EXPECT_GE(true_offset_ms, lower_bound_ms);
133 EXPECT_LE(true_offset_ms, upper_bound_ms);
134 }
135
136 // Same scenario as above, but event C arrives before event B. It doesn't mean
137 // event C occurred before event B.
TEST_F(ReceiverTimeOffsetEstimatorImplTest,EventCArrivesBeforeEventB)138 TEST_F(ReceiverTimeOffsetEstimatorImplTest, EventCArrivesBeforeEventB) {
139 int64_t true_offset_ms = 100;
140 receiver_clock_.Advance(base::TimeDelta::FromMilliseconds(true_offset_ms));
141
142 base::TimeDelta lower_bound;
143 base::TimeDelta upper_bound;
144
145 EXPECT_FALSE(estimator_.GetReceiverOffsetBounds(&lower_bound, &upper_bound));
146
147 const RtpTimeTicks rtp_timestamp;
148 FrameId frame_id = FrameId::first();
149
150 AdvanceClocks(base::TimeDelta::FromMilliseconds(20));
151
152 std::unique_ptr<FrameEvent> encode_event(new FrameEvent());
153 encode_event->timestamp = sender_clock_.NowTicks();
154 encode_event->type = FRAME_ENCODED;
155 encode_event->media_type = VIDEO_EVENT;
156 encode_event->rtp_timestamp = rtp_timestamp;
157 encode_event->frame_id = frame_id;
158 encode_event->size = 1234;
159 encode_event->key_frame = true;
160 encode_event->target_bitrate = 5678;
161 encode_event->encoder_cpu_utilization = 9.10;
162 encode_event->idealized_bitrate_utilization = 11.12;
163 cast_environment_->logger()->DispatchFrameEvent(std::move(encode_event));
164
165 std::unique_ptr<PacketEvent> send_event(new PacketEvent());
166 send_event->timestamp = sender_clock_.NowTicks();
167 send_event->type = PACKET_SENT_TO_NETWORK;
168 send_event->media_type = VIDEO_EVENT;
169 send_event->rtp_timestamp = rtp_timestamp;
170 send_event->frame_id = frame_id;
171 send_event->packet_id = 56;
172 send_event->max_packet_id = 78;
173 send_event->size = 1500;
174 cast_environment_->logger()->DispatchPacketEvent(std::move(send_event));
175
176 EXPECT_FALSE(estimator_.GetReceiverOffsetBounds(&lower_bound, &upper_bound));
177
178 AdvanceClocks(base::TimeDelta::FromMilliseconds(10));
179 base::TimeTicks event_b_time = receiver_clock_.NowTicks();
180 AdvanceClocks(base::TimeDelta::FromMilliseconds(30));
181 base::TimeTicks event_c_time = sender_clock_.NowTicks();
182
183 std::unique_ptr<FrameEvent> ack_event(new FrameEvent());
184 ack_event->timestamp = event_c_time;
185 ack_event->type = FRAME_ACK_RECEIVED;
186 ack_event->media_type = VIDEO_EVENT;
187 ack_event->rtp_timestamp = rtp_timestamp;
188 ack_event->frame_id = frame_id;
189 cast_environment_->logger()->DispatchFrameEvent(std::move(ack_event));
190
191 EXPECT_FALSE(estimator_.GetReceiverOffsetBounds(&lower_bound, &upper_bound));
192
193 std::unique_ptr<PacketEvent> receive_event(new PacketEvent());
194 receive_event->timestamp = event_b_time;
195 receive_event->type = PACKET_RECEIVED;
196 receive_event->media_type = VIDEO_EVENT;
197 receive_event->rtp_timestamp = rtp_timestamp;
198 receive_event->frame_id = frame_id;
199 receive_event->packet_id = 56;
200 receive_event->max_packet_id = 78;
201 receive_event->size = 1500;
202 cast_environment_->logger()->DispatchPacketEvent(std::move(receive_event));
203
204 std::unique_ptr<FrameEvent> ack_sent_event(new FrameEvent());
205 ack_sent_event->timestamp = event_b_time;
206 ack_sent_event->type = FRAME_ACK_SENT;
207 ack_sent_event->media_type = VIDEO_EVENT;
208 ack_sent_event->rtp_timestamp = rtp_timestamp;
209 ack_sent_event->frame_id = frame_id;
210 cast_environment_->logger()->DispatchFrameEvent(std::move(ack_sent_event));
211
212 EXPECT_TRUE(estimator_.GetReceiverOffsetBounds(&lower_bound, &upper_bound));
213
214 int64_t lower_bound_ms = lower_bound.InMilliseconds();
215 int64_t upper_bound_ms = upper_bound.InMilliseconds();
216 EXPECT_EQ(70, lower_bound_ms);
217 EXPECT_EQ(110, upper_bound_ms);
218 EXPECT_GE(true_offset_ms, lower_bound_ms);
219 EXPECT_LE(true_offset_ms, upper_bound_ms);
220 }
221
TEST_F(ReceiverTimeOffsetEstimatorImplTest,MultipleIterations)222 TEST_F(ReceiverTimeOffsetEstimatorImplTest, MultipleIterations) {
223 int64_t true_offset_ms = 100;
224 receiver_clock_.Advance(base::TimeDelta::FromMilliseconds(true_offset_ms));
225
226 base::TimeDelta lower_bound;
227 base::TimeDelta upper_bound;
228
229 const RtpTimeTicks rtp_timestamp_a;
230 FrameId frame_id_a = FrameId::first();
231 const RtpTimeTicks rtp_timestamp_b =
232 rtp_timestamp_a + RtpTimeDelta::FromTicks(90);
233 FrameId frame_id_b = frame_id_a + 1;
234 const RtpTimeTicks rtp_timestamp_c =
235 rtp_timestamp_b + RtpTimeDelta::FromTicks(90);
236 FrameId frame_id_c = frame_id_b + 1;
237
238 // Frame 1 times: [20, 30+100, 60]
239 // Frame 2 times: [30, 50+100, 55]
240 // Frame 3 times: [77, 80+100, 110]
241 // Bound should end up at [95, 103]
242 // Events times in chronological order: 20, 30 x2, 50, 55, 60, 77, 80, 110
243 AdvanceClocks(base::TimeDelta::FromMilliseconds(20));
244 std::unique_ptr<FrameEvent> encode_event(new FrameEvent());
245 encode_event->timestamp = sender_clock_.NowTicks();
246 encode_event->type = FRAME_ENCODED;
247 encode_event->media_type = VIDEO_EVENT;
248 encode_event->rtp_timestamp = rtp_timestamp_a;
249 encode_event->frame_id = frame_id_a;
250 encode_event->size = 1234;
251 encode_event->key_frame = true;
252 encode_event->target_bitrate = 5678;
253 encode_event->encoder_cpu_utilization = 9.10;
254 encode_event->idealized_bitrate_utilization = 11.12;
255 cast_environment_->logger()->DispatchFrameEvent(std::move(encode_event));
256
257 std::unique_ptr<PacketEvent> send_event(new PacketEvent());
258 send_event->timestamp = sender_clock_.NowTicks();
259 send_event->type = PACKET_SENT_TO_NETWORK;
260 send_event->media_type = VIDEO_EVENT;
261 send_event->rtp_timestamp = rtp_timestamp_a;
262 send_event->frame_id = frame_id_a;
263 send_event->packet_id = 56;
264 send_event->max_packet_id = 78;
265 send_event->size = 1500;
266 cast_environment_->logger()->DispatchPacketEvent(std::move(send_event));
267
268 AdvanceClocks(base::TimeDelta::FromMilliseconds(10));
269 encode_event.reset(new FrameEvent());
270 encode_event->timestamp = sender_clock_.NowTicks();
271 encode_event->type = FRAME_ENCODED;
272 encode_event->media_type = VIDEO_EVENT;
273 encode_event->rtp_timestamp = rtp_timestamp_b;
274 encode_event->frame_id = frame_id_b;
275 encode_event->size = 1234;
276 encode_event->key_frame = true;
277 encode_event->target_bitrate = 5678;
278 encode_event->encoder_cpu_utilization = 9.10;
279 encode_event->idealized_bitrate_utilization = 11.12;
280 cast_environment_->logger()->DispatchFrameEvent(std::move(encode_event));
281
282 send_event.reset(new PacketEvent());
283 send_event->timestamp = sender_clock_.NowTicks();
284 send_event->type = PACKET_SENT_TO_NETWORK;
285 send_event->media_type = VIDEO_EVENT;
286 send_event->rtp_timestamp = rtp_timestamp_b;
287 send_event->frame_id = frame_id_b;
288 send_event->packet_id = 56;
289 send_event->max_packet_id = 78;
290 send_event->size = 1500;
291 cast_environment_->logger()->DispatchPacketEvent(std::move(send_event));
292
293 std::unique_ptr<FrameEvent> ack_sent_event(new FrameEvent());
294 ack_sent_event->timestamp = receiver_clock_.NowTicks();
295 ack_sent_event->type = FRAME_ACK_SENT;
296 ack_sent_event->media_type = VIDEO_EVENT;
297 ack_sent_event->rtp_timestamp = rtp_timestamp_a;
298 ack_sent_event->frame_id = frame_id_a;
299 cast_environment_->logger()->DispatchFrameEvent(std::move(ack_sent_event));
300
301 AdvanceClocks(base::TimeDelta::FromMilliseconds(20));
302
303 std::unique_ptr<PacketEvent> receive_event(new PacketEvent());
304 receive_event->timestamp = receiver_clock_.NowTicks();
305 receive_event->type = PACKET_RECEIVED;
306 receive_event->media_type = VIDEO_EVENT;
307 receive_event->rtp_timestamp = rtp_timestamp_b;
308 receive_event->frame_id = frame_id_b;
309 receive_event->packet_id = 56;
310 receive_event->max_packet_id = 78;
311 receive_event->size = 1500;
312 cast_environment_->logger()->DispatchPacketEvent(std::move(receive_event));
313
314 ack_sent_event.reset(new FrameEvent());
315 ack_sent_event->timestamp = receiver_clock_.NowTicks();
316 ack_sent_event->type = FRAME_ACK_SENT;
317 ack_sent_event->media_type = VIDEO_EVENT;
318 ack_sent_event->rtp_timestamp = rtp_timestamp_b;
319 ack_sent_event->frame_id = frame_id_b;
320 cast_environment_->logger()->DispatchFrameEvent(std::move(ack_sent_event));
321
322 AdvanceClocks(base::TimeDelta::FromMilliseconds(5));
323 std::unique_ptr<FrameEvent> ack_event(new FrameEvent());
324 ack_event->timestamp = sender_clock_.NowTicks();
325 ack_event->type = FRAME_ACK_RECEIVED;
326 ack_event->media_type = VIDEO_EVENT;
327 ack_event->rtp_timestamp = rtp_timestamp_b;
328 ack_event->frame_id = frame_id_b;
329 cast_environment_->logger()->DispatchFrameEvent(std::move(ack_event));
330
331 AdvanceClocks(base::TimeDelta::FromMilliseconds(5));
332 ack_event.reset(new FrameEvent());
333 ack_event->timestamp = sender_clock_.NowTicks();
334 ack_event->type = FRAME_ACK_RECEIVED;
335 ack_event->media_type = VIDEO_EVENT;
336 ack_event->rtp_timestamp = rtp_timestamp_a;
337 ack_event->frame_id = frame_id_a;
338 cast_environment_->logger()->DispatchFrameEvent(std::move(ack_event));
339
340 AdvanceClocks(base::TimeDelta::FromMilliseconds(17));
341 encode_event.reset(new FrameEvent());
342 encode_event->timestamp = sender_clock_.NowTicks();
343 encode_event->type = FRAME_ENCODED;
344 encode_event->media_type = VIDEO_EVENT;
345 encode_event->rtp_timestamp = rtp_timestamp_c;
346 encode_event->frame_id = frame_id_c;
347 encode_event->size = 1234;
348 encode_event->key_frame = true;
349 encode_event->target_bitrate = 5678;
350 encode_event->encoder_cpu_utilization = 9.10;
351 encode_event->idealized_bitrate_utilization = 11.12;
352 cast_environment_->logger()->DispatchFrameEvent(std::move(encode_event));
353
354 send_event.reset(new PacketEvent());
355 send_event->timestamp = sender_clock_.NowTicks();
356 send_event->type = PACKET_SENT_TO_NETWORK;
357 send_event->media_type = VIDEO_EVENT;
358 send_event->rtp_timestamp = rtp_timestamp_c;
359 send_event->frame_id = frame_id_c;
360 send_event->packet_id = 56;
361 send_event->max_packet_id = 78;
362 send_event->size = 1500;
363 cast_environment_->logger()->DispatchPacketEvent(std::move(send_event));
364
365 AdvanceClocks(base::TimeDelta::FromMilliseconds(3));
366 receive_event.reset(new PacketEvent());
367 receive_event->timestamp = receiver_clock_.NowTicks();
368 receive_event->type = PACKET_RECEIVED;
369 receive_event->media_type = VIDEO_EVENT;
370 receive_event->rtp_timestamp = rtp_timestamp_c;
371 receive_event->frame_id = frame_id_c;
372 receive_event->packet_id = 56;
373 receive_event->max_packet_id = 78;
374 receive_event->size = 1500;
375 cast_environment_->logger()->DispatchPacketEvent(std::move(receive_event));
376
377 ack_sent_event.reset(new FrameEvent());
378 ack_sent_event->timestamp = receiver_clock_.NowTicks();
379 ack_sent_event->type = FRAME_ACK_SENT;
380 ack_sent_event->media_type = VIDEO_EVENT;
381 ack_sent_event->rtp_timestamp = rtp_timestamp_c;
382 ack_sent_event->frame_id = frame_id_c;
383 cast_environment_->logger()->DispatchFrameEvent(std::move(ack_sent_event));
384
385 AdvanceClocks(base::TimeDelta::FromMilliseconds(30));
386 ack_event.reset(new FrameEvent());
387 ack_event->timestamp = sender_clock_.NowTicks();
388 ack_event->type = FRAME_ACK_RECEIVED;
389 ack_event->media_type = VIDEO_EVENT;
390 ack_event->rtp_timestamp = rtp_timestamp_c;
391 ack_event->frame_id = frame_id_c;
392 cast_environment_->logger()->DispatchFrameEvent(std::move(ack_event));
393
394 EXPECT_TRUE(estimator_.GetReceiverOffsetBounds(&lower_bound, &upper_bound));
395 int64_t lower_bound_ms = lower_bound.InMilliseconds();
396 int64_t upper_bound_ms = upper_bound.InMilliseconds();
397 EXPECT_GT(lower_bound_ms, 90);
398 EXPECT_LE(lower_bound_ms, true_offset_ms);
399 EXPECT_LT(upper_bound_ms, 150);
400 EXPECT_GT(upper_bound_ms, true_offset_ms);
401 }
402
403 } // namespace cast
404 } // namespace media
405