E:/prg/sdlpp/include/sdlpp_sound.h

#ifndef H_SDLPP_SOUND
#define H_SDLPP_SOUND

#include "sdlpp_common.h"
#include "sdlpp_io.h"

class MP3Decoder;

namespace SDLPP {

const int SOUND_BUFFER_SIZE = 1024;

//
// Sound functions.
//   Initialize sound engine by using the init_audio function in the Application object
//   Create as many SoundClip objects as you want and play them when you want
//   Note that destroying a SoundClip object while it's playing is not recommended.
//


//struct Sound_State
//{
//  Sound_State() : sample(0), next_data(0) {}
//  void* sample;
//  int   next_data;
//};

class SoundClip : public RefCount
{
public:
  SoundClip(const xstring& filename="", ResourceFile* rf=0);
  SoundClip(std::istream* is);
  virtual ~SoundClip();
  SoundClip(const SoundClip& rhs);
  SoundClip& operator= (const SoundClip& rhs);
  
  void play(bool loop=false);
protected:
  void destroy();
private:
  void load_from_rwop(SDL_RWops* rwops, const char* name);
  void load(const xstring& filename);
  void load(std::istream* is);
  friend class SoundManager;
  Uint8* m_Buffer;
  Uint32 m_Length;
  bool   m_Converted;
};

class SoundStream : public RefCount
{
public:
  SoundStream(const xstring& filename="");
  SoundStream(std::istream* is);
  SoundStream(ResourceFile& rf, const xstring& name);
  virtual ~SoundStream();
  SoundStream(const SoundStream& rhs);
  SoundStream& operator= (const SoundStream& rhs);

  void play();

  void stop();
protected:
  void destroy();

  virtual Uint8* get_frame(int bytes);
private:
  void load_from_rwop(SDL_RWops* rwops, const char* name);
  void load(const xstring& filename);
  void load(std::istream* is);
  friend class SoundManager;
  friend struct SoundStream_Thread;

  int frames_available();
  int frames_to_fill();

  int    decode_thread();

  struct Data
  {
    Data(int size)
      : m_DataStream(0),
        m_Source(0),
        m_Decoder(0),
        m_Buffer(new Uint8[size]),
        m_Start(0), 
        m_Stop(0),
        m_DecodeThread(0),
        m_Semaphore(0),
        m_Finished(false),
        m_ThreadDone(false)
    {}
    std::istream*        m_DataStream;
    SDL_RWops*           m_Source;
    //Sound_State          m_State;
    MP3Decoder*          m_Decoder;
    std::vector<Uint8>   m_EncodedStream;
    Uint8*               m_Buffer;
    int                  m_Start,m_Stop;
    SDL_Thread*          m_DecodeThread;
    SDL_sem*             m_Semaphore;
    bool                 m_Finished;
    bool                 m_ThreadDone;
  } *m_Data;
};

class SoundManager : public Singleton
{
  struct SoundClipState
  {
    SoundClipState(SoundClip c, bool l) : clip(c), pos(0), loop(l) {}
    SoundClip  clip;
    int        pos;
    bool       loop;
  };

  typedef std::list<SoundClipState> clip_seq;
  typedef std::list<SoundStream> stream_seq;
  clip_seq   m_Clips;
  stream_seq m_Streams;
  double     m_Gain,m_dGain;
  bool       m_Fading;

  void cleanup();
  void AudioCallback(Uint8 *stream, int len);
  static void AudioCallback(void *userdata, Uint8 *stream, int len);
  static Accumulator<int> s_MixingBuffer;
public:
  static SoundManager* instance(bool destroy=false)
  {
    static SoundManager* ptr=0;
    if (!ptr && !destroy) ptr=new SoundManager;
    else
    if (ptr && destroy) { delete ptr; ptr=0; }
    return ptr;
  }

  virtual void shutdown();

  void initialize(int freq, bool stereo);

  void pause(bool state=true);

  void clear(int duration=0);

  int  get_freq() const { return m_Spec.freq; }
  bool is_stereo() const { return m_Spec.channels==2; }

  void play(SoundClip clip, bool loop);

  void play(SoundStream stream);

  SDL_AudioSpec* get_audio_spec() { return &m_Spec; }
private:
  friend class std::auto_ptr<SoundManager>;
  SoundManager() : m_Fading(false), m_Gain(1.0), m_dGain(0.0) {}
  ~SoundManager() 
  {
    SDL_CloseAudio();
  }
  SoundManager(const SoundManager&) {}

  SDL_AudioSpec m_Spec;
};


} // namespace SDLPP


#endif // H_SDLPP_SOUND

---