src/chromecast/media/cma/base/buffering_state.h

   1 // Copyright 2014 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 CHROMECAST_MEDIA_CMA_BASE_BUFFERING_STATE_H_
   6 #define CHROMECAST_MEDIA_CMA_BASE_BUFFERING_STATE_H_
   7
   8 #include <string>
   9
  10 #include "base/callback.h"
  11 #include "base/macros.h"
  12 #include "base/memory/ref_counted.h"
  13 #include "base/time/time.h"
  14
  15 namespace chromecast {
  16 namespace media {
  17
  18 class BufferingConfig : public base::RefCountedThreadSafe<BufferingConfig> {
  19  public:
  20   BufferingConfig(base::TimeDelta low_level_threshold,
  21                   base::TimeDelta high_level_threshold);
  22
  23   base::TimeDelta low_level() const { return low_level_threshold_; }
  24   base::TimeDelta high_level() const { return high_level_threshold_; }
  25
  26   void set_low_level(base::TimeDelta low_level) {
  27     low_level_threshold_ = low_level;
  28   }
  29   void set_high_level(base::TimeDelta high_level) {
  30     high_level_threshold_ = high_level;
  31   }
  32
  33  private:
  34   friend class base::RefCountedThreadSafe<BufferingConfig>;
  35   virtual ~BufferingConfig();
  36
  37   base::TimeDelta low_level_threshold_;
  38   base::TimeDelta high_level_threshold_;
  39
  40   DISALLOW_COPY_AND_ASSIGN(BufferingConfig);
  41 };
  42
  43 class BufferingState
  44     : public base::RefCountedThreadSafe<BufferingState> {
  45  public:
  46   typedef base::Callback<void(base::TimeDelta)> HighLevelBufferCB;
  47
  48   enum State {
  49     kLowLevel,
  50     kMediumLevel,
  51     kHighLevel,
  52     kEosReached,
  53   };
  54
  55   // Creates a new buffering state. The initial state is |kLowLevel|.
  56   // |state_changed_cb| is used to notify about possible state changes.
  57   // |high_level_buffer_cb| is used to adjust the high buffer threshold
  58   // when the underlying buffer is not large enough to accomodate
  59   // the current high buffer level.
  60   BufferingState(const scoped_refptr<BufferingConfig>& config,
  61                  const base::Closure& state_changed_cb,
  62                  const HighLevelBufferCB& high_level_buffer_cb);
  63
  64   // Returns the buffering state.
  65   State GetState() const { return state_; }
  66
  67   // Invoked when the buffering configuration has changed.
  68   // Based on the new configuration, the buffering state might change.
  69   // However, |state_changed_cb_| is not triggered in that case.
  70   void OnConfigChanged();
  71
  72   // Sets the current rendering time for this stream.
  73   void SetMediaTime(base::TimeDelta media_time);
  74
  75   // Sets/gets the maximum rendering media time for this stream.
  76   // The maximum rendering time is always lower than the buffered time.
  77   void SetMaxRenderingTime(base::TimeDelta max_rendering_time);
  78   base::TimeDelta GetMaxRenderingTime() const;
  79
  80   // Sets the buffered time.
  81   void SetBufferedTime(base::TimeDelta buffered_time);
  82
  83   // Notifies the buffering state that all the frames for this stream have been
  84   // buffered, i.e. the end of stream has been reached.
  85   void NotifyEos();
  86
  87   // Notifies the buffering state the underlying buffer has reached
  88   // its maximum capacity.
  89   // The maximum frame timestamp in the buffer is given by |buffered_time|.
  90   // Note: this timestamp can be different from the one provided through
  91   // SetBufferedTime since SetBufferedTime takes the timestamp of a playable
  92   // frame which is not necessarily the case here (e.g. missing key id).
  93   void NotifyMaxCapacity(base::TimeDelta buffered_time);
  94
  95   // Buffering state as a human readable string, for debugging.
  96   std::string ToString() const;
  97
  98  private:
  99   friend class base::RefCountedThreadSafe<BufferingState>;
 100   virtual ~BufferingState();
 101
 102   // Returns the state solely based on the buffered time.
 103   State GetBufferLevelState() const;
 104
 105   // Updates the state to |new_state|.
 106   void UpdateState(State new_state);
 107
 108   scoped_refptr<BufferingConfig> const config_;
 109
 110   // Callback invoked each time there is a change of state.
 111   base::Closure state_changed_cb_;
 112
 113   // Callback invoked to adjust the high buffer level.
 114   HighLevelBufferCB high_level_buffer_cb_;
 115
 116   // State.
 117   State state_;
 118
 119   // Playback media time.
 120   // Equal to kNoTimestamp() when not known.
 121   base::TimeDelta media_time_;
 122
 123   // Maximum rendering media time.
 124   // This corresponds to the timestamp of the last frame sent to the hardware
 125   // decoder/renderer.
 126   base::TimeDelta max_rendering_time_;
 127
 128   // Buffered media time.
 129   // Equal to kNoTimestamp() when not known.
 130   base::TimeDelta buffered_time_;
 131
 132   DISALLOW_COPY_AND_ASSIGN(BufferingState);
 133 };
 134
 135 }  // namespace media
 136 }  // namespace chromecast
 137
 138 #endif  // CHROMECAST_MEDIA_CMA_BASE_BUFFERING_STATE_H_