src/media/filters/chunk_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 #ifndef MEDIA_FILTERS_CHUNK_DEMUXER_H_
   6 #define MEDIA_FILTERS_CHUNK_DEMUXER_H_
   7
   8 #include <deque>
   9 #include <map>
  10 #include <string>
  11 #include <utility>
  12 #include <vector>
  13
  14 #include "base/synchronization/lock.h"
  15 #include "media/base/byte_queue.h"
  16 #include "media/base/demuxer.h"
  17 #include "media/base/ranges.h"
  18 #include "media/base/stream_parser.h"
  19 #include "media/filters/source_buffer_stream.h"
  20
  21 namespace media {
  22
  23 class FFmpegURLProtocol;
  24 class SourceState;
  25
  26 class MEDIA_EXPORT ChunkDemuxerStream : public DemuxerStream {
  27  public:
  28   typedef std::deque<scoped_refptr<StreamParserBuffer> > BufferQueue;
  29
  30   explicit ChunkDemuxerStream(Type type, bool splice_frames_enabled);
  31   virtual ~ChunkDemuxerStream();
  32
  33   // ChunkDemuxerStream control methods.
  34   void StartReturningData();
  35   void AbortReads();
  36   void CompletePendingReadIfPossible();
  37   void Shutdown();
  38
  39   // SourceBufferStream manipulation methods.
  40   void Seek(base::TimeDelta time);
  41   bool IsSeekWaitingForData() const;
  42
  43   // Add buffers to this stream.  Buffers are stored in SourceBufferStreams,
  44   // which handle ordering and overlap resolution.
  45   // Returns true if buffers were successfully added.
  46   bool Append(const StreamParser::BufferQueue& buffers);
  47
  48   // Removes buffers between |start| and |end| according to the steps
  49   // in the "Coded Frame Removal Algorithm" in the Media Source
  50   // Extensions Spec.
  51   // https://dvcs.w3.org/hg/html-media/raw-file/default/media-source/media-source.html#sourcebuffer-coded-frame-removal
  52   //
  53   // |duration| is the current duration of the presentation. It is
  54   // required by the computation outlined in the spec.
  55   void Remove(base::TimeDelta start, base::TimeDelta end,
  56               base::TimeDelta duration);
  57
  58   // Signal to the stream that duration has changed to |duration|.
  59   void OnSetDuration(base::TimeDelta duration);
  60
  61   // Returns the range of buffered data in this stream, capped at |duration|.
  62   Ranges<base::TimeDelta> GetBufferedRanges(base::TimeDelta duration) const;
  63
  64   // Returns the duration of the buffered data.
  65   // Returns base::TimeDelta() if the stream has no buffered data.
  66   base::TimeDelta GetBufferedDuration() const;
  67
  68   // Signal to the stream that buffers handed in through subsequent calls to
  69   // Append() belong to a media segment that starts at |start_timestamp|.
  70   void OnNewMediaSegment(base::TimeDelta start_timestamp);
  71
  72   // Called when midstream config updates occur.
  73   // Returns true if the new config is accepted.
  74   // Returns false if the new config should trigger an error.
  75   bool UpdateAudioConfig(const AudioDecoderConfig& config, const LogCB& log_cb);
  76   bool UpdateVideoConfig(const VideoDecoderConfig& config, const LogCB& log_cb);
  77   void UpdateTextConfig(const TextTrackConfig& config, const LogCB& log_cb);
  78
  79   void MarkEndOfStream();
  80   void UnmarkEndOfStream();
  81
  82   // DemuxerStream methods.
  83   virtual void Read(const ReadCB& read_cb) OVERRIDE;
  84   virtual Type type() OVERRIDE;
  85   virtual void EnableBitstreamConverter() OVERRIDE;
  86   virtual AudioDecoderConfig audio_decoder_config() OVERRIDE;
  87   virtual VideoDecoderConfig video_decoder_config() OVERRIDE;
  88   virtual bool SupportsConfigChanges() OVERRIDE;
  89
  90   // Returns the text track configuration.  It is an error to call this method
  91   // if type() != TEXT.
  92   TextTrackConfig text_track_config();
  93
  94   // Sets the memory limit, in bytes, on the SourceBufferStream.
  95   void set_memory_limit_for_testing(int memory_limit) {
  96     stream_->set_memory_limit_for_testing(memory_limit);
  97   }
  98
  99   bool supports_partial_append_window_trimming() const {
 100     return partial_append_window_trimming_enabled_;
 101   }
 102
 103  private:
 104   enum State {
 105     UNINITIALIZED,
 106     RETURNING_DATA_FOR_READS,
 107     RETURNING_ABORT_FOR_READS,
 108     SHUTDOWN,
 109   };
 110
 111   // Assigns |state_| to |state|
 112   void ChangeState_Locked(State state);
 113
 114   void CompletePendingReadIfPossible_Locked();
 115
 116   // Specifies the type of the stream.
 117   Type type_;
 118
 119   scoped_ptr<SourceBufferStream> stream_;
 120
 121   mutable base::Lock lock_;
 122   State state_;
 123   ReadCB read_cb_;
 124   bool splice_frames_enabled_;
 125   bool partial_append_window_trimming_enabled_;
 126
 127   DISALLOW_IMPLICIT_CONSTRUCTORS(ChunkDemuxerStream);
 128 };
 129
 130 // Demuxer implementation that allows chunks of media data to be passed
 131 // from JavaScript to the media stack.
 132 class MEDIA_EXPORT ChunkDemuxer : public Demuxer {
 133  public:
 134   enum Status {
 135     kOk,              // ID added w/o error.
 136     kNotSupported,    // Type specified is not supported.
 137     kReachedIdLimit,  // Reached ID limit. We can't handle any more IDs.
 138   };
 139
 140   // |open_cb| Run when Initialize() is called to signal that the demuxer
 141   //   is ready to receive media data via AppenData().
 142   // |need_key_cb| Run when the demuxer determines that an encryption key is
 143   //   needed to decrypt the content.
 144   // |enable_text| Process inband text tracks in the normal way when true,
 145   //   otherwise ignore them.
 146   // |log_cb| Run when parsing error messages need to be logged to the error
 147   //   console.
 148   // |splice_frames_enabled| Indicates that it's okay to generate splice frames
 149   //   per the MSE specification.  Renderers must understand DecoderBuffer's
 150   //   splice_timestamp() field.
 151   ChunkDemuxer(const base::Closure& open_cb,
 152                const NeedKeyCB& need_key_cb,
 153                const LogCB& log_cb,
 154                bool splice_frames_enabled);
 155   virtual ~ChunkDemuxer();
 156
 157   // Demuxer implementation.
 158   virtual void Initialize(DemuxerHost* host,
 159                           const PipelineStatusCB& cb,
 160                           bool enable_text_tracks) OVERRIDE;
 161   virtual void Stop(const base::Closure& callback) OVERRIDE;
 162   virtual void Seek(base::TimeDelta time, const PipelineStatusCB&  cb) OVERRIDE;
 163   virtual DemuxerStream* GetStream(DemuxerStream::Type type) OVERRIDE;
 164   virtual base::TimeDelta GetStartTime() const OVERRIDE;
 165   virtual base::Time GetTimelineOffset() const OVERRIDE;
 166   virtual Liveness GetLiveness() const OVERRIDE;
 167
 168   // Methods used by an external object to control this demuxer.
 169   //
 170   // Indicates that a new Seek() call is on its way. Any pending Reads on the
 171   // DemuxerStream objects should be aborted immediately inside this call and
 172   // future Read calls should return kAborted until the Seek() call occurs.
 173   // This method MUST ALWAYS be called before Seek() is called to signal that
 174   // the next Seek() call represents the seek point we actually want to return
 175   // data for.
 176   // |seek_time| - The presentation timestamp for the seek that triggered this
 177   // call. It represents the most recent position the caller is trying to seek
 178   // to.
 179   void StartWaitingForSeek(base::TimeDelta seek_time);
 180
 181   // Indicates that a Seek() call is on its way, but another seek has been
 182   // requested that will override the impending Seek() call. Any pending Reads
 183   // on the DemuxerStream objects should be aborted immediately inside this call
 184   // and future Read calls should return kAborted until the next
 185   // StartWaitingForSeek() call. This method also arranges for the next Seek()
 186   // call received before a StartWaitingForSeek() call to immediately call its
 187   // callback without waiting for any data.
 188   // |seek_time| - The presentation timestamp for the seek request that
 189   // triggered this call. It represents the most recent position the caller is
 190   // trying to seek to.
 191   void CancelPendingSeek(base::TimeDelta seek_time);
 192
 193   // Registers a new |id| to use for AppendData() calls. |type| indicates
 194   // the MIME type for the data that we intend to append for this ID.
 195   // kOk is returned if the demuxer has enough resources to support another ID
 196   //    and supports the format indicated by |type|.
 197   // kNotSupported is returned if |type| is not a supported format.
 198   // kReachedIdLimit is returned if the demuxer cannot handle another ID right
 199   //    now.
 200   Status AddId(const std::string& id, const std::string& type,
 201                std::vector<std::string>& codecs);
 202
 203   // Removed an ID & associated resources that were previously added with
 204   // AddId().
 205   void RemoveId(const std::string& id);
 206
 207   // Gets the currently buffered ranges for the specified ID.
 208   Ranges<base::TimeDelta> GetBufferedRanges(const std::string& id) const;
 209
 210   // Appends media data to the source buffer associated with |id|, applying
 211   // and possibly updating |*timestamp_offset| during coded frame processing.
 212   // |append_window_start| and |append_window_end| correspond to the MSE spec's
 213   // similarly named source buffer attributes that are used in coded frame
 214   // processing.
 215   void AppendData(const std::string& id, const uint8* data, size_t length,
 216                   base::TimeDelta append_window_start,
 217                   base::TimeDelta append_window_end,
 218                   base::TimeDelta* timestamp_offset);
 219
 220   // Aborts parsing the current segment and reset the parser to a state where
 221   // it can accept a new segment.
 222   // Some pending frames can be emitted during that process. These frames are
 223   // applied |timestamp_offset|.
 224   void Abort(const std::string& id,
 225              base::TimeDelta append_window_start,
 226              base::TimeDelta append_window_end,
 227              base::TimeDelta* timestamp_offset);
 228
 229   // Remove buffers between |start| and |end| for the source buffer
 230   // associated with |id|.
 231   void Remove(const std::string& id, base::TimeDelta start,
 232               base::TimeDelta end);
 233
 234   // Returns the current presentation duration.
 235   double GetDuration();
 236   double GetDuration_Locked();
 237
 238   // Notifies the demuxer that the duration of the media has changed to
 239   // |duration|.
 240   void SetDuration(double duration);
 241
 242   // Returns true if the source buffer associated with |id| is currently parsing
 243   // a media segment, or false otherwise.
 244   bool IsParsingMediaSegment(const std::string& id);
 245
 246   // Set the append mode to be applied to subsequent buffers appended to the
 247   // source buffer associated with |id|. If |sequence_mode| is true, caller
 248   // is requesting "sequence" mode. Otherwise, caller is requesting "segments"
 249   // mode.
 250   void SetSequenceMode(const std::string& id, bool sequence_mode);
 251
 252   // Signals the coded frame processor for the source buffer associated with
 253   // |id| to update its group start timestamp to be |timestamp_offset| if it is
 254   // in sequence append mode.
 255   void SetGroupStartTimestampIfInSequenceMode(const std::string& id,
 256                                               base::TimeDelta timestamp_offset);
 257
 258   // Called to signal changes in the "end of stream"
 259   // state. UnmarkEndOfStream() must not be called if a matching
 260   // MarkEndOfStream() has not come before it.
 261   void MarkEndOfStream(PipelineStatus status);
 262   void UnmarkEndOfStream();
 263
 264   void Shutdown();
 265
 266   // Sets the memory limit on each stream. |memory_limit| is the
 267   // maximum number of bytes each stream is allowed to hold in its buffer.
 268   void SetMemoryLimitsForTesting(int memory_limit);
 269
 270   // Returns the ranges representing the buffered data in the demuxer.
 271   // TODO(wolenetz): Remove this method once MediaSourceDelegate no longer
 272   // requires it for doing hack browser seeks to I-frame on Android. See
 273   // http://crbug.com/304234.
 274   Ranges<base::TimeDelta> GetBufferedRanges() const;
 275
 276  private:
 277   enum State {
 278     WAITING_FOR_INIT,
 279     INITIALIZING,
 280     INITIALIZED,
 281     ENDED,
 282     PARSE_ERROR,
 283     SHUTDOWN,
 284   };
 285
 286   void ChangeState_Locked(State new_state);
 287
 288   // Reports an error and puts the demuxer in a state where it won't accept more
 289   // data.
 290   void ReportError_Locked(PipelineStatus error);
 291
 292   // Returns true if any stream has seeked to a time without buffered data.
 293   bool IsSeekWaitingForData_Locked() const;
 294
 295   // Returns true if all streams can successfully call EndOfStream,
 296   // false if any can not.
 297   bool CanEndOfStream_Locked() const;
 298
 299   // SourceState callbacks.
 300   void OnSourceInitDone(bool success,
 301                         const StreamParser::InitParameters& params);
 302
 303   // Creates a DemuxerStream for the specified |type|.
 304   // Returns a new ChunkDemuxerStream instance if a stream of this type
 305   // has not been created before. Returns NULL otherwise.
 306   ChunkDemuxerStream* CreateDemuxerStream(DemuxerStream::Type type);
 307
 308   void OnNewTextTrack(ChunkDemuxerStream* text_stream,
 309                       const TextTrackConfig& config);
 310
 311   // Returns true if |source_id| is valid, false otherwise.
 312   bool IsValidId(const std::string& source_id) const;
 313
 314   // Increases |duration_| to |new_duration|, if |new_duration| is higher.
 315   void IncreaseDurationIfNecessary(base::TimeDelta new_duration);
 316
 317   // Decreases |duration_| if the buffered region is less than |duration_| when
 318   // EndOfStream() is called.
 319   void DecreaseDurationIfNecessary();
 320
 321   // Sets |duration_| to |new_duration|, sets |user_specified_duration_| to -1
 322   // and notifies |host_|.
 323   void UpdateDuration(base::TimeDelta new_duration);
 324
 325   // Returns the ranges representing the buffered data in the demuxer.
 326   Ranges<base::TimeDelta> GetBufferedRanges_Locked() const;
 327
 328   // Start returning data on all DemuxerStreams.
 329   void StartReturningData();
 330
 331   // Aborts pending reads on all DemuxerStreams.
 332   void AbortPendingReads();
 333
 334   // Completes any pending reads if it is possible to do so.
 335   void CompletePendingReadsIfPossible();
 336
 337   // Seeks all SourceBufferStreams to |seek_time|.
 338   void SeekAllSources(base::TimeDelta seek_time);
 339
 340   // Shuts down all DemuxerStreams by calling Shutdown() on
 341   // all objects in |source_state_map_|.
 342   void ShutdownAllStreams();
 343
 344   mutable base::Lock lock_;
 345   State state_;
 346   bool cancel_next_seek_;
 347
 348   DemuxerHost* host_;
 349   base::Closure open_cb_;
 350   NeedKeyCB need_key_cb_;
 351   bool enable_text_;
 352   // Callback used to report error strings that can help the web developer
 353   // figure out what is wrong with the content.
 354   LogCB log_cb_;
 355
 356   PipelineStatusCB init_cb_;
 357   // Callback to execute upon seek completion.
 358   // TODO(wolenetz/acolwell): Protect against possible double-locking by first
 359   // releasing |lock_| before executing this callback. See
 360   // http://crbug.com/308226
 361   PipelineStatusCB seek_cb_;
 362
 363   scoped_ptr<ChunkDemuxerStream> audio_;
 364   scoped_ptr<ChunkDemuxerStream> video_;
 365
 366   base::TimeDelta duration_;
 367
 368   // The duration passed to the last SetDuration(). If
 369   // SetDuration() is never called or an AppendData() call or
 370   // a EndOfStream() call changes |duration_|, then this
 371   // variable is set to < 0 to indicate that the |duration_| represents
 372   // the actual duration instead of a user specified value.
 373   double user_specified_duration_;
 374
 375   base::Time timeline_offset_;
 376   Liveness liveness_;
 377
 378   typedef std::map<std::string, SourceState*> SourceStateMap;
 379   SourceStateMap source_state_map_;
 380
 381   // Used to ensure that (1) config data matches the type and codec provided in
 382   // AddId(), (2) only 1 audio and 1 video sources are added, and (3) ids may be
 383   // removed with RemoveID() but can not be re-added (yet).
 384   std::string source_id_audio_;
 385   std::string source_id_video_;
 386
 387   // Indicates that splice frame generation is enabled.
 388   const bool splice_frames_enabled_;
 389
 390   DISALLOW_COPY_AND_ASSIGN(ChunkDemuxer);
 391 };
 392
 393 }  // namespace media
 394
 395 #endif  // MEDIA_FILTERS_CHUNK_DEMUXER_H_