audio_clock_unittest.cc 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377
  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. #include "media/filters/audio_clock.h"
  5. #include <memory>
  6. #include "base/time/time.h"
  7. #include "media/base/audio_timestamp_helper.h"
  8. #include "testing/gtest/include/gtest/gtest.h"
  9. namespace media {
  10. class AudioClockTest : public testing::Test {
  11. public:
  12. AudioClockTest() { SetupClock(base::TimeDelta(), 10); }
  13. AudioClockTest(const AudioClockTest&) = delete;
  14. AudioClockTest& operator=(const AudioClockTest&) = delete;
  15. ~AudioClockTest() override = default;
  16. void WroteAudio(int frames_written,
  17. int frames_requested,
  18. int delay_frames,
  19. double playback_rate) {
  20. clock_->WroteAudio(frames_written, frames_requested, delay_frames,
  21. playback_rate);
  22. }
  23. void SetupClock(base::TimeDelta start_time, int sample_rate) {
  24. sample_rate_ = sample_rate;
  25. clock_ = std::make_unique<AudioClock>(start_time, sample_rate_);
  26. }
  27. int FrontTimestampInDays() { return clock_->front_timestamp().InDays(); }
  28. int FrontTimestampInMilliseconds() {
  29. return clock_->front_timestamp().InMilliseconds();
  30. }
  31. int BackTimestampInMilliseconds() {
  32. return clock_->back_timestamp().InMilliseconds();
  33. }
  34. int TimeUntilPlaybackInMilliseconds(int timestamp_ms) {
  35. return clock_->TimeUntilPlayback(base::Milliseconds(timestamp_ms))
  36. .InMilliseconds();
  37. }
  38. int ContiguousAudioDataBufferedInDays() {
  39. base::TimeDelta total, same_rate_total;
  40. clock_->ContiguousAudioDataBufferedForTesting(&total, &same_rate_total);
  41. return total.InDays();
  42. }
  43. int ContiguousAudioDataBufferedInMilliseconds() {
  44. base::TimeDelta total, same_rate_total;
  45. clock_->ContiguousAudioDataBufferedForTesting(&total, &same_rate_total);
  46. return total.InMilliseconds();
  47. }
  48. int ContiguousAudioDataBufferedAtSameRateInMilliseconds() {
  49. base::TimeDelta total, same_rate_total;
  50. clock_->ContiguousAudioDataBufferedForTesting(&total, &same_rate_total);
  51. return same_rate_total.InMilliseconds();
  52. }
  53. int sample_rate_;
  54. std::unique_ptr<AudioClock> clock_;
  55. };
  56. TEST_F(AudioClockTest, FrontTimestampStartsAtStartTimestamp) {
  57. base::TimeDelta expected = base::Seconds(123);
  58. AudioClock clock(expected, sample_rate_);
  59. EXPECT_EQ(expected, clock.front_timestamp());
  60. }
  61. TEST_F(AudioClockTest, BackTimestampStartsAtStartTimestamp) {
  62. base::TimeDelta expected = base::Seconds(123);
  63. AudioClock clock(expected, sample_rate_);
  64. EXPECT_EQ(expected, clock.back_timestamp());
  65. }
  66. TEST_F(AudioClockTest, Playback) {
  67. // The first time we write data we should still expect our start timestamp
  68. // due to delay.
  69. WroteAudio(10, 10, 20, 1.0);
  70. EXPECT_EQ(0, FrontTimestampInMilliseconds());
  71. EXPECT_EQ(1000, BackTimestampInMilliseconds());
  72. EXPECT_EQ(0, ContiguousAudioDataBufferedInMilliseconds());
  73. EXPECT_EQ(0, ContiguousAudioDataBufferedAtSameRateInMilliseconds());
  74. // The media time should remain at start timestamp as we write data.
  75. WroteAudio(10, 10, 20, 1.0);
  76. EXPECT_EQ(0, FrontTimestampInMilliseconds());
  77. EXPECT_EQ(2000, BackTimestampInMilliseconds());
  78. EXPECT_EQ(0, ContiguousAudioDataBufferedInMilliseconds());
  79. EXPECT_EQ(0, ContiguousAudioDataBufferedAtSameRateInMilliseconds());
  80. WroteAudio(10, 10, 20, 1.0);
  81. EXPECT_EQ(0, FrontTimestampInMilliseconds());
  82. EXPECT_EQ(3000, BackTimestampInMilliseconds());
  83. EXPECT_EQ(3000, ContiguousAudioDataBufferedInMilliseconds());
  84. EXPECT_EQ(3000, ContiguousAudioDataBufferedAtSameRateInMilliseconds());
  85. // The media time should now start advanced now that delay has been covered.
  86. WroteAudio(10, 10, 20, 1.0);
  87. EXPECT_EQ(1000, FrontTimestampInMilliseconds());
  88. EXPECT_EQ(4000, BackTimestampInMilliseconds());
  89. EXPECT_EQ(3000, ContiguousAudioDataBufferedInMilliseconds());
  90. EXPECT_EQ(3000, ContiguousAudioDataBufferedAtSameRateInMilliseconds());
  91. WroteAudio(10, 10, 20, 1.0);
  92. EXPECT_EQ(2000, FrontTimestampInMilliseconds());
  93. EXPECT_EQ(5000, BackTimestampInMilliseconds());
  94. EXPECT_EQ(3000, ContiguousAudioDataBufferedInMilliseconds());
  95. EXPECT_EQ(3000, ContiguousAudioDataBufferedAtSameRateInMilliseconds());
  96. // Introduce a rate change to slow down time:
  97. // - Current time will advance by one second until it hits rate change
  98. // - Contiguous audio data will start shrinking immediately
  99. WroteAudio(10, 10, 20, 0.5);
  100. EXPECT_EQ(3000, FrontTimestampInMilliseconds());
  101. EXPECT_EQ(5500, BackTimestampInMilliseconds());
  102. EXPECT_EQ(2500, ContiguousAudioDataBufferedInMilliseconds());
  103. EXPECT_EQ(2000, ContiguousAudioDataBufferedAtSameRateInMilliseconds());
  104. WroteAudio(10, 10, 20, 0.5);
  105. EXPECT_EQ(4000, FrontTimestampInMilliseconds());
  106. EXPECT_EQ(6000, BackTimestampInMilliseconds());
  107. EXPECT_EQ(2000, ContiguousAudioDataBufferedInMilliseconds());
  108. EXPECT_EQ(1000, ContiguousAudioDataBufferedAtSameRateInMilliseconds());
  109. WroteAudio(10, 10, 20, 0.5);
  110. EXPECT_EQ(5000, FrontTimestampInMilliseconds());
  111. EXPECT_EQ(6500, BackTimestampInMilliseconds());
  112. EXPECT_EQ(1500, ContiguousAudioDataBufferedInMilliseconds());
  113. EXPECT_EQ(1500, ContiguousAudioDataBufferedAtSameRateInMilliseconds());
  114. WroteAudio(10, 10, 20, 0.5);
  115. EXPECT_EQ(5500, FrontTimestampInMilliseconds());
  116. EXPECT_EQ(7000, BackTimestampInMilliseconds());
  117. EXPECT_EQ(1500, ContiguousAudioDataBufferedInMilliseconds());
  118. EXPECT_EQ(1500, ContiguousAudioDataBufferedAtSameRateInMilliseconds());
  119. // Introduce a rate change to speed up time:
  120. // - Current time will advance by half a second until it hits rate change
  121. // - Contiguous audio data will start growing immediately
  122. WroteAudio(10, 10, 20, 2);
  123. EXPECT_EQ(6000, FrontTimestampInMilliseconds());
  124. EXPECT_EQ(9000, BackTimestampInMilliseconds());
  125. EXPECT_EQ(3000, ContiguousAudioDataBufferedInMilliseconds());
  126. EXPECT_EQ(1000, ContiguousAudioDataBufferedAtSameRateInMilliseconds());
  127. WroteAudio(10, 10, 20, 2);
  128. EXPECT_EQ(6500, FrontTimestampInMilliseconds());
  129. EXPECT_EQ(11000, BackTimestampInMilliseconds());
  130. EXPECT_EQ(4500, ContiguousAudioDataBufferedInMilliseconds());
  131. EXPECT_EQ(500, ContiguousAudioDataBufferedAtSameRateInMilliseconds());
  132. WroteAudio(10, 10, 20, 2);
  133. EXPECT_EQ(7000, FrontTimestampInMilliseconds());
  134. EXPECT_EQ(13000, BackTimestampInMilliseconds());
  135. EXPECT_EQ(6000, ContiguousAudioDataBufferedInMilliseconds());
  136. EXPECT_EQ(6000, ContiguousAudioDataBufferedAtSameRateInMilliseconds());
  137. WroteAudio(10, 10, 20, 2);
  138. EXPECT_EQ(9000, FrontTimestampInMilliseconds());
  139. EXPECT_EQ(15000, BackTimestampInMilliseconds());
  140. EXPECT_EQ(6000, ContiguousAudioDataBufferedInMilliseconds());
  141. EXPECT_EQ(6000, ContiguousAudioDataBufferedAtSameRateInMilliseconds());
  142. // Write silence to simulate reaching end of stream:
  143. // - Current time will advance by half a second until it hits silence
  144. // - Contiguous audio data will start shrinking towards zero
  145. WroteAudio(0, 10, 20, 2);
  146. EXPECT_EQ(11000, FrontTimestampInMilliseconds());
  147. EXPECT_EQ(15000, BackTimestampInMilliseconds());
  148. EXPECT_EQ(4000, ContiguousAudioDataBufferedInMilliseconds());
  149. EXPECT_EQ(4000, ContiguousAudioDataBufferedAtSameRateInMilliseconds());
  150. WroteAudio(0, 10, 20, 2);
  151. EXPECT_EQ(13000, FrontTimestampInMilliseconds());
  152. EXPECT_EQ(15000, BackTimestampInMilliseconds());
  153. EXPECT_EQ(2000, ContiguousAudioDataBufferedInMilliseconds());
  154. EXPECT_EQ(2000, ContiguousAudioDataBufferedAtSameRateInMilliseconds());
  155. WroteAudio(0, 10, 20, 2);
  156. EXPECT_EQ(15000, FrontTimestampInMilliseconds());
  157. EXPECT_EQ(15000, BackTimestampInMilliseconds());
  158. EXPECT_EQ(0, ContiguousAudioDataBufferedInMilliseconds());
  159. EXPECT_EQ(0, ContiguousAudioDataBufferedAtSameRateInMilliseconds());
  160. // At this point media time should stop increasing.
  161. WroteAudio(0, 10, 20, 2);
  162. EXPECT_EQ(15000, FrontTimestampInMilliseconds());
  163. EXPECT_EQ(15000, BackTimestampInMilliseconds());
  164. EXPECT_EQ(0, ContiguousAudioDataBufferedInMilliseconds());
  165. EXPECT_EQ(0, ContiguousAudioDataBufferedAtSameRateInMilliseconds());
  166. }
  167. TEST_F(AudioClockTest, AlternatingAudioAndSilence) {
  168. // Buffer #1: [0, 1000)
  169. WroteAudio(10, 10, 20, 1.0);
  170. EXPECT_EQ(0, FrontTimestampInMilliseconds());
  171. EXPECT_EQ(1000, BackTimestampInMilliseconds());
  172. EXPECT_EQ(0, ContiguousAudioDataBufferedInMilliseconds());
  173. // Buffer #2: 1000ms of silence
  174. WroteAudio(0, 10, 20, 1.0);
  175. EXPECT_EQ(0, FrontTimestampInMilliseconds());
  176. EXPECT_EQ(1000, BackTimestampInMilliseconds());
  177. EXPECT_EQ(0, ContiguousAudioDataBufferedInMilliseconds());
  178. // Buffer #3: [1000, 2000):
  179. // - Buffer #1 is at front with 1000ms of contiguous audio data
  180. WroteAudio(10, 10, 20, 1.0);
  181. EXPECT_EQ(0, FrontTimestampInMilliseconds());
  182. EXPECT_EQ(2000, BackTimestampInMilliseconds());
  183. EXPECT_EQ(1000, ContiguousAudioDataBufferedInMilliseconds());
  184. // Buffer #4: 1000ms of silence
  185. // - Buffer #1 has been played out
  186. // - Buffer #2 of silence leaves us with 0ms of contiguous audio data
  187. WroteAudio(0, 10, 20, 1.0);
  188. EXPECT_EQ(1000, FrontTimestampInMilliseconds());
  189. EXPECT_EQ(2000, BackTimestampInMilliseconds());
  190. EXPECT_EQ(0, ContiguousAudioDataBufferedInMilliseconds());
  191. // Buffer #5: [2000, 3000):
  192. // - Buffer #3 is at front with 1000ms of contiguous audio data
  193. WroteAudio(10, 10, 20, 1.0);
  194. EXPECT_EQ(1000, FrontTimestampInMilliseconds());
  195. EXPECT_EQ(3000, BackTimestampInMilliseconds());
  196. EXPECT_EQ(1000, ContiguousAudioDataBufferedInMilliseconds());
  197. }
  198. TEST_F(AudioClockTest, ZeroDelay) {
  199. // The first time we write data we should expect the first timestamp
  200. // immediately.
  201. WroteAudio(10, 10, 0, 1.0);
  202. EXPECT_EQ(0, FrontTimestampInMilliseconds());
  203. EXPECT_EQ(1000, BackTimestampInMilliseconds());
  204. EXPECT_EQ(1000, ContiguousAudioDataBufferedInMilliseconds());
  205. // Ditto for all subsequent buffers.
  206. WroteAudio(10, 10, 0, 1.0);
  207. EXPECT_EQ(1000, FrontTimestampInMilliseconds());
  208. EXPECT_EQ(2000, BackTimestampInMilliseconds());
  209. EXPECT_EQ(1000, ContiguousAudioDataBufferedInMilliseconds());
  210. WroteAudio(10, 10, 0, 1.0);
  211. EXPECT_EQ(2000, FrontTimestampInMilliseconds());
  212. EXPECT_EQ(3000, BackTimestampInMilliseconds());
  213. EXPECT_EQ(1000, ContiguousAudioDataBufferedInMilliseconds());
  214. // Ditto for silence.
  215. WroteAudio(0, 10, 0, 1.0);
  216. EXPECT_EQ(3000, FrontTimestampInMilliseconds());
  217. EXPECT_EQ(3000, BackTimestampInMilliseconds());
  218. EXPECT_EQ(0, ContiguousAudioDataBufferedInMilliseconds());
  219. WroteAudio(0, 10, 0, 1.0);
  220. EXPECT_EQ(3000, FrontTimestampInMilliseconds());
  221. EXPECT_EQ(3000, BackTimestampInMilliseconds());
  222. EXPECT_EQ(0, ContiguousAudioDataBufferedInMilliseconds());
  223. }
  224. TEST_F(AudioClockTest, TimeUntilPlayback) {
  225. // Construct an audio clock with the following representation:
  226. //
  227. // existing
  228. // |- delay -|------------------ calls to WroteAudio() ------------------|
  229. // +------------+---------+------------+-----------+------------+-----------+
  230. // | 20 silence | 10 @ 1x | 10 silence | 10 @ 0.5x | 10 silence | 10 @ 2.0x |
  231. // +------------+---------+------------+-----------+------------+-----------+
  232. // Media: 0 1000 1000 1500 1500 3500
  233. // Wall: 2000 3000 4000 5000 6000 7000
  234. WroteAudio(10, 10, 60, 1.0);
  235. WroteAudio(0, 10, 60, 1.0);
  236. WroteAudio(10, 10, 60, 0.5);
  237. WroteAudio(0, 10, 60, 0.5);
  238. WroteAudio(10, 10, 60, 2.0);
  239. EXPECT_EQ(0, FrontTimestampInMilliseconds());
  240. EXPECT_EQ(3500, BackTimestampInMilliseconds());
  241. EXPECT_EQ(0, ContiguousAudioDataBufferedInMilliseconds());
  242. // Media timestamp zero has to wait for silence to pass.
  243. EXPECT_EQ(2000, TimeUntilPlaybackInMilliseconds(0));
  244. // From then on out it's simply adding up the number of frames and taking
  245. // silence into account.
  246. EXPECT_EQ(2500, TimeUntilPlaybackInMilliseconds(500));
  247. EXPECT_EQ(3000, TimeUntilPlaybackInMilliseconds(1000));
  248. EXPECT_EQ(4500, TimeUntilPlaybackInMilliseconds(1250));
  249. EXPECT_EQ(5000, TimeUntilPlaybackInMilliseconds(1500));
  250. EXPECT_EQ(6500, TimeUntilPlaybackInMilliseconds(2500));
  251. EXPECT_EQ(7000, TimeUntilPlaybackInMilliseconds(3500));
  252. }
  253. TEST_F(AudioClockTest, SupportsYearsWorthOfAudioData) {
  254. // Use number of frames that would be likely to overflow 32-bit integer math.
  255. const int huge_amount_of_frames = std::numeric_limits<int>::max();
  256. const base::TimeDelta huge =
  257. base::Seconds(huge_amount_of_frames / sample_rate_);
  258. EXPECT_EQ(2485, huge.InDays()); // Just to give some context on how big...
  259. // Use zero delay to test calculation of current timestamp.
  260. WroteAudio(huge_amount_of_frames, huge_amount_of_frames, 0, 1.0);
  261. EXPECT_EQ(0, FrontTimestampInDays());
  262. EXPECT_EQ(2485, ContiguousAudioDataBufferedInDays());
  263. WroteAudio(huge_amount_of_frames, huge_amount_of_frames, 0, 1.0);
  264. EXPECT_EQ(huge.InDays(), FrontTimestampInDays());
  265. EXPECT_EQ(huge.InDays(), ContiguousAudioDataBufferedInDays());
  266. WroteAudio(huge_amount_of_frames, huge_amount_of_frames, 0, 1.0);
  267. EXPECT_EQ((huge * 2).InDays(), FrontTimestampInDays());
  268. EXPECT_EQ(huge.InDays(), ContiguousAudioDataBufferedInDays());
  269. WroteAudio(huge_amount_of_frames, huge_amount_of_frames, 0, 1.0);
  270. EXPECT_EQ((huge * 3).InDays(), FrontTimestampInDays());
  271. EXPECT_EQ(huge.InDays(), ContiguousAudioDataBufferedInDays());
  272. // Use huge delay to test calculation of buffered data.
  273. WroteAudio(
  274. huge_amount_of_frames, huge_amount_of_frames, huge_amount_of_frames, 1.0);
  275. EXPECT_EQ((huge * 3).InDays(), FrontTimestampInDays());
  276. EXPECT_EQ((huge * 2).InDays(), ContiguousAudioDataBufferedInDays());
  277. }
  278. TEST_F(AudioClockTest, CompensateForSuspendedWrites) {
  279. // Buffer 6 seconds of delay and 1 second of audio data.
  280. WroteAudio(10, 10, 60, 1.0);
  281. // Media timestamp zero has to wait for silence to pass.
  282. const int kBaseTimeMs = 6000;
  283. EXPECT_EQ(kBaseTimeMs, TimeUntilPlaybackInMilliseconds(0));
  284. // Elapsing frames less than we have buffered should do nothing.
  285. const int kDelayFrames = 2;
  286. for (int i = 1000; i <= kBaseTimeMs; i += 1000) {
  287. clock_->CompensateForSuspendedWrites(base::Milliseconds(i), kDelayFrames);
  288. EXPECT_EQ(kBaseTimeMs - (i - 1000), TimeUntilPlaybackInMilliseconds(0));
  289. // Write silence to simulate maintaining a 7s output buffer.
  290. WroteAudio(0, 10, 60, 1.0);
  291. }
  292. // Exhausting all frames should advance timestamps and prime the buffer with
  293. // our delay frames value.
  294. clock_->CompensateForSuspendedWrites(base::Milliseconds(7000), kDelayFrames);
  295. EXPECT_EQ(kDelayFrames * 100, TimeUntilPlaybackInMilliseconds(1000));
  296. }
  297. TEST_F(AudioClockTest, FramesToTimePrecision) {
  298. SetupClock(base::TimeDelta(), 48000);
  299. double micros_per_frame = base::Time::kMicrosecondsPerSecond / 48000.0;
  300. int frames_written = 0;
  301. // Write ~2 hours of data to clock to give any error a significant chance to
  302. // accumulate.
  303. while (clock_->back_timestamp() <= base::Hours(2)) {
  304. frames_written += 1024;
  305. WroteAudio(1024, 1024, 0, 1);
  306. }
  307. // Verify no error accumulated.
  308. EXPECT_EQ(std::round(frames_written * micros_per_frame),
  309. clock_->back_timestamp().InMicroseconds());
  310. }
  311. } // namespace media