split out loaders

panda/metalibs/panda/Sources.pp

@@ -15,7 +15,8 @@
     gsgmisc light linmath mathutil net pnm \
     pnmimagetypes pnmimage sgattrib sgmanip sgraph sgraphutil \
     switchnode text tform tiff lerp loader putil effects \
-    audio audio_load_midi audio_load_st audio_load_wav pandabase \
+    audio pandabase \
+//     audio audio_load_midi audio_load_st audio_load_wav pandabase \
 
 #define LOCAL_LIBS downloader event ipc express pandabase
 #define OTHER_LIBS dtool

panda/src/audio/Sources.pp

@@ -29,6 +29,7 @@
 
 #begin lib_target
   #define TARGET audio_load_midi
+  #define BUILDING_DLL BUILDING_MISC
   #define LOCAL_LIBS \
     audio
 
@@ -39,6 +40,7 @@
 
 #begin lib_target
   #define TARGET audio_load_wav
+  #define BUILDING_DLL BUILDING_MISC
   #define LOCAL_LIBS \
     audio
 
@@ -49,6 +51,7 @@
 
 #begin lib_target
   #define TARGET audio_load_st
+  #define BUILDING_DLL BUILDING_MISC
   #define USE_SOXST yes
   #define LOCAL_LIBS \
     audio

panda/src/audio/audio_linux_traits.cxx

@@ -188,7 +188,7 @@ static void internal_update(void*) {
   }
   while (1) {
     if (have_buffers == 0) {
-      ipc_traits::sleep(0, 10000);
+      ipc_traits::sleep(0, audio_auto_update_delay);
     } else {
       write(output_fd, current_buffer, audio_buffer_size);
       {
@@ -248,7 +248,8 @@ void LinuxSample::destroy(AudioTraits::SampleClass* sample) {
 }
 
 LinuxSample* LinuxSample::load_raw(byte* data, unsigned long size) {
-  return new LinuxSample(new Buffer(data, size));
+  LinuxSample* ret = new LinuxSample(new Buffer(data, size));
+  return ret;
 }
 
 LinuxMusic::~LinuxMusic(void) {

panda/src/audio/audio_manager.cxx

@@ -62,7 +62,7 @@ void AudioManager::ns_play(AudioMusic* music) {
 void AudioManager::spawned_update(void*) {
   while (1) {
     AudioManager::update();
-    ipc_traits::sleep(0, 1000000);
+    ipc_traits::sleep(0, audio_auto_update_delay);
   }
 }
 

panda/src/audio/audio_music.I

@@ -9,12 +9,14 @@
 //  Description: initialize a new music
 ////////////////////////////////////////////////////////////////////
 INLINE AudioMusic::AudioMusic(AudioTraits::MusicClass* music,
-				AudioTraits::PlayerClass* player,
+			      AudioTraits::PlayingClass* state,
-				AudioTraits::DeleteMusicFunc* destroy,
+			      AudioTraits::PlayerClass* player,
-				const string& filename) : Namable(filename),
+			      AudioTraits::DeleteMusicFunc* destroy,
-							  _music(music),
+			      const string& filename) : Namable(filename),
-							  _player(player),
+							_music(music),
-							  _destroy(destroy) {}
+							_state(state),
+							_player(player),
+							_destroy(destroy) {}
 
 ////////////////////////////////////////////////////////////////////
 //     Function: AudioMusic::copy constructor
@@ -22,9 +24,10 @@ INLINE AudioMusic::AudioMusic(AudioTraits::MusicClass* music,
 //  Description: copy a music, but we don't really want to allow this
 ////////////////////////////////////////////////////////////////////
 INLINE AudioMusic::AudioMusic(const AudioMusic& c) : Namable(c.get_name()),
-							_music(c._music),
+						     _music(c._music),
-							_player(c._player),
+						     _state(c._state),
-							_destroy(c._destroy) {}
+						     _player(c._player),
+						     _destroy(c._destroy) {}
 
 ////////////////////////////////////////////////////////////////////
 //     Function: AudioMusic::assignment operator
@@ -34,6 +37,7 @@ INLINE AudioMusic::AudioMusic(const AudioMusic& c) : Namable(c.get_name()),
 INLINE AudioMusic& AudioMusic::operator=(const AudioMusic& c) {
   this->set_name(c.get_name());
   this->_music = c._music;
+  this->_state = c._state;
   this->_player = c._player;
   this->_destroy = c._destroy;
   return *this;

panda/src/audio/audio_music.cxx

@@ -24,13 +24,19 @@ AudioMusic::~AudioMusic(void) {
 //  Description: return the current play status of this music
 ////////////////////////////////////////////////////////////////////
 AudioMusic::MusicStatus AudioMusic::status(void) {
+  //  AudioTraits::PlayingClass::PlayingStatus stat = _state->status();
   AudioTraits::MusicClass::MusicStatus stat = _music->status();
   switch (stat) {
+    //  case AudioTraits::PlayingClass::BAD:
+  case AudioTraits::MusicClass::BAD:
+    return BAD;
+    //  case AudioTraits::PlayingClass::READY:
   case AudioTraits::MusicClass::READY:
     return READY;
+    //  case AudioTraits::PlayingClass::PLAYING:
   case AudioTraits::MusicClass::PLAYING:
     return PLAYING;
   }
   audio_cat->error() << "unknown status for music" << endl;
-  return READY;
+  return BAD;
 }

panda/src/audio/audio_music.h

@@ -16,11 +16,13 @@ class AudioManager;
 class EXPCL_PANDA AudioMusic : public TypedReferenceCount, public Namable {
 private:
   AudioTraits::MusicClass *_music;
+  AudioTraits::PlayingClass *_state;
   AudioTraits::PlayerClass *_player;
   AudioTraits::DeleteMusicFunc *_destroy;
 protected:
-  INLINE AudioMusic(AudioTraits::MusicClass*, AudioTraits::PlayerClass*,
+  INLINE AudioMusic(AudioTraits::MusicClass*, AudioTraits::PlayingClass*,
-		    AudioTraits::DeleteMusicFunc*, const string&);
+		    AudioTraits::PlayerClass*, AudioTraits::DeleteMusicFunc*,
+		    const string&);
   INLINE AudioMusic(const AudioMusic&);
   INLINE AudioMusic& operator=(const AudioMusic&);
 
@@ -33,7 +35,7 @@ public:
   virtual ~AudioMusic(void);
   INLINE bool operator==(const AudioMusic&) const;
 
-  enum MusicStatus { READY, PLAYING };
+  enum MusicStatus { BAD, READY, PLAYING };
 
   MusicStatus status(void);
 public:

panda/src/audio/audio_pool.cxx

@@ -96,8 +96,9 @@ AudioSample* AudioPool::ns_load_sample(Filename filename) {
     audio_cat->error() << "could not load '" << filename << "'" << endl;
     return (AudioSample*)0L;
   }
-  PT(AudioSample) the_sample = new AudioSample(sample, player, destroy,
+  PT(AudioSample) the_sample = new AudioSample(sample,
-					       filename);
+					       (AudioTraits::PlayingClass*)0L,
+					       player, destroy, filename);
   _samples[filename] = the_sample;
   return the_sample;
 }
@@ -195,7 +196,9 @@ AudioMusic* AudioPool::ns_load_music(Filename filename) {
     audio_cat->error() << "could not load '" << filename << "'" << endl;
     return (AudioMusic*)0L;
   }
-  PT(AudioMusic) the_music = new AudioMusic(music, player, destroy, filename);
+  PT(AudioMusic) the_music = new AudioMusic(music,
+					    (AudioTraits::PlayingClass*)0L,
+					    player, destroy, filename);
   _music[filename] = the_music;
   return the_music;
 }

panda/src/audio/audio_sample.I

@@ -9,10 +9,12 @@
 //  Description: initialize a new sample
 ////////////////////////////////////////////////////////////////////
 INLINE AudioSample::AudioSample(AudioTraits::SampleClass* sample,
+				AudioTraits::PlayingClass* state,
 				AudioTraits::PlayerClass* player,
 				AudioTraits::DeleteSampleFunc* destroy,
 				const string& filename) : Namable(filename),
 							  _sample(sample),
+							  _state(state),
 							  _player(player),
 							  _destroy(destroy) {}
 
@@ -23,6 +25,7 @@ INLINE AudioSample::AudioSample(AudioTraits::SampleClass* sample,
 ////////////////////////////////////////////////////////////////////
 INLINE AudioSample::AudioSample(const AudioSample& c) : Namable(c.get_name()),
 							_sample(c._sample),
+							_state(c._state),
 							_player(c._player),
 							_destroy(c._destroy) {}
 
@@ -34,6 +37,7 @@ INLINE AudioSample::AudioSample(const AudioSample& c) : Namable(c.get_name()),
 INLINE AudioSample& AudioSample::operator=(const AudioSample& c) {
   this->set_name(c.get_name());
   this->_sample = c._sample;
+  this->_state = c._state;
   this->_player = c._player;
   this->_destroy = c._destroy;
   return *this;

panda/src/audio/audio_sample.cxx

@@ -33,13 +33,19 @@ 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();
   switch (stat) {
+    //  case AudioTraits::PlayingClass::BAD:
+  case AudioTraits::SampleClass::BAD:
+    return BAD;
+    //  case AudioTraits::PlayingClass::READY:
   case AudioTraits::SampleClass::READY:
     return READY;
+    //  case AudioTraits::PlayingClass::PLAYING:
   case AudioTraits::SampleClass::PLAYING:
     return PLAYING;
   }
   audio_cat->error() << "unknown status for sample" << endl;
-  return READY;
+  return BAD;
 }

panda/src/audio/audio_sample.h

@@ -16,11 +16,13 @@ class AudioManager;
 class EXPCL_PANDA AudioSample : public TypedReferenceCount, public Namable {
 private:
   AudioTraits::SampleClass *_sample;
+  AudioTraits::PlayingClass *_state;
   AudioTraits::PlayerClass *_player;
   AudioTraits::DeleteSampleFunc *_destroy;
 protected:
-  INLINE AudioSample(AudioTraits::SampleClass*, AudioTraits::PlayerClass*,
+  INLINE AudioSample(AudioTraits::SampleClass*, AudioTraits::PlayingClass*,
-		     AudioTraits::DeleteSampleFunc*, const string&);
+		     AudioTraits::PlayerClass*, AudioTraits::DeleteSampleFunc*,
+		     const string&);
   INLINE AudioSample(const AudioSample&);
   INLINE AudioSample& operator=(const AudioSample&);
 
@@ -33,7 +35,7 @@ public:
   virtual ~AudioSample(void);
   INLINE bool operator==(const AudioSample&) const;
 
-  enum SampleStatus { READY, PLAYING } ;
+  enum SampleStatus { BAD, READY, PLAYING } ;
   
   float length(void);
   SampleStatus status(void);

panda/src/audio/audio_trait.cxx

@@ -27,6 +27,15 @@ AudioTraits::MusicClass::MusicStatus AudioTraits::MusicClass::status(void) {
   return READY;
 }
 
+AudioTraits::PlayingClass::~PlayingClass(void) {
+}
+
+AudioTraits::PlayingClass::PlayingStatus
+AudioTraits::PlayingClass::status(void) {
+  audio_cat->error() << "In abstract PlayingClass::status!" << endl;
+  return BAD;
+}
+
 AudioTraits::PlayerClass::~PlayerClass(void) {
 }
 

panda/src/audio/audio_trait.h

@@ -21,7 +21,7 @@ public:
     SampleClass(void) {}
     virtual ~SampleClass(void);
 
-    enum SampleStatus { READY, PLAYING } ;
+    enum SampleStatus { BAD, READY, PLAYING } ;
 
     virtual float length(void) = 0;
     virtual SampleStatus status(void) = 0;
@@ -31,9 +31,19 @@ public:
     MusicClass(void) {}
     virtual ~MusicClass(void);
 
-    enum MusicStatus { READY, PLAYING };
+    enum MusicStatus { BAD, READY, PLAYING } ;
+
     virtual MusicStatus status(void) = 0;
   };
+  class EXPCL_PANDA PlayingClass {
+  public:
+    PlayingClass(void) {}
+    virtual ~PlayingClass(void);
+
+    enum PlayingStatus { BAD, READY, PLAYING } ;
+
+    virtual PlayingStatus status(void) = 0;
+  };
   class EXPCL_PANDA PlayerClass {
   public:
     PlayerClass(void) {}
@@ -49,18 +59,14 @@ public:
 // this is really ugly.  But since we have to be able to include/compile
 // all of the driver files on any system, I need to centralize a switch
 // for which one is real.
-#ifdef HAVE_MIKMOD
-#define AUDIO_USE_MIKMOD
-#else /* HAVE_MIKMOD */
-#ifdef PENV_WIN32
-#define AUDIO_USE_WIN32
-#else /* PENV_WIN32 */
 #ifdef PENV_LINUX
 #define AUDIO_USE_LINUX
-#else /* PENV_LINUX */
+#elif defined(PENV_WIN32)
+#define AUDIO_USE_WIN32
+#elif defined(HAVE_MIKMOD)
+#define AUDIO_USE_MIKMOD
+#else
 #define AUDIO_USE_NULL
-#endif /* PENV_LINUX */
+#endif
-#endif /* PENV_WIN32 */
-#endif /* HAVE_MIKMOD */
 
 #endif /* __AUDIO_TRAIT_H__ */

panda/src/audio/config_audio.cxx

@@ -20,6 +20,8 @@ int audio_driver_select = config_audio.GetInt("audio-driver-select", 0);
 string* audio_driver_params;
 int audio_buffer_size = config_audio.GetInt("audio-buffer-size", 4096);
 string* audio_device;
+int audio_auto_update_delay = config_audio.GetInt("audio-auto-update-delay",
+						  100000);
 
 ConfigureFn(config_audio) {
   AudioSample::init_type();

panda/src/audio/config_audio.h

@@ -18,5 +18,6 @@ extern int audio_driver_select;
 extern string* audio_driver_params;
 extern int audio_buffer_size;
 extern string* audio_device;
+extern int audio_auto_update_delay;
 
 #endif /* __CONFIG_AUDIO_H__ */