media/base/null_video_sink.h

   1 // Copyright 2015 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_AUDIO_NULL_VIDEO_SINK_H_
   6 #define MEDIA_AUDIO_NULL_VIDEO_SINK_H_
   7
   8 #include "base/cancelable_callback.h"
   9 #include "base/memory/scoped_ptr.h"
  10 #include "base/time/default_tick_clock.h"
  11 #include "base/time/tick_clock.h"
  12 #include "media/base/video_renderer_sink.h"
  13
  14 namespace base {
  15 class SingleThreadTaskRunner;
  16 }
  17
  18 namespace media {
  19
  20 class NullVideoSink : public VideoRendererSink {
  21  public:
  22   using NewFrameCB = base::Callback<void(const scoped_refptr<VideoFrame>&)>;
  23
  24   // Periodically calls |callback| every |interval| on |task_runner| once the
  25   // sink has been started.  If |clockless| is true, the RenderCallback will
  26   // be called back to back by repeated post tasks. Optionally, if specified,
  27   // |new_frame_cb| will be called for each new frame received.
  28   NullVideoSink(bool clockless,
  29                 base::TimeDelta interval,
  30                 const NewFrameCB& new_frame_cb,
  31                 const scoped_refptr<base::SingleThreadTaskRunner>& task_runner);
  32   ~NullVideoSink() override;
  33
  34   // VideoRendererSink implementation.
  35   void Start(RenderCallback* callback) override;
  36   void Stop() override;
  37   void PaintFrameUsingOldRenderingPath(
  38       const scoped_refptr<VideoFrame>& frame) override;
  39
  40   void set_tick_clock_for_testing(base::TickClock* tick_clock) {
  41     tick_clock_ = tick_clock;
  42   }
  43
  44   // Sets |stop_cb_|, which will be fired when Stop() is called.
  45   void set_stop_cb(const base::Closure& stop_cb) {
  46     stop_cb_ = stop_cb;
  47   }
  48
  49   bool is_started() const { return started_; }
  50
  51   void set_background_render(bool is_background_rendering) {
  52     background_render_ = is_background_rendering;
  53   }
  54
  55  private:
  56   // Task that periodically calls Render() to consume video data.
  57   void CallRender();
  58
  59   const bool clockless_;
  60   const base::TimeDelta interval_;
  61   const NewFrameCB new_frame_cb_;
  62   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
  63
  64   bool started_;
  65   RenderCallback* callback_;
  66
  67   // Manages cancellation of periodic Render() callback task.
  68   base::CancelableClosure cancelable_worker_;
  69
  70   // Used to determine when a new frame is received.
  71   scoped_refptr<VideoFrame> last_frame_;
  72
  73   // Used to determine the interval given to RenderCallback::Render() as well as
  74   // to maintain stable periodicity of callbacks.
  75   base::TimeTicks current_render_time_;
  76
  77   // Allow for an injectable tick clock for testing.
  78   base::DefaultTickClock default_tick_clock_;
  79   base::TimeTicks last_now_;
  80
  81   // If specified, used instead of |default_tick_clock_|.
  82   base::TickClock* tick_clock_;
  83
  84   // If set, called when Stop() is called.
  85   base::Closure stop_cb_;
  86
  87   // Value passed to RenderCallback::Render().
  88   bool background_render_;
  89
  90   DISALLOW_COPY_AND_ASSIGN(NullVideoSink);
  91 };
  92
  93 }  // namespace media
  94
  95 #endif  // MEDIA_AUDIO_NULL_VIDEO_SINK_H_