sdlmixer.cpp

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.
*/

#include <SDL/SDL.h>

#include <boost/assign/list_of.hpp> // for 'map_list_of()'

#include "sdlmixer.h"
#include <wt/trace.h>

namespace Wt {

Factory<Audio, SDLMixer> SDLMixer::factory;

FlagMap SDLMixer::fadingTypeMap;
FlagMap SDLMixer::musicTypeMap;

SDLMixer::SDLMixer()
        : Audio() {

    // we can't reliably initialize staticly since we have to make
    // sure the enumeration is initialized first and this depends
    // from the linking order (static initialization fiasco)
    fadingTypeMap = boost::assign::map_list_of
                    (MIX_NO_FADING, FadingType::None)
                    (MIX_FADING_OUT, FadingType::Out)
                    (MIX_FADING_IN, FadingType::In);

    musicTypeMap = boost::assign::map_list_of
                   (MUS_NONE, MusicType::None)
                   (MUS_CMD, MusicType::Cmd)
                   (MUS_WAV, MusicType::WAV)
                   (MUS_MOD, MusicType::MOD)
                   (MUS_MID, MusicType::MID)
                   (MUS_OGG, MusicType::OGG)
                   (MUS_MP3, MusicType::MP3);

    adjustAllocatedChannels<SDLMixer>(0, Mix_AllocateChannels(-1));
    Mix_ChannelFinished(onChannelFinish);
    Mix_HookMusicFinished(onMusicFinish);
}

SDLMixer::~SDLMixer() {
    trace("sdlmixer", "Entering Destructor for SDLMixer\n");
    allocateChannels(0);
    Mix_CloseAudio();
}

Audio* SDLMixer::load() {
    trace("sdlmixer", "Initializing SDL audio...\n");
    if (SDL_InitSubSystem(SDL_INIT_AUDIO) < 0) {
        trace("sdlmixer", "Initialize SDL audio: %s\n", SDL_GetError());
        goto fail;
    }

    int audio_rate, audio_channels;
    Uint16 audio_format;
    int chunksize;

    audio_format = MIX_DEFAULT_FORMAT;
    audio_channels = MIX_DEFAULT_CHANNELS;

    //undef this (HIFI) to reduce CPU by a 5%
    audio_rate = MIX_DEFAULT_FREQUENCY;
    chunksize = 1024;
    //audio_rate = 44100;
    //chunksize = 2048;

    /* Open the audio device */
    if (Mix_OpenAudio(audio_rate, audio_format,
                      audio_channels, chunksize) < 0) {
        trace("sdlmixer", "Initializing SDLMixer failed: %s\n", SDL_GetError());
        SDL_QuitSubSystem(SDL_INIT_AUDIO);
        goto fail;
    }

    Mix_QuerySpec(&audio_rate, &audio_format, &audio_channels);
    trace("sdlmixer") << "Opened audio at "<< audio_rate <<
    " Hz " << (audio_format & 0xFF) << "bit " <<
    ((audio_channels > 1) ? "stereo" : "mono") << std::endl;

    trace("audio", "SDLMixer initialization...ok\n");
    return new SDLMixer();

fail:
    trace("audio", "SDLMixer initialization...fail\n");
    return 0;
}

Audio::Chunk* SDLMixer::loadChunk(const std::string& filename) const {
    Mix_Chunk *chunk = Mix_LoadWAV(filename.c_str());
    return (chunk) ? new SDLMixer::Chunk(chunk) : 0;
}

int SDLMixer::allocateChannels(int num_channels) {
    const int oldnum = numChannels();
    assert(Mix_AllocateChannels(-1) == oldnum);

    if (num_channels == oldnum || num_channels < 0)
        return oldnum;

    adjustAllocatedChannels<SDLMixer>(oldnum,
                                      Mix_AllocateChannels(num_channels));

    return numChannels();
}

void SDLMixer::pause() {
    Mix_Pause(-1);
}

void SDLMixer::resume() {
    Mix_Resume(-1);
}

void SDLMixer::stop(int ms) {
    (ms) ? Mix_ExpireChannel(-1, ms) :
    Mix_HaltChannel(-1);
}

void SDLMixer::fadeOut(int ms) {
    Mix_FadeOutChannel(-1, ms);
}

int SDLMixer::playingChannels() const {
    return Mix_Playing(-1);
}

int SDLMixer::pausedChannels() const {
    return Mix_Paused(-1);
}

bool SDLMixer::isAvailable() const {
    return true;
}

// ************* SDLMixer::Music *****************
Audio::Music *SDLMixer::loadMusic(const std::string& filename) {
    Mix_Music *m = Mix_LoadMUS(filename.c_str());
    return (m) ? new Music(m) : 0;
}

SDLMixer::Music::Music(Mix_Music *music_p)
        : Audio::Music(),
music_p(music_p) {
    trace("sdlmixer", "SDLMixer::Music::Music() constructor called\n");
}

SDLMixer::Music::~Music() {
    Mix_FreeMusic(music_p);
}

/// it blocks until any previously music fading out is done
void SDLMixer::playMusic(Audio::Music& music) {
    SDLMixer::Music& m = * static_cast<SDLMixer::Music *>(&music);
    trace("sdlmixer", "SDLMixer::playMusic() called\n");
    Mix_PlayMusic(m, musicLoops - 1);
}

void SDLMixer::fadeInMusic(Audio::Music& music, int ms) {
    SDLMixer::Music& m = * static_cast<SDLMixer::Music *>(&music);
    Mix_FadeInMusic(m, musicLoops - 1, ms);
}

void SDLMixer::fadeOutMusic(int ms) {
    Mix_FadeOutMusic(ms);
}

void SDLMixer::setMusicVolume(int volume) {
    SDLMixer& self = * static_cast<SDLMixer *>(instance());
    int hwvol = self.HWVolume(volume);
    Mix_VolumeMusic(hwvol);
}

void SDLMixer::pauseMusic() {
    Mix_PauseMusic();
}

void SDLMixer::rewindMusic() {
    Mix_RewindMusic();
}

bool SDLMixer::setMusicPosition(double start_sec) {
    return !Mix_SetMusicPosition(start_sec);
}

void SDLMixer::stopMusic() {
    Mix_HaltMusic();
}

bool SDLMixer::playingMusic() const {
    return Mix_PlayingMusic();
}

bool SDLMixer::pausedMusic() const {
    return Mix_PausedMusic();
}

int SDLMixer::musicFading() const {
    return fadingTypeMap[Mix_FadingMusic()];
}

int SDLMixer::Music::type() const {
    return musicTypeMap[Mix_GetMusicType(music_p)];
}

int SDLMixer::minHWVolume() const {
    return 0;
}

int SDLMixer::maxHWVolume() const {
    return MIX_MAX_VOLUME;
}

void SDLMixer::onChannelFinish(int channel_id) {
    Audio::onChannelFinish(channel_id);
    // if this function is called  SDLMixer is running
    // so all static casts are safe
    SDLMixer& self = * static_cast<SDLMixer *>(instance());
    SDLMixer::Channel *channel =
        static_cast<SDLMixer::Channel *>(self.channels[channel_id]);
    SDLMixer::Chunk *chunk = static_cast<SDLMixer::Chunk *>(channel->chunk());
    channel->chunk_p = 0;
    chunk->channel_id = -1;
}

// ********* SDLMixer::Chunk ***************

SDLMixer::Chunk::Chunk(Mix_Chunk *mix_chunk_p)
        : Audio::Chunk(),
        chunk_p(mix_chunk_p, Deleter()),
channel_id(-1) {
    trace("sdlmixer",
          "SDLMixer::Chunk Creating chunk %p (%p)\n", this, mix_chunk_p);
    setVolume(Audio::maxVolume);
}

SDLMixer::Chunk::~Chunk() {
    trace("sdlmixer",
          "SDLMixer::~Chunk Stoping chunk %p (%p)\n",
          this, chunk_p.get());
    stop();
}

void SDLMixer::Chunk::setVolume(int volume) {
    SDLMixer& self = * static_cast<SDLMixer *>(instance());
    int hwvol = self.HWVolume(volume);
    detach();
    Mix_VolumeChunk(*this, hwvol);
}

void SDLMixer::Chunk::play(int duration) {
    detach();
    channel_id = Mix_PlayChannelTimed(-1, *this, loops - 1, duration);
    if (channel_id >= 0)
        Audio::Chunk::channel<SDLMixer>()->chunk_p = this;
}

void SDLMixer::Chunk::fadeIn(int ms, int duration) {
    detach();
    channel_id = Mix_FadeInChannelTimed(-1, *this, loops - 1, ms, duration);
    if (channel_id >= 0)
        Audio::Chunk::channel<SDLMixer>()->chunk_p = this;
}

void SDLMixer::Chunk::fadeOut(int ms) {
    if (channel_id < 0)
        return;
    Mix_FadeOutChannel(channel_id, ms);
}

void SDLMixer::Chunk::pause() {
    if (channel_id < 0)
        return;
    Mix_Pause(channel_id);
}

void SDLMixer::Chunk::resume() {
    if (channel_id < 0)
        return;
    Mix_Resume(channel_id);
}

void SDLMixer::Chunk::stop(int ms) {
    if (channel_id < 0)
        return;
    (ms) ? Mix_ExpireChannel(channel_id, ms) :
    Mix_HaltChannel(channel_id);
}

bool SDLMixer::Chunk::playing() const {
    return (channel_id < 0) ? false : Mix_Playing(channel_id);
}

bool SDLMixer::Chunk::paused() const {
    return (channel_id < 0) ? false : Mix_Paused(channel_id);
}

Audio::Channel *SDLMixer::Chunk::channel() const {
    SDLMixer& self = * static_cast<SDLMixer *>(instance());
    return (channel_id < 0) ? 0 : self.channels[channel_id];
}

static Mix_Chunk *clone_chunk(const Mix_Chunk *chunk_p) {
    Mix_Chunk *new_chunk_p = static_cast<Mix_Chunk *>(malloc(sizeof(Mix_Chunk)));
    *new_chunk_p = *chunk_p;
    new_chunk_p->allocated = 0;
    trace("sdlmixer", "clone_chunk %p --> %p\n", chunk_p, new_chunk_p);
    return new_chunk_p;
}

void SDLMixer::Chunk::Deleter::operator()(Mix_Chunk *c) {
    trace("sdlmixer",
          "SDLMixer::Chunk::Deleter Deleting Mix_Chunk (%p)\n", c);
    Mix_FreeChunk(c);
}

Audio::Chunk *SDLMixer::Chunk::clone() const {
    trace("sdlmixer", "SDLMixer::Chunk::clone %p\n", this);
    return new Chunk(clone_chunk(*this));
}

void SDLMixer::Chunk::detach() {
    trace("sdlmixer", "SDLMixer::Chunk::detach %p\n", this);
    //avoid detaching if we are the only client for this Sound
    if (!chunk_p.unique()) {
        trace("sdlmixer", "SDLMixer::Chunk::detaching %p\n", this);
        chunk_p.reset(clone_chunk(*this), Deleter());
    }
}

// ********* SDLMixer::Channel ***************

SDLMixer::Channel::Channel(int id) :
        Audio::Channel(),
        chunk_p(0),
channel_id(id) {}

void SDLMixer::Channel::setVolume(int volume) {
    SDLMixer& self = * static_cast<SDLMixer *>(instance());
    int hwvol = self.HWVolume(volume);
    Mix_Volume(channel_id, hwvol);
}

void SDLMixer::Channel::play(Audio::Chunk& chunk, int duration) {
    trace("sdlmixer", "SDLMixer::Channel::play()\n");
    SDLMixer::Chunk& c = * static_cast<SDLMixer::Chunk *>(&chunk);
    int status = Mix_PlayChannelTimed(channel_id, c,
                                      loops - 1, duration);
    if (!status)
        chunk_p = &c;
}

void SDLMixer::Channel::fadeIn(Audio::Chunk& chunk, int ms, int duration) {
    SDLMixer::Chunk& c = * static_cast<SDLMixer::Chunk *>(&chunk);
    int status = Mix_FadeInChannelTimed(channel_id, c,
                                        loops - 1, ms, duration);
    if (!status)
        chunk_p = &c;
}

void SDLMixer::Channel::fadeOut(int ms) {
    Mix_FadeOutChannel(channel_id, ms);
}

void SDLMixer::Channel::pause() {
    Mix_Pause(channel_id);
}

void SDLMixer::Channel::resume() {
    Mix_Resume(channel_id);
}

void SDLMixer::Channel::stop(int ms) {
    (ms) ? Mix_ExpireChannel(channel_id, ms) :
    Mix_HaltChannel(channel_id);
}

bool SDLMixer::Channel::playing() const {
    return Mix_Playing(channel_id);
}

bool SDLMixer::Channel::paused() const {
    return Mix_Paused(channel_id);
}

int SDLMixer::Channel::fading() const {
    return fadingTypeMap[Mix_FadingChannel(channel_id)];
}

Audio::Chunk *SDLMixer::Channel::chunk() const {
    return chunk_p;
}

} // namespace Wt

---

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.