Have AudioRendererImpl advance time until it's told to stop.

media/filters/audio_clock.h

 // 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.
 
 #ifndef MEDIA_FILTERS_AUDIO_CLOCK_H_
 #define MEDIA_FILTERS_AUDIO_CLOCK_H_
 
 #include <deque>
 
 #include "base/time/time.h"
@@ skipping 11 matching lines @@
   ~AudioClock();
 
   // |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.
   void WroteAudio(int frames_written,
                   int frames_requested,
                   int delay_frames,
                   float playback_rate);
 
-  // Calculates the current media timestamp taking silence and changes in
-  // playback rate into account.
-  base::TimeDelta current_media_timestamp() const {
-    return current_media_timestamp_;
-  }
+  // Returns the bounds of media data currently buffered by the audio hardware,
+  // taking silence and changes in playback rate into account. Buffered audio
+  // structure and timestamps are updated with every call to WroteAudio().
+  //
+  // start_timestamp = 1000 ms                            sample_rate = 40 Hz
+  // +-----------------------+----------------------+-----------------------+
+  // |   10 frames silence   |   20 frames @ 1.0x   |   20 frames @ 0.5x    |
+  // |                       |       = 500 ms       |       = 250 ms        |
+  // +-----------------------+----------------------+-----------------------+
+  // ^                                                                      ^
+  // front_timestamp() is equal to               back_timestamp() is equal to
+  // |start_timestamp| since no                  amount of media frames tracked
+  // media data has been played yet.             by AudioClock, which would be
+  //                                             1750 ms.
+  base::TimeDelta front_timestamp() const { return front_timestamp_; }
+  base::TimeDelta back_timestamp() const { return back_timestamp_; }

[xhwang, 2014/09/03 23:37:34]

Following dalecurtis's comment, it'd be nice to provide more detail (here or in
a class level) how/why silence is used in this class. It's not obvious to me
what 10 frames of silence means. Is playback rate applicable to silence? Can we
say 10 frames of silence equals to 250ms?

[scherkus (not reviewing), 2014/09/04 01:47:22]

tried to beef up all the comments

for the sake of progress I might go ahead and CQ this -- I'm always more than
happy to tweak 'n update documentation!

 
   // Clients can provide |time_since_writing| to simulate the passage of time
   // since last writing audio to get a more accurate current media timestamp.
-  base::TimeDelta CurrentMediaTimestampSinceWriting(
+  //
+  // The value will be bounded between front_timestamp() and back_timestamp().
+  base::TimeDelta TimestampSinceWriting(
       base::TimeDelta time_since_writing) const;
 
   // 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 contiguous_audio_data_buffered() const {
     return contiguous_audio_data_buffered_;
   }
 
   // Same as above, but also treats changes in playback rate as a break in media
   // time.
   base::TimeDelta contiguous_audio_data_buffered_at_same_rate() const {
     return contiguous_audio_data_buffered_at_same_rate_;
   }
 
-  // Returns true if there is any audio data buffered by the audio hardware,
-  // even if there is silence mixed in.
-  bool audio_data_buffered() const { return audio_data_buffered_; }
-
  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);
 
     int64_t frames;
     float playback_rate;
   };
 
   // Helpers for operating on |buffered_|.
   void PushBufferedAudioData(int64_t frames, float playback_rate);
   void PopBufferedAudioData(int64_t frames);
   base::TimeDelta ComputeBufferedMediaTime(int64_t frames) const;
 
   const base::TimeDelta start_timestamp_;
   const int sample_rate_;
   const double microseconds_per_frame_;
 
   std::deque<AudioData> buffered_;
   int64_t total_buffered_frames_;
 
-  base::TimeDelta current_media_timestamp_;
+  base::TimeDelta front_timestamp_;
+  base::TimeDelta back_timestamp_;
 
   // Cached results of last call to WroteAudio().
-  bool audio_data_buffered_;
   base::TimeDelta contiguous_audio_data_buffered_;
   base::TimeDelta contiguous_audio_data_buffered_at_same_rate_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioClock);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_FILTERS_AUDIO_CLOCK_H_