#include "darkplaces.h"
#include "snd_main.h"
#include "snd_wav.h"
#include "sound.h"

Include dependency graph for snd_wav.c:

Data Structures
struct	wavinfo_t

Functions
static void	FindChunk (const char *name)

static void	FindNextChunk (const char *name)

static int	GetLittleLong (void)

static short	GetLittleShort (void)

static wavinfo_t	GetWavinfo (char name, unsigned char wav, int wavlength)

qbool	S_LoadWavFile (const char filename, sfx_t sfx)

static void	WAV_FreeSfx (sfx_t *sfx)

static void	WAV_GetSamplesFloat (channel_t ch, sfx_t sfx, int firstsampleframe, int numsampleframes, float *outsamplesfloat)

Variables
static unsigned char *	data_p

static int	iff_chunk_len

static unsigned char *	iff_data

static unsigned char *	iff_end

static unsigned char *	last_chunk

const snd_fetcher_t	wav_fetcher = { WAV_GetSamplesFloat, NULL, WAV_FreeSfx }

Function Documentation

◆ FindChunk()

static void FindChunk ( const char * name )

static

Definition at line 100 of file snd_wav.c.

{
    last_chunk = iff_data;
    FindNextChunk (name);
}

References FindNextChunk(), iff_data, last_chunk, and name.

Referenced by GetWavinfo().

◆ FindNextChunk()

static void FindNextChunk ( const char * name )

static

Definition at line 68 of file snd_wav.c.

{
    while (1)
    {
        data_p=last_chunk;
 
        if (data_p >= iff_end)
        {   // didn't find the chunk
            data_p = NULL;
            return;
        }
 
        data_p += 4;
        iff_chunk_len = GetLittleLong();
        if (iff_chunk_len < 0)
        {
            data_p = NULL;
            return;
        }
        if (data_p + iff_chunk_len > iff_end)
        {
            // truncated chunk!
            data_p = NULL;
            return;
        }
        data_p -= 8;
        last_chunk = data_p + 8 + ( (iff_chunk_len + 1) & ~1 );
        if (!strncmp((const char *)data_p, name, 4))
            return;
    }
}

References data_p, GetLittleLong(), iff_chunk_len, iff_end, last_chunk, name, and NULL.

Referenced by FindChunk(), and GetWavinfo().

◆ GetLittleLong()

static int GetLittleLong ( void )

static

Definition at line 58 of file snd_wav.c.

{
    int val = 0;
 
    val = BuffLittleLong (data_p);
    data_p += 4;
 
    return val;
}

References BuffLittleLong(), and data_p.

Referenced by FindNextChunk(), and GetWavinfo().

◆ GetLittleShort()

static short GetLittleShort ( void )

static

Definition at line 48 of file snd_wav.c.

{
    short val;
 
    val = BuffLittleShort (data_p);
    data_p += 2;
 
    return val;
}

References BuffLittleShort(), and data_p.

Referenced by GetWavinfo().

◆ GetWavinfo()

static wavinfo_t GetWavinfo	(	char *	name,
		unsigned char *	wav,
		int	wavlength )

static

Definition at line 131 of file snd_wav.c.

{
    wavinfo_t info;
    int i;
    int format;
    int samples;
 
    memset (&info, 0, sizeof(info));
 
    if (!wav)
        return info;
 
    iff_data = wav;
    iff_end = wav + wavlength;
 
    // find "RIFF" chunk
    FindChunk("RIFF");
    if (!(data_p && !strncmp((const char *)data_p+8, "WAVE", 4)))
    {
        Con_Print("Missing RIFF/WAVE chunks\n");
        return info;
    }
 
    // get "fmt " chunk
    iff_data = data_p + 12;
    //DumpChunks ();
 
    FindChunk("fmt ");
    if (!data_p)
    {
        Con_Print("Missing fmt chunk\n");
        return info;
    }
    data_p += 8;
    format = GetLittleShort();
    if (format != 1)
    {
        Con_Print("Microsoft PCM format only\n");
        return info;
    }
 
    info.channels = GetLittleShort();
    info.rate = GetLittleLong();
    data_p += 4+2;
    info.width = GetLittleShort() / 8;
 
    // get cue chunk
    FindChunk("cue ");
    if (data_p)
    {
        data_p += 32;
        info.loopstart = GetLittleLong();
 
        // if the next chunk is a LIST chunk, look for a cue length marker
        FindNextChunk ("LIST");
        if (data_p)
        {
            if (!strncmp ((const char *)data_p + 28, "mark", 4))
            {   // this is not a proper parse, but it works with cooledit...
                data_p += 24;
                i = GetLittleLong ();   // samples in loop
                info.samples = info.loopstart + i;
            }
        }
    }
    else
        info.loopstart = -1;
 
    // find data chunk
    FindChunk("data");
    if (!data_p)
    {
        Con_Print("Missing data chunk\n");
        return info;
    }
 
    data_p += 4;
    samples = GetLittleLong () / info.width / info.channels;
 
    if (info.samples)
    {
        if (samples < info.samples)
        {
            Con_Printf ("Sound %s has a bad loop length\n", name);
            info.samples = samples;
        }
    }
    else
        info.samples = samples;
 
    info.dataofs = data_p - wav;
 
    return info;
}

References wavinfo_t::channels, Con_Print(), Con_Printf(), data_p, wavinfo_t::dataofs, FindChunk(), FindNextChunk(), format, GetLittleLong(), GetLittleShort(), i, iff_data, iff_end, wavinfo_t::loopstart, name, wavinfo_t::rate, samples, wavinfo_t::samples, and wavinfo_t::width.

Referenced by S_LoadWavFile().

◆ S_LoadWavFile()

qbool S_LoadWavFile	(	const char *	filename,
		sfx_t *	sfx )

Definition at line 268 of file snd_wav.c.

{
    fs_offset_t filesize;
    unsigned char *data;
    wavinfo_t info;
    int i, len;
    const unsigned char *inb;
    unsigned char *outb;
 
    // Already loaded?
    if (sfx->fetcher != NULL)
        return true;
 
    // Load the file
    data = FS_LoadFile(filename, snd_mempool, false, &filesize);
    if (!data)
        return false;
 
    // Don't try to load it if it's not a WAV file
    if (memcmp (data, "RIFF", 4) || memcmp (data + 8, "WAVE", 4))
    {
        Mem_Free(data);
        return false;
    }
 
    if (developer_loading.integer >= 2)
        Con_Printf ("Loading WAV file \"%s\"\n", filename);
 
    info = GetWavinfo (sfx->name, data, (int)filesize);
    if (info.channels < 1 || info.channels > 2)  // Stereo sounds are allowed (intended for music)
    {
        Con_Printf("%s has an unsupported number of channels (%i)\n",sfx->name, info.channels);
        Mem_Free(data);
        return false;
    }
    //if (info.channels == 2)
    //  Log_Printf("stereosounds.log", "%s\n", sfx->name);
 
    sfx->format.speed = info.rate;
    sfx->format.width = info.width;
    sfx->format.channels = info.channels;
    sfx->fetcher = &wav_fetcher;
    sfx->fetcher_data = Mem_Alloc(snd_mempool, info.samples * sfx->format.width * sfx->format.channels);
    sfx->total_length = info.samples;
    sfx->memsize += filesize;
    len = info.samples * sfx->format.channels * sfx->format.width;
    inb = data + info.dataofs;
    outb = (unsigned char *)sfx->fetcher_data;
    if (info.width == 2)
    {
        if (mem_bigendian)
        {
            // we have to byteswap the data at load (better than doing it while mixing)
            for (i = 0;i < len;i += 2)
            {
                outb[i] = inb[i+1];
                outb[i+1] = inb[i];
            }
        }
        else
        {
            // we can just copy it straight
            memcpy(outb, inb, len);
        }
    }
    else
    {
        // convert unsigned byte sound data to signed bytes for quicker mixing
        for (i = 0;i < len;i++)
            outb[i] = inb[i] - 0x80;
    }
 
    if (info.loopstart < 0)
        sfx->loopstart = sfx->total_length;
    else
        sfx->loopstart = info.loopstart;
    sfx->loopstart = min(sfx->loopstart, sfx->total_length);
    sfx->flags &= ~SFXFLAG_STREAMED;
 
    Mem_Free(data); // we already got a copy of this in fetcher_data
    return true;
}

References wavinfo_t::channels, Con_Printf(), data, wavinfo_t::dataofs, developer_loading, FS_LoadFile(), GetWavinfo(), i, cvar_t::integer, wavinfo_t::loopstart, Mem_Alloc, mem_bigendian, Mem_Free, min, NULL, wavinfo_t::rate, wavinfo_t::samples, snd_mempool, wav_fetcher, and wavinfo_t::width.

Referenced by S_LoadSound().

◆ WAV_FreeSfx()

static void WAV_FreeSfx ( sfx_t * sfx )

static

Definition at line 254 of file snd_wav.c.

{
    // free the loaded sound data
    Mem_Free(sfx->fetcher_data);
}

References Mem_Free.

◆ WAV_GetSamplesFloat()

static void WAV_GetSamplesFloat	(	channel_t *	ch,
		sfx_t *	sfx,
		int	firstsampleframe,
		int	numsampleframes,
		float *	outsamplesfloat )

static

Definition at line 232 of file snd_wav.c.

{
    int i, len = numsampleframes * sfx->format.channels;
    if (sfx->format.width == 2)
    {
        const short *bufs = (const short *)sfx->fetcher_data + firstsampleframe * sfx->format.channels;
        for (i = 0;i < len;i++)
            outsamplesfloat[i] = bufs[i] * (1.0f / 32768.0f);
    }
    else
    {
        const signed char *bufb = (const signed char *)sfx->fetcher_data + firstsampleframe * sfx->format.channels;
        for (i = 0;i < len;i++)
            outsamplesfloat[i] = bufb[i] * (1.0f / 128.0f);
    }
}