Introduce media::AudioClock::WallTimeForTimestamp().

media/filters/audio_clock.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/filters/audio_clock.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "media/base/buffers.h"
@@ skipping 71 matching lines @@
 
 base::TimeDelta AudioClock::TimestampSinceWriting(
     base::TimeDelta time_since_writing) const {
   int64_t frames_played_since_writing = std::min(
       total_buffered_frames_,
       static_cast<int64_t>(time_since_writing.InSecondsF() * sample_rate_));
   return front_timestamp_ +
          ComputeBufferedMediaTime(frames_played_since_writing);
 }
 
+base::TimeDelta AudioClock::TimeUntilPlayback(base::TimeDelta timestamp) const {
+  DCHECK(timestamp >= front_timestamp_);
+  DCHECK(timestamp <= back_timestamp_);
+
+  int64_t frames_until_timestamp = 0;
+  double timestamp_us = timestamp.InMicroseconds();
+  double media_time_us = front_timestamp_.InMicroseconds();
+
+  for (size_t i = 0; i < buffered_.size(); ++i) {
+    // Leading silence is always accounted prior to anything else.
+    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.
+    double delta_us = buffered_[i].frames * buffered_[i].playback_rate *
+                      microseconds_per_frame_;
+    double max_media_time_us = media_time_us + delta_us;
+
+    // Determine amount of media time to convert to frames for current block. If
+    // target timestamp falls within current block, scale the amount of frames
+    // based on remaining amount of media time.
+    if (timestamp_us <= max_media_time_us) {
+      frames_until_timestamp +=
+          buffered_[i].frames * (timestamp_us - media_time_us) / delta_us;
+      break;
+    }
+
+    media_time_us = max_media_time_us;
+    frames_until_timestamp += buffered_[i].frames;
+  }
+
+  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) {
 }
 
 void AudioClock::PushBufferedAudioData(int64_t frames, float playback_rate) {
   if (frames == 0)
     return;
 
   total_buffered_frames_ += frames;
 
@@ skipping 29 matching lines @@
     int64_t min_frames = std::min(buffered_[i].frames, frames);
     scaled_frames += min_frames * buffered_[i].playback_rate;
     frames -= min_frames;
   }
 
   return base::TimeDelta::FromMicroseconds(scaled_frames *
                                            microseconds_per_frame_);
 }
 
 }  // namespace media