StreamingSoundData.h

Go to the documentation of this file.

// StreamingSoundData.h - embedded sound definition, for gnash
// 
//   Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
//   Free Software Foundation, Inc
// 
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

#ifndef SOUND_STREAMING_SOUND_DATA_H
#define SOUND_STREAMING_SOUND_DATA_H

#include <vector>
#include <map> 
#include <memory> 
#include <set> 
#include <cassert>
#include <boost/thread/mutex.hpp>
#include <boost/scoped_ptr.hpp>
#include <boost/ptr_container/ptr_vector.hpp>

#include "SimpleBuffer.h" 
#include "SoundInfo.h" 

// Forward declarations
namespace gnash {
    namespace sound {
        class InputStream;
        class StreamingSound;
    }
    namespace media {
        class MediaHandler;
    }
}

namespace gnash {
namespace sound {

class StreamingSoundData
{
public:

    //
    typedef std::list<InputStream*> Instances;

    //
    StreamingSoundData(const media::SoundInfo& info, int nVolume);

    ~StreamingSoundData();

    //
    size_t append(std::auto_ptr<SimpleBuffer> data, size_t sampleCount,
            int seekSamples);

    bool empty() const {
        return _buffers.empty();
    }

    const SimpleBuffer& getBlock(size_t index) const {
        return _buffers[index];
    }

    size_t getSampleCount(size_t index) const {
        return _blockData[index].sampleCount;
    }

    size_t getSeekSamples(size_t index) const {
        return _blockData[index].seekSamples;
    }

    size_t blockCount() const {
        return _buffers.size();
    }

    size_t playingBlock() const;

    //
    bool isPlaying() const;

    //
    size_t numPlayingInstances() const;

    void getPlayingInstances(std::vector<InputStream*>& to) const;

    //
    InputStream* firstPlayingInstance() const;

    //
    std::auto_ptr<StreamingSound> createInstance(media::MediaHandler& mh,
            unsigned long blockOffset);

    //
    void clearInstances();

    //
    Instances::iterator eraseActiveSound(Instances::iterator i);

    //
    void eraseActiveSound(InputStream* inst);

    media::SoundInfo soundinfo;

    int volume;

private:

    struct BlockData
    {
        BlockData(size_t count, int seek)
            :
            sampleCount(count),
            seekSamples(seek)
        {}

        size_t sampleCount;
        size_t seekSamples;
    };

    //
    Instances _soundInstances;

    mutable boost::mutex _soundInstancesMutex;

    boost::ptr_vector<SimpleBuffer> _buffers;

    std::vector<BlockData> _blockData;
};

} // gnash.sound namespace 
} // namespace gnash

#endif // SOUND_EMBEDSOUND_H