Fix setinfo.
[xonotic/darkplaces.git] / snd_main.h
index 0eea61a..527ce49 100644 (file)
@@ -24,26 +24,38 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 #include "sound.h"
 
 
-typedef struct
-{
-       unsigned int    length;
-       unsigned int    offset;
-       qbyte   data[4];        // variable sized
-} sfxbuffer_t;
-
-typedef struct
+typedef struct snd_format_s
 {
        unsigned int    speed;
-       unsigned int    width;
-       unsigned int    channels;
+       unsigned short  width;
+       unsigned short  channels;
 } snd_format_t;
 
+typedef struct snd_buffer_s
+{
+       snd_format_t            format;
+       unsigned int            nbframes;       // current size, in sample frames
+       unsigned int            maxframes;      // max size (buffer size), in sample frames
+       unsigned char           samples[4];     // variable sized
+} snd_buffer_t;
+
+typedef struct snd_ringbuffer_s
+{
+       snd_format_t            format;
+       unsigned char*          ring;
+       unsigned int            maxframes;      // max size (buffer size), in sample frames
+       unsigned int            startframe;     // index of the first frame in the buffer
+                                                                       // if startframe == endframe, the bufffer is empty
+       unsigned int            endframe;       // index of the first EMPTY frame in the "ring" buffer
+                                                                       // may be smaller than startframe if the "ring" buffer has wrapped
+} snd_ringbuffer_t;
+
 // sfx_t flags
 #define SFXFLAG_NONE                   0
 #define SFXFLAG_FILEMISSING            (1 << 0) // wasn't able to load the associated sound file
-#define SFXFLAG_SERVERSOUND            (1 << 1) // the sfx is part of the server precache list
+#define SFXFLAG_LEVELSOUND             (1 << 1) // the sfx is part of the server or client precache list for this level
 #define SFXFLAG_STREAMED               (1 << 2) // informative only. You shouldn't need to know that
-#define SFXFLAG_PERMANENTLOCK  (1 << 3) // can never be freed (ex: used by the client code)
+#define SFXFLAG_MENUSOUND              (1 << 3) // not freed during level change (menu sounds, music, etc)
 
 typedef struct snd_fetcher_s snd_fetcher_t;
 struct sfx_s
@@ -51,100 +63,151 @@ struct sfx_s
        char                            name[MAX_QPATH];
        sfx_t                           *next;
        size_t                          memsize;                // total memory used (including sfx_t and fetcher data)
-       int                                     locks;                  // One lock is automatically granted while the sfx is
-                                                                               // playing (and removed when stopped). Locks can also be
-                                                                               // added by S_PrecacheSound and S_ServerSounds.
-                                                                               // A SFX with no lock and no SFXFLAG_PERMANENTLOCK is
-                                                                               // freed at level change by S_ServerSounds.
+
+       snd_format_t            format;                 // format describing the audio data that fetcher->getsamplesfloat will return
        unsigned int            flags;                  // cf SFXFLAG_* defines
-       snd_format_t            format;
-       int                                     loopstart;
-       unsigned int            total_length;
+       unsigned int            loopstart;              // in sample frames. equals total_length if not looped
+       unsigned int            total_length;   // in sample frames
        const snd_fetcher_t     *fetcher;
        void                            *fetcher_data;  // Per-sfx data for the sound fetching functions
+
+       float                           volume_mult;    // for replay gain (multiplier to apply)
+       float                           volume_peak;    // for replay gain (highest peak); if set to 0, ReplayGain isn't supported
 };
 
-typedef struct
-{
-       snd_format_t    format;
-       int                             samples;                // mono samples in buffer
-       int                             samplepos;              // in mono samples
-       unsigned char   *buffer;
-       int                             bufferlength;   // used only by certain drivers
-} dma_t;
-
-typedef struct
+// maximum supported speakers constant
+#define SND_LISTENERS 8
+
+typedef struct channel_s
 {
-       sfx_t                   *sfx;                   // sfx number
+       // provided sound information
+       sfx_t                   *sfx;                   // pointer to sound sample being used
+       float                   basevolume;             // 0-1 master volume
        unsigned int    flags;                  // cf CHANNELFLAG_* defines
-       int                             master_vol;             // 0-255 master volume
-       int                             leftvol;                // 0-255 volume
-       int                             rightvol;               // 0-255 volume
-       int                             end;                    // end time in global paintsamples
-       int                             lastptime;              // last time this channel was painted
-       int                             pos;                    // sample position in sfx
-       int                             entnum;                 // to allow overriding a specific sound
-       int                             entchannel;
+       int                             entnum;                 // makes sound follow entity origin (allows replacing interrupting existing sound on same id)
+       int                             entchannel;             // which channel id on the entity
        vec3_t                  origin;                 // origin of sound effect
-       vec_t                   dist_mult;              // distance multiplier (attenuation/clipK)
+       vec_t                   distfade;               // distance multiplier (attenuation/clipK)
        void                    *fetcher_data;  // Per-channel data for the sound fetching function
+       int                             prologic_invert;// whether a sound is played on the surround channels in prologic
+       float                   basespeed;              // playback rate multiplier for pitch variation
+
+       // these are often updated while mixer is running, glitching should be minimized (mismatched channel volumes from spatialization is okay)
+       // spatialized playback speed (speed * doppler ratio)
+       float                   mixspeed;
+       // spatialized volume per speaker (mastervol * distanceattenuation * channelvolume cvars)
+       float                   volume[SND_LISTENERS];
+
+       // updated ONLY by mixer
+       // position in sfx, starts at 0, loops or stops at sfx->total_length
+       double                  position;
 } channel_t;
 
-typedef const sfxbuffer_t* (*snd_fetcher_getsb_t) (channel_t* ch, unsigned int start, unsigned int nbsamples);
-typedef void (*snd_fetcher_endsb_t) (channel_t* ch);
-typedef void (*snd_fetcher_free_t) (sfx_t* sfx);
+// Sound fetching functions
+// "start" is both an input and output parameter: it returns the actual start time of the sound buffer
+typedef void (*snd_fetcher_getsamplesfloat_t) (channel_t *ch, sfx_t *sfx, int firstsampleframe, int numsampleframes, float *outsamplesfloat);
+typedef void (*snd_fetcher_stopchannel_t) (channel_t *ch);
+typedef void (*snd_fetcher_freesfx_t) (sfx_t *sfx);
 struct snd_fetcher_s
 {
-       snd_fetcher_getsb_t             getsb;
-       snd_fetcher_endsb_t             endsb;
-       snd_fetcher_free_t              free;
+       snd_fetcher_getsamplesfloat_t           getsamplesfloat;
+       snd_fetcher_stopchannel_t               stopchannel;
+       snd_fetcher_freesfx_t           freesfx;
 };
 
-void S_PaintChannels(int endtime);
+extern unsigned int total_channels;
+extern channel_t channels[MAX_CHANNELS];
 
-// initializes cycling through a DMA buffer and returns information on it
-qboolean SNDDMA_Init(void);
+extern snd_ringbuffer_t *snd_renderbuffer;
+extern qboolean snd_threaded; // enables use of snd_usethreadedmixing, provided that no sound hacks are in effect (like timedemo)
+extern qboolean snd_usethreadedmixing; // if true, the main thread does not mix sound, soundtime does not advance, and neither does snd_renderbuffer->endframe, instead the audio thread will call S_MixToBuffer as needed
 
-// gets the current DMA position
-int SNDDMA_GetDMAPos(void);
+extern cvar_t _snd_mixahead;
+extern cvar_t snd_swapstereo;
+extern cvar_t snd_streaming;
+extern cvar_t snd_streaming_length;
 
-void SNDDMA_Submit(void);
+#define SND_CHANNELLAYOUT_AUTO         0
+#define SND_CHANNELLAYOUT_STANDARD     1
+#define SND_CHANNELLAYOUT_ALSA         2
+extern cvar_t snd_channellayout;
 
-// shutdown the DMA xfer.
-void SNDDMA_Shutdown(void);
+extern int snd_blocked;                // counter. When > 0, we stop submitting sound to the audio device
+
+extern mempool_t *snd_mempool;
 
-qboolean S_LoadSound (sfx_t *s, qboolean complain);
+// If simsound is true, the sound card is not initialized and no sound is submitted to it.
+// More generally, all arch-dependent operations are skipped or emulated.
+// Used for isolating performance in the renderer.
+extern qboolean simsound;
 
-void S_LockSfx (sfx_t *sfx);
-void S_UnlockSfx (sfx_t *sfx);
 
-void *S_LockBuffer(void);
-void S_UnlockBuffer(void);
+#define STREAM_BUFFERSIZE 16384 // in sampleframes
 
-extern size_t ResampleSfx (const qbyte *in_data, size_t in_length, const snd_format_t* in_format, qbyte *out_data, const char* sfxname);
 
 // ====================================================================
+//         Architecture-independent functions
+// ====================================================================
 
-// 0 to NUM_AMBIENTS - 1 = water, etc
-// NUM_AMBIENTS to NUM_AMBIENTS + MAX_DYNAMIC_CHANNELS - 1 = normal entity sounds
-// NUM_AMBIENTS + MAX_DYNAMIC_CHANNELS to total_channels = static sounds
-#define        MAX_CHANNELS                    516
-#define        MAX_DYNAMIC_CHANNELS    128
+void S_MixToBuffer(void *stream, unsigned int frames);
 
-extern channel_t channels[MAX_CHANNELS];
+qboolean S_LoadSound (sfx_t *sfx, qboolean complain);
 
-extern unsigned int total_channels;
+snd_buffer_t *Snd_CreateSndBuffer (const unsigned char *samples, unsigned int sampleframes, const snd_format_t* in_format, unsigned int sb_speed);
+qboolean Snd_AppendToSndBuffer (snd_buffer_t* sb, const unsigned char *samples, unsigned int sampleframes, const snd_format_t* format);
 
-extern int paintedtime;
-extern int soundtime;
-extern volatile dma_t *shm;
+// If "buffer" is NULL, the function allocates one buffer of "sampleframes" sample frames itself
+// (if "sampleframes" is 0, the function chooses the size).
+snd_ringbuffer_t *Snd_CreateRingBuffer (const snd_format_t* format, unsigned int sampleframes, void* buffer);
 
-extern cvar_t snd_swapstereo;
-extern cvar_t snd_streaming;
 
-extern int snd_blocked;
+// ====================================================================
+//         Architecture-dependent functions
+// ====================================================================
 
-extern mempool_t *snd_mempool;
+// Create "snd_renderbuffer" with the proper sound format if the call is successful
+// May return a suggested format if the requested format isn't available
+qboolean SndSys_Init (const snd_format_t* requested, snd_format_t* suggested);
+
+// Stop the sound card, delete "snd_renderbuffer" and free its other resources
+void SndSys_Shutdown (void);
 
+// Submit the contents of "snd_renderbuffer" to the sound card
+void SndSys_Submit (void);
+
+// Returns the number of sample frames consumed since the sound started
+unsigned int SndSys_GetSoundTime (void);
+
+// Get the exclusive lock on "snd_renderbuffer"
+qboolean SndSys_LockRenderBuffer (void);
+
+// Release the exclusive lock on "snd_renderbuffer"
+void SndSys_UnlockRenderBuffer (void);
+
+// if the sound system can generate events, send them
+void SndSys_SendKeyEvents(void);
+
+// exported for capturevideo so ogg can see all channels
+typedef struct portable_samplepair_s
+{
+       float sample[SND_LISTENERS];
+} portable_sampleframe_t;
+
+typedef struct listener_s
+{
+       int channel_unswapped; // for un-swapping
+       float yawangle;
+       float dotscale;
+       float dotbias;
+       float ambientvolume;
+}
+listener_t;
+typedef struct speakerlayout_s
+{
+       const char *name;
+       unsigned int channels;
+       listener_t listeners[SND_LISTENERS];
+}
+speakerlayout_t;
 
 #endif