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