libcore/asobj/PlayHead.h

   1 // PlayHead.h: media playback controller
   2 //
   3 //   Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 Free Software
   4 //   Foundation, Inc
   5 //
   6 // This program is free software; you can redistribute it and/or modify
   7 // it under the terms of the GNU General Public License as published by
   8 // the Free Software Foundation; either version 3 of the License, or
   9 // (at your option) any later version.
  10 //
  11 // This program is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU General Public License
  17 // along with this program; if not, write to the Free Software
  18 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  19
  20
  21 #ifndef GNASH_PLAYHEAD_H
  22 #define GNASH_PLAYHEAD_H
  23
  24 #include <boost/cstdint.hpp> // For C99 int types
  25
  26 // Forward declarations
  27 namespace gnash {
  28     class VirtualClock;
  29 }
  30
  31 namespace gnash {
  32
  33 /// The playback controller
  34 class PlayHead {
  35
  36 public:
  37
  38     /// Flags for playback state
  39     enum PlaybackStatus {
  40         PLAY_PLAYING = 1,
  41         PLAY_PAUSED = 2
  42     };
  43
  44     /// Initialize playhead given a VirtualCock to use
  45     /// as clock source.
  46     //
  47     /// The PlayHead will have initial state set to PAUSED
  48     /// and initial position set to 0.
  49     ///
  50     /// @param clockSource
  51     /// The VirtualClock to use as time source.
  52     /// Ownership left to caller (not necessarely a good thing).
  53     ///
  54     PlayHead(VirtualClock* clockSource);
  55
  56     /// Set a video consumer as available
  57     //
  58     /// This should be completely fine to do during
  59     /// PlayHead lifetime.
  60     ///
  61     void setVideoConsumerAvailable()
  62     {
  63         _availableConsumers |= CONSUMER_VIDEO;
  64     }
  65
  66     /// Set an audio consumer as available
  67     //
  68     /// This should be completely fine to do during
  69     /// PlayHead lifetime.
  70     ///
  71     void setAudioConsumerAvailable()
  72     {
  73         _availableConsumers |= CONSUMER_AUDIO;
  74     }
  75
  76     /// Get current playhead position (milliseconds)
  77     boost::uint64_t getPosition() const { return _position; }
  78
  79     /// Get current playback state
  80     PlaybackStatus getState() const { return _state; }
  81
  82     /// Set playback state, returning old state
  83     PlaybackStatus setState(PlaybackStatus newState);
  84
  85     /// Toggle playback state, returning old state
  86     PlaybackStatus toggleState();
  87
  88     /// Return true if video of current position have been consumed
  89     bool isVideoConsumed() const
  90     {
  91         return (_positionConsumers & CONSUMER_VIDEO);
  92     }
  93
  94     /// Mark current position as being consumed by video consumer
  95     void setVideoConsumed()
  96     {
  97         _positionConsumers |= CONSUMER_VIDEO;
  98     }
  99
 100     /// Return true if audio of current position have been consumed
 101     bool isAudioConsumed() const
 102     {
 103         return (_positionConsumers & CONSUMER_AUDIO);
 104     }
 105
 106     /// Mark current position as being consumed by audio consumer
 107     void setAudioConsumed()
 108     {
 109         _positionConsumers |= CONSUMER_AUDIO;
 110     }
 111
 112     /// Change current position to the given time.
 113     //
 114     /// Consume flag will be reset.
 115     ///
 116     /// @param position
 117     /// Position timestamp (milliseconds)
 118     ///
 119     /// POSTCONDITIONS:
 120     /// - isVideoConsumed() == false
 121     /// - isAudioConsumed() == false
 122     /// - getPosition() == position
 123     ///
 124     void seekTo(boost::uint64_t position);
 125
 126     /// Advance position if all available consumers consumed the current one
 127     //
 128     /// Clock source will be used to determine the amount
 129     /// of milliseconds to advance position to.
 130     ///
 131     /// Consumer flags will be reset.
 132     ///
 133     /// POSTCONDITIONS:
 134     /// - isVideoConsumed() == false
 135     /// - isAudioConsumed() == false
 136     ///
 137     void advanceIfConsumed();
 138
 139
 140 private:
 141
 142     /// Flags for consumers state
 143     enum ConsumerFlag {
 144         CONSUMER_VIDEO = 1,
 145         CONSUMER_AUDIO = 2
 146     };
 147
 148     /// Current playhead position
 149     boost::uint64_t _position;
 150
 151     /// Current playback state
 152     PlaybackStatus _state;
 153
 154     /// Binary OR of consumers representing
 155     /// which consumers are active
 156     int _availableConsumers;
 157
 158     /// Binary OR of consumers representing
 159     /// which consumers consumed current position
 160     int _positionConsumers;
 161
 162     /// The clock source, externally owned
 163     VirtualClock* _clockSource;
 164
 165     /// Offset to subtract from current clock source
 166     /// to get current position
 167     //
 168     /// The offset will be
 169     boost::uint64_t _clockOffset;
 170
 171 };
 172
 173 } // end of gnash namespace
 174
 175 // __PLAYHEAD_H__
 176 #endif
 177