audio.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_events.h>

#include <boost/assign/list_of.hpp>

#include "sdlevent.h"
#include "sdlmixer.h"

#include <wt/trace.h>
#include <wt/application.h>
#include <wt/audio.h>

namespace Wt {

Factory<Audio, NullAudio> NullAudio::factory;

Audio::FactoryList Audio::factories= boost::assign::list_of<AudioBaseFactory *>
                                     (&SDLMixer::factory)
                                     (&NullAudio::factory);

Audio::FadingType::Member Audio::FadingType::None = 0;
Audio::FadingType::Member Audio::FadingType::Out;
Audio::FadingType::Member Audio::FadingType::In;

Audio::MusicType::Member Audio::MusicType::None = 0;
Audio::MusicType::Member Audio::MusicType::Cmd;
Audio::MusicType::Member Audio::MusicType::WAV;
Audio::MusicType::Member Audio::MusicType::MOD;
Audio::MusicType::Member Audio::MusicType::MID;
Audio::MusicType::Member Audio::MusicType::OGG;
Audio::MusicType::Member Audio::MusicType::MP3;

Audio::Audio()
        : Singleton<Audio>(this),
musicLoops(1) {
    SDLEvent& sdlevent = *SDLEvent::instance();
    sdlevent[SDLEvent::Audio] = &handleAudioEvent;
}

Audio::~Audio() {
    trace("audio", "Entering Destructor for Audio\n");
}

Audio* Audio::load() {
    //this code never runs if we are initialized
    FactoryList::iterator it = factories.begin(), end = factories.end();
    Audio *audio;

    trace("audio", "Audio initialization...\n");
    do {
        audio = (*it)->instance();
        ++it;
    } while (!audio && it != end);

    trace("audio", "Audio driver %p\n", instance_);
    return audio;
}

Audio::Chunk* Audio::loadChunk(const std::string&) const {
    return 0;
}

int Audio::numChannels() const {
    return channels.size();
}

Audio::Channel *Audio::operator[](int i) const {
    return channels[i];
}

int Audio::allocateChannels(int) {
    return channels.size();
}

/// pause all channels
void Audio::pause() {}

/// resume all channels
void Audio::resume() {}

/// stop all channels
void Audio::stop(int) {}

void Audio::fadeOut(int) {}

int Audio::playingChannels() const {
    return 0;
}

int Audio::pausedChannels() const {
    return 0;
}

bool Audio::isAvailable() const {
    return false;
}

// ************* music *****************
Audio::Music *Audio::loadMusic(const std::string&) {
    return new Music;
}

Audio::Music::Music() {}
Audio::Music::~Music() {}

void Audio::playMusic(Music&) {
    trace("audio", "Audio::playMusic() called\n");
}

void Audio::fadeInMusic(Music&, int) {}

void Audio::fadeOutMusic(int) {}

void Audio::setMusicVolume(int) {}

void Audio::pauseMusic() {}

void Audio::rewindMusic() {}

bool Audio::setMusicPosition(double) {
    return false;
}

void Audio::stopMusic() {}

bool Audio::playingMusic() const {
    return false;
}

bool Audio::pausedMusic() const {
    return false;
}

int Audio::musicFading() const {
    return 0;
}

int Audio::Music::type() const {
    return 0;
}

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

int Audio::maxHWVolume() const {
    return 1;
}

int Audio::HWVolume(int volume) const {
    return (maxHWVolume() - minHWVolume()) *  volume /
           (maxVolume - minVolume);
}

/*! posts a SDL type event (SDLEvent::Audio)
in the SDL event queue. By the time the event
it is dispatched all SDL actions are allowed.
*/
void Audio::onChannelFinish(int channel_id) {
    Audio& self = *instance();
    Channel *channel = self.channels[channel_id];
    Chunk *chunk = channel->chunk();

    SDL_Event event;

    event.type = SDLEvent::Audio;
    event.user.code = 0;
    event.user.data1 = new Event(channel, chunk);
    event.user.data2 = 0;

    trace("audio", "channelFinished callback called %d\n", channel_id);
    SDLEvent::push(&event);
}

/*! posts a SDL type event (SDLEvent::Audio)
in the SDL event queue. By the time the event
it is dispatched all SDL actions are allowed.
*/
void Audio::onMusicFinish() {
    SDL_Event event;

    event.type = SDLEvent::Audio;
    event.user.code = 0;
    event.user.data1 = new Event(0, 0);
    event.user.data2 = 0;

    trace("audio", "musicFinished callback called\n");

    SDLEvent::push(&event);
}

/// SDLEvent::Audio handler
/*! it emits the required signal to all interested parties */
void Audio::handleAudioEvent(const SDL_Event *event) {
    trace("audio", "audio event delivered\n");
    Event *sdl_audio_event = static_cast<Event *>(event->user.data1);
    Chunk *chunk = sdl_audio_event->chunk();
    Channel *channel = sdl_audio_event->channel();
    if (chunk && channel) {
        chunk->finished(chunk);
        channel->finished(channel);
        instance()->finished(channel);
    } else {
        instance()->musicFinished();
    }
    delete sdl_audio_event;
}

// ********* Audio::Chunk ***************

Audio::Chunk::Chunk()
        : loops(1) {}

Audio::Chunk::~Chunk() {
    stop();
}

void Audio::Chunk::setVolume(int) {}

void Audio::Chunk::play(int) {}

void Audio::Chunk::fadeIn(int, int) {}

void Audio::Chunk::fadeOut(int) {}

/// pause chunk
void Audio::Chunk::pause() {}

/// resume chunk
void Audio::Chunk::resume() {}

/// stop chunk
void Audio::Chunk::stop(int) {}

bool Audio::Chunk::playing() const {
    return false;
}

bool Audio::Chunk::paused() const {
    return false;
}

Audio::Channel *Audio::Chunk::channel() const {
    return 0;
}

Audio::Chunk *Audio::Chunk::clone() const {
    return 0;
}

void Audio::Chunk::detach() {}

// ********* Audio::Channel ***************

Audio::Channel::Channel() :
loops(1) {}

Audio::Channel::~Channel() {}

void Audio::Channel::setVolume(int) {}

void Audio::Channel::play(Chunk&, int) {
    trace("audio", "Audio::Channel::play()\n");
}

void Audio::Channel::fadeIn(Chunk&, int, int) {}

void Audio::Channel::fadeOut(int) {}

/// pause channel
void Audio::Channel::pause() {}

/// resume channel
void Audio::Channel::resume() {}

/// stop channel
void Audio::Channel::stop(int) {}

bool Audio::Channel::playing() const {
    return false;
}

bool Audio::Channel::paused() const {
    return false;
}

int Audio::Channel::fading() const {
    return 0;
}

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

// ********* NullAudio ***************

NullAudio::NullAudio() {
    // allocate one channel so we don't crash
    adjustAllocatedChannels<NullAudio>(0, 1);
}

NullAudio::~NullAudio() {
    allocateChannels(0);
}

Audio* NullAudio::load() {
    trace("audio", "NullAudio initialization...ok\n");
    return new NullAudio;
}

Audio::Chunk* NullAudio::loadChunk(const std::string&) const {
    return new Chunk;
}

// ********* NullAudio::Chunk ***************

NullAudio::Chunk::Chunk() : Audio::Chunk() {}

Audio::Channel *NullAudio::Chunk::channel() const {
    // we go through this to avoid protections
    NullAudio& self = * static_cast<NullAudio *>(instance());
    return static_cast<NullAudio::Channel *>(self.channels[0]);
}

void NullAudio::Chunk::play(int duration) {
    trace("audio", "NullAudio::Chunk::play()\n");
    Audio::Chunk::channel<NullAudio>()->play(*this, duration);
}

void NullAudio::Chunk::fadeIn(int ms, int duration) {
    trace("audio", "NullAudio::Chunk::fadeIn()\n");
    Audio::Chunk::channel<NullAudio>()->fadeIn(*this, ms, duration);
}

Audio::Chunk *NullAudio::Chunk::clone() const {
    return new Chunk;
}

void NullAudio::Chunk::detach() {}

// ********* NullAudio::Channel ***************

NullAudio::Channel::Channel(int) : Audio::Channel() {}

void NullAudio::Channel::play(Audio::Chunk& chunk, int) {
    trace("audio", "NullAudio::Channel::play()\n");
    chunk_p = &chunk;
    onChannelFinish(0);
}

void NullAudio::Channel::fadeIn(Audio::Chunk& chunk, int, int) {
    trace("audio", "NullAudio::Channel::fadeIn()\n");
    chunk_p = &chunk;
    onChannelFinish(0);
}

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

void NullAudio::playMusic(Music&) {
    trace("audio", "NullAudio::playMusic() called\n");
    onMusicFinish();
}

void NullAudio::fadeInMusic(Music&, int) {
    onMusicFinish();
}

} // namespace Wt

---

Generated Fri Jul 28 19:22:59 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.