RomanNum3ral
/
open_toontown_panda3d
mirror of https://github.com/open-toontown/panda3d.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

changes to temporal state for audio

This commit is contained in:
Cary Sandvig 2000-10-19 17:13:11 +00:00
parent 8b514d8e65
commit f9ac6aec59
35 changed files with 935 additions and 1062 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
panda/src/audio/Sources.pp
View File

@ -1,5 +1,6 @@
#define OTHER_LIBS dtool
#define DIRECTORY_IF_AUDIO yes
// #define USE_MIKMOD yes
#begin lib_target
#define USE_AUDIO yes
@ -10,21 +11,20 @@
#define SOURCES \
audio_manager.I audio_manager.cxx audio_manager.h audio_midi.cxx \
audio_midi.h audio_music.I audio_music.cxx audio_music.h \
audio_pool.I audio_pool.cxx audio_pool.h audio_sample.I \
audio_sample.cxx audio_sample.h audio_trait.cxx audio_trait.h \
audio_midi.h audio_pool.I audio_pool.cxx audio_pool.h \
audio_trait.cxx audio_trait.h \
config_audio.cxx config_audio.h audio_mikmod_traits.cxx \
audio_mikmod_traits.h audio_win_traits.I audio_win_traits.cxx \
audio_win_traits.h audio_null_traits.I audio_null_traits.cxx \
audio_null_traits.h audio_linux_traits.I audio_linux_traits.cxx \
audio_linux_traits.h
audio_linux_traits.h audio_sound.h audio_sound.I audio_sound.cxx
#define INSTALL_HEADERS \
audio.h audio_manager.h audio_music.h audio_pool.I audio_pool.h \
audio_sample.I audio_sample.h audio_trait.h audio_mikmod_traits.h \
audio.h audio_manager.h Audio_Pool.I audio_pool.h \
audio_trait.h audio_mikmod_traits.h \
audio_win_traits.I audio_win_traits.h audio_null_traits.I \
audio_null_traits.h audio_linux_traits.I audio_linux_traits.h \
audio_music.I config_audio.h audio_manager.I
audio_music.I config_audio.h audio_manager.I audio_sound.h audio_sound.I
#define IGATESCAN audio.h

3
panda/src/audio/audio.h
View File

@ -7,8 +7,7 @@
#define __AUDIO_H__
#include "audio_trait.h"
#include "audio_sample.h"
#include "audio_music.h"
#include "audio_sound.h"
#include "audio_manager.h"
#include "audio_pool.h"

32
panda/src/audio/audio_linux_traits.I
View File

@ -3,19 +3,39 @@
//
////////////////////////////////////////////////////////////////////
INLINE LinuxSample::LinuxSample(Buffer* b) : AudioTraits::SampleClass(),
_data(b) {
INLINE LinuxSample::LinuxSample(byte* b, unsigned long s)
: AudioTraits::SoundClass(), _data(b), _size(s) {
}
INLINE Buffer* LinuxSample::get_data(void) {
INLINE byte* LinuxSample::get_data(void) const {
return _data;
}
INLINE LinuxMusic::LinuxMusic(void) : AudioTraits::MusicClass() {
INLINE unsigned long LinuxSample::get_size(void) const {
return _size;
}
INLINE LinuxPlaying::LinuxPlaying(void) : AudioTraits::PlayingClass() {
INLINE LinuxMusic::LinuxMusic(void) : AudioTraits::SoundClass() {
}
INLINE LinuxPlayer::LinuxPlayer(void) : AudioTraits::PlayerClass() {
INLINE LinuxSamplePlaying::LinuxSamplePlaying(AudioTraits::SoundClass* s)
: AudioTraits::PlayingClass(s), _buff((Buffer*)0L) {
LinuxSample* smpl = (LinuxSample*)s;
_buff = new Buffer(smpl->get_data(), smpl->get_size());
}
INLINE Buffer* LinuxSamplePlaying::get_data(void) {
return _buff;
}
INLINE LinuxMusicPlaying::LinuxMusicPlaying(AudioTraits::SoundClass* s)
: AudioTraits::PlayingClass(s) {
}
INLINE LinuxSamplePlayer::LinuxSamplePlayer(void)
: AudioTraits::PlayerClass() {
}
INLINE LinuxMusicPlayer::LinuxMusicPlayer(void)
: AudioTraits::PlayerClass() {
}

114
panda/src/audio/audio_linux_traits.cxx
View File

@ -249,75 +249,127 @@ static void initialize(void) {
LinuxSample::~LinuxSample(void) {
}
float LinuxSample::length(void) {
return (_data->get_size()) / (audio_mix_freq * sample_size * 2.);
float LinuxSample::length(void) const {
return _size / (audio_mix_freq * sample_size * 2.);
}
AudioTraits::SampleClass::SampleStatus LinuxSample::status(void) {
BufferSet::iterator i = buffers.find(_data);
if (i != buffers.end())
return AudioTraits::SampleClass::PLAYING;
return AudioTraits::SampleClass::READY;
AudioTraits::PlayingClass* LinuxSample::get_state(void) const {
return new LinuxSamplePlaying((LinuxSample*)this);
}
LinuxPlaying* LinuxSample::get_state(void) {
return new LinuxPlaying();
AudioTraits::PlayerClass* LinuxSample::get_player(void) const {
return LinuxSamplePlayer::get_instance();
}
void LinuxSample::destroy(AudioTraits::SampleClass* sample) {
delete sample;
AudioTraits::DeleteSoundFunc* LinuxSample::get_destroy(void) const {
return LinuxSample::destroy;
}
AudioTraits::DeletePlayingFunc* LinuxSample::get_delstate(void) const {
return LinuxSamplePlaying::destroy;
}
void LinuxSample::destroy(AudioTraits::SoundClass* sound) {
delete sound;
}
LinuxSample* LinuxSample::load_raw(byte* data, unsigned long size) {
LinuxSample* ret = new LinuxSample(new Buffer(data, size));
LinuxSample* ret = new LinuxSample(data, size);
return ret;
}
LinuxMusic::~LinuxMusic(void) {
}
AudioTraits::MusicClass::MusicStatus LinuxMusic::status(void) {
return AudioTraits::MusicClass::READY;
float LinuxMusic::length(void) const {
return -1.;
}
LinuxPlaying* LinuxMusic::get_state(void) {
return new LinuxPlaying();
AudioTraits::PlayingClass* LinuxMusic::get_state(void) const {
return new LinuxMusicPlaying((LinuxMusic*)this);
}
void LinuxMusic::destroy(AudioTraits::MusicClass* music) {
AudioTraits::PlayerClass* LinuxMusic::get_player(void) const {
return LinuxMusicPlayer::get_instance();
}
AudioTraits::DeleteSoundFunc* LinuxMusic::get_destroy(void) const {
return LinuxMusic::destroy;
}
AudioTraits::DeletePlayingFunc* LinuxMusic::get_delstate(void) const {
return LinuxMusicPlaying::destroy;
}
void LinuxMusic::destroy(AudioTraits::SoundClass* music) {
delete music;
}
LinuxPlaying::~LinuxPlaying(void) {
LinuxSamplePlaying::~LinuxSamplePlaying(void) {
}
AudioTraits::PlayingClass::PlayingStatus LinuxPlaying::status(void) {
AudioTraits::PlayingClass::PlayingStatus LinuxSamplePlaying::status(void) {
LinuxSample* s = (LinuxSample*)_sound;
BufferSet::iterator i = buffers.find(_buff);
if (i != buffers.end())
return AudioTraits::PlayingClass::PLAYING;
return AudioTraits::PlayingClass::READY;
}
void LinuxSamplePlaying::destroy(AudioTraits::PlayingClass* state) {
delete state;
}
LinuxMusicPlaying::~LinuxMusicPlaying(void) {
}
AudioTraits::PlayingClass::PlayingStatus LinuxMusicPlaying::status(void) {
return AudioTraits::PlayingClass::BAD;
}
LinuxPlayer* LinuxPlayer::_global_instance = (LinuxPlayer*)0L;
LinuxPlayer::~LinuxPlayer(void) {
void LinuxMusicPlaying::destroy(AudioTraits::PlayingClass* state) {
delete state;
}
void LinuxPlayer::play_sample(AudioTraits::SampleClass* sample) {
LinuxSamplePlayer* LinuxSamplePlayer::_global_instance =
(LinuxSamplePlayer*)0L;
LinuxSamplePlayer::~LinuxSamplePlayer(void) {
}
void LinuxSamplePlayer::play_sound(AudioTraits::SoundClass*,
AudioTraits::PlayingClass* playing) {
initialize();
LinuxSample* lsample = (LinuxSample*)sample;
buffers.insert(lsample->get_data());
LinuxSamplePlaying* lplaying = (LinuxSamplePlaying*)playing;
buffers.insert(lplaying->get_data());
}
void LinuxPlayer::play_music(AudioTraits::MusicClass*) {
void LinuxSamplePlayer::set_volume(AudioTraits::PlayingClass*, int) {
}
void LinuxPlayer::set_volume(AudioTraits::SampleClass*, int) {
LinuxSamplePlayer* LinuxSamplePlayer::get_instance(void) {
if (_global_instance == (LinuxSamplePlayer*)0L)
_global_instance = new LinuxSamplePlayer();
return _global_instance;
}
void LinuxPlayer::set_volume(AudioTraits::MusicClass*, int) {
LinuxMusicPlayer* LinuxMusicPlayer::_global_instance =
(LinuxMusicPlayer*)0L;
LinuxMusicPlayer::~LinuxMusicPlayer(void) {
}
LinuxPlayer* LinuxPlayer::get_instance(void) {
if (_global_instance == (LinuxPlayer*)0L)
_global_instance = new LinuxPlayer();
void LinuxMusicPlayer::play_sound(AudioTraits::SoundClass*,
AudioTraits::PlayingClass*) {
initialize();
}
void LinuxMusicPlayer::set_volume(AudioTraits::PlayingClass*, int) {
}
LinuxMusicPlayer* LinuxMusicPlayer::get_instance(void) {
if (_global_instance == (LinuxMusicPlayer*)0L)
_global_instance = new LinuxMusicPlayer();
return _global_instance;
}

86
panda/src/audio/audio_linux_traits.h
View File

@ -57,60 +57,92 @@ public:
}
};
class LinuxPlaying;
class LinuxSamplePlaying;
class EXPCL_PANDA LinuxSample : public AudioTraits::SampleClass {
class EXPCL_PANDA LinuxSample : public AudioTraits::SoundClass {
private:
Buffer* _data;
byte* _data;
unsigned long _size;
public:
INLINE LinuxSample(Buffer*);
INLINE LinuxSample(byte*, unsigned long);
virtual ~LinuxSample(void);
virtual float length(void);
virtual AudioTraits::SampleClass::SampleStatus status(void);
virtual float length(void) const;
virtual AudioTraits::PlayingClass* get_state(void) const;
virtual AudioTraits::PlayerClass* get_player(void) const;
virtual AudioTraits::DeleteSoundFunc* get_destroy(void) const;
virtual AudioTraits::DeletePlayingFunc* get_delstate(void) const;
static void destroy(AudioTraits::SoundClass*);
public:
// used by the loader
static LinuxSample* load_raw(byte*, unsigned long);
virtual LinuxPlaying* get_state(void);
static void destroy(AudioTraits::SampleClass*);
// used by the players
INLINE Buffer* get_data(void);
INLINE byte* get_data(void) const;
INLINE unsigned long get_size(void) const;
};
class EXPCL_PANDA LinuxMusic : public AudioTraits::MusicClass {
class EXPCL_PANDA LinuxMusic : public AudioTraits::SoundClass {
public:
INLINE LinuxMusic(void);
virtual ~LinuxMusic(void);
virtual AudioTraits::MusicClass::MusicStatus status(void);
public:
virtual LinuxPlaying* get_state(void);
static void destroy(AudioTraits::MusicClass*);
virtual float length(void) const;
virtual AudioTraits::PlayingClass* get_state(void) const;
virtual AudioTraits::PlayerClass* get_player(void) const;
virtual AudioTraits::DeleteSoundFunc* get_destroy(void) const;
virtual AudioTraits::DeletePlayingFunc* get_delstate(void) const;
static void destroy(AudioTraits::SoundClass*);
};
class EXPCL_PANDA LinuxPlaying : public AudioTraits::PlayingClass {
class EXPCL_PANDA LinuxSamplePlaying : public AudioTraits::PlayingClass {
Buffer* _buff;
public:
INLINE LinuxPlaying(void);
virtual ~LinuxPlaying(void);
INLINE LinuxSamplePlaying(AudioTraits::SoundClass*);
virtual ~LinuxSamplePlaying(void);
virtual AudioTraits::PlayingClass::PlayingStatus status(void);
public:
INLINE Buffer* get_data(void);
static void destroy(AudioTraits::PlayingClass*);
};
class EXPCL_PANDA LinuxPlayer : public AudioTraits::PlayerClass {
class EXPCL_PANDA LinuxMusicPlaying : public AudioTraits::PlayingClass {
public:
INLINE LinuxPlayer(void);
virtual ~LinuxPlayer(void);
INLINE LinuxMusicPlaying(AudioTraits::SoundClass*);
virtual ~LinuxMusicPlaying(void);
virtual void play_sample(AudioTraits::SampleClass*);
virtual void play_music(AudioTraits::MusicClass*);
virtual void set_volume(AudioTraits::SampleClass*, int);
virtual void set_volume(AudioTraits::MusicClass*, int);
virtual AudioTraits::PlayingClass::PlayingStatus status(void);
static void destroy(AudioTraits::PlayingClass*);
};
class EXPCL_PANDA LinuxSamplePlayer : public AudioTraits::PlayerClass {
public:
INLINE LinuxSamplePlayer(void);
virtual ~LinuxSamplePlayer(void);
virtual void play_sound(AudioTraits::SoundClass*,
AudioTraits::PlayingClass*);
virtual void set_volume(AudioTraits::PlayingClass*, int);
public:
// used by the readers
static LinuxPlayer* get_instance(void);
static LinuxSamplePlayer* get_instance(void);
private:
static LinuxPlayer* _global_instance;
static LinuxSamplePlayer* _global_instance;
};
class EXPCL_PANDA LinuxMusicPlayer : public AudioTraits::PlayerClass {
public:
INLINE LinuxMusicPlayer(void);
virtual ~LinuxMusicPlayer(void);
virtual void play_sound(AudioTraits::SoundClass*,
AudioTraits::PlayingClass*);
virtual void set_volume(AudioTraits::PlayingClass*, int);
public:
// used by the readers
static LinuxMusicPlayer* get_instance(void);
private:
static LinuxMusicPlayer* _global_instance;
};
#include "audio_linux_traits.I"

34
panda/src/audio/audio_manager.I
View File

@ -4,21 +4,12 @@
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
// Function: AudioManager::play (AudioSample)
// Function: AudioManager::play (AudioSound)
// Access: Public, Static
// Description: Play an audio sample
// Description: Play some audio
////////////////////////////////////////////////////////////////////
INLINE void AudioManager::play(AudioSample* sample) {
get_ptr()->ns_play(sample);
}
////////////////////////////////////////////////////////////////////
// Function: AudioManager::play (AudioMusic)
// Access: Public, Static
// Description: Play an audio music instance
////////////////////////////////////////////////////////////////////
INLINE void AudioManager::play(AudioMusic* music) {
get_ptr()->ns_play(music);
INLINE void AudioManager::play(AudioSound* sound) {
get_ptr()->ns_play(sound);
}
////////////////////////////////////////////////////////////////////
@ -51,21 +42,12 @@ INLINE void AudioManager::shutdown(void) {
}
////////////////////////////////////////////////////////////////////
// Function: AudioManager::set_volume (sample)
// Function: AudioManager::set_volume (sound)
// Access: Public, Static
// Description: set the volume on a sample
// Description: set the volume on a sound instance
////////////////////////////////////////////////////////////////////
INLINE void AudioManager::set_volume(AudioSample* sample, int v) {
get_ptr()->ns_set_volume(sample, v);
}
////////////////////////////////////////////////////////////////////
// Function: AudioManager::set_volume (music)
// Access: Public, Static
// Description: set the volume on music
////////////////////////////////////////////////////////////////////
INLINE void AudioManager::set_volume(AudioMusic* music, int v) {
get_ptr()->ns_set_volume(music, v);
INLINE void AudioManager::set_volume(AudioSound* sound, int v) {
get_ptr()->ns_set_volume(sound, v);
}
////////////////////////////////////////////////////////////////////

34
panda/src/audio/audio_manager.cxx
View File

@ -66,21 +66,12 @@ AudioManager* AudioManager::get_ptr(void) {
}
////////////////////////////////////////////////////////////////////
// Function: AudioManager::ns_play (AudioSample)
// Function: AudioManager::ns_play (AudioSound)
// Access: Private
// Description: get the player off the sample, and start it playing
// Description: get the player off the sound, and start it playing
////////////////////////////////////////////////////////////////////
void AudioManager::ns_play(AudioSample* sample) {
sample->get_player()->play_sample(sample->get_sample());
}
////////////////////////////////////////////////////////////////////
// Function: AudioManager::ns_play (AudioMusic)
// Access: Private
// Description: get the player off the music, and start it playing
////////////////////////////////////////////////////////////////////
void AudioManager::ns_play(AudioMusic* music) {
music->get_player()->play_music(music->get_music());
void AudioManager::ns_play(AudioSound* sound) {
sound->get_player()->play_sound(sound->get_sound(), sound->get_state());
}
////////////////////////////////////////////////////////////////////
@ -100,21 +91,12 @@ void* AudioManager::spawned_update(void* data) {
}
////////////////////////////////////////////////////////////////////
// Function: AudioManager::ns_set_volume (AudioSample)
// Function: AudioManager::ns_set_volume (AudioSound)
// Access: Private
// Description: get the player off the sample, and set volume on it
// Description: get the player off the sound, and set volume on it
////////////////////////////////////////////////////////////////////
void AudioManager::ns_set_volume(AudioSample* sample, int v) {
sample->get_player()->set_volume(sample->get_sample(), v);
}
////////////////////////////////////////////////////////////////////
// Function: AudioManager::ns_set_volume (AudioMusic)
// Access: Private
// Description: get the player off the music, and set volume on it
////////////////////////////////////////////////////////////////////
void AudioManager::ns_set_volume(AudioMusic* music, int v) {
music->get_player()->set_volume(music->get_music(), v);
void AudioManager::ns_set_volume(AudioSound* sound, int v) {
sound->get_player()->set_volume(sound->get_state(), v);
}
////////////////////////////////////////////////////////////////////

15
panda/src/audio/audio_manager.h
View File

@ -7,8 +7,7 @@
#define __AUDIO_MANAGER_H__
#include "audio_trait.h"
#include "audio_sample.h"
#include "audio_music.h"
#include "audio_sound.h"
#include <ipc_mutex.h>
#include <ipc_thread.h>
@ -17,12 +16,10 @@ class EXPCL_PANDA AudioManager {
private:
INLINE AudioManager(void);
void ns_play(AudioSample*);
void ns_play(AudioMusic*);
void ns_play(AudioSound*);
void ns_set_volume(AudioSound*, int);
void ns_spawn_update(void);
void ns_shutdown(void);
void ns_set_volume(AudioSample*, int);
void ns_set_volume(AudioMusic*, int);
static AudioManager* get_ptr(void);
static void* spawned_update(void*);
@ -41,13 +38,11 @@ public:
static void set_update_func(UpdateFunc*);
static void set_shutdown_func(ShutdownFunc*);
INLINE static void play(AudioSample*);
INLINE static void play(AudioMusic*);
INLINE static void play(AudioSound*);
INLINE static void set_volume(AudioSound*, int);
INLINE static void update(void);
INLINE static void spawn_update(void);
INLINE static void shutdown(void);
INLINE static void set_volume(AudioSample*, int);
INLINE static void set_volume(AudioMusic*, int);
};
#include "audio_manager.I"

192
panda/src/audio/audio_mikmod_traits.cxx
View File

@ -124,25 +124,33 @@ static void initialize(void) {
have_initialized = true;
}
MikModSample::MikModSample(SAMPLE* sample) : _sample(sample), _voice(-1) {
MikModSample::MikModSample(SAMPLE* sample) : _sample(sample) {
}
MikModSample::~MikModSample(void) {
Sample_Free(_sample);
}
float MikModSample::length(void) {
float MikModSample::length(void) const {
float len = _sample->length;
float speed = _sample->speed;
return len / speed;
}
AudioTraits::SampleClass::SampleStatus MikModSample::status(void) {
if (_voice == -1)
return READY;
if (Voice_Stopped(_voice))
return PLAYING;
return READY;
AudioTraits::PlayingClass* MikModSample::get_state(void) const {
return new MikModSamplePlaying((MikModSample*)this);
}
AudioTraits::PlayerClass* MikModSample::get_player(void) const {
return MikModSamplePlayer::get_instance();
}
AudioTraits::DeleteSoundFunc* MikModSample::get_destroy(void) const {
return MikModSample::destroy;
}
AudioTraits::DeletePlayingFunc* MikModSample::get_delstate(void) const {
return MikModSamplePlaying::destroy;
}
MikModSample* MikModSample::load_wav(Filename filename) {
@ -156,22 +164,10 @@ MikModSample* MikModSample::load_wav(Filename filename) {
return new MikModSample(sample);
}
MikModPlaying* MikModSample::get_state(void) {
return new MikModPlaying();
}
void MikModSample::destroy(AudioTraits::SampleClass* sample) {
void MikModSample::destroy(AudioTraits::SoundClass* sample) {
delete sample;
}
void MikModSample::set_voice(int v) {
_voice = v;
}
int MikModSample::get_voice(void) {
return _voice;
}
SAMPLE* MikModSample::get_sample(void) {
return _sample;
}
@ -186,8 +182,28 @@ MikModMusic::MikModMusic(void) {
MikModMusic::~MikModMusic(void) {
}
AudioTraits::MusicClass::MusicStatus MikModMusic::status(void) {
return READY;
float MikModMusic::length(void) const {
return -1.;
}
AudioTraits::PlayingClass* MikModMusic::get_state(void) const {
return new MikModMusicPlaying((MikModMusic*)this);
}
AudioTraits::PlayerClass* MikModMusic::get_player(void) const {
return MikModFmsynthPlayer::get_instance();
}
AudioTraits::DeleteSoundFunc* MikModMusic::get_destroy(void) const {
return MikModMusic::destroy;
}
AudioTraits::DeletePlayingFunc* MikModMusic::get_delstate(void) const {
return MikModMusicPlaying::destroy;
}
void MikModMusic::destroy(AudioTraits::SoundClass* music) {
delete music;
}
MikModMidi::MikModMidi(void) {
@ -201,28 +217,83 @@ MikModMidi* MikModMidi::load_midi(Filename) {
return new MikModMidi();
}
MikModPlaying* MikModMidi::get_state(void) {
return new MikModPlaying();
float MikModMidi::length(void) const {
return -1.;
}
void MikModMidi::destroy(AudioTraits::MusicClass* music) {
AudioTraits::PlayingClass* MikModMidi::get_state(void) const {
return new MikModMidiPlaying((MikModMidi*)this);
}
AudioTraits::PlayerClass* MikModMidi::get_player(void) const {
return MikModMidiPlayer::get_instance();
}
AudioTraits::DeleteSoundFunc* MikModMidi::get_destroy(void) const {
return MikModMidi::destroy;
}
AudioTraits::DeletePlayingFunc* MikModMidi::get_delstate(void) const {
return MikModMidiPlaying::destroy;
}
void MikModMidi::destroy(AudioTraits::SoundClass* music) {
delete music;
}
AudioTraits::MusicClass::MusicStatus MikModMidi::status(void) {
return READY;
MikModSamplePlaying::MikModSamplePlaying(AudioTraits::SoundClass* s)
: AudioTraits::PlayingClass(s) {
}
MikModPlaying::MikModPlaying(void) : AudioTraits::PlayingClass() {
MikModSamplePlaying::~MikModSamplePlaying(void) {
}
MikModPlaying::~MikModPlaying(void) {
}
AudioTraits::PlayingClass::PlayingStatus MikModPlaying::status(void) {
AudioTraits::PlayingClass::PlayingStatus MikModSamplePlaying::status(void) {
return AudioTraits::PlayingClass::BAD;
}
void MikModSamplePlaying::set_voice(int v) {
_voice = v;
}
int MikModSamplePlaying::get_voice(void) const {
return _voice;
}
void MikModSamplePlaying::destroy(AudioTraits::PlayingClass* play) {
delete play;
}
MikModMusicPlaying::MikModMusicPlaying(AudioTraits::SoundClass* s)
: AudioTraits::PlayingClass(s) {
}
MikModMusicPlaying::~MikModMusicPlaying(void) {
}
AudioTraits::PlayingClass::PlayingStatus MikModMusicPlaying::status(void) {
return AudioTraits::PlayingClass::BAD;
}
void MikModMusicPlaying::destroy(AudioTraits::PlayingClass* play) {
delete play;
}
MikModMidiPlaying::MikModMidiPlaying(AudioTraits::SoundClass* s)
: AudioTraits::PlayingClass(s) {
}
MikModMidiPlaying::~MikModMidiPlaying(void) {
}
AudioTraits::PlayingClass::PlayingStatus MikModMidiPlaying::status(void) {
return AudioTraits::PlayingClass::BAD;
}
void MikModMidiPlaying::destroy(AudioTraits::PlayingClass* play) {
delete play;
}
MikModSamplePlayer* MikModSamplePlayer::_global_instance =
(MikModSamplePlayer*)0L;
@ -232,7 +303,8 @@ MikModSamplePlayer::MikModSamplePlayer(void) : AudioTraits::PlayerClass() {
MikModSamplePlayer::~MikModSamplePlayer(void) {
}
void MikModSamplePlayer::play_sample(AudioTraits::SampleClass* sample) {
void MikModSamplePlayer::play_sound(AudioTraits::SoundClass* sample,
AudioTraits::PlayingClass* playing) {
if (!have_initialized)
initialize();
if (!MikMod_Active()) {
@ -243,28 +315,19 @@ void MikModSamplePlayer::play_sample(AudioTraits::SampleClass* sample) {
}
// cast to the correct type
MikModSample* msample = (MikModSample*)sample;
MikModSamplePlaying* mplay = (MikModSamplePlaying*)playing;
// fire it off
msample->set_voice(Sample_Play(msample->get_sample(), 0, 0));
Voice_SetFrequency(msample->get_voice(), msample->get_freq());
if (Voice_GetFrequency(msample->get_voice()) != msample->get_freq())
mplay->set_voice(Sample_Play(msample->get_sample(), 0, 0));
Voice_SetFrequency(mplay->get_voice(), msample->get_freq());
if (Voice_GetFrequency(mplay->get_voice()) != msample->get_freq())
audio_cat->error() << "setting freq did not stick!" << endl;
Voice_SetPanning(msample->get_voice(), 127);
Voice_SetPanning(mplay->get_voice(), 127);
}
void MikModSamplePlayer::play_music(AudioTraits::MusicClass*) {
audio_cat->error() << "trying to play music with a MikModSamplePlayer"
<< endl;
}
void MikModSamplePlayer::set_volume(AudioTraits::SampleClass* sample, int v) {
void MikModSamplePlayer::set_volume(AudioTraits::PlayingClass* state, int v) {
initialize();
MikModSample* msample = (MikModSample*)sample;
Voice_SetVolume(msample->get_voice(), v);
}
void MikModSamplePlayer::set_volume(AudioTraits::MusicClass*, int) {
audio_cat->error()
<< "trying to set volume on music withe a MikModSamplePlayer" << endl;
MikModSamplePlaying* mplay = (MikModSamplePlaying*)state;
Voice_SetVolume(mplay->get_voice(), v);
}
MikModSamplePlayer* MikModSamplePlayer::get_instance(void) {
@ -273,26 +336,30 @@ MikModSamplePlayer* MikModSamplePlayer::get_instance(void) {
return _global_instance;
}
MikModFmsynthPlayer* MikModFmsynthPlayer::_global_instance =
(MikModFmsynthPlayer*)0L;
MikModFmsynthPlayer::MikModFmsynthPlayer(void) {
}
MikModFmsynthPlayer::~MikModFmsynthPlayer(void) {
}
void MikModFmsynthPlayer::play_sample(AudioTraits::SampleClass*) {
void MikModFmsynthPlayer::play_sound(AudioTraits::SoundClass*,
AudioTraits::PlayingClass*) {
audio_cat->error() << "trying to play a sample with a MikModFmsynthPlayer"
<< endl;
}
void MikModFmsynthPlayer::play_music(AudioTraits::MusicClass* music) {
}
void MikModFmsynthPlayer::set_volume(AudioTraits::SampleClass*, int) {
void MikModFmsynthPlayer::set_volume(AudioTraits::PlayingClass*, int) {
audio_cat->error()
<< "trying to set volume on a sample with a MikModFmsynthPlayer" << endl;
}
void MikModFmsynthPlayer::set_volume(AudioTraits::MusicClass*, int) {
MikModFmsynthPlayer* MikModFmsynthPlayer::get_instance(void) {
if (_global_instance == (MikModFmsynthPlayer*)0L)
_global_instance = new MikModFmsynthPlayer();
return _global_instance;
}
MikModMidiPlayer* MikModMidiPlayer::_global_instance = (MikModMidiPlayer*)0L;
@ -303,22 +370,17 @@ MikModMidiPlayer::MikModMidiPlayer(void) {
MikModMidiPlayer::~MikModMidiPlayer(void) {
}
void MikModMidiPlayer::play_sample(AudioTraits::SampleClass*) {
void MikModMidiPlayer::play_sound(AudioTraits::SoundClass*,
AudioTraits::PlayingClass*) {
audio_cat->error() << "trying to play a sample with a MikModMidiPlayer"
<< endl;
}
void MikModMidiPlayer::play_music(AudioTraits::MusicClass* music) {
}
void MikModMidiPlayer::set_volume(AudioTraits::SampleClass*, int) {
void MikModMidiPlayer::set_volume(AudioTraits::PlayingClass*, int) {
audio_cat->error()
<< "trying to set volume on a sample with a MikModMidiPlayer" << endl;
}
void MikModMidiPlayer::set_volume(AudioTraits::MusicClass*, int) {
}
MikModMidiPlayer* MikModMidiPlayer::get_instance(void) {
if (_global_instance == (MikModMidiPlayer*)0L)
_global_instance = new MikModMidiPlayer();

93
panda/src/audio/audio_mikmod_traits.h
View File

@ -14,61 +14,92 @@
#include <filename.h>
#include <mikmod.h>
class MikModPlaying;
class MikModSamplePlaying;
class EXPCL_PANDA MikModSample : public AudioTraits::SampleClass {
class EXPCL_PANDA MikModSample : public AudioTraits::SoundClass {
private:
SAMPLE* _sample;
int _voice;
MikModSample(SAMPLE*);
public:
virtual ~MikModSample(void);
virtual float length(void);
virtual AudioTraits::SampleClass::SampleStatus status(void);
virtual float length(void) const;
virtual AudioTraits::PlayingClass* get_state(void) const;
virtual AudioTraits::PlayerClass* get_player(void) const;
virtual AudioTraits::DeleteSoundFunc* get_destroy(void) const;
virtual AudioTraits::DeletePlayingFunc* get_delstate(void) const;
public:
// used by the readers
static MikModSample* load_wav(Filename);
virtual MikModPlaying* get_state(void);
static void destroy(AudioTraits::SampleClass*);
static void destroy(AudioTraits::SoundClass*);
// used by the players
virtual void set_voice(int);
virtual int get_voice(void);
virtual SAMPLE* get_sample(void);
virtual int get_freq(void);
};
class EXPCL_PANDA MikModMusic : public AudioTraits::MusicClass {
class EXPCL_PANDA MikModMusic : public AudioTraits::SoundClass {
private:
MODULE* _music;
public:
MikModMusic(void);
virtual ~MikModMusic(void);
virtual AudioTraits::MusicClass::MusicStatus status(void);
virtual float length(void) const;
virtual AudioTraits::PlayingClass* get_state(void) const;
virtual AudioTraits::PlayerClass* get_player(void) const;
virtual AudioTraits::DeleteSoundFunc* get_destroy(void) const;
virtual AudioTraits::DeletePlayingFunc* get_delstate(void) const;
static void destroy(AudioTraits::SoundClass*);
};
class EXPCL_PANDA MikModMidi : public AudioTraits::MusicClass {
class EXPCL_PANDA MikModMidi : public AudioTraits::SoundClass {
private:
public:
MikModMidi(void);
virtual ~MikModMidi(void);
virtual AudioTraits::MusicClass::MusicStatus status(void);
virtual float length(void) const;
virtual AudioTraits::PlayingClass* get_state(void) const;
virtual AudioTraits::PlayerClass* get_player(void) const;
virtual AudioTraits::DeleteSoundFunc* get_destroy(void) const;
virtual AudioTraits::DeletePlayingFunc* get_delstate(void) const;
static void destroy(AudioTraits::SoundClass*);
public:
// used by the readers
static MikModMidi* load_midi(Filename);
static void destroy(AudioTraits::MusicClass*);
virtual MikModPlaying* get_state(void);
};
class EXPCL_PANDA MikModPlaying : public AudioTraits::PlayingClass {
class EXPCL_PANDA MikModSamplePlaying : public AudioTraits::PlayingClass {
private:
int _voice;
public:
MikModPlaying(void);
~MikModPlaying(void);
MikModSamplePlaying(AudioTraits::SoundClass*);
~MikModSamplePlaying(void);
virtual AudioTraits::PlayingClass::PlayingStatus status(void);
static void destroy(AudioTraits::PlayingClass*);
public:
virtual void set_voice(int);
virtual int get_voice(void) const;
};
class EXPCL_PANDA MikModMusicPlaying : public AudioTraits::PlayingClass {
public:
MikModMusicPlaying(AudioTraits::SoundClass*);
~MikModMusicPlaying(void);
virtual AudioTraits::PlayingClass::PlayingStatus status(void);
static void destroy(AudioTraits::PlayingClass*);
};
class EXPCL_PANDA MikModMidiPlaying : public AudioTraits::PlayingClass {
public:
MikModMidiPlaying(AudioTraits::SoundClass*);
~MikModMidiPlaying(void);
virtual AudioTraits::PlayingClass::PlayingStatus status(void);
static void destroy(AudioTraits::PlayingClass*);
};
class EXPCL_PANDA MikModSamplePlayer : public AudioTraits::PlayerClass {
@ -76,10 +107,9 @@ public:
MikModSamplePlayer(void);
virtual ~MikModSamplePlayer(void);
virtual void play_sample(AudioTraits::SampleClass*);
virtual void play_music(AudioTraits::MusicClass*);
virtual void set_volume(AudioTraits::SampleClass*, int);
virtual void set_volume(AudioTraits::MusicClass*, int);
virtual void play_sound(AudioTraits::SoundClass*,
AudioTraits::PlayingClass*);
virtual void set_volume(AudioTraits::PlayingClass*, int);
public:
// used by the readers
static MikModSamplePlayer* get_instance(void);
@ -92,10 +122,14 @@ public:
MikModFmsynthPlayer(void);
virtual ~MikModFmsynthPlayer(void);
virtual void play_sample(AudioTraits::SampleClass*);
virtual void play_music(AudioTraits::MusicClass*);
virtual void set_volume(AudioTraits::SampleClass*, int);
virtual void set_volume(AudioTraits::MusicClass*, int);
virtual void play_sound(AudioTraits::SoundClass*,
AudioTraits::PlayingClass*);
virtual void set_volume(AudioTraits::PlayingClass*, int);
public:
// used by the readers
static MikModFmsynthPlayer* get_instance(void);
private:
static MikModFmsynthPlayer* _global_instance;
};
class EXPCL_PANDA MikModMidiPlayer : public AudioTraits::PlayerClass {
@ -103,10 +137,9 @@ public:
MikModMidiPlayer(void);
virtual ~MikModMidiPlayer(void);
virtual void play_sample(AudioTraits::SampleClass*);
virtual void play_music(AudioTraits::MusicClass*);
virtual void set_volume(AudioTraits::SampleClass*, int);
virtual void set_volume(AudioTraits::MusicClass*, int);
virtual void play_sound(AudioTraits::SoundClass*,
AudioTraits::PlayingClass*);
virtual void set_volume(AudioTraits::PlayingClass*, int);
public:
// used by the readers
static MikModMidiPlayer* get_instance(void);

9
panda/src/audio/audio_music.I
View File

@ -61,6 +61,15 @@ INLINE AudioTraits::MusicClass* AudioMusic::get_music(void) {
return _music;
}
////////////////////////////////////////////////////////////////////
// Function: AudioMusic::get_playing
// Access: Protected
// Description: return the trait playing class for this music
////////////////////////////////////////////////////////////////////
INLINE AudioTraits::PlayingClass* AudioMusic::get_playing(void) {
return _state;
}
////////////////////////////////////////////////////////////////////
// Function: AudioMusic::equality operator
// Access: Public

1
panda/src/audio/audio_music.h
View File

@ -28,6 +28,7 @@ protected:
INLINE AudioTraits::PlayerClass* get_player(void);
INLINE AudioTraits::MusicClass* get_music(void);
INLINE AudioTraits::PlayingClass* get_playing(void);
friend class AudioPool;
friend class AudioManager;

8
panda/src/audio/audio_null_traits.I
View File

@ -3,13 +3,11 @@
//
////////////////////////////////////////////////////////////////////
INLINE NullSample::NullSample(void) : AudioTraits::SampleClass() {
INLINE NullSound::NullSound(void) : AudioTraits::SoundClass() {
}
INLINE NullMusic::NullMusic(void) : AudioTraits::MusicClass() {
}
INLINE NullPlaying::NullPlaying(void) : AudioTraits::PlayingClass() {
INLINE NullPlaying::NullPlaying(AudioTraits::SoundClass* sound)
: AudioTraits::PlayingClass(sound) {
}
INLINE NullPlayer::NullPlayer(void) : AudioTraits::PlayerClass() {

52
panda/src/audio/audio_null_traits.cxx
View File

@ -24,28 +24,33 @@ static void initialize(void) {
have_initialized = true;
}
NullSample::~NullSample(void) {
NullSound::~NullSound(void) {
}
float NullSample::length(void) {
float NullSound::length(void) const {
if (audio_cat->is_debug())
audio_cat->debug() << "in sample length in Null audio driver" << endl;
return 0.;
return -1.;
}
AudioTraits::SampleClass::SampleStatus NullSample::status(void) {
if (audio_cat->is_debug())
audio_cat->debug() << "in sample status in Null audio driver" << endl;
return AudioTraits::SampleClass::READY;
AudioTraits::PlayingClass* NullSound::get_state(void) const {
return new NullPlaying((NullSound*)this);
}
NullMusic::~NullMusic(void) {
AudioTraits::PlayerClass* NullSound::get_player(void) const {
return new NullPlayer();
}
AudioTraits::MusicClass::MusicStatus NullMusic::status(void) {
if (audio_cat->is_debug())
audio_cat->debug() << "in music status in Null audio driver" << endl;
return READY;
AudioTraits::DeleteSoundFunc* NullSound::get_destroy(void) const {
return NullSound::destroy;
}
AudioTraits::DeletePlayingFunc* NullSound::get_delstate(void) const {
return NullPlaying::destroy;
}
void NullSound::destroy(AudioTraits::SoundClass* sound) {
delete sound;
}
NullPlaying::~NullPlaying(void) {
@ -57,28 +62,23 @@ AudioTraits::PlayingClass::PlayingStatus NullPlaying::status(void) {
return BAD;
}
void NullPlaying::destroy(AudioTraits::PlayingClass* play) {
delete play;
}
NullPlayer::~NullPlayer(void) {
}
void NullPlayer::play_sample(AudioTraits::SampleClass*) {
void NullPlayer::play_sound(AudioTraits::SoundClass*,
AudioTraits::PlayingClass*) {
if (audio_cat->is_debug())
audio_cat->debug() << "in play sample in Null audio driver" << endl;
audio_cat->debug() << "in play sound in Null audio driver" << endl;
}
void NullPlayer::play_music(AudioTraits::MusicClass*) {
void NullPlayer::set_volume(AudioTraits::PlayingClass*, int) {
if (audio_cat->is_debug())
audio_cat->debug() << "in play music in Null audio driver" << endl;
}
void NullPlayer::set_volume(AudioTraits::SampleClass*, int) {
if (audio_cat->is_debug())
audio_cat->debug() << "in set volume (sample) in Null audio driver"
audio_cat->debug() << "in set volume in Null audio driver"
<< endl;
}
void NullPlayer::set_volume(AudioTraits::MusicClass*, int) {
if (audio_cat->is_debug())
audio_cat->debug() << "in set volume (music) in Null audio driver" << endl;
}
#endif /* AUDIO_USE_NULL */

32
panda/src/audio/audio_null_traits.h
View File

@ -13,29 +13,26 @@
class NullPlaying;
class EXPCL_PANDA NullSample : public AudioTraits::SampleClass {
class EXPCL_PANDA NullSound : public AudioTraits::SoundClass {
public:
INLINE NullSample(void);
virtual ~NullSample(void);
INLINE NullSound(void);
virtual ~NullSound(void);
virtual float length(void);
virtual AudioTraits::SampleClass::SampleStatus status(void);
};
class EXPCL_PANDA NullMusic : public AudioTraits::MusicClass {
public:
INLINE NullMusic(void);
virtual ~NullMusic(void);
virtual AudioTraits::MusicClass::MusicStatus status(void);
virtual float length(void) const;
virtual AudioTraits::PlayingClass* get_state(void) const;
virtual AudioTraits::PlayerClass* get_player(void) const;
virtual AudioTraits::DeleteSoundFunc* get_destroy(void) const;
virtual AudioTraits::DeletePlayingFunc* get_delstate(void) const;
static void destroy(AudioTraits::SoundClass*);
};
class EXPCL_PANDA NullPlaying : public AudioTraits::PlayingClass {
public:
INLINE NullPlaying(void);
INLINE NullPlaying(AudioTraits::SoundClass*);
virtual ~NullPlaying(void);
virtual AudioTraits::PlayingClass::PlayingStatus status(void);
static void destroy(AudioTraits::PlayingClass*);
};
class EXPCL_PANDA NullPlayer : public AudioTraits::PlayerClass {
@ -43,10 +40,9 @@ public:
INLINE NullPlayer(void);
virtual ~NullPlayer(void);
virtual void play_sample(AudioTraits::SampleClass*);
virtual void play_music(AudioTraits::MusicClass*);
virtual void set_volume(AudioTraits::SampleClass*, int);
virtual void set_volume(AudioTraits::MusicClass*, int);
virtual void play_sound(AudioTraits::SoundClass*,
AudioTraits::PlayingClass*);
virtual void set_volume(AudioTraits::PlayingClass*, int);
};
#include "audio_null_traits.I"

122
panda/src/audio/audio_pool.I
View File

@ -4,131 +4,67 @@
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
// Function: AudioPool::has_sample
// Function: AudioPool::has_sound
// Access: Public, Static
// Description: Returns true if the sample has ever been loaded,
// Description: Returns true if the sound has ever been loaded,
// false otherwise.
////////////////////////////////////////////////////////////////////
INLINE bool AudioPool::has_sample(const string& filename) {
return get_ptr()->ns_has_sample(filename);
INLINE bool AudioPool::has_sound(const string& filename) {
return get_ptr()->ns_has_sound(filename);
}
////////////////////////////////////////////////////////////////////
// Function: AudioPool::verify_sample
// Function: AudioPool::verify_sound
// Access: Public, Static
// Description: Loads the given filename up into a sample, if it has
// Description: Loads the given filename up into a sound, if it has
// not already been loaded, and returns true to indicate
// success, or false to indicate failure. If this
// returns true, it is guaranteed that a subsequent call
// to load_sample() with the same sample name will
// return a valid AudioSample pointer.
// to load_sound() with the same sound name will
// return a valid AudioSound pointer.
////////////////////////////////////////////////////////////////////
INLINE bool AudioPool::verify_sample(const string& filename) {
return load_sample(filename) != (AudioSample*)0L;
INLINE bool AudioPool::verify_sound(const string& filename) {
return load_sound(filename) != (AudioSound*)0L;
}
////////////////////////////////////////////////////////////////////
// Function: AudioPool::load_sample
// Function: AudioPool::load_sound
// Access: Public, Static
// Description: Loads the given filename up into a sample, if it has
// not already been loaded, and returns the new sample.
// If a sample with the same filename was previously
// loaded, returns that one instead. If the sample
// Description: Loads the given filename up into a sound, if it has
// not already been loaded, and returns the new sound.
// If a sound with the same filename was previously
// loaded, returns that one instead. If the sound
// file cannot be found, returns NULL.
////////////////////////////////////////////////////////////////////
INLINE AudioSample* AudioPool::load_sample(const string& filename) {
return get_ptr()->ns_load_sample(filename);
INLINE AudioSound* AudioPool::load_sound(const string& filename) {
return get_ptr()->ns_load_sound(filename);
}
////////////////////////////////////////////////////////////////////
// Function: AudioPool::release_sample
// Function: AudioPool::release_sound
// Access: Public, Static
// Description: Removes the indicated sample from the pool,
// indicating it will never be loaded again; the sample
// Description: Removes the indicated sound from the pool,
// indicating it will never be loaded again; the sound
// may then be freed. If this function is never called,
// a reference count will be maintained on every sample
// ever loaded, and samples will never be freed.
// a reference count will be maintained on every sound
// ever loaded, and sounds will never be freed.
//
// The sample's name should not have been changed
// The sound's name should not have been changed
// during its lifetime, or this function may fail to
// locate it in the pool.
////////////////////////////////////////////////////////////////////
INLINE void AudioPool::release_sample(AudioSample* sample) {
get_ptr()->ns_release_sample(sample);
INLINE void AudioPool::release_sound(AudioSound* sound) {
get_ptr()->ns_release_sound(sound);
}
////////////////////////////////////////////////////////////////////
// Function: AudioPool::release_all_samples
// Function: AudioPool::release_all_sounds
// Access: Public, Static
// Description: Releases all samples in the pool and restores the
// Description: Releases all sounds in the pool and restores the
// pool to the empty state.
////////////////////////////////////////////////////////////////////
INLINE void AudioPool::release_all_samples(void) {
get_ptr()->ns_release_all_samples();
}
////////////////////////////////////////////////////////////////////
// Function: AudioPool::has_music
// Access: Public, Static
// Description: Returns true if the music has ever been loaded,
// false otherwise.
////////////////////////////////////////////////////////////////////
INLINE bool AudioPool::has_music(const string& filename) {
return get_ptr()->ns_has_music(filename);
}
////////////////////////////////////////////////////////////////////
// Function: AudioPool::verify_music
// Access: Public, Static
// Description: Loads the given filename up into a music, if it has
// not already been loaded, and returns true to indicate
// success, or false to indicate failure. If this
// returns true, it is guaranteed that a subsequent call
// to load_music() with the same music name will
// return a valid AudioMusic pointer.
////////////////////////////////////////////////////////////////////
INLINE bool AudioPool::verify_music(const string& filename) {
return load_music(filename) != (AudioMusic*)0L;
}
////////////////////////////////////////////////////////////////////
// Function: AudioPool::load_music
// Access: Public, Static
// Description: Loads the given filename up into a music, if it has
// not already been loaded, and returns the new music.
// If a music with the same filename was previously
// loaded, returns that one instead. If the music
// file cannot be found, returns NULL.
////////////////////////////////////////////////////////////////////
INLINE AudioMusic* AudioPool::load_music(const string& filename) {
return get_ptr()->ns_load_music(filename);
}
////////////////////////////////////////////////////////////////////
// Function: AudioPool::release_music
// Access: Public, Static
// Description: Removes the indicated music from the pool,
// indicating it will never be loaded again; the music
// may then be freed. If this function is never called,
// a reference count will be maintained on every music
// ever loaded, and music will never be freed.
//
// The music's name should not have been changed
// during its lifetime, or this function may fail to
// locate it in the pool.
////////////////////////////////////////////////////////////////////
INLINE void AudioPool::release_music(AudioMusic* music) {
get_ptr()->ns_release_music(music);
}
////////////////////////////////////////////////////////////////////
// Function: AudioPool::release_all_music
// Access: Public, Static
// Description: Releases all music in the pool and restores the
// pool to the empty state.
////////////////////////////////////////////////////////////////////
INLINE void AudioPool::release_all_music(void) {
get_ptr()->ns_release_all_music();
INLINE void AudioPool::release_all_sounds(void) {
get_ptr()->ns_release_all_sounds();
}
////////////////////////////////////////////////////////////////////

247
panda/src/audio/audio_pool.cxx
View File

@ -8,29 +8,17 @@
#include <config_util.h>
AudioPool* AudioPool::_global_ptr = (AudioPool*)0L;
typedef map<string, AudioPool::SampleLoadFunc*> SampleLoaders;
SampleLoaders* _sample_loaders = (SampleLoaders*)0L;
typedef map<string, AudioPool::MusicLoadFunc*> MusicLoaders;
MusicLoaders* _music_loaders = (MusicLoaders*)0L;
typedef map<string, AudioPool::SoundLoadFunc*> SoundLoaders;
SoundLoaders* _sound_loaders = (SoundLoaders*)0L;
////////////////////////////////////////////////////////////////////
// Function: check_sample_loaders
// Function: check_sound_loaders
// Access: Static
// Description: ensure that the sample loaders map has been initialized
// Description: ensure that the sound loaders map has been initialized
////////////////////////////////////////////////////////////////////
static void check_sample_loaders(void) {
if (_sample_loaders == (SampleLoaders*)0L)
_sample_loaders = new SampleLoaders;
}
////////////////////////////////////////////////////////////////////
// Function: check_music_loaders
// Access: Static
// Description: ensure that the music loaders map has been initialized
////////////////////////////////////////////////////////////////////
static void check_music_loaders(void) {
if (_music_loaders == (MusicLoaders*)0L)
_music_loaders = new MusicLoaders;
static void check_sound_loaders(void) {
if (_sound_loaders == (SoundLoaders*)0L)
_sound_loaders = new SoundLoaders;
}
////////////////////////////////////////////////////////////////////
@ -46,211 +34,108 @@ AudioPool* AudioPool::get_ptr(void) {
}
////////////////////////////////////////////////////////////////////
// Function: AudioPool::ns_has_sample
// Function: AudioPool::ns_has_sound
// Access: Private
// Description: The nonstatic implementation of has_sample().
// Description: The nonstatic implementation of has_sound().
////////////////////////////////////////////////////////////////////
bool AudioPool::ns_has_sample(Filename filename) {
bool AudioPool::ns_has_sound(Filename filename) {
filename.resolve_filename(get_sound_path());
SampleMap::const_iterator si;
si = _samples.find(filename);
if (si != _samples.end()) {
// this sample was previously loaded
SoundMap::const_iterator si;
si = _sounds.find(filename);
if (si != _sounds.end()) {
// this sound was previously loaded
return true;
}
return false;
}
////////////////////////////////////////////////////////////////////
// Function: AudioPool::ns_load_sample
// Function: AudioPool::ns_load_sound
// Access: Private
// Description: The nonstatic implementation of load_sample().
// Description: The nonstatic implementation of load_sound().
////////////////////////////////////////////////////////////////////
AudioSample* AudioPool::ns_load_sample(Filename filename) {
AudioSound* AudioPool::ns_load_sound(Filename filename) {
filename.resolve_filename(get_sound_path());
SampleMap::const_iterator si;
si = _samples.find(filename);
if (si != _samples.end()) {
// this sample was previously loaded
return (*si).second;
SoundMap::const_iterator si;
si = _sounds.find(filename);
if (si != _sounds.end()) {
// this sound was previously loaded
AudioTraits::SoundClass* sc = (*si).second;
return new AudioSound(sc, sc->get_state(), sc->get_player(),
sc->get_delstate(), filename);
}
if (!filename.exists()) {
audio_cat.info() << "'" << filename << "' does not exist" << endl;
return (AudioSample*)0L;
return (AudioSound*)0L;
}
audio_cat.info() << "Loading sample " << filename << endl;
AudioTraits::SampleClass* sample = (AudioTraits::SampleClass*)0L;
AudioTraits::PlayingClass* state = (AudioTraits::PlayingClass*)0L;
AudioTraits::PlayerClass* player = (AudioTraits::PlayerClass*)0L;
AudioTraits::DeleteSampleFunc* destroy = (AudioTraits::DeleteSampleFunc*)0L;
audio_cat.info() << "Loading sound " << filename << endl;
string ext = filename.get_extension();
SampleLoaders::const_iterator sli;
check_sample_loaders();
sli = _sample_loaders->find(ext);
if (sli == _sample_loaders->end()) {
SoundLoaders::const_iterator sli;
check_sound_loaders();
sli = _sound_loaders->find(ext);
if (sli == _sound_loaders->end()) {
audio_cat->error() << "no loader available for audio type '" << ext
<< "'" << endl;
return (AudioSample*)0L;
return (AudioSound*)0L;
}
(*((*sli).second))(&sample, &state, &player, &destroy, filename);
if ((sample == (AudioTraits::SampleClass*)0L) ||
(state == (AudioTraits::PlayingClass*)0L) ||
(player == (AudioTraits::PlayerClass*)0L) ||
(destroy == (AudioTraits::DeleteSampleFunc*)0L)) {
AudioTraits::SoundClass* sound = (*((*sli).second))(filename);
if (sound == (AudioTraits::SoundClass*)0L) {
audio_cat->error() << "could not load '" << filename << "'" << endl;
return (AudioSample*)0L;
return (AudioSound*)0L;
}
PT(AudioSample) the_sample = new AudioSample(sample, state, player, destroy,
filename);
_samples[filename] = the_sample;
return the_sample;
PT(AudioSound) the_sound = new AudioSound(sound, sound->get_state(),
sound->get_player(),
sound->get_delstate(), filename);
_sounds[filename] = sound;
return the_sound;
}
////////////////////////////////////////////////////////////////////
// Function: AudioPool::ns_release_sample
// Function: AudioPool::ns_release_sound
// Access: Private
// Description: The nonstatic implementation of release_sample().
// Description: The nonstatic implementation of release_sound().
////////////////////////////////////////////////////////////////////
void AudioPool::ns_release_sample(AudioSample* sample) {
string filename = sample->get_name();
SampleMap::iterator si;
si = _samples.find(filename);
if (si != _samples.end() && (*si).second == sample) {
_samples.erase(si);
void AudioPool::ns_release_sound(AudioSound* sound) {
string filename = sound->get_name();
SoundMap::iterator si;
si = _sounds.find(filename);
if (si != _sounds.end() && (*si).second == sound->get_sound()) {
AudioTraits::SoundClass* sc = (*si).second;
(*(sc->get_destroy()))(sc);
_sounds.erase(si);
}
}
////////////////////////////////////////////////////////////////////
// Function: AudioPool::ns_release_all_samples
// Function: AudioPool::ns_release_all_sounds
// Access: Private
// Description: The nonstatic implementation of release_all_samples().
// Description: The nonstatic implementation of release_all_sounds().
////////////////////////////////////////////////////////////////////
void AudioPool::ns_release_all_samples(void) {
_samples.clear();
void AudioPool::ns_release_all_sounds(void) {
for (SoundMap::iterator i=_sounds.begin(); i!=_sounds.end(); ++i) {
AudioTraits::SoundClass* sc = (*i).second;
(*(sc->get_destroy()))(sc);
}
_sounds.clear();
}
////////////////////////////////////////////////////////////////////
// Function: AudioPool::register_sample_loader
// Function: AudioPool::register_sound_loader
// Access: Public, static
// Description: A static function to register a function for loading
// audio samples.
// audio sounds.
////////////////////////////////////////////////////////////////////
void AudioPool::register_sample_loader(const string& ext,
AudioPool::SampleLoadFunc* func) {
SampleLoaders::const_iterator sli;
check_sample_loaders();
sli = _sample_loaders->find(ext);
if (sli != _sample_loaders->end()) {
void AudioPool::register_sound_loader(const string& ext,
AudioPool::SoundLoadFunc* func) {
SoundLoaders::const_iterator sli;
check_sound_loaders();
sli = _sound_loaders->find(ext);
if (sli != _sound_loaders->end()) {
audio_cat->warning() << "attempted to register a loader for audio type '"
<< ext << "' more then once." << endl;
return;
}
(*_sample_loaders)[ext] = func;
}
////////////////////////////////////////////////////////////////////
// Function: AudioPool::ns_has_music
// Access: Private
// Description: The nonstatic implementation of has_music().
////////////////////////////////////////////////////////////////////
bool AudioPool::ns_has_music(Filename filename) {
filename.resolve_filename(get_sound_path());
MusicMap::const_iterator si;
si = _music.find(filename);
if (si != _music.end()) {
// this music was previously loaded
return true;
}
return false;
}
////////////////////////////////////////////////////////////////////
// Function: AudioPool::ns_load_music
// Access: Private
// Description: The nonstatic implementation of load_music().
////////////////////////////////////////////////////////////////////
AudioMusic* AudioPool::ns_load_music(Filename filename) {
filename.resolve_filename(get_sound_path());
MusicMap::const_iterator si;
si = _music.find(filename);
if (si != _music.end()) {
// this sample was previously loaded
return (*si).second;
}
if (!filename.exists()) {
audio_cat.info() << "'" << filename << "' does not exist" << endl;
return (AudioMusic*)0L;
}
audio_cat.info() << "Loading music " << filename << "\n";
AudioTraits::MusicClass* music = (AudioTraits::MusicClass*)0L;
AudioTraits::PlayingClass* state = (AudioTraits::PlayingClass*)0L;
AudioTraits::PlayerClass* player = (AudioTraits::PlayerClass*)0L;
AudioTraits::DeleteMusicFunc* destroy = (AudioTraits::DeleteMusicFunc*)0L;
string ext = filename.get_extension();
MusicLoaders::const_iterator sli;
check_music_loaders();
sli = _music_loaders->find(ext);
if (sli == _music_loaders->end()) {
audio_cat->error() << "no loader available for audio type '" << ext
<< "'" << endl;
return (AudioMusic*)0L;
}
(*((*sli).second))(&music, &state, &player, &destroy, filename);
if ((music == (AudioTraits::MusicClass*)0L) ||
(state == (AudioTraits::PlayingClass*)0L) ||
(player == (AudioTraits::PlayerClass*)0L) ||
(destroy == (AudioTraits::DeleteMusicFunc*)0L)) {
audio_cat->error() << "could not load '" << filename << "'" << endl;
return (AudioMusic*)0L;
}
PT(AudioMusic) the_music = new AudioMusic(music, state, player, destroy,
filename);
_music[filename] = the_music;
return the_music;
}
////////////////////////////////////////////////////////////////////
// Function: AudioPool::ns_release_music
// Access: Private
// Description: The nonstatic implementation of release_music().
////////////////////////////////////////////////////////////////////
void AudioPool::ns_release_music(AudioMusic* music) {
string filename = music->get_name();
MusicMap::iterator si;
si = _music.find(filename);
if (si != _music.end() && (*si).second == music) {
_music.erase(si);
}
}
////////////////////////////////////////////////////////////////////
// Function: AudioPool::ns_release_all_music
// Access: Private
// Description: The nonstatic implementation of release_all_music().
////////////////////////////////////////////////////////////////////
void AudioPool::ns_release_all_music(void) {
_music.clear();
}
////////////////////////////////////////////////////////////////////
// Function: AudioPool::register_music_loader
// Access: Public, static
// Description: A static function to register a function for loading
// audio music.
////////////////////////////////////////////////////////////////////
void AudioPool::register_music_loader(const string& ext,
AudioPool::MusicLoadFunc* func) {
MusicLoaders::const_iterator sli;
check_music_loaders();
sli = _music_loaders->find(ext);
if (sli != _music_loaders->end()) {
audio_cat->warning() << "attempted to register a loader for audio type '"
<< ext << "' more then once." << endl;
return;
}
(*_music_loaders)[ext] = func;
(*_sound_loaders)[ext] = func;
}

52
panda/src/audio/audio_pool.h
View File

@ -6,8 +6,8 @@
#ifndef __AUDIO_POOL_H__
#define __AUDIO_POOL_H__
#include "audio_sample.h"
#include "audio_music.h"
#include "audio_sound.h"
#include "audio_trait.h"
#include <map>
#include <pandabase.h>
#include <filename.h>
@ -17,47 +17,25 @@ class EXPCL_PANDA AudioPool {
private:
INLINE AudioPool(void);
bool ns_has_sample(Filename filename);
AudioSample* ns_load_sample(Filename filename);
void ns_release_sample(AudioSample* sample);
void ns_release_all_samples(void);
bool ns_has_music(Filename filename);
AudioMusic* ns_load_music(Filename filename);
void ns_release_music(AudioMusic* music);
void ns_release_all_music(void);
bool ns_has_sound(Filename filename);
AudioSound* ns_load_sound(Filename filename);
void ns_release_sound(AudioSound* sound);
void ns_release_all_sounds(void);
static AudioPool* get_ptr(void);
static AudioPool *_global_ptr;
typedef map<string, PT(AudioSample) > SampleMap;
SampleMap _samples;
typedef map<string, PT(AudioMusic) > MusicMap;
MusicMap _music;
typedef map<string, AudioTraits::SoundClass* > SoundMap;
SoundMap _sounds;
public:
typedef void SampleLoadFunc(AudioTraits::SampleClass**,
AudioTraits::PlayingClass**,
AudioTraits::PlayerClass**,
AudioTraits::DeleteSampleFunc**, Filename);
typedef AudioTraits::SoundClass* SoundLoadFunc(Filename);
INLINE static bool has_sample(const string& filename);
INLINE static bool verify_sample(const string& filename);
INLINE static AudioSample* load_sample(const string& filename);
INLINE static void release_sample(AudioSample* sample);
INLINE static void release_all_samples(void);
static void register_sample_loader(const string&, SampleLoadFunc*);
typedef void MusicLoadFunc(AudioTraits::MusicClass**,
AudioTraits::PlayingClass**,
AudioTraits::PlayerClass**,
AudioTraits::DeleteMusicFunc**, Filename);
INLINE static bool has_music(const string& filename);
INLINE static bool verify_music(const string& filename);
INLINE static AudioMusic* load_music(const string& filename);
INLINE static void release_music(AudioMusic* music);
INLINE static void release_all_music(void);
static void register_music_loader(const string&, MusicLoadFunc*);
INLINE static bool has_sound(const string& filename);
INLINE static bool verify_sound(const string& filename);
INLINE static AudioSound* load_sound(const string& filename);
INLINE static void release_sound(AudioSound* sound);
INLINE static void release_all_sounds(void);
static void register_sound_loader(const string&, SoundLoadFunc*);
};
#include "audio_pool.I"

9
panda/src/audio/audio_sample.I
View File

@ -61,6 +61,15 @@ INLINE AudioTraits::SampleClass* AudioSample::get_sample(void) {
return _sample;
}
////////////////////////////////////////////////////////////////////
// Function: AudioSample::get_playing
// Access: Protected
// Description: return the trait playing class for this sample
////////////////////////////////////////////////////////////////////
INLINE AudioTraits::PlayingClass* AudioSample::get_playing(void) {
return _state;
}
////////////////////////////////////////////////////////////////////
// Function: AudioSample::equality operator
// Access: Public

12
panda/src/audio/audio_sample.cxx
View File

@ -33,17 +33,13 @@ float AudioSample::length(void) {
// Description: return the current play status of this sample
////////////////////////////////////////////////////////////////////
AudioSample::SampleStatus AudioSample::status(void) {
// AudioTraits::PlayingClass::PlayingStatus stat = _state->status();
AudioTraits::SampleClass::SampleStatus stat = _sample->status();
AudioTraits::PlayingClass::PlayingStatus stat = _state->status();
switch (stat) {
// case AudioTraits::PlayingClass::BAD:
case AudioTraits::SampleClass::BAD:
case AudioTraits::PlayingClass::BAD:
return BAD;
// case AudioTraits::PlayingClass::READY:
case AudioTraits::SampleClass::READY:
case AudioTraits::PlayingClass::READY:
return READY;
// case AudioTraits::PlayingClass::PLAYING:
case AudioTraits::SampleClass::PLAYING:
case AudioTraits::PlayingClass::PLAYING:
return PLAYING;
}
audio_cat->error() << "unknown status for sample" << endl;

1
panda/src/audio/audio_sample.h
View File

@ -28,6 +28,7 @@ protected:
INLINE AudioTraits::PlayerClass* get_player(void);
INLINE AudioTraits::SampleClass* get_sample(void);
INLINE AudioTraits::PlayingClass* get_playing(void);
friend class AudioPool;
friend class AudioManager;

2
panda/src/audio/audio_sound.cxx
View File

@ -32,7 +32,7 @@ float AudioSound::length(void) const {
// Access: Public
// Description: return the current play status of this sound
////////////////////////////////////////////////////////////////////
AudioSound::SoundStatus AudioSound::status(void) {
AudioSound::SoundStatus AudioSound::status(void) const {
AudioTraits::PlayingClass::PlayingStatus stat = _state->status();
switch (stat) {
case AudioTraits::PlayingClass::BAD:

4
panda/src/audio/audio_sound.h
View File

@ -21,7 +21,7 @@ private:
AudioTraits::DeletePlayingFunc *_delstate;
protected:
INLINE AudioSound(AudioTraits::SoundClass*, AudioTraits::PlayingClass*,
AudioTraits::PlayerClass*, AUdioTraits::DeletePlayingFunc*,
AudioTraits::PlayerClass*, AudioTraits::DeletePlayingFunc*,
const string&);
INLINE AudioSound(const AudioSound&);
INLINE AudioSound& operator=(const AudioSound&);
@ -62,4 +62,6 @@ private:
static TypeHandle _type_handle;
};
#include "audio_sound.I"
#endif /* __AUDIO_SOUND_H__ */

49
panda/src/audio/audio_trait.cxx
View File

@ -6,25 +6,34 @@
#include "audio_trait.h"
#include "config_audio.h"
AudioTraits::SampleClass::~SampleClass(void) {
AudioTraits::SoundClass::~SoundClass(void) {
}
float AudioTraits::SampleClass::length(void) {
audio_cat->error() << "In abstract SampleClass::length!" << endl;
return 0.;
float AudioTraits::SoundClass::length(void) const {
audio_cat->error() << "In abstract SoundClass::length!" << endl;
return -1.;
}
AudioTraits::SampleClass::SampleStatus AudioTraits::SampleClass::status(void) {
audio_cat->error() << "In abstract SampleClass::status!" << endl;
return READY;
AudioTraits::PlayingClass* AudioTraits::SoundClass::get_state(void) const {
audio_cat->error() << "In abstract SoundClass::get_state!" << endl;
return (AudioTraits::PlayingClass*)0L;
}
AudioTraits::MusicClass::~MusicClass(void) {
AudioTraits::PlayerClass* AudioTraits::SoundClass::get_player(void) const {
audio_cat->error() << "In abstract SoundClass::get_player!" << endl;
return (AudioTraits::PlayerClass*)0L;
}
AudioTraits::MusicClass::MusicStatus AudioTraits::MusicClass::status(void) {
audio_cat->error() << "In abstract MusicClass::status!" << endl;
return READY;
AudioTraits::DeleteSoundFunc*
AudioTraits::SoundClass::get_destroy(void) const {
audio_cat->error() << "In abstract SoundClass::get_destroy!" << endl;
return (AudioTraits::DeleteSoundFunc*)0L;
}
AudioTraits::DeletePlayingFunc*
AudioTraits::SoundClass::get_delstate(void) const {
audio_cat->error() << "In abstract SoundClass::get_delstate!" << endl;
return (AudioTraits::DeletePlayingFunc*)0L;
}
AudioTraits::PlayingClass::~PlayingClass(void) {
@ -39,19 +48,11 @@ AudioTraits::PlayingClass::status(void) {
AudioTraits::PlayerClass::~PlayerClass(void) {
}
void AudioTraits::PlayerClass::play_sample(AudioTraits::SampleClass*) {
audio_cat->error() << "In abstract PlayerClass::play_sample!" << endl;
void AudioTraits::PlayerClass::play_sound(AudioTraits::SoundClass*,
AudioTraits::PlayingClass*) {
audio_cat->error() << "In abstract PlayerClass::play_sound!" << endl;
}
void AudioTraits::PlayerClass::play_music(AudioTraits::MusicClass*) {
audio_cat->error() << "In abstract PlayerClass::play_music!" << endl;
}
void AudioTraits::PlayerClass::set_volume(AudioTraits::SampleClass*, int) {
audio_cat->error() << "In abstract PlayerClass::set_volume (sample)!"
<< endl;
}
void AudioTraits::PlayerClass::set_volume(AudioTraits::MusicClass*, int) {
audio_cat->error() << "In abstract PlayerClass::set_volume (music)!" << endl;
void AudioTraits::PlayerClass::set_volume(AudioTraits::PlayingClass*, int) {
audio_cat->error() << "In abstract PlayerClass::set_volume!" << endl;
}

43
panda/src/audio/audio_trait.h
View File

@ -10,34 +10,29 @@
class EXPCL_PANDA AudioTraits {
public:
class SampleClass;
class MusicClass;
class SoundClass;
class PlayingClass;
class PlayerClass;
typedef void DeleteSampleFunc(SampleClass*);
typedef void DeleteMusicFunc(MusicClass*);
typedef void DeleteSoundFunc(SoundClass*);
typedef void DeletePlayingFunc(PlayingClass*);
class EXPCL_PANDA SampleClass {
class EXPCL_PANDA SoundClass {
public:
SampleClass(void) {}
virtual ~SampleClass(void);
SoundClass(void) {}
virtual ~SoundClass(void);
enum SampleStatus { BAD, READY, PLAYING } ;
virtual float length(void) = 0;
virtual SampleStatus status(void) = 0;
};
class EXPCL_PANDA MusicClass {
public:
MusicClass(void) {}
virtual ~MusicClass(void);
enum MusicStatus { BAD, READY, PLAYING } ;
virtual MusicStatus status(void) = 0;
virtual float length(void) const = 0;
virtual PlayingClass* get_state(void) const = 0;
virtual PlayerClass* get_player(void) const = 0;
virtual DeleteSoundFunc* get_destroy(void) const = 0;
virtual DeletePlayingFunc* get_delstate(void) const = 0;
};
class EXPCL_PANDA PlayingClass {
protected:
SoundClass* _sound;
public:
PlayingClass(void) {}
PlayingClass(SoundClass* s) : _sound(s) {}
virtual ~PlayingClass(void);
enum PlayingStatus { BAD, READY, PLAYING } ;
@ -49,10 +44,8 @@ public:
PlayerClass(void) {}
virtual ~PlayerClass(void);
virtual void play_sample(SampleClass*) = 0;
virtual void play_music(MusicClass*) = 0;
virtual void set_volume(SampleClass*, int) = 0;
virtual void set_volume(MusicClass*, int) = 0;
virtual void play_sound(SoundClass*, PlayingClass*) = 0;
virtual void set_volume(PlayingClass*, int) = 0;
};
};

21
panda/src/audio/audio_win_traits.I
View File

@ -3,18 +3,13 @@
//
////////////////////////////////////////////////////////////////////
INLINE WinSample::WinSample(void) : AudioTraits::SampleClass(), _channel(NULL),
_data(NULL), _len(0) {
INLINE WinSample::WinSample(void) : AudioTraits::SoundClass(), _data(NULL),
_len(0) {
}
INLINE LPDIRECTSOUNDBUFFER WinSample::get_channel(void) {
return _channel;
}
INLINE WinMusic::WinMusic(void) : AudioTraits::MusicClass(),
INLINE WinMusic::WinMusic(void) : AudioTraits::SoundClass(),
_performance(NULL), _music(NULL),
_buffer(NULL), _synth(NULL), _data(NULL),
_len(0) {
_buffer(NULL), _synth(NULL) {
init();
}
@ -26,8 +21,12 @@ INLINE IDirectMusicSegment* WinMusic::get_music(void) {
return _music;
}
INLINE WinPlaying::WinPlaying(void) : AudioTraits::PlayingClass() {
INLINE LPDIRECTSOUNDBUFFER WinSamplePlaying::get_channel(void) {
return _channel;
}
INLINE WinPlayer::WinPlayer(void) : AudioTraits::PlayerClass() {
INLINE WinSamplePlayer::WinSamplePlayer(void) : AudioTraits::PlayerClass() {
}
INLINE WinMusicPlayer::WinMusicPlayer(void) : AudioTraits::PlayerClass() {
}

338
panda/src/audio/audio_win_traits.cxx
View File

@ -163,42 +163,28 @@ static void shutdown(void) {
}
WinSample::~WinSample(void) {
// unload any data we have
if (_channel) {
_channel->Release();
_channel = NULL;
}
// we may or may not be leaking the _data
}
float WinSample::length(void) {
float WinSample::length(void) const {
// DO THIS
return 0.;
}
AudioTraits::SampleClass::SampleStatus WinSample::status(void) {
if (_channel) {
DWORD dwStatus;
_channel->GetStatus(&dwStatus);
if (dwStatus & DSBSTATUS_PLAYING)
return AudioTraits::SampleClass::PLAYING;
}
return AudioTraits::SampleClass::READY;
AudioTraits::PlayingClass* WinSample::get_state(void) const {
return new WinSamplePlaying((WinSample*)this);
}
BYTE* WinSample::lock(void) {
HRESULT result = _channel->Lock(0, 0, (void**)&_data, &_len, NULL, 0,
DSBLOCK_ENTIREBUFFER);
if (FAILED(result)) {
audio_cat->error() << "failed to lock buffer" << endl;
return NULL;
}
return _data;
AudioTraits::PlayerClass* WinSample::get_player(void) const {
return WinSamplePlayer::get_instance();
}
void WinSample::unlock(void) {
HRESULT result = _channel->Unlock(_data, _len, NULL, 0);
CHECK_RESULT(result, "failed to unlock buffer");
AudioTraits::DeleteSoundFunc* WinSample::get_destroy(void) const {
return WinSample::destroy;
}
AudioTraits::DeletePlayingFunc* WinSample::get_delstate(void) const {
return WinSamplePlaying::destroy;
}
// these are used by the wav loader
@ -353,42 +339,10 @@ WinSample* WinSample::load_wav(Filename filename) {
return ret;
}
// create direct sound channel
ret = new WinSample();
DSBUFFERDESC dsbdDesc;
ZeroMemory(&dsbdDesc, sizeof(DSBUFFERDESC));
dsbdDesc.dwSize = sizeof(DSBUFFERDESC);
/*
dsbdDesc.dwFlags = DSBCAPS_CTRLDEFAULT | DSBCAPS_STATIC |
DSBCAPS_GLOBALFOCUS;
*/
dsbdDesc.dwFlags = DSBCAPS_STATIC |
DSBCAPS_GLOBALFOCUS;
dsbdDesc.dwBufferBytes = wavSize;
dsbdDesc.lpwfxFormat = &wavInfo;
dsbdDesc.lpwfxFormat->cbSize = sizeof(wavInfo);
result = soundDirectSound->CreateSoundBuffer(&dsbdDesc, &(ret->_channel), NULL);
if (FAILED(result)) {
delete ret;
ret = (WinSample*)0L;
}
if (ret) {
BYTE* dst = NULL;
dst = ret->lock();
try {
memcpy(dst, wavData, wavSize);
}
catch(...) {
delete ret;
ret = (WinSample*)0L;
}
if (ret)
ret->unlock();
}
if (wavData)
delete [] wavData;
memcpy(&(ret->_info), &wavInfo, sizeof(WAVEFORMATEX));
ret->_data = wavData;
ret->_len = wavSize;
return ret;
}
@ -413,43 +367,13 @@ WinSample* WinSample::load_raw(unsigned char* data, unsigned long size) {
// create a direct sound channel for this data
ret = new WinSample();
DSBUFFERDESC dsbdDesc;
ZeroMemory(&dsbdDesc, sizeof(DSBUFFERDESC));
dsbdDesc.dwSize = sizeof(DSBUFFERDESC);
dsbdDesc.dwFlags = DSBCAPS_STATIC | DSBCAPS_GLOBALFOCUS;
dsbdDesc.dwBufferBytes = size;
dsbdDesc.lpwfxFormat = &wavInfo;
dsbdDesc.lpwfxFormat->cbSize = sizeof(wavInfo);
HRESULT result = soundDirectSound->CreateSoundBuffer(&dsbdDesc,
&(ret->_channel), NULL);
if (FAILED(result)) {
delete ret;
ret = (WinSample*)0L;
}
if (ret) {
BYTE* dst = NULL;
dst = ret->lock();
try {
memcpy(dst, data, size);
}
catch (...) {
delete ret;
ret = (WinSample*)0L;
}
if (ret)
ret->unlock();
delete [] data;
return ret;
}
memcpy(&(ret->_info), &wavInfo, sizeof(WAVEFORMATEX));
ret->_data = data;
ret->_len = size;
return ret;
}
WinPlaying* WinSample::get_state(void) {
return new WinPlaying();
}
void WinSample::destroy(AudioTraits::SampleClass* sample) {
void WinSample::destroy(AudioTraits::SoundClass* sample) {
delete sample;
}
@ -559,22 +483,29 @@ void WinMusic::init(void) {
<< endl;
}
AudioTraits::MusicClass::MusicStatus WinMusic::status(void) {
if (audio_cat->is_debug())
audio_cat->debug() << "in WinMusic::status()" << endl;
float WinMusic::length(void) const {
// DO THIS
return -1.;
}
if (_performance && _music) {
if (_performance->IsPlaying(_music, NULL) == S_OK) {
if (audio_cat->is_debug())
audio_cat->debug() << "returning PLAYING" << endl;
return PLAYING;
}
} else
if (audio_cat->is_debug())
audio_cat->debug() << "MusicStatus no performance or music!" << endl;
if (audio_cat->is_debug())
audio_cat->debug() << "returning READY" << endl;
return READY;
AudioTraits::PlayingClass* WinMusic::get_state(void) const {
return new WinMusicPlaying((WinMusic*)this);
}
AudioTraits::PlayerClass* WinMusic::get_player(void) const {
return WinMusicPlayer::get_instance();
}
AudioTraits::DeleteSoundFunc* WinMusic::get_destroy(void) const {
return WinMusic::destroy;
}
AudioTraits::DeletePlayingFunc* WinMusic::get_delstate(void) const {
return WinMusicPlaying::destroy;
}
void WinMusic::destroy(AudioTraits::SoundClass* music) {
delete music;
}
WinMusic* WinMusic::load_midi(Filename filename) {
@ -644,34 +575,119 @@ WinMusic* WinMusic::load_midi(Filename filename) {
return ret;
}
WinPlaying* WinMusic::get_state(void) {
return new WinPlaying();
WinSamplePlaying::WinSamplePlaying(AudioTraits::SoundClass* s)
: AudioTraits::PlayingClass(s) {
initialize();
WinSample* ws = (WinSample*)s;
if (ws == (WinSample*)0L)
return;
if (ws->_data == (unsigned char*)0L)
return;
DSBUFFERDESC dsbdDesc;
ZeroMemory(&dsbdDesc, sizeof(DSBUFFERDESC));
dsbdDesc.dwSize = sizeof(DSBUFFERDESC);
dsbdDesc.dwFlags = DSBCAPS_STATIC | DSBCAPS_GLOBALFOCUS;
dsbdDesc.dwBufferBytes = ws->_len;
dsbdDesc.lpwfxFormat = &(ws->_info);
dsbdDesc.lpwfxFormat->cbSize = sizeof(ws->_info);
HRESULT result = soundDirectSound->CreateSoundBuffer(&dsbdDesc, &_channel,
NULL);
if (FAILED(result)) {
_channel = NULL;
return;
}
BYTE* dst = NULL;
dst = this->lock();
try {
memcpy(dst, ws->_data, ws->_len);
}
catch (...) {
_channel = NULL;
return;
}
this->unlock();
}
void WinMusic::destroy(AudioTraits::MusicClass* music) {
WinSamplePlaying::~WinSamplePlaying(void) {
}
void WinSamplePlaying::destroy(AudioTraits::PlayingClass* play) {
delete play;
}
AudioTraits::PlayingClass::PlayingStatus WinSamplePlaying::status(void) {
if (_channel) {
DWORD dwStatus;
_channel->GetStatus(&dwStatus);
if (dwStatus & DSBSTATUS_PLAYING)
return AudioTraits::PlayingClass::PLAYING;
}
return AudioTraits::PlayingClass::READY;
}
BYTE* WinSamplePlaying::lock(void) {
WinSample* s = (WinSample*)(_sound);
HRESULT result = _channel->Lock(0, 0, (void**)&(s->_data), &(s->_len), NULL,
0, DSBLOCK_ENTIREBUFFER);
if (FAILED(result)) {
audio_cat->error() << "failed to lock buffer" << endl;
return NULL;
}
return (s->_data);
}
void WinSamplePlaying::unlock(void) {
WinSample* s = (WinSample*)(_sound);
HRESULT result = _channel->Unlock(s->_data, s->_len, NULL, 0);
CHECK_RESULT(result, "failed to unlock buffer");
}
WinMusicPlaying::WinMusicPlaying(AudioTraits::SoundClass* s)
: AudioTraits::PlayingClass(s) {
initialize();
}
WinMusicPlaying::~WinMusicPlaying(void) {
}
void WinMusicPlaying::destroy(AudioTraits::PlayingClass* play) {
delete play;
}
AudioTraits::PlayingClass::PlayingStatus WinMusicPlaying::status(void) {
if (audio_cat->is_debug())
audio_cat->debug() << "in WinMusic::destroy()" << endl;
delete music;
audio_cat->debug() << "in WinMusic::status()" << endl;
WinMusic* wm = (WinMusic*)_sound;
if (wm->get_performance() && wm->get_music()) {
if (wm->get_performance()->IsPlaying(_music, NULL) == S_OK) {
if (audio_cat->is_debug())
audio_cat->debug() << "returning PLAYING" << endl;
return PLAYING;
}
} else
if (audio_cat->is_debug())
audio_cat->debug() << "MusicStatus no performance or music!" << endl;
if (audio_cat->is_debug())
audio_cat->debug() << "out of WinMusic::destroy()" << endl;
audio_cat->debug() << "returning READY" << endl;
return READY;
}
WinPlaying::~WinPlaying(void) {
WinSamplePlayer* WinSamplePlayer::_global_instance = (WinSamplePlayer*)0L;
WinSamplePlayer::~WinSamplePlayer(void) {
}
AudioTraits::PlayingClass::PlayingStatus WinPlaying::status(void) {
return AudioTraits::PlayingClass::BAD;
}
WinPlayer* WinPlayer::_global_instance = (WinPlayer*)0L;
WinPlayer::~WinPlayer(void) {
}
void WinPlayer::play_sample(AudioTraits::SampleClass* sample) {
void WinSamplePlayer::play_sound(AudioTraits::SoundClass* sample,
AudioTraits::PlayingClass* play) {
initialize();
WinSample* wsample = (WinSample*)sample;
LPDIRECTSOUNDBUFFER chan = wsample->get_channel();
WinSamplePlaying* wplay = (WinSamplePlaying*)play;
LPDIRECTSOUNDBUFFER chan = wplay->get_channel();
if (chan) {
chan->Stop();
HRESULT result = chan->Play(0, 0, 0);
@ -680,9 +696,10 @@ void WinPlayer::play_sample(AudioTraits::SampleClass* sample) {
}
}
void WinPlayer::play_music(AudioTraits::MusicClass* music) {
void WinSamplePlayer::play_music(AudioTraits::MusicClass* music,
AudioTraits::PlayingClass*) {
if (audio_cat->is_debug())
audio_cat->debug() << "in WinPlayer::play_music()" << endl;
audio_cat->debug() << "in WinSamplePlayer::play_music()" << endl;
initialize();
WinMusic* wmusic = (WinMusic*)music;
IDirectMusicPerformance* _perf = wmusic->get_performance();
@ -714,18 +731,67 @@ void WinPlayer::play_music(AudioTraits::MusicClass* music) {
}
}
if (audio_cat->is_debug())
audio_cat->debug() << "out of WinPlayer::play_music()" << endl;
audio_cat->debug() << "out of WinSamplePlayer::play_music()" << endl;
}
void WinPlayer::set_volume(AudioTraits::SampleClass*, int) {
void WinSamplePlayer::set_volume(AudioTraits::PlayingClass*, int) {
}
void WinPlayer::set_volume(AudioTraits::MusicClass*, int) {
WinSamplePlayer* WinSamplePlayer::get_instance(void) {
if (_global_instance == (WinSamplePlayer*)0L)
_global_instance = new WinSamplePlayer();
return _global_instance;
}
WinPlayer* WinPlayer::get_instance(void) {
if (_global_instance == (WinPlayer*)0L)
_global_instance = new WinPlayer();
WinMusicPlayer* WinMusicPlayer::_global_instance = (WinMusicPlayer*)0L;
WinMusicPlayer::~WinMusicPlayer(void) {
}
void WinMusicPlayer::play_sound(AudioTraits::SoundClass* music,
AudioTraits::PlayingClass*) {
if (audio_cat->is_debug())
audio_cat->debug() << "in WinMusicPlayer::play_music()" << endl;
initialize();
WinMusic* wmusic = (WinMusic*)music;
IDirectMusicPerformance* _perf = wmusic->get_performance();
IDirectMusicSegment* _msc = wmusic->get_music();
if (audio_cat->is_debug())
audio_cat->debug() << "about to jump in: _perf = " << (void*)_perf
<< " _msc = " << (void*)_msc << endl;
if (_perf && _msc) {
if (audio_cat->is_debug())
audio_cat->debug() << "made it inside" << endl;
// _msc->SetRepeats(0);
IDirectMusicSegmentState* segState;
// HRESULT result = _perf->PlaySegment(_msc, 0, 0, NULL);
HRESULT result = _perf->PlaySegment(_msc, 0, 0, &segState);
if (result != S_OK) {
audio_cat->error() << "music play failed" << endl;
switch (result) {
case E_OUTOFMEMORY: audio_cat->error() << "reports out of memory" << endl;
break;
case E_POINTER: audio_cat->error() << "reports invalid pointer" << endl;
break;
case DMUS_E_NO_MASTER_CLOCK: audio_cat->error() << "reports no master clock" << endl;
break;
case DMUS_E_SEGMENT_INIT_FAILED: audio_cat->error() << "reports segment init failed" << endl;
break;
case DMUS_E_TIME_PAST: audio_cat->error() << "reports time past" << endl;
break;
};
}
}
if (audio_cat->is_debug())
audio_cat->debug() << "out of WinMusicPlayer::play_music()" << endl;
}
void WinMusicPlayer::set_volume(AudioTraits::PlayingClass*, int) {
}
WinMusicPlayer* WinMusicPlayer::get_instance(void) {
if (_global_instance == (WinMusicPlayer*)0L)
_global_instance = new WinMusicPlayer();
return _global_instance;
}

92
panda/src/audio/audio_win_traits.h
View File

@ -16,77 +16,107 @@
#include <dsound.h>
#include <dmusici.h>
class WinPlaying;
class WinSamplePlaying;
class EXPCL_PANDA WinSample : public AudioTraits::SampleClass {
private:
LPDIRECTSOUNDBUFFER _channel;
class EXPCL_PANDA WinSample : public AudioTraits::SoundClass {
public:
BYTE* _data;
DWORD _len;
WAVEFORMATEX _info;
public:
INLINE WinSample(void);
virtual ~WinSample(void);
virtual float length(void);
virtual AudioTraits::SampleClass::SampleStatus status(void);
virtual float length(void) const;
virtual AudioTraits::PlayingClass* get_state(void) const;
virtual AudioTraits::PlayerClass* get_player(void) const;
virtual AudioTraits::DeleteSoundFunc* get_destroy(void) const;
virtual AudioTraits::DeletePlayingFunc* get_delstate(void) const;
public:
// these are used by the laoders
BYTE* lock(void);
void unlock(void);
static WinSample* load_wav(Filename);
static WinSample* load_raw(unsigned char*, unsigned long);
virtual WinPlaying* get_state(void);
static void destroy(AudioTraits::SampleClass*);
// these are used by the player
INLINE LPDIRECTSOUNDBUFFER get_channel(void);
static void destroy(AudioTraits::SoundClass*);
};
class EXPCL_PANDA WinMusic : public AudioTraits::MusicClass {
class EXPCL_PANDA WinMusic : public AudioTraits::SoundClass {
private:
IDirectMusicPerformance* _performance;
IDirectMusicSegment* _music;
IDirectSoundBuffer* _buffer;
IDirectMusicPort* _synth;
BYTE* _data;
DWORD _len;
// BYTE* _data;
// DWORD _len;
void init(void);
public:
INLINE WinMusic(void);
virtual ~WinMusic(void);
virtual AudioTraits::MusicClass::MusicStatus status(void);
virtual float length(void) const;
virtual AudioTraits::PlayingClass* get_state(void) const;
virtual AudioTraits::PlayerClass* get_player(void) const;
virtual AudioTraits::DeleteSoundFunc* get_destroy(void) const;
virtual AudioTraits::DeletePlayingFunc* get_delstate(void) const;
// these are used by the loaders
static WinMusic* load_midi(Filename);
virtual WinPlaying* get_state(void);
static void destroy(AudioTraits::MusicClass*);
// these are used by the players
INLINE IDirectMusicPerformance* get_performance(void);
INLINE IDirectMusicSegment* get_music(void);
};
class EXPCL_PANDA WinPlaying : public AudioTraits::PlayingClass {
class EXPCL_PANDA WinSamplePlaying : public AudioTraits::PlayingClass {
private:
LPDIRECTSOUNDBUFFER _channel;
public:
INLINE WinPlaying(void);
~WinPlaying(void);
WinSamplePlaying(AudioTraits::SoundClass*);
~WinSamplePlaying(void);
virtual AudioTraits::PlayingClass::PlayingStatus status(void);
static void destroy(AudioTraits::PlayingClass*);
// these are used by the laoders
BYTE* lock(void);
void unlock(void);
// these are used by the player
INLINE LPDIRECTSOUNDBUFFER get_channel(void);
};
class EXPCL_PANDA WinPlayer : public AudioTraits::PlayerClass {
class EXPCL_PANDA WinMusicPlaying : public AudioTraits::PlayingClass {
public:
INLINE WinPlayer(void);
virtual ~WinPlayer(void);
WinMusicPlaying(AudioTraits::SourceClass*);
~WinMusicPlaying(void);
virtual void play_sample(AudioTraits::SampleClass*);
virtual void play_music(AudioTraits::MusicClass*);
virtual void set_volume(AudioTraits::SampleClass*, int);
virtual void set_volume(AudioTraits::MusicClass*, int);
virtual AudioTraits::PlayingClass::PlayingStatus status(void);
static void destroy(AudioTraits::PlayingClass*);
};
class EXPCL_PANDA WinSamplePlayer : public AudioTraits::PlayerClass {
public:
INLINE WinSamplePlayer(void);
virtual ~WinSamplePlayer(void);
virtual void play_sound(AudioTraits::SoundClass*,
AudioTraits::PlayingClass*);
virtual void set_volume(AudioTraits::PlayingClass*, int);
public:
// used by the readers
static WinPlayer* get_instance(void);
static WinSamplePlayer* get_instance(void);
private:
static WinPlayer* _global_instance;
static WinSamplePlayer* _global_instance;
};
class EXPCL_PANDA WinMusicPlayer : public AudioTraits::PlayerClass {
public:
INLINE WinMusicPlayer(void);
virtual ~WinMusicPlayer(void);
virtual void play_sound(AudioTraits::SoundClass*,
AudioTraits::PlayingClass*);
virtual void set_volume(AudioTraits::PlayingClass*, int);
public:
// used by the readers
static WinMusicPlayer* get_instance(void);
private:
static WinMusicPlayer* _global_instance;
};
#include "audio_win_traits.I"

6
panda/src/audio/config_audio.cxx
View File

@ -4,8 +4,7 @@
////////////////////////////////////////////////////////////////////
#include "config_audio.h"
#include "audio_sample.h"
#include "audio_music.h"
#include "audio_sound.h"
#include <dconfig.h>
#include <filename.h>
#include <load_dso.h>
@ -24,8 +23,7 @@ int audio_auto_update_delay = config_audio.GetInt("audio-auto-update-delay",
100000);
ConfigureFn(config_audio) {
AudioSample::init_type();
AudioMusic::init_type();
AudioSound::init_type();
Config::ConfigTable::Symbol mode;
config_audio.GetAll("audio-mode-flag", mode);

14
panda/src/audio/test_audio.cxx
View File

@ -15,30 +15,30 @@ main(int argc, char* argv[]) {
// audio_cat->fatal() << "could not locate 'test.wav'" << endl;
// exit(-1);
// }
if (! AudioPool::verify_sample("test.mp3")) {
if (! AudioPool::verify_sound("test.mp3")) {
audio_cat->fatal() << "could not locate 'test.mp3'" << endl;
exit(-1);
}
// AudioSample* sample = AudioPool::load_sample("test.wav");
AudioSample* sample = AudioPool::load_sample("test.mp3");
audio_cat->info() << "test.wav is " << sample->length() << "sec long"
AudioSound* sample = AudioPool::load_sound("test.mp3");
audio_cat->info() << "test.wav is " << sample->length() << " sec long"
<< endl;
audio_cat->info() << "Playing test.wav" << endl;
AudioManager::play(sample);
while (sample->status() == AudioSample::PLAYING) {
while (sample->status() == AudioSound::PLAYING) {
AudioManager::update();
ipc_traits::sleep(0, 1000000);
}
// AudioMidi foo("test.midi");
if (! AudioPool::verify_music("test.midi")) {
if (! AudioPool::verify_sound("test.midi")) {
audio_cat->fatal() << "could not locate 'test.midi'" << endl;
exit(-1);
}
AudioMusic* music = AudioPool::load_music("test.midi");
AudioSound* music = AudioPool::load_sound("test.midi");
audio_cat->info() << "Playing test.midi" << endl;
AudioManager::play(music);
while (music->status() == AudioMusic::PLAYING) {
while (music->status() == AudioSound::PLAYING) {
AudioManager::update();
ipc_traits::sleep(0, 1000000);
}

64
panda/src/audiotraits/audio_load_midi.cxx
View File

@ -14,60 +14,26 @@ Configure(audio_load_midi);
#include "audio_mikmod_traits.h"
void AudioDestroyMidi(AudioTraits::MusicClass* music) {
MikModMidi::destroy(music);
}
void AudioLoadMidi(AudioTraits::MusicClass** music,
AudioTraits::PlayingClass** state,
AudioTraits::PlayerClass** player,
AudioTraits::DeleteMusicFunc** destroy, Filename filename) {
*music = MikModMidi::load_midi(filename);
if (*music == (AudioTraits::MusicClass*)0L)
return;
*state = ((MikModMidi*)(*music))->get_state();
*player = MikModMidiPlayer::get_instance();
*destroy = AudioDestroyMidi;
AudioTraits::SoundClass* AudioLoadMidi(Filename filename) {
return MikModMidi::load_midi(filename);
}
#elif defined(AUDIO_USE_WIN32)
#include "audio_win_traits.h"
void EXPCL_MISC AudioDestroyMidi(AudioTraits::MusicClass* music) {
WinMusic::destroy(music);
}
void AudioLoadMidi(AudioTraits::MusicClass** music,
AudioTraits::PlayingClass** state,
AudioTraits::PlayerClass** player,
AudioTraits::DeleteMusicFunc** destroy, Filename filename) {
*music = WinMusic::load_midi(filename);
if (*music == (AudioTraits::MusicClass*)0L)
return;
*state = ((WinMusic*)(*music))->get_state();
*player = WinPlayer::get_instance();
*destroy = AudioDestroyMidi;
EXPCL_MISC AudioTraits::SoundClass* AudioLoadMidi(Filename filename) {
return WinMusic::load_midi(filename);
}
#elif defined(AUDIO_USE_LINUX)
#include "audio_linux_traits.h"
void AudioDestroyMidi(AudioTraits::MusicClass* music) {
LinuxMusic::destroy(music);
}
void AudioLoadMidi(AudioTraits::MusicClass** music,
AudioTraits::PlayingClass** state,
AudioTraits::PlayerClass** player,
AudioTraits::DeleteMusicFunc** destroy, Filename) {
AudioTraits::SoundClass* AudioLoadMidi(Filename) {
audio_cat->warning() << "linux doesn't support reading midi data yet"
<< endl;
*music = (AudioTraits::MusicClass*)0L;
*state = (AudioTraits::PlayingClass*)0L;
*player = (AudioTraits::PlayerClass*)0L;
*destroy = AudioDestroyMidi;
return (AudioTraits::SoundClass*)0L;
}
#elif defined(AUDIO_USE_NULL)
@ -75,18 +41,8 @@ void AudioLoadMidi(AudioTraits::MusicClass** music,
// Null driver
#include "audio_null_traits.h"
void AudioDestroyMidi(AudioTraits::MusicClass* music) {
delete music;
}
void AudioLoadMidi(AudioTraits::MusicClass** music,
AudioTraits::PlayingClass** state,
AudioTraits::PlayerClass** player,
AudioTraits::DeleteMusicFunc** destroy, Filename) {
*music = new NullMusic();
*state = new NullPlaying();
*player = new NullPlayer();
*destroy = AudioDestroyMidi;
AudioTraits::SoundClass* AudioLoadMidi(Filename) {
return new NullSound();
}
#else /* AUDIO_USE_NULL */
@ -96,6 +52,6 @@ void AudioLoadMidi(AudioTraits::MusicClass** music,
#endif /* AUDIO_USE_NULL */
ConfigureFn(audio_load_midi) {
AudioPool::register_music_loader("midi", AudioLoadMidi);
AudioPool::register_music_loader("mid", AudioLoadMidi);
AudioPool::register_sound_loader("midi", AudioLoadMidi);
AudioPool::register_sound_loader("mid", AudioLoadMidi);
}

68
panda/src/audiotraits/audio_load_mp3.cxx
View File

@ -432,92 +432,46 @@ static void read_file(Filename filename, unsigned char** buf,
#include "audio_mikmod_traits.h"
void AudioDestroyMp3(AudioTraits::SampleClass* sample) {
delete sample;
}
void AudioLoadMp3(AudioTraits::SampleClass** sample,
AudioTraits::PlayingClass** state,
AudioTraits::PlayerClass** player,
AudioTraits::DeleteSampleFunc** destroy, Filename) {
AudioTraits::SoundClass* AudioLoadMp3(Filename) {
audio_cat->warning() << "Mikmod doesn't support reading mp3 data yet"
<< endl;
*sample = (AudioTraits::SampleClass*)0L;
*state = (AudioTraits::PlayingClass*)0L;
*player = (AudioTraits::PlayerClass*)0L;
*destroy = AudioDestroyMp3;
return (AudioTraits::SoundClass*)0L;
}
#elif defined(AUDIO_USE_WIN32)
#include "audio_win_traits.h"
void EXPCL_MISC AudioDestroyMp3(AudioTraits::SampleClass* sample) {
delete sample;
}
void AudioLoadMp3(AudioTraits::SampleClass** sample,
AudioTraits::PlayingClass** state,
AudioTraits::PlayerClass** player,
AudioTraits::DeleteSampleFunc** destroy, Filename filename) {
EXPCL_MISC AudioTraits::SoundClass* AudioLoadMp3(Filename filename) {
unsigned char* buf;
unsigned long len;
read_file(filename, &buf, len);
if (buf != (unsigned char*)0L) {
*sample = WinSample::load_raw(buf, len);
*state = ((WinSample*)(*sample))->get_state();
*player = WinPlayer::get_instance();
} else {
*sample = (AudioTraits::SampleClass*)0L;
*state = (AudioTraits::PlayingClass*)0L;
*player = (AudioTraits::PlayerClass*)0L;
return WinSample::load_raw(buf, len);
}
*destroy = AudioDestroyMp3;
return (AudioTraits::SampleClass*)0L;
}
#elif defined(AUDIO_USE_LINUX)
#include "audio_linux_traits.h"
void AudioDestroyMp3(AudioTraits::SampleClass* sample) {
delete sample;
}
void AudioLoadMp3(AudioTraits::SampleClass** sample,
AudioTraits::PlayingClass** state,
AudioTraits::PlayerClass** player,
AudioTraits::DeleteSampleFunc** destroy, Filename filename) {
AudioTraits::SoundClass* AudioLoadMp3(Filename filename) {
unsigned char* buf;
unsigned long len;
read_file(filename, &buf, len);
if (buf != (unsigned char*)0L) {
*sample = LinuxSample::load_raw(buf, len);
*state = ((LinuxSample*)(*sample))->get_state();
*player = LinuxPlayer::get_instance();
} else {
*sample = (AudioTraits::SampleClass*)0L;
*state = (AudioTraits::PlayingClass*)0L;
*player = (AudioTraits::PlayerClass*)0L;
return LinuxSample::load_raw(buf, len);
}
*destroy = AudioDestroyMp3;
return (AudioTraits::SoundClass*)0L;
}
#elif defined(AUDIO_USE_NULL)
#include "audio_null_traits.h"
void AudioDestroyMp3(AudioTraits::SampleClass* sample) {
delete sample;
}
void AudioLoadMp3(AudioTraits::SampleClass** sample,
AudioTraits::PlayingClass** state,
AudioTraits::PlayerClass** player,
AudioTraits::DeleteSampleFunc** destroy, Filename) {
*sample = (AudioTraits::SampleClass*)0L;
*state = (AudioTraits::PlayingClass*)0L;
*player = (AudioTraits::PlayerClass*)0L;
*destroy = AudioDestroyMp3;
AudioTraits::SoundClass* AudioLoadMp3(Filename) {
return new NullSound();
}
#else
@ -527,5 +481,5 @@ void AudioLoadMp3(AudioTraits::SampleClass** sample,
#endif
ConfigureFn(audio_load_mp3) {
AudioPool::register_sample_loader("mp3", AudioLoadMp3);
AudioPool::register_sound_loader("mp3", AudioLoadMp3);
}

70
panda/src/audiotraits/audio_load_st.cxx
View File

@ -381,80 +381,42 @@ void cleanup(void) {
#ifdef AUDIO_USE_MIKMOD
void AudioDestroySt(AudioTraits::SampleClass* sample) {
delete sample;
}
void AudioLoadSt(AudioTraits::SampleClass** sample,
AudioTraits::PlayingClass** state,
AudioTraits::PlayerClass** player,
AudioTraits::DeleteSampleFunc** destroy, Filename) {
AudioTraits::SoundClass* AudioLoadSt(Filename) {
audio_cat->warning() << "MikMod doesn't support reading raw data yet"
<< endl;
*sample = (AudioTraits::SampleClass*)0L;
*state = (AudioTraits::PlayingClass*)0L;
*player = (AudioTraits::PlayerClass*)0L;
*destroy = AudioDestroySt;
return (AudioTraits::SoundClass*)0L;
}
#elif defined(AUDIO_USE_WIN32)
#include "audio_win_traits.h"
void EXPCL_MISC AudioDestroySt(AudioTraits::SampleClass* sample) {
WinSample::destroy(sample);
}
void AudioLoadSt(AudioTraits::SampleClass** sample,
AudioTraits::PlayingClass** state,
AudioTraits::PlayerClass** player,
AudioTraits::DeleteSampleFunc** destroy, Filename filename) {
EXPCL_MISC AudioTraits::SoundClass* AudioLoadSt(Filename filename) {
#ifdef HAVE_SOXST
unsigned char* buf;
unsigned long len;
read_file(filename, &buf, len);
if (buf != (unsigned char*)0L) {
*sample = WinSample::load_raw(buf, len);
*state = ((WinSample*)(*sample))->get_state();
*player = WinPlayer::get_instance();
*destroy = AudioDestroySt;
return WinSample::load_raw(buf, len);
}
#else /* HAVE_SOXST */
*sample = (AudioTraits::SampleClass*)0L;
*state = (AudioTraits::PlayingClass*)0L;
*player = (AudioTraits::PlayerClass*)0L;
*destroy = AudioDestroySt;
#endif /* HAVE_SOXST */
return (AudioTraits::SampleClass*)0L;
}
#elif defined(AUDIO_USE_LINUX)
#include "audio_linux_traits.h"
void AudioDestroySt(AudioTraits::SampleClass* sample) {
LinuxSample::destroy(sample);
}
void AudioLoadSt(AudioTraits::SampleClass** sample,
AudioTraits::PlayingClass** state,
AudioTraits::PlayerClass** player,
AudioTraits::DeleteSampleFunc** destroy, Filename filename) {
AudioTraits::SoundClass* AudioLoadSt(Filename filename) {
#ifdef HAVE_SOXST
byte* buf;
unsigned long len;
read_file(filename, &buf, len);
if (buf != (byte*)0L) {
*sample = LinuxSample::load_raw(buf, len);
*state = ((LinuxSample*)(*sample))->get_state();
*player = LinuxPlayer::get_instance();
*destroy = AudioDestroySt;
return LinuxSample::load_raw(buf, len);
}
#else /* HAVE_SOXST */
*sample = (AudioTraits::SampleClass*)0L;
*state = (AudioTraits::PlayingClass*)0L;
*player = (AudioTraits::PlayerClass*)0L;
*destroy = AudioDestroySt;
#endif /* HAVE_SOXST */
return (AudioTraits::SoundClass*)0L;
}
#elif defined(AUDIO_USE_NULL)
@ -462,18 +424,8 @@ void AudioLoadSt(AudioTraits::SampleClass** sample,
// Null driver
#include "audio_null_traits.h"
void AudioDestroySt(AudioTraits::SampleClass* sample) {
delete sample;
}
void AudioLoadSt(AudioTraits::SampleClass** sample,
AudioTraits::PlayingClass** state,
AudioTraits::PlayerClass** player,
AudioTraits::DeleteSampleFunc** destroy, Filename) {
*sample = new NullSample();
*state = new NullPlaying();
*player = new NullPlayer();
*destroy = AudioDestroySt;
AudioTraits::SoundClass* AudioLoadSt(Filename) {
return new NullSound();
}
#else /* AUDIO_USE_NULL */
@ -489,7 +441,7 @@ ConfigureFn(audio_load_st) {
if (audio_cat->is_debug())
audio_cat->debug() << "adding reader for '." << FORMATS[i].names[j]
<< "'" << endl;
AudioPool::register_sample_loader(FORMATS[i].names[j], AudioLoadSt);
AudioPool::register_sound_loader(FORMATS[i].names[j], AudioLoadSt);
}
#else /* HAVE_SOXST */
audio_cat->info() << "HAVE_SOXST is not defined" << endl;

62
panda/src/audiotraits/audio_load_wav.cxx
View File

@ -15,60 +15,26 @@ Configure(audio_load_wav);
#include "audio_mikmod_traits.h"
void AudioDestroyWav(AudioTraits::SampleClass* sample) {
MikModSample::destroy(sample);
}
void AudioLoadWav(AudioTraits::SampleClass** sample,
AudioTraits::PlayingClass** state,
AudioTraits::PlayerClass** player,
AudioTraits::DeleteSampleFunc** destroy, Filename filename) {
*sample = MikModSample::load_wav(filename);
if (*sample == (AudioTraits::SampleClass*)0L)
return;
*state = ((MikModSample*)(*sample))->get_state();
*player = MikModSamplePlayer::get_instance();
*destroy = AudioDestroyWav;
AudioTraits::SoundClass* AudioLoadWav(Filename filename) {
return MikModSample::load_wav(filename);
}
#elif defined(AUDIO_USE_WIN32)
#include "audio_win_traits.h"
void EXPCL_MISC AudioDestroyWav(AudioTraits::SampleClass* sample) {
WinSample::destroy(sample);
}
void AudioLoadWav(AudioTraits::SampleClass** sample,
AudioTraits::PlayingClass** state,
AudioTraits::PlayerClass** player,
AudioTraits::DeleteSampleFunc** destroy, Filename filename) {
*sample = WinSample::load_wav(filename);
if (*sample == (AudioTraits::SampleClass*)0L)
return;
*state = ((WinSample*)(*sample))->get_state();
*player = WinPlayer::get_instance();
*destroy = AudioDestroyWav;
EXPCL_MISC AudioTraits::SoundClass* AudioLoadWav(Filename filename) {
return WinSample::load_wav(filename);
}
#elif defined(AUDIO_USE_LINUX)
#include "audio_linux_traits.h"
void AudioDestroyWav(AudioTraits::SampleClass* sample) {
LinuxSample::destroy(sample);
}
void AudioLoadWav(AudioTraits::SampleClass** sample,
AudioTraits::PlayingClass** state,
AudioTraits::PlayerClass** player,
AudioTraits::DeleteSampleFunc** destroy, Filename) {
AudioTraits::SoundClass* AudioLoadWav(Filename) {
audio_cat->error() << "Linux driver does not natively support WAV."
<< " Try the 'st' loader." << endl;
*sample = (AudioTraits::SampleClass*)0L;
*state = (AudioTraits::PlayingClass*)0L;
*player = (AudioTraits::PlayerClass*)0L;
*destroy = AudioDestroyWav;
return (AudioTraits::SoundClass*)0L;
}
#elif defined(AUDIO_USE_NULL)
@ -76,18 +42,8 @@ void AudioLoadWav(AudioTraits::SampleClass** sample,
// Null driver
#include "audio_null_traits.h"
void AudioDestroyWav(AudioTraits::SampleClass* sample) {
delete sample;
}
void AudioLoadWav(AudioTraits::SampleClass** sample,
AudioTraits::PlayingClass** state,
AudioTraits::PlayerClass** player,
AudioTraits::DeleteSampleFunc** destroy, Filename) {
*sample = new NullSample();
*state = new NullPlaying();
*player = new NullPlayer();
*destroy = AudioDestroyWav;
AudioTraits::SoundClass* AudioLoadWav(Filename) {
return new NullSound();
}
#else /* AUDIO_USE_NULL */
@ -97,5 +53,5 @@ void AudioLoadWav(AudioTraits::SampleClass** sample,
#endif /* AUDIO_USE_NULL */
ConfigureFn(audio_load_wav) {
AudioPool::register_sample_loader("wav", AudioLoadWav);
AudioPool::register_sound_loader("wav", AudioLoadWav);
}

2
panda/src/mpg123/vbrhead.c
View File

@ -58,7 +58,7 @@ int getVBRHeader(struct vbrHeader *head,unsigned char *buf, struct frame *fr)
buf += 4;
}
fprintf(stderr,"Found XING %04lx\n",head->flags);
// fprintf(stderr,"Found XING %04lx\n",head->flags);
return 1;