mirror of
https://github.com/nzp-team/fteqw.git
synced 2024-11-22 20:11:44 +00:00
8dadfb4878
Cmake: Add FTE_WERROR option, defaults to true in debug builds and off in release builds (in case future compilers have issues).
Cmake: Pull in libXscreensaver so we don't get interrupted by screensavers when playing demos.
Make: Added `make webcl-rel` for a web build without server bloat (eg for sites focused on demo playback. Yes, this means you XantoM).
fteqcc: Include the decompiler in fteqcc (non-gui) builds ('-d' arg).
fteqcc: Decompiler can now mostly handle hexen2 mods without any unknown opcodes.
Allow ezHud and OpenSSL to be compiled as in-engine plugins, potentially for web and windows ports respectively.
Web: Fix support for ogg vorbis. Add support for voip.
Web: Added basic support for WebXR.
QTV: Don't try seeking on unseekable qtv streams. Don't spam when developer 1 is set.
QTV: add support for some eztv extensions.
MVD: added hack to use ktx's vweps in mvd where mvdsv doesn't bother to record the info.
qwfwd: hack around a hack in qwfwd, allowing it to work again.
recording: favour qwd in single player, instead of mvd.
Protocol: reduce client memory used for precache names. Bump maximum precache counts - some people are just abusive, yes you Orl.
hexen2: add enough clientside protocol compat to play the demo included with h2mp. lacks effects.
in_xflip: restored this setting.
fs_hidesyspaths: new cvar, defaults to enabled so you won't find your username or whatever turning up in screenshots or the like. change it to 0 before debuging stuff eg via 'path'.
gl_overbright_models: Added cvar to match QS.
netchan: Added MTU determination, we'll no longer fail to connect when routers stupidly drop icmp packets.
Win: try a few other versions of xinput too.
CSQC: Added a CSQC_GenerateMaterial function, to give the csqc a chance to generate custom materials.
MenuQC: Added support for the skeletal objects API.
1311 lines
32 KiB
C
1311 lines
32 KiB
C
/*
|
|
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.
|
|
|
|
*/
|
|
// snd_mem.c: sound caching
|
|
|
|
#include "quakedef.h"
|
|
|
|
#include "winquake.h"
|
|
#include "fs.h"
|
|
|
|
typedef struct
|
|
{
|
|
int format;
|
|
int rate;
|
|
int bitwidth;
|
|
int numchannels;
|
|
int loopstart;
|
|
int samples;
|
|
int dataofs; // chunk starts this many bytes from file start
|
|
} wavinfo_t;
|
|
|
|
static wavinfo_t GetWavinfo (char *name, qbyte *wav, int wavlength);
|
|
|
|
#define LINEARUPSCALE(in, inrate, insamps, out, outrate, outlshift, outrshift) \
|
|
{ \
|
|
scale = inrate / (double)outrate; \
|
|
infrac = floor(scale * 65536); \
|
|
outsamps = insamps / scale; \
|
|
inaccum = 0; \
|
|
outnlsamps = floor(1.0 / scale); \
|
|
outsamps -= outnlsamps; \
|
|
\
|
|
while (outsamps) \
|
|
{ \
|
|
*out = ((0xFFFF - inaccum)*in[0] + inaccum*in[1]) >> (16 - outlshift + outrshift); \
|
|
inaccum += infrac; \
|
|
in += (inaccum >> 16); \
|
|
inaccum &= 0xFFFF; \
|
|
out++; \
|
|
outsamps--; \
|
|
} \
|
|
while (outnlsamps) \
|
|
{ \
|
|
*out = (*in >> outrshift) << outlshift; \
|
|
out++; \
|
|
outnlsamps--; \
|
|
} \
|
|
}
|
|
|
|
#define LINEARUPSCALESTEREO(in, inrate, insamps, out, outrate, outlshift, outrshift) \
|
|
{ \
|
|
scale = inrate / (double)outrate; \
|
|
infrac = floor(scale * 65536); \
|
|
outsamps = insamps / scale; \
|
|
inaccum = 0; \
|
|
outnlsamps = floor(1.0 / scale); \
|
|
outsamps -= outnlsamps; \
|
|
\
|
|
while (outsamps) \
|
|
{ \
|
|
out[0] = ((0xFFFF - inaccum)*in[0] + inaccum*in[2]) >> (16 - outlshift + outrshift); \
|
|
out[1] = ((0xFFFF - inaccum)*in[1] + inaccum*in[3]) >> (16 - outlshift + outrshift); \
|
|
inaccum += infrac; \
|
|
in += (inaccum >> 16) * 2; \
|
|
inaccum &= 0xFFFF; \
|
|
out += 2; \
|
|
outsamps--; \
|
|
} \
|
|
while (outnlsamps) \
|
|
{ \
|
|
out[0] = (in[0] >> outrshift) << outlshift; \
|
|
out[1] = (in[1] >> outrshift) << outlshift; \
|
|
out += 2; \
|
|
outnlsamps--; \
|
|
} \
|
|
}
|
|
|
|
#define LINEARUPSCALESTEREOTOMONO(in, inrate, insamps, out, outrate, outlshift, outrshift) \
|
|
{ \
|
|
scale = inrate / (double)outrate; \
|
|
infrac = floor(scale * 65536); \
|
|
outsamps = insamps / scale; \
|
|
inaccum = 0; \
|
|
outnlsamps = floor(1.0 / scale); \
|
|
outsamps -= outnlsamps; \
|
|
\
|
|
while (outsamps) \
|
|
{ \
|
|
*out = ((((0xFFFF - inaccum)*in[0] + inaccum*in[2]) >> (16 - outlshift + outrshift)) + \
|
|
(((0xFFFF - inaccum)*in[1] + inaccum*in[3]) >> (16 - outlshift + outrshift))) >> 1; \
|
|
inaccum += infrac; \
|
|
in += (inaccum >> 16) * 2; \
|
|
inaccum &= 0xFFFF; \
|
|
out++; \
|
|
outsamps--; \
|
|
} \
|
|
while (outnlsamps) \
|
|
{ \
|
|
out[0] = (((in[0] >> outrshift) << outlshift) + ((in[1] >> outrshift) << outlshift)) >> 1; \
|
|
out++; \
|
|
outnlsamps--; \
|
|
} \
|
|
}
|
|
|
|
#define LINEARDOWNSCALE(in, inrate, insamps, out, outrate, outlshift, outrshift) \
|
|
{ \
|
|
scale = outrate / (double)inrate; \
|
|
infrac = floor(scale * 65536); \
|
|
inaccum = 0; \
|
|
insamps--; \
|
|
outsampleft = 0; \
|
|
\
|
|
while (insamps) \
|
|
{ \
|
|
inaccum += infrac; \
|
|
if (inaccum >> 16) \
|
|
{ \
|
|
inaccum &= 0xFFFF; \
|
|
outsampleft += (infrac - inaccum) * (*in); \
|
|
*out = outsampleft >> (16 - outlshift + outrshift); \
|
|
out++; \
|
|
outsampleft = inaccum * (*in); \
|
|
} \
|
|
else \
|
|
outsampleft += infrac * (*in); \
|
|
in++; \
|
|
insamps--; \
|
|
} \
|
|
outsampleft += (0xFFFF - inaccum) * (*in);\
|
|
*out = outsampleft >> (16 - outlshift + outrshift); \
|
|
}
|
|
|
|
#define LINEARDOWNSCALESTEREO(in, inrate, insamps, out, outrate, outlshift, outrshift) \
|
|
{ \
|
|
scale = outrate / (double)inrate; \
|
|
infrac = floor(scale * 65536); \
|
|
inaccum = 0; \
|
|
insamps--; \
|
|
outsampleft = 0; \
|
|
outsampright = 0; \
|
|
\
|
|
while (insamps) \
|
|
{ \
|
|
inaccum += infrac; \
|
|
if (inaccum >> 16) \
|
|
{ \
|
|
inaccum &= 0xFFFF; \
|
|
outsampleft += (infrac - inaccum) * in[0]; \
|
|
outsampright += (infrac - inaccum) * in[1]; \
|
|
out[0] = outsampleft >> (16 - outlshift + outrshift); \
|
|
out[1] = outsampright >> (16 - outlshift + outrshift); \
|
|
out += 2; \
|
|
outsampleft = inaccum * in[0]; \
|
|
outsampright = inaccum * in[1]; \
|
|
} \
|
|
else \
|
|
{ \
|
|
outsampleft += infrac * in[0]; \
|
|
outsampright += infrac * in[1]; \
|
|
} \
|
|
in += 2; \
|
|
insamps--; \
|
|
} \
|
|
outsampleft += (0xFFFF - inaccum) * in[0];\
|
|
outsampright += (0xFFFF - inaccum) * in[1];\
|
|
out[0] = outsampleft >> (16 - outlshift + outrshift); \
|
|
out[1] = outsampright >> (16 - outlshift + outrshift); \
|
|
}
|
|
|
|
#define LINEARDOWNSCALESTEREOTOMONO(in, inrate, insamps, out, outrate, outlshift, outrshift) \
|
|
{ \
|
|
scale = outrate / (double)inrate; \
|
|
infrac = floor(scale * 65536); \
|
|
inaccum = 0; \
|
|
insamps--; \
|
|
outsampleft = 0; \
|
|
\
|
|
while (insamps) \
|
|
{ \
|
|
inaccum += infrac; \
|
|
if (inaccum >> 16) \
|
|
{ \
|
|
inaccum &= 0xFFFF; \
|
|
outsampleft += (infrac - inaccum) * ((in[0] + in[1]) >> 1); \
|
|
*out = outsampleft >> (16 - outlshift + outrshift); \
|
|
out++; \
|
|
outsampleft = inaccum * ((in[0] + in[1]) >> 1); \
|
|
} \
|
|
else \
|
|
outsampleft += infrac * ((in[0] + in[1]) >> 1); \
|
|
in += 2; \
|
|
insamps--; \
|
|
} \
|
|
outsampleft += (0xFFFF - inaccum) * ((in[0] + in[1]) >> 1);\
|
|
*out = outsampleft >> (16 - outlshift + outrshift); \
|
|
}
|
|
|
|
#define STANDARDRESCALE(in, inrate, insamps, out, outrate, outlshift, outrshift) \
|
|
{ \
|
|
scale = inrate / (double)outrate; \
|
|
infrac = floor(scale * 65536); \
|
|
outsamps = insamps / scale; \
|
|
inaccum = 0; \
|
|
\
|
|
while (outsamps) \
|
|
{ \
|
|
*out = (*in >> outrshift) << outlshift; \
|
|
inaccum += infrac; \
|
|
in += (inaccum >> 16); \
|
|
inaccum &= 0xFFFF; \
|
|
out++; \
|
|
outsamps--; \
|
|
} \
|
|
}
|
|
|
|
#define STANDARDRESCALESTEREO(in, inrate, insamps, out, outrate, outlshift, outrshift) \
|
|
{ \
|
|
scale = inrate / (double)outrate; \
|
|
infrac = floor(scale * 65536); \
|
|
outsamps = insamps / scale; \
|
|
inaccum = 0; \
|
|
\
|
|
while (outsamps) \
|
|
{ \
|
|
out[0] = (in[0] >> outrshift) << outlshift; \
|
|
out[1] = (in[1] >> outrshift) << outlshift; \
|
|
inaccum += infrac; \
|
|
in += (inaccum >> 16) * 2; \
|
|
inaccum &= 0xFFFF; \
|
|
out += 2; \
|
|
outsamps--; \
|
|
} \
|
|
}
|
|
|
|
#define STANDARDRESCALESTEREOTOMONO(in, inrate, insamps, out, outrate, outlshift, outrshift) \
|
|
{ \
|
|
scale = inrate / (double)outrate; \
|
|
infrac = floor(scale * 65536); \
|
|
outsamps = insamps / scale; \
|
|
inaccum = 0; \
|
|
\
|
|
while (outsamps) \
|
|
{ \
|
|
out[0] = (((in[0] >> outrshift) << outlshift) + ((in[1] >> outrshift) << outlshift)) >> 1; \
|
|
inaccum += infrac; \
|
|
in += (inaccum >> 16) * 2; \
|
|
inaccum &= 0xFFFF; \
|
|
out++; \
|
|
outsamps--; \
|
|
} \
|
|
}
|
|
|
|
#define QUICKCONVERT(in, insamps, out, outlshift, outrshift) \
|
|
{ \
|
|
while (insamps) \
|
|
{ \
|
|
*out = (*in >> outrshift) << outlshift; \
|
|
out++; \
|
|
in++; \
|
|
insamps--; \
|
|
} \
|
|
}
|
|
|
|
#define QUICKCONVERTSTEREOTOMONO(in, insamps, out, outlshift, outrshift) \
|
|
{ \
|
|
while (insamps) \
|
|
{ \
|
|
*out = (((in[0] >> outrshift) << outlshift) + ((in[1] >> outrshift) << outlshift)) >> 1; \
|
|
out++; \
|
|
in += 2; \
|
|
insamps--; \
|
|
} \
|
|
}
|
|
|
|
// SND_ResampleStream: takes a sound stream and converts with given parameters. Limited to
|
|
// 8-16-bit signed conversions and mono-to-mono/stereo-to-stereo conversions.
|
|
// Not an in-place algorithm.
|
|
void SND_ResampleStream (void *in, int inrate, qaudiofmt_t informat, int inchannels, int insamps, void *out, int outrate, qaudiofmt_t outformat, int outchannels, int resampstyle)
|
|
{
|
|
double scale;
|
|
signed char *in8 = (signed char *)in;
|
|
short *in16 = (short *)in;
|
|
signed char *out8 = (signed char *)out;
|
|
short *out16 = (short *)out;
|
|
int outsamps, outnlsamps, outsampleft, outsampright;
|
|
int infrac, inaccum;
|
|
|
|
if (insamps <= 0)
|
|
return;
|
|
|
|
if (inchannels == outchannels && informat == outformat && inrate == outrate)
|
|
{
|
|
memcpy(out, in, informat*insamps*inchannels);
|
|
return;
|
|
}
|
|
|
|
if (inchannels == 1 && outchannels == 1)
|
|
{
|
|
if (informat == QAF_S8)
|
|
{
|
|
if (outformat == QAF_S8)
|
|
{
|
|
if (inrate < outrate) // upsample
|
|
{
|
|
if (resampstyle)
|
|
LINEARUPSCALE(in8, inrate, insamps, out8, outrate, 0, 0)
|
|
else
|
|
STANDARDRESCALE(in8, inrate, insamps, out8, outrate, 0, 0)
|
|
}
|
|
else // downsample
|
|
{
|
|
if (resampstyle > 1)
|
|
LINEARDOWNSCALE(in8, inrate, insamps, out8, outrate, 0, 0)
|
|
else
|
|
STANDARDRESCALE(in8, inrate, insamps, out8, outrate, 0, 0)
|
|
}
|
|
return;
|
|
}
|
|
else if (outformat == QAF_S16)
|
|
{
|
|
if (inrate == outrate) // quick convert
|
|
QUICKCONVERT(in8, insamps, out16, 8, 0)
|
|
else if (inrate < outrate) // upsample
|
|
{
|
|
if (resampstyle)
|
|
LINEARUPSCALE(in8, inrate, insamps, out16, outrate, 8, 0)
|
|
else
|
|
STANDARDRESCALE(in8, inrate, insamps, out16, outrate, 8, 0)
|
|
}
|
|
else // downsample
|
|
{
|
|
if (resampstyle > 1)
|
|
LINEARDOWNSCALE(in8, inrate, insamps, out16, outrate, 8, 0)
|
|
else
|
|
STANDARDRESCALE(in8, inrate, insamps, out16, outrate, 8, 0)
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
else if (informat == QAF_S16) // 16-bit
|
|
{
|
|
if (outformat == QAF_S16)
|
|
{
|
|
if (inrate < outrate) // upsample
|
|
{
|
|
if (resampstyle)
|
|
LINEARUPSCALE(in16, inrate, insamps, out16, outrate, 0, 0)
|
|
else
|
|
STANDARDRESCALE(in16, inrate, insamps, out16, outrate, 0, 0)
|
|
}
|
|
else // downsample
|
|
{
|
|
if (resampstyle > 1)
|
|
LINEARDOWNSCALE(in16, inrate, insamps, out16, outrate, 0, 0)
|
|
else
|
|
STANDARDRESCALE(in16, inrate, insamps, out16, outrate, 0, 0)
|
|
}
|
|
return;
|
|
}
|
|
else if (outformat == QAF_S8)
|
|
{
|
|
if (inrate == outrate) // quick convert
|
|
QUICKCONVERT(in16, insamps, out8, 0, 8)
|
|
else if (inrate < outrate) // upsample
|
|
{
|
|
if (resampstyle)
|
|
LINEARUPSCALE(in16, inrate, insamps, out8, outrate, 0, 8)
|
|
else
|
|
STANDARDRESCALE(in16, inrate, insamps, out8, outrate, 0, 8)
|
|
}
|
|
else // downsample
|
|
{
|
|
if (resampstyle > 1)
|
|
LINEARDOWNSCALE(in16, inrate, insamps, out8, outrate, 0, 8)
|
|
else
|
|
STANDARDRESCALE(in16, inrate, insamps, out8, outrate, 0, 8)
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
else if (outchannels == 2 && inchannels == 2)
|
|
{
|
|
if (informat == QAF_S8)
|
|
{
|
|
if (outformat == QAF_S8)
|
|
{
|
|
if (inrate < outrate) // upsample
|
|
{
|
|
if (resampstyle)
|
|
LINEARUPSCALESTEREO(in8, inrate, insamps, out8, outrate, 0, 0)
|
|
else
|
|
STANDARDRESCALESTEREO(in8, inrate, insamps, out8, outrate, 0, 0)
|
|
}
|
|
else // downsample
|
|
{
|
|
if (resampstyle > 1)
|
|
LINEARDOWNSCALESTEREO(in8, inrate, insamps, out8, outrate, 0, 0)
|
|
else
|
|
STANDARDRESCALESTEREO(in8, inrate, insamps, out8, outrate, 0, 0)
|
|
}
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
if (inrate == outrate) // quick convert
|
|
{
|
|
insamps *= 2;
|
|
QUICKCONVERT(in8, insamps, out16, 8, 0)
|
|
}
|
|
else if (inrate < outrate) // upsample
|
|
{
|
|
if (resampstyle)
|
|
LINEARUPSCALESTEREO(in8, inrate, insamps, out16, outrate, 8, 0)
|
|
else
|
|
STANDARDRESCALESTEREO(in8, inrate, insamps, out16, outrate, 8, 0)
|
|
}
|
|
else // downsample
|
|
{
|
|
if (resampstyle > 1)
|
|
LINEARDOWNSCALESTEREO(in8, inrate, insamps, out16, outrate, 8, 0)
|
|
else
|
|
STANDARDRESCALESTEREO(in8, inrate, insamps, out16, outrate, 8, 0)
|
|
}
|
|
}
|
|
}
|
|
else if (informat == QAF_S16) // 16-bit
|
|
{
|
|
if (outformat == QAF_S16)
|
|
{
|
|
if (inrate < outrate) // upsample
|
|
{
|
|
if (resampstyle)
|
|
LINEARUPSCALESTEREO(in16, inrate, insamps, out16, outrate, 0, 0)
|
|
else
|
|
STANDARDRESCALESTEREO(in16, inrate, insamps, out16, outrate, 0, 0)
|
|
}
|
|
else // downsample
|
|
{
|
|
if (resampstyle > 1)
|
|
LINEARDOWNSCALESTEREO(in16, inrate, insamps, out16, outrate, 0, 0)
|
|
else
|
|
STANDARDRESCALESTEREO(in16, inrate, insamps, out16, outrate, 0, 0)
|
|
}
|
|
}
|
|
else if (outformat == QAF_S8)
|
|
{
|
|
if (inrate == outrate) // quick convert
|
|
{
|
|
insamps *= 2;
|
|
QUICKCONVERT(in16, insamps, out8, 0, 8)
|
|
}
|
|
else if (inrate < outrate) // upsample
|
|
{
|
|
if (resampstyle)
|
|
LINEARUPSCALESTEREO(in16, inrate, insamps, out8, outrate, 0, 8)
|
|
else
|
|
STANDARDRESCALESTEREO(in16, inrate, insamps, out8, outrate, 0, 8)
|
|
}
|
|
else // downsample
|
|
{
|
|
if (resampstyle > 1)
|
|
LINEARDOWNSCALESTEREO(in16, inrate, insamps, out8, outrate, 0, 8)
|
|
else
|
|
STANDARDRESCALESTEREO(in16, inrate, insamps, out8, outrate, 0, 8)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#if 0
|
|
else if (outchannels == 1 && inchannels == 2)
|
|
{
|
|
if (informat == QAF_S8)
|
|
{
|
|
if (outformat == QAF_S8)
|
|
{
|
|
if (inrate < outrate) // upsample
|
|
{
|
|
if (resampstyle)
|
|
LINEARUPSCALESTEREOTOMONO(in8, inrate, insamps, out8, outrate, 0, 0)
|
|
else
|
|
STANDARDRESCALESTEREOTOMONO(in8, inrate, insamps, out8, outrate, 0, 0)
|
|
}
|
|
else // downsample
|
|
STANDARDRESCALESTEREOTOMONO(in8, inrate, insamps, out8, outrate, 0, 0)
|
|
}
|
|
else if (outformat == QAF_S16)
|
|
{
|
|
if (inrate == outrate) // quick convert
|
|
QUICKCONVERTSTEREOTOMONO(in8, insamps, out16, 8, 0)
|
|
else if (inrate < outrate) // upsample
|
|
{
|
|
if (resampstyle)
|
|
LINEARUPSCALESTEREOTOMONO(in8, inrate, insamps, out16, outrate, 8, 0)
|
|
else
|
|
STANDARDRESCALESTEREOTOMONO(in8, inrate, insamps, out16, outrate, 8, 0)
|
|
}
|
|
else // downsample
|
|
STANDARDRESCALESTEREOTOMONO(in8, inrate, insamps, out16, outrate, 8, 0)
|
|
}
|
|
}
|
|
else if (informat == QAF_S16) // 16-bit
|
|
{
|
|
if (outformat == QAF_S16)
|
|
{
|
|
if (inrate < outrate) // upsample
|
|
{
|
|
if (resampstyle)
|
|
LINEARUPSCALESTEREOTOMONO(in16, inrate, insamps, out16, outrate, 0, 0)
|
|
else
|
|
STANDARDRESCALESTEREOTOMONO(in16, inrate, insamps, out16, outrate, 0, 0)
|
|
}
|
|
else // downsample
|
|
STANDARDRESCALESTEREOTOMONO(in16, inrate, insamps, out16, outrate, 0, 0)
|
|
}
|
|
else if (outformat == QAF_S8)
|
|
{
|
|
if (inrate == outrate) // quick convert
|
|
QUICKCONVERTSTEREOTOMONO(in16, insamps, out8, 0, 8)
|
|
else if (inrate < outrate) // upsample
|
|
{
|
|
if (resampstyle)
|
|
LINEARUPSCALESTEREOTOMONO(in16, inrate, insamps, out8, outrate, 0, 8)
|
|
else
|
|
STANDARDRESCALESTEREOTOMONO(in16, inrate, insamps, out8, outrate, 0, 8)
|
|
}
|
|
else // downsample
|
|
STANDARDRESCALESTEREOTOMONO(in16, inrate, insamps, out8, outrate, 0, 8)
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
================
|
|
ResampleSfx
|
|
================
|
|
*/
|
|
static qboolean ResampleSfx (sfx_t *sfx, int inrate, int inchannels, qaudiofmt_t informat, int insamps, int inloopstart, qbyte *data)
|
|
{
|
|
extern cvar_t snd_linearresample;
|
|
extern cvar_t snd_loadasstereo;
|
|
double scale;
|
|
sfxcache_t *sc;
|
|
int outsamps;
|
|
int len;
|
|
qaudiofmt_t outformat;
|
|
|
|
scale = snd_speed / (double)inrate;
|
|
outsamps = insamps * scale;
|
|
if (snd_loadas8bit.ival < 0)
|
|
outformat = QAF_S16;
|
|
else if (snd_loadas8bit.ival)
|
|
outformat = QAF_S8;
|
|
else
|
|
outformat = informat;
|
|
len = outsamps * QAF_BYTES(outformat) * inchannels;
|
|
|
|
sfx->decoder.buf = sc = BZ_Malloc(sizeof(sfxcache_t) + len);
|
|
if (!sc)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
sc->numchannels = inchannels;
|
|
sc->format = outformat;
|
|
sc->speed = snd_speed;
|
|
sc->length = outsamps;
|
|
sc->soundoffset = 0;
|
|
sc->data = (qbyte*)(sc+1);
|
|
if (inloopstart == -1)
|
|
sfx->loopstart = inloopstart;
|
|
else
|
|
sfx->loopstart = inloopstart * scale;
|
|
|
|
SND_ResampleStream (data,
|
|
inrate,
|
|
informat,
|
|
inchannels,
|
|
insamps,
|
|
sc->data,
|
|
sc->speed,
|
|
sc->format,
|
|
sc->numchannels,
|
|
snd_linearresample.ival);
|
|
|
|
if (inchannels == 1 && snd_loadasstereo.ival)
|
|
{ //I'm implementing this to work around what looks like a firefox bug, where mono buffers don't get played (but stereo works just fine despite all the spacialisation issues associated with that).
|
|
sfxcache_t *nc = sfx->decoder.buf = BZ_Malloc(sizeof(sfxcache_t) + len*2);
|
|
*nc = *sc;
|
|
nc->data = (qbyte*)(nc+1);
|
|
SND_ResampleStream (sc->data,
|
|
sc->speed,
|
|
sc->format,
|
|
sc->numchannels,
|
|
outsamps,
|
|
nc->data,
|
|
nc->speed*2,
|
|
nc->format,
|
|
nc->numchannels,
|
|
false);
|
|
nc->numchannels *= 2;
|
|
BZ_Free(sc);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//=============================================================================
|
|
#ifdef PACKAGE_DOOMWAD
|
|
#define DSPK_RATE 140
|
|
#define DSPK_BASE 170.0
|
|
#define DSPK_EXP 0.0433
|
|
|
|
/*
|
|
qboolean QDECL S_LoadDoomSpeakerSound (sfx_t *s, qbyte *data, size_t datalen, int sndspeed, qboolean forcedecode)
|
|
{
|
|
sfxcache_t *sc;
|
|
|
|
// format data from Unofficial Doom Specs v1.6
|
|
unsigned short *dataus;
|
|
int samples, len, inrate, inaccum;
|
|
qbyte *outdata;
|
|
qbyte towrite;
|
|
double timeraccum, timerfreq;
|
|
|
|
if (datalen < 4)
|
|
return NULL;
|
|
|
|
dataus = (unsigned short*)data;
|
|
|
|
if (LittleShort(dataus[0]) != 0)
|
|
return NULL;
|
|
|
|
samples = LittleShort(dataus[1]);
|
|
|
|
data += 4;
|
|
datalen -= 4;
|
|
|
|
if (datalen != samples)
|
|
return NULL;
|
|
|
|
len = (int)((double)samples * (double)snd_speed / DSPK_RATE);
|
|
|
|
sc = Cache_Alloc (&s->cache, len + sizeof(sfxcache_t), s->name);
|
|
if (!sc)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
sc->length = len;
|
|
s->loopstart = -1;
|
|
sc->numchannels = 1;
|
|
sc->width = 1;
|
|
sc->speed = snd_speed;
|
|
|
|
timeraccum = 0;
|
|
outdata = sc->data;
|
|
towrite = 0x40;
|
|
inrate = (int)((double)snd_speed / DSPK_RATE);
|
|
inaccum = inrate;
|
|
if (*data)
|
|
timerfreq = DSPK_BASE * pow((double)2.0, DSPK_EXP * (*data));
|
|
else
|
|
timerfreq = 0;
|
|
|
|
while (len > 0)
|
|
{
|
|
timeraccum += timerfreq;
|
|
if (timeraccum > (float)snd_speed)
|
|
{
|
|
towrite ^= 0xFF; // swap speaker component
|
|
timeraccum -= (float)snd_speed;
|
|
}
|
|
|
|
inaccum--;
|
|
if (!inaccum)
|
|
{
|
|
data++;
|
|
if (*data)
|
|
timerfreq = DSPK_BASE * pow((double)2.0, DSPK_EXP * (*data));
|
|
inaccum = inrate;
|
|
}
|
|
*outdata = towrite;
|
|
outdata++;
|
|
len--;
|
|
}
|
|
|
|
return sc;
|
|
}
|
|
*/
|
|
static qboolean QDECL S_LoadDoomSound (sfx_t *s, qbyte *data, size_t datalen, int sndspeed, qboolean forcedecode)
|
|
{
|
|
// format data from Unofficial Doom Specs v1.6
|
|
unsigned short *dataus;
|
|
int samples, rate;
|
|
|
|
if (datalen < 8)
|
|
return false;
|
|
|
|
dataus = (unsigned short*)data;
|
|
|
|
if (LittleShort(dataus[0]) != 3)
|
|
return false;
|
|
|
|
rate = LittleShort(dataus[1]);
|
|
samples = LittleShort(dataus[2]);
|
|
|
|
data += 8;
|
|
datalen -= 8;
|
|
|
|
if (datalen != samples)
|
|
return false;
|
|
|
|
COM_CharBias(data, datalen);
|
|
|
|
return ResampleSfx (s, rate, 1, 1, samples, -1, data);
|
|
}
|
|
#endif
|
|
|
|
static qboolean QDECL S_LoadWavSound (sfx_t *s, qbyte *data, size_t datalen, int sndspeed, qboolean forcedecode)
|
|
{
|
|
wavinfo_t info;
|
|
qaudiofmt_t format;
|
|
|
|
if (datalen < 4 || strncmp(data, "RIFF", 4))
|
|
return false;
|
|
|
|
info = GetWavinfo (s->name, data, datalen);
|
|
if (info.numchannels < 1 || info.numchannels > 2)
|
|
{
|
|
s->loadstate = SLS_FAILED;
|
|
Con_Printf ("%s has an unsupported quantity of channels.\n",s->name);
|
|
return false;
|
|
}
|
|
|
|
if (info.format == 1 && info.bitwidth == 8) //unsigned bytes
|
|
{
|
|
COM_CharBias(data + info.dataofs, info.samples*info.numchannels);
|
|
format = QAF_S8;
|
|
}
|
|
else if (info.format == 1 && info.bitwidth == 16) //signed shorts
|
|
{
|
|
COM_SwapLittleShortBlock((short *)(data + info.dataofs), info.samples*info.numchannels);
|
|
format = QAF_S16;
|
|
}
|
|
else if (info.format == 1 && info.bitwidth == 32) //24 or 32bit int audio
|
|
{
|
|
short *out = (short *)(data + info.dataofs);
|
|
int *in = (int *)(data + info.dataofs);
|
|
size_t samples = info.samples*info.numchannels;
|
|
while(samples --> 0)
|
|
{ //in place size conversion, so we need to do it forwards.
|
|
*out++ = LittleLong(*in++)>>16; //just drop the least significant bits.
|
|
}
|
|
format = QAF_S16;
|
|
}
|
|
#ifdef MIXER_F32
|
|
else if (info.format == 3 && info.bitwidth == 32) //signed floats
|
|
{
|
|
if (bigendian)
|
|
{
|
|
size_t i = info.samples*info.numchannels;
|
|
float *ptr = (float*)(data + info.dataofs);
|
|
while(i --> 0)
|
|
ptr[i] = LittleFloat(ptr[i]);
|
|
}
|
|
format = QAF_F32;
|
|
}
|
|
#else
|
|
else if (info.format == 3 && info.bitwidth == 32) //signed floats
|
|
{
|
|
short *out = (short *)(data + info.dataofs);
|
|
float *in = (float *)(data + info.dataofs);
|
|
size_t samples = info.samples*info.numchannels;
|
|
int t;
|
|
while(samples --> 0)
|
|
{ //in place size conversion, so we need to do it forwards.
|
|
t = LittleFloat(*in++) * 32767;
|
|
t = bound(-32768, t, 32767);
|
|
*out++ = t;
|
|
}
|
|
format = QAF_S16;
|
|
}
|
|
#endif
|
|
else
|
|
{
|
|
s->loadstate = SLS_FAILED;
|
|
switch(info.format)
|
|
{
|
|
case 1/*WAVE_FORMAT_PCM*/:
|
|
case 3/*WAVE_FORMAT_IEEE_FLOAT*/: Con_Printf ("%s has an unsupported width (%i bits).\n", s->name, info.bitwidth); break;
|
|
case 6/*WAVE_FORMAT_ALAW*/: Con_Printf ("%s uses unsupported a-law format.\n", s->name); break;
|
|
case 7/*WAVE_FORMAT_MULAW*/: Con_Printf ("%s uses unsupported mu-law format.\n", s->name); break;
|
|
case 0xfffe/*WAVE_FORMAT_EXTENSIBLE*/:
|
|
default: Con_Printf ("%s has an unsupported format (%#x).\n", s->name, info.format); break;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
return ResampleSfx (s, info.rate, info.numchannels, format, info.samples, info.loopstart, data + info.dataofs);
|
|
}
|
|
|
|
#ifdef FTE_TARGET_WEB
|
|
#if 1
|
|
void S_BrowserDecoded (void *ctx, void *dataptr, int frames, int channels, float rate)
|
|
{
|
|
sfx_t *sfx = ctx;
|
|
|
|
//make sure we were not restarting at the time... FIXME: make stricter?
|
|
extern sfx_t *known_sfx;
|
|
extern int num_sfx;
|
|
int id = sfx-known_sfx;
|
|
if (id < 0 || id >= num_sfx || sfx != &known_sfx[id])
|
|
return; //err... don't crash out!
|
|
|
|
sfx->loopstart = -1;
|
|
if (dataptr)
|
|
{ //okay, something loaded. woo.
|
|
Z_Free(sfx->decoder.buf);
|
|
sfx->decoder.buf = NULL;
|
|
sfx->decoder.decodedata = NULL;
|
|
ResampleSfx (sfx, rate, channels, QAF_S16, frames, -1, dataptr);
|
|
}
|
|
else
|
|
{
|
|
Con_Printf(CON_WARNING"Failed to decode %s\n", sfx->name);
|
|
sfx->loadstate = SLS_FAILED;
|
|
}
|
|
}
|
|
static qboolean QDECL S_LoadBrowserFile (sfx_t *s, qbyte *data, size_t datalen, int sndspeed, qboolean forcedecode)
|
|
{
|
|
struct sfxcache_s *buf;
|
|
|
|
if (datalen > 4 && !strncmp(data, "RIFF", 4))
|
|
return false; //do NOT use this code for wav files. we have no way to read the looping flags which would break things in certain situations. we MUST fall back on our normal loader.
|
|
|
|
s->decoder.buf = buf = Z_Malloc(sizeof(*buf)+128);
|
|
//fill with a placeholder
|
|
buf->length = 128;
|
|
buf->speed = snd_speed;
|
|
buf->format = QAF_S8; //something basic
|
|
buf->numchannels=1;
|
|
buf->soundoffset = 0;
|
|
buf->data = (qbyte*)(buf+1);
|
|
|
|
s->loopstart = 0; //keep looping silence until it actually loads something.
|
|
|
|
return emscriptenfte_pcm_loadaudiofile(s, S_BrowserDecoded, data, datalen, sndspeed);
|
|
}
|
|
#else
|
|
//web browsers contain their own decoding libraries that our openal stuff can use.
|
|
static qboolean QDECL S_LoadBrowserFile (sfx_t *s, qbyte *data, size_t datalen, int sndspeed, qboolean forcedecode)
|
|
{
|
|
sfxcache_t *sc;
|
|
s->decoder.buf = sc = BZ_Malloc(sizeof(sfxcache_t) + datalen);
|
|
s->loopstart = -1;
|
|
sc->data = (qbyte*)(sc+1);
|
|
sc->length = datalen;
|
|
sc->format = QAF_BLOB; //ie: not pcm
|
|
sc->speed = sndspeed;
|
|
sc->numchannels = 2;
|
|
sc->soundoffset = 0;
|
|
memcpy(sc->data, data, datalen);
|
|
|
|
return true;
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
qboolean QDECL S_LoadOVSound (sfx_t *s, qbyte *data, size_t datalen, int sndspeed, qboolean forcedecode);
|
|
|
|
//highest priority is last.
|
|
static struct
|
|
{
|
|
S_LoadSound_t loadfunc;
|
|
void *module;
|
|
} AudioInputPlugins[10] =
|
|
{
|
|
#ifdef FTE_TARGET_WEB
|
|
{S_LoadBrowserFile},
|
|
#endif
|
|
#ifdef AVAIL_OGGVORBIS
|
|
{S_LoadOVSound},
|
|
#endif
|
|
{S_LoadWavSound},
|
|
#ifdef PACKAGE_DOOMWAD
|
|
{S_LoadDoomSound},
|
|
// {S_LoadDoomSpeakerSound},
|
|
#endif
|
|
};
|
|
|
|
qboolean S_RegisterSoundInputPlugin(void *module, S_LoadSound_t loadfnc)
|
|
{
|
|
int i;
|
|
for (i = 0; i < sizeof(AudioInputPlugins)/sizeof(AudioInputPlugins[0]); i++)
|
|
{
|
|
if (!AudioInputPlugins[i].loadfunc)
|
|
{
|
|
AudioInputPlugins[i].module = module;
|
|
AudioInputPlugins[i].loadfunc = loadfnc;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
void S_UnregisterSoundInputModule(void *module)
|
|
{ //unregister all sound handlers for the given module.
|
|
int i;
|
|
for (i = 0; i < sizeof(AudioInputPlugins)/sizeof(AudioInputPlugins[0]); i++)
|
|
{
|
|
if (AudioInputPlugins[i].module == module)
|
|
{
|
|
AudioInputPlugins[i].module = NULL;
|
|
AudioInputPlugins[i].loadfunc = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void S_LoadedOrFailed (void *ctx, void *ctxdata, size_t a, size_t b)
|
|
{
|
|
sfx_t *s = ctx;
|
|
s->loadstate = a;
|
|
}
|
|
/*
|
|
==============
|
|
S_LoadSound
|
|
==============
|
|
*/
|
|
|
|
static void S_LoadSoundWorker (void *ctx, void *ctxdata, size_t forcedecode, size_t b)
|
|
{
|
|
sfx_t *s = ctx;
|
|
char namebuffer[256];
|
|
qbyte *data;
|
|
int i;
|
|
size_t result;
|
|
char *name = s->name;
|
|
size_t filesize;
|
|
|
|
s->loopstart = -1;
|
|
|
|
if (s->syspath)
|
|
{
|
|
vfsfile_t *f;
|
|
|
|
if ((f = VFSOS_Open(name, "rb")))
|
|
{
|
|
filesize = VFS_GETLEN(f);
|
|
data = BZ_Malloc (filesize);
|
|
result = VFS_READ(f, data, filesize);
|
|
|
|
if (result != filesize)
|
|
Con_SafePrintf("S_LoadSound() fread: Filename: %s, expected %"PRIuSIZE", result was %"PRIuSIZE"\n", name, filesize, result);
|
|
|
|
VFS_CLOSE(f);
|
|
}
|
|
else
|
|
{
|
|
Con_SafePrintf ("Couldn't load %s\n", namebuffer);
|
|
COM_AddWork(WG_MAIN, S_LoadedOrFailed, s, NULL, SLS_FAILED, 0);
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//Con_Printf ("S_LoadSound: %x\n", (int)stackbuf);
|
|
// load it in
|
|
const char *prefixes[] = {"sound/", ""};
|
|
const char *extensions[] = {
|
|
".wav",
|
|
#ifdef AVAIL_OGGOPUS
|
|
".opus",
|
|
#endif
|
|
#ifdef AVAIL_OGGVORBIS
|
|
".ogg",
|
|
#endif
|
|
};
|
|
char altname[sizeof(namebuffer)];
|
|
char orig[16];
|
|
size_t pre, ex;
|
|
|
|
data = NULL;
|
|
filesize = 0;
|
|
if (*name == '*') //q2 sexed sounds
|
|
{
|
|
//clq2_parsestartsound detects this also, and should not try playing these sounds.
|
|
s->loadstate = SLS_FAILED;
|
|
return;
|
|
}
|
|
|
|
for (pre = 0; !data && pre < countof(prefixes); pre++)
|
|
{
|
|
if (name[0] == '.' && name[1] == '.' && name[2] == '/')
|
|
{ //someone's being specific. disable prefixes entirely.
|
|
if (pre)
|
|
break;
|
|
//not relative to sound/
|
|
Q_snprintfz(namebuffer, sizeof(namebuffer), "%s", name+3);
|
|
}
|
|
else
|
|
Q_snprintfz(namebuffer, sizeof(namebuffer), "%s%s", prefixes[pre], name);
|
|
|
|
data = FS_LoadMallocFile(namebuffer, &filesize);
|
|
if (data)
|
|
break;
|
|
COM_FileExtension(namebuffer, orig, sizeof(orig));
|
|
COM_StripExtension(namebuffer, altname, sizeof(altname));
|
|
for (ex = 0; ex < countof(extensions); ex++)
|
|
{
|
|
if (!strcmp(orig, extensions[ex]+1))
|
|
continue;
|
|
Q_snprintfz(namebuffer, sizeof(namebuffer), "%s%s", altname, extensions[ex]);
|
|
data = FS_LoadMallocFile(namebuffer, &filesize);
|
|
if (data)
|
|
{
|
|
static float throttletimer;
|
|
Con_ThrottlePrintf(&throttletimer, 1, "S_LoadSound: %s%s requested, but could only find %s\n", prefixes[pre], name, namebuffer);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (data && !Ruleset_FileLoaded(name, data, filesize))
|
|
{
|
|
BZ_Free(data);
|
|
data = NULL;
|
|
filesize = 0;
|
|
}
|
|
}
|
|
|
|
if (!data)
|
|
{
|
|
//FIXME: check to see if queued for download.
|
|
if (name[0] == '.' && name[1] == '.' && name[2] == '/')
|
|
Con_DPrintf ("Couldn't load %s\n", name+3);
|
|
else
|
|
Con_DPrintf ("Couldn't load sound/%s\n", name);
|
|
COM_AddWork(WG_MAIN, S_LoadedOrFailed, s, NULL, SLS_FAILED, 0);
|
|
return;
|
|
}
|
|
|
|
for (i = sizeof(AudioInputPlugins)/sizeof(AudioInputPlugins[0])-1; i >= 0; i--)
|
|
{
|
|
if (AudioInputPlugins[i].loadfunc)
|
|
{
|
|
if (AudioInputPlugins[i].loadfunc(s, data, filesize, snd_speed, forcedecode))
|
|
{
|
|
//wake up the main thread in case it decided to wait for us.
|
|
COM_AddWork(WG_MAIN, S_LoadedOrFailed, s, NULL, SLS_LOADED, 0);
|
|
BZ_Free(data);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (s->loadstate != SLS_FAILED)
|
|
Con_Printf ("Format not recognised: %s\n", namebuffer);
|
|
|
|
COM_AddWork(WG_MAIN, S_LoadedOrFailed, s, NULL, SLS_FAILED, 0);
|
|
BZ_Free(data);
|
|
return;
|
|
}
|
|
|
|
qboolean S_LoadSound (sfx_t *s, qboolean force)
|
|
{
|
|
if (s->loadstate == SLS_NOTLOADED && sndcardinfo)
|
|
{
|
|
s->loadstate = SLS_LOADING;
|
|
COM_AddWork(WG_LOADER, S_LoadSoundWorker, s, NULL, force, 0);
|
|
}
|
|
if (s->loadstate == SLS_FAILED)
|
|
return false; //it failed to load once before, don't bother trying again.
|
|
|
|
return true; //loaded okay, or still loading
|
|
}
|
|
|
|
/*
|
|
===============================================================================
|
|
|
|
WAV loading
|
|
|
|
===============================================================================
|
|
*/
|
|
|
|
typedef struct
|
|
{
|
|
char *wavname;
|
|
qbyte *data_p;
|
|
qbyte *iff_end;
|
|
qbyte *last_chunk;
|
|
qbyte *iff_data;
|
|
int iff_chunk_len;
|
|
} wavctx_t;
|
|
|
|
static short GetLittleShort(wavctx_t *ctx)
|
|
{
|
|
short val = 0;
|
|
val = *ctx->data_p;
|
|
val = val + (*(ctx->data_p+1)<<8);
|
|
ctx->data_p += 2;
|
|
return val;
|
|
}
|
|
|
|
static int GetLittleLong(wavctx_t *ctx)
|
|
{
|
|
int val = 0;
|
|
val = *ctx->data_p;
|
|
val = val + (*(ctx->data_p+1)<<8);
|
|
val = val + (*(ctx->data_p+2)<<16);
|
|
val = val + (*(ctx->data_p+3)<<24);
|
|
ctx->data_p += 4;
|
|
return val;
|
|
}
|
|
|
|
static unsigned int FindNextChunk(wavctx_t *ctx, char *name)
|
|
{
|
|
unsigned int dataleft;
|
|
|
|
while (1)
|
|
{
|
|
dataleft = ctx->iff_end - ctx->last_chunk;
|
|
if (dataleft < 8)
|
|
{ // didn't find the chunk
|
|
ctx->data_p = NULL;
|
|
return 0;
|
|
}
|
|
|
|
ctx->data_p=ctx->last_chunk;
|
|
ctx->data_p += 4;
|
|
dataleft-= 8;
|
|
ctx->iff_chunk_len = GetLittleLong(ctx);
|
|
if (ctx->iff_chunk_len < 0)
|
|
{
|
|
ctx->data_p = NULL;
|
|
return 0;
|
|
}
|
|
if (ctx->iff_chunk_len > dataleft)
|
|
{
|
|
Con_DPrintf ("\"%s\" seems truncated by %i bytes\n", ctx->wavname, ctx->iff_chunk_len-dataleft);
|
|
#if 1
|
|
ctx->iff_chunk_len = dataleft;
|
|
#else
|
|
ctx->data_p = NULL;
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
dataleft-= ctx->iff_chunk_len;
|
|
// if (iff_chunk_len > 1024*1024)
|
|
// Sys_Error ("FindNextChunk: %i length is past the 1 meg sanity limit", iff_chunk_len);
|
|
ctx->data_p -= 8;
|
|
ctx->last_chunk = ctx->data_p + 8 + ctx->iff_chunk_len;
|
|
if ((ctx->iff_chunk_len&1) && dataleft)
|
|
ctx->last_chunk++;
|
|
if (!Q_strncmp(ctx->data_p, name, 4))
|
|
return ctx->iff_chunk_len;
|
|
}
|
|
}
|
|
|
|
static unsigned int FindChunk(wavctx_t *ctx, char *name)
|
|
{
|
|
ctx->last_chunk = ctx->iff_data;
|
|
return FindNextChunk (ctx, name);
|
|
}
|
|
|
|
|
|
#if 0
|
|
static void DumpChunks(void)
|
|
{
|
|
char str[5];
|
|
|
|
str[4] = 0;
|
|
data_p=iff_data;
|
|
do
|
|
{
|
|
memcpy (str, data_p, 4);
|
|
data_p += 4;
|
|
iff_chunk_len = GetLittleLong();
|
|
Con_Printf ("0x%x : %s (%d)\n", (int)(data_p - 4), str, iff_chunk_len);
|
|
data_p += (iff_chunk_len + 1) & ~1;
|
|
} while (data_p < iff_end);
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
============
|
|
GetWavinfo
|
|
============
|
|
*/
|
|
static wavinfo_t GetWavinfo (char *name, qbyte *wav, int wavlength)
|
|
{
|
|
extern cvar_t snd_ignorecueloops;
|
|
wavinfo_t info;
|
|
int i;
|
|
int samples;
|
|
int chunklen;
|
|
wavctx_t ctx;
|
|
|
|
memset (&info, 0, sizeof(info));
|
|
|
|
if (!wav)
|
|
return info;
|
|
|
|
ctx.data_p = NULL;
|
|
ctx.last_chunk = NULL;
|
|
ctx.iff_chunk_len = 0;
|
|
|
|
ctx.iff_data = wav;
|
|
ctx.iff_end = wav + wavlength;
|
|
ctx.wavname = name;
|
|
|
|
// find "RIFF" chunk
|
|
chunklen = FindChunk(&ctx, "RIFF");
|
|
if (chunklen < 4 || Q_strncmp(ctx.data_p+8, "WAVE", 4))
|
|
{
|
|
Con_Printf("Missing RIFF/WAVE chunks in %s\n", name);
|
|
return info;
|
|
}
|
|
|
|
// get "fmt " chunk
|
|
ctx.iff_data = ctx.data_p + 12;
|
|
// DumpChunks ();
|
|
|
|
chunklen = FindChunk(&ctx, "fmt ");
|
|
if (chunklen < 24-8)
|
|
{
|
|
Con_Printf("Missing/truncated fmt chunk\n");
|
|
return info;
|
|
}
|
|
ctx.data_p += 8;
|
|
info.format = GetLittleShort(&ctx);
|
|
|
|
info.numchannels = GetLittleShort(&ctx);
|
|
info.rate = GetLittleLong(&ctx);
|
|
ctx.data_p += 4+2;
|
|
info.bitwidth = GetLittleShort(&ctx);
|
|
|
|
// get cue chunk
|
|
chunklen = FindChunk(&ctx, "cue ");
|
|
if (chunklen >= 36-8 && !snd_ignorecueloops.ival)
|
|
{
|
|
ctx.data_p += 32;
|
|
info.loopstart = GetLittleLong(&ctx);
|
|
// Con_Printf("loopstart=%d\n", sfx->loopstart);
|
|
|
|
// if the next chunk is a LIST chunk, look for a cue length marker
|
|
chunklen = FindNextChunk (&ctx, "LIST");
|
|
if (chunklen >= 32-8)
|
|
{
|
|
if (!strncmp (ctx.data_p + 28, "mark", 4))
|
|
{ // this is not a proper parse, but it works with cooledit...
|
|
ctx.data_p += 24;
|
|
i = GetLittleLong (&ctx); // samples in loop
|
|
info.samples = info.loopstart + i;
|
|
// Con_Printf("looped length: %i\n", i);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
info.loopstart = -1;
|
|
|
|
// find data chunk
|
|
chunklen = FindChunk(&ctx, "data");
|
|
if (!ctx.data_p)
|
|
{
|
|
Con_Printf("Missing data chunk in %s\n", name);
|
|
return info;
|
|
}
|
|
|
|
ctx.data_p += 8;
|
|
samples = (chunklen<<3) / info.bitwidth / info.numchannels;
|
|
|
|
if (info.samples)
|
|
{
|
|
if (samples < info.samples)
|
|
{
|
|
info.samples = samples;
|
|
Con_Printf ("Sound %s has a bad loop length\n", name);
|
|
}
|
|
}
|
|
else
|
|
info.samples = samples;
|
|
|
|
if (info.loopstart > info.samples)
|
|
{
|
|
Con_Printf ("Sound %s has a bad loop start\n", name);
|
|
info.loopstart = info.samples;
|
|
}
|
|
|
|
info.dataofs = ctx.data_p - wav;
|
|
|
|
return info;
|
|
}
|