sdlmixer.h

Go to the documentation of this file.

/*
  libwt - Vassilis Virvilis Toolkit - a widget library
  Copyright (C) 2006 Vassilis Virvilis <vasvir2@fastmail.fm>
 
  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.
  
  This library 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
  Lesser General Public License for more details.
  
  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the
  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  Boston, MA  02111-1307, SA.
*/

#ifndef WT_SDLMIXER_H
#define _SDLMIXER_H

// \todo Music is not forward declarable
#include <SDL/SDL_mixer.h>

#include <boost/shared_ptr.hpp>

#include <wt/flagmap.h>
#include <wt/audio.h>

struct Mix_Chunk;

namespace Wt {

/// Wrapper class around the audio mixer
class SDLMixer : public Audio {
    friend class Singleton<Audio>;
public:
    static Factory<Audio, SDLMixer> factory;

    //forward declaration needed
    class Channel;
    /// SDLMixer::Chunk implementation class
class Chunk : public Audio::Chunk {
        friend class SDLMixer;
        friend class Channel;
    public:
        virtual void setVolume(int volume);
        virtual void play(int duration = -1);
        virtual void fadeIn(int ms, int duration = -1);
        virtual void fadeOut(int ms);

        /// pause chunk
        virtual void pause();
        /// resume chunk
        virtual void resume();
        /// stop chunk
        virtual void stop(int ms = 0);

        virtual bool playing() const;
        virtual bool paused() const;

        operator Mix_Chunk *() {
            return chunk_p.get();
        }

        operator const Mix_Chunk *() const {
            return chunk_p.get();
        }

        virtual Audio::Channel *channel() const;

        virtual Audio::Chunk *clone() const;
        virtual void detach();

        ~Chunk();

    protected:
        Chunk(Mix_Chunk *chunk);

    private:
        /// wraps up the Mix_Chunk deletion so we can use
        /// boost smart pointers with it
        class Deleter {
        public:
            void operator()(Mix_Chunk* c);
        };

        typedef boost::shared_ptr<Mix_Chunk> Ptr;
        Ptr chunk_p;
        int channel_id;
    };

    virtual Audio::Chunk* loadChunk(const std::string& filename) const;

class Channel : public Audio::Channel {
        friend class Audio;
        friend class SDLMixer;
        friend class Chunk;
    public:
        virtual void setVolume(int);
        virtual void play(Audio::Chunk& chunk, int duration = -1);
        virtual void fadeIn(Audio::Chunk& chunk, int ms, int duration = -1);
        virtual void fadeOut(int ms);
        /// pause channel
        virtual void pause();
        /// resume channel
        virtual void resume();
        /// stop channel
        virtual void stop(int ms = 0);

        virtual bool playing() const;
        virtual bool paused() const;
        virtual int fading() const;

        virtual Audio::Chunk *chunk() const;

    protected:
        Channel(int id);
    private:
        Audio::Chunk *chunk_p;
        int channel_id;
    };

    virtual int allocateChannels(int channels);

    /// pause all channels
    virtual void pause();
    /// resume all channels
    virtual void resume();
    /// stop all channels
    virtual void stop(int ms = 0);
    virtual void fadeOut(int ms);

    virtual int playingChannels() const;
    virtual int pausedChannels() const;

    virtual bool isAvailable() const;

    //music
class Music : public Audio::Music {
        friend class SDLMixer;
    protected:
        Music(Mix_Music *music_p);
    public:
        virtual int type() const;

        operator Mix_Music *() const {
            return music_p;
        }

        virtual ~Music();
    private:
        Mix_Music *music_p;
    };

    virtual Audio::Music *loadMusic(const std::string& filename);
    virtual void playMusic(Audio::Music&);
    virtual void fadeInMusic(Audio::Music&, int ms);
    virtual void fadeOutMusic(int ms);
    virtual void setMusicVolume(int volume);
    virtual void pauseMusic();
    virtual void rewindMusic();
    virtual bool setMusicPosition(double start_sec);
    virtual void stopMusic();
    virtual bool playingMusic() const;
    virtual bool pausedMusic() const;
    virtual int musicFading() const;

protected:
    ~SDLMixer();
    SDLMixer();
    static Audio* load();

    virtual int minHWVolume() const;
    virtual int maxHWVolume() const;

    /// callback called when a channel finishes
    static void onChannelFinish(int channel);

private:
    static FlagMap fadingTypeMap;
    static FlagMap musicTypeMap;
};

} // namespace Wt

#endif // _SDLMIXER_H

---

Generated Fri Jul 28 19:23:00 2006.
Copyright © 1998-2003 by the respective authors.

This document is licensed under the terms of the GNU Free Documentation License and may be freely distributed under the conditions given by this license.