Introduce AudioClock to improve playback delay calculations.

media/filters/buffered_audio_tracker.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_BUFFERED_AUDIO_TRACKER_H_
+#define MEDIA_FILTERS_BUFFERED_AUDIO_TRACKER_H_
+
+#include <deque>
+
+#include "base/time/time.h"
+#include "media/base/media_export.h"
+
+namespace media {
+
+// Models a queue of buffered audio in a playback pipeline for use with
+// estimating the amount of delay in wall clock time. Takes changes in playback
+// rate into account to handle scenarios where multiple rates may be present in
+// a playback pipelines with large delay.
+class MEDIA_EXPORT BufferedAudioTracker {
+ public:
+  explicit BufferedAudioTracker(int sample_rate);
+  ~BufferedAudioTracker();
+
+  // Called each time an audio callback is fired. Excess buffered frames will be
+  // trimmed until the amount buffered is <= |delay_frames|.
+  void AudioCallbackFired(int delay_frames);
+
+  // |frames| amount of audio data at |playback_rate| was written.
+  void WroteAudio(int frames, float playback_rate);

[scherkus (not reviewing), 2014/04/29 17:22:06]

I need to think about it some more ... but an alternative API could be something
like:

void WroteAudio(int frames, int total_frames, float playback_rate);

... and we could get rid of WroteSilence(). That way we could [D]CHECK() that
alternating calls to AudioCallbackFired() and WroteAudio() were written, but
that seems overly strict

[DaleCurtis, 2014/04/29 17:55:54]

I like the idea of a single function API.  Can't you take that one step further
and collapse AudioCallbackFired w/ WroteAudio()?

[scherkus (not reviewing), 2014/04/29 18:19:03]

yeah I played around with that .. the key thing is you need to extract
BufferedTime() prior to writing data

you end up with something like:

base::TimeDelta WroteAudio(int frames, int total_frames, float playback_rate,
int delay_frames);

I'll try it out and see what it's like

[DaleCurtis, 2014/04/29 18:31:01]

Ah, that's a bit awkward then.  Merging the Wrote() methods sounds fine then if
there's no way to streamline the interface. I'll give it some more thought too. 

+
+  // |frames| amount of silence was written.
+  void WroteSilence(int frames);
+
+  // Returns the amount of wall time currently buffered.
+  base::TimeDelta BufferedTime() const;
+
+ private:
+  int sample_rate_;
+
+  struct BufferedAudio {
+    BufferedAudio(int frames, float playback_rate);
+
+    int frames;
+    float playback_rate;
+  };
+
+  std::deque<BufferedAudio> buffered_audio_;
+
+  DISALLOW_COPY_AND_ASSIGN(BufferedAudioTracker);
+};
+
+}  // namespace media
+
+#endif  // MEDIA_FILTERS_BUFFERED_AUDIO_TRACKER_H_