libsound/StreamingSoundData.h

   1 // StreamingSoundData.h - embedded sound definition, for gnash
   2 //
   3 //   Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
   4 //   Free Software 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 #ifndef SOUND_STREAMING_SOUND_DATA_H
  21 #define SOUND_STREAMING_SOUND_DATA_H
  22
  23 #include <vector>
  24 #include <cassert>
  25 #include <list>
  26 #include <memory>
  27 #include <mutex>
  28
  29 #include "SoundInfo.h"
  30
  31 // Forward declarations
  32 namespace gnash {
  33     class SimpleBuffer;
  34     namespace sound {
  35         class InputStream;
  36         class StreamingSound;
  37     }
  38     namespace media {
  39         class MediaHandler;
  40     }
  41 }
  42
  43 namespace gnash {
  44 namespace sound {
  45
  46 /// Definition of an embedded sound
  47 class StreamingSoundData
  48 {
  49 public:
  50
  51     /// Container for the active instances of this sounds being played
  52     //
  53     /// NOTE: This class does NOT own the active sounds
  54     typedef std::list<InputStream*> Instances;
  55
  56     /// Construct a sound with given data, info and volume.
  57     //
  58     /// @param info encoding info
  59     /// @param nVolume initial volume (0..100).
  60     StreamingSoundData(media::SoundInfo info, int nVolume);
  61
  62     ~StreamingSoundData();
  63
  64     /// Append a sound data block
  65     //
  66     /// @param data          Undecoded sound data. Must be appropriately
  67     ///                      padded (see MediaHandler::getInputPaddingBytes())
  68     /// @param sampleCount   The number of samples when decoded.
  69     /// @param seekSamples   Where to start playing from at a particular frame.
  70     size_t append(SimpleBuffer data, size_t sampleCount,
  71             int seekSamples);
  72
  73     /// Do we have any data?
  74     bool empty() const {
  75         return _buffers.empty();
  76     }
  77
  78     const SimpleBuffer& getBlock(size_t index) const {
  79         return _buffers[index];
  80     }
  81
  82     size_t getSampleCount(size_t index) const {
  83         return _blockData[index].sampleCount;
  84     }
  85
  86     size_t getSeekSamples(size_t index) const {
  87         return _blockData[index].seekSamples;
  88     }
  89
  90     size_t blockCount() const {
  91         return _buffers.size();
  92     }
  93
  94     size_t playingBlock() const;
  95
  96     /// Are there known playing instances of this sound ?
  97     //
  98     /// Locks _soundInstancesMutex
  99     ///
 100     bool isPlaying() const;
 101
 102     /// Return number of playing instances of this sound
 103     //
 104     /// Locks _soundInstancesMutex
 105     ///
 106     size_t numPlayingInstances() const;
 107
 108     /// Append to the given vector all playing instances of this sound def
 109     void getPlayingInstances(std::vector<InputStream*>& to) const;
 110
 111     /// Return the first created instance of this sound
 112     //
 113     /// Locks _soundInstancesMutex
 114     ///
 115     InputStream* firstPlayingInstance() const;
 116
 117     /// Create an instance of this sound
 118     //
 119     /// The returned instance ownership is transferred
 120     ///
 121     /// @param mh               The MediaHandler to use for on-demand decoding
 122     /// @param blockOffset      Block number in the immutable (encoded) data
 123     ///                         this instance should start decoding.
 124     ///                         This refers to a specific StreamSoundBlock.
 125     ///                         @see gnash::swf::StreamSoundBlockTag
 126     /// Locks the _soundInstancesMutex when pushing to it
 127     std::unique_ptr<StreamingSound> createInstance(media::MediaHandler& mh,
 128             unsigned long blockOffset);
 129
 130     /// Drop all active sounds
 131     //
 132     /// Locks _soundInstancesMutex
 133     ///
 134     void clearInstances();
 135
 136     /// Drop an active sound (by iterator)
 137     //
 138     /// Does *NOT* lock the _soundInstancesMutex
 139     ///
 140     /// @return iterator after the one being erased
 141     ///
 142     Instances::iterator eraseActiveSound(Instances::iterator i);
 143
 144     /// Drop an active sound (by pointer)
 145     //
 146     /// @param inst The active sound instance to unregister
 147     ///
 148     /// This is intended to be called by StreamingSoundDataInst
 149     /// destructor, which may be called by a separate thread
 150     /// so MUST be thread-safe
 151     ///
 152     /// Does lock the _soundInstancesMutex
 153     void eraseActiveSound(InputStream* inst);
 154
 155     /// Object holding information about the sound
 156     media::SoundInfo soundinfo;
 157
 158     /// Volume for AS-sounds, range: 0-100.
 159     /// It's the SWF range that is represented here.
 160     int volume;
 161
 162 private:
 163
 164     struct BlockData
 165     {
 166         BlockData(size_t count, int seek)
 167             :
 168             sampleCount(count),
 169             seekSamples(seek)
 170         {}
 171
 172         size_t sampleCount;
 173         size_t seekSamples;
 174     };
 175
 176     /// Playing instances of this sound definition
 177     //
 178     /// Multithread access to this member is protected
 179     /// by the _soundInstancesMutex mutex
 180     Instances _soundInstances;
 181
 182     /// Mutex protecting access to _soundInstances
 183     mutable std::mutex _soundInstancesMutex;
 184
 185     std::vector<SimpleBuffer> _buffers;
 186
 187     std::vector<BlockData> _blockData;
 188 };
 189
 190 } // gnash.sound namespace
 191 } // namespace gnash
 192
 193 #endif // SOUND_EMBEDSOUND_H