zdoom/raze-gles
0
0
Fork 0
mirror of https://github.com/ZDoom/raze-gles.git synced 2024-12-24 10:40:46 +00:00
Code Issues Projects Releases Packages Wiki Activity

More audiolib cleanup, remove 8-bit output support.

Browse source 
git-svn-id: https://svn.eduke32.com/eduke32@5272 1a8010ca-5511-0410-912e-c29ae57300e0
This commit is contained in:
terminx 2015-07-08 03:34:09 +00:00
parent 388fbe041e
commit 26933ecdc2
23 changed files with 95 additions and 463 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
polymer/eduke32/eduke32.vcxproj
View file

@ -321,6 +321,7 @@
<ClInclude Include="source\gamevars.h" />
<ClInclude Include="source\global.h" />
<ClInclude Include="source\input.h" />
<ClInclude Include="source\jaudiolib\include\drivers.h" />
<ClInclude Include="source\lunatic\lunatic_game.h" />
<ClInclude Include="source\lunatic\lunatic_m32.h" />
<ClInclude Include="source\m32def.h" />
@ -358,14 +359,11 @@
<ClInclude Include="source\jaudiolib\src\driver_directsound.h" />
<ClInclude Include="source\jaudiolib\src\driver_nosound.h" />
<ClInclude Include="source\jaudiolib\src\driver_sdl.h" />
<ClInclude Include="source\jaudiolib\src\drivers.h" />
<ClInclude Include="source\jaudiolib\include\fx_man.h" />
<ClInclude Include="source\jaudiolib\src\linklist.h" />
<ClInclude Include="source\jaudiolib\src\ll_man.h" />
<ClInclude Include="source\jaudiolib\src\multivoc.h" />
<ClInclude Include="source\jaudiolib\include\music.h" />
<ClInclude Include="source\jaudiolib\src\pitch.h" />
<ClInclude Include="source\jaudiolib\include\sndcards.h" />
<ClInclude Include="source\jmact\_control.h" />
<ClInclude Include="source\jmact\_scrplib.h" />
<ClInclude Include="source\jmact\animlib.h" />

9
polymer/eduke32/eduke32.vcxproj.filters
View file

@ -243,9 +243,6 @@
<ClInclude Include="source\jaudiolib\src\driver_sdl.h">
<Filter>jaudiolib\headers</Filter>
</ClInclude>
<ClInclude Include="source\jaudiolib\src\drivers.h">
<Filter>jaudiolib\headers</Filter>
</ClInclude>
<ClInclude Include="source\jaudiolib\include\fx_man.h">
<Filter>jaudiolib\headers</Filter>
</ClInclude>
@ -264,9 +261,6 @@
<ClInclude Include="source\jaudiolib\src\pitch.h">
<Filter>jaudiolib\headers</Filter>
</ClInclude>
<ClInclude Include="source\jaudiolib\include\sndcards.h">
<Filter>jaudiolib\headers</Filter>
</ClInclude>
<ClInclude Include="source\jmact\_control.h">
<Filter>jmact\headers</Filter>
</ClInclude>
@ -516,6 +510,9 @@
<ClInclude Include="build\include\jwzglesI.h">
<Filter>build\headers</Filter>
</ClInclude>
<ClInclude Include="source\jaudiolib\include\drivers.h">
<Filter>jaudiolib\headers</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<ClCompile Include="build\src\a-c.c">

7
polymer/eduke32/source/jaudiolib/include/drivers.h
View file

@ -26,8 +26,11 @@
typedef enum
{
ASS_NoSound,
ASS_SDL,
#if defined HAVE_DS
ASS_DirectSound,
#elif defined HAVE_SDL
ASS_SDL,
#endif
ASS_NumSoundCards,
ASS_AutoDetect = -2
} soundcardnames;
@ -38,7 +41,7 @@ int32_t SoundDriver_IsSupported(int32_t driver);
int32_t SoundDriver_GetError(void);
const char *SoundDriver_ErrorString(int32_t ErrorNumber);
int32_t SoundDriver_Init(int32_t *mixrate, int32_t *numchannels, int32_t *samplebits, void *initdata);
int32_t SoundDriver_Init(int32_t *mixrate, int32_t *numchannels, void *initdata);
void SoundDriver_Shutdown(void);
int32_t SoundDriver_BeginPlayback(char *BufferStart, int32_t BufferSize, int32_t NumDivisions, void(*CallBackFunc)(void));
void SoundDriver_StopPlayback(void);

3
polymer/eduke32/source/jaudiolib/include/fx_man.h
View file

@ -57,8 +57,7 @@ enum FX_LOOP_HOW
#define FX_MUSIC_PRIORITY INT_MAX
const char *FX_ErrorString(int32_t ErrorNumber);
int32_t FX_Init(int32_t SoundCard, int32_t numvoices, int32_t numchannels, int32_t samplebits, unsigned mixrate,
void *initdata);
int32_t FX_Init(int32_t SoundCard, int32_t numvoices, int32_t numchannels, unsigned mixrate, void *initdata);
int32_t FX_Shutdown(void);
void FX_SetCallBack(void(*function)(uint32_t));
void FX_SetVolume(int32_t volume);

35
polymer/eduke32/source/jaudiolib/src/_multivc.h
View file

@ -36,16 +36,9 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#include "multivoc.h"
#define VOC_8BIT 0x0
#define VOC_CT4_ADPCM 0x1
#define VOC_CT3_ADPCM 0x2
#define VOC_CT2_ADPCM 0x3
#define VOC_16BIT 0x4
#define VOC_ALAW 0x6
#define VOC_MULAW 0x7
#define VOC_CREATIVE_ADPCM 0x200
#define T_SIXTEENBIT_STEREO 0
#define T_8BITS 1
#define T_MONO 2
#define T_16BITSOURCE 4
#define T_STEREOSOURCE 8
@ -64,24 +57,6 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#define MIX_VOLUME(volume) ((max(0, min((volume), 255)) * (MV_MAXVOLUME + 1)) >> 8)
#define STEREO 1
#define SIXTEEN_BIT 2
#define MONO_8BIT 0
#define STEREO_8BIT ( STEREO )
#define MONO_16BIT ( SIXTEEN_BIT )
#define STEREO_16BIT ( STEREO | SIXTEEN_BIT )
#define MONO_8BIT_SAMPLE_SIZE 1
#define MONO_16BIT_SAMPLE_SIZE 2
#define STEREO_8BIT_SAMPLE_SIZE ( 2 * MONO_8BIT_SAMPLE_SIZE )
#define STEREO_16BIT_SAMPLE_SIZE ( 2 * MONO_16BIT_SAMPLE_SIZE )
//#define SILENCE_16BIT 0x80008000
#define SILENCE_16BIT 0
#define SILENCE_8BIT 0x80808080
//#define SILENCE_16BIT_PAS 0
#define MV_MIXBUFFERSIZE 256
#define MV_NUMBEROFBUFFERS 16
#define MV_TOTALBUFFERSIZE ( MV_MIXBUFFERSIZE * MV_NUMBEROFBUFFERS )
@ -200,28 +175,18 @@ void MV_ReleaseFLACVoice(VoiceNode *voice);
void MV_ReleaseXAVoice(VoiceNode *voice);
// implemented in mix.c
void MV_Mix8BitMono(uint32_t position, uint32_t rate, const char *start, uint32_t length);
void MV_Mix8BitStereo(uint32_t position, uint32_t rate, const char *start, uint32_t length);
void MV_Mix16BitMono(uint32_t position, uint32_t rate, const char *start, uint32_t length);
void MV_Mix16BitStereo(uint32_t position, uint32_t rate, const char *start, uint32_t length);
void MV_Mix16BitMono16(uint32_t position, uint32_t rate, const char *start, uint32_t length);
void MV_Mix8BitMono16(uint32_t position, uint32_t rate, const char *start, uint32_t length);
void MV_Mix8BitStereo16(uint32_t position, uint32_t rate, const char *start, uint32_t length);
void MV_Mix16BitStereo16(uint32_t position, uint32_t rate, const char *start, uint32_t length);
void MV_16BitReverb( char const *src, char *dest, int16_t *volume, int32_t count );
void MV_8BitReverb( int8_t *src, int8_t *dest, int16_t *volume, int32_t count );
// implemented in mixst.c
void MV_Mix8BitMono8Stereo(uint32_t position, uint32_t rate, const char *start, uint32_t length);
void MV_Mix8BitStereo8Stereo(uint32_t position, uint32_t rate, const char *start, uint32_t length);
void MV_Mix16BitMono8Stereo(uint32_t position, uint32_t rate, const char *start, uint32_t length);
void MV_Mix16BitStereo8Stereo(uint32_t position, uint32_t rate, const char *start, uint32_t length);
void MV_Mix16BitMono16Stereo(uint32_t position, uint32_t rate, const char *start, uint32_t length);
void MV_Mix8BitMono16Stereo(uint32_t position, uint32_t rate, const char *start, uint32_t length);
void MV_Mix8BitStereo16Stereo(uint32_t position, uint32_t rate, const char *start, uint32_t length);
void MV_Mix16BitStereo16Stereo(uint32_t position, uint32_t rate, const char *start, uint32_t length);
extern char *MV_HarshClipTable;
extern char *MV_MixDestination; // pointer to the next output sample
extern uint32_t MV_MixPosition; // return value of where the source pointer got to
extern const int16_t *MV_LeftVolume;

4
polymer/eduke32/source/jaudiolib/src/driver_directsound.c
View file

@ -300,7 +300,7 @@ static void TeardownDSound(HRESULT err)
lpds = NULL;
}
int32_t DirectSoundDrv_PCM_Init(int32_t *mixrate, int32_t *numchannels, int32_t *samplebits, void * initdata)
int32_t DirectSoundDrv_PCM_Init(int32_t *mixrate, int32_t *numchannels, void * initdata)
{
HRESULT err;
DSBUFFERDESC bufdesc;
@ -341,7 +341,7 @@ int32_t DirectSoundDrv_PCM_Init(int32_t *mixrate, int32_t *numchannels, int32_t
wfex.wFormatTag = WAVE_FORMAT_PCM;
wfex.nChannels = *numchannels;
wfex.nSamplesPerSec = *mixrate;
wfex.wBitsPerSample = *samplebits;
wfex.wBitsPerSample = 16;
wfex.nBlockAlign = wfex.nChannels * wfex.wBitsPerSample / 8;
wfex.nAvgBytesPerSec = wfex.nSamplesPerSec * wfex.nBlockAlign;

2
polymer/eduke32/source/jaudiolib/src/driver_directsound.h
View file

@ -22,7 +22,7 @@
int32_t DirectSoundDrv_GetError(void);
const char *DirectSoundDrv_ErrorString( int32_t ErrorNumber );
int32_t DirectSoundDrv_PCM_Init(int32_t *mixrate, int32_t *numchannels, int32_t *samplebits, void * initdata);
int32_t DirectSoundDrv_PCM_Init(int32_t *mixrate, int32_t *numchannels, void * initdata);
void DirectSoundDrv_PCM_Shutdown(void);
int32_t DirectSoundDrv_PCM_BeginPlayback(char *BufferStart, int32_t BufferSize,
int32_t NumDivisions, void ( *CallBackFunc )( void ) );

3
polymer/eduke32/source/jaudiolib/src/driver_nosound.c
View file

@ -40,11 +40,10 @@ const char *NoSoundDrv_ErrorString( int32_t ErrorNumber )
return "No sound, Ok.";
}
int32_t NoSoundDrv_PCM_Init(int32_t *mixrate, int32_t *numchannels, int32_t *samplebits, void * initdata)
int32_t NoSoundDrv_PCM_Init(int32_t *mixrate, int32_t *numchannels, void * initdata)
{
UNREFERENCED_PARAMETER(mixrate);
UNREFERENCED_PARAMETER(numchannels);
UNREFERENCED_PARAMETER(samplebits);
UNREFERENCED_PARAMETER(initdata);
return 0;
}

2
polymer/eduke32/source/jaudiolib/src/driver_nosound.h
View file

@ -21,7 +21,7 @@
int NoSoundDrv_GetError(void);
const char *NoSoundDrv_ErrorString( int ErrorNumber );
int NoSoundDrv_PCM_Init(int *mixrate, int *numchannels, int *samplebits, void * initdata);
int NoSoundDrv_PCM_Init(int *mixrate, int *numchannels, void * initdata);
void NoSoundDrv_PCM_Shutdown(void);
int NoSoundDrv_PCM_BeginPlayback(char *BufferStart, int BufferSize,
int NumDivisions, void ( *CallBackFunc )( void ) );

12
polymer/eduke32/source/jaudiolib/src/driver_sdl.c
View file

@ -143,7 +143,7 @@ const char *SDLDrv_ErrorString( int32_t ErrorNumber )
return ErrorString;
}
int32_t SDLDrv_PCM_Init(int32_t *mixrate, int32_t *numchannels, int32_t *samplebits, void * initdata)
int32_t SDLDrv_PCM_Init(int32_t *mixrate, int32_t *numchannels, void * initdata)
{
int32_t err = 0;
int32_t chunksize;
@ -164,17 +164,21 @@ int32_t SDLDrv_PCM_Init(int32_t *mixrate, int32_t *numchannels, int32_t *sampleb
if (*mixrate >= 16000) chunksize *= 2;
if (*mixrate >= 32000) chunksize *= 2;
err = Mix_OpenAudio(*mixrate, (*samplebits == 8) ? AUDIO_U8 : AUDIO_S16SYS, *numchannels, chunksize);
err = Mix_OpenAudio(*mixrate, AUDIO_S16SYS, *numchannels, chunksize);
if (err < 0) {
ErrorCode = SDLErr_OpenAudio;
return SDLErr_Error;
}
if (Mix_QuerySpec(mixrate, &fmt, numchannels))
{
if (fmt == AUDIO_U8 || fmt == AUDIO_S8) *samplebits = 8;
else *samplebits = 16;
if (fmt == AUDIO_U8 || fmt == AUDIO_S8)
{
ErrorCode = SDLErr_OpenAudio;
return SDLErr_Error;
}
}
//Mix_SetPostMix(fillData, NULL);

2
polymer/eduke32/source/jaudiolib/src/driver_sdl.h
View file

@ -21,7 +21,7 @@
int32_t SDLDrv_GetError(void);
const char *SDLDrv_ErrorString( int32_t ErrorNumber );
int32_t SDLDrv_PCM_Init(int32_t *mixrate, int32_t *numchannels, int32_t *samplebits, void * initdata);
int32_t SDLDrv_PCM_Init(int32_t *mixrate, int32_t *numchannels, void * initdata);
void SDLDrv_PCM_Shutdown(void);
int32_t SDLDrv_PCM_BeginPlayback(char *BufferStart, int32_t BufferSize,
int32_t NumDivisions, void ( *CallBackFunc )( void ) );

38
polymer/eduke32/source/jaudiolib/src/drivers.c
View file

@ -27,12 +27,10 @@
#include "driver_nosound.h"
#ifdef HAVE_SDL
# include "driver_sdl.h"
#endif
#ifdef HAVE_DS
#if defined HAVE_DS
# include "driver_directsound.h"
#elif defined HAVE_SDL
# include "driver_sdl.h"
#endif
int32_t ASS_SoundDriver = -1;
@ -43,7 +41,7 @@ static struct
{
int32_t (*GetError)(void);
const char *(*ErrorString)(int32_t);
int32_t (*Init)(int32_t *, int32_t *, int32_t *, void *);
int32_t (*Init)(int32_t *, int32_t *, void *);
void (*Shutdown)(void);
int32_t (*BeginPlayback)(char *, int32_t, int32_t, void (*)(void));
void (*StopPlayback)(void);
@ -57,32 +55,24 @@ static struct
NoSoundDrv_PCM_BeginPlayback, NoSoundDrv_PCM_StopPlayback, NoSoundDrv_PCM_Lock, NoSoundDrv_PCM_Unlock,
},
// Simple DirectMedia Layer
#ifdef HAVE_SDL
{
SDLDrv_GetError, SDLDrv_ErrorString, SDLDrv_PCM_Init, SDLDrv_PCM_Shutdown,
SDLDrv_PCM_BeginPlayback, SDLDrv_PCM_StopPlayback, SDLDrv_PCM_Lock, SDLDrv_PCM_Unlock,
},
#else
UNSUPPORTED
#endif
// Windows DirectSound
#ifdef HAVE_DS
#if defined HAVE_DS
{
DirectSoundDrv_GetError, DirectSoundDrv_ErrorString, DirectSoundDrv_PCM_Init, DirectSoundDrv_PCM_Shutdown,
DirectSoundDrv_PCM_BeginPlayback, DirectSoundDrv_PCM_StopPlayback, DirectSoundDrv_PCM_Lock,
DirectSoundDrv_PCM_Unlock,
},
#else
UNSUPPORTED
#endif
// Simple DirectMedia Layer
#elif defined HAVE_SDL
{
SDLDrv_GetError, SDLDrv_ErrorString, SDLDrv_PCM_Init, SDLDrv_PCM_Shutdown,
SDLDrv_PCM_BeginPlayback, SDLDrv_PCM_StopPlayback, SDLDrv_PCM_Lock, SDLDrv_PCM_Unlock,
},
#endif
};
int32_t SoundDriver_IsSupported(int32_t driver) { return (SoundDrivers[driver].GetError != 0); }
int32_t SoundDriver_GetError(void)
{
return SoundDriver_IsSupported(ASS_SoundDriver) ? SoundDrivers[ASS_SoundDriver].GetError() : -1;
@ -99,9 +89,9 @@ const char * SoundDriver_ErrorString( int32_t ErrorNumber )
return SoundDrivers[ASS_SoundDriver].ErrorString(ErrorNumber);
}
int32_t SoundDriver_Init(int32_t *mixrate, int32_t *numchannels, int32_t *samplebits, void *initdata)
int32_t SoundDriver_Init(int32_t *mixrate, int32_t *numchannels, void *initdata)
{
return SoundDrivers[ASS_SoundDriver].Init(mixrate, numchannels, samplebits, initdata);
return SoundDrivers[ASS_SoundDriver].Init(mixrate, numchannels, initdata);
}
void SoundDriver_Shutdown(void) { SoundDrivers[ASS_SoundDriver].Shutdown(); }

4
polymer/eduke32/source/jaudiolib/src/flac.c
View file

@ -665,6 +665,10 @@ void MV_ReleaseFLACVoice(VoiceNode *voice)
voice->rawdataptr = 0;
}
#else
#include <stdlib.h>
#include <stdio.h>
#include "_multivc.h"
int32_t MV_PlayFLAC(char *ptr, uint32_t ptrlength, int32_t loopstart, int32_t loopend, int32_t pitchoffset,
int32_t vol, int32_t left, int32_t right, int32_t priority, uint32_t callbackval)
{

4
polymer/eduke32/source/jaudiolib/src/fx_man.c
View file

@ -75,7 +75,7 @@ static inline int32_t FX_CheckMVErr(int32_t status)
return status;
}
int32_t FX_Init(int32_t SoundCard, int32_t numvoices, int32_t numchannels, int32_t samplebits, unsigned mixrate, void *initdata)
int32_t FX_Init(int32_t SoundCard, int32_t numvoices, int32_t numchannels, unsigned mixrate, void *initdata)
{
if (FX_Installed)
FX_Shutdown();
@ -106,7 +106,7 @@ int32_t FX_Init(int32_t SoundCard, int32_t numvoices, int32_t numchannels, int32
int status = FX_Ok;
if (MV_Init(SoundCard, mixrate, numvoices, numchannels, samplebits, initdata) != MV_Ok)
if (MV_Init(SoundCard, mixrate, numvoices, numchannels, initdata) != MV_Ok)
{
FX_SetErrorCode(FX_MultiVocError);
status = FX_Error;

110
polymer/eduke32/source/jaudiolib/src/mix.c
View file

@ -29,56 +29,6 @@
length = count of samples to mix
*/
// 8-bit mono source, 8-bit mono output
void MV_Mix8BitMono(uint32_t position, uint32_t rate, const char *start, uint32_t length)
{
uint8_t const * const source = (uint8_t *) start;
uint8_t *dest = (uint8_t *) MV_MixDestination;
int32_t sample0;
while (length--) {
sample0 = source[position >> 16];
position += rate;
sample0 = MV_LeftVolume[sample0] + *dest;
sample0 = MV_HarshClipTable[sample0 + 128];
*dest = sample0 & 255;
dest += MV_SampleSize;
}
MV_MixPosition = position;
MV_MixDestination = (char *) dest;
}
// 8-bit mono source, 8-bit stereo output
void MV_Mix8BitStereo(uint32_t position, uint32_t rate, const char *start, uint32_t length)
{
uint8_t const * const source = (uint8_t *) start;
uint8_t *dest = (uint8_t *) MV_MixDestination;
int32_t sample0, sample1;
while (length--) {
sample0 = source[position >> 16];
sample1 = sample0;
position += rate;
sample0 = MV_LeftVolume[sample0] + *dest;
sample1 = MV_RightVolume[sample1] + *(dest + MV_RightChannelOffset);
sample0 = MV_HarshClipTable[sample0 + 128];
sample1 = MV_HarshClipTable[sample1 + 128];
*dest = sample0 & 255;
*(dest + MV_RightChannelOffset) = sample1 & 255;
dest += MV_SampleSize;
}
MV_MixPosition = position;
MV_MixDestination = (char *) dest;
}
// 8-bit mono source, 16-bit mono output
void MV_Mix16BitMono(uint32_t position, uint32_t rate, const char *start, uint32_t length)
{
@ -165,56 +115,6 @@ void MV_Mix16BitMono16(uint32_t position, uint32_t rate, const char *start, uint
MV_MixDestination = (char *) dest;
}
// 16-bit mono source, 8-bit mono output
void MV_Mix8BitMono16(uint32_t position, uint32_t rate, const char *start, uint32_t length)
{
int8_t const * const source = (int8_t *) start + 1;
uint8_t *dest = (uint8_t *) MV_MixDestination;
int32_t sample0;
while (length--) {
sample0 = source[(position >> 16) << 1];
position += rate;
sample0 = MV_LeftVolume[sample0 + 128] + *dest;
sample0 = MV_HarshClipTable[sample0 + 128];
*dest = sample0 & 255;
dest += MV_SampleSize;
}
MV_MixPosition = position;
MV_MixDestination = (char *) dest;
}
// 16-bit mono source, 8-bit stereo output
void MV_Mix8BitStereo16(uint32_t position, uint32_t rate, const char *start, uint32_t length)
{
int8_t const * const source = (int8_t *) start + 1;
uint8_t *dest = (uint8_t *) MV_MixDestination;
int32_t sample0, sample1;
while (length--) {
sample0 = source[(position >> 16) << 1];
sample1 = sample0;
position += rate;
sample0 = MV_LeftVolume[sample0 + 128] + *dest;
sample1 = MV_RightVolume[sample1 + 128] + *(dest + MV_RightChannelOffset);
sample0 = MV_HarshClipTable[sample0 + 128];
sample1 = MV_HarshClipTable[sample1 + 128];
*dest = sample0 & 255;
*(dest + MV_RightChannelOffset) = sample1 & 255;
dest += MV_SampleSize;
}
MV_MixPosition = position;
MV_MixDestination = (char *) dest;
}
// 16-bit mono source, 16-bit stereo output
void MV_Mix16BitStereo16(uint32_t position, uint32_t rate, const char *start, uint32_t length)
{
@ -278,13 +178,3 @@ void MV_16BitReverb(char const *src, char *dest, int16_t *volume, int32_t count)
*output++ = (int16_t) (sample0l + sample0h + 128);
} while (--count > 0);
}
void MV_8BitReverb(int8_t *src, int8_t *dest, int16_t *volume, int32_t count)
{
uint8_t const * input = (uint8_t *) src;
uint8_t * output = (uint8_t *) dest;
do {
*output++ = ((int16_t *) volume)[*input++] + 128;
} while (--count > 0);
}

104
polymer/eduke32/source/jaudiolib/src/mixst.c
View file

@ -30,57 +30,6 @@
length = count of samples to mix
*/
// 8-bit stereo source, 8-bit mono output
void MV_Mix8BitMono8Stereo(uint32_t position, uint32_t rate, const char *start, uint32_t length)
{
uint8_t const * const source = (uint8_t *) start;
uint8_t *dest = (uint8_t *) MV_MixDestination;
int32_t sample0, sample1;
while (length--) {
sample0 = source[(position >> 16) << 1];
sample1 = source[((position >> 16) << 1) + 1];
position += rate;
sample0 = (MV_LeftVolume[sample0] + MV_LeftVolume[sample1]) / 2 + *dest;
sample0 = MV_HarshClipTable[sample0 + 128];
*dest = sample0 & 255;
dest += MV_SampleSize;
}
MV_MixPosition = position;
MV_MixDestination = (char *) dest;
}
// 8-bit stereo source, 8-bit stereo output
void MV_Mix8BitStereo8Stereo(uint32_t position, uint32_t rate, const char *start, uint32_t length)
{
uint8_t const * const source = (uint8_t *) start;
uint8_t *dest = (uint8_t *) MV_MixDestination;
int32_t sample0, sample1;
while (length--) {
sample0 = source[(position >> 16) << 1];
sample1 = source[((position >> 16) << 1) + 1];
position += rate;
sample0 = MV_LeftVolume[sample0] + *dest;
sample1 = MV_RightVolume[sample1] + *(dest + MV_RightChannelOffset);
sample0 = MV_HarshClipTable[sample0 + 128];
sample1 = MV_HarshClipTable[sample1 + 128];
*dest = sample0 & 255;
*(dest + MV_RightChannelOffset) = sample1 & 255;
dest += MV_SampleSize;
}
MV_MixPosition = position;
MV_MixDestination = (char *) dest;
}
// 8-bit stereo source, 16-bit mono output
void MV_Mix16BitMono8Stereo(uint32_t position, uint32_t rate, const char *start, uint32_t length)
{
@ -179,59 +128,6 @@ void MV_Mix16BitMono16Stereo(uint32_t position, uint32_t rate, const char *start
MV_MixDestination = (char *) dest;
}
// 16-bit stereo source, 8-bit mono output
void MV_Mix8BitMono16Stereo(uint32_t position, uint32_t rate, const char *start, uint32_t length)
{
int8_t const * const source = (int8_t *) start + 1;
uint8_t *dest = (uint8_t *) MV_MixDestination;
int32_t sample0, sample1;
while (length--) {
sample0 = source[(position >> 16) << 2];
sample1 = source[((position >> 16) << 2) + 2];
position += rate;
sample0 = MV_LeftVolume[sample0 + 128];
sample1 = MV_LeftVolume[sample1 + 128];
sample0 = (sample0 + sample1) / 2 + *dest;
sample0 = MV_HarshClipTable[sample0 + 128];
*dest = sample0 & 255;
dest += MV_SampleSize;
}
MV_MixPosition = position;
MV_MixDestination = (char *) dest;
}
// 16-bit stereo source, 8-bit stereo output
void MV_Mix8BitStereo16Stereo(uint32_t position, uint32_t rate, const char *start, uint32_t length)
{
int8_t const * const source = (int8_t *) start + 1;
uint8_t *dest = (uint8_t *) MV_MixDestination;
int32_t sample0, sample1;
while (length--) {
sample0 = source[(position >> 16) << 2];
sample1 = source[((position >> 16) << 2) + 2];
position += rate;
sample0 = MV_LeftVolume[sample0 + 128] + *dest;
sample1 = MV_RightVolume[sample1 + 128] + *(dest + MV_RightChannelOffset);
sample0 = MV_HarshClipTable[sample0 + 128];
sample1 = MV_HarshClipTable[sample1 + 128];
*dest = sample0 & 255;
*(dest + MV_RightChannelOffset) = sample1 & 255;
dest += MV_SampleSize;
}
MV_MixPosition = position;
MV_MixDestination = (char *) dest;
}
// 16-bit stereo source, 16-bit stereo output
void MV_Mix16BitStereo16Stereo(uint32_t position, uint32_t rate, const char *start, uint32_t length)
{

182
polymer/eduke32/source/jaudiolib/src/multivoc.c
View file

@ -52,7 +52,6 @@ static VoiceNode *MV_GetVoice(int32_t handle);
static const int16_t *MV_GetVolumeTable(int32_t vol);
static void MV_CalcVolume(int32_t MaxLevel);
static void MV_CalcPanTable(void);
#define IS_QUIET(ptr) ((void *)(ptr) == (void *)&MV_VolumeTable[0])
@ -74,15 +73,11 @@ static int32_t MV_BufferLength;
static int32_t MV_NumberOfBuffers = MV_NUMBEROFBUFFERS;
static int32_t MV_Channels = 1;
static int32_t MV_Bits = 8;
static int32_t MV_Silence = SILENCE_8BIT;
static int32_t MV_SwapLeftRight = FALSE;
static int32_t MV_ReverseStereo = FALSE;
int32_t MV_MixRate;
// static int32_t MV_BuffShift;
static int32_t MV_BufferEmpty[MV_NUMBEROFBUFFERS];
char *MV_MixBuffer[MV_NUMBEROFBUFFERS + 1];
@ -95,9 +90,7 @@ static int32_t MV_MixPage = 0;
void (*MV_Printf)(const char *fmt, ...) = NULL;
static void (*MV_CallBackFunc)(uint32_t) = NULL;
static void (*MV_MixFunction)(VoiceNode *voice, int32_t buffer);
char *MV_HarshClipTable;
char *MV_MixDestination;
const int16_t *MV_LeftVolume;
const int16_t *MV_RightVolume;
@ -122,15 +115,6 @@ static inline void RestoreInterrupts(void)
SoundDriver_Unlock();
}
static inline void ClearBuffer_DW(void *ptr, unsigned data, int32_t length)
{
unsigned *ptrdw = (unsigned *)ptr;
while (length--)
{
*(ptrdw++) = data;
}
}
const char *MV_ErrorString(int32_t ErrorNumber)
{
switch (ErrorNumber)
@ -168,7 +152,7 @@ static void MV_Mix(VoiceNode *voice, int32_t buffer)
{
/* cheap fix for a crash under 64-bit linux */
/* v v v v */
if (voice->length == 0 && (!voice->GetSound || voice->GetSound(voice) != KeepPlaying))
if (voice->length == 0 && (voice->GetSound == NULL || voice->GetSound(voice) != KeepPlaying))
return;
int32_t length = MV_MIXBUFFERSIZE;
@ -282,7 +266,7 @@ static void MV_ServiceVoc(void)
//buffer even when no sounds are playing.
if (!MV_BufferEmpty[MV_MixPage])
{
ClearBuffer_DW(MV_MixBuffer[ MV_MixPage ], MV_Silence, MV_BufferSize >> 2);
Bmemset(MV_MixBuffer[MV_MixPage], 0, MV_BufferSize);
MV_BufferEmpty[ MV_MixPage ] = TRUE;
}
}
@ -301,10 +285,7 @@ static void MV_ServiceVoc(void)
{
int const count = (source + length > end) ? (end - source) : length;
if (MV_Bits == 16)
MV_16BitReverb(source, dest, MV_ReverbTable, count / 2);
else // if (MV_Bits == 8)
MV_8BitReverb((int8_t *) source, (int8_t *) dest, MV_ReverbTable, count);
MV_16BitReverb(source, dest, MV_ReverbTable, count / 2);
// if we go through the loop again, it means that we've wrapped around the buffer
source = MV_MixBuffer[ 0 ];
@ -337,7 +318,7 @@ static void MV_ServiceVoc(void)
MV_BufferEmpty[ MV_MixPage ] = FALSE;
MV_MixFunction(voice, MV_MixPage);
MV_Mix(voice, MV_MixPage);
// Is this voice done?
if (!voice->Playing)
@ -606,37 +587,25 @@ static const inline int16_t *MV_GetVolumeTable(int32_t vol) { return MV_VolumeTa
Selects which method should be used to mix the voice.
8Bit 16Bit 8Bit 16Bit | 8Bit 16Bit 8Bit 16Bit |
Mono Mono Ster Ster | Mono Mono Ster Ster | Mixer
Out Out Out Out | In In In In |
--------------------------+---------------------------+-------------
X | X | Mix8BitMono16
X | X | Mix8BitMono
X | X | Mix8BitStereo16
X | X | Mix8BitStereo
X | X | Mix16BitMono16
X | X | Mix16BitMono
X | X | Mix16BitStereo16
X | X | Mix16BitStereo
--------------------------+---------------------------+-------------
X | X | Mix16BitStereo16Stereo
X | X | Mix16BitStereo8Stereo
X | X | Mix8BitStereo16Stereo
X | X | Mix8BitStereo8Stereo
X | X | Mix16BitMono16Stereo
X | X | Mix16BitMono8Stereo
X | X | Mix8BitMono16Stereo
X | X | Mix8BitMono8Stereo
16Bit 16Bit | 8Bit 16Bit 8Bit 16Bit |
Mono Ster | Mono Mono Ster Ster | Mixer
Out Out | In In In In |
----------------------+---------------------------+-------------
X | X | Mix16BitMono16
X | X | Mix16BitMono
X | X | Mix16BitStereo16
X | X | Mix16BitStereo
----------------------+---------------------------+-------------
X | X | Mix16BitStereo16Stereo
X | X | Mix16BitStereo8Stereo
X | X | Mix16BitMono16Stereo
X | X | Mix16BitMono8Stereo
---------------------------------------------------------------------*/
void MV_SetVoiceMixMode(VoiceNode *voice)
{
int32_t type = T_DEFAULT;
if (MV_Bits == 8)
type |= T_8BITS;
if (MV_Channels == 1)
type |= T_MONO;
else
@ -658,18 +627,6 @@ void MV_SetVoiceMixMode(VoiceNode *voice)
switch (type)
{
case T_8BITS | T_16BITSOURCE | T_LEFTQUIET: MV_LeftVolume = MV_RightVolume;
case T_8BITS | T_16BITSOURCE | T_MONO:
case T_8BITS | T_16BITSOURCE | T_RIGHTQUIET: voice->mix = MV_Mix8BitMono16; break;
case T_8BITS | T_LEFTQUIET: MV_LeftVolume = MV_RightVolume;
case T_8BITS | T_MONO:
case T_8BITS | T_RIGHTQUIET: voice->mix = MV_Mix8BitMono; break;
case T_8BITS | T_16BITSOURCE: voice->mix = MV_Mix8BitStereo16; break;
case T_8BITS: voice->mix = MV_Mix8BitStereo; break;
case T_16BITSOURCE | T_LEFTQUIET: MV_LeftVolume = MV_RightVolume;
case T_16BITSOURCE | T_MONO:
case T_16BITSOURCE | T_RIGHTQUIET: voice->mix = MV_Mix16BitMono16; break;
@ -684,20 +641,12 @@ void MV_SetVoiceMixMode(VoiceNode *voice)
case T_16BITSOURCE | T_STEREOSOURCE: voice->mix = MV_Mix16BitStereo16Stereo; break;
case T_16BITSOURCE | T_STEREOSOURCE | T_8BITS: voice->mix = MV_Mix8BitStereo16Stereo; break;
case T_16BITSOURCE | T_STEREOSOURCE | T_MONO: voice->mix = MV_Mix16BitMono16Stereo; break;
case T_16BITSOURCE | T_STEREOSOURCE | T_8BITS | T_MONO: voice->mix = MV_Mix8BitMono16Stereo; break;
case T_STEREOSOURCE: voice->mix = MV_Mix16BitStereo8Stereo; break;
case T_STEREOSOURCE | T_8BITS: voice->mix = MV_Mix8BitStereo8Stereo; break;
case T_STEREOSOURCE | T_MONO: voice->mix = MV_Mix16BitMono8Stereo; break;
case T_STEREOSOURCE | T_8BITS | T_MONO: voice->mix = MV_Mix8BitMono8Stereo; break;
default: voice->mix = NULL; break;
}
}
@ -715,7 +664,7 @@ void MV_SetVoiceVolume(VoiceNode *voice, int32_t vol, int32_t left, int32_t righ
{
voice->RightVolume = MV_GetVolumeTable(right);
if (MV_SwapLeftRight)
if (MV_ReverseStereo)
swapptr(&voice->LeftVolume, &voice->RightVolume);
}
@ -843,33 +792,13 @@ void MV_SetReverbDelay(int32_t delay)
MV_ReverbDelay = max(MV_MIXBUFFERSIZE, min(delay, MV_GetMaxReverbDelay())) * MV_SampleSize;
}
static int32_t MV_SetMixMode(int32_t numchannels, int32_t samplebits)
static int32_t MV_SetMixMode(int32_t numchannels)
{
if (!MV_Installed)
return MV_Error;
int32_t mode = 0;
if (numchannels == 2)
mode |= STEREO;
if (samplebits == 16)
mode |= SIXTEEN_BIT;
MV_Channels = 1 + (mode & STEREO);
MV_SampleSize = sizeof(int8_t) * MV_Channels;
if (mode & SIXTEEN_BIT)
{
MV_Bits = 16;
MV_Silence = SILENCE_16BIT;
MV_SampleSize <<= 1;
}
else
{
MV_Bits = 8;
MV_Silence = SILENCE_8BIT;
}
MV_Channels = 1 + (numchannels == 2);
MV_SampleSize = sizeof(int8_t) * MV_Channels * 2;
MV_BufferSize = MV_MIXBUFFERSIZE * MV_SampleSize;
MV_NumberOfBuffers = MV_TOTALBUFFERSIZE / MV_BufferSize;
@ -883,18 +812,14 @@ static int32_t MV_SetMixMode(int32_t numchannels, int32_t samplebits)
static int32_t MV_StartPlayback(void)
{
// Initialize the buffers
ClearBuffer_DW(MV_MixBuffer[ 0 ], MV_Silence, MV_TOTALBUFFERSIZE >> 2);
Bmemset(MV_MixBuffer[0], 0, MV_TOTALBUFFERSIZE);
for (int buffer = 0; buffer < MV_NumberOfBuffers; buffer++)
MV_BufferEmpty[ buffer ] = TRUE;
MV_BufferEmpty[buffer] = TRUE;
MV_MixPage = 1;
MV_MixFunction = MV_Mix;
int status = SoundDriver_BeginPlayback(MV_MixBuffer[0], MV_BufferSize, MV_NumberOfBuffers, MV_ServiceVoc);
if (status != MV_Ok)
if (SoundDriver_BeginPlayback(MV_MixBuffer[0], MV_BufferSize, MV_NumberOfBuffers, MV_ServiceVoc) != MV_Ok)
{
MV_SetErrorCode(MV_DriverError);
return MV_Error;
@ -925,38 +850,18 @@ static void MV_StopPlayback(void)
RestoreInterrupts();
}
static void MV_CreateVolumeTable(int32_t index, int32_t volume, int32_t MaxVolume)
{
int const level = (volume * MaxVolume) / MV_MAXTOTALVOLUME;
if (MV_Bits == 16)
{
for (int i = 0; i < 65536; i += 256)
MV_VolumeTable[ index ][ i / 256 ] = ((i - 0x8000) * level) / MV_MAXVOLUME;
}
else
{
for (int i = 0; i < 256; i++)
MV_VolumeTable[ volume ][ i ] = ((i - 0x80) * level) / MV_MAXVOLUME;
}
}
static void MV_CalcVolume(int32_t MaxVolume)
{
for (int volume = 0; volume < 128; volume++)
{
MV_HarshClipTable[volume] = 0;
MV_HarshClipTable[volume + 384] = 255;
}
for (int volume = 0; volume < 256; volume++)
MV_HarshClipTable[volume + 128] = volume;
// For each volume level, create a translation table with the
// appropriate volume calculated.
for (int volume = 0; volume <= MV_MAXVOLUME; volume++)
MV_CreateVolumeTable(volume, volume, MaxVolume);
{
int const level = (volume * MaxVolume) / MV_MAXTOTALVOLUME;
for (int i = 0; i < 65536; i += 256)
MV_VolumeTable[volume][i / 256] = ((i - 0x8000) * level) / MV_MAXVOLUME;
}
}
static void MV_CalcPanTable(void)
@ -997,11 +902,11 @@ int32_t MV_GetVolume(void) { return MV_TotalVolume; }
void MV_SetCallBack(void (*function)(uint32_t)) { MV_CallBackFunc = function; }
void MV_SetReverseStereo(int32_t setting) { MV_SwapLeftRight = setting; }
void MV_SetReverseStereo(int32_t setting) { MV_ReverseStereo = setting; }
int32_t MV_GetReverseStereo(void) { return MV_SwapLeftRight; }
int32_t MV_GetReverseStereo(void) { return MV_ReverseStereo; }
int32_t MV_Init(int32_t soundcard, int32_t MixRate, int32_t Voices, int32_t numchannels, int32_t samplebits, void *initdata)
int32_t MV_Init(int32_t soundcard, int32_t MixRate, int32_t Voices, int32_t numchannels, void *initdata)
{
if (MV_Installed)
MV_Shutdown();
@ -1009,7 +914,7 @@ int32_t MV_Init(int32_t soundcard, int32_t MixRate, int32_t Voices, int32_t numc
MV_SetErrorCode(MV_Ok);
// MV_TotalMemory + 2: FIXME, see valgrind_errors.log
int const totalmem = Voices * sizeof(VoiceNode) + sizeof(HARSH_CLIP_TABLE_8) + MV_TOTALBUFFERSIZE + 2;
int const totalmem = Voices * sizeof(VoiceNode) + MV_TOTALBUFFERSIZE + 2;
char *ptr = (char *) Xaligned_alloc(16, totalmem);
@ -1024,9 +929,6 @@ int32_t MV_Init(int32_t soundcard, int32_t MixRate, int32_t Voices, int32_t numc
MV_Voices = (VoiceNode *)ptr;
ptr += Voices * sizeof(VoiceNode);
MV_HarshClipTable = ptr;
ptr += sizeof(HARSH_CLIP_TABLE_8);
// Set number of voices before calculating volume table
MV_MaxVoices = Voices;
@ -1043,19 +945,14 @@ int32_t MV_Init(int32_t soundcard, int32_t MixRate, int32_t Voices, int32_t numc
ASS_SoundDriver = soundcard;
// Initialize the sound card
int32_t status = SoundDriver_Init(&MixRate, &numchannels, &samplebits, initdata);
if (status != MV_Ok)
if (SoundDriver_Init(&MixRate, &numchannels, initdata) != MV_Ok)
MV_SetErrorCode(MV_DriverError);
if (MV_ErrorCode != MV_Ok)
{
status = MV_ErrorCode;
ALIGNED_FREE_AND_NULL(MV_Voices);
MV_HarshClipTable = NULL;
MV_SetErrorCode(status);
return MV_Error;
}
@ -1068,7 +965,7 @@ int32_t MV_Init(int32_t soundcard, int32_t MixRate, int32_t Voices, int32_t numc
MV_MixRate = MixRate;
// Set Mixer to play stereo digitized sound
MV_SetMixMode(numchannels, samplebits);
MV_SetMixMode(numchannels);
MV_ReverbDelay = MV_BufferSize * 3;
// Make sure we don't cross a physical page
@ -1085,11 +982,10 @@ int32_t MV_Init(int32_t soundcard, int32_t MixRate, int32_t Voices, int32_t numc
MV_SetVolume(MV_MAXTOTALVOLUME);
// Start the playback engine
status = MV_StartPlayback();
if (status != MV_Ok)
if (MV_StartPlayback() != MV_Ok)
{
// Preserve error code while we shutdown.
status = MV_ErrorCode;
int status = MV_ErrorCode;
MV_Shutdown();
MV_SetErrorCode(status);
return MV_Error;

2
polymer/eduke32/source/jaudiolib/src/multivoc.h
View file

@ -161,7 +161,7 @@ int32_t MV_GetVolume(void);
void MV_SetCallBack(void (*function)(uint32_t));
void MV_SetReverseStereo(int32_t setting);
int32_t MV_GetReverseStereo(void);
int32_t MV_Init(int32_t soundcard, int32_t MixRate, int32_t Voices, int32_t numchannels, int32_t samplebits,
int32_t MV_Init(int32_t soundcard, int32_t MixRate, int32_t Voices, int32_t numchannels,
void *initdata);
int32_t MV_Shutdown(void);
int32_t MV_SetVoiceCallback(int32_t handle, uint32_t callbackval);

4
polymer/eduke32/source/jaudiolib/src/vorbis.c
View file

@ -474,6 +474,10 @@ void MV_ReleaseVorbisVoice( VoiceNode * voice )
voice->rawdataptr = 0;
}
#else
#include <stdlib.h>
#include <stdio.h>
#include "_multivc.h"
int32_t MV_PlayVorbis(char *ptr, uint32_t ptrlength, int32_t loopstart, int32_t loopend, int32_t pitchoffset,
int32_t vol, int32_t left, int32_t right, int32_t priority, uint32_t callbackval)
{

15
polymer/eduke32/source/menus.c
View file

@ -958,7 +958,7 @@ static MenuEntry_t ME_SAVE_TEMPLATE = MAKE_MENUENTRY( NULL, &MF_MinifontRed, &ME
static MenuEntry_t ME_SAVE[MAXSAVEGAMES];
static MenuEntry_t *MEL_SAVE[MAXSAVEGAMES];
static int32_t soundrate, soundbits, soundvoices;
static int32_t soundrate, soundvoices;
static MenuOption_t MEO_SOUND = MAKE_MENUOPTION( &MF_Redfont, &MEOS_OffOn, &ud.config.SoundToggle );
static MenuEntry_t ME_SOUND = MAKE_MENUENTRY( "Sound:", &MF_Redfont, &MEF_BigOptionsRt, &MEO_SOUND, Option );
@ -983,12 +983,6 @@ static MenuOptionSet_t MEOS_SOUND_SAMPLINGRATE = MAKE_MENUOPTIONSET( MEOSN_SOUND
static MenuOption_t MEO_SOUND_SAMPLINGRATE = MAKE_MENUOPTION( &MF_Redfont, &MEOS_SOUND_SAMPLINGRATE, &soundrate );
static MenuEntry_t ME_SOUND_SAMPLINGRATE = MAKE_MENUENTRY( "Sample rate:", &MF_Redfont, &MEF_BigOptionsRt, &MEO_SOUND_SAMPLINGRATE, Option );
static char *MEOSN_SOUND_SAMPLESIZE[] = { "8-bit", "16-bit", };
static int32_t MEOSV_SOUND_SAMPLESIZE[] = { 8, 16, };
static MenuOptionSet_t MEOS_SOUND_SAMPLESIZE = MAKE_MENUOPTIONSET( MEOSN_SOUND_SAMPLESIZE, MEOSV_SOUND_SAMPLESIZE, 0x3 );
static MenuOption_t MEO_SOUND_SAMPLESIZE = MAKE_MENUOPTION( &MF_Redfont, &MEOS_SOUND_SAMPLESIZE, &soundbits );
static MenuEntry_t ME_SOUND_SAMPLESIZE = MAKE_MENUENTRY( "Sample size:", &MF_Redfont, &MEF_BigOptionsRt, &MEO_SOUND_SAMPLESIZE, Option );
static MenuRangeInt32_t MEO_SOUND_NUMVOICES = MAKE_MENURANGE( &soundvoices, &MF_Redfont, 16, 256, 0, 16, 1 );
static MenuEntry_t ME_SOUND_NUMVOICES = MAKE_MENUENTRY( "Voices:", &MF_Redfont, &MEF_BigOptionsRt, &MEO_SOUND_NUMVOICES, RangeInt32 );
@ -1015,7 +1009,6 @@ static MenuEntry_t *MEL_SOUND[] = {
static MenuEntry_t *MEL_ADVSOUND[] = {
&ME_SOUND_SAMPLINGRATE,
&ME_SOUND_SAMPLESIZE,
&ME_Space2,
&ME_SOUND_NUMVOICES,
&ME_Space2,
@ -1639,11 +1632,9 @@ static void M_PreMenu(MenuID_t cm)
MenuEntry_DisableOnCondition(&ME_SOUND_VOLUME_MUSIC, !ud.config.MusicToggle);
MenuEntry_DisableOnCondition(&ME_SOUND_DUKETALK, !ud.config.SoundToggle);
MenuEntry_DisableOnCondition(&ME_SOUND_SAMPLINGRATE, !ud.config.SoundToggle && !ud.config.MusicToggle);
MenuEntry_DisableOnCondition(&ME_SOUND_SAMPLESIZE, !ud.config.SoundToggle && !ud.config.MusicToggle);
MenuEntry_DisableOnCondition(&ME_SOUND_NUMVOICES, !ud.config.SoundToggle);
MenuEntry_DisableOnCondition(&ME_SOUND_RESTART, soundrate == ud.config.MixRate &&
soundvoices == ud.config.NumVoices &&
soundbits == ud.config.NumBits);
soundvoices == ud.config.NumVoices);
break;
case MENU_MOUSESETUP:
@ -2588,7 +2579,6 @@ static void M_MenuEntryLinkActivate(MenuEntry_t *entry)
{
ud.config.MixRate = soundrate;
ud.config.NumVoices = soundvoices;
ud.config.NumBits = soundbits;
S_SoundShutdown();
S_MusicShutdown();
@ -3398,7 +3388,6 @@ void M_ChangeMenu(MenuID_t cm)
case MENU_ADVSOUND:
soundrate = ud.config.MixRate;
soundvoices = ud.config.NumVoices;
soundbits = ud.config.NumBits;
break;
default:

1
polymer/eduke32/source/osdcmds.c
View file

@ -1632,7 +1632,6 @@ int32_t registerosdcommands(void)
{ "snd_mastervolume", "master volume for sound system", (void *)&ud.config.MasterVolume, CVAR_INT, 0, 255 },
{ "snd_fxvolume", "volume of sound effects", (void *)&ud.config.FXVolume, CVAR_INT, 1, 255 },
{ "snd_mixrate", "sound mixing rate", (void *)&ud.config.MixRate, CVAR_INT, 0, 48000 },
{ "snd_numbits", "sound bits", (void *)&ud.config.NumBits, CVAR_INT, 8, 16 },
{ "snd_numchannels", "the number of sound channels", (void *)&ud.config.NumChannels, CVAR_INT, 0, 2 },
{ "snd_numvoices", "the number of concurrent sounds", (void *)&ud.config.NumVoices, CVAR_INT, 0, 256 },
{ "snd_reversestereo", "reverses the stereo channels", (void *)&ud.config.ReverseStereo, CVAR_BOOL, 0, 16 },

2
polymer/eduke32/source/sounds.c
View file

@ -64,7 +64,7 @@ void S_SoundStartup(void)
initprintf("Initializing sound... ");
if (FX_Init(ASS_AutoDetect, ud.config.NumVoices, ud.config.NumChannels, ud.config.NumBits, ud.config.MixRate, initdata) != FX_Ok)
if (FX_Init(ASS_AutoDetect, ud.config.NumVoices, ud.config.NumChannels, ud.config.MixRate, initdata) != FX_Ok)
{
initprintf("failed! %s\n", FX_ErrorString(FX_Error));
return;

9
polymer/eduke32/source/sounds_mapster32.c
View file

@ -77,7 +77,7 @@ int32_t S_SoundStartup(void)
void *initdata = 0;
// TODO: read config
int32_t FXVolume=220, /*NumVoices=32,*/ NumChannels=2, NumBits=16, ReverseStereo=0;
int32_t FXVolume=220, /*NumVoices=32,*/ NumChannels=2, ReverseStereo=0;
fxdevicetype = ASS_AutoDetect;
@ -85,15 +85,14 @@ int32_t S_SoundStartup(void)
initdata = (void *) win_gethwnd(); // used for DirectSound
#endif
status = FX_Init(fxdevicetype, NumVoices, NumChannels, NumBits, MixRate, initdata);
status = FX_Init(fxdevicetype, NumVoices, NumChannels, MixRate, initdata);
if (status == FX_Ok)
{
FX_SetVolume(FXVolume);
FX_SetReverseStereo(ReverseStereo);
status = FX_SetCallBack(S_Callback);
FX_SetCallBack(S_Callback);
}
if (status != FX_Ok)
else
{
initprintf("Sound startup error: %s\n", FX_ErrorString(FX_Error));
return -2;