Introduce media::AudioClock::WallTimeForTimestamp().

media/filters/audio_clock.cc

Index: media/filters/audio_clock.cc
diff --git a/media/filters/audio_clock.cc b/media/filters/audio_clock.cc
index 69d2c9be7d7f1581e03bf8246b023d178f009cc9..5e6efde32053a88d2963b45aca37bf887fe24c4e 100644
--- a/media/filters/audio_clock.cc
+++ b/media/filters/audio_clock.cc
@@ -89,6 +89,47 @@ base::TimeDelta AudioClock::TimestampSinceWriting(
          ComputeBufferedMediaTime(frames_played_since_writing);
 }
 
+base::TimeDelta AudioClock::WallTimeForTimestamp(
+    base::TimeDelta timestamp) const {
+  DCHECK(timestamp >= front_timestamp_);
+  DCHECK(timestamp <= back_timestamp_);
+
+  base::TimeDelta media_time = front_timestamp_;
+  int64_t frames_until_timestamp = 0;
+
+  for (size_t i = 0; i < buffered_.size(); ++i) {
+    // Leading silence is always accounted prior to anything else.
+    if (i == 0 && buffered_[i].playback_rate == 0) {
+      frames_until_timestamp += buffered_[i].frames;
+      continue;
+    }
+
+    if (media_time >= timestamp)

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

Should never be true?  Which should allow the lower condition to merge into the
one above minus the i == 0.

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

Yeah code got a little mucked up after a few iterations. Rewritten using your
suggestion below.

+      break;
+
+    // Account for any silence between chunks of buffered audio data.
+    if (buffered_[i].playback_rate == 0) {
+      frames_until_timestamp += buffered_[i].frames;
+      continue;
+    }
+
+    // Calculate upper bound on media time for current block of buffered frames.
+    base::TimeDelta max_media_time =
+        media_time + base::TimeDelta::FromMicroseconds(
+                         buffered_[i].frames * buffered_[i].playback_rate *
+                         microseconds_per_frame_);
+

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

I'm wary of all these conversions back and forth from TimeDelta, though it's
likely fine for integer playback rates.  You can simplify all this to the
following which is both faster (~40% according to a quick unittest) and more
accurate:

int64_t frames_until_timestamp = 0;
double timestamp_us = timestamp.InMicroseconds();
double media_time = front_timestamp_.InMicroseconds();

for (...) {
  if (buffered_[i].playback_rate == 0) {
    frames_until_timestamp += buffered_[i].frames;
    continue;
  }

  const double delta = 
      buffered[i].frames * buffered[i].playbackrate * microseconds_per_frame_;
  const double max_media_time = media_time + delta;
  if (timestamp_us <= max_media_time) {
    frames_until_timestamp +=
        buffered[i].frames * (timestamp_us - media_time) / delta;
    break;
  }

  media_time = max_media_time;
  frames_until_timestamp += buffered_[i].frames;
}

return FromMicroseconds(frames_until_timestamp);

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

Done.

+    // Determine amount of media time to convert to frames for current block.
+    base::TimeDelta delta = std::min(max_media_time, timestamp) - media_time;
+    frames_until_timestamp +=
+        delta.InSecondsF() * sample_rate_ / buffered_[i].playback_rate;
+    media_time += delta;
+  }
+
+  return base::TimeDelta::FromMicroseconds(frames_until_timestamp *
+                                           microseconds_per_frame_);
+}
+
 AudioClock::AudioData::AudioData(int64_t frames, float playback_rate)
     : frames(frames), playback_rate(playback_rate) {
 }