sound.h

Go to the documentation of this file.

/*****************************************************************************
 * $Id: sound.h,v 1.12 2003/06/27 08:38:26 schou Exp $
 * Author: Jakob Schou Jensen <schou@sourceforge.net>
 * Licence: GPL
 *
 * Description: Sound functions
 *
 ****************************************************************************/

#ifndef SOUND_H
#define SOUND_H

#include <SDL/SDL.h>
#include <vorbis/codec.h>
#include <vorbis/vorbisfile.h>
#include <adsomath.h>

#define MAX_AUDIO_CHANNELS 64
#define SOUND_PROCESS_NUM 2
#define SOUND_PHOTON_NUM 3
#define SOUNDWAVE_MAX_WAVES 4


// Wave file structures

#define FormatID 'fmt '
#define DataID 'data'

typedef char ChunkID[4];

#define checkID(a,b) (a[0]==b[0] && a[1]==b[1] && a[2]==b[2] && a[3]==b[3])

struct FileChunk {
  ChunkID RiffID;
  int chunkSize;
  ChunkID WaveID;
};

struct ChunkHeader {
  ChunkID        chunkID;
  long           chunkSize;
};

struct FormatChunk {
  short          wFormatTag;
  unsigned short wChannels;
  unsigned long  dwSamplesPerSec;
  unsigned long  dwAvgBytesPerSec;
  unsigned short wBlockAlign;
  unsigned short wBitsPerSample;
};

// Internal wave data structure

struct WaveData {
  int samplesPerSec;
  int bitsPerSample;
  int channels;
  int length;
  unsigned char *data;
};

WaveData *readWav(FILE *file, int maxDataSize);
WaveData *readRaw(FILE *file, char *filename);
int isWavFile(FILE *file);

class StereoSample {
 public:
  short left,right;
  StereoSample(short l, short r) { left = l; right = r; }
};

// Sound

class Sound {
 protected:
  int active;
  int starting;
  int stereo;
  v3f pos;
  int positional;

  // distance lpf
  double lpf_alpha, lpf_beta;
  double lpf_x1, lpf_y1;

  double currentFreq, targetFreq;
  double currentVol, targetVol;
  double currentVelocity, targetVelocity;
  double currentAttLeft, targetAttLeft;
  double currentAttRight, targetAttRight;

 public:
  virtual short nextSample(double fragPos);
  virtual void startFill();
  virtual StereoSample nextStereoSample(double fragPos);
  virtual void play();
  virtual void playVelocity(double v);
  virtual void stop();
  int isActive(){return active;}
  void setFreq(double f);
  void setVol(double v);
  void setVelocity(double v);
  void setPos(v3f p);
  int isPlaying(){return active;}
  Sound();

  friend void fillAudio(void *udata, Uint8 *stream, int len);
  friend class AudioServer;
};

#define SOUNDSYNTH_BELL   0
#define SOUNDSYNTH_ENGINE 1
#define SOUNDSYNTH_BEEP   2

// SoundSynth

class SoundSynth : public Sound {
  int type;
  int samplePos;
  double wavePos;
 public:
  short nextSample(double fragPos);
  void play();
  void playVelocity(double v);
  void stop();
  void setType(int);
};

// SoundWave

struct Dobbler {
  double t, v, y;
  v3f d_r;

  static const double v_s;
  Dobbler(v3f pos, v3f vel);
  Dobbler(){}
};

class SoundWave : public Sound {
  int loop;
  int samplePos;
  double wavePos;
  WaveData *wave;
  WaveData *waveList[SOUNDWAVE_MAX_WAVES];
  int nWaves, activeWave;
  int dobblerEnabled;
  Dobbler dobbler;

  int *ptimeArray, *pwiArray;
  double *pvelArray;
  Dobbler *pdobArray;
  int ptimeMax, ptimeHead, ptimeTail, playTimed;
  int lastFillTime, setFillTime;
  
 public:
  short nextSample(double fragPos);
  StereoSample nextStereoSample(double fragPos);
  void startFill();
  void play();
  void playVelocity(double v);
  void playDobbler(double,Dobbler);
  void enableDobbler(){ dobblerEnabled = 1; stereo = 1; }
  void enableTimedPlay();
  void stop();
  int loadWave(char*);
  int loadMultiWave(char*);
  void setActiveWave(int i){ if(i<nWaves) activeWave = i; }
  void setLoop(int);
  SoundWave(){ wave = 0; loop = 0; playTimed = 0; nWaves = 0; activeWave = 0; dobblerEnabled = 0; }
};

// SoundOgg

struct SoundOggTrack {
  int streamPos;
  int pcm_length;
  int bars;
  int pre;
};

struct SoundOggSong {
  short *trackList;
  int length;
  int loopStart;
};

struct SoundOggMemFile {
  char *data;
  size_t size;
  long pos;
};

class SoundOgg : public Sound {
  OggVorbis_File *vf0,*vf1;
  vorbis_info *vi;
  SoundOggTrack *tracks;
  int trackCount;
  int bpm; // beats per minute
  int spb; // samples per bar

  char *waveBuffer0, *waveBuffer1;
  int buf0Index, buf0Len, buf1Index, buf1Len, bufSize; // buffer index/length in bytes
  int buf0TrackPos, buf1TrackPos; // track position in samples
  int buf0TrackNum, buf1TrackNum;
  int stream0seek, stream1seek;

  int current_section;

  int rate_44100; // otherwise 22050 is assumed

  SoundOggSong *song;
  int songPos;

  int nextTrack();

 public:
  short nextSample(double fragPos);
  StereoSample nextStereoSample(double fragPos);
  void play();
  void stop();
  int init(char *filename);
  void setSong(SoundOggSong *);
  SoundOgg();
};

void fillAudio(void *udata, Uint8 *stream, int len);


// AudioServer

class AudioServer {
  unsigned int samplePos;
  Sound *ch[MAX_AUDIO_CHANNELS];
  int nChannel;
  int initialized;
 public:

  int init();
  void close();
  int isInitialized(){return initialized;}
  int addChannel(Sound *s);
  void setHeadPos(v3f pos, v3f d_r);
  void lockAudio(){
    if(initialized) SDL_LockAudio();
  }
  void unlockAudio(){
    if(initialized) SDL_UnlockAudio();
  }

  AudioServer(){
    nChannel = 0;
    initialized = 0;
  }

  friend void fillAudio(void *udata, Uint8 *stream, int len);
};

// SoundArchive

struct OggPage {
  char id[4];
  char pad[22];
  unsigned char segmentCount;
  unsigned char segments[255];
};

// Sound Archive stream
class SaStream {
public:
  FILE *file;
  int startPos, endPos;

  int nextStream();
  SaStream(FILE *f){ file = f; startPos = 0; endPos = -1; }
};

struct SoundArchiveEntry {
  char *name;
  char *data;
  int length;
  int rate;
  int channels;
};

class SoundArchive {
 public:
  SoundArchiveEntry *entries;
  int entryCount;

  WaveData *lookup(char *name);

  int load(char *);

  SoundArchive(){ entries = 0; entryCount = 0; }
};

void initSound();

extern AudioServer audio;

extern SoundArchive soundArchive;

extern SoundSynth soundBell;
extern SoundWave soundProcess[SOUND_PROCESS_NUM];
extern SoundWave soundOppScore;
extern SoundWave soundLogon;
extern SoundWave soundCallRescue;
extern SoundWave soundRescue;
extern SoundWave soundRescueDeny;
extern SoundWave soundTurboOn;
extern SoundWave soundTurboOff;
extern SoundWave soundKey;
extern SoundWave soundDeadKey;
extern SoundWave soundEpsilonSucces;
extern SoundWave soundScreenPrint;
extern SoundWave soundNetLink;
extern SoundWave soundChatPrint;
extern SoundWave soundUfo;
extern SoundWave soundUfoBeam;
extern SoundWave soundUfoHit;
extern SoundWave soundPhoton[SOUND_PHOTON_NUM];
extern SoundOgg soundMusic;

extern SoundOggSong themePrelude;
extern SoundOggSong themeBriefing;
extern SoundOggSong themeMissionPart1;
extern SoundOggSong themeMissionPart2;
extern SoundOggSong themeSuccess;

#endif

---