snd_main.h

Go to the documentation of this file.

/*
Copyright (C) 1996-1997 Id Software, Inc.
 
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
 
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
See the GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
*/
 
#ifndef SND_MAIN_H
#define SND_MAIN_H
 
#include <stddef.h>
#include "qtypes.h"
#include "qdefs.h"
struct mempool_s;
struct sfx_s;
 
typedef struct snd_format_s
{
    unsigned int    speed;
    unsigned short  width;
    unsigned short  channels;
} snd_format_t;
typedef struct snd_format_s {…};
 
typedef struct snd_buffer_s
{
    snd_format_t    format;
    unsigned int    nbframes;   
    unsigned int    maxframes;  
    unsigned char   samples[4]; 
} snd_buffer_t;
typedef struct snd_buffer_s {…};
 
typedef struct snd_ringbuffer_s
{
    snd_format_t    format;
    unsigned char  *ring;
    unsigned int    maxframes; 
    unsigned int    startframe;
    unsigned int    endframe;
} snd_ringbuffer_t;
typedef struct snd_ringbuffer_s {…};
 
// struct sfx_s flags
#define SFXFLAG_NONE         0
#define SFXFLAG_FILEMISSING  (1 << 0) 
#define SFXFLAG_LEVELSOUND   (1 << 1) 
#define SFXFLAG_STREAMED     (1 << 2) 
#define SFXFLAG_MENUSOUND    (1 << 3) 
 
typedef struct snd_fetcher_s snd_fetcher_t;
struct sfx_s
{
    char                  name[MAX_QPATH];
    struct sfx_s         *next;
    size_t                memsize;         
 
    snd_format_t          format;          
    unsigned int          flags;           
    unsigned int          loopstart;       
    unsigned int          total_length;    
    const snd_fetcher_t  *fetcher;
    void                 *fetcher_data;    
 
    float                 volume_mult;     
    float                 volume_peak;     
};
struct sfx_s {…};
 
// maximum supported speakers constant
#define SND_LISTENERS 8
 
typedef struct channel_s
{
    // provided sound information
    struct sfx_s  *sfx;             
    float          basevolume;      
    unsigned int   flags;           
    int            entnum;          
    int            entchannel;      
    vec3_t         origin;          
    vec_t          distfade;        
    void          *fetcher_data;    
    int            prologic_invert; 
    float          basespeed;       
 
    float          mixspeed;
    float          volume[SND_LISTENERS];
 
    double         position;
} channel_t;
typedef struct channel_s {…};
 
// 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, struct sfx_s *sfx, int firstsampleframe, int numsampleframes, float *outsamplesfloat);
typedef void (*snd_fetcher_stopchannel_t) (channel_t *ch);
typedef void (*snd_fetcher_freesfx_t) (struct sfx_s *sfx);
struct snd_fetcher_s
{
    snd_fetcher_getsamplesfloat_t  getsamplesfloat;
    snd_fetcher_stopchannel_t      stopchannel;
    snd_fetcher_freesfx_t          freesfx;
};
struct snd_fetcher_s {…};
 
extern unsigned int total_channels;
extern channel_t channels[MAX_CHANNELS];
 
extern snd_ringbuffer_t *snd_renderbuffer;
extern qbool snd_threaded; 
extern qbool snd_usethreadedmixing; 
 
extern cvar_t snd_waterfx;
extern cvar_t snd_streaming;
extern cvar_t snd_streaming_length;
 
#define SND_CHANNELLAYOUT_AUTO     0
#define SND_CHANNELLAYOUT_STANDARD 1
#define SND_CHANNELLAYOUT_ALSA     2
extern cvar_t snd_channellayout;
 
extern bool snd_blocked; 
 
extern struct mempool_s *snd_mempool;
 
extern qbool simsound;
 
extern cvar_t snd_bufferlength;
 
#define STREAM_BUFFERSIZE 16384 
 
 
// ====================================================================
//         Architecture-independent functions
// ====================================================================
 
void S_SetUnderwaterIntensity(void);
 
void S_MixToBuffer(void *stream, unsigned int frames);
 
qbool S_LoadSound (struct sfx_s *sfx, qbool complain);
 
snd_ringbuffer_t *Snd_CreateRingBuffer (const snd_format_t* format, unsigned int sampleframes, void* buffer);
 
 
// ====================================================================
//         Architecture-dependent functions
// ====================================================================
 
qbool SndSys_Init (snd_format_t* fmt);
 
void SndSys_Shutdown (void);
 
void SndSys_Submit (void);
 
unsigned int SndSys_GetSoundTime (void);
 
qbool SndSys_LockRenderBuffer (void);
 
void SndSys_UnlockRenderBuffer (void);
 
void SndSys_SendKeyEvents(void);
 
typedef struct portable_samplepair_s
{
    float sample[SND_LISTENERS];
} portable_sampleframe_t;
typedef struct portable_samplepair_s {…};
 
typedef struct listener_s
{
    int channel_unswapped; 
    float yawangle;
    float dotscale;
    float dotbias;
    float ambientvolume;
}
typedef struct listener_s {…};
listener_t;
typedef struct speakerlayout_s
{
    const char *name;
    unsigned int channels;
    listener_t listeners[SND_LISTENERS];
}
typedef struct speakerlayout_s {…};
speakerlayout_t;
 
#endif