changes to temporal state for audio

panda/src/audio/Sources.pp

@@ -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
 

panda/src/audio/audio.h

@@ -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"
 

panda/src/audio/audio_linux_traits.I

@@ -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() {
 }

panda/src/audio/audio_linux_traits.cxx

@@ -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);
+}
+
+AudioTraits::PlayerClass* LinuxSample::get_player(void) const {
+  return LinuxSamplePlayer::get_instance();
 }
 
-LinuxPlaying* LinuxSample::get_state(void) {
-  return new LinuxPlaying();
+AudioTraits::DeleteSoundFunc* LinuxSample::get_destroy(void) const {
+  return LinuxSample::destroy;
 }
 
-void LinuxSample::destroy(AudioTraits::SampleClass* sample) {
-  delete sample;
+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.;
+}
+
+AudioTraits::PlayingClass* LinuxMusic::get_state(void) const {
+  return new LinuxMusicPlaying((LinuxMusic*)this);
 }
 
-LinuxPlaying* LinuxMusic::get_state(void) {
-  return new LinuxPlaying();
+AudioTraits::PlayerClass* LinuxMusic::get_player(void) const {
+  return LinuxMusicPlayer::get_instance();
 }
 
-void LinuxMusic::destroy(AudioTraits::MusicClass* music) {
+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 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;
 }
 
-AudioTraits::PlayingClass::PlayingStatus LinuxPlaying::status(void) {
+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;
+void LinuxMusicPlaying::destroy(AudioTraits::PlayingClass* state) {
+  delete state;
+}
+
+LinuxSamplePlayer* LinuxSamplePlayer::_global_instance =
+   (LinuxSamplePlayer*)0L;
 
-LinuxPlayer::~LinuxPlayer(void) {
+LinuxSamplePlayer::~LinuxSamplePlayer(void) {
 }
 
-void LinuxPlayer::play_sample(AudioTraits::SampleClass* sample) {
+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;
+}
+
+LinuxMusicPlayer* LinuxMusicPlayer::_global_instance =
+   (LinuxMusicPlayer*)0L;
+
+LinuxMusicPlayer::~LinuxMusicPlayer(void) {
+}
+
+void LinuxMusicPlayer::play_sound(AudioTraits::SoundClass*,
+				  AudioTraits::PlayingClass*) {
+  initialize();
 }
 
-void LinuxPlayer::set_volume(AudioTraits::MusicClass*, int) {
+void LinuxMusicPlayer::set_volume(AudioTraits::PlayingClass*, int) {
 }
 
-LinuxPlayer* LinuxPlayer::get_instance(void) {
-  if (_global_instance == (LinuxPlayer*)0L)
-    _global_instance = new LinuxPlayer();
+LinuxMusicPlayer* LinuxMusicPlayer::get_instance(void) {
+  if (_global_instance == (LinuxMusicPlayer*)0L)
+    _global_instance = new LinuxMusicPlayer();
   return _global_instance;
 }
 

panda/src/audio/audio_linux_traits.h

@@ -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);
+  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 LinuxSamplePlaying : public AudioTraits::PlayingClass {
+  Buffer* _buff;
+public:
+  INLINE LinuxSamplePlaying(AudioTraits::SoundClass*);
+  virtual ~LinuxSamplePlaying(void);
+
+  virtual AudioTraits::PlayingClass::PlayingStatus status(void);
 public:
-  virtual LinuxPlaying* get_state(void);
-  static void destroy(AudioTraits::MusicClass*);
+  INLINE Buffer* get_data(void);
+  static void destroy(AudioTraits::PlayingClass*);
 };
 
-class EXPCL_PANDA LinuxPlaying : public AudioTraits::PlayingClass {
+class EXPCL_PANDA LinuxMusicPlaying : public AudioTraits::PlayingClass {
 public:
-  INLINE LinuxPlaying(void);
-  virtual ~LinuxPlaying(void);
+  INLINE LinuxMusicPlaying(AudioTraits::SoundClass*);
+  virtual ~LinuxMusicPlaying(void);
 
   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 LinuxSamplePlayer* get_instance(void);
+private:
+  static LinuxSamplePlayer* _global_instance;
 };
 
-class EXPCL_PANDA LinuxPlayer : public AudioTraits::PlayerClass {
+class EXPCL_PANDA LinuxMusicPlayer : public AudioTraits::PlayerClass {
 public:
-  INLINE LinuxPlayer(void);
-  virtual ~LinuxPlayer(void);
+  INLINE LinuxMusicPlayer(void);
+  virtual ~LinuxMusicPlayer(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 LinuxPlayer* get_instance(void);
+  static LinuxMusicPlayer* get_instance(void);
 private:
-  static LinuxPlayer* _global_instance;
+  static LinuxMusicPlayer* _global_instance;
 };
 
 #include "audio_linux_traits.I"

panda/src/audio/audio_manager.I

@@ -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)
-//       Access: Public, Static
-//  Description: set the volume on a sample
-////////////////////////////////////////////////////////////////////
-INLINE void AudioManager::set_volume(AudioSample* sample, int v) {
-  get_ptr()->ns_set_volume(sample, v);
-}
-
-////////////////////////////////////////////////////////////////////
-//     Function: AudioManager::set_volume (music)
+//     Function: AudioManager::set_volume (sound)
 //       Access: Public, Static
-//  Description: set the volume on music
+//  Description: set the volume on a sound instance
 ////////////////////////////////////////////////////////////////////
-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);
 }
 
 ////////////////////////////////////////////////////////////////////

panda/src/audio/audio_manager.cxx

@@ -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)
-//       Access: Private
-//  Description: get the player off the sample, 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)
+//     Function: AudioManager::ns_set_volume (AudioSound)
 //       Access: Private
-//  Description: get the player off the music, and set volume on it
+//  Description: get the player off the sound, 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);
 }
 
 ////////////////////////////////////////////////////////////////////

panda/src/audio/audio_manager.h

@@ -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"

panda/src/audio/audio_mikmod_traits.cxx

@@ -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.;
+}
+
+AudioTraits::PlayingClass* MikModMidi::get_state(void) const {
+  return new MikModMidiPlaying((MikModMidi*)this);
 }
 
-void MikModMidi::destroy(AudioTraits::MusicClass* music) {
+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) {
+}
+
+MikModSamplePlaying::~MikModSamplePlaying(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;
 }
 
-MikModPlaying::MikModPlaying(void) : AudioTraits::PlayingClass() {
+MikModMidiPlaying::MikModMidiPlaying(AudioTraits::SoundClass* s)
+  : AudioTraits::PlayingClass(s) {
 }
 
-MikModPlaying::~MikModPlaying(void) {
+MikModMidiPlaying::~MikModMidiPlaying(void) {
 }
 
-AudioTraits::PlayingClass::PlayingStatus MikModPlaying::status(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();

panda/src/audio/audio_mikmod_traits.h

@@ -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);

panda/src/audio/audio_music.I

@@ -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

panda/src/audio/audio_music.h

@@ -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;

panda/src/audio/audio_null_traits.I

@@ -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() {

panda/src/audio/audio_null_traits.cxx

@@ -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;
 }
 
-NullPlayer::~NullPlayer(void) {
+void NullPlaying::destroy(AudioTraits::PlayingClass* play) {
+  delete play;
 }
 
-void NullPlayer::play_sample(AudioTraits::SampleClass*) {
-  if (audio_cat->is_debug())
-    audio_cat->debug() << "in play sample in Null audio driver" << endl;
+NullPlayer::~NullPlayer(void) {
 }
 
-void NullPlayer::play_music(AudioTraits::MusicClass*) {
+void NullPlayer::play_sound(AudioTraits::SoundClass*,
+			    AudioTraits::PlayingClass*) {
   if (audio_cat->is_debug())
-    audio_cat->debug() << "in play music in Null audio driver" << endl;
+    audio_cat->debug() << "in play sound in Null audio driver" << endl;
 }
 
-void NullPlayer::set_volume(AudioTraits::SampleClass*, int) {
+void NullPlayer::set_volume(AudioTraits::PlayingClass*, 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 */

panda/src/audio/audio_null_traits.h

@@ -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);
-
-  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);
+  INLINE NullSound(void);
+  virtual ~NullSound(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"

panda/src/audio/audio_pool.I

@@ -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();
 }
 
 ////////////////////////////////////////////////////////////////////

panda/src/audio/audio_pool.cxx

@@ -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;
-  }
-  PT(AudioSample) the_sample = new AudioSample(sample, state, player, destroy,
-					       filename);
-  _samples[filename] = the_sample;
-  return the_sample;
-}
-
-////////////////////////////////////////////////////////////////////
-//     Function: AudioPool::ns_release_sample
-//       Access: Private
-//  Description: The nonstatic implementation of release_sample().
-////////////////////////////////////////////////////////////////////
-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);
-  }
-}
-
-////////////////////////////////////////////////////////////////////
-//     Function: AudioPool::ns_release_all_samples
-//       Access: Private
-//  Description: The nonstatic implementation of release_all_samples().
-////////////////////////////////////////////////////////////////////
-void AudioPool::ns_release_all_samples(void) {
-  _samples.clear();
-}
-
-////////////////////////////////////////////////////////////////////
-//     Function: AudioPool::register_sample_loader
-//       Access: Public, static
-//  Description: A static function to register a function for loading
-//               audio samples.
-////////////////////////////////////////////////////////////////////
-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()) {
-    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 (AudioSound*)0L;
   }
-  return false;
+  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_load_music
+//     Function: AudioPool::ns_release_sound
 //       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;
+//  Description: The nonstatic implementation of release_sound().
+////////////////////////////////////////////////////////////////////
+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);
   }
-  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
+//     Function: AudioPool::ns_release_all_sounds
 //       Access: Private
-//  Description: The nonstatic implementation of release_music().
+//  Description: The nonstatic implementation of release_all_sounds().
 ////////////////////////////////////////////////////////////////////
-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);
+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::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
+//     Function: AudioPool::register_sound_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 sounds.
+////////////////////////////////////////////////////////////////////
+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;
   }
-  (*_music_loaders)[ext] = func;
+  (*_sound_loaders)[ext] = func;
 }

panda/src/audio/audio_pool.h

@@ -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);
-
-  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*);
+  typedef AudioTraits::SoundClass* SoundLoadFunc(Filename);
+
+  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"

panda/src/audio/audio_sample.I

@@ -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

panda/src/audio/audio_sample.cxx

@@ -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;

panda/src/audio/audio_sample.h

@@ -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;

panda/src/audio/audio_sound.cxx

@@ -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:

panda/src/audio/audio_sound.h

@@ -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__ */

panda/src/audio/audio_trait.cxx

@@ -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_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::play_sound(AudioTraits::SoundClass*,
+					  AudioTraits::PlayingClass*) {
+  audio_cat->error() << "In abstract PlayerClass::play_sound!" << 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;
 }

panda/src/audio/audio_trait.h

@@ -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;
   };
 };
 

panda/src/audio/audio_win_traits.I

@@ -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 WinSamplePlayer::WinSamplePlayer(void) : AudioTraits::PlayerClass() {
 }
 
-INLINE WinPlayer::WinPlayer(void) : AudioTraits::PlayerClass() {
+INLINE WinMusicPlayer::WinMusicPlayer(void) : AudioTraits::PlayerClass() {
 }

panda/src/audio/audio_win_traits.cxx

@@ -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;
-  }
-}
-
-WinPlaying* WinSample::get_state(void) {
-  return new WinPlaying();
+  memcpy(&(ret->_info), &wavInfo, sizeof(WAVEFORMATEX));
+  ret->_data = data;
+  ret->_len = size;
+  return ret;
 }
 
-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) {
-  if (audio_cat->is_debug())
-    audio_cat->debug() << "in WinMusic::destroy()" << endl;
-  delete music;
-  if (audio_cat->is_debug())
-    audio_cat->debug() << "out of WinMusic::destroy()" << endl;
+WinSamplePlaying::~WinSamplePlaying(void) {
 }
 
-WinPlaying::~WinPlaying(void) {
+void WinSamplePlaying::destroy(AudioTraits::PlayingClass* play) {
+  delete play;
 }
 
-AudioTraits::PlayingClass::PlayingStatus WinPlaying::status(void) {
-  return AudioTraits::PlayingClass::BAD;
+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::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() << "returning READY" << endl;
+  return READY;
 }
 
-WinPlayer* WinPlayer::_global_instance = (WinPlayer*)0L;
+WinSamplePlayer* WinSamplePlayer::_global_instance = (WinSamplePlayer*)0L;
 
-WinPlayer::~WinPlayer(void) {
+WinSamplePlayer::~WinSamplePlayer(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 WinSamplePlayer::set_volume(AudioTraits::PlayingClass*, int) {
+}
+
+WinSamplePlayer* WinSamplePlayer::get_instance(void) {
+  if (_global_instance == (WinSamplePlayer*)0L)
+    _global_instance = new WinSamplePlayer();
+  return _global_instance;
 }
 
-void WinPlayer::set_volume(AudioTraits::SampleClass*, int) {
+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 WinPlayer::set_volume(AudioTraits::MusicClass*, int) {
+void WinMusicPlayer::set_volume(AudioTraits::PlayingClass*, int) {
 }
 
-WinPlayer* WinPlayer::get_instance(void) {
-  if (_global_instance == (WinPlayer*)0L)
-    _global_instance = new WinPlayer();
+WinMusicPlayer* WinMusicPlayer::get_instance(void) {
+  if (_global_instance == (WinMusicPlayer*)0L)
+    _global_instance = new WinMusicPlayer();
   return _global_instance;
 }
 

panda/src/audio/audio_win_traits.h

@@ -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 WinMusicPlaying : public AudioTraits::PlayingClass {
+public:
+  WinMusicPlaying(AudioTraits::SourceClass*);
+  ~WinMusicPlaying(void);
+
+  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 WinSamplePlayer* get_instance(void);
+private:
+  static WinSamplePlayer* _global_instance;
 };
 
-class EXPCL_PANDA WinPlayer : public AudioTraits::PlayerClass {
+class EXPCL_PANDA WinMusicPlayer : public AudioTraits::PlayerClass {
 public:
-  INLINE WinPlayer(void);
-  virtual ~WinPlayer(void);
+  INLINE WinMusicPlayer(void);
+  virtual ~WinMusicPlayer(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 WinPlayer* get_instance(void);
+  static WinMusicPlayer* get_instance(void);
 private:
-  static WinPlayer* _global_instance;
+  static WinMusicPlayer* _global_instance;
 };
 
 #include "audio_win_traits.I"

panda/src/audio/config_audio.cxx

@@ -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);

panda/src/audio/test_audio.cxx

@@ -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);
   }

panda/src/audiotraits/audio_load_midi.cxx

@@ -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);
 }

panda/src/audiotraits/audio_load_mp3.cxx

@@ -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);
 }

panda/src/audiotraits/audio_load_st.cxx

@@ -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;

panda/src/audiotraits/audio_load_wav.cxx

@@ -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);
 }

panda/src/mpg123/vbrhead.c

@@ -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;