media/filters/decoder_stream.h

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef MEDIA_FILTERS_DECODER_STREAM_H_
   6 #define MEDIA_FILTERS_DECODER_STREAM_H_
   7
   8 #include "base/basictypes.h"
   9 #include "base/callback.h"
  10 #include "base/compiler_specific.h"
  11 #include "base/memory/ref_counted.h"
  12 #include "base/memory/scoped_vector.h"
  13 #include "base/memory/weak_ptr.h"
  14 #include "media/base/audio_decoder.h"
  15 #include "media/base/decryptor.h"
  16 #include "media/base/demuxer_stream.h"
  17 #include "media/base/media_export.h"
  18 #include "media/base/pipeline_status.h"
  19 #include "media/filters/decoder_selector.h"
  20 #include "media/filters/decoder_stream_traits.h"
  21
  22 namespace base {
  23 class SingleThreadTaskRunner;
  24 }
  25
  26 namespace media {
  27
  28 class DecryptingDemuxerStream;
  29
  30 // Wraps a DemuxerStream and a list of Decoders and provides decoded
  31 // output to its client (e.g. Audio/VideoRendererImpl).
  32 template<DemuxerStream::Type StreamType>
  33 class MEDIA_EXPORT DecoderStream {
  34  public:
  35   typedef DecoderStreamTraits<StreamType> StreamTraits;
  36   typedef typename StreamTraits::DecoderType Decoder;
  37   typedef typename StreamTraits::OutputType Output;
  38   typedef typename StreamTraits::StreamInitCB InitCB;
  39   typedef typename Decoder::Status DecoderStatus;
  40
  41   enum Status {
  42     OK,  // Everything went as planned.
  43     ABORTED,  // Read aborted due to Reset() during pending read.
  44     DEMUXER_READ_ABORTED,  // Demuxer returned aborted read.
  45     DECODE_ERROR,  // Decoder returned decode error.
  46     DECRYPT_ERROR  // Decoder returned decrypt error.
  47   };
  48
  49   // Indicates completion of a DecoderStream read.
  50   typedef base::Callback<void(Status, const scoped_refptr<Output>&)> ReadCB;
  51
  52   DecoderStream(
  53       const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
  54       ScopedVector<Decoder> decoders,
  55       const SetDecryptorReadyCB& set_decryptor_ready_cb);
  56   virtual ~DecoderStream();
  57
  58   // Initializes the DecoderStream and returns the initialization result
  59   // through |init_cb|. Note that |init_cb| is always called asynchronously.
  60   void Initialize(DemuxerStream* stream,
  61                   bool low_delay,
  62                   const StatisticsCB& statistics_cb,
  63                   const InitCB& init_cb);
  64
  65   // Reads a decoded Output and returns it via the |read_cb|. Note that
  66   // |read_cb| is always called asynchronously. This method should only be
  67   // called after initialization has succeeded and must not be called during
  68   // any pending Reset() and/or Stop().
  69   void Read(const ReadCB& read_cb);
  70
  71   // Resets the decoder, flushes all decoded outputs and/or internal buffers,
  72   // fires any existing pending read callback and calls |closure| on completion.
  73   // Note that |closure| is always called asynchronously. This method should
  74   // only be called after initialization has succeeded and must not be called
  75   // during any pending Reset() and/or Stop().
  76   void Reset(const base::Closure& closure);
  77
  78   // Stops the decoder, fires any existing pending read callback or reset
  79   // callback and calls |closure| on completion. Note that |closure| is always
  80   // called asynchronously. The DecoderStream cannot be used anymore after
  81   // it is stopped. This method can be called at any time but not during another
  82   // pending Stop().
  83   void Stop(const base::Closure& closure);
  84
  85   // Returns true if the decoder currently has the ability to decode and return
  86   // an Output.
  87   // TODO(rileya): Remove the need for this by refactoring Decoder queueing
  88   // behavior.
  89   bool CanReadWithoutStalling() const;
  90
  91   // Returns true if one more decode request can be submitted to the decoder.
  92   bool CanDecodeMore() const;
  93
  94   // Allows callers to register for notification of splice buffers from the
  95   // demuxer.  I.e., DecoderBuffer::splice_timestamp() is not kNoTimestamp().
  96   //
  97   // The observer will be notified of all buffers with a splice_timestamp() and
  98   // the first buffer after which has a splice_timestamp() of kNoTimestamp().
  99   typedef base::Callback<void(base::TimeDelta)> SpliceObserverCB;
 100   void set_splice_observer(const SpliceObserverCB& splice_observer) {
 101     splice_observer_cb_ = splice_observer;
 102   }
 103
 104   // Allows callers to register for notification of config changes; this is
 105   // called immediately after recieving the 'kConfigChanged' status from the
 106   // DemuxerStream, before any action is taken to handle the config change.
 107   typedef base::Closure ConfigChangeObserverCB;
 108   void set_config_change_observer(
 109       const ConfigChangeObserverCB& config_change_observer) {
 110     config_change_observer_cb_ = config_change_observer;
 111   }
 112
 113  private:
 114   enum State {
 115     STATE_UNINITIALIZED,
 116     STATE_INITIALIZING,
 117     STATE_NORMAL,  // Includes idle, pending decoder decode/reset/stop.
 118     STATE_FLUSHING_DECODER,
 119     STATE_PENDING_DEMUXER_READ,
 120     STATE_REINITIALIZING_DECODER,
 121     STATE_STOPPED,
 122     STATE_ERROR
 123   };
 124
 125   // Called when |decoder_selector| selected the |selected_decoder|.
 126   // |decrypting_demuxer_stream| was also populated if a DecryptingDemuxerStream
 127   // is created to help decrypt the encrypted stream.
 128   void OnDecoderSelected(
 129       scoped_ptr<Decoder> selected_decoder,
 130       scoped_ptr<DecryptingDemuxerStream> decrypting_demuxer_stream);
 131
 132   // Satisfy pending |read_cb_| with |status| and |output|.
 133   void SatisfyRead(Status status,
 134                    const scoped_refptr<Output>& output);
 135
 136   // Decodes |buffer| and returns the result via OnDecodeOutputReady().
 137   void Decode(const scoped_refptr<DecoderBuffer>& buffer);
 138
 139   // Flushes the decoder with an EOS buffer to retrieve internally buffered
 140   // decoder output.
 141   void FlushDecoder();
 142
 143   // Callback for Decoder::Decode().
 144   void OnDecodeOutputReady(int buffer_size,
 145                            DecoderStatus status,
 146                            const scoped_refptr<Output>& output);
 147
 148   // Reads a buffer from |stream_| and returns the result via OnBufferReady().
 149   void ReadFromDemuxerStream();
 150
 151   // Callback for DemuxerStream::Read().
 152   void OnBufferReady(DemuxerStream::Status status,
 153                      const scoped_refptr<DecoderBuffer>& buffer);
 154
 155   void ReinitializeDecoder();
 156
 157   // Callback for Decoder reinitialization.
 158   void OnDecoderReinitialized(PipelineStatus status);
 159
 160   void ResetDecoder();
 161   void OnDecoderReset();
 162
 163   void StopDecoder();
 164
 165   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 166
 167   State state_;
 168
 169   StatisticsCB statistics_cb_;
 170   InitCB init_cb_;
 171
 172   ReadCB read_cb_;
 173   base::Closure reset_cb_;
 174   base::Closure stop_cb_;
 175
 176   DemuxerStream* stream_;
 177   bool low_delay_;
 178
 179   scoped_ptr<DecoderSelector<StreamType> > decoder_selector_;
 180
 181   // These two will be set by DecoderSelector::SelectDecoder().
 182   scoped_ptr<Decoder> decoder_;
 183   scoped_ptr<DecryptingDemuxerStream> decrypting_demuxer_stream_;
 184
 185   SpliceObserverCB splice_observer_cb_;
 186   ConfigChangeObserverCB config_change_observer_cb_;
 187
 188   // If a splice_timestamp() has been seen, this is true until a
 189   // splice_timestamp() of kNoTimestamp() is encountered.
 190   bool active_splice_;
 191
 192   // Decoded buffers that haven't been read yet. Used when the decoder supports
 193   // parallel decoding.
 194   std::list<scoped_refptr<Output> > ready_outputs_;
 195
 196   // Number of outstanding decode requests sent to the |decoder_|.
 197   int pending_decode_requests_;
 198
 199   // NOTE: Weak pointers must be invalidated before all other member variables.
 200   base::WeakPtrFactory<DecoderStream<StreamType> > weak_factory_;
 201
 202   // This is required so the VideoFrameStream can access private members in
 203   // FinishInitialization() and ReportStatistics().
 204   DISALLOW_IMPLICIT_CONSTRUCTORS(DecoderStream);
 205 };
 206
 207 template <>
 208 bool DecoderStream<DemuxerStream::AUDIO>::CanReadWithoutStalling() const;
 209
 210 template <>
 211 bool DecoderStream<DemuxerStream::AUDIO>::CanDecodeMore() const;
 212
 213 typedef DecoderStream<DemuxerStream::VIDEO> VideoFrameStream;
 214 typedef DecoderStream<DemuxerStream::AUDIO> AudioBufferStream;
 215
 216 }  // namespace media
 217
 218 #endif  // MEDIA_FILTERS_DECODER_STREAM_H_