mirror of
https://github.com/nzp-team/fteqw.git
synced 2024-11-23 20:32:43 +00:00
0c8ad17f7c
Added sv_guidkey cvar, allowing cross-server guid key generation (although it lacks auth). Support .ico, because we can. preliminary support for sdl 2.0.6's vulkan stuff. will wait till its actually released before its properly used. Fix capturedemo. videomap should typically use premultiplied alpha, apparently. Updated sound drivers. No more old drivers. Better cvar registration. More drivers optionally support float output. Added certificate log for dtls connections. Rewrote font char cache, now supports full unicode char range, not just ucs-2. Attempt to support FreeType 2.5+ rgba fonts. XMPP now supports carbons, and shows avatars in conversations. Updated xmpp's scram auth to be more strict, including the plus variation (hopefully), to block evil tls proxies. ffmpeg plugin now uses the decoupled api for decoding too. Cef plugin updated to support fte-scheme post data properly, as well as request/response headers (like cross-origin). git-svn-id: https://svn.code.sf.net/p/fteqw/code/trunk@5148 fc73d0e0-1445-4013-8a0c-d673dee63da5
595 lines
13 KiB
C
595 lines
13 KiB
C
/*
|
|
Copyright (C) 1996-1997 Id Software, Inc.
|
|
|
|
This program is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU General Public License
|
|
as published by the Free Software Foundation; either version 2
|
|
of the License, or (at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
|
|
See the GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
|
|
*/
|
|
|
|
|
|
//I had one at least, back in the day.
|
|
//should be fine for dosbox, if nothing else.
|
|
|
|
//warning: this sound code doesn't seem to cope well with low framerates. the dma buffer is too small.
|
|
//4096 bytes 16bit stereo means 1024 samples. so less than 10 fps and the mixer will miss buffer wraps.
|
|
|
|
|
|
#include <quakedef.h>
|
|
|
|
#include <dos.h>
|
|
#include <dpmi.h>
|
|
#include <go32.h>
|
|
#include <sys/nearptr.h>
|
|
|
|
#define SDRVNAME "SoundBlaster"
|
|
|
|
/*
|
|
===============================================================================
|
|
|
|
BLASTER SUPPORT
|
|
|
|
===============================================================================
|
|
*/
|
|
|
|
_go32_dpmi_seginfo dma_buffer_memory;
|
|
static short *dma_buffer=0; //realigned pointer
|
|
quintptr_t dma_buffer_phys; //realigned physical address - must be within the first 16mb
|
|
static int dma_size;
|
|
static int dma;
|
|
|
|
static int dsp_port;
|
|
static int irq;
|
|
static int low_dma;
|
|
static int high_dma;
|
|
static int mixer_port;
|
|
static int mpu401_port;
|
|
|
|
static int dsp_version;
|
|
static int dsp_minor_version;
|
|
|
|
static int timeconstant=-1;
|
|
static int oldmixervalue;
|
|
|
|
static int mode_reg;
|
|
static int flipflop_reg;
|
|
static int disable_reg;
|
|
static int clear_reg;
|
|
|
|
static soundcardinfo_t *becauseglobalssuck; //just protects against multiple devices being spawned at once.
|
|
|
|
|
|
static void PrintBits (qbyte b)
|
|
{
|
|
int i;
|
|
char str[9];
|
|
|
|
for (i=0 ; i<8 ; i++)
|
|
str[i] = '0' + ((b & (1<<(7-i))) > 0);
|
|
|
|
str[8] = 0;
|
|
Con_Printf ("%s (%i)", str, b);
|
|
}
|
|
|
|
// =======================================================================
|
|
// Interprets BLASTER variable
|
|
// =======================================================================
|
|
|
|
static int GetBLASTER(void)
|
|
{
|
|
char *BLASTER;
|
|
char *param;
|
|
|
|
BLASTER = getenv("BLASTER");
|
|
if (!BLASTER)
|
|
return 0;
|
|
|
|
param = strchr(BLASTER, 'A');
|
|
if (!param)
|
|
param = strchr(BLASTER, 'a');
|
|
if (!param)
|
|
return 0;
|
|
sscanf(param+1, "%x", &dsp_port);
|
|
|
|
param = strchr(BLASTER, 'I');
|
|
if (!param)
|
|
param = strchr(BLASTER, 'i');
|
|
if (!param)
|
|
return 0;
|
|
sscanf(param+1, "%d", &irq);
|
|
|
|
param = strchr(BLASTER, 'D');
|
|
if (!param)
|
|
param = strchr(BLASTER, 'd');
|
|
if (!param)
|
|
return 0;
|
|
sscanf(param+1, "%d", &low_dma);
|
|
|
|
param = strchr(BLASTER, 'H');
|
|
if (!param)
|
|
param = strchr(BLASTER, 'h');
|
|
if (param)
|
|
sscanf(param+1, "%d", &high_dma);
|
|
|
|
param = strchr(BLASTER, 'M');
|
|
if (!param)
|
|
param = strchr(BLASTER, 'm');
|
|
if (param)
|
|
sscanf(param+1, "%x", &mixer_port);
|
|
else
|
|
mixer_port = dsp_port;
|
|
|
|
param = strchr(BLASTER, 'P');
|
|
if (!param)
|
|
param = strchr(BLASTER, 'p');
|
|
if (param)
|
|
sscanf(param+1, "%x", &mpu401_port);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
// ==================================================================
|
|
// Resets DSP. Returns 0 on success.
|
|
// ==================================================================
|
|
|
|
static int ResetDSP(void)
|
|
{
|
|
volatile int i;
|
|
|
|
outportb(dsp_port + 6, 1);
|
|
for (i=65536 ; i ; i--) ;
|
|
outportb(dsp_port + 6, 0);
|
|
for (i=65536 ; i ; i--)
|
|
{
|
|
if (!(inportb(dsp_port + 0xe) & 0x80)) continue;
|
|
if (inportb(dsp_port + 0xa) == 0xaa) break;
|
|
}
|
|
if (i) return 0;
|
|
else return 1;
|
|
|
|
}
|
|
|
|
static int ReadDSP(void)
|
|
{
|
|
while (!(inportb(dsp_port+0xe)&0x80)) ;
|
|
return inportb(dsp_port+0xa);
|
|
}
|
|
|
|
static void WriteDSP(int val)
|
|
{
|
|
while ((inportb(dsp_port+0xc)&0x80)) ;
|
|
outportb(dsp_port+0xc, val);
|
|
}
|
|
|
|
static int ReadMixer(int addr)
|
|
{
|
|
outportb(mixer_port+4, addr);
|
|
return inportb(mixer_port+5);
|
|
}
|
|
|
|
static void WriteMixer(int addr, int val)
|
|
{
|
|
outportb(mixer_port+4, addr);
|
|
outportb(mixer_port+5, val);
|
|
}
|
|
|
|
/*
|
|
================
|
|
StartSB
|
|
|
|
================
|
|
*/
|
|
static void StartSB(soundcardinfo_t *sc)
|
|
{
|
|
int i;
|
|
|
|
// version 4.xx startup code
|
|
if (dsp_version >= 4)
|
|
{
|
|
Con_Printf("Version 4 SB startup\n");
|
|
WriteDSP(0xd1); // turn on speaker
|
|
|
|
WriteDSP(0x41);
|
|
|
|
WriteDSP(sc->sn.speed>>8);
|
|
WriteDSP(sc->sn.speed&0xff);
|
|
|
|
WriteDSP(0xb6); // 16-bit output
|
|
WriteDSP(0x30); // stereo
|
|
WriteDSP((sc->sn.samples-1) & 0xff); // # of samples - 1
|
|
WriteDSP((sc->sn.samples-1) >> 8);
|
|
}
|
|
// version 3.xx startup code
|
|
else if (dsp_version == 3)
|
|
{
|
|
Con_Printf("Version 3 SB startup\n");
|
|
WriteDSP(0xd1); // turn on speaker
|
|
|
|
oldmixervalue = ReadMixer (0xe);
|
|
WriteMixer (0xe, oldmixervalue | 0x2);// turn on stereo
|
|
|
|
WriteDSP(0x14); // send one byte
|
|
WriteDSP(0x0);
|
|
WriteDSP(0x0);
|
|
|
|
for (i=0 ; i<0x10000 ; i++)
|
|
inportb(dsp_port+0xe); // ack the dsp
|
|
|
|
timeconstant = 65536-(256000000/(sc->sn.numchannels*sc->sn.speed));
|
|
WriteDSP(0x40);
|
|
WriteDSP(timeconstant>>8);
|
|
|
|
WriteMixer (0xe, ReadMixer(0xe) | 0x20);// turn off filter
|
|
|
|
WriteDSP(0x48);
|
|
WriteDSP((sc->sn.samples-1) & 0xff); // # of samples - 1
|
|
WriteDSP((sc->sn.samples-1) >> 8);
|
|
|
|
WriteDSP(0x90); // high speed 8 bit stereo
|
|
}
|
|
// normal speed mono
|
|
else
|
|
{
|
|
Con_Printf("Version 2 SB startup\n");
|
|
WriteDSP(0xd1); // turn on speaker
|
|
|
|
timeconstant = 65536-(256000000/(sc->sn.numchannels*sc->sn.speed));
|
|
WriteDSP(0x40);
|
|
WriteDSP(timeconstant>>8);
|
|
|
|
WriteDSP(0x48);
|
|
WriteDSP((sc->sn.samples-1) & 0xff); // # of samples - 1
|
|
WriteDSP((sc->sn.samples-1) >> 8);
|
|
|
|
WriteDSP(0x1c); // normal speed 8 bit mono
|
|
}
|
|
}
|
|
|
|
static const int page_reg[] = { 0x87, 0x83, 0x81, 0x82, 0x8f, 0x8b, 0x89, 0x8a };
|
|
static const int addr_reg[] = { 0, 2, 4, 6, 0xc0, 0xc4, 0xc8, 0xcc };
|
|
static const int count_reg[] = { 1, 3, 5, 7, 0xc2, 0xc6, 0xca, 0xce };
|
|
|
|
/*
|
|
================
|
|
StartDMA
|
|
|
|
================
|
|
*/
|
|
static void StartDMA(void)
|
|
{
|
|
int mode;
|
|
|
|
// use a high dma channel if specified
|
|
if (high_dma && dsp_version >= 4) // 8 bit snd can never use 16 bit dma
|
|
dma = high_dma;
|
|
else
|
|
dma = low_dma;
|
|
|
|
Con_Printf ("Using DMA channel %i\n", dma);
|
|
|
|
if (dma > 3)
|
|
{
|
|
mode_reg = 0xd6;
|
|
flipflop_reg = 0xd8;
|
|
disable_reg = 0xd4;
|
|
clear_reg = 0xdc;
|
|
}
|
|
else
|
|
{
|
|
mode_reg = 0xb;
|
|
flipflop_reg = 0xc;
|
|
disable_reg = 0xa;
|
|
clear_reg = 0xe;
|
|
}
|
|
|
|
outportb(disable_reg, dma|4); // disable channel
|
|
// set mode- see "undocumented pc", p.876
|
|
mode = (1<<6) // single-cycle
|
|
+(0<<5) // address increment
|
|
+(1<<4) // auto-init dma
|
|
+(2<<2) // read
|
|
+(dma&3); // channel #
|
|
outportb(mode_reg, mode);
|
|
|
|
// set address
|
|
// set page
|
|
outportb(page_reg[dma], dma_buffer_phys >> 16);
|
|
|
|
if (dma > 3)
|
|
{ // address is in words
|
|
outportb(flipflop_reg, 0); // prepare to send 16-bit value
|
|
outportb(addr_reg[dma], (dma_buffer_phys>>1) & 0xff);
|
|
outportb(addr_reg[dma], (dma_buffer_phys>>9) & 0xff);
|
|
|
|
outportb(flipflop_reg, 0); // prepare to send 16-bit value
|
|
outportb(count_reg[dma], ((dma_size>>1)-1) & 0xff);
|
|
outportb(count_reg[dma], ((dma_size>>1)-1) >> 8);
|
|
}
|
|
else
|
|
{ // address is in bytes
|
|
outportb(flipflop_reg, 0); // prepare to send 16-bit value
|
|
outportb(addr_reg[dma], dma_buffer_phys & 0xff);
|
|
outportb(addr_reg[dma], (dma_buffer_phys>>8) & 0xff);
|
|
|
|
outportb(flipflop_reg, 0); // prepare to send 16-bit value
|
|
outportb(count_reg[dma], (dma_size-1) & 0xff);
|
|
outportb(count_reg[dma], (dma_size-1) >> 8);
|
|
}
|
|
|
|
outportb(clear_reg, 0); // clear write mask
|
|
outportb(disable_reg, dma&~4);
|
|
}
|
|
|
|
/*
|
|
==============
|
|
BLASTER_GetDMAPos
|
|
|
|
return the current sample position (in mono samples read)
|
|
inside the recirculating dma buffer, so the mixing code will know
|
|
how many sample are required to fill it up.
|
|
===============
|
|
*/
|
|
static unsigned int SBLASTER_GetDMAPos(soundcardinfo_t *sc)
|
|
{
|
|
int count;
|
|
|
|
// this function is called often. acknowledge the transfer completions
|
|
// all the time so that it loops
|
|
if (dsp_version >= 4)
|
|
inportb(dsp_port+0xf); // 16 bit audio
|
|
else
|
|
inportb(dsp_port+0xe); // 8 bit audio
|
|
|
|
// clear 16-bit reg flip-flop
|
|
// load the current dma count register
|
|
if (dma < 4)
|
|
{
|
|
outportb(0xc, 0);
|
|
count = inportb(dma*2+1);
|
|
count += inportb(dma*2+1) << 8;
|
|
if (sc->sn.samplebytes == 2)
|
|
count /= 2;
|
|
count = sc->sn.samples - (count+1);
|
|
}
|
|
else
|
|
{
|
|
outportb(0xd8, 0);
|
|
count = inportb(0xc0+(dma-4)*4+2);
|
|
count += inportb(0xc0+(dma-4)*4+2) << 8;
|
|
if (sc->sn.samplebytes == 1)
|
|
count *= 2;
|
|
count = sc->sn.samples - (count+1);
|
|
}
|
|
|
|
// Con_Printf("DMA pos = 0x%x\n", count);
|
|
|
|
// sc->sn.samplepos = count & (sc->sn.samples-1);
|
|
return count;
|
|
|
|
}
|
|
|
|
/*
|
|
==============
|
|
BLASTER_Shutdown
|
|
|
|
Reset the sound device for exiting
|
|
===============
|
|
*/
|
|
static void SBLASTER_Shutdown(soundcardinfo_t *sc)
|
|
{
|
|
if (becauseglobalssuck == sc)
|
|
becauseglobalssuck = NULL;
|
|
|
|
if (dsp_version >= 4)
|
|
{
|
|
}
|
|
else if (dsp_version == 3)
|
|
{
|
|
ResetDSP (); // stop high speed mode
|
|
WriteMixer (0xe, oldmixervalue); // turn stereo off and filter on
|
|
}
|
|
else
|
|
{
|
|
|
|
}
|
|
|
|
WriteDSP(0xd3); // turn off speaker
|
|
ResetDSP ();
|
|
|
|
outportb(disable_reg, dma|4); // disable dma channel
|
|
|
|
_go32_dpmi_free_dos_memory(&dma_buffer_memory);
|
|
}
|
|
|
|
//simple ring buffer
|
|
static void *SBLASTER_LockBuffer(soundcardinfo_t *sc, unsigned int *sampidx)
|
|
{
|
|
return sc->sn.buffer;
|
|
}
|
|
|
|
//that's permanently locked
|
|
static void SBLASTER_UnlockBuffer(soundcardinfo_t *sc, void *buffer)
|
|
{
|
|
}
|
|
|
|
//that the hardware has direct access to.
|
|
static void SBLASTER_Submit (soundcardinfo_t *sc, int start, int end)
|
|
{
|
|
}
|
|
|
|
//returns the address of some memory.
|
|
//ctx is required to free the memory afterwards
|
|
static qboolean dosmem_alloc(_go32_dpmi_seginfo *ctx, size_t size)
|
|
{
|
|
ctx->size = (size+15)>>4;
|
|
if (_go32_dpmi_allocate_dos_memory(ctx))
|
|
return false; //failed
|
|
return true;
|
|
}
|
|
|
|
static quintptr_t dosmem_phys(_go32_dpmi_seginfo *ctx)
|
|
{
|
|
return ctx->rm_segment<<4;
|
|
}
|
|
static void *dosmem_ptr(_go32_dpmi_seginfo *ctx)
|
|
{
|
|
__djgpp_nearptr_enable();
|
|
return (void*)(__djgpp_conventional_base+dosmem_phys(ctx));
|
|
}
|
|
|
|
|
|
/*
|
|
==================
|
|
BLASTER_Init
|
|
|
|
Returns false if nothing is found.
|
|
==================
|
|
*/
|
|
static qboolean SBLASTER_InitCard(soundcardinfo_t *sc, const char *pcmname)
|
|
{
|
|
int size;
|
|
int p;
|
|
|
|
if (becauseglobalssuck)
|
|
return 0;
|
|
|
|
//
|
|
// must have a blaster variable set
|
|
//
|
|
if (!GetBLASTER())
|
|
{
|
|
Con_NotifyBox (
|
|
"The BLASTER environment variable\n"
|
|
"is not set, sound effects are\n"
|
|
"disabled. See README.TXT for help.\n"
|
|
);
|
|
return 0;
|
|
}
|
|
|
|
if (ResetDSP())
|
|
{
|
|
Con_Printf("Could not reset SB");
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// get dsp version
|
|
//
|
|
WriteDSP(0xe1);
|
|
dsp_version = ReadDSP();
|
|
dsp_minor_version = ReadDSP();
|
|
|
|
// we need at least v2 for auto-init dma
|
|
if (dsp_version < 2)
|
|
{
|
|
Con_Printf ("Sound blaster must be at least v2.0\n");
|
|
return 0;
|
|
}
|
|
|
|
// allow command line parm to set quality down
|
|
p = COM_CheckParm ("-dsp");
|
|
if (p && p < com_argc - 1)
|
|
{
|
|
p = Q_atoi (com_argv[p+1]);
|
|
if (p < 2 || p > 4)
|
|
Con_Printf ("-dsp parameter can only be 2, 3, or 4\n");
|
|
else if (p > dsp_version)
|
|
Con_Printf ("Can't -dsp %i on v%i hardware\n", p, dsp_version);
|
|
else
|
|
dsp_version = p;
|
|
}
|
|
|
|
|
|
// everyone does 11khz sampling rate unless told otherwise
|
|
// sc->sn.speed = 11025;
|
|
// rc = COM_CheckParm("-sspeed");
|
|
// if (rc)
|
|
// sc->sn.speed = Q_atoi(com_argv[rc+1]);
|
|
|
|
// version 4 cards (sb 16) do 16 bit stereo
|
|
if (dsp_version >= 4)
|
|
{
|
|
if (sc->sn.numchannels != 1)
|
|
sc->sn.numchannels = 2;
|
|
if (sc->sn.samplebytes != 1)
|
|
sc->sn.samplebytes = 2;
|
|
}
|
|
// version 3 cards (sb pro) do 8 bit stereo
|
|
else if (dsp_version == 3)
|
|
{
|
|
if (sc->sn.numchannels != 1)
|
|
sc->sn.numchannels = 2;
|
|
sc->sn.samplebytes = 1;
|
|
}
|
|
// v2 cards do 8 bit mono
|
|
else
|
|
{
|
|
sc->sn.numchannels = 1;
|
|
sc->sn.samplebytes = 1;
|
|
}
|
|
|
|
if (sc->sn.samplebytes == 2)
|
|
sc->sn.sampleformat = QSF_S16;
|
|
else
|
|
sc->sn.sampleformat = QSF_U8;
|
|
|
|
sc->Lock = SBLASTER_LockBuffer;
|
|
sc->Unlock = SBLASTER_UnlockBuffer;
|
|
sc->Shutdown = SBLASTER_Shutdown;
|
|
sc->GetDMAPos = SBLASTER_GetDMAPos;
|
|
sc->Submit = SBLASTER_Submit;
|
|
|
|
size = 4096;
|
|
|
|
// allocate 8k and get a 4k-aligned buffer from it
|
|
if (!dosmem_alloc(&dma_buffer_memory, size*2))
|
|
{
|
|
Con_Printf("Couldn't allocate sound dma buffer");
|
|
return false;
|
|
}
|
|
dma_buffer_phys = ((dosmem_phys(&dma_buffer_memory) + size) & ~(size-1));
|
|
dma_buffer = (short *)((qbyte*)dosmem_ptr(&dma_buffer_memory) + dma_buffer_phys-dosmem_phys(&dma_buffer_memory));
|
|
|
|
dma_size = size;
|
|
memset(dma_buffer, 0, dma_size);
|
|
|
|
sc->sn.samples = size/sc->sn.samplebytes;
|
|
sc->sn.samplepos = 0;
|
|
sc->sn.buffer = (unsigned char *) dma_buffer;
|
|
sc->sn.samples = size/sc->sn.samplebytes;
|
|
|
|
StartDMA();
|
|
StartSB(sc);
|
|
|
|
becauseglobalssuck = sc;
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
|
|
static qboolean QDECL SBLASTER_Enumerate(void (QDECL *cb) (const char *drivername, const char *devicecode, const char *readablename))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
sounddriver_t SBLASTER_Output =
|
|
{
|
|
SDRVNAME,
|
|
SBLASTER_InitCard,
|
|
SBLASTER_Enumerate
|
|
};
|
|
|