static void decodeframe(uint8_t * srcP, uint8_t * dstP)
{
do
{
int32_t count=*srcP++;
if (!count) /* Short RLE */
{
int32_t color = *(srcP+1);
count = *(uint8_t *)((srcP += sizeof(int16_t)) - sizeof(int16_t));
Bmemset((dstP += count) - count, color, count);
continue;
}
else if ((count & 0x80) == 0) /* Short copy */
{
Bmemcpy((dstP += count) - count, (srcP += count) - count, count);
continue;
}
else if ((count &= ~0x80) > 0) /* short skip */
{
dstP += count;
continue;
}
/* long op */
count = B_LITTLE16(B_UNBUF16(srcP));
srcP += sizeof(int16_t);
if (!count) /* stop sign */
return;
else if ((count & 0x8000) == 0) /* long skip */
{
dstP += count;
continue;
}
else if ((count &= ~0x8000) & 0x4000) /* long RLE */
{
int32_t color = *srcP++;
count &= ~0x4000;
Bmemset((dstP += count) - count, color, count);
continue;
}
/* long copy */
Bmemcpy((dstP += count) - count, (srcP += count) - count, count);
}
while (1);
}
//
// addnewsymbol() -- Allocates space for a new symbol and attaches it
// appropriately to the lists, sorted.
//
static symbol_t *addnewsymbol(const char *name)
{
symbol_t *newsymb, *s, *t;
newsymb = (symbol_t *)Bmalloc(sizeof(symbol_t));
if (!newsymb) { return NULL; }
Bmemset(newsymb, 0, sizeof(symbol_t));
// link it to the main chain
if (!symbols) {
symbols = newsymb;
} else {
if (Bstrcasecmp(name, symbols->name) <= 0) {
t = symbols;
symbols = newsymb;
symbols->next = t;
} else {
s = symbols;
while (s->next) {
if (Bstrcasecmp(s->next->name, name) > 0) break;
s=s->next;
}
t = s->next;
s->next = newsymb;
newsymb->next = t;
}
}
return newsymb;
}
static inline void linefeed(void)
{
Bmemmove(osdtext+osdcols, osdtext, TEXTSIZE-osdcols);
Bmemset(osdtext, 32, osdcols);
if (osdlines < osdmaxlines) osdlines++;
}
void initfastcolorlookup_palette(uint8_t const * const pal)
{
Bmemset(colhere,0,sizeof(colhere));
Bmemset(colhead,0,sizeof(colhead));
colmatch_palette = pal;
char const *pal1 = (char *)&pal[768-3];
for (int i=255; i>=0; i--,pal1-=3)
{
int32_t const j = (pal1[0]>>FASTPALRIGHTSHIFT)*FASTPALGRIDSIZ*FASTPALGRIDSIZ
+ (pal1[1]>>FASTPALRIGHTSHIFT)*FASTPALGRIDSIZ + (pal1[2]>>FASTPALRIGHTSHIFT)
+ FASTPALGRIDSIZ*FASTPALGRIDSIZ + FASTPALGRIDSIZ + 1;
if (colhere[j>>3]&pow2char(j&7)) colnext[i] = colhead[j]; else colnext[i] = -1;
colhead[j] = i;
colhere[j>>3] |= pow2char(j&7);
}
//
// OSD_Init() -- Initialises the on-screen display
//
void OSD_Init(void)
{
Bmemset(osdtext, 32, TEXTSIZE);
osdlines=1;
osdinited=1;
OSD_RegisterFunction("listsymbols","listsymbols: lists all the recognized symbols",_internal_osdfunc_listsymbols);
OSD_RegisterFunction("help","help: displays help on the named symbol",_internal_osdfunc_help);
OSD_RegisterFunction("osdrows","osdrows: sets the number of visible lines of the OSD",_internal_osdfunc_vars);
atexit(OSD_Cleanup);
}
// This is run after all CON define's have been processed to set up the
// dynamic->static sound mapping.
void G_InitDynamicSounds(void)
{
int32_t i;
Bmemset(DynamicSoundMap, 0, sizeof(DynamicSoundMap));
for (i=0; g_dynSoundList[i].staticval >= 0; i++)
#ifdef DYNSOUNDREMAP_ENABLE
DynamicSoundMap[*(g_dynSoundList[i].dynvalptr)] = g_dynSoundList[i].staticval;
#else
DynamicSoundMap[g_dynSoundList[i].staticval] = g_dynSoundList[i].staticval;
#endif
}
int OSD_Dispatch(const char *cmd)
{
char *workbuf, *wp, *wtp, *state;
char *parms[MAXPARMS];
int numparms, restart = 0;
osdfuncparm_t ofp;
symbol_t *symb;
//int i;
workbuf = state = Bstrdup(cmd);
if (!workbuf) return -1;
do {
numparms = 0;
Bmemset(parms, 0, sizeof(parms));
wp = strtoken(state, &wtp, &restart);
if (!wp) {
state = wtp;
continue;
}
symb = findexactsymbol(wp);
if (!symb) {
OSD_Printf("Error: \"%s\" is not defined\n", wp);
free(workbuf);
return -1;
}
ofp.name = wp;
while (wtp && !restart) {
wp = strtoken(NULL, &wtp, &restart);
if (wp && numparms < MAXPARMS) parms[numparms++] = wp;
}
ofp.numparms = numparms;
ofp.parms = (const char **)parms;
ofp.raw = cmd;
switch (symb->func(&ofp)) {
case OSDCMD_OK: break;
case OSDCMD_SHOWHELP: OSD_Printf("%s\n", symb->help); break;
}
state = wtp;
} while (wtp && restart);
free(workbuf);
return 0;
}
static int32_t MV_StartPlayback(void)
{
// Initialize the buffers
Bmemset(MV_MixBuffer[0], 0, MV_TOTALBUFFERSIZE);
for (int buffer = 0; buffer < MV_NumberOfBuffers; buffer++)
MV_BufferEmpty[buffer] = TRUE;
MV_MixPage = 1;
if (SoundDriver_BeginPlayback(MV_MixBuffer[0], MV_BufferSize, MV_NumberOfBuffers, MV_ServiceVoc) != MV_Ok)
{
MV_SetErrorCode(MV_DriverError);
return MV_Error;
}
return MV_Ok;
}
void CONFIG_SetDefaultKeys(const char (*keyptr)[MAXGAMEFUNCLEN])
{
int32_t i,f;
Bmemset(ud.config.KeyboardKeys, 0xff, sizeof(ud.config.KeyboardKeys));
CONTROL_ClearAllBinds();
for (i=0; i < (int32_t)ARRAY_SIZE(keydefaults); i+=3)
{
f = CONFIG_FunctionNameToNum(keyptr[i+0]);
if (f == -1) continue;
ud.config.KeyboardKeys[f][0] = KB_StringToScanCode(keyptr[i+1]);
ud.config.KeyboardKeys[f][1] = KB_StringToScanCode(keyptr[i+2]);
if (f == gamefunc_Show_Console) OSD_CaptureKey(ud.config.KeyboardKeys[f][0]);
else CONFIG_MapKey(f, ud.config.KeyboardKeys[f][0], 0, ud.config.KeyboardKeys[f][1], 0);
}
}
void bflushchars(void)
{
Bmemset(&keyasciififo,0,sizeof(keyasciififo));
keyasciififoplc = keyasciififoend = 0;
}
void texcache_writetex(const char *fn, int32_t len, int32_t dameth, char effect, texcacheheader *head)
{
static GLint glGetTexLevelParameterivOK = GL_TRUE;
char cachefn[BMAX_PATH];
char *pic = NULL, *packbuf = NULL;
void *midbuf = NULL;
uint32_t alloclen=0, level;
uint32_t padx=0, pady=0;
GLint gi;
int32_t offset = 0;
if (!texcache_enabled()) return;
gi = GL_FALSE;
bglGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_COMPRESSED_ARB, &gi);
if (gi != GL_TRUE)
{
if (glGetTexLevelParameterivOK == GL_TRUE)
{
OSD_Printf("Error: glGetTexLevelParameteriv returned GL_FALSE!\n");
glGetTexLevelParameterivOK = GL_FALSE;
}
return;
}
Blseek(texcache.filehandle, 0, BSEEK_END);
offset = Blseek(texcache.filehandle, 0, BSEEK_CUR);
// OSD_Printf("Caching %s, offset 0x%x\n", cachefn, offset);
Bmemcpy(head->magic, TEXCACHEMAGIC, 4); // sizes are set by caller
if (glusetexcache == 2)
head->flags |= CACHEAD_COMPRESSED;
// native -> external (little-endian)
head->xdim = B_LITTLE32(head->xdim);
head->ydim = B_LITTLE32(head->ydim);
head->flags = B_LITTLE32(head->flags);
head->quality = B_LITTLE32(head->quality);
if (Bwrite(texcache.filehandle, head, sizeof(texcacheheader)) != sizeof(texcacheheader)) goto failure;
CLEAR_GL_ERRORS();
for (level = 0; level==0 || (padx > 1 || pady > 1); level++)
{
uint32_t miplen;
texcachepicture pict;
bglGetTexLevelParameteriv(GL_TEXTURE_2D, level, GL_TEXTURE_COMPRESSED_ARB, &gi); WRITEX_FAIL_ON_ERROR();
if (gi != GL_TRUE) goto failure; // an uncompressed mipmap
bglGetTexLevelParameteriv(GL_TEXTURE_2D, level, GL_TEXTURE_INTERNAL_FORMAT, &gi); WRITEX_FAIL_ON_ERROR();
#ifdef __APPLE__
if (pr_ati_textureformat_one && gi == 1) gi = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
#endif
// native -> external (little endian)
pict.format = B_LITTLE32(gi);
bglGetTexLevelParameteriv(GL_TEXTURE_2D, level, GL_TEXTURE_WIDTH, &gi); WRITEX_FAIL_ON_ERROR();
padx = gi; pict.xdim = B_LITTLE32(gi);
bglGetTexLevelParameteriv(GL_TEXTURE_2D, level, GL_TEXTURE_HEIGHT, &gi); WRITEX_FAIL_ON_ERROR();
pady = gi; pict.ydim = B_LITTLE32(gi);
bglGetTexLevelParameteriv(GL_TEXTURE_2D, level, GL_TEXTURE_BORDER, &gi); WRITEX_FAIL_ON_ERROR();
pict.border = B_LITTLE32(gi);
bglGetTexLevelParameteriv(GL_TEXTURE_2D, level, GL_TEXTURE_DEPTH, &gi); WRITEX_FAIL_ON_ERROR();
pict.depth = B_LITTLE32(gi);
bglGetTexLevelParameteriv(GL_TEXTURE_2D, level, GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB, &gi); WRITEX_FAIL_ON_ERROR();
miplen = gi; pict.size = B_LITTLE32(gi);
if (alloclen < miplen)
{
pic = (char *)Xrealloc(pic, miplen);
alloclen = miplen;
packbuf = (char *)Xrealloc(packbuf, alloclen);
midbuf = (void *)Xrealloc(midbuf, miplen);
}
bglGetCompressedTexImageARB(GL_TEXTURE_2D, level, pic); WRITEX_FAIL_ON_ERROR();
if (Bwrite(texcache.filehandle, &pict, sizeof(texcachepicture)) != sizeof(texcachepicture)) goto failure;
if (dxtfilter(texcache.filehandle, &pict, pic, midbuf, packbuf, miplen)) goto failure;
}
{
texcacheindex *t;
int32_t i = hash_find(&texcache.hashes, texcache_calcid(cachefn, fn, len, dameth, effect));
if (i > -1)
{
// update an existing entry
t = texcache.iptrs[i];
t->offset = offset;
t->len = Blseek(texcache.filehandle, 0, BSEEK_CUR) - t->offset;
/*initprintf("%s %d got a match for %s offset %d\n",__FILE__, __LINE__, cachefn,offset);*/
}
else
{
t = texcache.currentindex;
Bstrcpy(t->name, cachefn);
t->offset = offset;
t->len = Blseek(texcache.filehandle, 0, BSEEK_CUR) - t->offset;
t->next = (texcacheindex *)Xcalloc(1, sizeof(texcacheindex));
hash_add(&texcache.hashes, cachefn, texcache.numentries, 0);
if (++texcache.numentries > texcache.iptrcnt)
{
texcache.iptrcnt += 512;
texcache.iptrs = (texcacheindex **) Xrealloc(texcache.iptrs, sizeof(intptr_t) * texcache.iptrcnt);
}
texcache.iptrs[texcache.numentries-1] = t;
texcache.currentindex = t->next;
}
if (texcache.index)
{
fseek(texcache.index, 0, BSEEK_END);
Bfprintf(texcache.index, "%s %d %d\n", t->name, t->offset, t->len);
}
else OSD_Printf("wtf?\n");
}
goto success;
failure:
initprintf("ERROR: cache failure!\n");
texcache.currentindex->offset = 0;
Bmemset(texcache.currentindex->name,0,sizeof(texcache.currentindex->name));
success:
TEXCACHE_FREEBUFS();
}
int32_t CONFIG_ReadSetup(void)
{
int32_t dummy, i = 0;
char commmacro[] = "CommbatMacro# ";
char tempbuf[1024];
CONTROL_ClearAssignments();
CONFIG_SetDefaults();
ud.config.setupread = 1;
pathsearchmode = 1;
#ifndef EDUKE32_TOUCH_DEVICES
if (SafeFileExists(setupfilename) && ud.config.scripthandle < 0) // JBF 20031211
ud.config.scripthandle = SCRIPT_Load(setupfilename);
else if (SafeFileExists(SETUPFILENAME) && ud.config.scripthandle < 0)
{
i=wm_ynbox("Import Configuration Settings", "The configuration file \"%s\" was not found. "
"Import configuration data from \"%s\"?",setupfilename,SETUPFILENAME);
if (i) ud.config.scripthandle = SCRIPT_Load(SETUPFILENAME);
}
else if (SafeFileExists("duke3d.cfg") && ud.config.scripthandle < 0)
{
i=wm_ynbox("Import Configuration Settings", "The configuration file \"%s\" was not found. "
"Import configuration data from \"duke3d.cfg\"?",setupfilename);
if (i) ud.config.scripthandle = SCRIPT_Load("duke3d.cfg");
}
#endif
pathsearchmode = 0;
if (ud.config.scripthandle < 0) return -1;
if (ud.config.scripthandle >= 0)
{
char dummybuf[64];
for (dummy = 0; dummy < MAXRIDECULE; dummy++)
{
commmacro[13] = dummy+'0';
SCRIPT_GetString(ud.config.scripthandle, "Comm Setup",commmacro,&ud.ridecule[dummy][0]);
}
Bmemset(tempbuf, 0, sizeof(tempbuf));
// Bmemset(dummybuf, 0, sizeof(dummybuf));
SCRIPT_GetString(ud.config.scripthandle, "Comm Setup","PlayerName",&tempbuf[0]);
while (Bstrlen(OSD_StripColors(dummybuf,tempbuf)) > 10)
tempbuf[Bstrlen(tempbuf)-1] = '\0';
Bstrncpyz(szPlayerName, tempbuf, sizeof(szPlayerName));
if (g_rtsNamePtr == NULL)
SCRIPT_GetString(ud.config.scripthandle, "Comm Setup","RTSName",&ud.rtsname[0]);
SCRIPT_GetNumber(ud.config.scripthandle, "Setup","ConfigVersion",&ud.configversion);
SCRIPT_GetNumber(ud.config.scripthandle, "Setup","ForceSetup",&ud.config.ForceSetup);
SCRIPT_GetNumber(ud.config.scripthandle, "Setup","NoAutoLoad",&ud.config.NoAutoLoad);
// #ifdef _WIN32
if (g_noSetup == 0 && g_modDir[0] == '/')
{
struct Bstat st;
SCRIPT_GetString(ud.config.scripthandle, "Setup","ModDir",&g_modDir[0]);
if (Bstat(g_modDir, &st))
{
if ((st.st_mode & S_IFDIR) != S_IFDIR)
{
initprintf("Invalid mod dir in cfg!\n");
Bsprintf(g_modDir,"/");
}
}
}
// #endif
if (g_grpNamePtr == NULL && g_usingAddon == 0)
{
SCRIPT_GetStringPtr(ud.config.scripthandle, "Setup","SelectedGRP",&g_grpNamePtr);
if (g_grpNamePtr && !Bstrlen(g_grpNamePtr))
g_grpNamePtr = dup_filename(G_DefaultGrpFile());
}
if (!NAM)
{
SCRIPT_GetNumber(ud.config.scripthandle, "Screen Setup", "Out",&ud.lockout);
SCRIPT_GetString(ud.config.scripthandle, "Screen Setup","Password",&ud.pwlockout[0]);
}
SCRIPT_GetNumber(ud.config.scripthandle, "Screen Setup", "ScreenHeight",&ud.config.ScreenHeight);
SCRIPT_GetNumber(ud.config.scripthandle, "Screen Setup", "ScreenMode",&ud.config.ScreenMode);
SCRIPT_GetNumber(ud.config.scripthandle, "Screen Setup", "ScreenWidth",&ud.config.ScreenWidth);
SCRIPT_GetNumber(ud.config.scripthandle, "Screen Setup", "WindowPositioning", (int32_t *)&windowpos);
windowx = -1;
SCRIPT_GetNumber(ud.config.scripthandle, "Screen Setup", "WindowPosX", (int32_t *)&windowx);
windowy = -1;
SCRIPT_GetNumber(ud.config.scripthandle, "Screen Setup", "WindowPosY", (int32_t *)&windowy);
#ifdef RENDERTYPEWIN
SCRIPT_GetNumber(ud.config.scripthandle, "Screen Setup", "MaxRefreshFreq", (int32_t *)&maxrefreshfreq);
#endif
SCRIPT_GetNumber(ud.config.scripthandle, "Screen Setup", "ScreenBPP", &ud.config.ScreenBPP);
if (ud.config.ScreenBPP < 8) ud.config.ScreenBPP = 32;
#ifdef POLYMER
SCRIPT_GetNumber(ud.config.scripthandle, "Screen Setup", "Polymer", &dummy);
if (dummy > 0 && ud.config.ScreenBPP >= 16) glrendmode = REND_POLYMER;
else glrendmode = REND_POLYMOST;
#endif
/*
SCRIPT_GetNumber(ud.config.scripthandle, "Misc", "Color",&ud.color);
G_CheckPlayerColor((int32_t *)&ud.color,-1);
g_player[0].ps->palookup = g_player[0].pcolor = ud.color;
tempbuf[0] = 0;
*/
SCRIPT_GetNumber(ud.config.scripthandle, "Misc", "Executions",&ud.executions);
#ifdef _WIN32
SCRIPT_GetNumber(ud.config.scripthandle, "Updates", "CheckForUpdates", &ud.config.CheckForUpdates);
SCRIPT_GetNumber(ud.config.scripthandle, "Updates", "LastUpdateCheck", &ud.config.LastUpdateCheck);
#endif
}
//CONFIG_SetupMouse(ud.config.scripthandle);
//CONFIG_SetupJoystick(ud.config.scripthandle);
ud.config.setupread = 1;
return 0;
}
int32_t MV_Init(int32_t soundcard, int32_t MixRate, int32_t Voices, int32_t numchannels, void *initdata)
{
if (MV_Installed)
MV_Shutdown();
MV_SetErrorCode(MV_Ok);
// MV_TotalMemory + 2: FIXME, see valgrind_errors.log
int const totalmem = Voices * sizeof(VoiceNode) + MV_TOTALBUFFERSIZE + 2;
#ifdef _3DS
char *ptr = (char *) linearAlloc( totalmem);
#else
char *ptr = (char *) Xaligned_alloc(16, totalmem);
#endif
if (!ptr)
{
MV_SetErrorCode(MV_NoMem);
return MV_Error;
}
Bmemset(ptr, 0, totalmem);
MV_Voices = (VoiceNode *)ptr;
ptr += Voices * sizeof(VoiceNode);
// Set number of voices before calculating volume table
MV_MaxVoices = Voices;
LL_Reset((VoiceNode*) &VoiceList, next, prev);
LL_Reset((VoiceNode*) &VoicePool, next, prev);
for (int index = 0; index < Voices; index++)
{
LL_Add((VoiceNode*) &VoicePool, &MV_Voices[ index ], next, prev);
}
MV_SetReverseStereo(FALSE);
ASS_SoundDriver = soundcard;
// Initialize the sound card
if (SoundDriver_Init(&MixRate, &numchannels, initdata) != MV_Ok)
MV_SetErrorCode(MV_DriverError);
if (MV_ErrorCode != MV_Ok)
{
ALIGNED_FREE_AND_NULL(MV_Voices);
return MV_Error;
}
MV_Installed = TRUE;
MV_CallBackFunc = NULL;
MV_ReverbLevel = 0;
MV_ReverbTable = NULL;
// Set the sampling rate
MV_MixRate = MixRate;
// Set Mixer to play stereo digitized sound
MV_SetMixMode(numchannels);
MV_ReverbDelay = MV_BufferSize * 3;
// Make sure we don't cross a physical page
MV_MixBuffer[ MV_NumberOfBuffers ] = ptr;
for (int buffer = 0; buffer < MV_NumberOfBuffers; buffer++)
{
MV_MixBuffer[ buffer ] = ptr;
ptr += MV_BufferSize;
}
// Calculate pan table
MV_CalcPanTable();
MV_SetVolume(MV_MAXTOTALVOLUME);
// Start the playback engine
if (MV_StartPlayback() != MV_Ok)
{
// Preserve error code while we shutdown.
int status = MV_ErrorCode;
MV_Shutdown();
MV_SetErrorCode(status);
return MV_Error;
}
return MV_Ok;
}
/*---------------------------------------------------------------------
JBF: no synchronisation happens inside MV_ServiceVoc nor the
supporting functions it calls. This would cause a deadlock
between the mixer thread in the driver vs the nested
locking in the user-space functions of MultiVoc. The call
to MV_ServiceVoc is synchronised in the driver.
---------------------------------------------------------------------*/
static void MV_ServiceVoc(void)
{
// Toggle which buffer we'll mix next
if (++MV_MixPage >= MV_NumberOfBuffers)
MV_MixPage -= MV_NumberOfBuffers;
if (MV_ReverbLevel == 0)
{
// Initialize buffer
//Commented out so that the buffer is always cleared.
//This is so the guys at Echo Speech can mix into the
//buffer even when no sounds are playing.
if (!MV_BufferEmpty[MV_MixPage])
{
Bmemset(MV_MixBuffer[MV_MixPage], 0, MV_BufferSize);
MV_BufferEmpty[ MV_MixPage ] = TRUE;
}
}
else
{
char const *const end = MV_MixBuffer[0] + MV_BufferLength;
char *dest = MV_MixBuffer[MV_MixPage];
char const *source = MV_MixBuffer[MV_MixPage] - MV_ReverbDelay;
if (source < MV_MixBuffer[ 0 ])
source += MV_BufferLength;
int32_t length = MV_BufferSize;
while (length > 0)
{
int const count = (source + length > end) ? (end - source) : length;
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 ];
dest += count;
length -= count;
}
}
// Play any waiting voices
//DisableInterrupts();
VoiceNode *voice;
if (!VoiceList.next || (voice = VoiceList.next) == &VoiceList)
return;
int iter = 0;
VoiceNode *next;
do
{
next = voice->next;
if (++iter > MV_MaxVoices && MV_Printf)
MV_Printf("more iterations than voices! iter: %d\n",iter);
if (voice->Paused)
continue;
MV_BufferEmpty[ MV_MixPage ] = FALSE;
MV_Mix(voice, MV_MixPage);
// Is this voice done?
if (!voice->Playing)
{
//JBF: prevent a deadlock caused by MV_StopVoice grabbing the mutex again
//MV_StopVoice( voice );
LL_Remove(voice, next, prev);
LL_Add((VoiceNode*) &VoicePool, voice, next, prev);
switch (voice->wavetype)
{
#ifdef HAVE_VORBIS
case FMT_VORBIS: MV_ReleaseVorbisVoice(voice); break;
#endif
#ifdef HAVE_FLAC
case FMT_FLAC: MV_ReleaseFLACVoice(voice); break;
#endif
case FMT_XA: MV_ReleaseXAVoice(voice); break;
default: break;
}
voice->handle = 0;
if (MV_CallBackFunc)
MV_CallBackFunc(voice->callbackval);
}
}
while ((voice = next) != &VoiceList);
//RestoreInterrupts();
}
