Allow media track switching.

media/renderers/renderer_impl.h

 // Copyright 2014 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.
 
 #ifndef MEDIA_RENDERERS_RENDERER_IMPL_H_
 #define MEDIA_RENDERERS_RENDERER_IMPL_H_
 
 #include <list>
 #include <memory>
 #include <vector>
@@ skipping 43 matching lines @@
                   RendererClient* client,
                   const PipelineStatusCB& init_cb) final;
   void SetCdm(CdmContext* cdm_context,
               const CdmAttachedCB& cdm_attached_cb) final;
   void Flush(const base::Closure& flush_cb) final;
   void StartPlayingFrom(base::TimeDelta time) final;
   void SetPlaybackRate(double playback_rate) final;
   void SetVolume(float volume) final;
   base::TimeDelta GetMediaTime() final;
 
-  void OnStreamStatusChanged(DemuxerStream* stream,
-                             bool enabled,
-                             base::TimeDelta time);
-
   // Helper functions for testing purposes. Must be called before Initialize().
   void DisableUnderflowForTesting();
   void EnableClocklessVideoPlaybackForTesting();
   void set_time_source_for_testing(TimeSource* time_source) {
     time_source_ = time_source;
   }
   void set_video_underflow_threshold_for_testing(base::TimeDelta threshold) {
     video_underflow_threshold_ = threshold;
   }
 
@@ skipping 22 matching lines @@
   void OnAudioRendererInitializeDone(PipelineStatus status);
   void InitializeVideoRenderer();
   void OnVideoRendererInitializeDone(PipelineStatus status);
 
   // Helper functions and callbacks for Flush().
   void FlushAudioRenderer();
   void OnAudioRendererFlushDone();
   void FlushVideoRenderer();
   void OnVideoRendererFlushDone();
 
-  void RestartAudioRenderer(base::TimeDelta time);
-  void RestartVideoRenderer(base::TimeDelta time);
+  // This function notifies the renderer that the status of the demuxer |stream|
+  // has been changed, the new status is |enabled| and the change occured while
+  // playback position was |time|.
+  void OnStreamStatusChanged(DemuxerStream* stream,
+                             bool enabled,
+                             base::TimeDelta time);
+
+  // Reinitialize audio/video renderer during a demuxer stream switching. The
+  // renderer must be flushed first, and when the re-init is completed the
+  // corresponding callback will be invoked to restart playback.
+  // The |stream| parameter specifies the new demuxer stream, and the |time|
+  // parameter specifies the time on media timeline where the switch occured.
+  void ReinitializeAudioRenderer(DemuxerStream* stream, base::TimeDelta time);
+  void OnAudioRendererReinitialized(DemuxerStream* stream,
+                                    base::TimeDelta time,
+                                    PipelineStatus status);
+  void ReinitializeVideoRenderer(DemuxerStream* stream, base::TimeDelta time);
+  void OnVideoRendererReinitialized(DemuxerStream* stream,
+                                    base::TimeDelta time,
+                                    PipelineStatus status);
+
+  // Restart audio/video renderer playback after a demuxer stream switch or
+  // after a demuxer stream has been disabled and re-enabled. The |stream|
+  // parameter specifies which stream needs to be restarted. The |time|
+  // parameter specifies the position on the media timeline where the playback
+  // needs to be restarted. It is necessary for demuxers with independent
+  // streams (e.g. MSE / ChunkDemuxer) to synchronize data reading between those
+  // streams.
+  void RestartAudioRenderer(DemuxerStream* stream, base::TimeDelta time);
+  void RestartVideoRenderer(DemuxerStream* stream, base::TimeDelta time);
 
   // Callback executed by filters to update statistics.
   void OnStatisticsUpdate(const PipelineStatistics& stats);
 
   // Collection of callback methods and helpers for tracking changes in
   // buffering state and transition from paused/underflow states and playing
   // states.
   //
   // While in the kPlaying state:
   //   - A waiting to non-waiting transition indicates preroll has completed
   //     and StartPlayback() should be called
   //   - A non-waiting to waiting transition indicates underflow has occurred
   //     and PausePlayback() should be called
   void OnBufferingStateChange(DemuxerStream::Type type,
                               BufferingState new_buffering_state);
+
   // Handles the buffering notifications that we might get while an audio or a
   // video stream is being restarted. In those cases we don't want to report
   // underflows immediately and instead give decoders a chance to catch up with
   // currently playing stream. Returns true if the buffering nofication has been
   // handled and no further processing is necessary, returns false to indicate
   // that we should fall back to the regular OnBufferingStateChange logic.
   bool HandleRestartedStreamBufferingChanges(
       DemuxerStream::Type type,
       BufferingState new_buffering_state);
+
   bool WaitingForEnoughData() const;
   void PausePlayback();
   void StartPlayback();
 
   // Callbacks executed when a renderer has ended.
   void OnRendererEnded(DemuxerStream::Type type);
   bool PlaybackHasEnded() const;
   void RunEndedCallbackIfNeeded();
 
   // Callback executed when a runtime error happens.
@@ skipping 14 matching lines @@
 
   // Temporary callback used for Initialize() and Flush().
   PipelineStatusCB init_cb_;
   base::Closure flush_cb_;
 
   std::unique_ptr<RendererClientInternal> audio_renderer_client_;
   std::unique_ptr<RendererClientInternal> video_renderer_client_;
   std::unique_ptr<AudioRenderer> audio_renderer_;
   std::unique_ptr<VideoRenderer> video_renderer_;
 
+  DemuxerStream* current_audio_stream_;
+  DemuxerStream* current_video_stream_;
+
   // Renderer-provided time source used to control playback.
   TimeSource* time_source_;
   std::unique_ptr<WallClockTimeSource> wall_clock_time_source_;
   bool time_ticking_;
   double playback_rate_;
 
   // The time to start playback from after starting/seeking has completed.
   base::TimeDelta start_time_;
 
   BufferingState audio_buffering_state_;
@@ skipping 14 matching lines @@
 
   // Used to defer underflow for audio when restarting audio playback.
   base::CancelableClosure deferred_audio_restart_underflow_cb_;
 
   // The amount of time to wait before declaring underflow if the video renderer
   // runs out of data but the audio renderer still has enough.
   base::TimeDelta video_underflow_threshold_;
 
   bool restarting_audio_ = false;
   bool restarting_video_ = false;
-  std::list<base::Closure> pending_stream_status_notifications_;
+
+  // Flush operations and media track status changes must be serialized to avoid
+  // interfering with each other. This list will hold a list of postponed
+  // actions that need to be completed after the current async operation is
+  // completed.
+  std::list<base::Closure> pending_actions_;
+  base::Closure pending_flush_cb_;
 
   base::WeakPtr<RendererImpl> weak_this_;
   base::WeakPtrFactory<RendererImpl> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RendererImpl);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_RENDERERS_RENDERER_IMPL_H_