zdoom/raze-gles
0
0
Fork 0
mirror of https://github.com/ZDoom/raze-gles.git synced 2025-01-11 18:50:46 +00:00
Code Issues Projects Releases Packages Wiki Activity

Hopefully the last of the formatting changes + sound support for Linux. Previous commit also fixes the mouse cursor grab issue.

Browse source 
git-svn-id: https://svn.eduke32.com/eduke32@337 1a8010ca-5511-0410-912e-c29ae57300e0
This commit is contained in:
terminx 2006-11-16 03:02:42 +00:00
parent 9f9ccf8344
commit bbbccb7b11
47 changed files with 37320 additions and 33006 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

19
polymer/eduke32/Makefile
View file

@ -66,9 +66,21 @@ JMACTOBJ=$(OBJ)/util_lib.$o \
$(OBJ)/mathutil.$o \ $(OBJ)/mathutil.$o \
$(OBJ)/scriplib.$o $(OBJ)/scriplib.$o
AUDIOLIB_FX_STUB=$(OBJ)/audiolib_fxstub.$o AUDIOLIB_FX_SDL=$(OBJ)/mv_mix.$o \
AUDIOLIB_MUSIC_STUB=$(OBJ)/audiolib_musicstub.$o $(OBJ)/mv_mix16.$o \
$(OBJ)/mvreverb.$o \
$(OBJ)/ll_man.$o \
$(OBJ)/fx_man.$o \
$(OBJ)/dsl.$o \
$(OBJ)/nodpmi.$o \
$(OBJ)/unixpitch.$o \
$(OBJ)/unixvoc.$o
AUDIOLIB_MUSIC_SDL=$(OBJ)/sdlmusic.$o \
$(OBJ)/unixglob.$o
AUDIOLIB_JFAUD=$(OBJ)/jfaud_sounds.$o AUDIOLIB_JFAUD=$(OBJ)/jfaud_sounds.$o
AUDIOLIB_FX=$(OBJ)/mv_mix.$o \ AUDIOLIB_FX=$(OBJ)/mv_mix.$o \
$(OBJ)/mv_mix16.$o \ $(OBJ)/mv_mix16.$o \
$(OBJ)/mvreverb.$o \ $(OBJ)/mvreverb.$o \
@ -113,11 +125,12 @@ endif
ifeq ($(RENDERTYPE),SDL) ifeq ($(RENDERTYPE),SDL)
OURCFLAGS+= $(subst -Dmain=SDL_main,,$(shell sdl-config --cflags)) OURCFLAGS+= $(subst -Dmain=SDL_main,,$(shell sdl-config --cflags))
LIBS+= -lSDL_mixer
ifneq (0,$(JFAUD)) ifneq (0,$(JFAUD))
AUDIOLIBOBJ=$(AUDIOLIB_JFAUD) AUDIOLIBOBJ=$(AUDIOLIB_JFAUD)
else else
AUDIOLIBOBJ=$(AUDIOLIB_MUSIC_STUB) $(AUDIOLIB_FX_STUB) $(OBJ)/sounds.$o AUDIOLIBOBJ=$(AUDIOLIB_MUSIC_SDL) $(AUDIOLIB_FX_SDL) $(OBJ)/sounds.$o
endif endif
ifeq (1,$(HAVE_GTK2)) ifeq (1,$(HAVE_GTK2))

5
polymer/eduke32/Makefile.deps
View file

@ -45,6 +45,11 @@ $(OBJ)/mathutil.$o: $(SRC)/jmact/mathutil.c $(SRC)/jmact/types.h
$(OBJ)/scriplib.$o: $(SRC)/jmact/scriplib.c $(SRC)/jmact/scriplib.h $(SRC)/jmact/util_lib.h $(SRC)/jmact/_scrplib.h $(SRC)/jmact/types.h $(EINC)/compat.h $(OBJ)/scriplib.$o: $(SRC)/jmact/scriplib.c $(SRC)/jmact/scriplib.h $(SRC)/jmact/util_lib.h $(SRC)/jmact/_scrplib.h $(SRC)/jmact/types.h $(EINC)/compat.h
# jAudioLib objects # jAudioLib objects
$(OBJ)/dsl.$o: $(SRC)/jaudiolib/dsl.c $(SRC)/jaudiolib/util.h
$(OBJ)/nodpmi.$o: $(SRC)/jaudiolib/nodpmi.c $(SRC)/jaudiolib/dpmi.h
$(OBJ)/unixpitch.$o: $(SRC)/jaudiolib/unixpitch.c $(SRC)/jaudiolib/pitch.h
$(OBJ)/unixvoc.$o: $(SRC)/jaudiolib/unixvoc.c $(SRC)/jaudiolib/usrhooks.h $(SRC)/jaudiolib/linklist.h $(SRC)/jaudiolib/pitch.h $(SRC)/jaudiolib/multivoc.h $(SRC)/jaudiolib/_multivc.h
$(OBJ)/audiolib_fxstub.$o: $(SRC)/jaudiolib/audiolib_fxstub.c $(SRC)/jaudiolib/fx_man.h $(OBJ)/audiolib_fxstub.$o: $(SRC)/jaudiolib/audiolib_fxstub.c $(SRC)/jaudiolib/fx_man.h
$(OBJ)/audiolib_musicstub.$o: $(SRC)/jaudiolib/audiolib_musicstub.c $(SRC)/jaudiolib/music.h $(OBJ)/audiolib_musicstub.$o: $(SRC)/jaudiolib/audiolib_musicstub.c $(SRC)/jaudiolib/music.h

3
polymer/eduke32/source/astub.c
View file

@ -4298,8 +4298,7 @@ void ExtPreSaveMap(void)
} }
void ExtPreLoadMap(void) void ExtPreLoadMap(void)
{ {}
}
int ExtPreInit(int *argc,char ***argv) int ExtPreInit(int *argc,char ***argv)
{ {

5
polymer/eduke32/source/grpscan.c
View file

@ -10,15 +10,14 @@
struct grpfile grpfiles[numgrpfiles] = struct grpfile grpfiles[numgrpfiles] =
{ {
{ "Duke Nukem 3D", 0xBBC9CE44, 26524524, GAMEDUKE, NULL { "Duke Nukem 3D", 0xBBC9CE44, 26524524, GAMEDUKE, NULL },
}
,
{ "Duke Nukem 3D: Atomic Edition", 0xF514A6AC, 44348015, GAMEDUKE, NULL }, { "Duke Nukem 3D: Atomic Edition", 0xF514A6AC, 44348015, GAMEDUKE, NULL },
{ "Duke Nukem 3D: Atomic Edition", 0xFD3DCFF1, 44356548, GAMEDUKE, NULL }, { "Duke Nukem 3D: Atomic Edition", 0xFD3DCFF1, 44356548, GAMEDUKE, NULL },
{ "Duke Nukem 3D Shareware Version", 0x983AD923, 11035779, GAMEDUKE, NULL }, { "Duke Nukem 3D Shareware Version", 0x983AD923, 11035779, GAMEDUKE, NULL },
{ "Duke Nukem 3D Mac Shareware Version", 0xC5F71561, 10444391, GAMEDUKE, NULL }, { "Duke Nukem 3D Mac Shareware Version", 0xC5F71561, 10444391, GAMEDUKE, NULL },
{ "Duke Nukem 3D Mac", 0x00000000, 0, GAMEDUKE, NULL }, { "Duke Nukem 3D Mac", 0x00000000, 0, GAMEDUKE, NULL },
{ "NAM", 0x75C1F07B, 43448927, GAMENAM, NULL }, { "NAM", 0x75C1F07B, 43448927, GAMENAM, NULL },
{ "Napalm", 0x3DE1589A, 44365728, GAMENAM, NULL },
}; };
struct grpfile *foundgrps = NULL; struct grpfile *foundgrps = NULL;

2
polymer/eduke32/source/grpscan.h
View file

@ -2,7 +2,7 @@
#define __grpscan_h__ #define __grpscan_h__
// List of internally-known GRP files // List of internally-known GRP files
#define numgrpfiles 7 #define numgrpfiles 8
struct grpfile { struct grpfile {
const char *name; const char *name;
int crcval; int crcval;

11
polymer/eduke32/source/jaudiolib/_multivc.h
View file

@ -67,8 +67,11 @@ Modifications for JonoF's port by Jonathon Fowler (jonof@edgenetwk.com)
#define SILENCE_8BIT 0x80808080 #define SILENCE_8BIT 0x80808080
//#define SILENCE_16BIT_PAS 0 //#define SILENCE_16BIT_PAS 0
//#define MixBufferSize 256 #ifdef WINDOWS
#define MixBufferSize (MV_GetBufferSize(MV_RequestedMixRate)) #define MixBufferSize (MV_GetBufferSize(MV_RequestedMixRate))
#else
#define MixBufferSize 256
#endif
#define NumberOfBuffers 16 #define NumberOfBuffers 16
#define TotalBufferSize ( MixBufferSize * NumberOfBuffers ) #define TotalBufferSize ( MixBufferSize * NumberOfBuffers )
@ -269,10 +272,14 @@ parm [ edi ] [ eax ] [ ecx ] modify exact [ ecx edi ];
#define CDEC _cdecl #define CDEC _cdecl
#else #elif defined(WINDOWS)
#define CDEC __cdecl #define CDEC __cdecl
#else
#define CDEC
#endif #endif

74
polymer/eduke32/source/jaudiolib/audiolib_fx_fmod.c
View file

@ -106,7 +106,8 @@ char *FX_ErrorString(int ErrorNumber)
static char *OutputType(int a) static char *OutputType(int a)
{ {
switch (a) { switch (a)
{
case FSOUND_OUTPUT_NOSOUND: return "no-sound"; case FSOUND_OUTPUT_NOSOUND: return "no-sound";
case FSOUND_OUTPUT_WINMM: return "WinMM"; case FSOUND_OUTPUT_WINMM: return "WinMM";
case FSOUND_OUTPUT_DSOUND: return "DirectSound"; case FSOUND_OUTPUT_DSOUND: return "DirectSound";
@ -129,11 +130,13 @@ int FX_Init(int SoundCard, int numvoices, int numchannels, int samplebits, unsig
memset(FX_Samples, 0, sizeof(FX_Samples)); memset(FX_Samples, 0, sizeof(FX_Samples));
#ifdef WINDOWS #ifdef WINDOWS
if (hWindow) { if (hWindow)
{
//FSOUND_SetHWND(&hWindow); //FSOUND_SetHWND(&hWindow);
} }
#endif #endif
if (!FSOUND_Init(mixrate, numvoices, FSOUND_INIT_GLOBALFOCUS)) { if (!FSOUND_Init(mixrate, numvoices, FSOUND_INIT_GLOBALFOCUS))
{
FX_SetErrorCode(FX_FMODInit); FX_SetErrorCode(FX_FMODInit);
return FX_Error; return FX_Error;
} }
@ -167,7 +170,8 @@ int FX_Shutdown(void)
{ {
unsigned int curalloced, maxalloced; unsigned int curalloced, maxalloced;
if (chstates) { if (chstates)
{
FSOUND_GetMemoryStats(&curalloced, &maxalloced); FSOUND_GetMemoryStats(&curalloced, &maxalloced);
printOSD("FX_Shutdown(): allocation stats - currently %d bytes, maximum %d bytes\n",curalloced,maxalloced); printOSD("FX_Shutdown(): allocation stats - currently %d bytes, maximum %d bytes\n",curalloced,maxalloced);
} }
@ -215,8 +219,7 @@ void FX_SetVolume(int volume)
---------------------------------------------------------------------*/ ---------------------------------------------------------------------*/
void FX_SetReverseStereo(int setting) void FX_SetReverseStereo(int setting)
{ {}
}
/*--------------------------------------------------------------------- /*---------------------------------------------------------------------
@ -238,8 +241,7 @@ int FX_GetReverseStereo(void)
---------------------------------------------------------------------*/ ---------------------------------------------------------------------*/
void FX_SetReverb(int reverb) void FX_SetReverb(int reverb)
{ {}
}
/*--------------------------------------------------------------------- /*---------------------------------------------------------------------
@ -249,8 +251,7 @@ void FX_SetReverb(int reverb)
---------------------------------------------------------------------*/ ---------------------------------------------------------------------*/
void FX_SetReverbDelay(int delay) void FX_SetReverbDelay(int delay)
{ {}
}
/*--------------------------------------------------------------------- /*---------------------------------------------------------------------
@ -499,21 +500,27 @@ int FX_LoadSample(char *ptr, long size, unsigned long number, int priority)
void *ptr1,*ptr2; void *ptr1,*ptr2;
int ptr1len,ptr2len; int ptr1len,ptr2len;
if (!memcmp(ptr, "Creative Voice File", 0x13)) { if (!memcmp(ptr, "Creative Voice File", 0x13))
{
// VOC file // VOC file
if (FX_ReadVOCInfo(ptr,size,&samplerate,&channels,&samplesize,&datalen) == 0) { if (FX_ReadVOCInfo(ptr,size,&samplerate,&channels,&samplesize,&datalen) == 0)
{
flags |= (channels==2)?FSOUND_STEREO:FSOUND_MONO; flags |= (channels==2)?FSOUND_STEREO:FSOUND_MONO;
flags |= (samplesize==16)?FSOUND_16BITS:FSOUND_8BITS; flags |= (samplesize==16)?FSOUND_16BITS:FSOUND_8BITS;
flags |= FSOUND_SIGNED; flags |= FSOUND_SIGNED;
samp = FSOUND_Sample_Alloc(number, (datalen >> (channels-1)) / (samplesize>>3), flags, samplerate, -1, -1, priority); samp = FSOUND_Sample_Alloc(number, (datalen >> (channels-1)) / (samplesize>>3), flags, samplerate, -1, -1, priority);
if (samp) { if (samp)
if (FSOUND_Sample_Lock(samp,0,datalen,&ptr1,&ptr2,&ptr1len,&ptr2len)) { {
if (FSOUND_Sample_Lock(samp,0,datalen,&ptr1,&ptr2,&ptr1len,&ptr2len))
{
if (FX_ReadVOCData(ptr,ptr1,datalen,(samplesize==8))) ; if (FX_ReadVOCData(ptr,ptr1,datalen,(samplesize==8))) ;
FSOUND_Sample_Unlock(samp,ptr1,ptr2,ptr1len,ptr2len); FSOUND_Sample_Unlock(samp,ptr1,ptr2,ptr1len,ptr2len);
} }
} }
} }
} else { }
else
{
samp = FSOUND_Sample_Load(number, ptr, FSOUND_LOADMEMORY, size); samp = FSOUND_Sample_Load(number, ptr, FSOUND_LOADMEMORY, size);
} }
@ -552,7 +559,8 @@ int FX_ReadVOCInfo(char *data, long size, int *samplerate, int *channels, int *s
ptr += 4; ptr += 4;
while (1) { while (1)
{
blocktype = *(ptr++); blocktype = *(ptr++);
if ((ptr-data)>size) return -1; // truncated if ((ptr-data)>size) return -1; // truncated
@ -563,11 +571,13 @@ int FX_ReadVOCInfo(char *data, long size, int *samplerate, int *channels, int *s
blocklen |= *(ptr++) << 8; blocklen |= *(ptr++) << 8;
blocklen |= *(ptr++) << 16; blocklen |= *(ptr++) << 16;
switch (blocktype) { switch (blocktype)
{
case 1: /* sound data begin block */ case 1: /* sound data begin block */
if (!*samplerate) if (!*samplerate)
*samplerate = REGRESSSR(ptr[0]); *samplerate = REGRESSSR(ptr[0]);
if (ptr[1] != 0) { if (ptr[1] != 0)
{
/* only 8-bit files please */ /* only 8-bit files please */
return -1; return -1;
} }
@ -619,12 +629,15 @@ int FX_ReadVOCInfo(char *data, long size, int *samplerate, int *channels, int *s
case 8: /* sound attribute extension block */ case 8: /* sound attribute extension block */
*samplerate = REGRESSTC(ptr[0] | (ptr[1] << 8)); *samplerate = REGRESSTC(ptr[0] | (ptr[1] << 8));
*samplesize = 8; *samplesize = 8;
if (ptr[3] == 1) { if (ptr[3] == 1)
{
*samplerate >>= 1; *samplerate >>= 1;
*channels = 2; *channels = 2;
} else }
else
*channels = 1; *channels = 1;
if (ptr[2] != 0) { if (ptr[2] != 0)
{
/* only 8-bit files please */ /* only 8-bit files please */
return -1; return -1;
} }
@ -637,7 +650,8 @@ int FX_ReadVOCInfo(char *data, long size, int *samplerate, int *channels, int *s
*samplesize = ptr[4]; *samplesize = ptr[4];
*channels = ptr[5]; *channels = ptr[5];
if ((ptr[6] | (ptr[7] << 8)) != 0 && if ((ptr[6] | (ptr[7] << 8)) != 0 &&
(ptr[6] | (ptr[7] << 8)) != 4) { (ptr[6] | (ptr[7] << 8)) != 4)
{
/* only PCM please */ /* only PCM please */
return -1; return -1;
} }
@ -663,7 +677,8 @@ int FX_ReadVOCData(char *data, char *buf, int bufferlen, char eightbit)
data += 0x14 + 2 + 4; data += 0x14 + 2 + 4;
while (bufferlen>0) { while (bufferlen>0)
{
blocktype = *(data++); blocktype = *(data++);
if (blocktype == 0) if (blocktype == 0)
@ -673,7 +688,8 @@ int FX_ReadVOCData(char *data, char *buf, int bufferlen, char eightbit)
blocklen |= *(data++) << 8; blocklen |= *(data++) << 8;
blocklen |= *(data++) << 16; blocklen |= *(data++) << 16;
switch (blocktype) { switch (blocktype)
{
case 1: /* sound data */ case 1: /* sound data */
data += 2; data += 2;
@ -696,11 +712,14 @@ int FX_ReadVOCData(char *data, char *buf, int bufferlen, char eightbit)
} }
convertdata: convertdata:
bufferlen -= br; bufferlen -= br;
if (eightbit) { if (eightbit)
{
// FMOD wants signed data // FMOD wants signed data
for (; br>0; br--) for (; br>0; br--)
*(buf++) = (char)((short)(*(data++)) - 0x80); *(buf++) = (char)((short)(*(data++)) - 0x80);
} else { }
else
{
memcpy(buf,data,br); memcpy(buf,data,br);
buf += br; buf += br;
data += br; data += br;
@ -720,7 +739,8 @@ int FX_SimulateCallbacks(void)
chstatesa = chstates + (FX_NumVoices * chtoggle); chstatesa = chstates + (FX_NumVoices * chtoggle);
chstatesb = chstates + (FX_NumVoices * (chtoggle^1)); chstatesb = chstates + (FX_NumVoices * (chtoggle^1));
for (i=0;i<FX_NumVoices;i++) { for (i=0;i<FX_NumVoices;i++)
{
chstatesa[i] = FSOUND_IsPlaying(i); chstatesa[i] = FSOUND_IsPlaying(i);
if (chstatesa[i] == chstatesb[i]) continue; // channel is still silent/playing if (chstatesa[i] == chstatesb[i]) continue; // channel is still silent/playing
if (chstatesa[i] > chstatesb[i]) continue; // channel has begun playing if (chstatesa[i] > chstatesb[i]) continue; // channel has begun playing

12
polymer/eduke32/source/jaudiolib/audiolib_fxstub.c
View file

@ -141,8 +141,7 @@ void FX_SetVolume
int volume int volume
) )
{ {}
}
/*--------------------------------------------------------------------- /*---------------------------------------------------------------------
@ -156,8 +155,7 @@ void FX_SetReverseStereo
int setting int setting
) )
{ {}
}
/*--------------------------------------------------------------------- /*---------------------------------------------------------------------
@ -187,8 +185,7 @@ void FX_SetReverb
int reverb int reverb
) )
{ {}
}
/*--------------------------------------------------------------------- /*---------------------------------------------------------------------
@ -202,8 +199,7 @@ void FX_SetReverbDelay
int delay int delay
) )
{ {}
}
/*--------------------------------------------------------------------- /*---------------------------------------------------------------------

54
polymer/eduke32/source/jaudiolib/audiolib_musicstub.c
View file

@ -151,8 +151,7 @@ void MUSIC_SetMaxFMMidiChannel
int channel int channel
) )
{ {}
}
/*--------------------------------------------------------------------- /*---------------------------------------------------------------------
@ -166,8 +165,7 @@ void MUSIC_SetVolume
int volume int volume
) )
{ {}
}
/*--------------------------------------------------------------------- /*---------------------------------------------------------------------
@ -182,8 +180,7 @@ void MUSIC_SetMidiChannelVolume
int volume int volume
) )
{ {}
}
/*--------------------------------------------------------------------- /*---------------------------------------------------------------------
@ -197,8 +194,7 @@ void MUSIC_ResetMidiChannelVolumes
void void
) )
{ {}
}
/*--------------------------------------------------------------------- /*---------------------------------------------------------------------
@ -229,8 +225,7 @@ void MUSIC_SetLoopFlag
int loopflag int loopflag
) )
{ {}
}
/*--------------------------------------------------------------------- /*---------------------------------------------------------------------
@ -260,8 +255,7 @@ void MUSIC_Continue
void void
) )
{ {}
}
/*--------------------------------------------------------------------- /*---------------------------------------------------------------------
@ -275,8 +269,7 @@ void MUSIC_Pause
void void
) )
{ {}
}
/*--------------------------------------------------------------------- /*---------------------------------------------------------------------
@ -323,8 +316,7 @@ void MUSIC_SetContext
int context int context
) )
{ {}
}
/*--------------------------------------------------------------------- /*---------------------------------------------------------------------
@ -338,8 +330,7 @@ int MUSIC_GetContext
void void
) )
{ {}
}
/*--------------------------------------------------------------------- /*---------------------------------------------------------------------
@ -353,8 +344,7 @@ void MUSIC_SetSongTick
unsigned long PositionInTicks unsigned long PositionInTicks
) )
{ {}
}
/*--------------------------------------------------------------------- /*---------------------------------------------------------------------
@ -368,8 +358,7 @@ void MUSIC_SetSongTime
unsigned long milliseconds unsigned long milliseconds
) )
{ {}
}
/*--------------------------------------------------------------------- /*---------------------------------------------------------------------
@ -385,8 +374,7 @@ void MUSIC_SetSongPosition
int tick int tick
) )
{ {}
}
/*--------------------------------------------------------------------- /*---------------------------------------------------------------------
@ -400,8 +388,7 @@ void MUSIC_GetSongPosition
songposition *pos songposition *pos
) )
{ {}
}
/*--------------------------------------------------------------------- /*---------------------------------------------------------------------
@ -415,8 +402,7 @@ void MUSIC_GetSongLength
songposition *pos songposition *pos
) )
{ {}
}
@ -468,8 +454,7 @@ void MUSIC_StopFade
void void
) )
{ {}
}
/*--------------------------------------------------------------------- /*---------------------------------------------------------------------
@ -485,8 +470,7 @@ void MUSIC_RerouteMidiChannel
int(*function)(int event, int c1, int c2) int(*function)(int event, int c1, int c2)
) )
{ {}
}
/*--------------------------------------------------------------------- /*---------------------------------------------------------------------
@ -500,11 +484,9 @@ void MUSIC_RegisterTimbreBank
unsigned char *timbres unsigned char *timbres
) )
{ {}
}
void MUSIC_Update(void) void MUSIC_Update(void)
{ {}
}

30
polymer/eduke32/source/jaudiolib/debugio.h Executable file
View file

@ -0,0 +1,30 @@
/*
Copyright (C) 1994-1995 Apogee Software, Ltd.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __DEBUGIO_H
#define __DEBUGIO_H
void DB_SetXY( int x, int y );
void DB_PutChar( char ch );
int DB_PrintString( char *string );
int DB_PrintNum( int number );
int DB_PrintUnsigned( unsigned long number, int radix );
int DB_printf( char *fmt, ... );
#endif

83
polymer/eduke32/source/jaudiolib/dma.h Executable file
View file

@ -0,0 +1,83 @@
/*
Copyright (C) 1994-1995 Apogee Software, Ltd.
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.
*/
/**********************************************************************
file: DMA.H
author: James R. Dose
date: February 4, 1994
Public header file for DMA.C
(c) Copyright 1994 James R. Dose. All Rights Reserved.
**********************************************************************/
#ifndef __DMA_H
#define __DMA_H
enum DMA_ERRORS
{
DMA_Error = -1,
DMA_Ok = 0,
DMA_ChannelOutOfRange,
DMA_InvalidChannel
};
enum DMA_Modes
{
DMA_SingleShotRead,
DMA_SingleShotWrite,
DMA_AutoInitRead,
DMA_AutoInitWrite
};
char *DMA_ErrorString
(
int ErrorNumber
);
int DMA_VerifyChannel
(
int channel
);
int DMA_SetupTransfer
(
int channel,
char *address,
int length,
int mode
);
int DMA_EndTransfer
(
int channel
);
char *DMA_GetCurrentPos
(
int channel
);
int DMA_GetTransferCount
(
int channel
);
#endif

43
polymer/eduke32/source/jaudiolib/dpmi.h Executable file
View file

@ -0,0 +1,43 @@
/*
Copyright (C) 1994-1995 Apogee Software, Ltd.
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.
*/
/**********************************************************************
module: DPMI.H
author: James R. Dose
date: March 31, 1994
Inline functions for performing DPMI calls.
(c) Copyright 1994 James R. Dose. All Rights Reserved.
**********************************************************************/
#ifndef __DPMI_H
#define __DPMI_H
enum DPMI_Errors
{
DPMI_Warning = -2,
DPMI_Error = -1,
DPMI_Ok = 0
};
int DPMI_GetDOSMemory( void **ptr, int *descriptor, unsigned length );
int DPMI_FreeDOSMemory( int descriptor );
#endif

266
polymer/eduke32/source/jaudiolib/dsl.c Executable file
View file

@ -0,0 +1,266 @@
/*
Copyright (C) 2003-2004 Ryan C. Gordon. and James Bentler
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.
Originally written by Ryan C. Gordon. (icculus@clutteredmind.org)
Adapted to work with JonoF's port by James Bentler (bentler@cs.umn.edu)
*/
#include <stdlib.h>
#include <string.h>
#include "dsl.h"
#include "util.h"
#include "SDL.h"
#include "SDL_mixer.h"
extern volatile int MV_MixPage;
static int DSL_ErrorCode = DSL_Ok;
static int mixer_initialized;
static void(*_CallBackFunc)(void);
static volatile char *_BufferStart;
static int _BufferSize;
static int _NumDivisions;
static int _SampleRate;
static int _remainder;
static Mix_Chunk *blank;
static unsigned char *blank_buf;
/*
possible todo ideas: cache sdl/sdl mixer error messages.
*/
char *DSL_ErrorString(int ErrorNumber)
{
char *ErrorString;
switch (ErrorNumber)
{
case DSL_Warning:
case DSL_Error:
ErrorString = DSL_ErrorString(DSL_ErrorCode);
break;
case DSL_Ok:
ErrorString = "SDL Driver ok.";
break;
case DSL_SDLInitFailure:
ErrorString = "SDL Audio initialization failed.";
break;
case DSL_MixerActive:
ErrorString = "SDL Mixer already initialized.";
break;
case DSL_MixerInitFailure:
ErrorString = "SDL Mixer initialization failed.";
break;
default:
ErrorString = "Unknown SDL Driver error.";
break;
}
return ErrorString;
}
static void DSL_SetErrorCode(int ErrorCode)
{
DSL_ErrorCode = ErrorCode;
}
int DSL_Init(void)
{
DSL_SetErrorCode(DSL_Ok);
if (SDL_InitSubSystem(SDL_INIT_AUDIO) < 0)
{
DSL_SetErrorCode(DSL_SDLInitFailure);
return DSL_Error;
}
return DSL_Ok;
}
void DSL_Shutdown(void)
{
DSL_StopPlayback();
}
static void mixer_callback(int chan, void *stream, int len, void *udata)
{
Uint8 *stptr;
Uint8 *fxptr;
int copysize;
/* len should equal _BufferSize, else this is screwed up */
stptr = (Uint8 *)stream;
if (_remainder > 0)
{
copysize = min(len, _remainder);
fxptr = (Uint8 *)(&_BufferStart[MV_MixPage *
_BufferSize]);
memcpy(stptr, fxptr+(_BufferSize-_remainder), copysize);
len -= copysize;
_remainder -= copysize;
stptr += copysize;
}
while (len > 0)
{
/* new buffer */
_CallBackFunc();
fxptr = (Uint8 *)(&_BufferStart[MV_MixPage *
_BufferSize]);
copysize = min(len, _BufferSize);
memcpy(stptr, fxptr, copysize);
len -= copysize;
stptr += copysize;
}
_remainder = len;
}
int DSL_BeginBufferedPlayback(char *BufferStart,
int BufferSize, int NumDivisions, unsigned SampleRate,
int MixMode, void(*CallBackFunc)(void))
{
Uint16 format;
Uint8 *tmp;
int channels;
int chunksize;
if (mixer_initialized)
{
DSL_SetErrorCode(DSL_MixerActive);
return DSL_Error;
}
_CallBackFunc = CallBackFunc;
_BufferStart = BufferStart;
_BufferSize = (BufferSize / NumDivisions);
_NumDivisions = NumDivisions;
_SampleRate = SampleRate;
_remainder = 0;
format = (MixMode & SIXTEEN_BIT) ? AUDIO_S16SYS : AUDIO_U8;
channels = (MixMode & STEREO) ? 2 : 1;
/*
23ms is typically ideal (11025,22050,44100)
46ms isn't bad
*/
chunksize = 512;
if (SampleRate >= 16000) chunksize *= 2;
if (SampleRate >= 32000) chunksize *= 2;
/*
// SDL mixer does this already
if (MixMode & SIXTEEN_BIT) chunksize *= 2;
if (MixMode & STEREO) chunksize *= 2;
*/
if (Mix_OpenAudio(SampleRate, format, channels, chunksize) < 0)
{
DSL_SetErrorCode(DSL_MixerInitFailure);
return DSL_Error;
}
/*
Mix_SetPostMix(mixer_callback, NULL);
*/
/* have to use a channel because postmix will overwrite the music... */
Mix_RegisterEffect(0, mixer_callback, NULL, NULL);
/* create a dummy sample just to allocate that channel */
blank_buf = (Uint8 *)malloc(4096);
memset(blank_buf, 0, 4096);
blank = Mix_QuickLoad_RAW(blank_buf, 4096);
Mix_PlayChannel(0, blank, -1);
mixer_initialized = 1;
return DSL_Ok;
}
void DSL_StopPlayback(void)
{
if (mixer_initialized)
{
Mix_HaltChannel(0);
}
if (blank != NULL)
{
Mix_FreeChunk(blank);
}
blank = NULL;
if (blank_buf != NULL)
{
free(blank_buf);
}
blank_buf = NULL;
if (mixer_initialized)
{
Mix_CloseAudio();
}
mixer_initialized = 0;
}
unsigned DSL_GetPlaybackRate(void)
{
return _SampleRate;
}
unsigned long DisableInterrupts(void)
{
return 0;
}
void RestoreInterrupts(unsigned long flags)
{}

50
polymer/eduke32/source/jaudiolib/dsl.h Executable file
View file

@ -0,0 +1,50 @@
/*
Copyright (C) 2003-2004 Ryan C. Gordon. and James Bentler
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.
Originally written by Ryan C. Gordon. (icculus@clutteredmind.org)
Adapted to work with JonoF's port by James Bentler (bentler@cs.umn.edu)
*/
#ifndef AUDIOLIB__DSL_H
#define AUDIOLIB__DSL_H
#define MONO_8BIT 0
#define STEREO 1
#define SIXTEEN_BIT 2
#define STEREO_16BIT ( STEREO | SIXTEEN_BIT )
enum DSL_ERRORS
{
DSL_Warning = -2,
DSL_Error = -1,
DSL_Ok = 0,
DSL_SDLInitFailure,
DSL_MixerActive,
DSL_MixerInitFailure
};
char *DSL_ErrorString( int ErrorNumber );
int DSL_Init( void );
void DSL_StopPlayback( void );
unsigned DSL_GetPlaybackRate( void );
int DSL_BeginBufferedPlayback( char *BufferStart,
int BufferSize, int NumDivisions, unsigned SampleRate,
int MixMode, void ( *CallBackFunc )( void ) );
void DSL_Shutdown( void );
#endif

123
polymer/eduke32/source/jaudiolib/dsoundout.c
View file

@ -107,7 +107,8 @@ int RestoreInterrupts(int a)
*/ */
char *DSOUND_ErrorString(int errorcode) char *DSOUND_ErrorString(int errorcode)
{ {
switch (errorcode) { switch (errorcode)
{
case DSOUND_Warning: case DSOUND_Warning:
case DSOUND_Error: case DSOUND_Error:
return DSOUND_ErrorString(DSOUND_ErrorCode); return DSOUND_ErrorString(DSOUND_ErrorCode);
@ -175,13 +176,15 @@ int DSOUND_Init(int soundcard, int mixrate, int numchannels, int samplebits, int
WAVEFORMATEX wfex; WAVEFORMATEX wfex;
DSBPOSITIONNOTIFY posn; DSBPOSITIONNOTIFY posn;
if (DSOUND_Installed) { if (DSOUND_Installed)
{
DSOUND_Shutdown(); DSOUND_Shutdown();
} }
printOSD("Initializing DirectSound...\n"); printOSD("Initializing DirectSound...\n");
if (!_DSOUND_CriticalSectionAlloced) { if (!_DSOUND_CriticalSectionAlloced)
{
// initialize the critical section object we'll use to // initialize the critical section object we'll use to
// simulate (dis|en)abling interrupts // simulate (dis|en)abling interrupts
InitializeCriticalSection(&mutex); InitializeCriticalSection(&mutex);
@ -190,14 +193,16 @@ int DSOUND_Init(int soundcard, int mixrate, int numchannels, int samplebits, int
printOSD(" - Loading DSOUND.DLL\n"); printOSD(" - Loading DSOUND.DLL\n");
hDSoundDLL = LoadLibrary("DSOUND.DLL"); hDSoundDLL = LoadLibrary("DSOUND.DLL");
if (!hDSoundDLL) { if (!hDSoundDLL)
{
DSOUND_Shutdown(); DSOUND_Shutdown();
DSOUND_SetErrorCode(DSOUND_NoDLL); DSOUND_SetErrorCode(DSOUND_NoDLL);
return DSOUND_Error; return DSOUND_Error;
} }
aDirectSoundCreate = (void *)GetProcAddress(hDSoundDLL, "DirectSoundCreate"); aDirectSoundCreate = (void *)GetProcAddress(hDSoundDLL, "DirectSoundCreate");
if (!aDirectSoundCreate) { if (!aDirectSoundCreate)
{
DSOUND_Shutdown(); DSOUND_Shutdown();
DSOUND_SetErrorCode(DSOUND_NoDirectSoundCreate); DSOUND_SetErrorCode(DSOUND_NoDirectSoundCreate);
return DSOUND_Error; return DSOUND_Error;
@ -205,14 +210,16 @@ int DSOUND_Init(int soundcard, int mixrate, int numchannels, int samplebits, int
printOSD(" - Creating DirectSound object\n"); printOSD(" - Creating DirectSound object\n");
hr = aDirectSoundCreate(NULL, &lpDS, NULL); hr = aDirectSoundCreate(NULL, &lpDS, NULL);
if (hr != DS_OK) { if (hr != DS_OK)
{
DSOUND_Shutdown(); DSOUND_Shutdown();
DSOUND_SetErrorCode(DSOUND_FailedDSC); DSOUND_SetErrorCode(DSOUND_FailedDSC);
return DSOUND_Error; return DSOUND_Error;
} }
hr = IDirectSound_SetCooperativeLevel(lpDS, (HWND)win_gethwnd(), DSSCL_EXCLUSIVE); hr = IDirectSound_SetCooperativeLevel(lpDS, (HWND)win_gethwnd(), DSSCL_EXCLUSIVE);
if (hr != DS_OK) { if (hr != DS_OK)
{
DSOUND_Shutdown(); DSOUND_Shutdown();
DSOUND_SetErrorCode(DSOUND_FailedSetCoopLevel); DSOUND_SetErrorCode(DSOUND_FailedSetCoopLevel);
return DSOUND_Error; return DSOUND_Error;
@ -223,7 +230,8 @@ int DSOUND_Init(int soundcard, int mixrate, int numchannels, int samplebits, int
dsbuf.dwSize = sizeof(DSBUFFERDESC); dsbuf.dwSize = sizeof(DSBUFFERDESC);
dsbuf.dwFlags = DSBCAPS_PRIMARYBUFFER; dsbuf.dwFlags = DSBCAPS_PRIMARYBUFFER;
hr = IDirectSound_CreateSoundBuffer(lpDS, &dsbuf, &lpDSBPrimary, NULL); hr = IDirectSound_CreateSoundBuffer(lpDS, &dsbuf, &lpDSBPrimary, NULL);
if (hr != DS_OK) { if (hr != DS_OK)
{
DSOUND_Shutdown(); DSOUND_Shutdown();
DSOUND_SetErrorCode(DSOUND_FailedCreatePrimary); DSOUND_SetErrorCode(DSOUND_FailedCreatePrimary);
return DSOUND_Error; return DSOUND_Error;
@ -242,7 +250,8 @@ int DSOUND_Init(int soundcard, int mixrate, int numchannels, int samplebits, int
wfex.nBlockAlign = (wfex.wBitsPerSample / 8) * wfex.nChannels; wfex.nBlockAlign = (wfex.wBitsPerSample / 8) * wfex.nChannels;
wfex.nAvgBytesPerSec = wfex.nBlockAlign * wfex.nSamplesPerSec; wfex.nAvgBytesPerSec = wfex.nBlockAlign * wfex.nSamplesPerSec;
hr = IDirectSoundBuffer_SetFormat(lpDSBPrimary, &wfex); hr = IDirectSoundBuffer_SetFormat(lpDSBPrimary, &wfex);
if (hr != DS_OK) { if (hr != DS_OK)
{
DSOUND_Shutdown(); DSOUND_Shutdown();
DSOUND_SetErrorCode(DSOUND_FailedSetFormat); DSOUND_SetErrorCode(DSOUND_FailedSetFormat);
return DSOUND_Error; return DSOUND_Error;
@ -255,28 +264,32 @@ int DSOUND_Init(int soundcard, int mixrate, int numchannels, int samplebits, int
dsbuf.dwBufferBytes = buffersize; dsbuf.dwBufferBytes = buffersize;
dsbuf.lpwfxFormat = &wfex; dsbuf.lpwfxFormat = &wfex;
hr = IDirectSound_CreateSoundBuffer(lpDS, &dsbuf, &lpDSBSecondary, NULL); hr = IDirectSound_CreateSoundBuffer(lpDS, &dsbuf, &lpDSBSecondary, NULL);
if (hr != DS_OK) { if (hr != DS_OK)
{
DSOUND_Shutdown(); DSOUND_Shutdown();
DSOUND_SetErrorCode(DSOUND_FailedCreateSecondary); DSOUND_SetErrorCode(DSOUND_FailedCreateSecondary);
return DSOUND_Error; return DSOUND_Error;
} }
hr = IDirectSoundBuffer_QueryInterface(lpDSBSecondary, &IID_IDirectSoundNotify, &lpDSNotify); hr = IDirectSoundBuffer_QueryInterface(lpDSBSecondary, &IID_IDirectSoundNotify, &lpDSNotify);
if (hr != DS_OK) { if (hr != DS_OK)
{
DSOUND_Shutdown(); DSOUND_Shutdown();
DSOUND_SetErrorCode(DSOUND_FailedQueryNotify); DSOUND_SetErrorCode(DSOUND_FailedQueryNotify);
return DSOUND_Error; return DSOUND_Error;
} }
hPosNotify = (HANDLE *)malloc(sizeof(HANDLE)); hPosNotify = (HANDLE *)malloc(sizeof(HANDLE));
if (!hPosNotify) { if (!hPosNotify)
{
DSOUND_Shutdown(); DSOUND_Shutdown();
DSOUND_SetErrorCode(DSOUND_FailedSetNotify); DSOUND_SetErrorCode(DSOUND_FailedSetNotify);
return DSOUND_Error; return DSOUND_Error;
} }
hPosNotify[0] = CreateEvent(NULL, FALSE, FALSE, NULL); hPosNotify[0] = CreateEvent(NULL, FALSE, FALSE, NULL);
if (!hPosNotify) { if (!hPosNotify)
{
DSOUND_Shutdown(); DSOUND_Shutdown();
DSOUND_SetErrorCode(DSOUND_FailedCreateNotifyEvent); DSOUND_SetErrorCode(DSOUND_FailedCreateNotifyEvent);
return DSOUND_Error; return DSOUND_Error;
@ -288,7 +301,8 @@ int DSOUND_Init(int soundcard, int mixrate, int numchannels, int samplebits, int
posn.hEventNotify = hPosNotify[0]; posn.hEventNotify = hPosNotify[0];
hr = IDirectSoundNotify_SetNotificationPositions(lpDSNotify, 1, &posn); hr = IDirectSoundNotify_SetNotificationPositions(lpDSNotify, 1, &posn);
if (hr != DS_OK) { if (hr != DS_OK)
{
DSOUND_Shutdown(); DSOUND_Shutdown();
DSOUND_SetErrorCode(DSOUND_FailedSetNotify); DSOUND_SetErrorCode(DSOUND_FailedSetNotify);
return DSOUND_Error; return DSOUND_Error;
@ -315,39 +329,46 @@ int DSOUND_Shutdown(void)
DSOUND_StopPlayback(); DSOUND_StopPlayback();
if (lpDSNotify) { if (lpDSNotify)
{
IDirectSoundNotify_Release(lpDSNotify); IDirectSoundNotify_Release(lpDSNotify);
lpDSNotify = NULL; lpDSNotify = NULL;
} }
if (hPosNotify) { if (hPosNotify)
for (i=0; i<_DSOUND_NumBuffers; i++) { {
for (i=0; i<_DSOUND_NumBuffers; i++)
{
if (hPosNotify[i]) CloseHandle(hPosNotify[i]); if (hPosNotify[i]) CloseHandle(hPosNotify[i]);
} }
free(hPosNotify); free(hPosNotify);
hPosNotify = NULL; hPosNotify = NULL;
} }
if (lpDSBSecondary) { if (lpDSBSecondary)
{
printOSD(" - Releasing secondary buffer\n"); printOSD(" - Releasing secondary buffer\n");
IDirectSoundBuffer_Stop(lpDSBSecondary); IDirectSoundBuffer_Stop(lpDSBSecondary);
IDirectSoundBuffer_Release(lpDSBSecondary); IDirectSoundBuffer_Release(lpDSBSecondary);
lpDSBSecondary = NULL; lpDSBSecondary = NULL;
} }
if (lpDSBPrimary) { if (lpDSBPrimary)
{
printOSD(" - Releasing primary buffer\n"); printOSD(" - Releasing primary buffer\n");
IDirectSoundBuffer_Release(lpDSBPrimary); IDirectSoundBuffer_Release(lpDSBPrimary);
lpDSBPrimary = NULL; lpDSBPrimary = NULL;
} }
if (lpDS) { if (lpDS)
{
printOSD(" - Releasing DirectSound object\n"); printOSD(" - Releasing DirectSound object\n");
IDirectSound_Release(lpDS); IDirectSound_Release(lpDS);
lpDS = NULL; lpDS = NULL;
} }
if (hDSoundDLL) { if (hDSoundDLL)
{
printOSD(" - Unloading DSOUND.DLL\n"); printOSD(" - Unloading DSOUND.DLL\n");
FreeLibrary(hDSoundDLL); FreeLibrary(hDSoundDLL);
hDSoundDLL = NULL; hDSoundDLL = NULL;
@ -396,18 +417,21 @@ static DWORD WINAPI isr(LPVOID parm)
h = creat("audio.raw",S_IREAD|S_IWRITE); h = creat("audio.raw",S_IREAD|S_IWRITE);
#endif #endif
while (1) { while (1)
{
rv = WaitForMultipleObjects(1+_DSOUND_NumBuffers, handles, FALSE, INFINITE); rv = WaitForMultipleObjects(1+_DSOUND_NumBuffers, handles, FALSE, INFINITE);
if (!(rv >= WAIT_OBJECT_0 && rv <= WAIT_OBJECT_0+1+_DSOUND_NumBuffers)) return -1; if (!(rv >= WAIT_OBJECT_0 && rv <= WAIT_OBJECT_0+1+_DSOUND_NumBuffers)) return -1;
if (rv == WAIT_OBJECT_0) { if (rv == WAIT_OBJECT_0)
{
// we've been asked to finish up // we've been asked to finish up
break; break;
} }
// otherwise we just service the interrupt // otherwise we just service the interrupt
if (_DSOUND_CallBack) { if (_DSOUND_CallBack)
{
DisableInterrupts(); DisableInterrupts();
p = _DSOUND_CallBack(rv-WAIT_OBJECT_0-1); p = _DSOUND_CallBack(rv-WAIT_OBJECT_0-1);
@ -417,10 +441,12 @@ static DWORD WINAPI isr(LPVOID parm)
hr = IDirectSoundBuffer_Lock(lpDSBSecondary, p*_DSOUND_BufferLength, _DSOUND_BufferLength, hr = IDirectSoundBuffer_Lock(lpDSBSecondary, p*_DSOUND_BufferLength, _DSOUND_BufferLength,
&lockptr, &lockbytes, &lockptr2, &lockbytes2, 0); &lockptr, &lockbytes, &lockptr2, &lockbytes2, 0);
if (hr == DSERR_BUFFERLOST) { if (hr == DSERR_BUFFERLOST)
{
hr = IDirectSoundBuffer_Restore(lpDSBSecondary); hr = IDirectSoundBuffer_Restore(lpDSBSecondary);
} }
if (hr == DS_OK) { if (hr == DS_OK)
{
/* /*
#define copybuf(S,D,c) \ #define copybuf(S,D,c) \
({ void *__S=(S), *__D=(D); long __c=(c); \ ({ void *__S=(S), *__D=(D); long __c=(c); \
@ -461,33 +487,39 @@ int DSOUND_BeginBufferedPlayback(char *BufferStart, int (*CallBackFunc)(int), in
if (!lpDSBSecondary) return DSOUND_Error; if (!lpDSBSecondary) return DSOUND_Error;
if (isrthread) { if (isrthread)
{
DSOUND_StopPlayback(); DSOUND_StopPlayback();
} }
isrfinish = CreateEvent(NULL, TRUE, FALSE, NULL); isrfinish = CreateEvent(NULL, TRUE, FALSE, NULL);
if (!isrfinish) { if (!isrfinish)
{
DSOUND_SetErrorCode(DSOUND_FailedCreateFinishEvent); DSOUND_SetErrorCode(DSOUND_FailedCreateFinishEvent);
return DSOUND_Error; return DSOUND_Error;
} }
isrthread = CreateThread(NULL, 0, isr, NULL, CREATE_SUSPENDED, &threadid); isrthread = CreateThread(NULL, 0, isr, NULL, CREATE_SUSPENDED, &threadid);
if (!isrthread) { if (!isrthread)
{
DSOUND_SetErrorCode(DSOUND_FailedCreateThread); DSOUND_SetErrorCode(DSOUND_FailedCreateThread);
return DSOUND_Error; return DSOUND_Error;
} }
hPosNotify = (HANDLE *)malloc(sizeof(HANDLE)*numdivisions); hPosNotify = (HANDLE *)malloc(sizeof(HANDLE)*numdivisions);
if (!hPosNotify) { if (!hPosNotify)
{
DSOUND_Shutdown(); DSOUND_Shutdown();
DSOUND_SetErrorCode(DSOUND_FailedSetNotify); DSOUND_SetErrorCode(DSOUND_FailedSetNotify);
return DSOUND_Error; return DSOUND_Error;
} }
memset(hPosNotify, 0, sizeof(HANDLE)*numdivisions); memset(hPosNotify, 0, sizeof(HANDLE)*numdivisions);
for (i=0; i<numdivisions; i++) { for (i=0; i<numdivisions; i++)
{
hPosNotify[i] = CreateEvent(NULL, FALSE, FALSE, NULL); hPosNotify[i] = CreateEvent(NULL, FALSE, FALSE, NULL);
if (!hPosNotify[i]) { if (!hPosNotify[i])
{
DSOUND_Shutdown(); DSOUND_Shutdown();
DSOUND_SetErrorCode(DSOUND_FailedSetNotify); DSOUND_SetErrorCode(DSOUND_FailedSetNotify);
return DSOUND_Error; return DSOUND_Error;
@ -495,7 +527,8 @@ int DSOUND_BeginBufferedPlayback(char *BufferStart, int (*CallBackFunc)(int), in
} }
posns = (LPDSBPOSITIONNOTIFY)malloc(sizeof(DSBPOSITIONNOTIFY)*numdivisions); posns = (LPDSBPOSITIONNOTIFY)malloc(sizeof(DSBPOSITIONNOTIFY)*numdivisions);
if (!posns) { if (!posns)
{
DSOUND_Shutdown(); DSOUND_Shutdown();
DSOUND_SetErrorCode(DSOUND_FailedSetNotify); DSOUND_SetErrorCode(DSOUND_FailedSetNotify);
return DSOUND_Error; return DSOUND_Error;
@ -503,13 +536,15 @@ int DSOUND_BeginBufferedPlayback(char *BufferStart, int (*CallBackFunc)(int), in
_DSOUND_BufferLength = buffersize/numdivisions; _DSOUND_BufferLength = buffersize/numdivisions;
_DSOUND_NumBuffers = numdivisions; _DSOUND_NumBuffers = numdivisions;
for (i=0; i<numdivisions; i++) { for (i=0; i<numdivisions; i++)
{
posns[i].dwOffset = i*_DSOUND_BufferLength; posns[i].dwOffset = i*_DSOUND_BufferLength;
posns[i].hEventNotify = hPosNotify[i]; posns[i].hEventNotify = hPosNotify[i];
} }
hr = IDirectSoundNotify_SetNotificationPositions(lpDSNotify, numdivisions, posns); hr = IDirectSoundNotify_SetNotificationPositions(lpDSNotify, numdivisions, posns);
if (hr != DS_OK) { if (hr != DS_OK)
{
free(posns); free(posns);
DSOUND_Shutdown(); DSOUND_Shutdown();
DSOUND_SetErrorCode(DSOUND_FailedSetNotify); DSOUND_SetErrorCode(DSOUND_FailedSetNotify);
@ -522,7 +557,8 @@ int DSOUND_BeginBufferedPlayback(char *BufferStart, int (*CallBackFunc)(int), in
ResumeThread(isrthread); ResumeThread(isrthread);
hr = IDirectSoundBuffer_Play(lpDSBSecondary, 0, 0, DSBPLAY_LOOPING); hr = IDirectSoundBuffer_Play(lpDSBSecondary, 0, 0, DSBPLAY_LOOPING);
if (hr != DS_OK) { if (hr != DS_OK)
{
DSOUND_SetErrorCode(DSOUND_FailedPlaySecondary); DSOUND_SetErrorCode(DSOUND_FailedPlaySecondary);
return DSOUND_Error; return DSOUND_Error;
} }
@ -541,7 +577,8 @@ int DSOUND_StopPlayback(void)
BOOL t; BOOL t;
int i; int i;
if (isrthread) { if (isrthread)
{
SetEvent(isrfinish); SetEvent(isrfinish);
printOSD("DirectSound: Waiting for sound thread to exit\n"); printOSD("DirectSound: Waiting for sound thread to exit\n");
@ -562,17 +599,21 @@ int DSOUND_StopPlayback(void)
isrthread = NULL; isrthread = NULL;
} }
if (isrfinish) { if (isrfinish)
{
CloseHandle(isrfinish); CloseHandle(isrfinish);
isrfinish = NULL; isrfinish = NULL;
} }
if (lpDSBSecondary) { if (lpDSBSecondary)
{
IDirectSoundBuffer_Stop(lpDSBSecondary); IDirectSoundBuffer_Stop(lpDSBSecondary);
} }
if (hPosNotify) { if (hPosNotify)
for (i=0; i<_DSOUND_NumBuffers; i++) { {
for (i=0; i<_DSOUND_NumBuffers; i++)
{
if (hPosNotify[i]) CloseHandle(hPosNotify[i]); if (hPosNotify[i]) CloseHandle(hPosNotify[i]);
} }
free(hPosNotify); free(hPosNotify);

50
polymer/eduke32/source/jaudiolib/interrup.h Executable file
View file

@ -0,0 +1,50 @@
/*
Copyright (C) 1994-1995 Apogee Software, Ltd.
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.
*/
/**********************************************************************
module: INTERRUP.H
author: James R. Dose
date: March 31, 1994
Inline functions for disabling and restoring the interrupt flag.
(c) Copyright 1994 James R. Dose. All Rights Reserved.
**********************************************************************/
#ifndef __INTERRUPT_H
#define __INTERRUPT_H
unsigned long DisableInterrupts( void );
void RestoreInterrupts( unsigned long flags );
#ifdef PLAT_DOS
#pragma aux DisableInterrupts = \
"pushfd", \
"pop eax", \
"cli" \
modify [ eax ];
#pragma aux RestoreInterrupts = \
"push eax", \
"popfd" \
parm [ eax ];
#endif
#endif

75
polymer/eduke32/source/jaudiolib/midi.c
View file

@ -55,8 +55,11 @@ static int ( *_MIDI_RerouteFunctions[ NUM_MIDI_CHANNELS ] )
int event, int event,
int c1, int c1,
int c2 int c2
) = { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, ) =
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL }; {
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL
};
static track *_MIDI_TrackPtr = NULL; static track *_MIDI_TrackPtr = NULL;
static int _MIDI_TrackMemSize; static int _MIDI_TrackMemSize;
@ -544,15 +547,20 @@ static int _MIDI_ServiceRoutine ( void )
int c2; int c2;
int TimeSet = FALSE; int TimeSet = FALSE;
if ( _MIDI_SongActive ) { if (_MIDI_SongActive)
{
Track = _MIDI_TrackPtr; Track = _MIDI_TrackPtr;
tracknum = 0; tracknum = 0;
while( tracknum < _MIDI_NumTracks ) { while (tracknum < _MIDI_NumTracks)
while ( ( Track->active ) && ( Track->delay == 0 ) ) { {
while ((Track->active) && (Track->delay == 0))
{
GET_NEXT_EVENT(Track, event); GET_NEXT_EVENT(Track, event);
if ( GET_MIDI_COMMAND( event ) == MIDI_SPECIAL ) { if (GET_MIDI_COMMAND(event) == MIDI_SPECIAL)
switch( event ) { {
switch (event)
{
case MIDI_SYSEX : case MIDI_SYSEX :
case MIDI_SYSEX_CONTINUE : case MIDI_SYSEX_CONTINUE :
_MIDI_SysEx(Track); _MIDI_SysEx(Track);
@ -563,15 +571,19 @@ static int _MIDI_ServiceRoutine ( void )
break; break;
} }
if ( Track->active ) { if (Track->active)
{
Track->delay = _MIDI_ReadDelta(Track); Track->delay = _MIDI_ReadDelta(Track);
} }
continue; continue;
} }
if ( event & MIDI_RUNNING_STATUS ) { if (event & MIDI_RUNNING_STATUS)
{
Track->RunningStatus = event; Track->RunningStatus = event;
} else { }
else
{
event = Track->RunningStatus; event = Track->RunningStatus;
Track->pos--; Track->pos--;
} }
@ -579,37 +591,45 @@ static int _MIDI_ServiceRoutine ( void )
channel = GET_MIDI_CHANNEL(event); channel = GET_MIDI_CHANNEL(event);
command = GET_MIDI_COMMAND(event); command = GET_MIDI_COMMAND(event);
if ( _MIDI_CommandLengths[ command ] > 0 ) { if (_MIDI_CommandLengths[ command ] > 0)
{
GET_NEXT_EVENT(Track, c1); GET_NEXT_EVENT(Track, c1);
if ( _MIDI_CommandLengths[ command ] > 1 ) { if (_MIDI_CommandLengths[ command ] > 1)
{
GET_NEXT_EVENT(Track, c2); GET_NEXT_EVENT(Track, c2);
} }
} }
if ( _MIDI_RerouteFunctions[ channel ] != NULL ) { if (_MIDI_RerouteFunctions[ channel ] != NULL)
{
status = _MIDI_RerouteFunctions[ channel ](event, c1, c2); status = _MIDI_RerouteFunctions[ channel ](event, c1, c2);
if ( status == MIDI_DONT_PLAY ) { if (status == MIDI_DONT_PLAY)
{
Track->delay = _MIDI_ReadDelta(Track); Track->delay = _MIDI_ReadDelta(Track);
continue; continue;
} }
} }
switch ( command ) { switch (command)
{
case MIDI_NOTE_OFF : case MIDI_NOTE_OFF :
if ( _MIDI_Funcs->NoteOff ) { if (_MIDI_Funcs->NoteOff)
{
_MIDI_Funcs->NoteOff(channel, c1, c2); _MIDI_Funcs->NoteOff(channel, c1, c2);
} }
break; break;
case MIDI_NOTE_ON : case MIDI_NOTE_ON :
if ( _MIDI_Funcs->NoteOn ) { if (_MIDI_Funcs->NoteOn)
{
_MIDI_Funcs->NoteOn(channel, c1, c2); _MIDI_Funcs->NoteOn(channel, c1, c2);
} }
break; break;
case MIDI_POLY_AFTER_TCH : case MIDI_POLY_AFTER_TCH :
if ( _MIDI_Funcs->PolyAftertouch ) { if (_MIDI_Funcs->PolyAftertouch)
{
_MIDI_Funcs->PolyAftertouch(channel, c1, c2); _MIDI_Funcs->PolyAftertouch(channel, c1, c2);
} }
break; break;
@ -619,19 +639,22 @@ static int _MIDI_ServiceRoutine ( void )
break; break;
case MIDI_PROGRAM_CHANGE : case MIDI_PROGRAM_CHANGE :
if ( ( _MIDI_Funcs->ProgramChange ) && ( !Track->EMIDI_ProgramChange ) ) { if ((_MIDI_Funcs->ProgramChange) && (!Track->EMIDI_ProgramChange))
{
_MIDI_Funcs->ProgramChange(channel, MIDI_PatchMap[ c1 & 0x7f ]); _MIDI_Funcs->ProgramChange(channel, MIDI_PatchMap[ c1 & 0x7f ]);
} }
break; break;
case MIDI_AFTER_TOUCH : case MIDI_AFTER_TOUCH :
if ( _MIDI_Funcs->ChannelAftertouch ) { if (_MIDI_Funcs->ChannelAftertouch)
{
_MIDI_Funcs->ChannelAftertouch(channel, c1); _MIDI_Funcs->ChannelAftertouch(channel, c1);
} }
break; break;
case MIDI_PITCH_BEND : case MIDI_PITCH_BEND :
if ( _MIDI_Funcs->PitchBend ) { if (_MIDI_Funcs->PitchBend)
{
_MIDI_Funcs->PitchBend(channel, c1, c2); _MIDI_Funcs->PitchBend(channel, c1, c2);
} }
break; break;
@ -647,12 +670,16 @@ static int _MIDI_ServiceRoutine ( void )
Track++; Track++;
tracknum++; tracknum++;
if ( _MIDI_ActiveTracks == 0 ) { if (_MIDI_ActiveTracks == 0)
{
_MIDI_ResetTracks(); _MIDI_ResetTracks();
if ( _MIDI_Loop ) { if (_MIDI_Loop)
{
tracknum = 0; tracknum = 0;
Track = _MIDI_TrackPtr; Track = _MIDI_TrackPtr;
} else { }
else
{
_MIDI_SongActive = FALSE; _MIDI_SongActive = FALSE;
break; break;
} }

40
polymer/eduke32/source/jaudiolib/mpu401.c
View file

@ -40,11 +40,13 @@ static HMIDISTRM hmido = (HMIDISTRM)-1;
static MIDIOUTCAPS midicaps; static MIDIOUTCAPS midicaps;
static DWORD mididevice = -1; static DWORD mididevice = -1;
typedef struct { typedef struct
{
long time; long time;
long stream; long stream;
long event; long event;
} MIDIEVENTHEAD; }
MIDIEVENTHEAD;
#define PAD(x) ((((x)+3)&(~3))) #define PAD(x) ((((x)+3)&(~3)))
#define BUFFERLEN (32*4*4) #define BUFFERLEN (32*4*4)
@ -112,11 +114,14 @@ void MPU_Unpause(void)
void CALLBACK MPU_MIDICallback(HMIDIOUT handle, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2) void CALLBACK MPU_MIDICallback(HMIDIOUT handle, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2)
{ {
int i; int i;
switch (uMsg) { switch (uMsg)
{
case MOM_DONE: case MOM_DONE:
midiOutUnprepareHeader((HMIDIOUT)handle, (MIDIHDR*)dwParam1, sizeof(MIDIHDR)); midiOutUnprepareHeader((HMIDIOUT)handle, (MIDIHDR*)dwParam1, sizeof(MIDIHDR));
for (i=0;i<NUMBUFFERS;i++) { for (i=0;i<NUMBUFFERS;i++)
if (dwParam1 == (long)&bufferheaders[i]) { {
if (dwParam1 == (long)&bufferheaders[i])
{
eventcnt[i] = 0; // marks the buffer as free eventcnt[i] = 0; // marks the buffer as free
// printf("Finished buffer %d\n",i); // printf("Finished buffer %d\n",i);
_MPU_BuffersWaiting--; _MPU_BuffersWaiting--;
@ -139,7 +144,8 @@ void CALLBACK MPU_MIDICallback(HMIDIOUT handle, UINT uMsg, DWORD dwInstance, DWO
int MPU_GetNextBuffer(void) int MPU_GetNextBuffer(void)
{ {
int i; int i;
for (i=0; i<NUMBUFFERS; i++) { for (i=0; i<NUMBUFFERS; i++)
{
if (eventcnt[i] == 0) return i; if (eventcnt[i] == 0) return i;
} }
return -1; return -1;
@ -152,11 +158,14 @@ void MPU_SendMidi( char *data, int count )
static int masks[3] = { 0x000000ffl, 0x0000ffffl, 0x00ffffffl }; static int masks[3] = { 0x000000ffl, 0x0000ffffl, 0x00ffffffl };
if (count <= 0) return; if (count <= 0) return;
if (count <= 3) { if (count <= 3)
if (eventcnt[_MPU_CurrentBuffer] + 12 > BUFFERLEN) { {
if (eventcnt[_MPU_CurrentBuffer] + 12 > BUFFERLEN)
{
// buffer over-full // buffer over-full
nextbuffer = MPU_GetNextBuffer(); nextbuffer = MPU_GetNextBuffer();
if (nextbuffer < 0) { if (nextbuffer < 0)
{
// printf("All buffers full!\n"); // printf("All buffers full!\n");
return; return;
} }
@ -169,12 +178,16 @@ void MPU_SendMidi( char *data, int count )
((long*)p)[1] = 0; ((long*)p)[1] = 0;
((long*)p)[2] = (MEVT_SHORTMSG << 24) | ((*((long*)data)) & masks[count-1]); ((long*)p)[2] = (MEVT_SHORTMSG << 24) | ((*((long*)data)) & masks[count-1]);
eventcnt[_MPU_CurrentBuffer] += 12; eventcnt[_MPU_CurrentBuffer] += 12;
} else { }
else
{
padded = PAD(count); padded = PAD(count);
if (eventcnt[_MPU_CurrentBuffer] + 12 + padded > BUFFERLEN) { if (eventcnt[_MPU_CurrentBuffer] + 12 + padded > BUFFERLEN)
{
// buffer over-full // buffer over-full
nextbuffer = MPU_GetNextBuffer(); nextbuffer = MPU_GetNextBuffer();
if (nextbuffer < 0) { if (nextbuffer < 0)
{
// printf("All buffers full!\n"); // printf("All buffers full!\n");
return; return;
} }
@ -208,7 +221,8 @@ void MPU_SendMidiImmediate( char *data, int count )
if (!count) return; if (!count) return;
if (count<=3) midiOutShortMsg((HMIDIOUT)hmido, (*((long*)data)) & masks[count-1]); if (count<=3) midiOutShortMsg((HMIDIOUT)hmido, (*((long*)data)) & masks[count-1]);
else { else
{
ZeroMemory(&mhdr, sizeof(mhdr)); ZeroMemory(&mhdr, sizeof(mhdr));
mhdr.lpData = data; mhdr.lpData = data;
mhdr.dwBufferLength = count; mhdr.dwBufferLength = count;

6
polymer/eduke32/source/jaudiolib/music.c
View file

@ -551,8 +551,7 @@ void MUSIC_StopFade
void void
) )
{ {}
}
/*--------------------------------------------------------------------- /*---------------------------------------------------------------------
@ -584,8 +583,7 @@ void MUSIC_RegisterTimbreBank
unsigned char *timbres unsigned char *timbres
) )
{ {}
}
void MUSIC_Update(void) void MUSIC_Update(void)

50
polymer/eduke32/source/jaudiolib/nodpmi.c Executable file
View file

@ -0,0 +1,50 @@
/*
Copyright (C) 1994-1995 Apogee Software, Ltd.
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.
*/
/**********************************************************************
module: NODPMI.C
Functions for faking DPMI calls.
**********************************************************************/
#include <stdlib.h>
#include <string.h>
#include "dpmi.h"
#define TRUE ( 1 == 1 )
#define FALSE ( !TRUE )
int DPMI_GetDOSMemory(void **ptr, int *descriptor, unsigned length)
{
/* Lovely... */
*ptr = (void *)malloc(length);
*descriptor = (int) *ptr;
return (descriptor == 0) ? DPMI_Error : DPMI_Ok;
}
int DPMI_FreeDOSMemory(int descriptor)
{
free((void *)descriptor);
return (descriptor == 0) ? DPMI_Error : DPMI_Ok;
}

6
polymer/eduke32/source/jaudiolib/pitch.c
View file

@ -38,10 +38,12 @@ Modifications for JonoF's port by Jonathon Fowler (jonof@edgenetwk.com)
static unsigned long PitchTable[ 12 ][ MAXDETUNE ] = static unsigned long PitchTable[ 12 ][ MAXDETUNE ] =
{ {
{ 0x10000, 0x10097, 0x1012f, 0x101c7, 0x10260, 0x102f9, 0x10392, 0x1042c, {
0x10000, 0x10097, 0x1012f, 0x101c7, 0x10260, 0x102f9, 0x10392, 0x1042c,
0x104c6, 0x10561, 0x105fb, 0x10696, 0x10732, 0x107ce, 0x1086a, 0x10907, 0x104c6, 0x10561, 0x105fb, 0x10696, 0x10732, 0x107ce, 0x1086a, 0x10907,
0x109a4, 0x10a41, 0x10adf, 0x10b7d, 0x10c1b, 0x10cba, 0x10d59, 0x10df8, 0x109a4, 0x10a41, 0x10adf, 0x10b7d, 0x10c1b, 0x10cba, 0x10d59, 0x10df8,
0x10e98 }, 0x10e98
},
{ 0x10f38, 0x10fd9, 0x1107a, 0x1111b, 0x111bd, 0x1125f, 0x11302, 0x113a5, { 0x10f38, 0x10fd9, 0x1107a, 0x1111b, 0x111bd, 0x1125f, 0x11302, 0x113a5,
0x11448, 0x114eb, 0x1158f, 0x11634, 0x116d8, 0x1177e, 0x11823, 0x118c9, 0x11448, 0x114eb, 0x1158f, 0x11634, 0x116d8, 0x1177e, 0x11823, 0x118c9,
0x1196f, 0x11a16, 0x11abd, 0x11b64, 0x11c0c, 0x11cb4, 0x11d5d, 0x11e06, 0x1196f, 0x11a16, 0x11abd, 0x11b64, 0x11c0c, 0x11cb4, 0x11d5d, 0x11e06,

61
polymer/eduke32/source/jaudiolib/platform.h Executable file
View file

@ -0,0 +1,61 @@
#ifndef _INCLUDE_PLATFORM_H_
#define _INCLUDE_PLATFORM_H_
#if (!defined __EXPORT__)
#define __EXPORT__
#endif
#if (defined __WATCOMC__)
#define snprintf _snprintf
#endif
static __inline unsigned short _swap16(unsigned short D)
{
#if PLATFORM_MACOSX
register unsigned short returnValue;
__asm__ volatile("lhbrx %0,0,%1"
: "=r" (returnValue)
: "r" (&D)
);
return returnValue;
#else
return((D<<8)|(D>>8));
#endif
}
static __inline unsigned int _swap32(unsigned int D)
{
#if PLATFORM_MACOSX
register unsigned int returnValue;
__asm__ volatile("lwbrx %0,0,%1"
: "=r" (returnValue)
: "r" (&D)
);
return returnValue;
#else
return((D<<24)|((D<<8)&0x00FF0000)|((D>>8)&0x0000FF00)|(D>>24));
#endif
}
#if PLATFORM_MACOSX
#define PLATFORM_BIGENDIAN 1
#define BUILDSWAP_INTEL16(x) _swap16(x)
#define BUILDSWAP_INTEL32(x) _swap32(x)
#else
#if __BYTE_ORDER == __LITTLE_ENDIAN
#define PLATFORM_LITTLEENDIAN 1
#define BUILDSWAP_INTEL16(x) (x)
#define BUILDSWAP_INTEL32(x) (x)
#else
#define PLATFORM_BIGENDIAN 1
#define BUILDSWAP_INTEL16(x) _swap16(x)
#define BUILDSWAP_INTEL32(x) _swap32(x)
#endif
#endif
extern int has_altivec; /* PowerPC-specific. */
#endif /* !defined _INCLUDE_PLATFORM_H_ */
/* end of platform.h ... */

477
polymer/eduke32/source/jaudiolib/sdlmusic.c Executable file
View file

@ -0,0 +1,477 @@
/*
Copyright (C) 2003-2004 Ryan C. Gordon. and James Bentler
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.
Originally written by Ryan C. Gordon. (icculus@clutteredmind.org)
Adapted to work with JonoF's port by James Bentler (bentler@cs.umn.edu)
*/
/*
* A reimplementation of Jim Dose's FX_MAN routines, using SDL_mixer 1.2.
* Whee. FX_MAN is also known as the "Apogee Sound System", or "ASS" for
* short. How strangely appropriate that seems.
*/
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <assert.h>
#include "duke3d.h"
#include "cache1d.h"
#ifndef MAX_PATH
#define MAX_PATH 256
#endif
#if (defined __WATCOMC__)
// This is probably out of date. --ryan.
#include "dukesnd_watcom.h"
#endif
#if (!defined __WATCOMC__)
#define cdecl
#endif
#include <SDL.h>
#include <SDL_mixer.h>
#include "music.h"
#define __FX_TRUE (1 == 1)
#define __FX_FALSE (!__FX_TRUE)
#define DUKESND_DEBUG "DUKESND_DEBUG"
#ifndef min
#define min(a, b) (((a) < (b)) ? (a) : (b))
#endif
#ifndef max
#define max(a, b) (((a) > (b)) ? (a) : (b))
#endif
void GetUnixPathFromEnvironment(char *fullname, int32 length, const char *filename);
int MUSIC_ErrorCode = MUSIC_Ok;
static char warningMessage[80];
static char errorMessage[80];
static int fx_initialized = 0;
static int numChannels = MIX_CHANNELS;
static void(*callback)(unsigned long);
static int reverseStereo = 0;
static int reverbDelay = 256;
static int reverbLevel = 0;
static int fastReverb = 0;
static FILE *debug_file = NULL;
static int initialized_debugging = 0;
static int mixerIsStereo = 1;
// This gets called all over the place for information and debugging messages.
// If the user set the DUKESND_DEBUG environment variable, the messages
// go to the file that is specified in that variable. Otherwise, they
// are ignored for the expense of the function call. If DUKESND_DEBUG is
// set to "-" (without the quotes), then the output goes to stdout.
static void musdebug(const char *fmt, ...)
{
va_list ap;
if (debug_file)
{
fprintf(debug_file, "DUKEMUS: ");
va_start(ap, fmt);
vfprintf(debug_file, fmt, ap);
va_end(ap);
fprintf(debug_file, "\n");
fflush(debug_file);
} // if
} // musdebug
static void init_debugging(void)
{
const char *envr;
if (initialized_debugging)
return;
envr = getenv(DUKESND_DEBUG);
if (envr != NULL)
{
if (strcmp(envr, "-") == 0)
debug_file = stdout;
else
debug_file = fopen(envr, "w");
if (debug_file == NULL)
fprintf(stderr, "DUKESND: -WARNING- Could not open debug file!\n");
else
setbuf(debug_file, NULL);
} // if
initialized_debugging = 1;
} // init_debugging
static void setWarningMessage(const char *msg)
{
strncpy(warningMessage, msg, sizeof(warningMessage));
// strncpy() doesn't add the null char if there isn't room...
warningMessage[sizeof(warningMessage) - 1] = '\0';
musdebug("Warning message set to [%s].", warningMessage);
} // setErrorMessage
static void setErrorMessage(const char *msg)
{
strncpy(errorMessage, msg, sizeof(errorMessage));
// strncpy() doesn't add the null char if there isn't room...
errorMessage[sizeof(errorMessage) - 1] = '\0';
musdebug("Error message set to [%s].", errorMessage);
} // setErrorMessage
// The music functions...
char *MUSIC_ErrorString(int ErrorNumber)
{
switch (ErrorNumber)
{
case MUSIC_Warning:
return(warningMessage);
case MUSIC_Error:
return(errorMessage);
case MUSIC_Ok:
return("OK; no error.");
case MUSIC_ASSVersion:
return("Incorrect sound library version.");
case MUSIC_SoundCardError:
return("General sound card error.");
case MUSIC_InvalidCard:
return("Invalid sound card.");
case MUSIC_MidiError:
return("MIDI error.");
case MUSIC_MPU401Error:
return("MPU401 error.");
case MUSIC_TaskManError:
return("Task Manager error.");
//case MUSIC_FMNotDetected:
// return("FM not detected error.");
case MUSIC_DPMI_Error:
return("DPMI error.");
default:
return("Unknown error.");
} // switch
assert(0); // shouldn't hit this point.
return(NULL);
} // MUSIC_ErrorString
static int music_initialized = 0;
static int music_context = 0;
static int music_loopflag = MUSIC_PlayOnce;
static char *music_songdata = NULL;
static Mix_Music *music_musicchunk = NULL;
int MUSIC_Init(int SoundCard, int Address)
{
init_debugging();
musdebug("INIT! card=>%d, address=>%d...", SoundCard, Address);
if (music_initialized)
{
setErrorMessage("Music system is already initialized.");
return(MUSIC_Error);
} // if
SoundCard = 1;
music_initialized = 1;
return(MUSIC_Ok);
} // MUSIC_Init
int MUSIC_Shutdown(void)
{
musdebug("shutting down sound subsystem.");
MUSIC_StopSong();
music_context = 0;
music_initialized = 0;
music_loopflag = MUSIC_PlayOnce;
return(MUSIC_Ok);
} // MUSIC_Shutdown
void MUSIC_SetMaxFMMidiChannel(int channel)
{
musdebug("STUB ... MUSIC_SetMaxFMMidiChannel(%d).\n", channel);
} // MUSIC_SetMaxFMMidiChannel
void MUSIC_SetVolume(int volume)
{
volume = max(0, volume);
volume = min(volume, 255);
Mix_VolumeMusic(volume >> 1); // convert 0-255 to 0-128.
} // MUSIC_SetVolume
void MUSIC_SetMidiChannelVolume(int channel, int volume)
{
musdebug("STUB ... MUSIC_SetMidiChannelVolume(%d, %d).\n", channel, volume);
} // MUSIC_SetMidiChannelVolume
void MUSIC_ResetMidiChannelVolumes(void)
{
musdebug("STUB ... MUSIC_ResetMidiChannelVolumes().\n");
} // MUSIC_ResetMidiChannelVolumes
int MUSIC_GetVolume(void)
{
return(Mix_VolumeMusic(-1) << 1); // convert 0-128 to 0-255.
} // MUSIC_GetVolume
void MUSIC_SetLoopFlag(int loopflag)
{
music_loopflag = loopflag;
} // MUSIC_SetLoopFlag
int MUSIC_SongPlaying(void)
{
return((Mix_PlayingMusic()) ? __FX_TRUE : __FX_FALSE);
} // MUSIC_SongPlaying
void MUSIC_Continue(void)
{
if (Mix_PausedMusic())
Mix_ResumeMusic();
else if (music_songdata)
MUSIC_PlaySong(music_songdata, MUSIC_PlayOnce);
} // MUSIC_Continue
void MUSIC_Pause(void)
{
Mix_PauseMusic();
} // MUSIC_Pause
int MUSIC_StopSong(void)
{
//if (!fx_initialized)
if (!Mix_QuerySpec(NULL, NULL, NULL))
{
setErrorMessage("Need FX system initialized, too. Sorry.");
return(MUSIC_Error);
} // if
if ((Mix_PlayingMusic()) || (Mix_PausedMusic()))
Mix_HaltMusic();
if (music_musicchunk)
Mix_FreeMusic(music_musicchunk);
music_songdata = NULL;
music_musicchunk = NULL;
return(MUSIC_Ok);
} // MUSIC_StopSong
int MUSIC_PlaySong(unsigned char *song, int loopflag)
{
//SDL_RWops *rw;
MUSIC_StopSong();
music_songdata = song;
// !!! FIXME: This could be a problem...SDL/SDL_mixer wants a RWops, which
// !!! FIXME: is an i/o abstraction. Since we already have the MIDI data
// !!! FIXME: in memory, we fake it with a memory-based RWops. None of
// !!! FIXME: this is a problem, except the RWops wants to know how big
// !!! FIXME: its memory block is (so it can do things like seek on an
// !!! FIXME: offset from the end of the block), and since we don't have
// !!! FIXME: this information, we have to give it SOMETHING.
/* !!! ARGH! There's no LoadMUS_RW ?!
rw = SDL_RWFromMem((void *) song, (10 * 1024) * 1024); // yikes.
music_musicchunk = Mix_LoadMUS_RW(rw);
Mix_PlayMusic(music_musicchunk, (loopflag == MUSIC_PlayOnce) ? 0 : -1);
*/
return(MUSIC_Ok);
} // MUSIC_PlaySong
extern char ApogeePath[256] = "/tmp/";
// Duke3D-specific. --ryan.
void PlayMusic(char *_filename)
{
//char filename[MAX_PATH];
//strcpy(filename, _filename);
//FixFilePath(filename);
char filename[MAX_PATH];
long handle;
long size;
void *song;
long rc;
MUSIC_StopSong();
// Read from a groupfile, write it to disk so SDL_mixer can read it.
// Lame. --ryan.
handle = kopen4load(_filename, 0);
if (handle == -1)
return;
size = kfilelength(handle);
if (size == -1)
{
kclose(handle);
return;
} // if
song = malloc(size);
if (song == NULL)
{
kclose(handle);
return;
} // if
rc = kread(handle, song, size);
kclose(handle);
if (rc != size)
{
free(song);
return;
} // if
// save the file somewhere, so SDL_mixer can load it
GetUnixPathFromEnvironment(filename, MAX_PATH, "tmpsong.mid");
handle = SafeOpenWrite(filename, filetype_binary);
SafeWrite(handle, song, size);
close(handle);
free(song);
//music_songdata = song;
music_musicchunk = Mix_LoadMUS(filename);
if (music_musicchunk != NULL)
{
// !!! FIXME: I set the music to loop. Hope that's okay. --ryan.
Mix_PlayMusic(music_musicchunk, -1);
} // if
}
void MUSIC_SetContext(int context)
{
musdebug("STUB ... MUSIC_SetContext().\n");
music_context = context;
} // MUSIC_SetContext
int MUSIC_GetContext(void)
{
return(music_context);
} // MUSIC_GetContext
void MUSIC_SetSongTick(unsigned long PositionInTicks)
{
musdebug("STUB ... MUSIC_SetSongTick().\n");
} // MUSIC_SetSongTick
void MUSIC_SetSongTime(unsigned long milliseconds)
{
musdebug("STUB ... MUSIC_SetSongTime().\n");
}// MUSIC_SetSongTime
void MUSIC_SetSongPosition(int measure, int beat, int tick)
{
musdebug("STUB ... MUSIC_SetSongPosition().\n");
} // MUSIC_SetSongPosition
void MUSIC_GetSongPosition(songposition *pos)
{
musdebug("STUB ... MUSIC_GetSongPosition().\n");
} // MUSIC_GetSongPosition
void MUSIC_GetSongLength(songposition *pos)
{
musdebug("STUB ... MUSIC_GetSongLength().\n");
} // MUSIC_GetSongLength
int MUSIC_FadeVolume(int tovolume, int milliseconds)
{
Mix_FadeOutMusic(milliseconds);
return(MUSIC_Ok);
} // MUSIC_FadeVolume
int MUSIC_FadeActive(void)
{
return((Mix_FadingMusic() == MIX_FADING_OUT) ? __FX_TRUE : __FX_FALSE);
} // MUSIC_FadeActive
void MUSIC_StopFade(void)
{
musdebug("STUB ... MUSIC_StopFade().\n");
} // MUSIC_StopFade
void MUSIC_RerouteMidiChannel(int channel, int cdecl(*function)(int event, int c1, int c2))
{
musdebug("STUB ... MUSIC_RerouteMidiChannel().\n");
} // MUSIC_RerouteMidiChannel
void MUSIC_RegisterTimbreBank(unsigned char *timbres)
{
musdebug("STUB ... MUSIC_RegisterTimbreBank().\n");
} // MUSIC_RegisterTimbreBank
void MUSIC_Update(void)
{}

30
polymer/eduke32/source/jaudiolib/sdlout.c
View file

@ -87,7 +87,8 @@ int RestoreInterrupts(int a)
*/ */
char *SDLSOUND_ErrorString(int errorcode) char *SDLSOUND_ErrorString(int errorcode)
{ {
switch (errorcode) { switch (errorcode)
{
case SDLSOUND_Warning: case SDLSOUND_Warning:
case SDLSOUND_Error: case SDLSOUND_Error:
return SDLSOUND_ErrorString(SDLSOUND_ErrorCode); return SDLSOUND_ErrorString(SDLSOUND_ErrorCode);
@ -109,7 +110,8 @@ int SDLSOUND_Init(int soundcard, int mixrate, int numchannels, int samplebits, i
{ {
SDL_AudioSpec spec,got; SDL_AudioSpec spec,got;
if (SDLSOUND_Installed) { if (SDLSOUND_Installed)
{
SDLSOUND_Shutdown(); SDLSOUND_Shutdown();
} }
@ -169,16 +171,19 @@ int SDLSOUND_SetMixMode(int mode)
static void isr(void *userdata, unsigned char *stream, int len) static void isr(void *userdata, unsigned char *stream, int len)
{ {
// otherwise we just service the interrupt // otherwise we just service the interrupt
if (_DSOUND_CallBack) { if (_DSOUND_CallBack)
{
p = _DSOUND_CallBack(rv-WAIT_OBJECT_0-1); p = _DSOUND_CallBack(rv-WAIT_OBJECT_0-1);
hr = IDirectSoundBuffer_Lock(lpDSBSecondary, p*_DSOUND_BufferLength, _DSOUND_BufferLength, hr = IDirectSoundBuffer_Lock(lpDSBSecondary, p*_DSOUND_BufferLength, _DSOUND_BufferLength,
&lockptr, &lockbytes, &lockptr2, &lockbytes2, 0); &lockptr, &lockbytes, &lockptr2, &lockbytes2, 0);
if (hr == DSERR_BUFFERLOST) { if (hr == DSERR_BUFFERLOST)
{
hr = IDirectSoundBuffer_Restore(lpDSBSecondary); hr = IDirectSoundBuffer_Restore(lpDSBSecondary);
} }
if (hr == DS_OK) { if (hr == DS_OK)
{
/* /*
#define copybuf(S,D,c) \ #define copybuf(S,D,c) \
({ void *__S=(S), *__D=(D); long __c=(c); \ ({ void *__S=(S), *__D=(D); long __c=(c); \
@ -222,7 +227,8 @@ int DSOUND_StopPlayback(void)
BOOL t; BOOL t;
int i; int i;
if (isrthread) { if (isrthread)
{
SetEvent(isrfinish); SetEvent(isrfinish);
printOSD("DirectSound: Waiting for sound thread to exit\n"); printOSD("DirectSound: Waiting for sound thread to exit\n");
@ -243,17 +249,21 @@ int DSOUND_StopPlayback(void)
isrthread = NULL; isrthread = NULL;
} }
if (isrfinish) { if (isrfinish)
{
CloseHandle(isrfinish); CloseHandle(isrfinish);
isrfinish = NULL; isrfinish = NULL;
} }
if (lpDSBSecondary) { if (lpDSBSecondary)
{
IDirectSoundBuffer_Stop(lpDSBSecondary); IDirectSoundBuffer_Stop(lpDSBSecondary);
} }
if (hPosNotify) { if (hPosNotify)
for (i=0; i<_DSOUND_NumBuffers; i++) { {
for (i=0; i<_DSOUND_NumBuffers; i++)
{
if (hPosNotify[i]) CloseHandle(hPosNotify[i]); if (hPosNotify[i]) CloseHandle(hPosNotify[i]);
} }
free(hPosNotify); free(hPosNotify);

151
polymer/eduke32/source/jaudiolib/unixglob.c Executable file
View file

@ -0,0 +1,151 @@
/*
Copyright (C) 2003-2004 Ryan C. Gordon. and James Bentler
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.
Originally written by Ryan C. Gordon. (icculus@clutteredmind.org)
Adapted to work with JonoF's port by James Bentler (bentler@cs.umn.edu)
*/
static char ApogeePath[256] = "/tmp/";
#define PATH_SEP_CHAR '/'
#define PATH_SEP_STR "/"
#define ROOTDIR "/"
#define CURDIR "./"
#include "duke3d.h"
#include <dirent.h>
#include <errno.h>
#ifndef MAX_PATH
#define MAX_PATH 256
#endif
void FixFilePath(char *filename)
{
char *ptr;
char *lastsep = filename;
if ((!filename) || (*filename == '\0'))
return;
if (access(filename, F_OK) == 0) /* File exists; we're good to go. */
return;
for (ptr = filename; 1; ptr++)
{
if (*ptr == '\\')
*ptr = PATH_SEP_CHAR;
if ((*ptr == PATH_SEP_CHAR) || (*ptr == '\0'))
{
char pch = *ptr;
struct dirent *dent = NULL;
DIR *dir;
if ((pch == PATH_SEP_CHAR) && (*(ptr + 1) == '\0'))
return; /* eos is pathsep; we're done. */
if (lastsep == ptr)
continue; /* absolute path; skip to next one. */
*ptr = '\0';
if (lastsep == filename)
{
dir = opendir((*lastsep == PATH_SEP_CHAR) ? ROOTDIR : CURDIR);
if (*lastsep == PATH_SEP_CHAR)
{
lastsep++;
}
}
else
{
*lastsep = '\0';
dir = opendir(filename);
*lastsep = PATH_SEP_CHAR;
lastsep++;
}
if (dir == NULL)
{
*ptr = PATH_SEP_CHAR;
return; /* maybe dir doesn't exist? give up. */
}
while ((dent = readdir(dir)) != NULL)
{
if (strcasecmp(dent->d_name, lastsep) == 0)
{
/* found match; replace it. */
strcpy(lastsep, dent->d_name);
break;
}
}
closedir(dir);
*ptr = pch;
lastsep = ptr;
if (dent == NULL)
return; /* no match. oh well. */
if (pch == '\0') /* eos? */
return;
}
}
}
int32 SafeOpenWrite(const char *_filename, int32 filetype)
{
int handle;
char filename[MAX_PATH];
strncpy(filename, _filename, sizeof(filename));
filename[sizeof(filename) - 1] = '\0';
FixFilePath(filename);
handle = open(filename,O_RDWR | O_BINARY | O_CREAT | O_TRUNC
, S_IREAD | S_IWRITE);
if (handle == -1)
Error("Error opening %s: %s",filename,strerror(errno));
return handle;
}
void SafeWrite(int32 handle, void *buffer, int32 count)
{
unsigned iocount;
while (count)
{
iocount = count > 0x8000 ? 0x8000 : count;
if (write(handle,buffer,iocount) != (int)iocount)
Error("File write failure writing %ld bytes",count);
buffer = (void *)((byte *)buffer + iocount);
count -= iocount;
}
}
void GetUnixPathFromEnvironment(char *fullname, int32 length, const char *filename)
{
snprintf(fullname, length-1, "%s%s", ApogeePath, filename);
}

213
polymer/eduke32/source/jaudiolib/unixpitch.c Executable file
View file

@ -0,0 +1,213 @@
/*
Copyright (C) 1994-1995 Apogee Software, Ltd.
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.
*/
/**********************************************************************
module: PITCH.C
author: James R. Dose
date: June 14, 1993
Routines for pitch scaling.
(c) Copyright 1993 James R. Dose. All Rights Reserved.
**********************************************************************/
#include <stdlib.h>
//#include <math.h>
#include "dpmi.h"
#include "standard.h"
#include "pitch.h"
#define MAXDETUNE 25
static unsigned long PitchTable[ 12 ][ MAXDETUNE ] =
{
{
0x10000, 0x10097, 0x1012f, 0x101c7, 0x10260, 0x102f9, 0x10392, 0x1042c,
0x104c6, 0x10561, 0x105fb, 0x10696, 0x10732, 0x107ce, 0x1086a, 0x10907,
0x109a4, 0x10a41, 0x10adf, 0x10b7d, 0x10c1b, 0x10cba, 0x10d59, 0x10df8,
0x10e98
},
{ 0x10f38, 0x10fd9, 0x1107a, 0x1111b, 0x111bd, 0x1125f, 0x11302, 0x113a5,
0x11448, 0x114eb, 0x1158f, 0x11634, 0x116d8, 0x1177e, 0x11823, 0x118c9,
0x1196f, 0x11a16, 0x11abd, 0x11b64, 0x11c0c, 0x11cb4, 0x11d5d, 0x11e06,
0x11eaf },
{ 0x11f59, 0x12003, 0x120ae, 0x12159, 0x12204, 0x122b0, 0x1235c, 0x12409,
0x124b6, 0x12563, 0x12611, 0x126bf, 0x1276d, 0x1281c, 0x128cc, 0x1297b,
0x12a2b, 0x12adc, 0x12b8d, 0x12c3e, 0x12cf0, 0x12da2, 0x12e55, 0x12f08,
0x12fbc },
{ 0x1306f, 0x13124, 0x131d8, 0x1328d, 0x13343, 0x133f9, 0x134af, 0x13566,
0x1361d, 0x136d5, 0x1378d, 0x13846, 0x138fe, 0x139b8, 0x13a72, 0x13b2c,
0x13be6, 0x13ca1, 0x13d5d, 0x13e19, 0x13ed5, 0x13f92, 0x1404f, 0x1410d,
0x141cb },
{ 0x1428a, 0x14349, 0x14408, 0x144c8, 0x14588, 0x14649, 0x1470a, 0x147cc,
0x1488e, 0x14951, 0x14a14, 0x14ad7, 0x14b9b, 0x14c5f, 0x14d24, 0x14dea,
0x14eaf, 0x14f75, 0x1503c, 0x15103, 0x151cb, 0x15293, 0x1535b, 0x15424,
0x154ee },
{ 0x155b8, 0x15682, 0x1574d, 0x15818, 0x158e4, 0x159b0, 0x15a7d, 0x15b4a,
0x15c18, 0x15ce6, 0x15db4, 0x15e83, 0x15f53, 0x16023, 0x160f4, 0x161c5,
0x16296, 0x16368, 0x1643a, 0x1650d, 0x165e1, 0x166b5, 0x16789, 0x1685e,
0x16934 },
{ 0x16a09, 0x16ae0, 0x16bb7, 0x16c8e, 0x16d66, 0x16e3e, 0x16f17, 0x16ff1,
0x170ca, 0x171a5, 0x17280, 0x1735b, 0x17437, 0x17513, 0x175f0, 0x176ce,
0x177ac, 0x1788a, 0x17969, 0x17a49, 0x17b29, 0x17c09, 0x17cea, 0x17dcc,
0x17eae },
{ 0x17f91, 0x18074, 0x18157, 0x1823c, 0x18320, 0x18406, 0x184eb, 0x185d2,
0x186b8, 0x187a0, 0x18888, 0x18970, 0x18a59, 0x18b43, 0x18c2d, 0x18d17,
0x18e02, 0x18eee, 0x18fda, 0x190c7, 0x191b5, 0x192a2, 0x19391, 0x19480,
0x1956f },
{ 0x1965f, 0x19750, 0x19841, 0x19933, 0x19a25, 0x19b18, 0x19c0c, 0x19d00,
0x19df4, 0x19ee9, 0x19fdf, 0x1a0d5, 0x1a1cc, 0x1a2c4, 0x1a3bc, 0x1a4b4,
0x1a5ad, 0x1a6a7, 0x1a7a1, 0x1a89c, 0x1a998, 0x1aa94, 0x1ab90, 0x1ac8d,
0x1ad8b },
{ 0x1ae89, 0x1af88, 0x1b088, 0x1b188, 0x1b289, 0x1b38a, 0x1b48c, 0x1b58f,
0x1b692, 0x1b795, 0x1b89a, 0x1b99f, 0x1baa4, 0x1bbaa, 0x1bcb1, 0x1bdb8,
0x1bec0, 0x1bfc9, 0x1c0d2, 0x1c1dc, 0x1c2e6, 0x1c3f1, 0x1c4fd, 0x1c609,
0x1c716 },
{ 0x1c823, 0x1c931, 0x1ca40, 0x1cb50, 0x1cc60, 0x1cd70, 0x1ce81, 0x1cf93,
0x1d0a6, 0x1d1b9, 0x1d2cd, 0x1d3e1, 0x1d4f6, 0x1d60c, 0x1d722, 0x1d839,
0x1d951, 0x1da69, 0x1db82, 0x1dc9c, 0x1ddb6, 0x1ded1, 0x1dfec, 0x1e109,
0x1e225 },
{ 0x1e343, 0x1e461, 0x1e580, 0x1e6a0, 0x1e7c0, 0x1e8e0, 0x1ea02, 0x1eb24,
0x1ec47, 0x1ed6b, 0x1ee8f, 0x1efb4, 0x1f0d9, 0x1f1ff, 0x1f326, 0x1f44e,
0x1f576, 0x1f69f, 0x1f7c9, 0x1f8f3, 0x1fa1e, 0x1fb4a, 0x1fc76, 0x1fda3,
0x1fed1 }
};
//static int PITCH_Installed = FALSE;
/*---------------------------------------------------------------------
Function: PITCH_Init
Initializes pitch table.
---------------------------------------------------------------------*/
/*
void PITCH_Init
(
void
)
{
int note;
int detune;
if ( !PITCH_Installed )
{
for( note = 0; note < 12; note++ )
{
for( detune = 0; detune < MAXDETUNE; detune++ )
{
PitchTable[ note ][ detune ] = 0x10000 *
pow( 2, ( note * MAXDETUNE + detune ) / ( 12.0 * MAXDETUNE ) );
}
}
PITCH_Installed = TRUE;
}
}
*/
/**********************************************************************
Memory locked functions:
**********************************************************************/
#define PITCH_LockStart PITCH_GetScale
/*---------------------------------------------------------------------
Function: PITCH_GetScale
Returns a fixed-point value to scale number the specified amount.
---------------------------------------------------------------------*/
unsigned long PITCH_GetScale
(
int pitchoffset
)
{
unsigned long scale;
int octaveshift;
int noteshift;
int note;
int detune;
// if ( !PITCH_Installed )
// {
// PITCH_Init();
// }
if (pitchoffset == 0)
{
return(PitchTable[ 0 ][ 0 ]);
}
noteshift = pitchoffset % 1200;
if (noteshift < 0)
{
noteshift += 1200;
}
note = noteshift / 100;
detune = (noteshift % 100) / (100 / MAXDETUNE);
octaveshift = (pitchoffset - noteshift) / 1200;
if (detune < 0)
{
detune += (100 / MAXDETUNE);
note--;
if (note < 0)
{
note += 12;
octaveshift--;
}
}
scale = PitchTable[ note ][ detune ];
if (octaveshift < 0)
{
scale >>= -octaveshift;
}
else
{
scale <<= octaveshift;
}
return(scale);
}
/*---------------------------------------------------------------------
Function: PITCH_LockEnd
Used for determining the length of the functions to lock in memory.
---------------------------------------------------------------------*/
static void PITCH_LockEnd
(
void
)
{}

2710
polymer/eduke32/source/jaudiolib/unixvoc.c Executable file
View file

File diff suppressed because it is too large Load diff

12
polymer/eduke32/source/jaudiolib/util.h Executable file
View file

@ -0,0 +1,12 @@
#ifndef AUDIOLIB__UTIL_H
#define AUDIOLIB__UTIL_H
#ifndef min
#define min(a, b) ((a) < (b) ? (a) : (b))
#endif
#ifndef max
#define max(a, b) ((a) > (b) ? (a) : (b))
#endif
#endif

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

@ -41,15 +41,10 @@ static int currentlist=0;
static int function, whichkey; static int function, whichkey;
static int changesmade, newvidmode, curvidmode, newfullscreen; static int changesmade, newvidmode, curvidmode, newfullscreen;
static int vidsets[16] = static int vidsets[16] = { -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 };
{ static int curvidset, newvidset = 0;
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
}
, curvidset, newvidset = 0;
static char *mousebuttonnames[] = static char *mousebuttonnames[] = { "Left", "Right", "Middle", "Thumb", "Wheel Down", "Wheel Up" };
{ "Left", "Right", "Middle", "Thumb", "Wheel Down", "Wheel Up"
};
extern int gotvote[MAXPLAYERS], votes[MAXPLAYERS], voting; extern int gotvote[MAXPLAYERS], votes[MAXPLAYERS], voting;

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

@ -204,6 +204,7 @@ void intomenusounds(void)
void playmusic(char *fn) void playmusic(char *fn)
{ {
#if defined(_WIN32)
short fp; short fp;
long l; long l;
@ -224,6 +225,15 @@ void playmusic(char *fn)
kread(fp, MusicPtr, l); kread(fp, MusicPtr, l);
kclose(fp); kclose(fp);
MUSIC_PlaySong(MusicPtr, MUSIC_LoopSong); MUSIC_PlaySong(MusicPtr, MUSIC_LoopSong);
#else
void PlayMusic(char *_filename);
if(MusicToggle == 0) return;
if(MusicDevice < 0) return;
// FIXME: I need this to get the music volume initialized (not sure why) -- Jim Bentler
MUSIC_SetVolume( MusicVolume );
PlayMusic(fn);
#endif
} }
char loadsound(unsigned short num) char loadsound(unsigned short num)