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