sound_handler.h

Go to the documentation of this file.

// 
//   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_HANDLER_H
#define SOUND_HANDLER_H

#ifdef HAVE_CONFIG_H
#include "gnashconfig.h"
#endif

#include <string>
#include <vector>
#include <memory>
#include <limits>
#include <set>
#include <boost/scoped_ptr.hpp>

#include "dsodefs.h" // for DSOEXPORT
#include "MediaHandler.h" // for inlined ctor
#include "SoundEnvelope.h" // for SoundEnvelopes typedef
#include "AuxStream.h" // for aux_streamer_ptr typedef
#include "WAVWriter.h" // for dtor visibility 

namespace gnash {
    namespace media {
        class SoundInfo;
    }
    namespace sound {
        class EmbedSound;
        class StreamingSound;
        class StreamingSoundData;
        class InputStream;
    }
    class SimpleBuffer;
}

namespace gnash {

//
namespace sound {

//
//
class DSOEXPORT sound_handler
{
public:

    virtual ~sound_handler();

    //
    typedef unsigned long StreamBlockId;


    //
    virtual void stop_all_sounds();

    
    //
    virtual int create_sound(std::auto_ptr<SimpleBuffer> data,
            const media::SoundInfo& sinfo);
        
    //
    //
    virtual void stopEventSound(int sound_handle);

    //
    virtual void stopAllEventSounds();

    //
    //
    virtual void delete_sound(int sound_handle);

    //
    void startSound(int id, int loops, const SoundEnvelopes* env,
                   bool allowMultiple, unsigned int inPoint = 0,
                   unsigned int outPoint = 
                   std::numeric_limits<unsigned int>::max());

    //
    //
    bool isSoundPlaying(int id) const;
    
    //
    virtual void set_volume(int sound_handle, int volume);
    
    //
    virtual unsigned int get_duration(int sound_handle) const;

    //
    virtual unsigned int tell(int sound_handle) const;

    //
    virtual int get_volume(int sound_handle) const;


    virtual int createStreamingSound(const media::SoundInfo& sinfo);

    //
    virtual void stopStreamingSound(int handle);

    virtual StreamBlockId addSoundBlock(std::auto_ptr<SimpleBuffer> data,
               size_t sampleCount, int seekSamples, int streamId);

    //
    //
    virtual media::SoundInfo* get_sound_info(int handle) const;

    //
    //
    //
    void playStream(int handle, StreamBlockId blockId);

    //
    //
    int getStreamBlock(int handle) const;


    //
    int getFinalVolume() const { return _volume; }

    //
    void setFinalVolume(int v) { _volume = v; }

    //
    virtual void reset();
        
    virtual void mute();

    virtual void unmute();

    //
    virtual bool is_muted() const;

    virtual void pause() { _paused=true; }

    virtual void unpause() { _paused=false; }

    bool isPaused() const { return _paused; }

    //
    virtual InputStream* attach_aux_streamer(aux_streamer_ptr ptr, void* udata);

    //
    //
    virtual void unplugInputStream(InputStream* id);

    //
    size_t numSoundsStarted() const { return _soundsStarted; }

    //
    size_t numSoundsStopped() const { return _soundsStopped; }

    //
    virtual void fetchSamples(boost::int16_t* to, unsigned int nSamples);

    //
    virtual void mix(boost::int16_t* outSamples, boost::int16_t* inSamples,
                unsigned int nSamples, float volume) = 0;

    //
    void setAudioDump(const std::string& wavefile);

    //
    bool streamingSound() const;

protected:

    sound_handler(media::MediaHandler* m)
        :
        _soundsStarted(0),
        _soundsStopped(0),
        _paused(false),
        _muted(false),
        _volume(100),
        _mediaHandler(m)
    {
    }

    //
    virtual void plugInputStream(std::auto_ptr<InputStream> in);

    virtual void unplugAllInputStreams();

    bool hasInputStreams() const;

    //
    virtual void delete_all_sounds();

private:

    size_t _soundsStarted;

    size_t _soundsStopped;

    bool _paused;

    bool _muted;

    int _volume;

    typedef std::vector<EmbedSound*> Sounds;

    //
    Sounds  _sounds;

    typedef std::vector<StreamingSoundData*> StreamingSounds;

    //
    StreamingSounds _streamingSounds;

    void stopEmbedSoundInstances(EmbedSound& def);

    void stopEmbedSoundInstances(StreamingSoundData& def);

    typedef std::set<InputStream*> InputStreams;

    //
    InputStreams _inputStreams;

    media::MediaHandler* _mediaHandler;

    void unplugCompletedInputStreams();

    boost::scoped_ptr<WAVWriter> _wavWriter;

};

// TODO: move to appropriate specific sound handlers

#ifdef SOUND_SDL

DSOEXPORT sound_handler* create_sound_handler_sdl(media::MediaHandler* m);
#elif defined(SOUND_AHI)

DSOEXPORT sound_handler* create_sound_handler_aos4(media::MediaHandler* m);
#elif defined(SOUND_MKIT)

DSOEXPORT sound_handler* create_sound_handler_mkit(media::MediaHandler* m);
#endif

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

#endif // SOUND_HANDLER_H


// Local Variables:
// mode: C++
// indent-tabs-mode: t
// End: