media/filters/ffmpeg_demuxer.h

   1 // Copyright (c) 2012 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 // Implements the Demuxer interface using FFmpeg's libavformat.  At this time
   6 // will support demuxing any audio/video format thrown at it.  The streams
   7 // output mime types audio/x-ffmpeg and video/x-ffmpeg and include an integer
   8 // key FFmpegCodecID which contains the CodecID enumeration value.  The CodecIDs
   9 // can be used to create and initialize the corresponding FFmpeg decoder.
  10 //
  11 // FFmpegDemuxer sets the duration of pipeline during initialization by using
  12 // the duration of the longest audio/video stream.
  13 //
  14 // NOTE: since FFmpegDemuxer reads packets sequentially without seeking, media
  15 // files with very large drift between audio/video streams may result in
  16 // excessive memory consumption.
  17 //
  18 // When stopped, FFmpegDemuxer and FFmpegDemuxerStream release all callbacks
  19 // and buffered packets.  Reads from a stopped FFmpegDemuxerStream will not be
  20 // replied to.
  21
  22 #ifndef MEDIA_FILTERS_FFMPEG_DEMUXER_H_
  23 #define MEDIA_FILTERS_FFMPEG_DEMUXER_H_
  24
  25 #include <string>
  26 #include <utility>
  27 #include <vector>
  28
  29 #include "base/callback.h"
  30 #include "base/gtest_prod_util.h"
  31 #include "base/memory/scoped_vector.h"
  32 #include "base/threading/thread.h"
  33 #include "media/base/audio_decoder_config.h"
  34 #include "media/base/decoder_buffer.h"
  35 #include "media/base/decoder_buffer_queue.h"
  36 #include "media/base/demuxer.h"
  37 #include "media/base/pipeline.h"
  38 #include "media/base/text_track_config.h"
  39 #include "media/base/video_decoder_config.h"
  40 #include "media/ffmpeg/ffmpeg_deleters.h"
  41 #include "media/filters/blocking_url_protocol.h"
  42
  43 // FFmpeg forward declarations.
  44 struct AVPacket;
  45 struct AVRational;
  46 struct AVStream;
  47
  48 namespace media {
  49
  50 class MediaLog;
  51 class FFmpegBitstreamConverter;
  52 class FFmpegDemuxer;
  53 class FFmpegGlue;
  54
  55 typedef scoped_ptr<AVPacket, ScopedPtrAVFreePacket> ScopedAVPacket;
  56
  57 class FFmpegDemuxerStream : public DemuxerStream {
  58  public:
  59   // Keeps a copy of |demuxer| and initializes itself using information inside
  60   // |stream|.  Both parameters must outlive |this|.
  61   FFmpegDemuxerStream(FFmpegDemuxer* demuxer, AVStream* stream);
  62   ~FFmpegDemuxerStream() override;
  63
  64   // Enqueues the given AVPacket. It is invalid to queue a |packet| after
  65   // SetEndOfStream() has been called.
  66   void EnqueuePacket(ScopedAVPacket packet);
  67
  68   // Enters the end of stream state. After delivering remaining queued buffers
  69   // only end of stream buffers will be delivered.
  70   void SetEndOfStream();
  71
  72   // Drops queued buffers and clears end of stream state.
  73   void FlushBuffers();
  74
  75   // Empties the queues and ignores any additional calls to Read().
  76   void Stop();
  77
  78   base::TimeDelta duration() const { return duration_; }
  79
  80   // Enables fixes for ogg files with negative timestamps.  For AUDIO streams,
  81   // all packets with negative timestamps will be marked for post-decode
  82   // discard.  For all other stream types, if FFmpegDemuxer::start_time() is
  83   // negative, it will not be used to shift timestamps during EnqueuePacket().
  84   void enable_negative_timestamp_fixups_for_ogg() {
  85     fixup_negative_ogg_timestamps_ = true;
  86   }
  87
  88   // DemuxerStream implementation.
  89   Type type() const override;
  90   Liveness liveness() const override;
  91   void Read(const ReadCB& read_cb) override;
  92   void EnableBitstreamConverter() override;
  93   bool SupportsConfigChanges() override;
  94   AudioDecoderConfig audio_decoder_config() override;
  95   VideoDecoderConfig video_decoder_config() override;
  96   VideoRotation video_rotation() override;
  97
  98   void SetLiveness(Liveness liveness);
  99
 100   // Returns the range of buffered data in this stream.
 101   Ranges<base::TimeDelta> GetBufferedRanges() const;
 102
 103   // Returns elapsed time based on the already queued packets.
 104   // Used to determine stream duration when it's not known ahead of time.
 105   base::TimeDelta GetElapsedTime() const;
 106
 107   // Returns true if this stream has capacity for additional data.
 108   bool HasAvailableCapacity();
 109
 110   // Returns the total buffer size FFMpegDemuxerStream is holding onto.
 111   size_t MemoryUsage() const;
 112
 113   TextKind GetTextKind() const;
 114
 115   // Returns the value associated with |key| in the metadata for the avstream.
 116   // Returns an empty string if the key is not present.
 117   std::string GetMetadata(const char* key) const;
 118
 119  private:
 120   friend class FFmpegDemuxerTest;
 121
 122   // Runs |read_cb_| if present with the front of |buffer_queue_|, calling
 123   // NotifyCapacityAvailable() if capacity is still available.
 124   void SatisfyPendingRead();
 125
 126   // Converts an FFmpeg stream timestamp into a base::TimeDelta.
 127   static base::TimeDelta ConvertStreamTimestamp(const AVRational& time_base,
 128                                                 int64 timestamp);
 129
 130   // Resets any currently active bitstream converter.
 131   void ResetBitstreamConverter();
 132
 133   // Create new bitstream converter, destroying active converter if present.
 134   void InitBitstreamConverter();
 135
 136   FFmpegDemuxer* demuxer_;
 137   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 138   AVStream* stream_;
 139   AudioDecoderConfig audio_config_;
 140   VideoDecoderConfig video_config_;
 141   Type type_;
 142   Liveness liveness_;
 143   base::TimeDelta duration_;
 144   bool end_of_stream_;
 145   base::TimeDelta last_packet_timestamp_;
 146   base::TimeDelta last_packet_duration_;
 147   Ranges<base::TimeDelta> buffered_ranges_;
 148   VideoRotation video_rotation_;
 149
 150   DecoderBufferQueue buffer_queue_;
 151   ReadCB read_cb_;
 152
 153 #if defined(USE_PROPRIETARY_CODECS)
 154   scoped_ptr<FFmpegBitstreamConverter> bitstream_converter_;
 155 #endif
 156
 157   std::string encryption_key_id_;
 158   bool fixup_negative_ogg_timestamps_;
 159
 160   DISALLOW_COPY_AND_ASSIGN(FFmpegDemuxerStream);
 161 };
 162
 163 class MEDIA_EXPORT FFmpegDemuxer : public Demuxer {
 164  public:
 165   FFmpegDemuxer(const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
 166                 DataSource* data_source,
 167                 const EncryptedMediaInitDataCB& encrypted_media_init_data_cb,
 168                 const scoped_refptr<MediaLog>& media_log);
 169   ~FFmpegDemuxer() override;
 170
 171   // Demuxer implementation.
 172   void Initialize(DemuxerHost* host,
 173                   const PipelineStatusCB& status_cb,
 174                   bool enable_text_tracks) override;
 175   void Stop() override;
 176   void Seek(base::TimeDelta time, const PipelineStatusCB& cb) override;
 177   base::Time GetTimelineOffset() const override;
 178   DemuxerStream* GetStream(DemuxerStream::Type type) override;
 179   base::TimeDelta GetStartTime() const override;
 180
 181   // Calls |encrypted_media_init_data_cb_| with the initialization data
 182   // encountered in the file.
 183   void OnEncryptedMediaInitData(EmeInitDataType init_data_type,
 184                                 const std::string& encryption_key_id);
 185
 186   // Allow FFmpegDemuxerStream to notify us when there is updated information
 187   // about capacity and what buffered data is available.
 188   void NotifyCapacityAvailable();
 189   void NotifyBufferingChanged();
 190
 191   // The lowest demuxed timestamp.  If negative, DemuxerStreams must use this to
 192   // adjust packet timestamps such that external clients see a zero-based
 193   // timeline.
 194   base::TimeDelta start_time() const { return start_time_; }
 195
 196  private:
 197   // To allow tests access to privates.
 198   friend class FFmpegDemuxerTest;
 199
 200   // FFmpeg callbacks during initialization.
 201   void OnOpenContextDone(const PipelineStatusCB& status_cb, bool result);
 202   void OnFindStreamInfoDone(const PipelineStatusCB& status_cb, int result);
 203
 204   // FFmpeg callbacks during seeking.
 205   void OnSeekFrameDone(const PipelineStatusCB& cb, int result);
 206
 207   // FFmpeg callbacks during reading + helper method to initiate reads.
 208   void ReadFrameIfNeeded();
 209   void OnReadFrameDone(ScopedAVPacket packet, int result);
 210
 211   // Returns true iff any stream has additional capacity. Note that streams can
 212   // go over capacity depending on how the file is muxed.
 213   bool StreamsHaveAvailableCapacity();
 214
 215   // Returns true if the maximum allowed memory usage has been reached.
 216   bool IsMaxMemoryUsageReached() const;
 217
 218   // Signal all FFmpegDemuxerStreams that the stream has ended.
 219   void StreamHasEnded();
 220
 221   // Called by |url_protocol_| whenever |data_source_| returns a read error.
 222   void OnDataSourceError();
 223
 224   // Returns the stream from |streams_| that matches |type| as an
 225   // FFmpegDemuxerStream.
 226   FFmpegDemuxerStream* GetFFmpegStream(DemuxerStream::Type type) const;
 227
 228   // Called after the streams have been collected from the media, to allow
 229   // the text renderer to bind each text stream to the cue rendering engine.
 230   void AddTextStreams();
 231
 232   void SetLiveness(DemuxerStream::Liveness liveness);
 233
 234   DemuxerHost* host_;
 235
 236   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 237
 238   // Thread on which all blocking FFmpeg operations are executed.
 239   base::Thread blocking_thread_;
 240
 241   // Tracks if there's an outstanding av_read_frame() operation.
 242   //
 243   // TODO(scherkus): Allow more than one read in flight for higher read
 244   // throughput using demuxer_bench to verify improvements.
 245   bool pending_read_;
 246
 247   // Tracks if there's an outstanding av_seek_frame() operation. Used to discard
 248   // results of pre-seek av_read_frame() operations.
 249   bool pending_seek_;
 250
 251   // |streams_| mirrors the AVStream array in AVFormatContext. It contains
 252   // FFmpegDemuxerStreams encapsluating AVStream objects at the same index.
 253   //
 254   // Since we only support a single audio and video stream, |streams_| will
 255   // contain NULL entries for additional audio/video streams as well as for
 256   // stream types that we do not currently support.
 257   //
 258   // Once initialized, operations on FFmpegDemuxerStreams should be carried out
 259   // on the demuxer thread.
 260   typedef ScopedVector<FFmpegDemuxerStream> StreamVector;
 261   StreamVector streams_;
 262
 263   // Provides asynchronous IO to this demuxer. Consumed by |url_protocol_| to
 264   // integrate with libavformat.
 265   DataSource* data_source_;
 266
 267   scoped_refptr<MediaLog> media_log_;
 268
 269   // Derived bitrate after initialization has completed.
 270   int bitrate_;
 271
 272   // The first timestamp of the audio or video stream, whichever is lower.  This
 273   // is used to adjust timestamps so that external consumers always see a zero
 274   // based timeline.
 275   base::TimeDelta start_time_;
 276
 277   // The index and start time of the preferred streams for seeking.  Filled upon
 278   // completion of OnFindStreamInfoDone().  Each info entry represents an index
 279   // into |streams_| and the start time of that stream.
 280   //
 281   // Seek() will attempt to use |preferred_stream_for_seeking_| if the seek
 282   // point occurs after its associated start time.  Otherwise it will use
 283   // |fallback_stream_for_seeking_|.
 284   typedef std::pair<int, base::TimeDelta> StreamSeekInfo;
 285   StreamSeekInfo preferred_stream_for_seeking_;
 286   StreamSeekInfo fallback_stream_for_seeking_;
 287
 288   // The Time associated with timestamp 0. Set to a null
 289   // time if the file doesn't have an association to Time.
 290   base::Time timeline_offset_;
 291
 292   // Whether text streams have been enabled for this demuxer.
 293   bool text_enabled_;
 294
 295   // Set if we know duration of the audio stream. Used when processing end of
 296   // stream -- at this moment we definitely know duration.
 297   bool duration_known_;
 298
 299   // FFmpegURLProtocol implementation and corresponding glue bits.
 300   scoped_ptr<BlockingUrlProtocol> url_protocol_;
 301   scoped_ptr<FFmpegGlue> glue_;
 302
 303   const EncryptedMediaInitDataCB encrypted_media_init_data_cb_;
 304
 305   // NOTE: Weak pointers must be invalidated before all other member variables.
 306   base::WeakPtrFactory<FFmpegDemuxer> weak_factory_;
 307
 308   DISALLOW_COPY_AND_ASSIGN(FFmpegDemuxer);
 309 };
 310
 311 }  // namespace media
 312
 313 #endif  // MEDIA_FILTERS_FFMPEG_DEMUXER_H_