Add AudioBufferStream.

media/filters/decoder_stream.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_DECODER_STREAM_H_
 #define MEDIA_FILTERS_DECODER_STREAM_H_
 
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/weak_ptr.h"
+#include "media/base/audio_decoder.h"
 #include "media/base/decryptor.h"
 #include "media/base/demuxer_stream.h"
 #include "media/base/media_export.h"
 #include "media/base/pipeline_status.h"
 #include "media/filters/decoder_selector.h"
 
 namespace base {
 class SingleThreadTaskRunner;
 }
 
 namespace media {
 
 class DecryptingDemuxerStream;
 
 // Wraps a DemuxerStream and a list of Decoders and provides decoded
 // output to its client (e.g. Audio/VideoRendererImpl).
 template<DemuxerStream::Type StreamType>
 class MEDIA_EXPORT DecoderStream {
  public:
   typedef DecoderStreamTraits<StreamType> StreamTraits;
   typedef typename StreamTraits::DecoderType Decoder;
   typedef typename StreamTraits::OutputType Output;
   typedef typename StreamTraits::StreamInitCB InitCB;
+  typedef typename Decoder::Status DecoderStatus;
 
   enum Status {
     OK,  // Everything went as planned.
     ABORTED,  // Read aborted due to Reset() during pending read.
     DEMUXER_READ_ABORTED,  // Demuxer returned aborted read.
     DECODE_ERROR,  // Decoder returned decode error.
     DECRYPT_ERROR  // Decoder returned decrypt error.
   };
 
   // Indicates completion of a DecoderStream read.
@@ skipping 26 matching lines @@
 
   // Stops the decoder, fires any existing pending read callback or reset
   // callback and calls |closure| on completion. Note that |closure| is always
   // called asynchronously. The DecoderStream cannot be used anymore after
   // it is stopped. This method can be called at any time but not during another
   // pending Stop().
   void Stop(const base::Closure& closure);
 
   // Returns true if the decoder currently has the ability to decode and return
   // an Output.
+  // TODO(rileya): Remove the need for this by refactoring Decoder queueing
+  // behavior.
   bool CanReadWithoutStalling() const;
 
+  // TODO(rileya): Remove this once channel_layout/bits_per_channel/etc getters
+  // have been removed from AudioDecoder and plumbed elsewhere.
+  Decoder* decoder() { return decoder_.get(); }
+
  private:
   enum State {
     STATE_UNINITIALIZED,
     STATE_INITIALIZING,
     STATE_NORMAL,  // Includes idle, pending decoder decode/reset/stop.
     STATE_FLUSHING_DECODER,
     STATE_PENDING_DEMUXER_READ,
     STATE_REINITIALIZING_DECODER,
     STATE_STOPPED,
     STATE_ERROR
   };
 
   // Called when |decoder_selector| selected the |selected_decoder|.
   // |decrypting_demuxer_stream| was also populated if a DecryptingDemuxerStream
   // is created to help decrypt the encrypted stream.
   void OnDecoderSelected(
       scoped_ptr<Decoder> selected_decoder,
       scoped_ptr<DecryptingDemuxerStream> decrypting_demuxer_stream);
 
   // Satisfy pending |read_cb_| with |status| and |output|.
-  void SatisfyRead(Status status, const scoped_refptr<Output>& output);
+  void SatisfyRead(Status status,
+                   const scoped_refptr<Output>& output);
 
   // Abort pending |read_cb_|.
   void AbortRead();
 
   // Decodes |buffer| and returns the result via OnDecodeOutputReady().
   void Decode(const scoped_refptr<DecoderBuffer>& buffer);
 
   // Flushes the decoder with an EOS buffer to retrieve internally buffered
   // decoder output.
   void FlushDecoder();
 
   // Callback for Decoder::Decode().
   void OnDecodeOutputReady(int buffer_size,
-                           typename Decoder::Status status,
+                           DecoderStatus status,
                            const scoped_refptr<Output>& output);
 
+  // If the |decoder_| has queued output that we can immediately pass along to
+  // OnDecodeOutputReady, do so and return true. Returns false otherwise.
+  bool SendQueuedOutput();
+
   // Reads a buffer from |stream_| and returns the result via OnBufferReady().
   void ReadFromDemuxerStream();
 
   // Callback for DemuxerStream::Read().
   void OnBufferReady(DemuxerStream::Status status,
                      const scoped_refptr<DecoderBuffer>& buffer);
 
   void ReinitializeDecoder();
 
   // Callback for Decoder reinitialization.
@@ skipping 23 matching lines @@
 
   // These two will be set by DecoderSelector::SelectDecoder().
   scoped_ptr<Decoder> decoder_;
   scoped_ptr<DecryptingDemuxerStream> decrypting_demuxer_stream_;
 
   // This is required so the VideoFrameStream can access private members in
   // FinishInitialization() and ReportStatistics().
   DISALLOW_IMPLICIT_CONSTRUCTORS(DecoderStream);
 };
 
+template <>
+bool DecoderStream<DemuxerStream::AUDIO>::CanReadWithoutStalling() const;
+
 typedef DecoderStream<DemuxerStream::VIDEO> VideoFrameStream;
+typedef DecoderStream<DemuxerStream::AUDIO> AudioBufferStream;
 
 }  // namespace media
 
 #endif  // MEDIA_FILTERS_DECODER_STREAM_H_