Revert of media: Introduce Renderer interface and RendererImpl.

media/base/pipeline.h

 // Copyright (c) 2012 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_BASE_PIPELINE_H_
 #define MEDIA_BASE_PIPELINE_H_
 
+#include <string>
+
 #include "base/gtest_prod_util.h"
 #include "base/memory/weak_ptr.h"
+#include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/default_tick_clock.h"
+#include "media/base/audio_renderer.h"
 #include "media/base/buffering_state.h"
 #include "media/base/demuxer.h"
 #include "media/base/media_export.h"
 #include "media/base/pipeline_status.h"
 #include "media/base/ranges.h"
 #include "media/base/serial_runner.h"
 #include "media/base/video_rotation.h"
 #include "ui/gfx/size.h"
 
 namespace base {
 class SingleThreadTaskRunner;
 class TimeDelta;
 }
 
 namespace media {
 
 class FilterCollection;
 class MediaLog;
-class Renderer;
 class TextRenderer;
 class TextTrackConfig;
 class TimeDeltaInterpolator;
+class TimeSource;
+class VideoRenderer;
 
 // Metadata describing a pipeline once it has been initialized.
 struct PipelineMetadata {
   PipelineMetadata()
       : has_audio(false), has_video(false), video_rotation(VIDEO_ROTATION_0) {}
 
   bool has_audio;
   bool has_video;
   gfx::Size natural_size;
   VideoRotation video_rotation;
@@ skipping 121 matching lines @@
   // been determined yet, then returns 0.
   base::TimeDelta GetMediaDuration() const;
 
   // Return true if loading progress has been made since the last time this
   // method was called.
   bool DidLoadingProgress();
 
   // Gets the current pipeline statistics.
   PipelineStatistics GetStatistics() const;
 
+  void set_underflow_disabled_for_testing(bool disabled) {
+    underflow_disabled_for_testing_ = disabled;
+  }
+  void SetTimeDeltaInterpolatorForTesting(TimeDeltaInterpolator* interpolator);
   void SetErrorForTesting(PipelineStatus status);
   bool HasWeakPtrsForTesting() const;
 
  private:
   FRIEND_TEST_ALL_PREFIXES(PipelineTest, GetBufferedTimeRanges);
   FRIEND_TEST_ALL_PREFIXES(PipelineTest, EndedCallback);
   FRIEND_TEST_ALL_PREFIXES(PipelineTest, AudioStreamShorterThanVideo);
   friend class MediaLog;
 
   // Pipeline states, as described above.
   enum State {
     kCreated,
     kInitDemuxer,
-    kInitRenderer,
+    kInitAudioRenderer,
+    kInitVideoRenderer,
     kSeeking,
     kPlaying,
     kStopping,
     kStopped,
   };
 
   // Updates |state_|. All state transitions should use this call.
   void SetState(State next_state);
 
   static const char* GetStateString(State state);
@@ skipping 12 matching lines @@
                              const TextTrackConfig& config) OVERRIDE;
   virtual void RemoveTextStream(DemuxerStream* text_stream) OVERRIDE;
 
   // Callback executed when a rendering error happened, initiating the teardown
   // sequence.
   void OnError(PipelineStatus error);
 
   // Callback executed by filters to update statistics.
   void OnUpdateStatistics(const PipelineStatistics& stats);
 
+  // Callback executed by audio renderer to update clock time.
+  void OnAudioTimeUpdate(base::TimeDelta time, base::TimeDelta max_time);
+
+  // Callback executed by video renderer to update clock time.
+  void OnVideoTimeUpdate(base::TimeDelta max_time);
+
   // The following "task" methods correspond to the public methods, but these
   // methods are run as the result of posting a task to the Pipeline's
   // task runner.
   void StartTask();
 
   // Stops and destroys all filters, placing the pipeline in the kStopped state.
   void StopTask(const base::Closure& stop_cb);
 
   // Carries out stopping and destroying all filters, placing the pipeline in
   // the kStopped state.
   void ErrorChangedTask(PipelineStatus error);
 
   // Carries out notifying filters that the playback rate has changed.
   void PlaybackRateChangedTask(float playback_rate);
 
   // Carries out notifying filters that the volume has changed.
   void VolumeChangedTask(float volume);
 
   // Carries out notifying filters that we are seeking to a new timestamp.
   void SeekTask(base::TimeDelta time, const PipelineStatusCB& seek_cb);
 
   // Callbacks executed when a renderer has ended.
-  void OnRendererEnded();
+  void OnAudioRendererEnded();
+  void OnVideoRendererEnded();
   void OnTextRendererEnded();
   void RunEndedCallbackIfNeeded();
 
   // Carries out adding a new text stream to the text renderer.
   void AddTextStreamTask(DemuxerStream* text_stream,
                          const TextTrackConfig& config);
 
   // Carries out removing a text stream from the text renderer.
   void RemoveTextStreamTask(DemuxerStream* text_stream);
 
   // Kicks off initialization for each media object, executing |done_cb| with
   // the result when completed.
   void InitializeDemuxer(const PipelineStatusCB& done_cb);
-  void InitializeRenderer(const PipelineStatusCB& done_cb);
+  void InitializeAudioRenderer(const PipelineStatusCB& done_cb);
+  void InitializeVideoRenderer(const PipelineStatusCB& done_cb);
+
+  // Kicks off destroying filters. Called by StopTask() and ErrorChangedTask().
+  // When we start to tear down the pipeline, we will consider two cases:
+  // 1. when pipeline has not been initialized, we will transit to stopping
+  // state first.
+  // 2. when pipeline has been initialized, we will first transit to pausing
+  // => flushing => stopping => stopped state.
+  // This will remove the race condition during stop between filters.
+  void TearDownPipeline();
+
+  // Compute the time corresponding to a byte offset.
+  base::TimeDelta TimeForByteOffset_Locked(int64 byte_offset) const;
 
   void OnStateTransition(PipelineStatus status);
   void StateTransitionTask(PipelineStatus status);
 
   // Initiates an asynchronous pause-flush-seek-preroll call sequence
   // executing |done_cb| with the final status when completed.
   void DoSeek(base::TimeDelta seek_timestamp, const PipelineStatusCB& done_cb);
 
   // Initiates an asynchronous pause-flush-stop call sequence executing
   // |done_cb| when completed.
   void DoStop(const PipelineStatusCB& done_cb);
   void OnStopCompleted(PipelineStatus status);
 
-  void BufferingStateChanged(BufferingState new_buffering_state);
+  // 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 BufferingStateChanged(BufferingState* buffering_state,
+                             BufferingState new_buffering_state);
+  bool WaitingForEnoughData() const;
+  void PausePlayback();
+  void StartPlayback();
+
+  void PauseClockAndStopTicking_Locked();
+  void StartClockIfWaitingForTimeUpdate_Locked();
 
   // Task runner used to execute pipeline tasks.
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 
   // MediaLog to which to log events.
   scoped_refptr<MediaLog> media_log_;
 
   // Lock used to serialize access for the following data members.
   mutable base::Lock lock_;
 
@@ skipping 13 matching lines @@
   float volume_;
 
   // Current playback rate (>= 0.0f).  This value is set immediately via
   // SetPlaybackRate() and a task is dispatched on the task runner to notify
   // the filters.
   float playback_rate_;
 
   // Current duration as reported by |demuxer_|.
   base::TimeDelta duration_;
 
+  // base::TickClock used by |interpolator_|.
+  base::DefaultTickClock default_tick_clock_;
+
+  // Tracks the most recent media time update and provides interpolated values
+  // as playback progresses.
+  scoped_ptr<TimeDeltaInterpolator> interpolator_;
+
+  enum InterpolationState {
+    // Audio (if present) is not rendering. Time isn't being interpolated.
+    INTERPOLATION_STOPPED,
+
+    // Audio (if present) is rendering. Time isn't being interpolated.
+    INTERPOLATION_WAITING_FOR_AUDIO_TIME_UPDATE,
+
+    // Audio (if present) is rendering. Time is being interpolated.
+    INTERPOLATION_STARTED,
+  };
+
+  InterpolationState interpolation_state_;
+
   // Status of the pipeline.  Initialized to PIPELINE_OK which indicates that
   // the pipeline is operating correctly. Any other value indicates that the
   // pipeline is stopped or is stopping.  Clients can call the Stop() method to
   // reset the pipeline state, and restore this to PIPELINE_OK.
   PipelineStatus status_;
 
   // The following data members are only accessed by tasks posted to
   // |task_runner_|.
 
-  bool is_initialized_;
-
   // Member that tracks the current state.
   State state_;
 
   // The timestamp to start playback from after starting/seeking has completed.
   base::TimeDelta start_timestamp_;
 
   // Whether we've received the audio/video/text ended events.
-  bool renderer_ended_;
-  bool text_renderer_ended_;
+  bool audio_ended_;
+  bool video_ended_;
+  bool text_ended_;
+
+  BufferingState audio_buffering_state_;
+  BufferingState video_buffering_state_;
 
   // Temporary callback used for Start() and Seek().
   PipelineStatusCB seek_cb_;
 
   // Temporary callback used for Stop().
   base::Closure stop_cb_;
 
   // Permanent callbacks passed in via Start().
   base::Closure ended_cb_;
   PipelineStatusCB error_cb_;
   PipelineMetadataCB metadata_cb_;
   BufferingStateCB buffering_state_cb_;
   base::Closure duration_change_cb_;
 
   // Contains the demuxer and renderers to use when initializing.
   scoped_ptr<FilterCollection> filter_collection_;
 
   // Holds the initialized demuxer. Used for seeking. Owned by client.
   Demuxer* demuxer_;
 
   // Holds the initialized renderers. Used for setting the volume,
   // playback rate, and determining when playback has finished.
-  scoped_ptr<Renderer> renderer_;
+  scoped_ptr<AudioRenderer> audio_renderer_;
+  scoped_ptr<VideoRenderer> video_renderer_;
   scoped_ptr<TextRenderer> text_renderer_;
 
+  // Renderer-provided time source used to control playback.
+  TimeSource* time_source_;
+
   PipelineStatistics statistics_;
 
   scoped_ptr<SerialRunner> pending_callbacks_;
 
+  bool underflow_disabled_for_testing_;
+
   base::ThreadChecker thread_checker_;
 
   // NOTE: Weak pointers must be invalidated before all other member variables.
   base::WeakPtrFactory<Pipeline> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Pipeline);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_PIPELINE_H_