Initial implementation of stream switching in AdaptiveDemuxer.

media/filters/adaptive_demuxer.h

 // Copyright (c) 2011 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.
 
 // Implements a Demuxer that can switch among different data sources mid-stream.
 // Uses FFmpegDemuxer under the covers, so see the caveats at the top of
 // ffmpeg_demuxer.h.
 
 #ifndef MEDIA_FILTERS_ADAPTIVE_DEMUXER_H_
 #define MEDIA_FILTERS_ADAPTIVE_DEMUXER_H_
 
 #include <deque>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/synchronization/lock.h"
 #include "media/base/buffers.h"
 #include "media/base/filter_factories.h"
 #include "media/base/filters.h"
 #include "media/base/pipeline.h"
 #include "media/base/media_format.h"
 
 namespace media {
 
 class AdaptiveDemuxer;
+class StreamSwitchManager;
+
+typedef base::Callback<void(PipelineStatus, base::TimeDelta)> SeekHelperCB;

[Ami GONE FROM CHROMIUM, 2011/05/19 20:27:37]

Any reason these need to be outside in namespace scope?

[Ami GONE FROM CHROMIUM, 2011/05/19 20:27:37]

Doco these typedefs.
Their naming is leaving me scratching my head, since they're both Callback<>s,
so I expect them both to end with CB, but the only difference between their
names is the presence of the trailing CB.

[acolwell GONE FROM CHROMIUM, 2011/05/20 01:26:37]

Done.

[acolwell GONE FROM CHROMIUM, 2011/05/20 01:26:37]

Done.

+typedef base::Callback<void(const base::TimeDelta&, SeekHelperCB)> SeekHelper;

[Ami GONE FROM CHROMIUM, 2011/05/19 20:27:37]

TimeDelta is an int64; no need to pass by const&.

[acolwell GONE FROM CHROMIUM, 2011/05/20 01:26:37]

Done.

 
 class AdaptiveDemuxerStream : public DemuxerStream {
  public:
   typedef std::vector<scoped_refptr<DemuxerStream> > StreamVector;
+  typedef std::deque<ReadCallback> ReadCBQueue;
 
   // Keeps references to the passed-in streams.  |streams| must be non-empty and
   // all the streams in it must agree on type and media_format (or be NULL).
   // |initial_stream| must be a valid index into |streams| and specifies the
   // current stream on construction.
   AdaptiveDemuxerStream(StreamVector const& streams, int initial_stream);
   virtual ~AdaptiveDemuxerStream();
 
+  // Notifies this stream that a Seek() was requested on the demuxer.
+  void OnAdaptiveDemuxerSeek();
+
   // Change the stream to satisfy subsequent Read() requests from.  The
   // referenced pointer must not be NULL.
-  void ChangeCurrentStream(int index);
+  void ChangeCurrentStream(int index, const SeekHelper& seek_helper,
+                           const PipelineStatusCB& cb);
 
   // DemuxerStream methods.
   virtual void Read(const ReadCallback& read_callback);
   virtual Type type();
   virtual const MediaFormat& media_format();
   virtual void EnableBitstreamConverter();
   virtual AVStream* GetAVStream();
 
  private:
   // Returns a pointer to the current stream.
   DemuxerStream* current_stream();
 
   // DEBUG_MODE-only CHECK that the data members are in a reasonable state.
   void DCheckSanity();
 
+  void OnReadDone(Buffer* buffer);
+
+  bool IsSwitchPending_Locked() const;
+
+  // Starts the stream switch. This method expects that no Read()s are
+  // outstanding on | streams_[current_stream_index_] |.

[Ami GONE FROM CHROMIUM, 2011/05/19 20:27:37]

Inward-facing spaces around |'s are unnecessary (here and elsewhere).

[acolwell GONE FROM CHROMIUM, 2011/05/20 01:26:37]

Done.

+  void StartSwitch();
+
+  // Called by the SeekHelper when it has completed the seek on
+  // | streams_[switch_index_] |.
+  void OnSwitchSeekDone(PipelineStatus status,
+                        const base::TimeDelta& seek_time);
+
   StreamVector streams_;
   // Guards the members below.  Only held for simple variable reads/writes, not
   // during async operation.
   base::Lock lock_;
   int current_stream_index_;
   bool bitstream_converter_enabled_;
 
+   // The number of outstanding Read()'s on streams_[current_stream_index_].

[Ami GONE FROM CHROMIUM, 2011/05/19 20:27:37]

||'ify code in comments (here and elsewhere).

+  int pending_reads_;
+
+  // A queue of callback objects passed to Read() calls on this object.
+  ReadCBQueue read_cb_queue_;
+
+  // Callback passed to ChangeCurrentStream(). This is called & reset when the
+  // stream switch has completed.
+  PipelineStatusCB switch_cb_;
+
+  // The index of the stream we are switching to.

[Ami GONE FROM CHROMIUM, 2011/05/19 20:27:37]

Document value while not switching (or that value only makes sense when
!switch_cb_.is_null())?

[acolwell GONE FROM CHROMIUM, 2011/05/20 01:26:37]

Done.

+  int switch_index_;
+
+  // Helper object used to seek streams_|switch_index_| to a specific time.

[Ami GONE FROM CHROMIUM, 2011/05/19 20:27:37]

brackets instead of pipes

[acolwell GONE FROM CHROMIUM, 2011/05/20 01:26:37]

Done.

+  SeekHelper switch_seek_helper_;
+
+  // The timestamp of the last buffered returned via a Read() callback.

[Ami GONE FROM CHROMIUM, 2011/05/19 20:27:37]

s/buffered/buffer/

[acolwell GONE FROM CHROMIUM, 2011/05/20 01:26:37]

Done.

+  base::TimeDelta last_buffer_timestamp_;
+
   DISALLOW_IMPLICIT_CONSTRUCTORS(AdaptiveDemuxerStream);
 };
 
 class AdaptiveDemuxer : public Demuxer {
  public:
   typedef std::vector<scoped_refptr<Demuxer> > DemuxerVector;
+  typedef std::vector<int> StreamIdVector;
 
   // |demuxers| must be non-empty, and the index arguments must be valid indexes
   // into |demuxers|, or -1 to indicate no demuxer is serving that type.
   AdaptiveDemuxer(DemuxerVector const& demuxers,
                   int initial_audio_demuxer_index,
                   int initial_video_demuxer_index);
   virtual ~AdaptiveDemuxer();
 
-  // Change which demuxers the streams will use.
-  void ChangeCurrentDemuxer(int audio_index, int video_index);
+  // Change the to a different video stream.

[Ami GONE FROM CHROMIUM, 2011/05/19 20:27:37]

English.
I think this is the first time you/we enforce that the audio stream can't change
during playback.  A bunch of the .cc code can be simplified if this is the case,
I think.

[acolwell GONE FROM CHROMIUM, 2011/05/20 01:26:37]

Done.

For now I'm constraining code to video only. I envision adding audio switching
in the not too distant future. I just didn't want to handle switching both
streams in this initial CL.

+  void ChangeVideoStream(int video_id, const PipelineStatusCB& done_cb);
+
+  // Get the ID of the current video stream.

[Ami GONE FROM CHROMIUM, 2011/05/19 20:27:37]

This and the next method: are they really necessary?

[acolwell GONE FROM CHROMIUM, 2011/05/20 01:26:37]

These were added so a StreamSwitchManager object could initiate switches. I'm
sure this interface will change over time, but it was an initial attempt to
separate demuxer & stream switching logic from switch decision logic.

+  int GetCurrentVideoId() const;
+
+  // Get all of the video stream IDs.
+  StreamIdVector GetVideoIds() const;
 
   // Filter implementation.
   virtual void Stop(FilterCallback* callback);
   virtual void Seek(base::TimeDelta time, const FilterStatusCB&  cb);
   virtual void OnAudioRendererDisabled();
   virtual void set_host(FilterHost* filter_host);
   virtual void SetPlaybackRate(float playback_rate);
   virtual void SetPreload(Preload preload);
 
   // Demuxer implementation.
   virtual scoped_refptr<DemuxerStream> GetStream(DemuxerStream::Type type);
 
  private:
   // Returns a pointer to the currently active demuxer of the given type.
   Demuxer* current_demuxer(DemuxerStream::Type type);
 
+  // Called when the AdaptiveDemuxerStream completes a stream switch.
+  void ChangeVideoStreamDone(int new_stream_index,
+                             const PipelineStatusCB& done_cb,
+                             PipelineStatus status);
+
+  // Methods for SeekHelper.
+  // Initial method called when the AdaptiveDemuxerStream calls the SeekHelper.
+  void StartStreamSwitchSeek(DemuxerStream::Type type,
+                             int stream_index,
+                             const base::TimeDelta& seek_time,
+                             const SeekHelperCB& seek_cb);
+
+  // Called when the seek for index data initiated by StartStreamSwitchSeek()
+  // completes.
+  void OnIndexSeekDone(DemuxerStream::Type type,
+                       int stream_index,
+                       const base::TimeDelta& seek_time,
+                       const SeekHelperCB& seek_cb,
+                       PipelineStatus status);
+
+  // Called when the stream seek initiated by StartStreamSwitchSeek() or
+  // OnIndexSeekDone() completes.
+  void OnStreamSeekDone(const base::TimeDelta& seek_point,
+                        const SeekHelperCB& seek_cb,
+                        PipelineStatus status);
+
   DemuxerVector demuxers_;
   scoped_refptr<AdaptiveDemuxerStream> audio_stream_;
   scoped_refptr<AdaptiveDemuxerStream> video_stream_;
   // Guards the members below.  Only held for simple variable reads/writes, not
   // during async operation.
-  base::Lock lock_;
+  mutable base::Lock lock_;
   int current_audio_demuxer_index_;
   int current_video_demuxer_index_;
+  float playback_rate_;
+  bool switch_pending_;
+  scoped_refptr<StreamSwitchManager> stream_switch_manager_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(AdaptiveDemuxer);
 };
 
 // AdaptiveDemuxerFactory wraps an underlying DemuxerFactory that knows how to
 // build demuxers for a single URL, and implements a primitive (for now) version
 // of multi-file manifests.  The manifest is encoded in the |url| parameter to
 // Build() as:
 // x-adaptive:<initial_audio_index>:<initial_video_index>:<URL>[^<URL>]* where
 // <URL>'s are "real" media URLs which are passed to the underlying
@@ skipping 14 matching lines @@
 
  private:
   scoped_ptr<DemuxerFactory> delegate_factory_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(AdaptiveDemuxerFactory);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_FILTERS_ADAPTIVE_DEMUXER_H_