Xash3D FWGS engine.
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

1021 lines
29 KiB

/*
s_mix.c - portable code to mix sounds
Copyright (C) 2009 Uncle Mike
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 3 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.
*/
#include "common.h"
#include "sound.h"
#include "client.h"
#define IPAINTBUFFER 0
#define IROOMBUFFER 1
#define ISTREAMBUFFER 2
#define FILTERTYPE_NONE 0
#define FILTERTYPE_LINEAR 1
#define FILTERTYPE_CUBIC 2
#define CCHANVOLUMES 2
#define SND_SCALE_BITS 7
#define SND_SCALE_SHIFT (8 - SND_SCALE_BITS)
#define SND_SCALE_LEVELS (1 << SND_SCALE_BITS)
portable_samplepair_t *g_curpaintbuffer;
portable_samplepair_t streambuffer[(PAINTBUFFER_SIZE+1)];
portable_samplepair_t paintbuffer[(PAINTBUFFER_SIZE+1)];
portable_samplepair_t roombuffer[(PAINTBUFFER_SIZE+1)];
portable_samplepair_t facingbuffer[(PAINTBUFFER_SIZE+1)];
portable_samplepair_t temppaintbuffer[(PAINTBUFFER_SIZE+1)];
paintbuffer_t paintbuffers[CPAINTBUFFERS];
int snd_scaletable[SND_SCALE_LEVELS][256];
void S_InitScaletable( void )
{
int i, j;
for( i = 0; i < SND_SCALE_LEVELS; i++ )
{
for( j = 0; j < 256; j++ )
snd_scaletable[i][j] = ((signed char)j) * i * (1<<SND_SCALE_SHIFT);
}
}
/*
===================
S_TransferPaintBuffer
===================
*/
void S_TransferPaintBuffer( int endtime )
{
int *snd_p, snd_linear_count;
int lpos, lpaintedtime;
int i, val, sampleMask;
short *snd_out;
dword *pbuf;
pbuf = (dword *)dma.buffer;
snd_p = (int *)PAINTBUFFER;
lpaintedtime = paintedtime;
sampleMask = ((dma.samples >> 1) - 1);
while( lpaintedtime < endtime )
{
// handle recirculating buffer issues
lpos = lpaintedtime & sampleMask;
snd_out = (short *)pbuf + (lpos << 1);
snd_linear_count = (dma.samples>>1) - lpos;
if( lpaintedtime + snd_linear_count > endtime )
snd_linear_count = endtime - lpaintedtime;
snd_linear_count <<= 1;
// write a linear blast of samples
for( i = 0; i < snd_linear_count; i += 2 )
{
val = (snd_p[i+0] * 256) >> 8;
if( val > 0x7fff ) snd_out[i+0] = 0x7fff;
else if( val < (short)0x8000 )
snd_out[i+0] = (short)0x8000;
else snd_out[i+0] = val;
val = (snd_p[i+1] * 256) >> 8;
if( val > 0x7fff ) snd_out[i+1] = 0x7fff;
else if( val < (short)0x8000 )
snd_out[i+1] = (short)0x8000;
else snd_out[i+1] = val;
}
snd_p += snd_linear_count;
lpaintedtime += (snd_linear_count >> 1);
}
}
//===============================================================================
// Mix buffer (paintbuffer) management routines
//===============================================================================
// Activate a paintbuffer. All active paintbuffers are mixed in parallel within
// MIX_MixChannelsToPaintbuffer, according to flags
_inline void MIX_ActivatePaintbuffer( int ipaintbuffer )
{
Assert( ipaintbuffer < CPAINTBUFFERS );
paintbuffers[ipaintbuffer].factive = true;
}
_inline void MIX_SetCurrentPaintbuffer( int ipaintbuffer )
{
Assert( ipaintbuffer < CPAINTBUFFERS );
g_curpaintbuffer = paintbuffers[ipaintbuffer].pbuf;
Assert( g_curpaintbuffer != NULL );
}
_inline int MIX_GetCurrentPaintbufferIndex( void )
{
int i;
for( i = 0; i < CPAINTBUFFERS; i++ )
{
if( g_curpaintbuffer == paintbuffers[i].pbuf )
return i;
}
return 0;
}
_inline paintbuffer_t *MIX_GetCurrentPaintbufferPtr( void )
{
int ipaint = MIX_GetCurrentPaintbufferIndex();
Assert( ipaint < CPAINTBUFFERS );
return &paintbuffers[ipaint];
}
// Don't mix into any paintbuffers
_inline void MIX_DeactivateAllPaintbuffers( void )
{
int i;
for( i = 0; i < CPAINTBUFFERS; i++ )
paintbuffers[i].factive = false;
}
// set upsampling filter indexes back to 0
_inline void MIX_ResetPaintbufferFilterCounters( void )
{
int i;
for( i = 0; i < CPAINTBUFFERS; i++ )
paintbuffers[i].ifilter = FILTERTYPE_NONE;
}
// return pointer to front paintbuffer pbuf, given index
_inline portable_samplepair_t *MIX_GetPFrontFromIPaint( int ipaintbuffer )
{
Assert( ipaintbuffer < CPAINTBUFFERS );
return paintbuffers[ipaintbuffer].pbuf;
}
_inline paintbuffer_t *MIX_GetPPaintFromIPaint( int ipaint )
{
Assert( ipaint < CPAINTBUFFERS );
return &paintbuffers[ipaint];
}
void MIX_FreeAllPaintbuffers( void )
{
// clear paintbuffer structs
memset( paintbuffers, 0, CPAINTBUFFERS * sizeof( paintbuffer_t ));
}
// Initialize paintbuffers array, set current paint buffer to main output buffer IPAINTBUFFER
void MIX_InitAllPaintbuffers( void )
{
// clear paintbuffer structs
memset( paintbuffers, 0, CPAINTBUFFERS * sizeof( paintbuffer_t ));
paintbuffers[IPAINTBUFFER].pbuf = paintbuffer;
paintbuffers[IROOMBUFFER].pbuf = roombuffer;
paintbuffers[ISTREAMBUFFER].pbuf = streambuffer;
MIX_SetCurrentPaintbuffer( IPAINTBUFFER );
}
/*
===============================================================================
CHANNEL MIXING
===============================================================================
*/
void S_PaintMonoFrom8( portable_samplepair_t *pbuf, int *volume, byte *pData, int outCount )
{
int *lscale, *rscale;
int i, data;
lscale = snd_scaletable[volume[0] >> SND_SCALE_SHIFT];
rscale = snd_scaletable[volume[1] >> SND_SCALE_SHIFT];
for( i = 0; i < outCount; i++ )
{
data = pData[i];
pbuf[i].left += lscale[data];
pbuf[i].right += rscale[data];
}
}
void S_PaintStereoFrom8( portable_samplepair_t *pbuf, int *volume, byte *pData, int outCount )
{
int *lscale, *rscale;
uint left, right;
word *data;
int i;
lscale = snd_scaletable[volume[0] >> SND_SCALE_SHIFT];
rscale = snd_scaletable[volume[1] >> SND_SCALE_SHIFT];
data = (word *)pData;
for( i = 0; i < outCount; i++, data++ )
{
left = (byte)((*data & 0x00FF));
right = (byte)((*data & 0xFF00) >> 8);
pbuf[i].left += lscale[left];
pbuf[i].right += rscale[right];
}
}
void S_PaintMonoFrom16( portable_samplepair_t *pbuf, int *volume, short *pData, int outCount )
{
int left, right;
int i, data;
for( i = 0; i < outCount; i++ )
{
data = pData[i];
left = ( data * volume[0]) >> 8;
right = (data * volume[1]) >> 8;
pbuf[i].left += left;
pbuf[i].right += right;
}
}
void S_PaintStereoFrom16( portable_samplepair_t *pbuf, int *volume, short *pData, int outCount )
{
uint *data;
int left, right;
int i;
data = (uint *)pData;
for( i = 0; i < outCount; i++, data++ )
{
left = (signed short)((*data & 0x0000FFFF));
right = (signed short)((*data & 0xFFFF0000) >> 16);
left = (left * volume[0]) >> 8;
right = (right * volume[1]) >> 8;
pbuf[i].left += left;
pbuf[i].right += right;
}
}
void S_Mix8MonoTimeCompress( portable_samplepair_t *pbuf, int *volume, byte *pData, int inputOffset, uint rateScale, int outCount, int timecompress )
{
}
void S_Mix8Mono( portable_samplepair_t *pbuf, int *volume, byte *pData, int inputOffset, uint rateScale, int outCount, int timecompress )
{
int i, sampleIndex = 0;
uint sampleFrac = inputOffset;
int *lscale, *rscale;
if( timecompress != 0 )
{
S_Mix8MonoTimeCompress( pbuf, volume, pData, inputOffset, rateScale, outCount, timecompress );
// return;
}
// Not using pitch shift?
if( rateScale == FIX( 1 ))
{
S_PaintMonoFrom8( pbuf, volume, pData, outCount );
return;
}
lscale = snd_scaletable[volume[0] >> SND_SCALE_SHIFT];
rscale = snd_scaletable[volume[1] >> SND_SCALE_SHIFT];
for( i = 0; i < outCount; i++ )
{
pbuf[i].left += lscale[pData[sampleIndex]];
pbuf[i].right += rscale[pData[sampleIndex]];
sampleFrac += rateScale;
sampleIndex += FIX_INTPART( sampleFrac );
sampleFrac = FIX_FRACPART( sampleFrac );
}
}
void S_Mix8Stereo( portable_samplepair_t *pbuf, int *volume, byte *pData, int inputOffset, uint rateScale, int outCount )
{
int i, sampleIndex = 0;
uint sampleFrac = inputOffset;
int *lscale, *rscale;
// Not using pitch shift?
if( rateScale == FIX( 1 ))
{
S_PaintStereoFrom8( pbuf, volume, pData, outCount );
return;
}
lscale = snd_scaletable[volume[0] >> SND_SCALE_SHIFT];
rscale = snd_scaletable[volume[1] >> SND_SCALE_SHIFT];
for( i = 0; i < outCount; i++ )
{
pbuf[i].left += lscale[pData[sampleIndex+0]];
pbuf[i].right += rscale[pData[sampleIndex+1]];
sampleFrac += rateScale;
sampleIndex += FIX_INTPART( sampleFrac )<<1;
sampleFrac = FIX_FRACPART( sampleFrac );
}
}
void S_Mix16Mono( portable_samplepair_t *pbuf, int *volume, short *pData, int inputOffset, uint rateScale, int outCount )
{
int i, sampleIndex = 0;
uint sampleFrac = inputOffset;
// Not using pitch shift?
if( rateScale == FIX( 1 ))
{
S_PaintMonoFrom16( pbuf, volume, pData, outCount );
return;
}
for( i = 0; i < outCount; i++ )
{
pbuf[i].left += (volume[0] * (int)( pData[sampleIndex] ))>>8;
pbuf[i].right += (volume[1] * (int)( pData[sampleIndex] ))>>8;
sampleFrac += rateScale;
sampleIndex += FIX_INTPART( sampleFrac );
sampleFrac = FIX_FRACPART( sampleFrac );
}
}
void S_Mix16Stereo( portable_samplepair_t *pbuf, int *volume, short *pData, int inputOffset, uint rateScale, int outCount )
{
int i, sampleIndex = 0;
uint sampleFrac = inputOffset;
// Not using pitch shift?
if( rateScale == FIX( 1 ))
{
S_PaintStereoFrom16( pbuf, volume, pData, outCount );
return;
}
for( i = 0; i < outCount; i++ )
{
pbuf[i].left += (volume[0] * (int)( pData[sampleIndex+0] ))>>8;
pbuf[i].right += (volume[1] * (int)( pData[sampleIndex+1] ))>>8;
sampleFrac += rateScale;
sampleIndex += FIX_INTPART(sampleFrac)<<1;
sampleFrac = FIX_FRACPART(sampleFrac);
}
}
void S_MixChannel( channel_t *pChannel, void *pData, int outputOffset, int inputOffset, uint fracRate, int outCount, int timecompress )
{
int pvol[CCHANVOLUMES];
paintbuffer_t *ppaint = MIX_GetCurrentPaintbufferPtr();
wavdata_t *pSource = pChannel->sfx->cache;
portable_samplepair_t *pbuf;
Assert( pSource != NULL );
pvol[0] = bound( 0, pChannel->leftvol, 255 );
pvol[1] = bound( 0, pChannel->rightvol, 255 );
pbuf = ppaint->pbuf + outputOffset;
if( pSource->channels == 1 )
{
if( pSource->width == 1 )
S_Mix8Mono( pbuf, pvol, pData, inputOffset, fracRate, outCount, timecompress );
else S_Mix16Mono( pbuf, pvol, (short *)pData, inputOffset, fracRate, outCount );
}
else
{
if( pSource->width == 1 )
S_Mix8Stereo( pbuf, pvol, pData, inputOffset, fracRate, outCount );
else S_Mix16Stereo( pbuf, pvol, (short *)pData, inputOffset, fracRate, outCount );
}
}
int S_MixDataToDevice( channel_t *pChannel, int sampleCount, int outRate, int outOffset, int timeCompress )
{
// save this to compute total output
int startingOffset = outOffset;
float inputRate = ( pChannel->pitch * pChannel->sfx->cache->rate );
float rate = inputRate / outRate;
// shouldn't be playing this if finished, but return if we are
if( pChannel->pMixer.finished )
return 0;
// If we are terminating this wave prematurely, then make sure we detect the limit
if( pChannel->pMixer.forcedEndSample )
{
// how many total input samples will we need?
int samplesRequired = (int)(sampleCount * rate);
// will this hit the end?
if( pChannel->pMixer.sample + samplesRequired >= pChannel->pMixer.forcedEndSample )
{
// yes, mark finished and truncate the sample request
pChannel->pMixer.finished = true;
sampleCount = (int)((pChannel->pMixer.forcedEndSample - pChannel->pMixer.sample) / rate );
}
}
while( sampleCount > 0 )
{
int availableSamples, outSampleCount;
wavdata_t *pSource = pChannel->sfx->cache;
qboolean use_loop = pChannel->use_loop;
void *pData = NULL;
double sampleFrac;
int i, j;
// compute number of input samples required
double end = pChannel->pMixer.sample + rate * sampleCount;
int inputSampleCount = (int)(ceil( end ) - floor( pChannel->pMixer.sample ));
availableSamples = S_GetOutputData( pSource, &pData, pChannel->pMixer.sample, inputSampleCount, use_loop );
// none available, bail out
if( !availableSamples ) break;
sampleFrac = pChannel->pMixer.sample - floor( pChannel->pMixer.sample );
if( availableSamples < inputSampleCount )
{
// how many samples are there given the number of input samples and the rate.
outSampleCount = (int)ceil(( availableSamples - sampleFrac ) / rate );
}
else
{
outSampleCount = sampleCount;
}
// Verify that we won't get a buffer overrun.
Assert( floor( sampleFrac + rate * ( outSampleCount - 1 )) <= availableSamples );
// save current paintbuffer
j = MIX_GetCurrentPaintbufferIndex();
for( i = 0; i < CPAINTBUFFERS; i++ )
{
if( !paintbuffers[i].factive )
continue;
// mix chan into all active paintbuffers
MIX_SetCurrentPaintbuffer( i );
S_MixChannel( pChannel, pData, outOffset, FIX_FLOAT( sampleFrac ), FIX_FLOAT( rate ), outSampleCount, timeCompress );
}
MIX_SetCurrentPaintbuffer( j );
pChannel->pMixer.sample += outSampleCount * rate;
outOffset += outSampleCount;
sampleCount -= outSampleCount;
}
// Did we run out of samples? if so, mark finished
if( sampleCount > 0 )
{
pChannel->pMixer.finished = true;
}
// total number of samples mixed !!! at the output clock rate !!!
return outOffset - startingOffset;
}
qboolean S_ShouldContinueMixing( channel_t *ch )
{
if( ch->isSentence )
{
if( ch->currentWord )
return true;
return false;
}
return !ch->pMixer.finished;
}
// Mix all channels into active paintbuffers until paintbuffer is full or 'endtime' is reached.
// endtime: time in 44khz samples to mix
// rate: ignore samples which are not natively at this rate (for multipass mixing/filtering)
// if rate == SOUND_ALL_RATES then mix all samples this pass
// flags: if SOUND_MIX_DRY, then mix only samples with channel flagged as 'dry'
// outputRate: target mix rate for all samples. Note, if outputRate = SOUND_DMA_SPEED, then
// this routine will fill the paintbuffer to endtime. Otherwise, fewer samples are mixed.
// if( endtime - paintedtime ) is not aligned on boundaries of 4,
// we'll miss data if outputRate < SOUND_DMA_SPEED!
void MIX_MixChannelsToPaintbuffer( int endtime, int rate, int outputRate )
{
channel_t *ch;
wavdata_t *pSource;
int i, sampleCount;
qboolean bZeroVolume;
// mix each channel into paintbuffer
ch = channels;
// validate parameters
Assert( outputRate <= SOUND_DMA_SPEED );
// make sure we're not discarding data
Assert( !(( endtime - paintedtime ) & 0x3 ) || ( outputRate == SOUND_DMA_SPEED ));
// 44k: try to mix this many samples at outputRate
sampleCount = ( endtime - paintedtime ) / ( SOUND_DMA_SPEED / outputRate );
if( sampleCount <= 0 ) return;
for( i = 0; i < total_channels; i++, ch++ )
{
if( !ch->sfx ) continue;
// NOTE: background map is allow both type sounds: menu and game
if( !cl.background )
{
if( cls.key_dest == key_console && ch->localsound )
{
// play, playvol
}
else if(( s_listener.inmenu || s_listener.paused ) && !ch->localsound )
{
// play only local sounds, keep pause for other
continue;
}
else if( !s_listener.inmenu && !s_listener.active && !ch->staticsound )
{
// play only ambient sounds, keep pause for other
continue;
}
}
else if( cls.key_dest == key_console )
continue; // silent mode in console
pSource = S_LoadSound( ch->sfx );
// Don't mix sound data for sounds with zero volume. If it's a non-looping sound,
// just remove the sound when its volume goes to zero.
bZeroVolume = !ch->leftvol && !ch->rightvol;
if( !bZeroVolume )
{
// this values matched with GoldSrc
if( ch->leftvol < 8 && ch->rightvol < 8 )
bZeroVolume = true;
}
if( !pSource || ( bZeroVolume && pSource->loopStart == -1 ))
{
if( !pSource )
{
S_FreeChannel( ch );
continue;
}
}
else if( bZeroVolume )
{
continue;
}
// multipass mixing - only mix samples of specified sample rate
switch( rate )
{
case SOUND_11k:
case SOUND_22k:
case SOUND_44k:
if( rate != pSource->rate )
continue;
break;
default: break;
}
// get playback pitch
if( ch->isSentence )
ch->pitch = VOX_ModifyPitch( ch, ch->basePitch * 0.01f );
else ch->pitch = ch->basePitch * 0.01f;
ch->pitch *= ( sys_timescale.value + 1 ) / 2;
if( CL_GetEntityByIndex( ch->entnum ) && ( ch->entchannel == CHAN_VOICE || ch->entchannel == CHAN_STREAM ))
{
if( pSource->width == 1 )
SND_MoveMouth8( ch, pSource, sampleCount );
else SND_MoveMouth16( ch, pSource, sampleCount );
}
// mix channel to all active paintbuffers.
// NOTE: must be called once per channel only - consecutive calls retrieve additional data.
if( ch->isSentence )
VOX_MixDataToDevice( ch, sampleCount, outputRate, 0 );
else S_MixDataToDevice( ch, sampleCount, outputRate, 0, 0 );
if( !S_ShouldContinueMixing( ch ))
{
S_FreeChannel( ch );
}
}
}
// pass in index -1...count+2, return pointer to source sample in either paintbuffer or delay buffer
_inline portable_samplepair_t *S_GetNextpFilter( int i, portable_samplepair_t *pbuffer, portable_samplepair_t *pfiltermem )
{
// The delay buffer is assumed to precede the paintbuffer by 6 duplicated samples
if( i == -1 ) return (&(pfiltermem[0]));
if( i == 0 ) return (&(pfiltermem[1]));
if( i == 1 ) return (&(pfiltermem[2]));
// return from paintbuffer, where samples are doubled.
// even samples are to be replaced with interpolated value.
return (&(pbuffer[(i-2) * 2 + 1]));
}
// pass forward over passed in buffer and cubic interpolate all odd samples
// pbuffer: buffer to filter (in place)
// prevfilter: filter memory. NOTE: this must match the filtertype ie: filtercubic[] for FILTERTYPE_CUBIC
// if NULL then perform no filtering.
// count: how many samples to upsample. will become count*2 samples in buffer, in place.
void S_Interpolate2xCubic( portable_samplepair_t *pbuffer, portable_samplepair_t *pfiltermem, int cfltmem, int count )
{
// implement cubic interpolation on 2x upsampled buffer. Effectively delays buffer contents by 2 samples.
// pbuffer: contains samples at 0, 2, 4, 6...
// temppaintbuffer is temp buffer, same size as paintbuffer, used to store processed values
// count: number of samples to process in buffer ie: how many samples at 0, 2, 4, 6...
// finpos is the fractional, inpos the integer part.
// finpos = 0.5 for upsampling by 2x
// inpos is the position of the sample
// xm1 = x [inpos - 1];
// x0 = x [inpos + 0];
// x1 = x [inpos + 1];
// x2 = x [inpos + 2];
// a = (3 * (x0-x1) - xm1 + x2) / 2;
// b = 2*x1 + xm1 - (5*x0 + x2) / 2;
// c = (x1 - xm1) / 2;
// y [outpos] = (((a * finpos) + b) * finpos + c) * finpos + x0;
int i, upCount = count << 1;
int a, b, c;
int xm1, x0, x1, x2;
portable_samplepair_t *psamp0;
portable_samplepair_t *psamp1;
portable_samplepair_t *psamp2;
portable_samplepair_t *psamp3;
int outpos = 0;
Assert( upCount <= PAINTBUFFER_SIZE );
// pfiltermem holds 6 samples from previous buffer pass
// process 'count' samples
for( i = 0; i < count; i++)
{
// get source sample pointer
psamp0 = S_GetNextpFilter( i-1, pbuffer, pfiltermem );
psamp1 = S_GetNextpFilter( i+0, pbuffer, pfiltermem );
psamp2 = S_GetNextpFilter( i+1, pbuffer, pfiltermem );
psamp3 = S_GetNextpFilter( i+2, pbuffer, pfiltermem );
// write out original sample to interpolation buffer
temppaintbuffer[outpos++] = *psamp1;
// get all left samples for interpolation window
xm1 = psamp0->left;
x0 = psamp1->left;
x1 = psamp2->left;
x2 = psamp3->left;
// interpolate
a = (3 * (x0-x1) - xm1 + x2) / 2;
b = 2*x1 + xm1 - (5*x0 + x2) / 2;
c = (x1 - xm1) / 2;
// write out interpolated sample
temppaintbuffer[outpos].left = a/8 + b/4 + c/2 + x0;
// get all right samples for window
xm1 = psamp0->right;
x0 = psamp1->right;
x1 = psamp2->right;
x2 = psamp3->right;
// interpolate
a = (3 * (x0-x1) - xm1 + x2) / 2;
b = 2*x1 + xm1 - (5*x0 + x2) / 2;
c = (x1 - xm1) / 2;
// write out interpolated sample, increment output counter
temppaintbuffer[outpos++].right = a/8 + b/4 + c/2 + x0;
Assert( outpos <= ( sizeof( temppaintbuffer ) / sizeof( temppaintbuffer[0] )));
}
Assert( cfltmem >= 3 );
// save last 3 samples from paintbuffer
pfiltermem[0] = pbuffer[upCount - 5];
pfiltermem[1] = pbuffer[upCount - 3];
pfiltermem[2] = pbuffer[upCount - 1];
// copy temppaintbuffer back into paintbuffer
for( i = 0; i < upCount; i++ )
pbuffer[i] = temppaintbuffer[i];
}
// pass forward over passed in buffer and linearly interpolate all odd samples
// pbuffer: buffer to filter (in place)
// prevfilter: filter memory. NOTE: this must match the filtertype ie: filterlinear[] for FILTERTYPE_LINEAR
// if NULL then perform no filtering.
// count: how many samples to upsample. will become count*2 samples in buffer, in place.
void S_Interpolate2xLinear( portable_samplepair_t *pbuffer, portable_samplepair_t *pfiltermem, int cfltmem, int count )
{
int i, upCount = count<<1;
Assert( upCount <= PAINTBUFFER_SIZE );
Assert( cfltmem >= 1 );
// use interpolation value from previous mix
pbuffer[0].left = (pfiltermem->left + pbuffer[0].left) >> 1;
pbuffer[0].right = (pfiltermem->right + pbuffer[0].right) >> 1;
for( i = 2; i < upCount; i += 2 )
{
// use linear interpolation for upsampling
pbuffer[i].left = (pbuffer[i].left + pbuffer[i-1].left) >> 1;
pbuffer[i].right = (pbuffer[i].right + pbuffer[i-1].right) >> 1;
}
// save last value to be played out in buffer
*pfiltermem = pbuffer[upCount - 1];
}
// upsample by 2x, optionally using interpolation
// count: how many samples to upsample. will become count*2 samples in buffer, in place.
// pbuffer: buffer to upsample into (in place)
// pfiltermem: filter memory. NOTE: this must match the filtertype ie: filterlinear[] for FILTERTYPE_LINEAR
// if NULL then perform no filtering.
// cfltmem: max number of sample pairs filter can use
// filtertype: FILTERTYPE_NONE, _LINEAR, _CUBIC etc. Must match prevfilter.
void S_MixBufferUpsample2x( int count, portable_samplepair_t *pbuffer, portable_samplepair_t *pfiltermem, int cfltmem, int filtertype )
{
int upCount = count<<1;
int i, j;
// reverse through buffer, duplicating contents for 'count' samples
for( i = upCount - 1, j = count - 1; j >= 0; i-=2, j-- )
{
pbuffer[i] = pbuffer[j];
pbuffer[i-1] = pbuffer[j];
}
// pass forward through buffer, interpolate all even slots
switch( filtertype )
{
case FILTERTYPE_LINEAR:
S_Interpolate2xLinear( pbuffer, pfiltermem, cfltmem, count );
break;
case FILTERTYPE_CUBIC:
S_Interpolate2xCubic( pbuffer, pfiltermem, cfltmem, count );
break;
default: // no filter
break;
}
}
// zero out all paintbuffers
void MIX_ClearAllPaintBuffers( int SampleCount, qboolean clearFilters )
{
int count = Q_min( SampleCount, PAINTBUFFER_SIZE );
int i;
// zero out all paintbuffer data (ignore sampleCount)
for( i = 0; i < CPAINTBUFFERS; i++ )
{
if( paintbuffers[i].pbuf != NULL )
memset( paintbuffers[i].pbuf, 0, (count+1) * sizeof( portable_samplepair_t ));
if( clearFilters )
{
memset( paintbuffers[i].fltmem, 0, sizeof( paintbuffers[i].fltmem ));
}
}
if( clearFilters )
{
MIX_ResetPaintbufferFilterCounters();
}
}
// mixes pbuf1 + pbuf2 into pbuf3, count samples
// fgain is output gain 0-1.0
// NOTE: pbuf3 may equal pbuf1 or pbuf2!
void MIX_MixPaintbuffers( int ibuf1, int ibuf2, int ibuf3, int count, float fgain )
{
portable_samplepair_t *pbuf1, *pbuf2, *pbuf3;
int i, gain;
gain = 256 * fgain;
Assert( count <= PAINTBUFFER_SIZE );
Assert( ibuf1 < CPAINTBUFFERS );
Assert( ibuf2 < CPAINTBUFFERS );
Assert( ibuf3 < CPAINTBUFFERS );
pbuf1 = paintbuffers[ibuf1].pbuf;
pbuf2 = paintbuffers[ibuf2].pbuf;
pbuf3 = paintbuffers[ibuf3].pbuf;
// destination buffer stereo - average n chans down to stereo
// destination 2ch:
// pb1 2ch + pb2 2ch -> pb3 2ch
// pb1 2ch + pb2 (4ch->2ch) -> pb3 2ch
// pb1 (4ch->2ch) + pb2 (4ch->2ch) -> pb3 2ch
// mix front channels
for( i = 0; i < count; i++ )
{
pbuf3[i].left = pbuf1[i].left;
pbuf3[i].right = pbuf1[i].right;
pbuf3[i].left += (pbuf2[i].left * gain) >> 8;
pbuf3[i].right += (pbuf2[i].right * gain) >> 8;
}
}
void MIX_CompressPaintbuffer( int ipaint, int count )
{
portable_samplepair_t *pbuf;
paintbuffer_t *ppaint;
int i;
ppaint = MIX_GetPPaintFromIPaint( ipaint );
pbuf = ppaint->pbuf;
for( i = 0; i < count; i++, pbuf++ )
{
pbuf->left = CLIP( pbuf->left );
pbuf->right = CLIP( pbuf->right );
}
}
void S_MixUpsample( int sampleCount, int filtertype )
{
paintbuffer_t *ppaint = MIX_GetCurrentPaintbufferPtr();
int ifilter = ppaint->ifilter;
Assert( ifilter < CPAINTFILTERS );
S_MixBufferUpsample2x( sampleCount, ppaint->pbuf, &(ppaint->fltmem[ifilter][0]), CPAINTFILTERMEM, filtertype );
// make sure on next upsample pass for this paintbuffer, new filter memory is used
ppaint->ifilter++;
}
void MIX_MixRawSamplesBuffer( int end )
{
portable_samplepair_t *pbuf, *roombuf, *streambuf;
uint i, j, stop;
roombuf = MIX_GetPFrontFromIPaint( IROOMBUFFER );
streambuf = MIX_GetPFrontFromIPaint( ISTREAMBUFFER );
if( s_listener.paused ) return;
// paint in the raw channels
for( i = 0; i < MAX_RAW_CHANNELS; i++ )
{
// copy from the streaming sound source
rawchan_t *ch = raw_channels[i];
qboolean stream;
if( !ch )
continue;
// not audible
if( !ch->leftvol && !ch->rightvol )
continue;
stream = ch->entnum == S_RAW_SOUND_BACKGROUNDTRACK || CL_IsPlayerIndex( ch->entnum );
pbuf = stream ? streambuf : roombuf;
stop = (end < ch->s_rawend) ? end : ch->s_rawend;
for( j = paintedtime; j < stop; j++ )
{
pbuf[j-paintedtime].left += ( ch->rawsamples[j & ( ch->max_samples - 1 )].left * ch->leftvol ) >> 8;
pbuf[j-paintedtime].right += ( ch->rawsamples[j & ( ch->max_samples - 1 )].right * ch->rightvol ) >> 8;
}
if( ch->entnum > 0 )
SND_MoveMouthRaw( ch, &ch->rawsamples[paintedtime & ( ch->max_samples - 1 )], stop - paintedtime );
}
}
// upsample and mix sounds into final 44khz versions of:
// IROOMBUFFER, IFACINGBUFFER, IFACINGAWAY
// dsp fx are then applied to these buffers by the caller.
// caller also remixes all into final IPAINTBUFFER output.
void MIX_UpsampleAllPaintbuffers( int end, int count )
{
// 11khz sounds are mixed into 3 buffers based on distance from listener, and facing direction
// These buffers are facing, facingaway, room
// These 3 mixed buffers are then each upsampled to 22khz.
// 22khz sounds are mixed into the 3 buffers based on distance from listener, and facing direction
// These 3 mixed buffers are then each upsampled to 44khz.
// 44khz sounds are mixed into the 3 buffers based on distance from listener, and facing direction
MIX_DeactivateAllPaintbuffers();
// set paintbuffer upsample filter indices to 0
MIX_ResetPaintbufferFilterCounters();
// only mix to roombuffer if dsp fx are on KDB: perf
MIX_ActivatePaintbuffer( IROOMBUFFER ); // operates on MIX_MixChannelsToPaintbuffer
// mix 11khz sounds:
MIX_MixChannelsToPaintbuffer( end, SOUND_11k, SOUND_11k );
#if SOUND_DMA_SPEED >= SOUND_22k
// upsample all 11khz buffers by 2x
// only upsample roombuffer if dsp fx are on KDB: perf
MIX_SetCurrentPaintbuffer( IROOMBUFFER ); // operates on MixUpSample
S_MixUpsample( count / ( SOUND_DMA_SPEED / SOUND_11k ), s_lerping.value );
// mix 22khz sounds:
MIX_MixChannelsToPaintbuffer( end, SOUND_22k, SOUND_22k );
#endif
#if SOUND_DMA_SPEED >= SOUND_44k
// upsample all 22khz buffers by 2x
// only upsample roombuffer if dsp fx are on KDB: perf
MIX_SetCurrentPaintbuffer( IROOMBUFFER );
S_MixUpsample( count / ( SOUND_DMA_SPEED / SOUND_22k ), s_lerping.value );
// mix all 44khz sounds to all active paintbuffers
MIX_MixChannelsToPaintbuffer( end, SOUND_44k, SOUND_DMA_SPEED );
#endif
// mix raw samples from the video streams
MIX_MixRawSamplesBuffer( end );
MIX_DeactivateAllPaintbuffers();
MIX_SetCurrentPaintbuffer( IPAINTBUFFER );
}
void MIX_PaintChannels( int endtime )
{
int end, count;
CheckNewDspPresets();
while( paintedtime < endtime )
{
// if paintbuffer is smaller than DMA buffer
end = endtime;
if( endtime - paintedtime > PAINTBUFFER_SIZE )
end = paintedtime + PAINTBUFFER_SIZE;
// number of 44khz samples to mix into paintbuffer, up to paintbuffer size
count = end - paintedtime;
// clear the all mix buffers
MIX_ClearAllPaintBuffers( count, false );
MIX_UpsampleAllPaintbuffers( end, count );
// process all sounds with DSP
DSP_Process( idsp_room, MIX_GetPFrontFromIPaint( IROOMBUFFER ), count );
// add music or soundtrack from movie (no dsp)
MIX_MixPaintbuffers( IPAINTBUFFER, IROOMBUFFER, IPAINTBUFFER, count, S_GetMasterVolume() );
// add music or soundtrack from movie (no dsp)
MIX_MixPaintbuffers( IPAINTBUFFER, ISTREAMBUFFER, IPAINTBUFFER, count, S_GetMusicVolume() );
// clip all values > 16 bit down to 16 bit
MIX_CompressPaintbuffer( IPAINTBUFFER, count );
// transfer IPAINTBUFFER paintbuffer out to DMA buffer
MIX_SetCurrentPaintbuffer( IPAINTBUFFER );
// transfer out according to DMA format
S_TransferPaintBuffer( end );
paintedtime = end;
}
}