Make media::AudioClock track frames written to compute time.

media/filters/audio_clock.h

Index: media/filters/audio_clock.h
diff --git a/media/filters/audio_clock.h b/media/filters/audio_clock.h
index 625da7d183ee0abc032f116e1dc964b3521587e1..5aacd16ccad9ae9277aa3bfe050ad3eb8b947445 100644
--- a/media/filters/audio_clock.h
+++ b/media/filters/audio_clock.h
@@ -18,20 +18,16 @@ namespace media {
 // a playback pipeline with large delay.
 class MEDIA_EXPORT AudioClock {
  public:
-  explicit AudioClock(int sample_rate);
+  AudioClock(base::TimeDelta start_timestamp, int sample_rate);
   ~AudioClock();
 
-  // |frames| amount of audio data scaled to |playback_rate| was written.
+  // |frames_written| amount of audio data scaled to |playback_rate| written.
+  // |frames_requested| amount of audio data requested by hardware.
   // |delay_frames| is the current amount of hardware delay.
-  // |timestamp| is the endpoint media timestamp of the audio data written.
-  void WroteAudio(int frames,
+  void WroteAudio(int frames_written,
+                  int frames_requested,
                   int delay_frames,
-                  float playback_rate,
-                  base::TimeDelta timestamp);
-
-  // |frames| amount of silence was written.
-  // |delay_frames| is the current amount of hardware delay.
-  void WroteSilence(int frames, int delay_frames);
+                  float playback_rate);
 
   // Calculates the current media timestamp taking silence and changes in
   // playback rate into account.
@@ -41,36 +37,42 @@ class MEDIA_EXPORT AudioClock {
   base::TimeDelta CurrentMediaTimestamp(
       base::TimeDelta time_since_writing) const;
 
-  // Returns the last endpoint timestamp provided to WroteAudio().
-  base::TimeDelta last_endpoint_timestamp() const {
-    return last_endpoint_timestamp_;
-  }
+  // Returns the amount of contiguous media time buffered at the head of the
+  // audio hardware buffer. Silence introduced into the audio hardware buffer is
+  // treated as a break in media time.
+  base::TimeDelta ContiguousAudioDataBuffered() const;
 
- private:
-  void TrimBufferedAudioToMatchDelay(int delay_frames);
-  void PushBufferedAudio(int frames,
-                         float playback_rate,
-                         base::TimeDelta endpoint_timestamp);
-
-  const int sample_rate_;
+  // Same as above, but also treats changes in playback rate as a break in media
+  // time.
+  base::TimeDelta ContiguousAudioDataBufferedAtSameRate() const;
 
-  // Initially set to kNoTimestamp(), otherwise is the last endpoint timestamp
-  // delivered to WroteAudio(). A copy is kept outside of |buffered_audio_| to
-  // handle the case where all of |buffered_audio_| has been replaced with
-  // silence.
-  base::TimeDelta last_endpoint_timestamp_;
+  // Returns true if there is any audio data buffered by the audio hardware,
+  // even if there is silence mixed in.
+  bool AudioDataBuffered() const;
 
-  struct BufferedAudio {
-    BufferedAudio(int frames,
-                  float playback_rate,
-                  base::TimeDelta endpoint_timestamp);
+ private:
+  // Even with a ridiculously high sample rate of 256kHz, using 64 bits will
+  // permit tracking up to 416999965 days worth of time (that's 1141 millenia).
+  //
+  // 32 bits on the other hand would top out at measly 2 hours and 20 minutes.
+  struct AudioData {
+    AudioData(int64_t frames, float playback_rate);
 
-    int frames;
+    int64_t frames;
     float playback_rate;
-    base::TimeDelta endpoint_timestamp;
   };
 
-  std::deque<BufferedAudio> buffered_audio_;
+  // Helpers for operating on a std::deque<AudioData>.
+  static void PushAudioData(std::deque<AudioData>* audio_data,
+                            int64_t frames,
+                            float playback_rate);
+  static int64_t TotalFrames(const std::deque<AudioData>& audio_data);
+
+  const base::TimeDelta start_timestamp_;
+  const int sample_rate_;
+
+  std::deque<AudioData> buffered_;
+  std::deque<AudioData> played_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioClock);
 };