Introduce media::AudioClock::WallTimeForTimestamp().

media/filters/audio_clock_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/base/audio_timestamp_helper.h"
 #include "media/base/buffers.h"
 #include "media/filters/audio_clock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace media {
@@ skipping 21 matching lines @@
 
   int BackTimestampInMilliseconds() {
     return clock_.back_timestamp().InMilliseconds();
   }
 
   int TimestampSinceLastWritingInMilliseconds(int milliseconds) {
     return clock_.TimestampSinceWriting(base::TimeDelta::FromMilliseconds(
                                             milliseconds)).InMilliseconds();
   }
 
+  int WallTimeForTimestampInMilliseconds(int timestamp_ms) {
+    return clock_.WallTimeForTimestamp(base::TimeDelta::FromMilliseconds(
+                                           timestamp_ms)).InMilliseconds();
+  }
+
   int ContiguousAudioDataBufferedInDays() {
     return clock_.contiguous_audio_data_buffered().InDays();
   }
 
   int ContiguousAudioDataBufferedInMilliseconds() {
     return clock_.contiguous_audio_data_buffered().InMilliseconds();
   }
 
   int ContiguousAudioDataBufferedAtSameRateInMilliseconds() {
     return clock_.contiguous_audio_data_buffered_at_same_rate()
@@ skipping 228 matching lines @@
   //
   // +-------------------+----------------+------------------+----------------+
   // | 10 frames silence | 10 frames @ 1x | 10 frames @ 0.5x | 10 frames @ 2x |
   // +-------------------+----------------+------------------+----------------+
   // Media timestamp:    0              1000               1500             3500
   // Wall clock time:  2000             3000               4000             5000
   WroteAudio(10, 10, 40, 1.0);
   WroteAudio(10, 10, 40, 0.5);
   WroteAudio(10, 10, 40, 2.0);
   EXPECT_EQ(0, FrontTimestampInMilliseconds());
+  EXPECT_EQ(3500, BackTimestampInMilliseconds());
   EXPECT_EQ(0, ContiguousAudioDataBufferedInMilliseconds());
 
   // Simulate passing 2000ms of initial delay in the audio hardware.
   EXPECT_EQ(0, TimestampSinceLastWritingInMilliseconds(0));
   EXPECT_EQ(0, TimestampSinceLastWritingInMilliseconds(500));
   EXPECT_EQ(0, TimestampSinceLastWritingInMilliseconds(1000));
   EXPECT_EQ(0, TimestampSinceLastWritingInMilliseconds(1500));
   EXPECT_EQ(0, TimestampSinceLastWritingInMilliseconds(2000));
 
   // Now we should see the 1.0x buffer.
   EXPECT_EQ(500, TimestampSinceLastWritingInMilliseconds(2500));
   EXPECT_EQ(1000, TimestampSinceLastWritingInMilliseconds(3000));
 
   // Now we should see the 0.5x buffer.
   EXPECT_EQ(1250, TimestampSinceLastWritingInMilliseconds(3500));
   EXPECT_EQ(1500, TimestampSinceLastWritingInMilliseconds(4000));
 
   // Now we should see the 2.0x buffer.
   EXPECT_EQ(2500, TimestampSinceLastWritingInMilliseconds(4500));
   EXPECT_EQ(3500, TimestampSinceLastWritingInMilliseconds(5000));
 
   // Times beyond the known length of the audio clock should return the last
   // media timestamp we know of.
   EXPECT_EQ(3500, TimestampSinceLastWritingInMilliseconds(5001));
   EXPECT_EQ(3500, TimestampSinceLastWritingInMilliseconds(6000));
 }
 
+TEST_F(AudioClockTest, WallTimeForTimestamp) {
+  // Construct an audio clock with the following representation:
+  //
+  // +------------+---------+------------+-----------+------------+-----------+

[DaleCurtis, 2014/09/20 00:17:12]

As discussed, this diagram is wrong, here's a fixed'ish one for my own
edification:

  // 2000
  // +---------+------------+-----------+------------+-----------+
  // | 10 @ 1x | 10 silence | 10 @ 0.5x | 10 silence | 10 @ 2.0x |
  // +---------+------------+-----------+------------+-----------+
  // Media:   1000        1000         1500        1500         3500
  // Wall:    3000        4000         5000        6000         7000

[scherkus (not reviewing), 2014/09/22 18:34:12]

Done.

+  // | 10 silence | 10 @ 1x | 10 silence | 10 @ 0.5x | 10 silence | 10 @ 2.0x |
+  // +------------+---------+------------+-----------+------------+-----------+
+  // Media:       0       1000         1000        1500         1500        3500
+  // Wall:      2000      3000         4000        5000         6000        7000
+  WroteAudio(10, 10, 60, 1.0);
+  WroteAudio(0, 10, 60, 1.0);
+  WroteAudio(10, 10, 60, 0.5);
+  WroteAudio(0, 10, 60, 0.5);
+  WroteAudio(10, 10, 60, 2.0);
+  EXPECT_EQ(0, FrontTimestampInMilliseconds());
+  EXPECT_EQ(3500, BackTimestampInMilliseconds());
+  EXPECT_EQ(0, ContiguousAudioDataBufferedInMilliseconds());
+
+  // Media timestamp zero has to wait for silence to pass.
+  EXPECT_EQ(2000, WallTimeForTimestampInMilliseconds(0));
+
+  // From then on out it's simply adding up the number of frames and taking
+  // silence into account.
+  EXPECT_EQ(2500, WallTimeForTimestampInMilliseconds(500));
+  EXPECT_EQ(3000, WallTimeForTimestampInMilliseconds(1000));
+  EXPECT_EQ(4500, WallTimeForTimestampInMilliseconds(1250));
+  EXPECT_EQ(5000, WallTimeForTimestampInMilliseconds(1500));
+  EXPECT_EQ(6500, WallTimeForTimestampInMilliseconds(2500));
+  EXPECT_EQ(7000, WallTimeForTimestampInMilliseconds(3500));
+}
+
 TEST_F(AudioClockTest, SupportsYearsWorthOfAudioData) {
   // Use number of frames that would be likely to overflow 32-bit integer math.
   const int huge_amount_of_frames = std::numeric_limits<int>::max();
   const base::TimeDelta huge =
       base::TimeDelta::FromSeconds(huge_amount_of_frames / sample_rate_);
   EXPECT_EQ(2485, huge.InDays());  // Just to give some context on how big...
 
   // Use zero delay to test calculation of current timestamp.
   WroteAudio(huge_amount_of_frames, huge_amount_of_frames, 0, 1.0);
   EXPECT_EQ(0, FrontTimestampInDays());
@@ skipping 12 matching lines @@
   EXPECT_EQ(huge.InDays(), ContiguousAudioDataBufferedInDays());
 
   // Use huge delay to test calculation of buffered data.
   WroteAudio(
       huge_amount_of_frames, huge_amount_of_frames, huge_amount_of_frames, 1.0);
   EXPECT_EQ((huge * 3).InDays(), FrontTimestampInDays());
   EXPECT_EQ((huge * 2).InDays(), ContiguousAudioDataBufferedInDays());
 }
 
 }  // namespace media