Add an initial revision of an audio server.

services/media/audio/audio_pipe.h

Index: services/media/audio/audio_pipe.h
diff --git a/services/media/audio/audio_pipe.h b/services/media/audio/audio_pipe.h
new file mode 100644
index 0000000000000000000000000000000000000000..7d080f07080432f8deb2da5959eb6964bfe88a95
--- /dev/null
+++ b/services/media/audio/audio_pipe.h
@@ -0,0 +1,101 @@
+// Copyright 2015 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 SERVICES_MEDIA_AUDIO_AUDIO_PIPE_H_
+#define SERVICES_MEDIA_AUDIO_AUDIO_PIPE_H_
+
+#include <memory>
+#include <vector>
+
+#include "mojo/services/media/common/cpp/linear_transform.h"
+#include "services/media/audio/fwd_decls.h"
+#include "services/media/common/media_pipe_base.h"
+
+namespace mojo {
+namespace media {
+namespace audio {
+
+class AudioPipe : public MediaPipeBase {
+ public:
+  class AudioPacketRef;
+  using AudioPacketRefPtr = std::shared_ptr<AudioPacketRef>;
+  using MediaPacketStatePtr = MediaPipeBase::MediaPacketStatePtr;
+
+  class AudioPacketRef {
+   public:
+    struct Region {
+      Region(const void* b, uint32_t ffl) : base(b), frac_frame_len(ffl) {}
+      const void* base;
+      uint32_t frac_frame_len;
+    };
+
+    ~AudioPacketRef();
+
+    const MediaPacketPtr& GetPacket() const { return state_->GetPacket(); }
+    void SetResult(MediaResult result) { return state_->SetResult(result); }
+
+    // Accessors for starting and ending presentation time stamps expressed in
+    // units of audio frames (note, not media time), as signed 51.12 fixed point
+    // integers (see AudioTrackImpl:PTS_FRACTIONAL_BITS).  At 192KHz, this
+    // allows for ~372.7 years of usable range when starting from a media time
+    // of 0.

[jeffbrown, 2015/11/04 23:43:33]

Might be good to define a struct for manipulating fixed-point values of this
type.

[johngro, 2015/11/06 02:20:25]

I'm not sure that a struct is what you want here (in fact, I'm almost 100% sure
that it is not, but am more than willing to concrete proposals for how they
could make things better).  I'm not even sure that we want to keep the concept
of fractional timestamps expressed in track frames at this level. 
Unfortunately, allowing media timelines to be expressed in units which are not
fundamentally divisible by the underlying frame rates of the substreams (think
audio and video, but there are other valid types of substreams in the media
world) and an un-avoidable consequence of this decision.

The MPEG-2 system layer (both PS and TS) fundamentally disallows this given
their specific choices of media clock rates (27MHz for TS and 90KHz for PS), and
restricted choices of audio and video frame rates (easy to do when audio and
video are restricted to MP1L[123] audio and MP[12] video).  Of course, this
immediately becomes undone by people who then turn around and encapsulate other
audio and video codecs which support broader options for frame rates in the
container.

Other systems just give up and spec high resolution timestamps (usually in
expressed nanoseconds, but sometimes things like 100s or 10s of nanoseconds) as
their universal, internal clock resolution.  Gstreamer and (IIRC) DirectShow
took this approach.  I have found this to be a reasonable approach, provided
that PTS interpolation is handled properly (see below).

Other containers (I'm looking at you FLV) just fundamentally drop the ball and
spec millisecond as their media time, which is entirely insufficient, regardless
of the nature of the encoded media they are attempting to transport.

TL;DR?  It basically becomes the problem of the player/renderer combination to
deal with.  I provide a solution by allowing...

1) Unsynchronized audio to just not deal with timestamps at all (I have a bit of
work to do to properly handle this while guaranteeing no truncation on output,
but I promise you that this is not too difficult).
2) Synchronized audio where initial timestamps may be provided at the container
resolutions at random access points, and interpolated from there on out.  The
solution I use below deals properly with interpolation by using transformations
from the initial, explicitly provided, PTS.
3) Strictly obeying PTS explicitly provided by the user/player.  Right now, this
requires the player to deal with the problem of creeping rounding error. 
Allowing some level of slop in this to account for explicit (but incorrect),
timestamps is a subject I bring up in some of my initial requirements documents,
but have not handled here.  We need to decide if we are going to do anything at
all about it, and if we do, design/document the system first.  For now, either
get your PTSs right, or let me interpolate them for you.

+    //
+    // AudioPackets consumed by the AudioServer are all expected to have
+    // explicit presentation time stamps.  If packets sent by the user are
+    // missing timestamps, appropriate timestamps will be synthesized at this
+    // point in the pipeline.
+    //
+    // Note, the start pts is the time at which the first frame of audio in the
+    // packet should be presented.  The end_pts is the time at which the frame
+    // after the final frame in the packet would be presented.
+    //
+    // TODO(johngro): Reconsider this.  It may be best to keep things expressed
+    // simply in media time instead of converting to fractional units of track
+    // frames.  If/when outputs move away from a single fixed step size for
+    // output sampling, it will probably be best to just convert this back to
+    // media time.
+    const int64_t& start_pts() const { return start_pts_; }
+    const int64_t& end_pts() const { return end_pts_; }
+
+    // Accessor for the regions in the shared buffer which contain the actual
+    // sample data.
+    const std::vector<Region>& regions() const { return  regions_; }
+
+   private:
+    friend class AudioPipe;
+    AudioPacketRef(MediaPacketStatePtr state,
+                   AudioServerImpl* server,
+                   std::vector<Region>&& regions,
+                   int64_t start_pts,
+                   int64_t end_pts);
+
+    MediaPacketStatePtr state_;
+    AudioServerImpl* server_;
+
+    std::vector<Region> regions_;
+    int64_t start_pts_;
+    int64_t end_pts_;
+  };
+
+  AudioPipe(AudioTrackImpl* owner, AudioServerImpl* server);
+  ~AudioPipe() override;
+
+ protected:
+  void OnPacketReceived(MediaPacketStatePtr state) override;
+  void OnFlushRequested(const FlushCallback& cbk) override;
+
+ private:
+  AudioTrackImpl* owner_;
+  AudioServerImpl* server_;
+
+  // State used for timestamp interpolation
+  bool next_pts_known_ = 0;
+  int64_t next_pts_;
+};
+
+}  // namespace audio
+}  // namespace media
+}  // namespace mojo
+
+#endif  // SERVICES_MEDIA_AUDIO_AUDIO_PIPE_H_