mirror of
https://git.do.srb2.org/STJr/SRB2.git
synced 2024-11-14 00:40:52 +00:00
WIP: Remove support for DOS
WIP because I don't know if this wording is right for the error.
This commit is contained in:
parent
484b8e2c06
commit
0d48d4c833
28 changed files with 7 additions and 6227 deletions
2
bin/Dos/Debug/.gitignore
vendored
2
bin/Dos/Debug/.gitignore
vendored
|
@ -1,2 +0,0 @@
|
|||
# DON'T REMOVE
|
||||
# This keeps the folder from disappearing
|
2
bin/Dos/Release/.gitignore
vendored
2
bin/Dos/Release/.gitignore
vendored
|
@ -1,2 +0,0 @@
|
|||
# DON'T REMOVE
|
||||
# This keeps the folder from disappearing
|
2
objs/djgppdos/Debug/.gitignore
vendored
2
objs/djgppdos/Debug/.gitignore
vendored
|
@ -1,2 +0,0 @@
|
|||
# DON'T REMOVE
|
||||
# This keeps the folder from disappearing
|
2
objs/djgppdos/Release/.gitignore
vendored
2
objs/djgppdos/Release/.gitignore
vendored
|
@ -1,2 +0,0 @@
|
|||
# DON'T REMOVE
|
||||
# This keeps the folder from disappearing
|
10
src/Makefile
10
src/Makefile
|
@ -8,13 +8,11 @@
|
|||
# terms of the GNU General Public License, version 2.
|
||||
# See the 'LICENSE' file for more details.
|
||||
#
|
||||
# -DPC_DOS -> use DOS specific code (eg:textmode stuff)...
|
||||
# -DLINUX -> use for the GNU/Linux specific
|
||||
# -D_WINDOWS -> use for the Win32/DirectX specific
|
||||
# -DHAVE_SDL -> use for the SDL interface
|
||||
#
|
||||
# Sets:
|
||||
# Compile the DGJPP/DOS version with 'make WATTCP=1'
|
||||
# Compile the DirectX/Mingw version with 'make MINGW=1'
|
||||
# Compile the SDL/Mingw version with 'make MINGW=1 SDL=1'
|
||||
# Compile the SDL/Linux version with 'make LINUX=1'
|
||||
|
@ -146,10 +144,6 @@ NOHW=1
|
|||
NOHS=1
|
||||
endif
|
||||
|
||||
ifdef DJGPPDOS
|
||||
include djgppdos/Makefile.cfg
|
||||
endif
|
||||
|
||||
ifndef NOOPENMPT
|
||||
HAVE_OPENMPT=1
|
||||
endif
|
||||
|
@ -498,10 +492,6 @@ POS:=$(BIN)/en.mo
|
|||
OPTS+=-DGETTEXT
|
||||
endif
|
||||
|
||||
ifdef DJGPPDOS
|
||||
all: pre-build $(BIN)/$(EXENAME)
|
||||
endif
|
||||
|
||||
ifdef PANDORA
|
||||
all: pre-build $(BIN)/$(PNDNAME)
|
||||
endif
|
||||
|
|
|
@ -308,7 +308,7 @@ ifndef MINGW
|
|||
ifndef MINGW64
|
||||
ifndef SDL
|
||||
ifndef DUMMY
|
||||
DJGPPDOS=1
|
||||
$(error No interface or platform flag defined)
|
||||
endif
|
||||
endif
|
||||
endif
|
||||
|
@ -344,16 +344,6 @@ UPX_OPTS+=-q
|
|||
endif
|
||||
|
||||
#Interface Setup
|
||||
ifdef DJGPPDOS
|
||||
INTERFACE=djgppdos
|
||||
NASMFORMAT=coff
|
||||
OBJDIR:=$(OBJDIR)/djgppdos
|
||||
ifdef WATTCP
|
||||
OBJDIR:=$(OBJDIR)/wattcp
|
||||
endif
|
||||
WFLAGS+=-Wno-format
|
||||
BIN:=$(BIN)/Dos
|
||||
else
|
||||
ifdef DUMMY
|
||||
INTERFACE=dummy
|
||||
OBJDIR:=$(OBJDIR)/dummy
|
||||
|
@ -412,7 +402,6 @@ endif
|
|||
endif
|
||||
endif
|
||||
endif
|
||||
endif
|
||||
|
||||
ifdef ARCHNAME
|
||||
OBJDIR:=$(OBJDIR)/$(ARCHNAME)
|
||||
|
|
|
@ -1273,21 +1273,11 @@ void CONS_Printf(const char *fmt, ...)
|
|||
// echo console prints to log file
|
||||
DEBFILE(txt);
|
||||
|
||||
if (!con_started)
|
||||
{
|
||||
#ifdef PC_DOS
|
||||
CON_LogMessage(txt);
|
||||
free(txt);
|
||||
return;
|
||||
#endif
|
||||
}
|
||||
else
|
||||
// write message in con text buffer
|
||||
// write message in con text buffer
|
||||
if (con_started)
|
||||
CON_Print(txt);
|
||||
|
||||
#ifndef PC_DOS
|
||||
CON_LogMessage(txt);
|
||||
#endif
|
||||
CON_LogMessage(txt);
|
||||
|
||||
// make sure new text is visible
|
||||
con_scrollup = 0;
|
||||
|
|
74
src/d_main.c
74
src/d_main.c
|
@ -24,12 +24,6 @@
|
|||
#include <unistd.h> // for getcwd
|
||||
#endif
|
||||
|
||||
#ifdef PC_DOS
|
||||
#include <stdio.h> // for snprintf
|
||||
int snprintf(char *str, size_t n, const char *fmt, ...);
|
||||
//int vsnprintf(char *str, size_t n, const char *fmt, va_list ap);
|
||||
#endif
|
||||
|
||||
#ifdef _WIN32
|
||||
#include <direct.h>
|
||||
#include <malloc.h>
|
||||
|
@ -162,10 +156,6 @@ void D_PostEvent(const event_t *ev)
|
|||
events[eventhead] = *ev;
|
||||
eventhead = (eventhead+1) & (MAXEVENTS-1);
|
||||
}
|
||||
// just for lock this function
|
||||
#if defined (PC_DOS) && !defined (DOXYGEN)
|
||||
void D_PostEvent_end(void) {};
|
||||
#endif
|
||||
|
||||
// modifier keys
|
||||
// Now handled in I_OsPolling
|
||||
|
@ -1088,64 +1078,6 @@ static void IdentifyVersion(void)
|
|||
#endif
|
||||
}
|
||||
|
||||
#ifdef PC_DOS
|
||||
/* ======================================================================== */
|
||||
// Code for printing SRB2's title bar in DOS
|
||||
/* ======================================================================== */
|
||||
|
||||
//
|
||||
// Center the title string, then add the date and time of compilation.
|
||||
//
|
||||
static inline void D_MakeTitleString(char *s)
|
||||
{
|
||||
char temp[82];
|
||||
char *t;
|
||||
const char *u;
|
||||
INT32 i;
|
||||
|
||||
for (i = 0, t = temp; i < 82; i++)
|
||||
*t++=' ';
|
||||
|
||||
for (t = temp + (80-strlen(s))/2, u = s; *u != '\0' ;)
|
||||
*t++ = *u++;
|
||||
|
||||
u = compdate;
|
||||
for (t = temp + 1, i = 11; i-- ;)
|
||||
*t++ = *u++;
|
||||
u = comptime;
|
||||
for (t = temp + 71, i = 8; i-- ;)
|
||||
*t++ = *u++;
|
||||
|
||||
temp[80] = '\0';
|
||||
strcpy(s, temp);
|
||||
}
|
||||
|
||||
static inline void D_Titlebar(void)
|
||||
{
|
||||
char title1[82]; // srb2 title banner
|
||||
char title2[82];
|
||||
|
||||
strcpy(title1, "Sonic Robo Blast 2");
|
||||
strcpy(title2, "Sonic Robo Blast 2");
|
||||
|
||||
D_MakeTitleString(title1);
|
||||
|
||||
// SRB2 banner
|
||||
clrscr();
|
||||
textattr((BLUE<<4)+WHITE);
|
||||
clreol();
|
||||
cputs(title1);
|
||||
|
||||
// standard srb2 banner
|
||||
textattr((RED<<4)+WHITE);
|
||||
clreol();
|
||||
gotoxy((80-strlen(title2))/2, 2);
|
||||
cputs(title2);
|
||||
normvideo();
|
||||
gotoxy(1,3);
|
||||
}
|
||||
#endif
|
||||
|
||||
static void
|
||||
D_ConvertVersionNumbers (void)
|
||||
{
|
||||
|
@ -1189,7 +1121,7 @@ void D_SRB2Main(void)
|
|||
"in this program.\n\n");
|
||||
|
||||
// keep error messages until the final flush(stderr)
|
||||
#if !defined (PC_DOS) && !defined(NOTERMIOS)
|
||||
#if !defined(NOTERMIOS)
|
||||
if (setvbuf(stderr, NULL, _IOFBF, 1000))
|
||||
I_OutputMsg("setvbuf didnt work\n");
|
||||
#endif
|
||||
|
@ -1227,10 +1159,6 @@ void D_SRB2Main(void)
|
|||
dedicated = M_CheckParm("-dedicated") != 0;
|
||||
#endif
|
||||
|
||||
#ifdef PC_DOS
|
||||
D_Titlebar();
|
||||
#endif
|
||||
|
||||
if (devparm)
|
||||
CONS_Printf(M_GetText("Development mode ON.\n"));
|
||||
|
||||
|
|
|
@ -46,12 +46,6 @@
|
|||
#include "hardware/hw_light.h"
|
||||
#endif
|
||||
|
||||
#ifdef PC_DOS
|
||||
#include <stdio.h> // for snprintf
|
||||
//int snprintf(char *str, size_t n, const char *fmt, ...);
|
||||
int vsnprintf(char *str, size_t n, const char *fmt, va_list ap);
|
||||
#endif
|
||||
|
||||
// Free slot names
|
||||
// The crazy word-reading stuff uses these.
|
||||
static char *FREE_STATES[NUMSTATEFREESLOTS];
|
||||
|
|
|
@ -1,48 +0,0 @@
|
|||
#
|
||||
# djgppdos/makefile.cfg for SRB2/DOS
|
||||
#
|
||||
|
||||
#
|
||||
#now for the DOS stuff, go DOS!
|
||||
#
|
||||
|
||||
# options
|
||||
OPTS=-DPC_DOS
|
||||
WFLAGS+=-Wno-cast-qual
|
||||
NOHW=1
|
||||
NOHS=1
|
||||
PNG_CFLAGS=
|
||||
PNG_LDFLAGS=-lpng -lz
|
||||
|
||||
ifdef WATTCP
|
||||
OPTS+=-DWATTCP
|
||||
NOOBJDUMP=1
|
||||
endif
|
||||
|
||||
#ifdef DEBUGMODE
|
||||
LIBS=-lalld
|
||||
#else
|
||||
# LIBS=-lalleg
|
||||
#endif
|
||||
|
||||
ifndef NONET
|
||||
ifdef WATTCP
|
||||
LIBS+=-lwatt
|
||||
else
|
||||
LIBS+=-lsocket
|
||||
endif
|
||||
endif
|
||||
|
||||
ifdef RDB
|
||||
LIBS+=-lgdbst -ldzcom
|
||||
OPTS+=-DREMOTE_DEBUGGING
|
||||
endif
|
||||
|
||||
OBJS=$(OBJDIR)/i_video.o $(OBJDIR)/vid_vesa.o
|
||||
|
||||
# name of the exefile
|
||||
ifdef WATTCP
|
||||
EXENAME?=srb2dos.exe
|
||||
else
|
||||
EXENAME?=srb2w16.exe
|
||||
endif
|
|
@ -1,755 +0,0 @@
|
|||
/* bcd.c -- Brennan's CD-ROM Audio Playing Library
|
||||
by Brennan Underwood, http://brennan.home.ml.org/ */
|
||||
#include <dos.h>
|
||||
#include <dpmi.h>
|
||||
#include <go32.h>
|
||||
#include <fcntl.h>
|
||||
#include <stdio.h>
|
||||
#include <malloc.h>
|
||||
#include <unistd.h>
|
||||
#include <strings.h>
|
||||
#ifdef STANDALONE
|
||||
#include <conio.h> /* for getch() */
|
||||
#endif
|
||||
|
||||
#include "bcd.h"
|
||||
|
||||
typedef struct {
|
||||
int is_audio;
|
||||
int start, end, len;
|
||||
} Track;
|
||||
|
||||
static int mscdex_version;
|
||||
static int first_drive;
|
||||
static int num_tracks;
|
||||
static int lowest_track, highest_track;
|
||||
static int audio_length;
|
||||
|
||||
#ifdef STATIC_TRACKS
|
||||
static Track tracks[99];
|
||||
#else
|
||||
static Track *tracks;
|
||||
#endif
|
||||
|
||||
static int dos_mem_segment, dos_mem_selector = -1;
|
||||
|
||||
int _status, _error, _error_code;
|
||||
const char *_bcd_error = NULL;
|
||||
|
||||
#define RESET_ERROR (_error = _error_code = 0)
|
||||
#define ERROR_BIT (1 << 15)
|
||||
#define BUSY_BIT (1 << 9)
|
||||
#ifndef TRUE
|
||||
#define TRUE 1
|
||||
#define FALSE 0
|
||||
#endif
|
||||
|
||||
#pragma pack(1)
|
||||
|
||||
/* I know 'typedef struct {} bleh' is a bad habit, but... */
|
||||
typedef struct {
|
||||
unsigned char len;
|
||||
unsigned char unit;
|
||||
unsigned char command;
|
||||
unsigned short status;
|
||||
unsigned char reserved[8];
|
||||
} ATTRPACK RequestHeader;
|
||||
|
||||
typedef struct {
|
||||
RequestHeader request_header;
|
||||
unsigned char descriptor;
|
||||
unsigned long address;
|
||||
unsigned short len;
|
||||
unsigned short secnum;
|
||||
unsigned long ptr;
|
||||
} ATTRPACK IOCTLI;
|
||||
|
||||
typedef struct {
|
||||
unsigned char control;
|
||||
unsigned char lowest;
|
||||
unsigned char highest;
|
||||
char total[4];
|
||||
} ATTRPACK DiskInfo;
|
||||
|
||||
typedef struct {
|
||||
unsigned char control;
|
||||
unsigned char track_number;
|
||||
char start[4];
|
||||
unsigned char info;
|
||||
} ATTRPACK TrackInfo;
|
||||
|
||||
typedef struct {
|
||||
RequestHeader request;
|
||||
unsigned char mode;
|
||||
unsigned long start;
|
||||
unsigned long len;
|
||||
} ATTRPACK PlayRequest;
|
||||
|
||||
typedef struct {
|
||||
RequestHeader request;
|
||||
} ATTRPACK StopRequest;
|
||||
|
||||
typedef struct {
|
||||
RequestHeader request;
|
||||
} ATTRPACK ResumeRequest;
|
||||
|
||||
typedef struct {
|
||||
unsigned char control;
|
||||
unsigned char input0;
|
||||
unsigned char volume0;
|
||||
unsigned char input1;
|
||||
unsigned char volume1;
|
||||
unsigned char input2;
|
||||
unsigned char volume2;
|
||||
unsigned char input3;
|
||||
unsigned char volume3;
|
||||
} ATTRPACK VolumeRequest;
|
||||
|
||||
typedef struct {
|
||||
unsigned char control;
|
||||
unsigned char fn;
|
||||
} ATTRPACK LockRequest;
|
||||
|
||||
typedef struct {
|
||||
unsigned char control;
|
||||
unsigned char mbyte;
|
||||
} ATTRPACK MediaChangedRequest;
|
||||
|
||||
typedef struct {
|
||||
unsigned char control;
|
||||
unsigned long status;
|
||||
} ATTRPACK StatusRequest;
|
||||
|
||||
typedef struct {
|
||||
unsigned char control;
|
||||
unsigned char mode;
|
||||
unsigned long loc;
|
||||
} ATTRPACK PositionRequest;
|
||||
|
||||
#pragma pack()
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
const char *bcd_error(void) {
|
||||
static char retstr[132];
|
||||
const char *errorcodes[] = {
|
||||
"Write-protect violation",
|
||||
"Unknown unit",
|
||||
"Drive not ready",
|
||||
"Unknown command",
|
||||
"CRC error",
|
||||
"Bad drive request structure length",
|
||||
"Seek error",
|
||||
"Unknown media",
|
||||
"Sector not found",
|
||||
"Printer out of paper: world coming to an end",/* I mean really, on a CD? */
|
||||
"Write fault",
|
||||
"Read fault",
|
||||
"General failure",
|
||||
"Reserved",
|
||||
"Reserved",
|
||||
"Invalid disk change"
|
||||
};
|
||||
*retstr = 0;
|
||||
if (_error != 0) {
|
||||
strcat(retstr, "Device error: ");
|
||||
if (_error_code < 0 || _error_code > 0xf)
|
||||
strcat(retstr, "Invalid error");
|
||||
else
|
||||
strcat(retstr, errorcodes[_error_code]);
|
||||
strcat(retstr, " ");
|
||||
}
|
||||
if (_bcd_error != NULL) {
|
||||
if (*retstr) strcat(retstr, ", ");
|
||||
strcat(retstr, "BCD error: ");
|
||||
strcat(retstr, _bcd_error);
|
||||
}
|
||||
return retstr;
|
||||
}
|
||||
|
||||
/* DOS IOCTL w/ command block */
|
||||
static void bcd_ioctl(IOCTLI *ioctli, void *command, int len) {
|
||||
int ioctli_len = sizeof (IOCTLI);
|
||||
unsigned long command_address = dos_mem_segment << 4;
|
||||
__dpmi_regs regs;
|
||||
|
||||
memset(®s, 0, sizeof regs);
|
||||
regs.x.es = (__tb >> 4) & 0xffff;
|
||||
regs.x.ax = 0x1510;
|
||||
regs.x.bx = __tb & 0xf;
|
||||
regs.x.cx = first_drive;
|
||||
ioctli->address = dos_mem_segment << 16;
|
||||
ioctli->len = len;
|
||||
dosmemput(ioctli, ioctli_len, __tb); /* put ioctl into dos area */
|
||||
dosmemput(command, len, command_address); /* and command too */
|
||||
if (__dpmi_int(0x2f, ®s) == -1) {
|
||||
_bcd_error = "__dpmi_int() failed";
|
||||
return;
|
||||
}
|
||||
dosmemget(__tb, ioctli_len, ioctli); /* retrieve results */
|
||||
dosmemget(command_address, len, command);
|
||||
_status = ioctli->request_header.status;
|
||||
if (_status & ERROR_BIT) {
|
||||
_error = TRUE;
|
||||
_error_code = _status & 0xff;
|
||||
} else {
|
||||
_error = FALSE;
|
||||
_error_code = 0;
|
||||
}
|
||||
}
|
||||
|
||||
/* no command block */
|
||||
FUNCINLINE static ATTRINLINE void bcd_ioctl2(void *cmd, int len) {
|
||||
__dpmi_regs regs;
|
||||
memset(®s, 0, sizeof regs);
|
||||
regs.x.es = (__tb >> 4) & 0xffff;
|
||||
regs.x.ax = 0x1510;
|
||||
regs.x.bx = __tb & 0xf;
|
||||
regs.x.cx = first_drive;
|
||||
dosmemput(cmd, len, __tb); /* put ioctl block in dos arena */
|
||||
if (__dpmi_int(0x2f, ®s) == -1) {
|
||||
_bcd_error = "__dpmi_int() failed";
|
||||
return;
|
||||
}
|
||||
/* I hate to have no error capability for ioctl2 but the command block
|
||||
doesn't necessarily have a status field */
|
||||
RESET_ERROR;
|
||||
}
|
||||
|
||||
FUNCINLINE static ATTRINLINE int red2hsg(char *r) {
|
||||
return r[0] + r[1]*75 + r[2]*4500 - 150;
|
||||
}
|
||||
|
||||
int bcd_now_playing(void) {
|
||||
int i, loc = bcd_audio_position();
|
||||
_bcd_error = NULL;
|
||||
if (!bcd_audio_busy()) {
|
||||
_bcd_error = "Audio not playing";
|
||||
return 0;
|
||||
}
|
||||
if (
|
||||
#ifndef STATIC_TRACKS
|
||||
tracks == NULL &&
|
||||
#endif
|
||||
!bcd_get_audio_info())
|
||||
return 0;
|
||||
for (i = lowest_track; i <= highest_track; i++) {
|
||||
if (loc >= tracks[i].start && loc <= tracks[i].end) return i;
|
||||
}
|
||||
/* some bizarre location? */
|
||||
_bcd_error = "Head outside of bounds";
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* handles the setup for CD-ROM audio interface */
|
||||
int bcd_open(void) {
|
||||
__dpmi_regs regs;
|
||||
_bcd_error = NULL;
|
||||
|
||||
/* disk I/O wouldn't work anyway if you set sizeof tb this low, but... */
|
||||
if (_go32_info_block.size_of_transfer_buffer < 4096) {
|
||||
_bcd_error = "Transfer buffer too small";
|
||||
return 0;
|
||||
}
|
||||
|
||||
memset(®s, 0, sizeof regs);
|
||||
regs.x.ax = 0x1500;
|
||||
regs.x.bx = 0x0;
|
||||
__dpmi_int(0x2f, ®s);
|
||||
if (regs.x.bx == 0) { /* abba no longer lives */
|
||||
_bcd_error = "MSCDEX not found";
|
||||
return 0;
|
||||
}
|
||||
|
||||
first_drive = regs.x.cx; /* use the first drive */
|
||||
|
||||
/* check for mscdex at least 2.0 */
|
||||
memset(®s, 0, sizeof regs);
|
||||
regs.x.ax = 0x150C;
|
||||
__dpmi_int(0x2f, ®s);
|
||||
if (regs.x.bx == 0) {
|
||||
_bcd_error = "MSCDEX version < 2.0";
|
||||
return 0;
|
||||
}
|
||||
mscdex_version = regs.x.bx;
|
||||
|
||||
/* allocate 256 bytes of dos memory for the command blocks */
|
||||
if ((dos_mem_segment = __dpmi_allocate_dos_memory(16, &dos_mem_selector))<0) {
|
||||
_bcd_error = "Could not allocate 256 bytes of DOS memory";
|
||||
return 0;
|
||||
}
|
||||
|
||||
return mscdex_version;
|
||||
}
|
||||
|
||||
/* Shuts down CD-ROM audio interface */
|
||||
int bcd_close(void) {
|
||||
_bcd_error = NULL;
|
||||
if (dos_mem_selector != -1) {
|
||||
__dpmi_free_dos_memory(dos_mem_selector);
|
||||
dos_mem_selector = -1;
|
||||
}
|
||||
#ifndef STATIC_TRACKS
|
||||
if (tracks) free(tracks);
|
||||
tracks = NULL;
|
||||
#endif
|
||||
RESET_ERROR;
|
||||
return 1;
|
||||
}
|
||||
|
||||
int bcd_open_door(void) {
|
||||
IOCTLI ioctli;
|
||||
char eject = 0;
|
||||
_bcd_error = NULL;
|
||||
memset(&ioctli, 0, sizeof ioctli);
|
||||
ioctli.request_header.len = sizeof ioctli;
|
||||
ioctli.request_header.command = 12;
|
||||
ioctli.len = 1;
|
||||
bcd_ioctl(&ioctli, &eject, sizeof eject);
|
||||
if (_error) return 0;
|
||||
return 1;
|
||||
}
|
||||
|
||||
int bcd_close_door(void) {
|
||||
IOCTLI ioctli;
|
||||
char closeit = 5;
|
||||
_bcd_error = NULL;
|
||||
memset(&ioctli, 0, sizeof ioctli);
|
||||
ioctli.request_header.len = sizeof ioctli;
|
||||
ioctli.request_header.command = 12;
|
||||
ioctli.len = 1;
|
||||
bcd_ioctl(&ioctli, &closeit, sizeof closeit);
|
||||
if (_error) return 0;
|
||||
return 1;
|
||||
}
|
||||
|
||||
int bcd_lock(int fn) {
|
||||
IOCTLI ioctli;
|
||||
LockRequest req;
|
||||
_bcd_error = NULL;
|
||||
memset(&ioctli, 0, sizeof ioctli);
|
||||
memset(&req, 0, sizeof req);
|
||||
ioctli.request_header.len = sizeof ioctli;
|
||||
ioctli.request_header.command = 12;
|
||||
ioctli.len = sizeof req;
|
||||
req.control = 1;
|
||||
req.fn = fn ? 1 : 0;
|
||||
bcd_ioctl(&ioctli, &req, sizeof req);
|
||||
if (_error) return 0;
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
int bcd_disc_changed(void) {
|
||||
IOCTLI ioctli;
|
||||
MediaChangedRequest req;
|
||||
_bcd_error = NULL;
|
||||
memset(&ioctli, 0, sizeof ioctli);
|
||||
memset(&req, 0, sizeof req);
|
||||
ioctli.request_header.len = sizeof ioctli;
|
||||
ioctli.request_header.command = 3;
|
||||
ioctli.len = sizeof req;
|
||||
req.control = 9;
|
||||
bcd_ioctl(&ioctli, &req, sizeof req);
|
||||
return req.mbyte;
|
||||
}
|
||||
|
||||
int bcd_reset(void) {
|
||||
IOCTLI ioctli;
|
||||
char reset = 2;
|
||||
_bcd_error = NULL;
|
||||
|
||||
memset(&ioctli, 0, sizeof ioctli);
|
||||
ioctli.request_header.len = sizeof ioctli;
|
||||
ioctli.request_header.command = 12;
|
||||
ioctli.len = 1;
|
||||
bcd_ioctl(&ioctli, &reset, sizeof reset);
|
||||
if (_error) return 0;
|
||||
return 1;
|
||||
}
|
||||
|
||||
int bcd_device_status(void) {
|
||||
IOCTLI ioctli;
|
||||
StatusRequest req;
|
||||
_bcd_error = NULL;
|
||||
memset(&ioctli, 0, sizeof ioctli);
|
||||
memset(&req, 0, sizeof req);
|
||||
ioctli.request_header.len = sizeof ioctli; // ok
|
||||
ioctli.request_header.command = 3;
|
||||
ioctli.len = sizeof req;
|
||||
req.control = 6;
|
||||
bcd_ioctl(&ioctli, &req, sizeof req);
|
||||
return req.status;
|
||||
}
|
||||
|
||||
static inline int bcd_get_status_word(void) {
|
||||
IOCTLI ioctli;
|
||||
DiskInfo disk_info;
|
||||
|
||||
/* get cd info as an excuse to get a look at the status word */
|
||||
memset(&disk_info, 0, sizeof disk_info);
|
||||
memset(&ioctli, 0, sizeof ioctli);
|
||||
|
||||
ioctli.request_header.len = 26;
|
||||
ioctli.request_header.command = 3;
|
||||
ioctli.len = 7;
|
||||
disk_info.control = 10;
|
||||
bcd_ioctl(&ioctli, &disk_info, sizeof disk_info);
|
||||
return _status;
|
||||
}
|
||||
|
||||
int bcd_audio_busy(void) {
|
||||
_bcd_error = NULL;
|
||||
/* If the door is open, then the head is busy, and so the busy bit is
|
||||
on. It is not, however, playing audio. */
|
||||
if (bcd_device_status() & BCD_DOOR_OPEN)
|
||||
return 0;
|
||||
|
||||
bcd_get_status_word();
|
||||
if (_error) return -1;
|
||||
return (_status & BUSY_BIT) ? 1 : 0;
|
||||
}
|
||||
|
||||
int bcd_audio_position(void) {
|
||||
IOCTLI ioctli;
|
||||
PositionRequest req;
|
||||
_bcd_error = NULL;
|
||||
memset(&ioctli, 0, sizeof ioctli);
|
||||
memset(&req, 0, sizeof req);
|
||||
ioctli.request_header.len = sizeof ioctli;
|
||||
ioctli.request_header.command = 3;
|
||||
ioctli.len = sizeof req;
|
||||
req.control = 1;
|
||||
bcd_ioctl(&ioctli, &req, sizeof req);
|
||||
return req.loc;
|
||||
}
|
||||
|
||||
/* Internal function to get track info */
|
||||
static inline void bcd_get_track_info(int n, Track *t) {
|
||||
IOCTLI ioctli;
|
||||
TrackInfo info;
|
||||
|
||||
memset(&ioctli, 0, sizeof ioctli);
|
||||
memset(&info, 0, sizeof info);
|
||||
ioctli.request_header.len = sizeof ioctli;
|
||||
ioctli.request_header.command = 3;
|
||||
info.control = 11;
|
||||
info.track_number = n;
|
||||
bcd_ioctl(&ioctli, &info, sizeof info);
|
||||
t->start = red2hsg(info.start);
|
||||
if (info.info & 64)
|
||||
t->is_audio = 0;
|
||||
else
|
||||
t->is_audio = 1;
|
||||
}
|
||||
|
||||
int bcd_get_audio_info(void) {
|
||||
IOCTLI ioctli;
|
||||
DiskInfo disk_info;
|
||||
int i;
|
||||
|
||||
|
||||
_bcd_error = NULL;
|
||||
#ifndef STATIC_TRACKS
|
||||
if (tracks) free(tracks);
|
||||
tracks = NULL;
|
||||
#endif
|
||||
|
||||
memset(&disk_info, 0, sizeof disk_info);
|
||||
memset(&ioctli, 0, sizeof ioctli);
|
||||
|
||||
ioctli.request_header.len = 26;
|
||||
ioctli.request_header.command = 3;
|
||||
ioctli.len = 7;
|
||||
disk_info.control = 10;
|
||||
bcd_ioctl(&ioctli, &disk_info, sizeof disk_info);
|
||||
if (_error) return 0;
|
||||
|
||||
lowest_track = disk_info.lowest;
|
||||
highest_track = disk_info.highest;
|
||||
num_tracks = disk_info.highest - disk_info.lowest + 1;
|
||||
|
||||
#ifndef STATIC_TRACKS
|
||||
//tracks = calloc(num_tracks, sizeof (Track));
|
||||
/* alloc max space in order to attempt to avoid possible overrun bug */
|
||||
tracks = calloc(highest_track+1, sizeof (Track));
|
||||
if (tracks == NULL) {
|
||||
_bcd_error = "Out of memory allocating tracks\n";
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
/* get track starts */
|
||||
for (i = lowest_track; i <= highest_track; i++)
|
||||
bcd_get_track_info(i, tracks+i);
|
||||
|
||||
/* figure out track ends */
|
||||
for (i = lowest_track; i < highest_track; i++)
|
||||
tracks[i].end = tracks[i+1].start-1;
|
||||
audio_length = red2hsg(disk_info.total);
|
||||
tracks[i].end = audio_length;
|
||||
for (i = lowest_track; i <= highest_track; i++)
|
||||
tracks[i].len = tracks[i].end - tracks[i].start;
|
||||
|
||||
return num_tracks;
|
||||
}
|
||||
|
||||
int bcd_get_track_address(int trackno, int *start, int *len) {
|
||||
_bcd_error = NULL;
|
||||
//if (trackno >= num_tracks+1 || trackno <= 0) {
|
||||
if (trackno < lowest_track || trackno > highest_track) {
|
||||
_bcd_error = "Track out of range";
|
||||
*start = *len = 0;
|
||||
return 0;
|
||||
}
|
||||
*start = tracks[trackno].start;
|
||||
*len = tracks[trackno].len;
|
||||
return 1;
|
||||
}
|
||||
|
||||
int bcd_track_is_audio(int trackno) {
|
||||
//if (trackno >= num_tracks+1 || trackno <= 0) {
|
||||
if (trackno < lowest_track || trackno > highest_track) {
|
||||
_bcd_error = "Track out of range";
|
||||
return 0;
|
||||
}
|
||||
return tracks[trackno].is_audio;
|
||||
}
|
||||
|
||||
int bcd_set_volume(int volume) {
|
||||
IOCTLI ioctli;
|
||||
VolumeRequest v;
|
||||
|
||||
_bcd_error = NULL;
|
||||
if (volume > 255) volume = 255;
|
||||
else if (volume < 0) volume = 0;
|
||||
memset(&ioctli, 0, sizeof ioctli);
|
||||
ioctli.request_header.len = sizeof ioctli;
|
||||
ioctli.request_header.command = 12;
|
||||
ioctli.len = sizeof v;
|
||||
v.control = 3;
|
||||
v.volume0 = volume;
|
||||
v.input0 = 0;
|
||||
v.volume1 = volume;
|
||||
v.input1 = 1;
|
||||
v.volume2 = volume;
|
||||
v.input2 = 2;
|
||||
v.volume3 = volume;
|
||||
v.input3 = 3;
|
||||
|
||||
bcd_ioctl(&ioctli, &v, sizeof v);
|
||||
if (_error) return 0;
|
||||
return 1;
|
||||
}
|
||||
|
||||
int bcd_play(int location, int frames) {
|
||||
PlayRequest cmd;
|
||||
memset(&cmd, 0, sizeof cmd);
|
||||
|
||||
_bcd_error = NULL;
|
||||
/* the following should be in user code, but it'll fail otherwise */
|
||||
if (bcd_audio_busy())
|
||||
bcd_stop();
|
||||
|
||||
cmd.request.len = sizeof cmd;
|
||||
cmd.request.command = 132;
|
||||
cmd.start = location;
|
||||
cmd.len = frames;
|
||||
bcd_ioctl2(&cmd, sizeof cmd);
|
||||
if (_error) return 0;
|
||||
return 1;
|
||||
}
|
||||
|
||||
int bcd_play_track(int trackno) {
|
||||
_bcd_error = NULL;
|
||||
if (!bcd_get_audio_info()) return 0;
|
||||
|
||||
if (trackno < lowest_track || trackno > highest_track) {
|
||||
_bcd_error = "Track out of range";
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (! tracks[trackno].is_audio) {
|
||||
_bcd_error = "Not an audio track";
|
||||
return 0;
|
||||
}
|
||||
|
||||
return bcd_play(tracks[trackno].start, tracks[trackno].len);
|
||||
}
|
||||
|
||||
int bcd_stop(void) {
|
||||
StopRequest cmd;
|
||||
_bcd_error = NULL;
|
||||
memset(&cmd, 0, sizeof cmd);
|
||||
cmd.request.len = sizeof cmd;
|
||||
cmd.request.command = 133;
|
||||
bcd_ioctl2(&cmd, sizeof cmd);
|
||||
if (_error) return 0;
|
||||
return 1;
|
||||
}
|
||||
|
||||
int bcd_resume(void) {
|
||||
ResumeRequest cmd;
|
||||
_bcd_error = NULL;
|
||||
memset(&cmd, 0, sizeof cmd);
|
||||
cmd.request.len = sizeof cmd;
|
||||
cmd.request.command = 136;
|
||||
bcd_ioctl2(&cmd, sizeof cmd);
|
||||
if (_error) return 0;
|
||||
return 1;
|
||||
}
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef STANDALONE
|
||||
static char *card(int c) {
|
||||
return c == 1 ? "" : "s";
|
||||
}
|
||||
|
||||
static void print_hsg(int hsg) {
|
||||
int hours, minutes, seconds;
|
||||
seconds = hsg / 75;
|
||||
minutes = seconds / 60;
|
||||
seconds %= 60;
|
||||
hours = minutes / 60;
|
||||
minutes %= 60;
|
||||
printf("%2d:%02d:%02d", hours, minutes, seconds);
|
||||
}
|
||||
|
||||
static void print_binary(int v, int len) {
|
||||
for (;len;len--)
|
||||
printf("%d", (v & (1 << len)) ? 1 : 0);
|
||||
}
|
||||
|
||||
int main(int argc, char *argv[]) {
|
||||
int i, n1, n2, t;
|
||||
|
||||
if (!bcd_open()) {
|
||||
fprintf(stderr, "Couldn't open CD-ROM drive. %s\n", bcd_error());
|
||||
exit(0);
|
||||
}
|
||||
|
||||
for (i = 1; i < argc; i++) {
|
||||
if (*argv[i] == '-') strcpy(argv[i], argv[i]+1);
|
||||
if (!strcmp(argv[i], "open") || !strcmp(argv[i], "eject")) {
|
||||
bcd_open_door();
|
||||
} else if (!strcmp(argv[i], "close")) {
|
||||
bcd_close_door();
|
||||
} else if (!strcmp(argv[i], "sleep")) {
|
||||
if (++i >= argc) break;
|
||||
sleep(atoi(argv[i]));
|
||||
} else if (!strcmp(argv[i], "list")) {
|
||||
int nd = 0, na = 0, audio_time = 0;
|
||||
if (!bcd_get_audio_info()) {
|
||||
printf("Error getting audio info\n");
|
||||
} else if (lowest_track == 0) {
|
||||
printf("No audio tracks\n");
|
||||
} else {
|
||||
for (t = lowest_track; t <= highest_track; t++) {
|
||||
printf("Track %2d: ", t);
|
||||
print_hsg(tracks[t].start);
|
||||
printf(" -> ");
|
||||
print_hsg(tracks[t].end);
|
||||
printf(" (");
|
||||
print_hsg(tracks[t].len);
|
||||
if (tracks[t].is_audio) {
|
||||
na++;
|
||||
printf(") audio");
|
||||
audio_time += tracks[t].len;
|
||||
} else {
|
||||
nd++;
|
||||
printf(") data ");
|
||||
}
|
||||
printf(" (HSG: %06d->%06d)\n", tracks[t].start, tracks[t].end);
|
||||
}
|
||||
printf("%d audio track%s, %d data track%s\n", na, card(na), nd, card(nd));
|
||||
if (audio_time) {
|
||||
printf("Audio time: ");
|
||||
print_hsg(audio_time);
|
||||
printf("\n");
|
||||
}
|
||||
}
|
||||
} else if (!strcmp(argv[i], "lock")) {
|
||||
bcd_lock(1);
|
||||
} else if (!strcmp(argv[i], "pladdr")) {
|
||||
if (++i >= argc) break;
|
||||
n1 = atoi(argv[i]);
|
||||
if (++i >= argc) break;
|
||||
n2 = atoi(argv[i]);
|
||||
printf("Playing frame %d to frame %d\n", n1, n2);
|
||||
bcd_play(n1, n2-n1);
|
||||
} else if (!strcmp(argv[i], "play")) {
|
||||
if (++i >= argc) break;
|
||||
if (bcd_audio_busy()) {
|
||||
bcd_stop();
|
||||
delay(1000);
|
||||
}
|
||||
n1 = atoi(argv[i]);
|
||||
printf("Playing track %d\n", n1);
|
||||
bcd_play_track(n1);
|
||||
} else if (!strcmp(argv[i], "reset")) {
|
||||
bcd_reset();
|
||||
} else if (!strcmp(argv[i], "resume")) {
|
||||
bcd_resume();
|
||||
} else if (!strcmp(argv[i], "status")) {
|
||||
int s;
|
||||
s = bcd_device_status();
|
||||
printf("MSCDEX version %d.%d\n", mscdex_version >> 8,
|
||||
mscdex_version & 0xff);
|
||||
printf("Device status word '");
|
||||
print_binary(s, 16);
|
||||
printf("'\nDoor is %sopen\n", s & BCD_DOOR_OPEN ? "" : "not ");
|
||||
printf("Door is %slocked\n", s & BCD_DOOR_UNLOCKED ? "not " : "");
|
||||
printf("Audio is %sbusy\n", bcd_audio_busy() ? "" : "not ");
|
||||
s = bcd_disc_changed();
|
||||
if (s == BCD_DISC_UNKNOWN) printf("Media change status unknown\n");
|
||||
else printf("Media has %schanged\n",
|
||||
(s == BCD_DISC_CHANGED) ? "" : "not ");
|
||||
} else if (!strcmp(argv[i], "stop")) {
|
||||
bcd_stop();
|
||||
} else if (!strcmp(argv[i], "unlock")) {
|
||||
bcd_lock(0);
|
||||
} else if (!strcmp(argv[i], "volume")) {
|
||||
bcd_set_volume(atoi(argv[++i]));
|
||||
} else if (!strcmp(argv[i], "wait")) {
|
||||
while (bcd_audio_busy()) {
|
||||
int n = bcd_now_playing();
|
||||
if (n == 0) break;
|
||||
printf("%2d: ", n);
|
||||
print_hsg(bcd_audio_position() - tracks[n].start);
|
||||
printf("\r");
|
||||
fflush(stdout);
|
||||
delay(100);
|
||||
if (kbhit() && getch() == 27) break;
|
||||
}
|
||||
printf("\n");
|
||||
} else if (!strcmp(argv[i], "help") || !strcmp(argv[i], "usage")) {
|
||||
printf("BCD version %x.%x\n" \
|
||||
"Usage: BCD {commands}\n" \
|
||||
"Valid commands:\n" \
|
||||
"\tclose - close door/tray\n" \
|
||||
"\tdelay {n} - delay {n} seconds\n" \
|
||||
"\tlist - list track info\n" \
|
||||
"\tlock - lock door/tray\n" \
|
||||
"\topen - open door/tray\n" \
|
||||
"\tpladdr {n1} {n2}- play frame {n1} to {n2}\n" \
|
||||
"\tplay {n} - play track {n}\n" \
|
||||
"\treset - reset the drive\n" \
|
||||
"\tresume - resume from last stop\n" \
|
||||
"\tstatus - show drive status\n" \
|
||||
"\tstop - stop audio playback\n" \
|
||||
"\tunlock - unlock door/tray\n" \
|
||||
"\tvolume {n} - set volume to {n} where 0 <= {n} <= 255\n",
|
||||
BCD_VERSION >> 8, BCD_VERSION & 0xff);
|
||||
} else
|
||||
printf("Unknown command '%s'\n", argv[i]);
|
||||
if (_error || _bcd_error) printf("%s\n", bcd_error());
|
||||
}
|
||||
bcd_close();
|
||||
exit(0);
|
||||
}
|
||||
#endif
|
|
@ -1,90 +0,0 @@
|
|||
/* bcd.h -- header file for BCD, a CD-ROM audio playing library for DJGPP
|
||||
by Brennan Underwood, http://brennan.home.ml.org/ */
|
||||
#ifndef _BCD_H
|
||||
#define _BCD_H
|
||||
|
||||
#define BCD_VERSION 0x0103
|
||||
|
||||
/* Installation and setup functions */
|
||||
/* Call this first! */
|
||||
int bcd_open(void);
|
||||
/* Call before exit. */
|
||||
int bcd_close(void);
|
||||
|
||||
/* open door, unlocking first if necessary */
|
||||
int bcd_open_door(void);
|
||||
/* close door */
|
||||
int bcd_close_door(void);
|
||||
|
||||
/* pass 1 to lock door, 0 to unlock */
|
||||
int bcd_lock(int);
|
||||
|
||||
/* returns one of the following 3 #defined symbols */
|
||||
int bcd_disc_changed(void);
|
||||
#define BCD_DISC_CHANGED 0xff
|
||||
#define BCD_DISC_NOT_CHANGED 1
|
||||
#define BCD_DISC_UNKNOWN 0
|
||||
|
||||
/* perform a device reset */
|
||||
int bcd_reset(void);
|
||||
|
||||
/* compare the returned status int to the following bits */
|
||||
int bcd_device_status(void);
|
||||
#define BCD_DOOR_OPEN 1
|
||||
#define BCD_DOOR_UNLOCKED 2
|
||||
#define BCD_SUPPORT_COOKED 4
|
||||
#define BCD_READ_ONLY 8
|
||||
#define BCD_DATA_READ_ONLY 16
|
||||
#define BCD_SUPPORT_INTERLEAVE 32
|
||||
|
||||
/* returns 1 if audio is currently playing, 0 otherwise. -1 on error */
|
||||
int bcd_audio_busy(void);
|
||||
/* current head position in frames */
|
||||
int bcd_audio_position(void);
|
||||
/* convenience function, if audio busy, returns track# playing now */
|
||||
int bcd_now_playing(void);
|
||||
|
||||
/* query MSCDEX for track list when disc changed or just starting up */
|
||||
int bcd_get_audio_info(void);
|
||||
/* get a particular track's info */
|
||||
int bcd_get_track_address(int trackno, int *start, int *len);
|
||||
/* check for track's audio/data status */
|
||||
int bcd_track_is_audio(int trackno);
|
||||
/* play a particular track from beginning to end */
|
||||
int bcd_play_track(int tracknum);
|
||||
/* play an arbitrary section of audio for an arbitrary length of time */
|
||||
int bcd_play(int start, int len);
|
||||
/* set the output volume. pass a parameter from 0-255 */
|
||||
int bcd_set_volume(int);
|
||||
/* stop and pause are equivalent */
|
||||
int bcd_stop(void);
|
||||
#define bcd_pause bcd_stop
|
||||
int bcd_resume(void);
|
||||
|
||||
/* Troubleshooting */
|
||||
/* Returns a human readable description of the last error encountered */
|
||||
const char *bcd_error(void);
|
||||
extern int _error_code;
|
||||
/* If you are mad enough play the Rach 3, I mean parse _error_code yourself */
|
||||
#define BCD_DE_WRITE_PROTECT 0
|
||||
#define BCD_DE_UNKNOWN_UNIT 1
|
||||
#define BCD_DE_DRIVE_NOT_READY 2
|
||||
#define BCD_DE_UNKNOWN_COMMAND 3
|
||||
#define BCD_DE_CRC_ERROR 4
|
||||
#define BCD_DE_STRUCT_LEN 5
|
||||
#define BCD_DE_SEEK_ERROR 6
|
||||
#define BCD_DE_UNKNOWN_MEDIA 7
|
||||
#define BCD_DE_SECTOR_NOT_FOUND 8
|
||||
#define BCD_DE_OUT_OF_PAPER 9
|
||||
#define BCD_DE_WRITE_FAULT 10
|
||||
#define BCD_DE_READ_FAULT 11
|
||||
#define BCD_DE_GENERAL_FAILURE 12
|
||||
#define BCD_DE_INVALID_DISK_CHANGE 15
|
||||
/* set by BCD itself, for stuff like "Out of memory" */
|
||||
extern const char *_bcd_error;
|
||||
|
||||
/* uncomment this line to force BCD to use a statically allocated
|
||||
Track array instead of using malloc */
|
||||
#define STATIC_TRACKS
|
||||
|
||||
#endif
|
|
@ -1,445 +0,0 @@
|
|||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// Copyright (C) 1998-2000 by DooM Legacy Team.
|
||||
//
|
||||
// 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.
|
||||
//-----------------------------------------------------------------------------
|
||||
/// \file
|
||||
/// \brief cd music interface (uses bcd library)
|
||||
|
||||
// Alam_GBC: I hate you, Brennan Underwood :)
|
||||
#include "../doomtype.h"
|
||||
#include "bcd.c"
|
||||
//#include "bcd.h" // CD-Audio library by Brennan Underwood
|
||||
|
||||
#include "../doomdef.h"
|
||||
#include "../i_sound.h"
|
||||
#include "../command.h"
|
||||
#include "../i_system.h"
|
||||
#include "../s_sound.h"
|
||||
|
||||
// ------
|
||||
// protos
|
||||
// ------
|
||||
static void Command_Cd_f (void);
|
||||
|
||||
|
||||
//======================================================================
|
||||
// CD AUDIO MUSIC SUBSYSTEM
|
||||
//======================================================================
|
||||
|
||||
UINT8 cdaudio_started=0; // for system startup/shutdown
|
||||
|
||||
#define MAX_CD_TRACKS 256
|
||||
static boolean cdPlaying = false;
|
||||
static int cdPlayTrack; // when cdPlaying is true
|
||||
static boolean cdLooping = false;
|
||||
static UINT8 cdRemap[MAX_CD_TRACKS];
|
||||
static boolean cdEnabled=true; // cd info available
|
||||
static boolean cdValid; // true when last cd audio info was ok
|
||||
static boolean wasPlaying;
|
||||
static int cdVolume=0; // current cd volume (0-31)
|
||||
|
||||
// 0-31 like Music & Sfx, though CD hardware volume is 0-255.
|
||||
consvar_t cd_volume = {"cd_volume","18",CV_SAVE,soundvolume_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
||||
// allow Update for next/loop track
|
||||
// some crap cd drivers take up to
|
||||
// a second for a simple 'busy' check..
|
||||
// (on those Update can be disabled)
|
||||
consvar_t cdUpdate = {"cd_update","1",CV_SAVE, NULL, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
||||
|
||||
// hour,minutes,seconds
|
||||
FUNCINLINE static ATTRINLINE char *hms(int hsg)
|
||||
{
|
||||
int hours, minutes, seconds;
|
||||
static char s[9];
|
||||
|
||||
seconds = hsg / 75;
|
||||
minutes = seconds / 60;
|
||||
seconds %= 60;
|
||||
hours = minutes / 60;
|
||||
minutes %= 60;
|
||||
if (hours>0)
|
||||
sprintf (s, "%d:%02d:%02d", hours, minutes, seconds);
|
||||
else
|
||||
sprintf (s, "%2d:%02d", minutes, seconds);
|
||||
return s;
|
||||
}
|
||||
|
||||
static void Command_Cd_f (void)
|
||||
{
|
||||
const char * s;
|
||||
int i,j;
|
||||
|
||||
if (!cdaudio_started)
|
||||
return;
|
||||
|
||||
if (COM_Argc()<2)
|
||||
{
|
||||
CONS_Printf ("cd [on] [off] [remap] [reset] [open]\n"
|
||||
" [info] [play <track>] [loop <track>]\n"
|
||||
" [stop] [resume]\n");
|
||||
return;
|
||||
}
|
||||
|
||||
s = COM_Argv(1);
|
||||
|
||||
// activate cd music
|
||||
if (!strncmp(s,"on",2))
|
||||
{
|
||||
cdEnabled = true;
|
||||
return;
|
||||
}
|
||||
|
||||
// stop/deactivate cd music
|
||||
if (!strncmp(s,"off",3))
|
||||
{
|
||||
if (cdPlaying)
|
||||
I_StopCD ();
|
||||
cdEnabled = false;
|
||||
return;
|
||||
}
|
||||
|
||||
// remap tracks
|
||||
if (!strncmp(s,"remap",5))
|
||||
{
|
||||
i = COM_Argc() - 2;
|
||||
if (i <= 0)
|
||||
{
|
||||
CONS_Printf ("CD tracks remapped in that order :\n");
|
||||
for (j = 1; j < MAX_CD_TRACKS; j++)
|
||||
if (cdRemap[j] != j)
|
||||
CONS_Printf (" %2d -> %2d\n", j, cdRemap[j]);
|
||||
return;
|
||||
}
|
||||
for (j = 1; j <= i; j++)
|
||||
cdRemap[j] = atoi (COM_Argv (j+1));
|
||||
return;
|
||||
}
|
||||
|
||||
// reset the CD driver, useful on some odd cd's
|
||||
if (!strncmp(s,"reset",5))
|
||||
{
|
||||
cdEnabled = true;
|
||||
if (cdPlaying)
|
||||
I_StopCD ();
|
||||
for (i = 0; i < MAX_CD_TRACKS; i++)
|
||||
cdRemap[i] = i;
|
||||
bcd_reset ();
|
||||
cdValid = bcd_get_audio_info ();
|
||||
return;
|
||||
}
|
||||
|
||||
// any other command is not allowed until we could retrieve cd information
|
||||
if (!cdValid)
|
||||
{
|
||||
CONS_Printf ("CD is not ready.\n");
|
||||
return;
|
||||
}
|
||||
|
||||
if (!strncmp(s,"open",4))
|
||||
{
|
||||
if (cdPlaying)
|
||||
I_StopCD ();
|
||||
bcd_open_door();
|
||||
cdValid = false;
|
||||
return;
|
||||
}
|
||||
|
||||
if (!strncmp(s,"info",4))
|
||||
{
|
||||
int totaltime = 0;
|
||||
|
||||
if (!bcd_get_audio_info())
|
||||
{
|
||||
CONS_Printf ("Error getting audio info: %s\n",bcd_error());
|
||||
cdValid = false;
|
||||
return;
|
||||
}
|
||||
|
||||
cdValid = true;
|
||||
|
||||
if (lowest_track == 0)
|
||||
CONS_Printf ("No audio tracks\n");
|
||||
else
|
||||
{
|
||||
// display list of tracks
|
||||
// highlight current playing track
|
||||
for (i=lowest_track; i <= highest_track; i++)
|
||||
{
|
||||
CONS_Printf ("%s%2d. %s %s\n",
|
||||
cdPlaying && (cdPlayTrack == i) ? "\2 " : " ",
|
||||
i, tracks[i].is_audio ? "audio" : "data ",
|
||||
hms(tracks[i].len));
|
||||
if (tracks[i].is_audio)
|
||||
totaltime += tracks[i].len;
|
||||
}
|
||||
|
||||
if (totaltime)
|
||||
CONS_Printf ("\2Total time : %s\n", hms(totaltime));
|
||||
}
|
||||
if (cdPlaying)
|
||||
{
|
||||
CONS_Printf ("%s track : %d\n", cdLooping ? "looping" : "playing",
|
||||
cdPlayTrack);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
if (!strncmp(s,"play",4))
|
||||
{
|
||||
I_PlayCD ((UINT8)atoi (COM_Argv (2)), false);
|
||||
return;
|
||||
}
|
||||
|
||||
if (!strncmp(s,"stop",4))
|
||||
{
|
||||
I_StopCD ();
|
||||
return;
|
||||
}
|
||||
|
||||
if (!strncmp(s,"loop",4))
|
||||
{
|
||||
I_PlayCD ((UINT8)atoi (COM_Argv (2)), true);
|
||||
return;
|
||||
}
|
||||
|
||||
if (!strncmp(s,"resume",4))
|
||||
{
|
||||
I_ResumeCD ();
|
||||
return;
|
||||
}
|
||||
|
||||
CONS_Printf ("cd command '%s' unknown\n", s);
|
||||
}
|
||||
|
||||
|
||||
// pause cd music
|
||||
void I_StopCD (void)
|
||||
{
|
||||
if (!cdaudio_started || !cdEnabled)
|
||||
return;
|
||||
|
||||
bcd_stop();
|
||||
|
||||
wasPlaying = cdPlaying;
|
||||
cdPlaying = false;
|
||||
}
|
||||
|
||||
// continue after a pause
|
||||
void I_ResumeCD (void)
|
||||
{
|
||||
if (!cdaudio_started || !cdEnabled)
|
||||
return;
|
||||
|
||||
if (!cdValid)
|
||||
return;
|
||||
|
||||
if (!wasPlaying)
|
||||
return;
|
||||
|
||||
bcd_resume ();
|
||||
cdPlaying = true;
|
||||
}
|
||||
|
||||
|
||||
void I_ShutdownCD (void)
|
||||
{
|
||||
int rc;
|
||||
|
||||
if (!cdaudio_started)
|
||||
return;
|
||||
|
||||
I_StopCD ();
|
||||
|
||||
rc = bcd_close ();
|
||||
if (!rc)
|
||||
CONS_Printf ("Error shuting down cd\n");
|
||||
}
|
||||
|
||||
void I_InitCD (void)
|
||||
{
|
||||
int rc;
|
||||
int i;
|
||||
|
||||
rc = bcd_open ();
|
||||
|
||||
if (rc>=0x200)
|
||||
{
|
||||
CONS_Printf ("MSCDEX version %d.%d\n", rc>>8, rc&255);
|
||||
|
||||
I_AddExitFunc (I_ShutdownCD);
|
||||
cdaudio_started = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (!rc)
|
||||
CONS_Printf ("%s\n", bcd_error() );
|
||||
|
||||
cdaudio_started = false;
|
||||
return;
|
||||
}
|
||||
|
||||
// last saved in config.cfg
|
||||
i = cd_volume.value;
|
||||
I_SetVolumeCD (0); // initialize to 0 for some odd cd drivers
|
||||
I_SetVolumeCD (i); // now set the last saved volume
|
||||
|
||||
for (i = 0; i < MAX_CD_TRACKS; i++)
|
||||
cdRemap[i] = i;
|
||||
|
||||
if (!bcd_get_audio_info())
|
||||
{
|
||||
CONS_Printf("\2CD Init: No CD in player.\n");
|
||||
cdEnabled = false;
|
||||
cdValid = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
cdEnabled = true;
|
||||
cdValid = true;
|
||||
}
|
||||
|
||||
COM_AddCommand ("cd", Command_Cd_f);
|
||||
}
|
||||
|
||||
|
||||
|
||||
// loop/go to next track when track is finished (if cd_update var is true)
|
||||
// update the volume when it has changed (from console/menu)
|
||||
/// \todo check for cd change and restart music ?
|
||||
|
||||
void I_UpdateCD (void)
|
||||
{
|
||||
int newVolume;
|
||||
int now;
|
||||
static int last; //game tics (35th of second)
|
||||
|
||||
if (!cdaudio_started)
|
||||
return;
|
||||
|
||||
now = I_GetTime ();
|
||||
if ((now - last) < 10) // about 1/4 second
|
||||
return;
|
||||
last = now;
|
||||
|
||||
// update cd volume changed at console/menu
|
||||
newVolume = cd_volume.value & 31;
|
||||
|
||||
if (cdVolume != newVolume)
|
||||
I_SetVolumeCD (newVolume);
|
||||
|
||||
// slow drivers exit here
|
||||
if (!cdUpdate.value)
|
||||
return;
|
||||
|
||||
if (cdPlaying)
|
||||
{
|
||||
if (!bcd_audio_busy())
|
||||
{
|
||||
cdPlaying = false;
|
||||
if (cdLooping)
|
||||
I_PlayCD (cdPlayTrack, true);
|
||||
else
|
||||
{
|
||||
// play the next cd track, or restart the first
|
||||
cdPlayTrack++;
|
||||
if (cdPlayTrack > highest_track)
|
||||
cdPlayTrack = lowest_track;
|
||||
while (!tracks[cdPlayTrack].is_audio && cdPlayTrack<highest_track)
|
||||
cdPlayTrack++;
|
||||
I_PlayCD (cdPlayTrack, true);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
void I_PlayCD (UINT8 track, UINT8 looping)
|
||||
{
|
||||
if (!cdaudio_started || !cdEnabled)
|
||||
return;
|
||||
|
||||
if (!cdValid)
|
||||
return;
|
||||
|
||||
track = cdRemap[track];
|
||||
|
||||
if (cdPlaying)
|
||||
{
|
||||
if (cdPlayTrack == track)
|
||||
return;
|
||||
I_StopCD ();
|
||||
}
|
||||
|
||||
if (track < lowest_track || track > highest_track)
|
||||
{
|
||||
//CONS_Printf ("\2CD Audio: wrong track number %d\n", track);
|
||||
// suppose there are not enough tracks for game levels..
|
||||
// then do a modulo so we always get something to hear
|
||||
track = (track % (highest_track-lowest_track+1)) + 1;
|
||||
//return;
|
||||
}
|
||||
|
||||
cdPlayTrack = track;
|
||||
|
||||
if (!tracks[track].is_audio)
|
||||
{
|
||||
CONS_Printf ("\2CD Play: not an audio track\n");
|
||||
return;
|
||||
}
|
||||
|
||||
cdLooping = looping;
|
||||
|
||||
if (!bcd_play_track (track))
|
||||
{
|
||||
CONS_Printf ("CD Play: could not play track %d\n", track);
|
||||
cdValid = false;
|
||||
cdPlaying = false;
|
||||
return;
|
||||
}
|
||||
|
||||
cdPlaying = true;
|
||||
|
||||
}
|
||||
|
||||
|
||||
// volume : logical cd audio volume 0-31 (hardware is 0-255)
|
||||
boolean I_SetVolumeCD (INT32 volume)
|
||||
{
|
||||
int hardvol;
|
||||
|
||||
if (!cdaudio_started || !cdEnabled)
|
||||
return false;
|
||||
|
||||
// translate to hardware volume
|
||||
volume &= 31;
|
||||
|
||||
hardvol = ((volume+1)<<3)-1; //highest volume is 255
|
||||
if (hardvol<=8)
|
||||
hardvol=0; //lowest volume is ZERO
|
||||
|
||||
cdVolume = volume;
|
||||
|
||||
if (bcd_set_volume (hardvol))
|
||||
{
|
||||
CV_SetValue (&cd_volume, volume);
|
||||
|
||||
return true;
|
||||
}
|
||||
else
|
||||
return false;
|
||||
}
|
|
@ -1,78 +0,0 @@
|
|||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
// Copyright (C) 1998-2000 by DooM Legacy Team.
|
||||
//
|
||||
// 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.
|
||||
//-----------------------------------------------------------------------------
|
||||
/// \file
|
||||
/// \brief Main program, simply calls D_SRB2Main high level loop.
|
||||
|
||||
#include "../doomdef.h"
|
||||
|
||||
#include "../m_argv.h"
|
||||
#include "../d_main.h"
|
||||
|
||||
#include "../i_system.h"
|
||||
|
||||
#ifdef REMOTE_DEBUGGING
|
||||
#include <i386-stub.h>
|
||||
#include "rdb.h"
|
||||
#endif
|
||||
|
||||
//### let's try with Allegro ###
|
||||
#define alleg_mouse_unused
|
||||
#define alleg_timer_unused
|
||||
#define ALLEGRO_NO_KEY_DEFINES
|
||||
#define alleg_keyboard_unused
|
||||
#define alleg_joystick_unused
|
||||
#define alleg_gfx_driver_unused
|
||||
#define alleg_palette_unused
|
||||
#define alleg_graphics_unused
|
||||
#define alleg_vidmem_unused
|
||||
#define alleg_flic_unused
|
||||
#define alleg_sound_unused
|
||||
#define alleg_file_unused
|
||||
#define alleg_datafile_unused
|
||||
#define alleg_math_unused
|
||||
#define alleg_gui_unused
|
||||
#include <allegro.h>
|
||||
//### end of Allegro include ###
|
||||
|
||||
int main (int argc, char **argv)
|
||||
{
|
||||
myargc = argc;
|
||||
myargv = argv;
|
||||
|
||||
{
|
||||
//added:03-01-98:
|
||||
// Setup signal handlers and other stuff BEFORE ANYTHING ELSE!
|
||||
I_StartupSystem();
|
||||
#ifdef REMOTE_DEBUGGING
|
||||
/* Only setup if remote debugging is to be done, Muhahahaha!*/
|
||||
gdb_serial_init(DEBUG_COM_PORT,DEBUG_COM_PORT_SPEED);
|
||||
gdb_target_init();
|
||||
breakpoint();
|
||||
#endif
|
||||
|
||||
D_SRB2Main();
|
||||
D_SRB2Loop();
|
||||
|
||||
}
|
||||
//added:03-01-98:
|
||||
// hmmm... it will never go here.
|
||||
|
||||
return 0;
|
||||
}
|
||||
#if ALLEGRO_VERSION == 4
|
||||
END_OF_MAIN()
|
||||
#endif
|
|
@ -1,113 +0,0 @@
|
|||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
// Portions Copyright (C) 1998-2000 by DooM Legacy Team.
|
||||
//
|
||||
// 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.
|
||||
//-----------------------------------------------------------------------------
|
||||
/// \file
|
||||
/// \brief doomcom network interface
|
||||
|
||||
|
||||
#include <netinet/in.h>
|
||||
#include <errno.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#include <go32.h>
|
||||
#include <pc.h>
|
||||
#include <dpmi.h>
|
||||
#include <dos.h>
|
||||
#include <sys/nearptr.h>
|
||||
|
||||
#include "../doomdef.h"
|
||||
|
||||
#include "../i_system.h"
|
||||
#include "../d_event.h"
|
||||
#include "../d_net.h"
|
||||
#include "../m_argv.h"
|
||||
|
||||
#include "../doomstat.h"
|
||||
#include "../z_zone.h"
|
||||
#include "../i_net.h"
|
||||
#include "../i_tcp.h"
|
||||
|
||||
//
|
||||
// NETWORKING
|
||||
//
|
||||
|
||||
typedef enum
|
||||
{
|
||||
CMD_SEND = 1,
|
||||
CMD_GET = 2,
|
||||
} command_t;
|
||||
|
||||
static void External_Driver_Get(void);
|
||||
static void External_Driver_Send(void);
|
||||
static void External_Driver_FreeNode(INT32 nodenum);
|
||||
|
||||
static inline boolean External_Driver_OpenSocket(void)
|
||||
{
|
||||
I_NetGet = External_Driver_Get;
|
||||
I_NetSend = External_Driver_Send;
|
||||
I_NetCloseSocket = NULL;
|
||||
I_NetFreeNodenum = External_Driver_FreeNode;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
//
|
||||
// I_InitNetwork
|
||||
//
|
||||
boolean I_InitNetwork (void)
|
||||
{
|
||||
int netgamepar;
|
||||
|
||||
netgamepar = M_CheckParm ("-net");
|
||||
if (!netgamepar)
|
||||
return false;
|
||||
|
||||
// externals drivers specific
|
||||
|
||||
__djgpp_nearptr_enable();
|
||||
|
||||
// set up for network
|
||||
doomcom=(doomcom_t *)(__djgpp_conventional_base+atoi(myargv[netgamepar+1]));
|
||||
CONS_Printf("I_DosNet : Using int 0x%x for communication\n",doomcom->intnum);
|
||||
|
||||
server = (doomcom->consoleplayer == 0);
|
||||
if (!server)
|
||||
COM_BufAddText("connect any\n");
|
||||
|
||||
// ipx + time + 4 (padding)
|
||||
packetheaderlength=30+4+4;
|
||||
|
||||
hardware_MAXPACKETLENGTH = 512;
|
||||
|
||||
I_NetOpenSocket = External_Driver_OpenSocket;
|
||||
return true;
|
||||
}
|
||||
|
||||
FUNCNORETURN static ATTRNORETURN void External_Driver_Get(void)
|
||||
{
|
||||
I_Error("External_Driver_Get not supported at this time");
|
||||
}
|
||||
|
||||
FUNCNORETURN static ATTRNORETURN void External_Driver_Send(void)
|
||||
{
|
||||
I_Error("External_Driver_Send not supported at this time");
|
||||
}
|
||||
|
||||
FUNCNORETURN static ATTRNORETURN void External_Driver_FreeNode(INT32 nodenum)
|
||||
{
|
||||
nodenum = 0;
|
||||
I_Error("External_Driver_FreeNode not supported at this time");
|
||||
}
|
|
@ -1,620 +0,0 @@
|
|||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
// Portions Copyright (C) 1998-2000 by DooM Legacy Team.
|
||||
//
|
||||
// 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.
|
||||
//-----------------------------------------------------------------------------
|
||||
/// \file
|
||||
/// \brief interface level code for sound
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <math.h>
|
||||
|
||||
#include "../doomdef.h"
|
||||
#include "../doomstat.h"
|
||||
#include "../i_system.h"
|
||||
#include "../i_sound.h"
|
||||
#include "../z_zone.h"
|
||||
#include "../m_argv.h"
|
||||
#include "../m_misc.h"
|
||||
#include "../w_wad.h"
|
||||
#include "../s_sound.h"
|
||||
#include "../console.h"
|
||||
|
||||
//### let's try with Allegro ###
|
||||
#define alleg_mouse_unused
|
||||
#define alleg_timer_unused
|
||||
#define ALLEGRO_NO_KEY_DEFINES
|
||||
#define alleg_keyboard_unused
|
||||
#define alleg_joystick_unused
|
||||
#define alleg_gfx_driver_unused
|
||||
#define alleg_palette_unused
|
||||
#define alleg_graphics_unused
|
||||
#define alleg_vidmem_unused
|
||||
#define alleg_flic_unused
|
||||
//#define alleg_sound_unused we use it
|
||||
#define alleg_file_unused
|
||||
#define alleg_datafile_unused
|
||||
#define alleg_math_unused
|
||||
#define alleg_gui_unused
|
||||
#include <allegro.h>
|
||||
//### end of Allegro include ###
|
||||
|
||||
//allegro has 256 virtual voices
|
||||
// warning should by a power of 2
|
||||
#define VIRTUAL_VOICES 256
|
||||
#define VOICESSHIFT 8
|
||||
|
||||
// Needed for calling the actual sound output.
|
||||
#define SAMPLECOUNT 512
|
||||
|
||||
|
||||
|
||||
//
|
||||
// this function converts raw 11khz, 8-bit data to a SAMPLE* that allegro uses
|
||||
// it is need cuz allegro only loads samples from wavs and vocs
|
||||
//added:11-01-98: now reads the frequency from the rawdata header.
|
||||
// dsdata points a 4 UINT16 header:
|
||||
// +0 : value 3 what does it mean?
|
||||
// +2 : sample rate, either 11025 or 22050.
|
||||
// +4 : number of samples, each sample is a single byte since it's 8bit
|
||||
// +6 : value 0
|
||||
static inline SAMPLE *raw2SAMPLE(UINT8 *dsdata, size_t len)
|
||||
{
|
||||
SAMPLE *spl;
|
||||
|
||||
spl=Z_Malloc(sizeof (SAMPLE),PU_SOUND,NULL);
|
||||
if (spl==NULL)
|
||||
I_Error("Raw2Sample : no more free mem");
|
||||
spl->bits = 8;
|
||||
spl->stereo = 0;
|
||||
spl->freq = *((UINT16 *)dsdata+1); //mostly 11025, but some at 22050.
|
||||
spl->len = len-8;
|
||||
spl->priority = 255; //priority;
|
||||
spl->loop_start = 0;
|
||||
spl->loop_end = len-8;
|
||||
spl->param = -1;
|
||||
spl->data=(void *)(dsdata+8); //skip the 8bytes header
|
||||
|
||||
return spl;
|
||||
}
|
||||
|
||||
|
||||
// This function loads the sound data from the WAD lump,
|
||||
// for single sound.
|
||||
//
|
||||
void *I_GetSfx (sfxinfo_t * sfx)
|
||||
{
|
||||
UINT8 *dssfx;
|
||||
|
||||
if (sfx->lumpnum == LUMPERROR)
|
||||
sfx->lumpnum = S_GetSfxLumpNum (sfx);
|
||||
|
||||
sfx->length = W_LumpLength (sfx->lumpnum);
|
||||
|
||||
dssfx = (UINT8 *) W_CacheLumpNum (sfx->lumpnum, PU_SOUND);
|
||||
//_go32_dpmi_lock_data(dssfx,size);
|
||||
|
||||
// convert raw data and header from Doom sfx to a SAMPLE for Allegro
|
||||
return (void *)raw2SAMPLE (dssfx, sfx->length);
|
||||
}
|
||||
|
||||
|
||||
void I_FreeSfx (sfxinfo_t *sfx)
|
||||
{
|
||||
if (sfx->lumpnum == LUMPERROR)
|
||||
return;
|
||||
|
||||
// free sample data
|
||||
if ( sfx->data )
|
||||
Z_Free((UINT8 *) ((SAMPLE *)sfx->data)->data - 8);
|
||||
Z_Free(sfx->data); // Allegro SAMPLE structure
|
||||
sfx->data = NULL;
|
||||
sfx->lumpnum = LUMPERROR;
|
||||
}
|
||||
|
||||
FUNCINLINE static ATTRINLINE int Volset(int vol)
|
||||
{
|
||||
return (vol*255/31);
|
||||
}
|
||||
|
||||
|
||||
void I_SetSfxVolume(INT32 volume)
|
||||
{
|
||||
if (sound_disabled)
|
||||
return;
|
||||
|
||||
set_volume (Volset(volume),-1);
|
||||
}
|
||||
|
||||
//
|
||||
// Starting a sound means adding it
|
||||
// to the current list of active sounds
|
||||
// in the internal channels.
|
||||
// As the SFX info struct contains
|
||||
// e.g. a pointer to the raw data,
|
||||
// it is ignored.
|
||||
// As our sound handling does not handle
|
||||
// priority, it is ignored.
|
||||
// Pitching (that is, increased speed of playback)
|
||||
// is set, but currently not used by mixing.
|
||||
//
|
||||
INT32 I_StartSound ( sfxenum_t id,
|
||||
INT32 vol,
|
||||
INT32 sep,
|
||||
INT32 pitch,
|
||||
INT32 priority,
|
||||
INT32 channel)
|
||||
{
|
||||
int voice;
|
||||
(void)channel;
|
||||
|
||||
if (sound_disabled)
|
||||
return 0;
|
||||
|
||||
// UNUSED
|
||||
priority = 0;
|
||||
|
||||
pitch = (pitch-128)/2+128;
|
||||
voice = play_sample(S_sfx[id].data,vol,sep,(pitch*1000)/128,0);
|
||||
|
||||
// Returns a handle
|
||||
return (id<<VOICESSHIFT)+voice;
|
||||
}
|
||||
|
||||
void I_StopSound (INT32 handle)
|
||||
{
|
||||
// You need the handle returned by StartSound.
|
||||
// Would be looping all channels,
|
||||
// tracking down the handle,
|
||||
// an setting the channel to zero.
|
||||
int voice=handle & (VIRTUAL_VOICES-1);
|
||||
|
||||
if (sound_disabled)
|
||||
return;
|
||||
|
||||
if (voice_check(voice)==S_sfx[handle>>VOICESSHIFT].data)
|
||||
deallocate_voice(voice);
|
||||
}
|
||||
|
||||
INT32 I_SoundIsPlaying(INT32 handle)
|
||||
{
|
||||
if (sound_disabled)
|
||||
return FALSE;
|
||||
|
||||
if (voice_check(handle & (VIRTUAL_VOICES-1))==S_sfx[handle>>VOICESSHIFT].data)
|
||||
return TRUE;
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
// cut and past from ALLEGRO he don't share it :(
|
||||
static inline int absolute_freq(int freq, SAMPLE *spl)
|
||||
{
|
||||
if (freq == 1000)
|
||||
return spl->freq;
|
||||
else
|
||||
return (spl->freq * freq) / 1000;
|
||||
}
|
||||
|
||||
void I_UpdateSoundParams( INT32 handle,
|
||||
INT32 vol,
|
||||
INT32 sep,
|
||||
INT32 pitch)
|
||||
{
|
||||
// I fail too see that this is used.
|
||||
// Would be using the handle to identify
|
||||
// on which channel the sound might be active,
|
||||
// and resetting the channel parameters.
|
||||
int voice=handle & (VIRTUAL_VOICES-1);
|
||||
int numsfx=handle>>VOICESSHIFT;
|
||||
|
||||
if (sound_disabled)
|
||||
return;
|
||||
|
||||
if (voice_check(voice)==S_sfx[numsfx].data)
|
||||
{
|
||||
voice_set_volume(voice, vol);
|
||||
voice_set_pan(voice, sep);
|
||||
voice_set_frequency(voice, absolute_freq(pitch*1000/128,
|
||||
S_sfx[numsfx].data));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void I_ShutdownSound(void)
|
||||
{
|
||||
// Wait till all pending sounds are finished.
|
||||
|
||||
//added:03-01-98:
|
||||
if ( !sound_started )
|
||||
return;
|
||||
|
||||
//added:08-01-98: remove_sound() explicitly because we don't use
|
||||
// Allegro's allegro_exit();
|
||||
remove_sound();
|
||||
sound_started = false;
|
||||
}
|
||||
|
||||
static char soundheader[] = "sound";
|
||||
#if ALLEGRO_VERSION == 3
|
||||
static char soundvar[] = "sb_freq";
|
||||
#else
|
||||
static char soundvar[] = "sound_freq";
|
||||
#endif
|
||||
|
||||
void I_StartupSound(void)
|
||||
{
|
||||
int sfxcard,midicard;
|
||||
#if ALLEGRO_VERSION == 3
|
||||
char err[255];
|
||||
#endif
|
||||
|
||||
if (sound_disabled)
|
||||
sfxcard=DIGI_NONE;
|
||||
else
|
||||
sfxcard=DIGI_AUTODETECT;
|
||||
|
||||
if (midi_disabled)
|
||||
midicard=MIDI_NONE;
|
||||
else
|
||||
midicard=MIDI_AUTODETECT; //DetectMusicCard();
|
||||
|
||||
digital_disabled=true; //Alam: No OGG/MP3/IT/MOD support
|
||||
|
||||
// Secure and configure sound device first.
|
||||
CONS_Printf("I_StartupSound: ");
|
||||
|
||||
//Fab:25-04-98:note:install_sound will check for sound settings
|
||||
// in the sound.cfg or allegro.cfg, in the current directory,
|
||||
// or the directory pointed by 'ALLEGRO' env var.
|
||||
#if ALLEGRO_VERSION == 3
|
||||
if (install_sound(sfxcard,midicard,NULL)!=0)
|
||||
{
|
||||
sprintf (err,"Sound init error : %s\n",allegro_error);
|
||||
CONS_Error (err);
|
||||
sound_disabled=true;
|
||||
midi_disabled=true;
|
||||
}
|
||||
else
|
||||
{
|
||||
CONS_Printf(" configured audio device\n" );
|
||||
}
|
||||
|
||||
//added:08-01-98:we use a similar startup/shutdown scheme as Allegro.
|
||||
I_AddExitFunc(I_ShutdownSound);
|
||||
#endif
|
||||
sound_started = true;
|
||||
CV_SetValue(&cv_samplerate,get_config_int(soundheader,soundvar,cv_samplerate.value));
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
//
|
||||
// MUSIC API.
|
||||
// Still no music done.
|
||||
// Remains. Dummies.
|
||||
//
|
||||
|
||||
static MIDI* currsong; //im assuming only 1 song will be played at once
|
||||
static int islooping=0;
|
||||
static int musicdies=-1;
|
||||
UINT8 music_started=0;
|
||||
boolean songpaused=false;
|
||||
|
||||
/// ------------------------
|
||||
// MUSIC SYSTEM
|
||||
/// ------------------------
|
||||
|
||||
/* load_midi_mem:
|
||||
* Loads a standard MIDI file from memory, returning a pointer to
|
||||
* a MIDI structure, * or NULL on error.
|
||||
* It is the load_midi from Allegro modified to load it from memory
|
||||
*/
|
||||
static MIDI *load_midi_mem(char *mempointer,int *e)
|
||||
{
|
||||
int c = *e;
|
||||
long data=0;
|
||||
unsigned char *fp;
|
||||
MIDI *midi;
|
||||
int num_tracks=0;
|
||||
|
||||
fp = (void *)mempointer;
|
||||
if (!fp)
|
||||
return NULL;
|
||||
|
||||
midi = malloc(sizeof (MIDI)); /* get some memory */
|
||||
if (!midi)
|
||||
return NULL;
|
||||
|
||||
for (c=0; c<MIDI_TRACKS; c++)
|
||||
{
|
||||
midi->track[c].data = NULL;
|
||||
midi->track[c].len = 0;
|
||||
}
|
||||
|
||||
fp+=4+4; // header size + 'chunk' size
|
||||
|
||||
swab(fp,&data,2); // convert to intel-endian
|
||||
fp+=2; /* MIDI file type */
|
||||
if ((data != 0) && (data != 1)) // only type 0 and 1 are suported
|
||||
return NULL;
|
||||
|
||||
swab(fp,&num_tracks,2); /* number of tracks */
|
||||
fp+=2;
|
||||
if ((num_tracks < 1) || (num_tracks > MIDI_TRACKS))
|
||||
return NULL;
|
||||
|
||||
swab(fp,&data,2); /* beat divisions */
|
||||
fp+=2;
|
||||
midi->divisions = ABS(data);
|
||||
|
||||
for (c=0; c<num_tracks; c++)
|
||||
{ /* read each track */
|
||||
if (memcmp(fp, "MTrk", 4))
|
||||
return NULL;
|
||||
fp+=4;
|
||||
|
||||
//swab(fp,&data,4); don't work !!!!??
|
||||
((char *)&data)[0]=fp[3];
|
||||
((char *)&data)[1]=fp[2];
|
||||
((char *)&data)[2]=fp[1];
|
||||
((char *)&data)[3]=fp[0];
|
||||
fp+=4;
|
||||
|
||||
midi->track[c].len = data;
|
||||
|
||||
midi->track[c].data = fp;
|
||||
fp+=data;
|
||||
}
|
||||
|
||||
lock_midi(midi);
|
||||
return midi;
|
||||
}
|
||||
|
||||
void I_InitMusic(void)
|
||||
{
|
||||
if (midi_disabled)
|
||||
return;
|
||||
|
||||
I_AddExitFunc(I_ShutdownMusic);
|
||||
music_started = true;
|
||||
songpaused = false;
|
||||
}
|
||||
|
||||
void I_ShutdownMusic(void)
|
||||
{
|
||||
if ( !music_started )
|
||||
return;
|
||||
|
||||
I_StopSong();
|
||||
|
||||
music_started=false;
|
||||
}
|
||||
|
||||
/// ------------------------
|
||||
// MUSIC PROPERTIES
|
||||
/// ------------------------
|
||||
|
||||
musictype_t I_SongType(void)
|
||||
{
|
||||
if (currsong)
|
||||
return MU_MID;
|
||||
else
|
||||
return MU_NONE;
|
||||
}
|
||||
|
||||
boolean I_SongPlaying()
|
||||
{
|
||||
return (boolean)currsong;
|
||||
}
|
||||
|
||||
boolean I_SongPaused()
|
||||
{
|
||||
return songpaused;
|
||||
}
|
||||
|
||||
/// ------------------------
|
||||
// MUSIC EFFECTS
|
||||
/// ------------------------
|
||||
|
||||
boolean I_SetSongSpeed(float speed)
|
||||
{
|
||||
(void)speed;
|
||||
return false;
|
||||
}
|
||||
|
||||
/// ------------------------
|
||||
// MUSIC SEEKING
|
||||
/// ------------------------
|
||||
|
||||
UINT32 I_GetSongLength(void)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
boolean I_SetSongLoopPoint(UINT32 looppoint)
|
||||
{
|
||||
(void)looppoint;
|
||||
return false;
|
||||
}
|
||||
|
||||
UINT32 I_GetSongLoopPoint(void)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
boolean I_SetSongPosition(UINT32 position)
|
||||
{
|
||||
(void)position;
|
||||
return false;
|
||||
}
|
||||
|
||||
UINT32 I_GetSongPosition(void)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
/// ------------------------
|
||||
// MUSIC PLAYBACK
|
||||
/// ------------------------
|
||||
|
||||
boolean I_LoadSong(char *data, size_t len)
|
||||
{
|
||||
int e = len; //Alam: For error
|
||||
if (midi_disabled)
|
||||
return 0;
|
||||
|
||||
if (memcmp(data,"MThd",4)==0) // support mid file in WAD !!!
|
||||
{
|
||||
currsong=load_midi_mem(data,&e);
|
||||
}
|
||||
else
|
||||
{
|
||||
CONS_Printf("Music Lump is not a MIDI lump\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (currsong==NULL)
|
||||
{
|
||||
CONS_Printf("Not a valid mid file : %d\n",e);
|
||||
return 0;
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
void I_UnloadSong(void)
|
||||
{
|
||||
handle = 0;
|
||||
if (midi_disabled)
|
||||
return;
|
||||
|
||||
//destroy_midi(currsong);
|
||||
}
|
||||
|
||||
boolean I_PlaySong(boolean looping)
|
||||
{
|
||||
handle = 0;
|
||||
if (midi_disabled)
|
||||
return false;
|
||||
|
||||
islooping = looping;
|
||||
musicdies = gametic + NEWTICRATE*30;
|
||||
if (play_midi(currsong,looping)==0)
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
void I_StopSong(void)
|
||||
{
|
||||
handle = 0;
|
||||
if (midi_disabled)
|
||||
return;
|
||||
|
||||
islooping = 0;
|
||||
musicdies = 0;
|
||||
stop_midi();
|
||||
songpaused = false;
|
||||
}
|
||||
|
||||
void I_PauseSong (INT32 handle)
|
||||
{
|
||||
handle = 0;
|
||||
if (midi_disabled)
|
||||
return;
|
||||
midi_pause();
|
||||
songpaused = true;
|
||||
}
|
||||
|
||||
void I_ResumeSong (INT32 handle)
|
||||
{
|
||||
handle = 0;
|
||||
if (midi_disabled)
|
||||
return;
|
||||
midi_resume();
|
||||
songpaused = false;
|
||||
}
|
||||
|
||||
|
||||
void I_SetMusicVolume(INT32 volume)
|
||||
{
|
||||
if (midi_disabled)
|
||||
return;
|
||||
|
||||
// Now set volume on output device.
|
||||
set_volume (-1, Volset(volume));
|
||||
}
|
||||
|
||||
boolean I_SetSongTrack(INT32 track)
|
||||
{
|
||||
(void)track;
|
||||
return false;
|
||||
}
|
||||
|
||||
// Is the song playing?
|
||||
#if 0
|
||||
int I_QrySongPlaying(int handle)
|
||||
{
|
||||
if (midi_disabled)
|
||||
return 0;
|
||||
|
||||
//return islooping || musicdies > gametic;
|
||||
return (midi_pos==-1);
|
||||
}
|
||||
#endif
|
||||
|
||||
/// ------------------------
|
||||
// MUSIC FADING
|
||||
/// ------------------------
|
||||
|
||||
void I_SetInternalMusicVolume(UINT8 volume)
|
||||
{
|
||||
(void)volume;
|
||||
}
|
||||
|
||||
void I_StopFadingSong(void)
|
||||
{
|
||||
}
|
||||
|
||||
boolean I_FadeSongFromVolume(UINT8 target_volume, UINT8 source_volume, UINT32 ms, void (*callback)(void));
|
||||
{
|
||||
(void)target_volume;
|
||||
(void)source_volume;
|
||||
(void)ms;
|
||||
return false;
|
||||
}
|
||||
|
||||
boolean I_FadeSong(UINT8 target_volume, UINT32 ms, void (*callback)(void));
|
||||
{
|
||||
(void)target_volume;
|
||||
(void)ms;
|
||||
return false;
|
||||
}
|
||||
|
||||
boolean I_FadeOutStopSong(UINT32 ms)
|
||||
{
|
||||
(void)ms;
|
||||
return false;
|
||||
}
|
||||
|
||||
boolean I_FadeInPlaySong(UINT32 ms, boolean looping)
|
||||
{
|
||||
(void)ms;
|
||||
(void)looping;
|
||||
return false;
|
||||
}
|
File diff suppressed because it is too large
Load diff
|
@ -1,345 +0,0 @@
|
|||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
// Portions Copyright (C) 1998-2000 by DooM Legacy Team.
|
||||
//
|
||||
// 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.
|
||||
//-----------------------------------------------------------------------------
|
||||
/// \file
|
||||
/// \brief hardware and software level, screen and video i/o, refresh,
|
||||
/// setup ... a big mess. Got to clean that up!
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <unistd.h>
|
||||
#include <stdarg.h>
|
||||
#include <sys/time.h>
|
||||
#include <sys/types.h>
|
||||
//#include <sys/socket.h>
|
||||
|
||||
#include <netinet/in.h>
|
||||
//#include <errnos.h>
|
||||
#include <signal.h>
|
||||
|
||||
#include <go32.h>
|
||||
#include <pc.h>
|
||||
#include <dpmi.h>
|
||||
#include <dos.h>
|
||||
#include <sys/nearptr.h>
|
||||
|
||||
#include "../doomdef.h"
|
||||
#include "../i_system.h"
|
||||
#include "../v_video.h"
|
||||
#include "../m_argv.h"
|
||||
#include "vid_vesa.h"
|
||||
#include "../i_video.h"
|
||||
|
||||
|
||||
//dosstuff -newly added
|
||||
static unsigned long dascreen;
|
||||
static int gfx_use_vesa1;
|
||||
|
||||
boolean highcolor;
|
||||
|
||||
#define SCREENDEPTH 1 // bytes per pixel, do NOT change.
|
||||
|
||||
rendermode_t rendermode=render_soft;
|
||||
|
||||
//
|
||||
// I_OsPolling
|
||||
//
|
||||
void I_OsPolling(void)
|
||||
{
|
||||
I_GetEvent();
|
||||
//i dont think i have to do anything else here
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// I_UpdateNoBlit
|
||||
//
|
||||
void I_UpdateNoBlit (void)
|
||||
{
|
||||
// what is this?
|
||||
}
|
||||
|
||||
|
||||
//profile stuff ---------------------------------------------------------
|
||||
//added:16-01-98:wanted to profile the VID_BlitLinearScreen() asm code.
|
||||
//#define TIMING //uncomment this to enable profiling
|
||||
#ifdef TIMING
|
||||
#include "../p5prof.h"
|
||||
static INT64 mycount;
|
||||
static INT64 mytotal = 0;
|
||||
static unsigned long nombre = NEWTICRATE*10;
|
||||
//static char runtest[10][80];
|
||||
#endif
|
||||
//profile stuff ---------------------------------------------------------
|
||||
|
||||
//
|
||||
// I_FinishUpdate
|
||||
//
|
||||
static void I_BlitScreenVesa1(void); //see later
|
||||
void I_FinishUpdate (void)
|
||||
{
|
||||
if (marathonmode)
|
||||
SCR_DisplayMarathonInfo();
|
||||
|
||||
// draw captions if enabled
|
||||
if (cv_closedcaptioning.value)
|
||||
SCR_ClosedCaptions();
|
||||
|
||||
// draw FPS if enabled
|
||||
if (cv_ticrate.value)
|
||||
SCR_DisplayTicRate();
|
||||
|
||||
if (cv_showping.value && netgame && consoleplayer != serverplayer)
|
||||
SCR_DisplayLocalPing();
|
||||
|
||||
//blast it to the screen
|
||||
// this code sucks
|
||||
//memcpy(dascreen,screens[0],screenwidth*screenheight);
|
||||
|
||||
//added:03-01-98: I tried to I_WaitVBL(1) here, but it slows down
|
||||
// the game when the view becomes complicated, it looses ticks
|
||||
if (cv_vidwait.value)
|
||||
I_WaitVBL(1);
|
||||
|
||||
|
||||
//added:16-01-98:profile screen blit.
|
||||
#ifdef TIMING
|
||||
ProfZeroTimer();
|
||||
#endif
|
||||
//added:08-01-98: support vesa1 bank change, without Allegro's BITMAP screen.
|
||||
if ( gfx_use_vesa1 )
|
||||
{
|
||||
I_Error("Banked screen update not finished for dynamic res\n");
|
||||
I_BlitScreenVesa1(); //blast virtual to physical screen.
|
||||
}
|
||||
else
|
||||
{
|
||||
//added:16-01-98:use quickie asm routine, last 2 args are
|
||||
// src and dest rowbytes
|
||||
// (memcpy is as fast as this one...)
|
||||
VID_BlitLinearScreen(screens[0], vid.direct,
|
||||
vid.width*vid.bpp, vid.height,
|
||||
vid.width*vid.bpp, vid.rowbytes );
|
||||
}
|
||||
#ifdef TIMING
|
||||
RDMSR(0x10,&mycount);
|
||||
mytotal += mycount; //64bit add
|
||||
|
||||
if (nombre--==0)
|
||||
I_Error("ScreenBlit CPU Spy reports: 0x%d %d\n", *((int *)&mytotal+1),
|
||||
(int)mytotal );
|
||||
#endif
|
||||
|
||||
}
|
||||
|
||||
//
|
||||
// I_UpdateNoVsync
|
||||
//
|
||||
void I_UpdateNoVsync(void)
|
||||
{
|
||||
int real_vidwait = cv_vidwait.value;
|
||||
cv_vidwait.value = 0;
|
||||
I_FinishUpdate();
|
||||
cv_vidwait.value = real_vidwait;
|
||||
}
|
||||
|
||||
//
|
||||
// I_ReadScreen
|
||||
//
|
||||
void I_ReadScreen (UINT8 *scr)
|
||||
{
|
||||
VID_BlitLinearScreen(screens[0], scr,
|
||||
vid.width*vid.bpp, vid.height,
|
||||
vid.width*vid.bpp, vid.rowbytes );
|
||||
}
|
||||
|
||||
|
||||
void I_SetPalette (RGBA_t *palette)
|
||||
{
|
||||
int i;
|
||||
|
||||
outportb(0x3c8,0);
|
||||
for (i=0;i<256;i++,palette++)
|
||||
{
|
||||
outportb(0x3c9,palette->s.red>>2);
|
||||
outportb(0x3c9,palette->s.green>>2);
|
||||
outportb(0x3c9,palette->s.blue>>2);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//added 29-12-1997
|
||||
/*==========================================================================*/
|
||||
// I_BlastScreen : copy the virtual screen buffer to the physical screen mem
|
||||
// using bank switching if needed.
|
||||
/*==========================================================================*/
|
||||
static void I_BlitScreenVesa1(void)
|
||||
{
|
||||
#define VIDBANKSIZE (1<<16)
|
||||
#define VIDBANKSIZEMASK (VIDBANKSIZE-1) // defines ahoy!
|
||||
|
||||
__dpmi_regs r;
|
||||
UINT8 *p_src;
|
||||
long i;
|
||||
long virtualsize;
|
||||
|
||||
// virtual screen buffer size
|
||||
virtualsize = vid.rowbytes * vid.height * SCREENDEPTH;
|
||||
|
||||
p_src = screens[0];
|
||||
|
||||
for (i=0; virtualsize > 0; i++ )
|
||||
{
|
||||
r.x.ax = 0x4f05;
|
||||
r.x.bx = 0x0;
|
||||
r.x.cx = 0x0;
|
||||
r.x.dx = i;
|
||||
__dpmi_int(0x10,&r); //set bank
|
||||
|
||||
M_Memcpy((UINT8 *)dascreen,p_src,(virtualsize < VIDBANKSIZE) ? virtualsize : VIDBANKSIZE );
|
||||
|
||||
p_src += VIDBANKSIZE;
|
||||
virtualsize -= VIDBANKSIZE;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
//added:08-01-98: now we use Allegro's set_gfx_mode, but we want to
|
||||
// restore the exact text mode that was before.
|
||||
static INT16 myOldVideoMode;
|
||||
static inline void I_SaveOldVideoMode(void)
|
||||
{
|
||||
__dpmi_regs r;
|
||||
r.x.ax = 0x4f03; // Return current video mode
|
||||
__dpmi_int(0x10,&r);
|
||||
if ( r.x.ax != 0x4f )
|
||||
myOldVideoMode = -1;
|
||||
else
|
||||
myOldVideoMode = r.x.bx;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// Close the screen, restore previous video mode.
|
||||
//
|
||||
void I_ShutdownGraphics (void)
|
||||
{
|
||||
__dpmi_regs r;
|
||||
|
||||
rendermode = render_none;
|
||||
if ( !graphics_started )
|
||||
return;
|
||||
|
||||
// free the last video mode screen buffers
|
||||
if (vid.buffer)
|
||||
free (vid.buffer);
|
||||
|
||||
/* Restore old video mode */
|
||||
if (myOldVideoMode!=-1)
|
||||
{
|
||||
/* Restore old video mode */
|
||||
r.x.ax = 0x4f02; // Set Super VGA video mode
|
||||
r.x.bx = myOldVideoMode;
|
||||
__dpmi_int(0x10,&r);
|
||||
|
||||
// Boris: my s3 don't do a cls because "win95" :<
|
||||
clrscr();
|
||||
}
|
||||
else // no vesa put the normal video mode
|
||||
{
|
||||
r.x.ax = 0x03;
|
||||
__dpmi_int(0x10,&r);
|
||||
}
|
||||
|
||||
graphics_started = false;
|
||||
}
|
||||
|
||||
|
||||
//added:08-01-98:
|
||||
// Set VESA1 video mode, coz Allegro set_gfx_mode a larger screenwidth...
|
||||
//
|
||||
#if 0
|
||||
int set_vesa1_mode( int width, int height )
|
||||
{
|
||||
__dpmi_regs r;
|
||||
|
||||
// setup video mode.
|
||||
r.x.ax = 0x4f02;
|
||||
if ( ( width==320 )&&( height==200 ) && ( SCREENDEPTH==1 ) )
|
||||
r.x.bx = 0x13; // 320x 200x1 (256 colors)
|
||||
else
|
||||
if ( ( width==320 )&&( height==240 ) && ( SCREENDEPTH==1 ) )
|
||||
r.x.bx = 0x154; // 320x 240x1 (256 colors)
|
||||
else
|
||||
if ( ( width==320 )&&( height==400 ) && ( SCREENDEPTH==1 ) )
|
||||
r.x.bx = 0x155; // 320x 400x1 (256 colors)
|
||||
else
|
||||
if ( ( width==640 )&&( height==400 ) && ( SCREENDEPTH==1 ) )
|
||||
r.x.bx = 0x100; // 640x 400x1 (256 colors)
|
||||
else
|
||||
if ( ( width==640 )&&( height==480 ) && ( SCREENDEPTH==1 ) )
|
||||
r.x.bx = 0x101; // 640x 480x1 (256 colors)
|
||||
else
|
||||
if ( ( width==800 )&&( height==600 ) && ( SCREENDEPTH==1 ) )
|
||||
r.x.bx = 0x103; // 800x 600x1 (256 colors)
|
||||
else
|
||||
if ( ( width==1024)&&( height==768 ) && ( SCREENDEPTH==1 ) )
|
||||
r.x.bx = 0x105; //1024x 768x1 (256 colors)
|
||||
else
|
||||
I_Error("I_SetVesa1Mode: video mode not supported.");
|
||||
|
||||
// enter graphics mode.
|
||||
__dpmi_int(0x10,&r);
|
||||
|
||||
if ( r.x.ax != 0x4f )
|
||||
I_Error("I_SetVesa1Mode: init video mode failed !");
|
||||
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
//added:08-01-98: now uses Allegro to setup Linear Frame Buffer video modes.
|
||||
//
|
||||
// Initialize video mode, setup dynamic screen size variables,
|
||||
// and allocate screens.
|
||||
//
|
||||
void I_StartupGraphics(void)
|
||||
{
|
||||
//added:26-01-98: VID_Init() must be done only once,
|
||||
// use VID_SetMode() to change vid mode while in the game.
|
||||
if ( graphics_started )
|
||||
return;
|
||||
|
||||
// remember the exact screen mode we were...
|
||||
I_SaveOldVideoMode();
|
||||
|
||||
CONS_Printf("Vid_Init...");
|
||||
|
||||
// 0 for 256 color, else use highcolor modes
|
||||
highcolor = M_CheckParm ("-highcolor");
|
||||
|
||||
VID_Init();
|
||||
|
||||
//gfx_use_vesa1 = false;
|
||||
|
||||
//added:03-01-98: register exit code for graphics
|
||||
I_AddExitFunc(I_ShutdownGraphics);
|
||||
graphics_started = true;
|
||||
|
||||
}
|
||||
|
||||
void VID_StartupOpenGL(void) {}
|
|
@ -1,773 +0,0 @@
|
|||
/* ______ ___ ___
|
||||
* /\ _ \ /\_ \ /\_ \
|
||||
* \ \ \L\ \\//\ \ \//\ \ __ __ _ __ ___
|
||||
* \ \ __ \ \ \ \ \ \ \ /'__`\ /'_ `\/\`'__\/ __`\
|
||||
* \ \ \/\ \ \_\ \_ \_\ \_/\ __//\ \L\ \ \ \//\ \L\ \
|
||||
* \ \_\ \_\/\____\/\____\ \____\ \____ \ \_\\ \____/
|
||||
* \/_/\/_/\/____/\/____/\/____/\/___L\ \/_/ \/___/
|
||||
* /\____/
|
||||
* \_/__/
|
||||
*
|
||||
* Some definitions for internal use by the library code.
|
||||
* This should not be included by user programs.
|
||||
*
|
||||
* By Shawn Hargreaves.
|
||||
*
|
||||
* See readme.txt for copyright information.
|
||||
*/
|
||||
|
||||
|
||||
#ifndef INTERNAL_H
|
||||
#define INTERNAL_H
|
||||
|
||||
#include "allegro.h"
|
||||
|
||||
/* ______ ___ ___
|
||||
* /\ _ \ /\_ \ /\_ \
|
||||
* \ \ \L\ \\//\ \ \//\ \ __ __ _ __ ___
|
||||
* \ \ __ \ \ \ \ \ \ \ /'__`\ /'_ `\/\`'__\/ __`\
|
||||
* \ \ \/\ \ \_\ \_ \_\ \_/\ __//\ \L\ \ \ \//\ \L\ \
|
||||
* \ \_\ \_\/\____\/\____\ \____\ \____ \ \_\\ \____/
|
||||
* \/_/\/_/\/____/\/____/\/____/\/___L\ \/_/ \/___/
|
||||
* /\____/
|
||||
* \_/__/
|
||||
*
|
||||
* Some definitions for internal use by the library code.
|
||||
* This should not be included by user programs.
|
||||
*
|
||||
* By Shawn Hargreaves.
|
||||
*
|
||||
* See readme.txt for copyright information.
|
||||
*/
|
||||
|
||||
|
||||
#ifndef INTERNDJ_H
|
||||
#define INTERNDJ_H
|
||||
|
||||
#ifndef DJGPP
|
||||
#error This file should only be used by the djgpp version of Allegro
|
||||
#endif
|
||||
|
||||
|
||||
#include <dos.h>
|
||||
|
||||
|
||||
/* file access macros */
|
||||
#define FILE_OPEN(filename, handle) handle = open(filename, O_RDONLY | O_BINARY, S_IRUSR | S_IWUSR)
|
||||
#define FILE_CREATE(filename, handle) handle = open(filename, O_WRONLY | O_BINARY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR)
|
||||
#define FILE_CLOSE(handle) close(handle)
|
||||
#define FILE_READ(handle, buf, size, sz) sz = read(handle, buf, size)
|
||||
#define FILE_WRITE(handle, buf, size, sz) sz = write(handle, buf, size)
|
||||
#define FILE_SEARCH_STRUCT struct ffblk
|
||||
#define FILE_FINDFIRST(filename, attrib, dta) findfirst(filename, dta, attrib)
|
||||
#define FILE_FINDNEXT(dta) findnext(dta)
|
||||
#define FILE_ATTRIB ff_attrib
|
||||
#define FILE_SIZE ff_fsize
|
||||
#define FILE_NAME ff_name
|
||||
#define FILE_TIME ff_ftime
|
||||
#define FILE_DATE ff_fdate
|
||||
|
||||
|
||||
/* macros to enable and disable interrupts */
|
||||
#define DISABLE() asm volatile ("cli")
|
||||
#define ENABLE() asm volatile ("sti")
|
||||
|
||||
|
||||
__INLINE__ void enter_critical(void)
|
||||
{
|
||||
if (windows_version >= 3) {
|
||||
__dpmi_regs r;
|
||||
r.x.ax = 0x1681;
|
||||
__dpmi_int(0x2F, &r);
|
||||
}
|
||||
|
||||
DISABLE();
|
||||
}
|
||||
|
||||
|
||||
__INLINE__ void exit_critical(void)
|
||||
{
|
||||
if (windows_version >= 3) {
|
||||
__dpmi_regs r;
|
||||
r.x.ax = 0x1682;
|
||||
__dpmi_int(0x2F, &r);
|
||||
}
|
||||
|
||||
ENABLE();
|
||||
}
|
||||
|
||||
|
||||
/* interrupt hander stuff */
|
||||
#define _map_irq(irq) (((irq)>7) ? ((irq)+104) : ((irq)+8))
|
||||
|
||||
int _install_irq(int num, int (*handler)(void));
|
||||
void _remove_irq(int num);
|
||||
void _restore_irq(int irq);
|
||||
void _enable_irq(int irq);
|
||||
void _disable_irq(int irq);
|
||||
|
||||
#define _eoi(irq) { outportb(0x20, 0x20); if ((irq)>7) outportb(0xA0, 0x20); }
|
||||
|
||||
typedef struct _IRQ_HANDLER
|
||||
{
|
||||
int (*handler)(void); /* our C handler */
|
||||
int number; /* irq number */
|
||||
__dpmi_paddr old_vector; /* original protected mode vector */
|
||||
} _IRQ_HANDLER;
|
||||
|
||||
|
||||
/* DPMI memory mapping routines */
|
||||
int _create_physical_mapping(unsigned long *linear, int *segment, unsigned long physaddr, int size);
|
||||
void _remove_physical_mapping(unsigned long *linear, int *segment);
|
||||
int _create_linear_mapping(unsigned long *linear, unsigned long physaddr, int size);
|
||||
void _remove_linear_mapping(unsigned long *linear);
|
||||
int _create_selector(int *segment, unsigned long linear, int size);
|
||||
void _remove_selector(int *segment);
|
||||
void _unlock_dpmi_data(void *addr, int size);
|
||||
|
||||
|
||||
/* bank switching routines */
|
||||
void _accel_bank_stub(void);
|
||||
void _accel_bank_stub_end(void);
|
||||
|
||||
void _accel_bank_switch (void);
|
||||
void _accel_bank_switch_end(void);
|
||||
|
||||
void _vesa_window_1(void);
|
||||
void _vesa_window_1_end(void);
|
||||
void _vesa_window_2(void);
|
||||
void _vesa_window_2_end(void);
|
||||
|
||||
void _vesa_pm_window_1(void);
|
||||
void _vesa_pm_window_1_end(void);
|
||||
void _vesa_pm_window_2(void);
|
||||
void _vesa_pm_window_2_end(void);
|
||||
|
||||
void _vesa_pm_es_window_1(void);
|
||||
void _vesa_pm_es_window_1_end(void);
|
||||
void _vesa_pm_es_window_2(void);
|
||||
void _vesa_pm_es_window_2_end(void);
|
||||
|
||||
|
||||
/* stuff for the VESA and VBE/AF drivers */
|
||||
extern __dpmi_regs _dpmi_reg;
|
||||
|
||||
extern int _window_2_offset;
|
||||
|
||||
extern void (*_pm_vesa_switcher)(void);
|
||||
extern void (*_pm_vesa_scroller)(void);
|
||||
extern void (*_pm_vesa_pallete)(void);
|
||||
|
||||
extern int _mmio_segment;
|
||||
|
||||
extern void *_accel_driver;
|
||||
|
||||
extern int _accel_active;
|
||||
|
||||
extern void *_accel_set_bank;
|
||||
extern void *_accel_idle;
|
||||
|
||||
void _fill_vbeaf_libc_exports(void *ptr);
|
||||
void _fill_vbeaf_pmode_exports(void *ptr);
|
||||
|
||||
|
||||
/* sound lib stuff */
|
||||
extern int _fm_port;
|
||||
extern int _mpu_port;
|
||||
extern int _mpu_irq;
|
||||
extern int _sb_freq;
|
||||
extern int _sb_port;
|
||||
extern int _sb_dma;
|
||||
extern int _sb_irq;
|
||||
|
||||
int _sb_read_dsp_version(void);
|
||||
int _sb_reset_dsp(int data);
|
||||
void _sb_voice(int state);
|
||||
int _sb_set_mixer(int digi_volume, int midi_volume);
|
||||
|
||||
void _mpu_poll(void);
|
||||
|
||||
int _dma_allocate_mem(int bytes, int *sel, unsigned long *phys);
|
||||
void _dma_start(int channel, unsigned long addr, int size, int auto_init, int input);
|
||||
void _dma_stop(int channel);
|
||||
unsigned long _dma_todo(int channel);
|
||||
void _dma_lock_mem(void);
|
||||
|
||||
|
||||
#endif /* ifndef INTERNDJ_H */
|
||||
|
||||
|
||||
/* flag for how many times we have been initialised */
|
||||
extern int _allegro_count;
|
||||
|
||||
|
||||
/* some Allegro functions need a block of scratch memory */
|
||||
extern void *_scratch_mem;
|
||||
extern int _scratch_mem_size;
|
||||
|
||||
__INLINE__ void _grow_scratch_mem(int size)
|
||||
{
|
||||
if (size > _scratch_mem_size) {
|
||||
size = (size+1023) & 0xFFFFFC00;
|
||||
_scratch_mem = realloc(_scratch_mem, size);
|
||||
_scratch_mem_size = size;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* list of functions to call at program cleanup */
|
||||
void _add_exit_func(void (*func)(void));
|
||||
void _remove_exit_func(void (*func)(void));
|
||||
|
||||
|
||||
/* reads a translation file into memory */
|
||||
void _load_config_text(void);
|
||||
|
||||
|
||||
/* various bits of mouse stuff */
|
||||
void _set_mouse_range(void);
|
||||
extern BITMAP *_mouse_screen;
|
||||
extern BITMAP *_mouse_sprite, *_mouse_pointer;
|
||||
extern int _mouse_x_focus, _mouse_y_focus;
|
||||
extern int _mouse_width, _mouse_height;
|
||||
|
||||
|
||||
/* various bits of timer stuff */
|
||||
extern int _timer_use_retrace;
|
||||
extern volatile int _retrace_hpp_value;
|
||||
|
||||
|
||||
/* caches and tables for svga bank switching */
|
||||
extern int _last_bank_1, _last_bank_2;
|
||||
extern int *_gfx_bank;
|
||||
|
||||
|
||||
/* bank switching routines */
|
||||
void _stub_bank_switch (void);
|
||||
void _stub_bank_switch_end(void);
|
||||
|
||||
|
||||
/* stuff for setting up bitmaps */
|
||||
void _check_gfx_virginity(void);
|
||||
BITMAP *_make_bitmap(int w, int h, unsigned long addr, GFX_DRIVER *driver, int color_depth, int bpl);
|
||||
void _sort_out_virtual_width(int *width, GFX_DRIVER *driver);
|
||||
|
||||
GFX_VTABLE *_get_vtable(int color_depth);
|
||||
|
||||
extern GFX_VTABLE _screen_vtable;
|
||||
|
||||
extern int _sub_bitmap_id_count;
|
||||
|
||||
extern int _textmode;
|
||||
|
||||
#define BYTES_PER_PIXEL(bpp) (((int)(bpp) + 7) / 8)
|
||||
|
||||
int _color_load_depth(int depth);
|
||||
|
||||
extern int _color_conv;
|
||||
|
||||
BITMAP *_fixup_loaded_bitmap(BITMAP *bmp, PALETTE pal, int bpp);
|
||||
|
||||
|
||||
/* VGA register access routines */
|
||||
void _vga_vsync(void);
|
||||
void _vga_set_pallete_range(PALLETE p, int from, int to, int vsync);
|
||||
|
||||
extern int _crtc;
|
||||
|
||||
|
||||
/* _read_vga_register:
|
||||
* Reads the contents of a VGA register.
|
||||
*/
|
||||
__INLINE__ int _read_vga_register(int port, int index)
|
||||
{
|
||||
if (port==0x3C0)
|
||||
inportb(_crtc+6);
|
||||
|
||||
outportb(port, index);
|
||||
return inportb(port+1);
|
||||
}
|
||||
|
||||
|
||||
/* _write_vga_register:
|
||||
* Writes a byte to a VGA register.
|
||||
*/
|
||||
__INLINE__ void _write_vga_register(int port, int index, int v)
|
||||
{
|
||||
if (port==0x3C0) {
|
||||
inportb(_crtc+6);
|
||||
outportb(port, index);
|
||||
outportb(port, v);
|
||||
}
|
||||
else {
|
||||
outportb(port, index);
|
||||
outportb(port+1, v);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* _alter_vga_register:
|
||||
* Alters specific bits of a VGA register.
|
||||
*/
|
||||
__INLINE__ void _alter_vga_register(int port, int index, int mask, int v)
|
||||
{
|
||||
int temp;
|
||||
temp = _read_vga_register(port, index);
|
||||
temp &= (~mask);
|
||||
temp |= (v & mask);
|
||||
_write_vga_register(port, index, temp);
|
||||
}
|
||||
|
||||
|
||||
/* _vsync_out_h:
|
||||
* Waits until the VGA is not in either a vertical or horizontal retrace.
|
||||
*/
|
||||
__INLINE__ void _vsync_out_h(void)
|
||||
{
|
||||
do {
|
||||
} while (inportb(0x3DA) & 1);
|
||||
}
|
||||
|
||||
|
||||
/* _vsync_out_v:
|
||||
* Waits until the VGA is not in a vertical retrace.
|
||||
*/
|
||||
__INLINE__ void _vsync_out_v(void)
|
||||
{
|
||||
do {
|
||||
} while (inportb(0x3DA) & 8);
|
||||
}
|
||||
|
||||
|
||||
/* _vsync_in:
|
||||
* Waits until the VGA is in the vertical retrace period.
|
||||
*/
|
||||
__INLINE__ void _vsync_in(void)
|
||||
{
|
||||
if (_timer_use_retrace) {
|
||||
int t = retrace_count;
|
||||
|
||||
do {
|
||||
} while (t == retrace_count);
|
||||
}
|
||||
else {
|
||||
do {
|
||||
} while (!(inportb(0x3DA) & 8));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* _write_hpp:
|
||||
* Writes to the VGA pelpan register.
|
||||
*/
|
||||
__INLINE__ void _write_hpp(int value)
|
||||
{
|
||||
if (_timer_use_retrace) {
|
||||
_retrace_hpp_value = value;
|
||||
|
||||
do {
|
||||
} while (_retrace_hpp_value == value);
|
||||
}
|
||||
else {
|
||||
do {
|
||||
} while (!(inportb(0x3DA) & 8));
|
||||
|
||||
_write_vga_register(0x3C0, 0x33, value);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void _set_vga_virtual_width(int old_width, int new_width);
|
||||
|
||||
|
||||
/* current drawing mode */
|
||||
extern int _drawing_mode;
|
||||
extern BITMAP *_drawing_pattern;
|
||||
extern int _drawing_x_anchor;
|
||||
extern int _drawing_y_anchor;
|
||||
extern unsigned int _drawing_x_mask;
|
||||
extern unsigned int _drawing_y_mask;
|
||||
|
||||
|
||||
/* graphics drawing routines */
|
||||
void _normal_line(BITMAP *bmp, int x1, int y1, int x2, int y2, int color);
|
||||
void _normal_rectfill(BITMAP *bmp, int x1, int y1, int x2, int y2, int color);
|
||||
|
||||
int _linear_getpixel8(struct BITMAP *bmp, int x, int y);
|
||||
void _linear_putpixel8(struct BITMAP *bmp, int x, int y, int color);
|
||||
void _linear_vline8(struct BITMAP *bmp, int x, int y1, int y2, int color);
|
||||
void _linear_hline8(struct BITMAP *bmp, int x1, int y, int x2, int color);
|
||||
void _linear_draw_sprite8(struct BITMAP *bmp, struct BITMAP *sprite, int x, int y);
|
||||
void _linear_draw_sprite_v_flip8(struct BITMAP *bmp, struct BITMAP *sprite, int x, int y);
|
||||
void _linear_draw_sprite_h_flip8(struct BITMAP *bmp, struct BITMAP *sprite, int x, int y);
|
||||
void _linear_draw_sprite_vh_flip8(struct BITMAP *bmp, struct BITMAP *sprite, int x, int y);
|
||||
void _linear_draw_trans_sprite8(struct BITMAP *bmp, struct BITMAP *sprite, int x, int y);
|
||||
void _linear_draw_lit_sprite8(struct BITMAP *bmp, struct BITMAP *sprite, int x, int y, int color);
|
||||
void _linear_draw_rle_sprite8(struct BITMAP *bmp, struct RLE_SPRITE *sprite, int x, int y);
|
||||
void _linear_draw_trans_rle_sprite8(struct BITMAP *bmp, struct RLE_SPRITE *sprite, int x, int y);
|
||||
void _linear_draw_lit_rle_sprite8(struct BITMAP *bmp, struct RLE_SPRITE *sprite, int x, int y, int color);
|
||||
void _linear_draw_character8(struct BITMAP *bmp, struct BITMAP *sprite, int x, int y, int color);
|
||||
void _linear_textout_fixed8(struct BITMAP *bmp, void *f, int h, unsigned char *str, int x, int y, int color);
|
||||
void _linear_blit8(struct BITMAP *source, struct BITMAP *dest, int source_x, int source_y, int dest_x, int dest_y, int width, int height);
|
||||
void _linear_blit_backward8(struct BITMAP *source, struct BITMAP *dest, int source_x, int source_y, int dest_x, int dest_y, int width, int height);
|
||||
void _linear_masked_blit8(struct BITMAP *source, struct BITMAP *dest, int source_x, int source_y, int dest_x, int dest_y, int width, int height);
|
||||
void _linear_clear_to_color8(struct BITMAP *bitmap, int color);
|
||||
|
||||
#ifdef ALLEGRO_COLOR16
|
||||
|
||||
void _linear_putpixel15(struct BITMAP *bmp, int x, int y, int color);
|
||||
void _linear_vline15(struct BITMAP *bmp, int x, int y1, int y2, int color);
|
||||
void _linear_hline15(struct BITMAP *bmp, int x1, int y, int x2, int color);
|
||||
void _linear_draw_trans_sprite15(struct BITMAP *bmp, struct BITMAP *sprite, int x, int y);
|
||||
void _linear_draw_lit_sprite15(struct BITMAP *bmp, struct BITMAP *sprite, int x, int y, int color);
|
||||
void _linear_draw_rle_sprite15(struct BITMAP *bmp, struct RLE_SPRITE *sprite, int x, int y);
|
||||
void _linear_draw_trans_rle_sprite15(struct BITMAP *bmp, struct RLE_SPRITE *sprite, int x, int y);
|
||||
void _linear_draw_lit_rle_sprite15(struct BITMAP *bmp, struct RLE_SPRITE *sprite, int x, int y, int color);
|
||||
|
||||
int _linear_getpixel16(struct BITMAP *bmp, int x, int y);
|
||||
void _linear_putpixel16(struct BITMAP *bmp, int x, int y, int color);
|
||||
void _linear_vline16(struct BITMAP *bmp, int x, int y1, int y2, int color);
|
||||
void _linear_hline16(struct BITMAP *bmp, int x1, int y, int x2, int color);
|
||||
void _linear_draw_sprite16(struct BITMAP *bmp, struct BITMAP *sprite, int x, int y);
|
||||
void _linear_draw_256_sprite16(struct BITMAP *bmp, struct BITMAP *sprite, int x, int y);
|
||||
void _linear_draw_sprite_v_flip16(struct BITMAP *bmp, struct BITMAP *sprite, int x, int y);
|
||||
void _linear_draw_sprite_h_flip16(struct BITMAP *bmp, struct BITMAP *sprite, int x, int y);
|
||||
void _linear_draw_sprite_vh_flip16(struct BITMAP *bmp, struct BITMAP *sprite, int x, int y);
|
||||
void _linear_draw_trans_sprite16(struct BITMAP *bmp, struct BITMAP *sprite, int x, int y);
|
||||
void _linear_draw_lit_sprite16(struct BITMAP *bmp, struct BITMAP *sprite, int x, int y, int color);
|
||||
void _linear_draw_rle_sprite16(struct BITMAP *bmp, struct RLE_SPRITE *sprite, int x, int y);
|
||||
void _linear_draw_trans_rle_sprite16(struct BITMAP *bmp, struct RLE_SPRITE *sprite, int x, int y);
|
||||
void _linear_draw_lit_rle_sprite16(struct BITMAP *bmp, struct RLE_SPRITE *sprite, int x, int y, int color);
|
||||
void _linear_draw_character16(struct BITMAP *bmp, struct BITMAP *sprite, int x, int y, int color);
|
||||
void _linear_textout_fixed16(struct BITMAP *bmp, void *f, int h, unsigned char *str, int x, int y, int color);
|
||||
void _linear_blit16(struct BITMAP *source, struct BITMAP *dest, int source_x, int source_y, int dest_x, int dest_y, int width, int height);
|
||||
void _linear_blit_backward16(struct BITMAP *source, struct BITMAP *dest, int source_x, int source_y, int dest_x, int dest_y, int width, int height);
|
||||
void _linear_masked_blit16(struct BITMAP *source, struct BITMAP *dest, int source_x, int source_y, int dest_x, int dest_y, int width, int height);
|
||||
void _linear_clear_to_color16(struct BITMAP *bitmap, int color);
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef ALLEGRO_COLOR24
|
||||
|
||||
int _linear_getpixel24(struct BITMAP *bmp, int x, int y);
|
||||
void _linear_putpixel24(struct BITMAP *bmp, int x, int y, int color);
|
||||
void _linear_vline24(struct BITMAP *bmp, int x, int y1, int y2, int color);
|
||||
void _linear_hline24(struct BITMAP *bmp, int x1, int y, int x2, int color);
|
||||
void _linear_draw_sprite24(struct BITMAP *bmp, struct BITMAP *sprite, int x, int y);
|
||||
void _linear_draw_256_sprite24(struct BITMAP *bmp, struct BITMAP *sprite, int x, int y);
|
||||
void _linear_draw_sprite_v_flip24(struct BITMAP *bmp, struct BITMAP *sprite, int x, int y);
|
||||
void _linear_draw_sprite_h_flip24(struct BITMAP *bmp, struct BITMAP *sprite, int x, int y);
|
||||
void _linear_draw_sprite_vh_flip24(struct BITMAP *bmp, struct BITMAP *sprite, int x, int y);
|
||||
void _linear_draw_trans_sprite24(struct BITMAP *bmp, struct BITMAP *sprite, int x, int y);
|
||||
void _linear_draw_lit_sprite24(struct BITMAP *bmp, struct BITMAP *sprite, int x, int y, int color);
|
||||
void _linear_draw_rle_sprite24(struct BITMAP *bmp, struct RLE_SPRITE *sprite, int x, int y);
|
||||
void _linear_draw_trans_rle_sprite24(struct BITMAP *bmp, struct RLE_SPRITE *sprite, int x, int y);
|
||||
void _linear_draw_lit_rle_sprite24(struct BITMAP *bmp, struct RLE_SPRITE *sprite, int x, int y, int color);
|
||||
void _linear_draw_character24(struct BITMAP *bmp, struct BITMAP *sprite, int x, int y, int color);
|
||||
void _linear_textout_fixed24(struct BITMAP *bmp, void *f, int h, unsigned char *str, int x, int y, int color);
|
||||
void _linear_blit24(struct BITMAP *source, struct BITMAP *dest, int source_x, int source_y, int dest_x, int dest_y, int width, int height);
|
||||
void _linear_blit_backward24(struct BITMAP *source, struct BITMAP *dest, int source_x, int source_y, int dest_x, int dest_y, int width, int height);
|
||||
void _linear_masked_blit24(struct BITMAP *source, struct BITMAP *dest, int source_x, int source_y, int dest_x, int dest_y, int width, int height);
|
||||
void _linear_clear_to_color24(struct BITMAP *bitmap, int color);
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef ALLEGRO_COLOR32
|
||||
|
||||
int _linear_getpixel32(struct BITMAP *bmp, int x, int y);
|
||||
void _linear_putpixel32(struct BITMAP *bmp, int x, int y, int color);
|
||||
void _linear_vline32(struct BITMAP *bmp, int x, int y1, int y2, int color);
|
||||
void _linear_hline32(struct BITMAP *bmp, int x1, int y, int x2, int color);
|
||||
void _linear_draw_sprite32(struct BITMAP *bmp, struct BITMAP *sprite, int x, int y);
|
||||
void _linear_draw_256_sprite32(struct BITMAP *bmp, struct BITMAP *sprite, int x, int y);
|
||||
void _linear_draw_sprite_v_flip32(struct BITMAP *bmp, struct BITMAP *sprite, int x, int y);
|
||||
void _linear_draw_sprite_h_flip32(struct BITMAP *bmp, struct BITMAP *sprite, int x, int y);
|
||||
void _linear_draw_sprite_vh_flip32(struct BITMAP *bmp, struct BITMAP *sprite, int x, int y);
|
||||
void _linear_draw_trans_sprite32(struct BITMAP *bmp, struct BITMAP *sprite, int x, int y);
|
||||
void _linear_draw_lit_sprite32(struct BITMAP *bmp, struct BITMAP *sprite, int x, int y, int color);
|
||||
void _linear_draw_rle_sprite32(struct BITMAP *bmp, struct RLE_SPRITE *sprite, int x, int y);
|
||||
void _linear_draw_trans_rle_sprite32(struct BITMAP *bmp, struct RLE_SPRITE *sprite, int x, int y);
|
||||
void _linear_draw_lit_rle_sprite32(struct BITMAP *bmp, struct RLE_SPRITE *sprite, int x, int y, int color);
|
||||
void _linear_draw_character32(struct BITMAP *bmp, struct BITMAP *sprite, int x, int y, int color);
|
||||
void _linear_textout_fixed32(struct BITMAP *bmp, void *f, int h, unsigned char *str, int x, int y, int color);
|
||||
void _linear_blit32(struct BITMAP *source, struct BITMAP *dest, int source_x, int source_y, int dest_x, int dest_y, int width, int height);
|
||||
void _linear_blit_backward32(struct BITMAP *source, struct BITMAP *dest, int source_x, int source_y, int dest_x, int dest_y, int width, int height);
|
||||
void _linear_masked_blit32(struct BITMAP *source, struct BITMAP *dest, int source_x, int source_y, int dest_x, int dest_y, int width, int height);
|
||||
void _linear_clear_to_color32(struct BITMAP *bitmap, int color);
|
||||
|
||||
#endif
|
||||
|
||||
int _x_getpixel(struct BITMAP *bmp, int x, int y);
|
||||
void _x_putpixel(struct BITMAP *bmp, int x, int y, int color);
|
||||
void _x_vline(struct BITMAP *bmp, int x, int y1, int y2, int color);
|
||||
void _x_hline(struct BITMAP *bmp, int x1, int y, int x2, int color);
|
||||
void _x_draw_sprite(struct BITMAP *bmp, struct BITMAP *sprite, int x, int y);
|
||||
void _x_draw_sprite_v_flip(struct BITMAP *bmp, struct BITMAP *sprite, int x, int y);
|
||||
void _x_draw_sprite_h_flip(struct BITMAP *bmp, struct BITMAP *sprite, int x, int y);
|
||||
void _x_draw_sprite_vh_flip(struct BITMAP *bmp, struct BITMAP *sprite, int x, int y);
|
||||
void _x_draw_trans_sprite(struct BITMAP *bmp, struct BITMAP *sprite, int x, int y);
|
||||
void _x_draw_lit_sprite(struct BITMAP *bmp, struct BITMAP *sprite, int x, int y, int color);
|
||||
void _x_draw_rle_sprite(struct BITMAP *bmp, struct RLE_SPRITE *sprite, int x, int y);
|
||||
void _x_draw_trans_rle_sprite(struct BITMAP *bmp, struct RLE_SPRITE *sprite, int x, int y);
|
||||
void _x_draw_lit_rle_sprite(struct BITMAP *bmp, struct RLE_SPRITE *sprite, int x, int y, int color);
|
||||
void _x_draw_character(struct BITMAP *bmp, struct BITMAP *sprite, int x, int y, int color);
|
||||
void _x_textout_fixed(struct BITMAP *bmp, void *f, int h, unsigned char *str, int x, int y, int color);
|
||||
void _x_blit_from_memory(struct BITMAP *source, struct BITMAP *dest, int source_x, int source_y, int dest_x, int dest_y, int width, int height);
|
||||
void _x_blit_to_memory(struct BITMAP *source, struct BITMAP *dest, int source_x, int source_y, int dest_x, int dest_y, int width, int height);
|
||||
void _x_blit(struct BITMAP *source, struct BITMAP *dest, int source_x, int source_y, int dest_x, int dest_y, int width, int height);
|
||||
void _x_blit_forward(struct BITMAP *source, struct BITMAP *dest, int source_x, int source_y, int dest_x, int dest_y, int width, int height);
|
||||
void _x_blit_backward(struct BITMAP *source, struct BITMAP *dest, int source_x, int source_y, int dest_x, int dest_y, int width, int height);
|
||||
void _x_masked_blit(struct BITMAP *source, struct BITMAP *dest, int source_x, int source_y, int dest_x, int dest_y, int width, int height);
|
||||
void _x_clear_to_color(struct BITMAP *bitmap, int color);
|
||||
|
||||
|
||||
/* asm helper for stretch_blit() */
|
||||
void _do_stretch(BITMAP *source, BITMAP *dest, void *drawer, int sx, fixed sy, fixed syd, int dx, int dy, int dh, int color_depth);
|
||||
|
||||
|
||||
/* number of fractional bits used by the polygon rasteriser */
|
||||
#define POLYGON_FIX_SHIFT 18
|
||||
|
||||
|
||||
/* bitfield specifying which polygon attributes need interpolating */
|
||||
#define INTERP_FLAT 1
|
||||
#define INTERP_1COL 2
|
||||
#define INTERP_3COL 4
|
||||
#define INTERP_FIX_UV 8
|
||||
#define INTERP_Z 16
|
||||
#define INTERP_FLOAT_UV 32
|
||||
#define OPT_FLOAT_UV_TO_FIX 64
|
||||
#define COLOR_TO_RGB 128
|
||||
|
||||
|
||||
/* information for polygon scanline fillers */
|
||||
typedef struct POLYGON_SEGMENT
|
||||
{
|
||||
fixed u, v, du, dv; /* fixed point u/v coordinates */
|
||||
fixed c, dc; /* single color gouraud shade values */
|
||||
fixed r, g, b, dr, dg, db; /* RGB gouraud shade values */
|
||||
float z, dz; /* polygon depth (1/z) */
|
||||
float fu, fv, dfu, dfv; /* floating point u/v coordinates */
|
||||
unsigned char *texture; /* the texture map */
|
||||
int umask, vmask, vshift; /* texture map size information */
|
||||
int seg; /* destination bitmap selector */
|
||||
} POLYGON_SEGMENT;
|
||||
|
||||
|
||||
/* an active polygon edge */
|
||||
typedef struct POLYGON_EDGE
|
||||
{
|
||||
int top; /* top y position */
|
||||
int bottom; /* bottom y position */
|
||||
fixed x, dx; /* fixed point x position and gradient */
|
||||
fixed w; /* width of line segment */
|
||||
POLYGON_SEGMENT dat; /* texture/gouraud information */
|
||||
struct POLYGON_EDGE *prev; /* doubly linked list */
|
||||
struct POLYGON_EDGE *next;
|
||||
} POLYGON_EDGE;
|
||||
|
||||
|
||||
/* prototype for the scanline filler functions */
|
||||
typedef void (*SCANLINE_FILLER)(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
|
||||
|
||||
/* polygon helper functions */
|
||||
extern SCANLINE_FILLER _optim_alternative_drawer;
|
||||
POLYGON_EDGE *_add_edge(POLYGON_EDGE *list, POLYGON_EDGE *edge, int sort_by_x);
|
||||
POLYGON_EDGE *_remove_edge(POLYGON_EDGE *list, POLYGON_EDGE *edge);
|
||||
void _fill_3d_edge_structure(POLYGON_EDGE *edge, V3D *v1, V3D *v2, int flags, BITMAP *bmp);
|
||||
void _fill_3d_edge_structure_f(POLYGON_EDGE *edge, V3D_f *v1, V3D_f *v2, int flags, BITMAP *bmp);
|
||||
SCANLINE_FILLER _get_scanline_filler(int type, int *flags, POLYGON_SEGMENT *info, BITMAP *texture, BITMAP *bmp);
|
||||
void _clip_polygon_segment(POLYGON_SEGMENT *info, int gap, int flags);
|
||||
|
||||
|
||||
/* polygon scanline filler functions */
|
||||
void _poly_scanline_gcol8(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_grgb8(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_atex8(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_ptex8(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_atex_mask8(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_ptex_mask8(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_atex_lit8(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_ptex_lit8(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_atex_mask_lit8(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_ptex_mask_lit8(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
|
||||
void _poly_scanline_grgb8x(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
|
||||
void _poly_scanline_grgb15(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_atex_mask15(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_ptex_mask15(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_atex_lit15(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_ptex_lit15(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_atex_mask_lit15(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_ptex_mask_lit15(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
|
||||
void _poly_scanline_grgb15x(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_atex_lit15x(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_ptex_lit15x(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_atex_mask_lit15x(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_ptex_mask_lit15x(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
|
||||
void _poly_scanline_ptex_lit15d(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_ptex_mask_lit15d(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
|
||||
void _poly_scanline_grgb16(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_atex16(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_ptex16(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_atex_mask16(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_ptex_mask16(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_atex_lit16(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_ptex_lit16(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_atex_mask_lit16(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_ptex_mask_lit16(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
|
||||
void _poly_scanline_grgb16x(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_atex_lit16x(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_ptex_lit16x(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_atex_mask_lit16x(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_ptex_mask_lit16x(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
|
||||
void _poly_scanline_ptex_lit16d(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_ptex_mask_lit16d(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
|
||||
void _poly_scanline_grgb24(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_atex24(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_ptex24(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_atex_mask24(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_ptex_mask24(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_atex_lit24(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_ptex_lit24(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_atex_mask_lit24(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_ptex_mask_lit24(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
|
||||
void _poly_scanline_grgb24x(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_atex_lit24x(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_ptex_lit24x(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_atex_mask_lit24x(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_ptex_mask_lit24x(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
|
||||
void _poly_scanline_ptex_lit24d(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_ptex_mask_lit24d(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
|
||||
void _poly_scanline_grgb32(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_atex32(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_ptex32(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_atex_mask32(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_ptex_mask32(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_atex_lit32(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_ptex_lit32(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_atex_mask_lit32(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_ptex_mask_lit32(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
|
||||
void _poly_scanline_grgb32x(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_atex_lit32x(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_ptex_lit32x(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_atex_mask_lit32x(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_ptex_mask_lit32x(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
|
||||
void _poly_scanline_ptex_lit32d(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
void _poly_scanline_ptex_mask_lit32d(unsigned long addr, int w, POLYGON_SEGMENT *info);
|
||||
|
||||
|
||||
/* sound lib stuff */
|
||||
extern int _digi_volume;
|
||||
extern int _midi_volume;
|
||||
extern int _flip_pan;
|
||||
extern int _sound_hq;
|
||||
|
||||
extern int (*_midi_init)(void);
|
||||
extern void (*_midi_exit)(void);
|
||||
|
||||
int _midi_allocate_voice(int min, int max);
|
||||
|
||||
extern volatile long _midi_tick;
|
||||
|
||||
int _digmid_find_patches(char *dir, char *file);
|
||||
|
||||
#define VIRTUAL_VOICES 256
|
||||
|
||||
|
||||
typedef struct /* a virtual (as seen by the user) soundcard voice */
|
||||
{
|
||||
SAMPLE *sample; /* which sample are we playing? (NULL = free) */
|
||||
int num; /* physical voice number (-1 = been killed off) */
|
||||
int autokill; /* set to free the voice when the sample finishes */
|
||||
long time; /* when we were started (for voice allocation) */
|
||||
int priority; /* how important are we? */
|
||||
} VOICE;
|
||||
|
||||
extern VOICE _voice[VIRTUAL_VOICES];
|
||||
|
||||
|
||||
typedef struct /* a physical (as used by hardware) soundcard voice */
|
||||
{
|
||||
int num; /* the virtual voice currently using me (-1 = free) */
|
||||
int playmode; /* are we looping? */
|
||||
int vol; /* current volume (fixed point .12) */
|
||||
int dvol; /* volume delta, for ramping */
|
||||
int target_vol; /* target volume, for ramping */
|
||||
int pan; /* current pan (fixed point .12) */
|
||||
int dpan; /* pan delta, for sweeps */
|
||||
int target_pan; /* target pan, for sweeps */
|
||||
int freq; /* current frequency (fixed point .12) */
|
||||
int dfreq; /* frequency delta, for sweeps */
|
||||
int target_freq; /* target frequency, for sweeps */
|
||||
} PHYS_VOICE;
|
||||
|
||||
extern PHYS_VOICE _phys_voice[DIGI_VOICES];
|
||||
|
||||
|
||||
#define MIXER_DEF_SFX 8
|
||||
#define MIXER_MAX_SFX 64
|
||||
|
||||
int _mixer_init(int bufsize, int freq, int stereo, int is16bit, int *voices);
|
||||
void _mixer_exit(void);
|
||||
void _mix_some_samples(unsigned long buf, unsigned short seg, int issigned);
|
||||
|
||||
void _mixer_init_voice(int voice, SAMPLE *sample);
|
||||
void _mixer_release_voice(int voice);
|
||||
void _mixer_start_voice(int voice);
|
||||
void _mixer_stop_voice(int voice);
|
||||
void _mixer_loop_voice(int voice, int loopmode);
|
||||
int _mixer_get_position(int voice);
|
||||
void _mixer_set_position(int voice, int position);
|
||||
int _mixer_get_volume(int voice);
|
||||
void _mixer_set_volume(int voice, int volume);
|
||||
void _mixer_ramp_volume(int voice, int time, int endvol);
|
||||
void _mixer_stop_volume_ramp(int voice);
|
||||
int _mixer_get_frequency(int voice);
|
||||
void _mixer_set_frequency(int voice, int frequency);
|
||||
void _mixer_sweep_frequency(int voice, int time, int endfreq);
|
||||
void _mixer_stop_frequency_sweep(int voice);
|
||||
int _mixer_get_pan(int voice);
|
||||
void _mixer_set_pan(int voice, int pan);
|
||||
void _mixer_sweep_pan(int voice, int time, int endpan);
|
||||
void _mixer_stop_pan_sweep(int voice);
|
||||
void _mixer_set_echo(int voice, int strength, int delay);
|
||||
void _mixer_set_tremolo(int voice, int rate, int depth);
|
||||
void _mixer_set_vibrato(int voice, int rate, int depth);
|
||||
|
||||
/* dummy functions for the NoSound drivers */
|
||||
int _dummy_detect(int input);
|
||||
int _dummy_init(int input, int voices);
|
||||
void _dummy_exit(int input);
|
||||
int _dummy_mixer_volume(int volume);
|
||||
void _dummy_init_voice(int voice, SAMPLE *sample);
|
||||
void _dummy_noop1(int p);
|
||||
void _dummy_noop2(int p1, int p2);
|
||||
void _dummy_noop3(int p1, int p2, int p3);
|
||||
int _dummy_get_position(int voice);
|
||||
int _dummy_get(int voice);
|
||||
void _dummy_raw_midi(unsigned char data);
|
||||
int _dummy_load_patches(char *patches, char *drums);
|
||||
void _dummy_adjust_patches(char *patches, char *drums);
|
||||
void _dummy_key_on(int inst, int note, int bend, int vol, int pan);
|
||||
|
||||
|
||||
/* from djgpp's libc, needed to find which directory we were run from */
|
||||
extern int __crt0_argc;
|
||||
extern char **__crt0_argv;
|
||||
|
||||
|
||||
#endif /* ifndef INTERNAL_H */
|
|
@ -1,22 +0,0 @@
|
|||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// Copyright (C) 2005-2020 by Sonic Team Junior.
|
||||
//
|
||||
// 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.
|
||||
//-----------------------------------------------------------------------------
|
||||
/// \file
|
||||
/// \brief Set Com port and speed for GDBStubs for DJGGP
|
||||
///
|
||||
/// copy and rename as rdb.h and set the defines below as needed
|
||||
|
||||
#define DEBUG_COM_PORT 2
|
||||
#define DEBUG_COM_PORT_SPEED 9600
|
|
@ -1,903 +0,0 @@
|
|||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// Copyright (C) 1998-2000 by DooM Legacy Team.
|
||||
//
|
||||
// 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.
|
||||
//-----------------------------------------------------------------------------
|
||||
/// \file
|
||||
/// \brief extended vesa VESA2.0 video modes i/o
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../i_system.h" //I_Error()
|
||||
#include "vid_vesa.h"
|
||||
#include "../doomdef.h" //MAXVIDWIDTH, MAXVIDHEIGHT
|
||||
#include "../screen.h"
|
||||
|
||||
#include <dpmi.h>
|
||||
#include <go32.h>
|
||||
#include <sys/farptr.h>
|
||||
#include <sys/movedata.h>
|
||||
#include <sys/segments.h>
|
||||
#include <sys/nearptr.h>
|
||||
|
||||
#include "../console.h"
|
||||
#include "../command.h" //added:21-03-98: vid_xxx commands
|
||||
#include "../i_video.h"
|
||||
|
||||
|
||||
// PROTOS
|
||||
static vmode_t *VID_GetModePtr (int modenum);
|
||||
static int VID_VesaGetModeInfo (int modenum);
|
||||
static void VID_VesaGetExtraModes (void);
|
||||
static INT32 VID_VesaInitMode (viddef_t *lvid, vmode_t *pcurrentmode);
|
||||
|
||||
static void VID_Command_NumModes_f (void);
|
||||
static void VID_Command_ModeInfo_f (void);
|
||||
static void VID_Command_ModeList_f (void);
|
||||
static void VID_Command_Mode_f (void);
|
||||
|
||||
consvar_t cv_vidwait = {"vid_wait", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
static consvar_t cv_stretch = {"stretch", "On", CV_SAVE|CV_NOSHOWHELP, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
||||
#define VBEVERSION 2 // we need vesa2 or higher
|
||||
|
||||
// -----------------------------------------------------
|
||||
#define MASK_LINEAR(addr) (addr & 0x000FFFFF)
|
||||
#define RM_TO_LINEAR(addr) (((addr & 0xFFFF0000) >> 12) + (addr & 0xFFFF))
|
||||
#define RM_OFFSET(addr) (addr & 0xF)
|
||||
#define RM_SEGMENT(addr) ((addr >> 4) & 0xFFFF)
|
||||
// -----------------------------------------------------
|
||||
|
||||
static int totalvidmem;
|
||||
|
||||
static vmode_t vesa_modes[MAX_VESA_MODES] = {{NULL, NULL, 0, 0, 0, 0, 0, 0, NULL, NULL, 0}};
|
||||
static vesa_extra_t vesa_extra[MAX_VESA_MODES];
|
||||
|
||||
//this is the only supported non-vesa mode : standard 320x200x256c.
|
||||
#define NUMVGAVIDMODES 1
|
||||
static INT32 VGA_InitMode (viddef_t *lvid, vmode_t *pcurrentmode);
|
||||
static char vgamode1[] ="320x200";
|
||||
static vmode_t vgavidmodes[NUMVGAVIDMODES] = {
|
||||
{
|
||||
NULL,
|
||||
vgamode1,
|
||||
320, 200, //(200.0/320.0)*(320.0/240.0),
|
||||
320, 1, // rowbytes, bytes per pixel
|
||||
0, 1,
|
||||
NULL,
|
||||
VGA_InitMode, 0
|
||||
}
|
||||
};
|
||||
|
||||
static char names[MAX_VESA_MODES][10];
|
||||
|
||||
//----------------------------i_video.c------------------------------------
|
||||
// these ones should go to i_video.c, but I prefer keep them away from the
|
||||
// doom sources until the vesa stuff is ok.
|
||||
static int numvidmodes; //total number of video modes, vga, vesa1, vesa2.
|
||||
static vmode_t *pvidmodes; //start of videomodes list.
|
||||
static vmode_t *pcurrentmode; // the current active videomode.
|
||||
//----------------------------i_video.c------------------------------------
|
||||
|
||||
|
||||
|
||||
// table des modes videos.
|
||||
// seul le mode 320x200x256c standard VGA est support‚ sans le VESA.
|
||||
// ce mode est le mode num‚ro 0 dans la liste.
|
||||
typedef struct
|
||||
{
|
||||
int modenum; // vesa vbe2.0 modenum
|
||||
int mode_attributes;
|
||||
int winasegment;
|
||||
int winbsegment;
|
||||
int bytes_per_scanline; // bytes per logical scanline (+16)
|
||||
int win; // window number (A=0, B=1)
|
||||
int win_size; // window size (+6)
|
||||
int granularity; // how finely i can set the window in vid mem (+4)
|
||||
int width, height; // displayed width and height (+18, +20)
|
||||
int bits_per_pixel; // er, better be 8, 15, 16, 24, or 32 (+25)
|
||||
int bytes_per_pixel; // er, better be 1, 2, or 4
|
||||
int memory_model; // and better be 4 or 6, packed or direct color (+27)
|
||||
int num_pages; // number of complete frame buffer pages (+29)
|
||||
int red_width; // the # of bits in the red component (+31)
|
||||
int red_pos; // the bit position of the red component (+32)
|
||||
int green_width; // etc.. (+33)
|
||||
int green_pos; // (+34)
|
||||
int blue_width; // (+35)
|
||||
int blue_pos; // (+36)
|
||||
int pptr;
|
||||
int pagesize;
|
||||
int numpages;
|
||||
} modeinfo_t;
|
||||
|
||||
static vbeinfoblock_t vesainfo;
|
||||
static vesamodeinfo_t vesamodeinfo;
|
||||
|
||||
// ------------------------------------------------------------------------
|
||||
// DOS stuff
|
||||
// ------------------------------------------------------------------------
|
||||
static unsigned long conventional_memory = (unsigned long)-1;
|
||||
|
||||
FUNCINLINE static ATTRINLINE void map_in_conventional_memory(void)
|
||||
{
|
||||
if (conventional_memory == (unsigned long)-1)
|
||||
{
|
||||
if (__djgpp_nearptr_enable())
|
||||
{
|
||||
conventional_memory = __djgpp_conventional_base;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Converts a flat 32 bit ptr to a realmode 0x12345 type ptr (seg<<4 + offs)
|
||||
#if 0
|
||||
unsigned int ptr2real(void *ptr)
|
||||
{
|
||||
map_in_conventional_memory();
|
||||
return (int)ptr - conventional_memory;
|
||||
}
|
||||
#endif
|
||||
|
||||
// Converts 0x12345 (seg<<4+offs) realmode ptr to a flat 32bit ptr
|
||||
FUNCINLINE static ATTRINLINE void *real2ptr(unsigned int real)
|
||||
{
|
||||
map_in_conventional_memory();
|
||||
return (void *) (real + conventional_memory);
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------
|
||||
|
||||
|
||||
/* ======================================================================== */
|
||||
// Add the standard VGA video modes (only one now) to the video modes list.
|
||||
/* ======================================================================== */
|
||||
static inline void VGA_Init(void)
|
||||
{
|
||||
vgavidmodes[NUMVGAVIDMODES-1].pnext = pvidmodes;
|
||||
pvidmodes = &vgavidmodes[0];
|
||||
numvidmodes += NUMVGAVIDMODES;
|
||||
}
|
||||
|
||||
|
||||
//added:30-01-98: return number of video modes in pvidmodes list
|
||||
INT32 VID_NumModes(void)
|
||||
{
|
||||
return numvidmodes;
|
||||
}
|
||||
|
||||
//added:21-03-98: return info on video mode
|
||||
FUNCINLINE static ATTRINLINE const char *VID_ModeInfo (int modenum, char **ppheader)
|
||||
{
|
||||
static const char *badmodestr = "Bad video mode number\n";
|
||||
vmode_t *pv;
|
||||
|
||||
pv = VID_GetModePtr (modenum);
|
||||
|
||||
if (!pv)
|
||||
{
|
||||
if (ppheader)
|
||||
*ppheader = NULL;
|
||||
return badmodestr;
|
||||
}
|
||||
else
|
||||
{
|
||||
//if (ppheader)
|
||||
// *ppheader = pv->header;
|
||||
return pv->name;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
//added:03-02-98: return a video mode number from the dimensions
|
||||
INT32 VID_GetModeForSize( INT32 w, INT32 h)
|
||||
{
|
||||
vmode_t *pv;
|
||||
int modenum;
|
||||
|
||||
pv = pvidmodes;
|
||||
for (modenum=0; pv!=NULL; pv=pv->pnext,modenum++ )
|
||||
{
|
||||
if ( pv->width==(unsigned)w && pv->height==(unsigned)h )
|
||||
return modenum;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/* ======================================================================== */
|
||||
//
|
||||
/* ======================================================================== */
|
||||
void VID_Init (void)
|
||||
{
|
||||
COM_AddCommand ("vid_nummodes", VID_Command_NumModes_f);
|
||||
COM_AddCommand ("vid_modeinfo", VID_Command_ModeInfo_f);
|
||||
COM_AddCommand ("vid_modelist", VID_Command_ModeList_f);
|
||||
COM_AddCommand ("vid_mode", VID_Command_Mode_f);
|
||||
CV_RegisterVar (&cv_vidwait);
|
||||
CV_RegisterVar (&cv_stretch);
|
||||
|
||||
//setup the videmodes list,
|
||||
// note that mode 0 must always be VGA mode 0x13
|
||||
pvidmodes = NULL;
|
||||
pcurrentmode = NULL;
|
||||
numvidmodes = 0;
|
||||
// setup the vesa_modes list
|
||||
VID_VesaGetExtraModes ();
|
||||
|
||||
// the game boots in 320x200 standard VGA, but
|
||||
// we need a highcolor mode to run the game in highcolor
|
||||
if (highcolor && numvidmodes==0)
|
||||
I_Error ("No 15bit highcolor VESA2 video mode found, cannot run in highcolor.\n");
|
||||
|
||||
// add the vga modes at the start of the modes list
|
||||
VGA_Init();
|
||||
|
||||
|
||||
#ifdef DEBUG
|
||||
CONS_Printf("VID_SetMode(%d)\n",vid.modenum);
|
||||
#endif
|
||||
VID_SetMode (0); //vid.modenum);
|
||||
|
||||
|
||||
#ifdef DEBUG
|
||||
CONS_Printf("after VID_SetMode\n");
|
||||
CONS_Printf("vid.width %d\n",vid.width);
|
||||
CONS_Printf("vid.height %d\n",vid.height);
|
||||
CONS_Printf("vid.buffer %x\n",vid.buffer);
|
||||
CONS_Printf("vid.rowbytes %d\n",vid.rowbytes);
|
||||
CONS_Printf("vid.numpages %d\n",vid.numpages);
|
||||
CONS_Printf("vid.recalc %d\n",vid.recalc);
|
||||
CONS_Printf("vid.direct %x\n",vid.direct);
|
||||
#endif
|
||||
|
||||
}
|
||||
|
||||
|
||||
// ========================================================================
|
||||
// Returns a vmode_t from the video modes list, given a video mode number.
|
||||
// ========================================================================
|
||||
vmode_t *VID_GetModePtr (int modenum)
|
||||
{
|
||||
vmode_t *pv;
|
||||
|
||||
pv = pvidmodes;
|
||||
if (!pv)
|
||||
I_Error ("VID_error 1\n");
|
||||
|
||||
while (modenum--)
|
||||
{
|
||||
pv = pv->pnext;
|
||||
if (!pv)
|
||||
I_Error ("VID_error 2\n");
|
||||
}
|
||||
|
||||
return pv;
|
||||
}
|
||||
|
||||
|
||||
//added:30-01-98:return the name of a video mode
|
||||
const char *VID_GetModeName (INT32 modenum)
|
||||
{
|
||||
return (VID_GetModePtr(modenum))->name;
|
||||
}
|
||||
|
||||
|
||||
// ========================================================================
|
||||
// Sets a video mode
|
||||
// ========================================================================
|
||||
INT32 VID_SetMode (INT32 modenum) //, UINT8 *palette)
|
||||
{
|
||||
int vstat;
|
||||
vmode_t *pnewmode, *poldmode;
|
||||
|
||||
if ((modenum >= numvidmodes) || (modenum < 0))
|
||||
{
|
||||
if (pcurrentmode == NULL)
|
||||
{
|
||||
modenum = 0; // mode hasn't been set yet, so initialize to base
|
||||
// mode since they gave us an invalid initial mode
|
||||
}
|
||||
else
|
||||
{
|
||||
//nomodecheck = true;
|
||||
I_Error ("Unknown video mode: %d\n", modenum);
|
||||
//nomodecheck = false;
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
pnewmode = VID_GetModePtr (modenum);
|
||||
|
||||
if (pnewmode == pcurrentmode)
|
||||
return 1; // already in the desired mode
|
||||
|
||||
// initialize the new mode
|
||||
poldmode = pcurrentmode;
|
||||
pcurrentmode = pnewmode;
|
||||
|
||||
// initialize vidbuffer size for setmode
|
||||
vid.width = pcurrentmode->width;
|
||||
vid.height = pcurrentmode->height;
|
||||
//vid.aspect = pcurrentmode->aspect;
|
||||
vid.rowbytes = pcurrentmode->rowbytes;
|
||||
vid.bpp = pcurrentmode->bytesperpixel;
|
||||
|
||||
//debug
|
||||
//if (vid.rowbytes != vid.width)
|
||||
// I_Error("vidrowbytes (%d) <> vidwidth(%d)\n",vid.rowbytes,vid.width);
|
||||
|
||||
vstat = (*pcurrentmode->setmode) (&vid, pcurrentmode);
|
||||
|
||||
if (vstat < 1)
|
||||
{
|
||||
if (vstat == 0)
|
||||
{
|
||||
// harware could not setup mode
|
||||
//if (!VID_SetMode (vid.modenum))
|
||||
// I_Error ("VID_SetMode: couldn't set video mode (hard failure)");
|
||||
I_Error("Couldn't set video mode %d\n", modenum);
|
||||
}
|
||||
else
|
||||
if (vstat == -1)
|
||||
{
|
||||
CONS_Printf ("Not enough mem for VID_SetMode...\n");
|
||||
|
||||
// not enough memory; just put things back the way they were
|
||||
pcurrentmode = poldmode;
|
||||
vid.width = pcurrentmode->width;
|
||||
vid.height = pcurrentmode->height;
|
||||
vid.rowbytes = pcurrentmode->rowbytes;
|
||||
vid.bpp = pcurrentmode->bytesperpixel;
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
vid.modenum = modenum;
|
||||
|
||||
//printf ("%s\n", VID_ModeInfo (vid.modenum, NULL));
|
||||
|
||||
//added:20-01-98: recalc all tables and realloc buffers based on
|
||||
// vid values.
|
||||
vid.recalc = 1;
|
||||
|
||||
if (!cv_stretch.value && (float)vid.width/vid.height != ((float)BASEVIDWIDTH/BASEVIDHEIGHT))
|
||||
vid.height = (int)(vid.width * ((float)BASEVIDHEIGHT/BASEVIDWIDTH));// Adjust the height to match
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
void VID_CheckRenderer(void) {}
|
||||
void VID_CheckGLLoaded(rendermode_t oldrender) {}
|
||||
|
||||
|
||||
|
||||
// converts a segm:offs 32bit pair to a 32bit flat ptr
|
||||
#if 0
|
||||
void *VID_ExtraFarToLinear (void *ptr)
|
||||
{
|
||||
int temp;
|
||||
|
||||
temp = (int)ptr;
|
||||
return real2ptr (((temp & 0xFFFF0000) >> 12) + (temp & 0xFFFF));
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
// ========================================================================
|
||||
// Helper function for VID_VesaGetExtraModes
|
||||
// In: vesa mode number, from the vesa videomodenumbers list
|
||||
// Out: false, if no info for given modenum
|
||||
// ========================================================================
|
||||
int VID_VesaGetModeInfo (int modenum)
|
||||
{
|
||||
int bytes_per_pixel;
|
||||
unsigned int i;
|
||||
__dpmi_regs regs;
|
||||
|
||||
for (i=0; i<sizeof (vesamodeinfo_t); i++)
|
||||
_farpokeb(_dos_ds, MASK_LINEAR(__tb)+i, 0);
|
||||
|
||||
regs.x.ax = 0x4f01;
|
||||
regs.x.di = RM_OFFSET(__tb);
|
||||
regs.x.es = RM_SEGMENT(__tb);
|
||||
regs.x.cx = modenum;
|
||||
__dpmi_int(0x10, ®s);
|
||||
if (regs.h.ah)
|
||||
return false;
|
||||
else
|
||||
{
|
||||
dosmemget (MASK_LINEAR(__tb), sizeof (vesamodeinfo_t), &vesamodeinfo);
|
||||
|
||||
bytes_per_pixel = (vesamodeinfo.BitsPerPixel+1)/8;
|
||||
|
||||
// we add either highcolor or lowcolor video modes, not the two
|
||||
if (highcolor && (vesamodeinfo.BitsPerPixel != 15))
|
||||
return false;
|
||||
if (!highcolor && (vesamodeinfo.BitsPerPixel != 8))
|
||||
return false;
|
||||
|
||||
if ((bytes_per_pixel > 2) ||
|
||||
(vesamodeinfo.XResolution > MAXVIDWIDTH) ||
|
||||
(vesamodeinfo.YResolution > MAXVIDHEIGHT))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
// we only want color graphics modes that are supported by the hardware
|
||||
if ((vesamodeinfo.ModeAttributes &
|
||||
(MODE_SUPPORTED_IN_HW | COLOR_MODE | GRAPHICS_MODE) ) !=
|
||||
(MODE_SUPPORTED_IN_HW | COLOR_MODE | GRAPHICS_MODE))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
// we only work with linear frame buffers, except for 320x200,
|
||||
// which is linear when banked at 0xA000
|
||||
if (!(vesamodeinfo.ModeAttributes & LINEAR_FRAME_BUFFER))
|
||||
{
|
||||
if ((vesamodeinfo.XResolution != 320) ||
|
||||
(vesamodeinfo.YResolution != 200))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// pagesize
|
||||
if ((vesamodeinfo.BytesPerScanLine * vesamodeinfo.YResolution)
|
||||
> totalvidmem)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
vesamodeinfo.NumberOfImagePages = 1;
|
||||
|
||||
|
||||
#ifdef DEBUG
|
||||
CONS_Printf("VID: (VESA) info for mode 0x%x\n", modeinfo.modenum);
|
||||
CONS_Printf(" mode attrib = 0x%0x\n", modeinfo.mode_attributes);
|
||||
CONS_Printf(" win a attrib = 0x%0x\n", *(UINT8 *)(infobuf+2));
|
||||
CONS_Printf(" win b attrib = 0x%0x\n", *(UINT8 *)(infobuf+3));
|
||||
CONS_Printf(" win a seg 0x%0x\n", (int) modeinfo.winasegment);
|
||||
CONS_Printf(" win b seg 0x%0x\n", (int) modeinfo.winbsegment);
|
||||
CONS_Printf(" bytes per scanline = %d\n",
|
||||
modeinfo.bytes_per_scanline);
|
||||
CONS_Printf(" width = %d, height = %d\n", modeinfo.width,
|
||||
modeinfo.height);
|
||||
CONS_Printf(" win = %c\n", 'A' + modeinfo.win);
|
||||
CONS_Printf(" win granularity = %d\n", modeinfo.granularity);
|
||||
CONS_Printf(" win size = %d\n", modeinfo.win_size);
|
||||
CONS_Printf(" bits per pixel = %d\n", modeinfo.bits_per_pixel);
|
||||
CONS_Printf(" bytes per pixel = %d\n", modeinfo.bytes_per_pixel);
|
||||
CONS_Printf(" memory model = 0x%x\n", modeinfo.memory_model);
|
||||
CONS_Printf(" num pages = %d\n", modeinfo.num_pages);
|
||||
CONS_Printf(" red width = %d\n", modeinfo.red_width);
|
||||
CONS_Printf(" red pos = %d\n", modeinfo.red_pos);
|
||||
CONS_Printf(" green width = %d\n", modeinfo.green_width);
|
||||
CONS_Printf(" green pos = %d\n", modeinfo.green_pos);
|
||||
CONS_Printf(" blue width = %d\n", modeinfo.blue_width);
|
||||
CONS_Printf(" blue pos = %d\n", modeinfo.blue_pos);
|
||||
CONS_Printf(" phys mem = %x\n", modeinfo.pptr);
|
||||
#endif
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
// ========================================================================
|
||||
// Get extended VESA modes information, keep the ones that we support,
|
||||
// so they'll be available in the game Video menu.
|
||||
// ========================================================================
|
||||
#define MAXVESADESC 100
|
||||
static char vesadesc[MAXVESADESC] = "";
|
||||
|
||||
void VID_VesaGetExtraModes (void)
|
||||
{
|
||||
unsigned int i;
|
||||
unsigned long addr;
|
||||
int nummodes;
|
||||
__dpmi_meminfo phys_mem_info;
|
||||
unsigned long mode_ptr;
|
||||
__dpmi_regs regs;
|
||||
|
||||
// make a copy of the video modes list! else trash in __tb
|
||||
UINT16 vmode[MAX_VESA_MODES+1];
|
||||
int numvmodes;
|
||||
UINT16 vesamode;
|
||||
|
||||
// new ugly stuff...
|
||||
for (i=0; i<sizeof (vbeinfoblock_t); i++)
|
||||
_farpokeb(_dos_ds, MASK_LINEAR(__tb)+i, 0);
|
||||
|
||||
dosmemput("VBE2", 4, MASK_LINEAR(__tb));
|
||||
|
||||
// see if VESA support is available
|
||||
regs.x.ax = 0x4f00;
|
||||
regs.x.di = RM_OFFSET(__tb);
|
||||
regs.x.es = RM_SEGMENT(__tb);
|
||||
__dpmi_int(0x10, ®s);
|
||||
if (regs.h.ah)
|
||||
goto no_vesa;
|
||||
|
||||
dosmemget(MASK_LINEAR(__tb), sizeof (vbeinfoblock_t), &vesainfo);
|
||||
|
||||
if (strncmp((void *)vesainfo.VESASignature, "VESA", 4) != 0)
|
||||
{
|
||||
no_vesa:
|
||||
CONS_Printf ("No VESA driver\n");
|
||||
return;
|
||||
}
|
||||
|
||||
if (vesainfo.VESAVersion < (VBEVERSION<<8))
|
||||
{
|
||||
CONS_Printf ("VESA VBE %d.0 not available\n", VBEVERSION);
|
||||
return;
|
||||
}
|
||||
|
||||
//
|
||||
// vesa version number
|
||||
//
|
||||
CONS_Printf ("%4.4s %d.%d (", vesainfo.VESASignature,
|
||||
vesainfo.VESAVersion>>8,
|
||||
vesainfo.VESAVersion&0xFF);
|
||||
|
||||
//
|
||||
// vesa description string
|
||||
//
|
||||
i = 0;
|
||||
addr = RM_TO_LINEAR(vesainfo.OemStringPtr);
|
||||
_farsetsel(_dos_ds);
|
||||
while (_farnspeekb(addr) != 0)
|
||||
{
|
||||
vesadesc[i++] = _farnspeekb(addr++);
|
||||
if (i == MAXVESADESC-1)
|
||||
break;
|
||||
}
|
||||
vesadesc[i]=0;
|
||||
CONS_Printf ("%s)\n",vesadesc);
|
||||
|
||||
totalvidmem = vesainfo.TotalMemory << 16;
|
||||
|
||||
//
|
||||
// find 8 bit modes
|
||||
//
|
||||
numvmodes = 0;
|
||||
mode_ptr = RM_TO_LINEAR(vesainfo.VideoModePtr);
|
||||
while ((vmode[numvmodes] = _farpeekw(_dos_ds, mode_ptr)) != 0xFFFF)
|
||||
{
|
||||
numvmodes++;
|
||||
if ( numvmodes == MAX_VESA_MODES )
|
||||
break;
|
||||
mode_ptr += 2;
|
||||
}
|
||||
vmode[numvmodes] = 0xffff;
|
||||
|
||||
nummodes = 0; // number of video modes accepted for the game
|
||||
|
||||
numvmodes=0; // go again through vmodes table
|
||||
while ( ((vesamode=vmode[numvmodes++]) != 0xFFFF) && (nummodes < MAX_VESA_MODES) )
|
||||
{
|
||||
//fill the modeinfo struct.
|
||||
if (VID_VesaGetModeInfo (vesamode))
|
||||
{
|
||||
vesa_modes[nummodes].pnext = &vesa_modes[nummodes+1];
|
||||
if (vesamodeinfo.XResolution > 999)
|
||||
{
|
||||
if (vesamodeinfo.YResolution > 999)
|
||||
{
|
||||
sprintf (&names[nummodes][0], "%4dx%4d", vesamodeinfo.XResolution,
|
||||
vesamodeinfo.YResolution);
|
||||
names[nummodes][9] = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
sprintf (&names[nummodes][0], "%4dx%3d", vesamodeinfo.XResolution,
|
||||
vesamodeinfo.YResolution);
|
||||
names[nummodes][8] = 0;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (vesamodeinfo.YResolution > 999)
|
||||
{
|
||||
sprintf (&names[nummodes][0], "%3dx%4d", vesamodeinfo.XResolution,
|
||||
vesamodeinfo.YResolution);
|
||||
names[nummodes][8] = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
sprintf (&names[nummodes][0], "%3dx%3d", vesamodeinfo.XResolution,
|
||||
vesamodeinfo.YResolution);
|
||||
names[nummodes][7] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
vesa_modes[nummodes].name = &names[nummodes][0];
|
||||
vesa_modes[nummodes].width = vesamodeinfo.XResolution;
|
||||
vesa_modes[nummodes].height = vesamodeinfo.YResolution;
|
||||
|
||||
//added:20-01-98:aspect ratio to be implemented...
|
||||
vesa_modes[nummodes].rowbytes = vesamodeinfo.BytesPerScanLine;
|
||||
vesa_modes[nummodes].windowed = 0;
|
||||
vesa_modes[nummodes].pextradata = &vesa_extra[nummodes];
|
||||
vesa_modes[nummodes].setmode = VID_VesaInitMode;
|
||||
|
||||
if (vesamodeinfo.ModeAttributes & LINEAR_FRAME_BUFFER)
|
||||
{
|
||||
// add linear bit to mode for linear modes
|
||||
vesa_extra[nummodes].vesamode = vesamode | LINEAR_MODE;
|
||||
vesa_modes[nummodes].numpages = 1; //vesamodeinfo.NumberOfImagePages;
|
||||
|
||||
phys_mem_info.address = (int)vesamodeinfo.PhysBasePtr;
|
||||
phys_mem_info.size = 0x400000;
|
||||
|
||||
// returns -1 on error
|
||||
if (__dpmi_physical_address_mapping(&phys_mem_info))
|
||||
{
|
||||
//skip this mode, it doesnt work
|
||||
continue;
|
||||
}
|
||||
|
||||
// if physical mapping was ok... convert the selector:offset
|
||||
vesa_extra[nummodes].plinearmem =
|
||||
real2ptr (phys_mem_info.address);
|
||||
|
||||
// lock the region
|
||||
__dpmi_lock_linear_region (&phys_mem_info);
|
||||
}
|
||||
else
|
||||
{
|
||||
// banked at 0xA0000
|
||||
vesa_extra[nummodes].vesamode = vesamode;
|
||||
//vesa_extra[nummodes].pages[0] = 0;
|
||||
vesa_extra[nummodes].plinearmem =
|
||||
real2ptr (vesamodeinfo.WinASegment<<4);
|
||||
|
||||
vesa_modes[nummodes].numpages = 1; //modeinfo.numpages;
|
||||
}
|
||||
|
||||
vesa_modes[nummodes].bytesperpixel = (vesamodeinfo.BitsPerPixel+1)/8;
|
||||
|
||||
nummodes++;
|
||||
}
|
||||
}
|
||||
|
||||
// add the VESA modes at the start of the mode list (if there are any)
|
||||
if (nummodes)
|
||||
{
|
||||
vesa_modes[nummodes-1].pnext = NULL; //pvidmodes;
|
||||
pvidmodes = &vesa_modes[0];
|
||||
numvidmodes += nummodes;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
// ========================================================================
|
||||
// Free the video buffer of the last video mode,
|
||||
// allocate a new buffer for the video mode to set.
|
||||
// ========================================================================
|
||||
static boolean VID_FreeAndAllocVidbuffer (viddef_t *lvid)
|
||||
{
|
||||
int vidbuffersize;
|
||||
|
||||
vidbuffersize = (lvid->width * lvid->height * lvid->bpp * NUMSCREENS); //status bar
|
||||
|
||||
// free allocated buffer for previous video mode
|
||||
if (lvid->buffer!=NULL)
|
||||
{
|
||||
free(lvid->buffer);
|
||||
}
|
||||
|
||||
// allocate the new screen buffer
|
||||
if ( (lvid->buffer = (UINT8 *) malloc(vidbuffersize))==NULL )
|
||||
return false;
|
||||
|
||||
// initially clear the video buffer
|
||||
memset (lvid->buffer, 0x00, vidbuffersize);
|
||||
|
||||
#ifdef DEBUG
|
||||
CONS_Printf("VID_FreeAndAllocVidbuffer done, vidbuffersize: %x\n",vidbuffersize);
|
||||
#endif
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
// ========================================================================
|
||||
// Set video mode routine for STANDARD VGA MODES (NO HIGHCOLOR)
|
||||
// Out: 1 ok,
|
||||
// 0 hardware could not set mode,
|
||||
// -1 no mem
|
||||
// ========================================================================
|
||||
static INT32 VGA_InitMode (viddef_t *lvid, vmode_t *currentmodep)
|
||||
{
|
||||
__dpmi_regs regs;
|
||||
|
||||
if (!VID_FreeAndAllocVidbuffer (lvid))
|
||||
return -1; //no mem
|
||||
|
||||
//added:26-01-98: should clear video mem here
|
||||
|
||||
//set mode 0x13
|
||||
regs.h.ah = 0;
|
||||
regs.h.al = 0x13;
|
||||
__dpmi_int(0x10, ®s);
|
||||
|
||||
// here it is the standard VGA 64k window, not an LFB
|
||||
// (you could have 320x200x256c with LFB in the vesa modes)
|
||||
lvid->direct = (UINT8 *) real2ptr (0xa0000);
|
||||
lvid->u.numpages = 1;
|
||||
lvid->bpp = currentmodep->bytesperpixel;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
// ========================================================================
|
||||
// Set video mode routine for VESA video modes, see VID_SetMode()
|
||||
// Out: 1 ok,
|
||||
// 0 hardware could not set mode,
|
||||
// -1 no mem
|
||||
// ========================================================================
|
||||
INT32 VID_VesaInitMode (viddef_t *lvid, vmode_t *currentmodep)
|
||||
{
|
||||
vesa_extra_t *pextra;
|
||||
__dpmi_regs regs;
|
||||
|
||||
pextra = currentmodep->pextradata;
|
||||
|
||||
#ifdef DEBUG
|
||||
CONS_Printf("VID_VesaInitMode...\n");
|
||||
CONS_Printf(" currentmodep->name %s\n",currentmodep->name);
|
||||
CONS_Printf(" width %d\n",currentmodep->width);
|
||||
CONS_Printf(" height %d\n",currentmodep->height);
|
||||
CONS_Printf(" rowbytes %d\n",currentmodep->rowbytes);
|
||||
CONS_Printf(" windowed %d\n",currentmodep->windowed);
|
||||
CONS_Printf(" numpages %d\n",currentmodep->numpages);
|
||||
CONS_Printf(" currentmodep->pextradata :\n");
|
||||
CONS_Printf(" ->vesamode %x\n",pextra->vesamode);
|
||||
CONS_Printf(" ->plinearmem %x\n\n",pextra->plinearmem);
|
||||
#endif
|
||||
|
||||
//added:20-01-98:no page flipping now... TO DO!!!
|
||||
lvid->u.numpages = 1;
|
||||
|
||||
// clean up any old vid buffer lying around, alloc new if needed
|
||||
if (!VID_FreeAndAllocVidbuffer (lvid))
|
||||
return -1; //no mem
|
||||
|
||||
|
||||
//added:20-01-98: should clear video mem here
|
||||
|
||||
|
||||
// set the mode
|
||||
regs.x.ax = 0x4f02;
|
||||
regs.x.bx = pextra->vesamode;
|
||||
__dpmi_int (0x10, ®s);
|
||||
|
||||
if (regs.x.ax != 0x4f)
|
||||
return 0; // could not set mode
|
||||
|
||||
//added:20-01-98: should setup wait_vsync flag, currentpage here...
|
||||
// plus check for display_enable bit
|
||||
|
||||
//added:20-01-98: here we should set the page if page flipping...
|
||||
|
||||
// points to LFB, or the start of VGA mem.
|
||||
lvid->direct = pextra->plinearmem;
|
||||
lvid->bpp = currentmodep->bytesperpixel;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
// ========================================================================
|
||||
// VIDEO MODE CONSOLE COMMANDS
|
||||
// ========================================================================
|
||||
|
||||
|
||||
// vid_nummodes
|
||||
//
|
||||
//added:21-03-98:
|
||||
void VID_Command_NumModes_f (void)
|
||||
{
|
||||
int nummodes;
|
||||
|
||||
nummodes = VID_NumModes ();
|
||||
CONS_Printf ("%d video mode(s) available(s)\n", nummodes);
|
||||
}
|
||||
|
||||
|
||||
// vid_modeinfo <modenum>
|
||||
//
|
||||
void VID_Command_ModeInfo_f (void)
|
||||
{
|
||||
vmode_t *pv;
|
||||
int modenum;
|
||||
|
||||
if (COM_Argc()!=2)
|
||||
modenum = vid.modenum; // describe the current mode
|
||||
else
|
||||
modenum = atoi (COM_Argv(1)); // .. the given mode number
|
||||
|
||||
if (modenum >= VID_NumModes())
|
||||
{
|
||||
CONS_Printf ("No such video mode\n");
|
||||
return;
|
||||
}
|
||||
|
||||
pv = VID_GetModePtr (modenum);
|
||||
|
||||
CONS_Printf ("%s\n", VID_ModeInfo (modenum, NULL));
|
||||
CONS_Printf ("width : %d\n"
|
||||
"height: %d\n"
|
||||
"bytes per scanline: %d\n"
|
||||
"bytes per pixel: %d\n"
|
||||
"numpages: %d\n",
|
||||
pv->width,
|
||||
pv->height,
|
||||
pv->rowbytes,
|
||||
pv->bytesperpixel,
|
||||
pv->numpages );
|
||||
}
|
||||
|
||||
|
||||
// vid_modelist
|
||||
//
|
||||
void VID_Command_ModeList_f (void)
|
||||
{
|
||||
int i, nummodes;
|
||||
const char *pinfo;
|
||||
char *pheader;
|
||||
vmode_t *pv;
|
||||
boolean na;
|
||||
|
||||
na = false;
|
||||
|
||||
nummodes = VID_NumModes ();
|
||||
for (i=0 ; i<nummodes ; i++)
|
||||
{
|
||||
pv = VID_GetModePtr (i);
|
||||
pinfo = VID_ModeInfo (i, &pheader);
|
||||
|
||||
if (i==0 || pv->bytesperpixel==1)
|
||||
CONS_Printf ("%d: %s\n", i, pinfo);
|
||||
else
|
||||
CONS_Printf ("%d: %s (hicolor)\n", i, pinfo);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
// vid_mode <modenum>
|
||||
//
|
||||
void VID_Command_Mode_f (void)
|
||||
{
|
||||
int modenum;
|
||||
|
||||
if (COM_Argc()!=2)
|
||||
{
|
||||
CONS_Printf ("vid_mode <modenum> : set video mode\n");
|
||||
return;
|
||||
}
|
||||
|
||||
modenum = atoi(COM_Argv(1));
|
||||
|
||||
if (modenum >= VID_NumModes())
|
||||
CONS_Printf ("No such video mode\n");
|
||||
else
|
||||
// request vid mode change
|
||||
setmodeneeded = modenum+1;
|
||||
}
|
|
@ -1,109 +0,0 @@
|
|||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// Copyright (C) 1998-2000 by DooM Legacy Team.
|
||||
//
|
||||
// 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.
|
||||
//-----------------------------------------------------------------------------
|
||||
/// \file
|
||||
/// \brief VESA extra modes.
|
||||
|
||||
#include "../doomdef.h"
|
||||
#include "../screen.h"
|
||||
|
||||
|
||||
|
||||
#define MODE_SUPPORTED_IN_HW 0x0001
|
||||
#define COLOR_MODE 0x0008
|
||||
#define GRAPHICS_MODE 0x0010
|
||||
#define VGA_INCOMPATIBLE 0x0020
|
||||
#define LINEAR_FRAME_BUFFER 0x0080
|
||||
#define LINEAR_MODE 0x4000
|
||||
|
||||
#define MAX_VESA_MODES 30 // we'll just take the first 30 if there
|
||||
|
||||
|
||||
// VESA information block structure
|
||||
typedef struct vbeinfoblock_s
|
||||
{
|
||||
UINT8 VESASignature[4];
|
||||
UINT16 VESAVersion;
|
||||
unsigned long OemStringPtr;
|
||||
UINT8 Capabilities[4];
|
||||
unsigned long VideoModePtr;
|
||||
UINT16 TotalMemory;
|
||||
UINT8 OemSoftwareRev[2];
|
||||
UINT8 OemVendorNamePtr[4];
|
||||
UINT8 OemProductNamePtr[4];
|
||||
UINT8 OemProductRevPtr[4];
|
||||
UINT8 Reserved[222];
|
||||
UINT8 OemData[256];
|
||||
} ATTRPACK vbeinfoblock_t;
|
||||
|
||||
|
||||
// VESA information for a specific mode
|
||||
typedef struct vesamodeinfo_s
|
||||
{
|
||||
UINT16 ModeAttributes;
|
||||
UINT8 WinAAttributes;
|
||||
UINT8 WinBAttributes;
|
||||
UINT16 WinGranularity;
|
||||
UINT16 WinSize;
|
||||
UINT16 WinASegment;
|
||||
UINT16 WinBSegment;
|
||||
unsigned long WinFuncPtr;
|
||||
UINT16 BytesPerScanLine;
|
||||
UINT16 XResolution;
|
||||
UINT16 YResolution;
|
||||
UINT8 XCharSize;
|
||||
UINT8 YCharSize;
|
||||
UINT8 NumberOfPlanes;
|
||||
UINT8 BitsPerPixel;
|
||||
UINT8 NumberOfBanks;
|
||||
UINT8 MemoryModel;
|
||||
UINT8 BankSize;
|
||||
UINT8 NumberOfImagePages;
|
||||
UINT8 Reserved_page;
|
||||
UINT8 RedMaskSize;
|
||||
UINT8 RedMaskPos;
|
||||
UINT8 GreenMaskSize;
|
||||
UINT8 GreenMaskPos;
|
||||
UINT8 BlueMaskSize;
|
||||
UINT8 BlueMaskPos;
|
||||
UINT8 ReservedMaskSize;
|
||||
UINT8 ReservedMaskPos;
|
||||
UINT8 DirectColorModeInfo;
|
||||
|
||||
/* VBE 2.0 extensions */
|
||||
unsigned long PhysBasePtr;
|
||||
unsigned long OffScreenMemOffset;
|
||||
UINT16 OffScreenMemSize;
|
||||
|
||||
/* VBE 3.0 extensions */
|
||||
UINT16 LinBytesPerScanLine;
|
||||
UINT8 BnkNumberOfPages;
|
||||
UINT8 LinNumberOfPages;
|
||||
UINT8 LinRedMaskSize;
|
||||
UINT8 LinRedFieldPos;
|
||||
UINT8 LinGreenMaskSize;
|
||||
UINT8 LinGreenFieldPos;
|
||||
UINT8 LinBlueMaskSize;
|
||||
UINT8 LinBlueFieldPos;
|
||||
UINT8 LinRsvdMaskSize;
|
||||
UINT8 LinRsvdFieldPos;
|
||||
unsigned long MaxPixelClock;
|
||||
|
||||
UINT8 Reserved[190];
|
||||
} ATTRPACK vesamodeinfo_t;
|
||||
|
||||
|
||||
// setup standard VGA + VESA modes list, activate the default video mode.
|
||||
void VID_Init (void);
|
|
@ -110,10 +110,6 @@
|
|||
#include <io.h>
|
||||
#endif
|
||||
|
||||
#ifdef PC_DOS
|
||||
#include <conio.h>
|
||||
#endif
|
||||
|
||||
//#define NOMD5
|
||||
|
||||
// Uncheck this to compile debugging code
|
||||
|
@ -558,8 +554,8 @@ INT32 I_GetKey(void);
|
|||
#endif
|
||||
|
||||
// The character that separates pathnames. Forward slash on
|
||||
// most systems, but reverse solidus (\) on Windows and DOS.
|
||||
#if defined (PC_DOS) || defined (_WIN32)
|
||||
// most systems, but reverse solidus (\) on Windows.
|
||||
#if defined (_WIN32)
|
||||
#define PATHSEP "\\"
|
||||
#else
|
||||
#define PATHSEP "/"
|
||||
|
|
|
@ -74,12 +74,6 @@
|
|||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef PC_DOS
|
||||
#include <stdio.h> // for snprintf
|
||||
int snprintf(char *str, size_t n, const char *fmt, ...);
|
||||
//int vsnprintf(char *str, size_t n, const char *fmt, va_list ap);
|
||||
#endif
|
||||
|
||||
#if defined (__GNUC__) && (__GNUC__ >= 4)
|
||||
#define FIXUPO0
|
||||
#endif
|
||||
|
|
|
@ -793,8 +793,6 @@ static void M_PNGText(png_structp png_ptr, png_infop png_info_ptr, PNG_CONST png
|
|||
"SDL";
|
||||
#elif defined (_WINDOWS)
|
||||
"DirectX";
|
||||
#elif defined (PC_DOS)
|
||||
"Allegro";
|
||||
#else
|
||||
"Unknown";
|
||||
#endif
|
||||
|
|
|
@ -31,12 +31,6 @@
|
|||
#include "hardware/hw_md2.h"
|
||||
#endif
|
||||
|
||||
#ifdef PC_DOS
|
||||
#include <stdio.h> // for snprintf
|
||||
int snprintf(char *str, size_t n, const char *fmt, ...);
|
||||
//int vsnprintf(char *str, size_t n, const char *fmt, va_list ap);
|
||||
#endif
|
||||
|
||||
INT32 numskins = 0;
|
||||
skin_t skins[MAXSKINS];
|
||||
|
||||
|
|
|
@ -70,12 +70,6 @@
|
|||
#include "hardware/hw_glob.h"
|
||||
#endif
|
||||
|
||||
#ifdef PC_DOS
|
||||
#include <stdio.h> // for snprintf
|
||||
int snprintf(char *str, size_t n, const char *fmt, ...);
|
||||
//int vsnprintf(char *str, size_t n, const char *fmt, va_list ap);
|
||||
#endif
|
||||
|
||||
#ifdef _DEBUG
|
||||
#include "console.h"
|
||||
#endif
|
||||
|
|
|
@ -43,12 +43,6 @@
|
|||
#include "hardware/hw_main.h"
|
||||
#endif
|
||||
|
||||
#ifdef PC_DOS
|
||||
#include <stdio.h> // for snprintf
|
||||
int snprintf(char *str, size_t n, const char *fmt, ...);
|
||||
//int vsnprintf(char *str, size_t n, const char *fmt, va_list ap);
|
||||
#endif
|
||||
|
||||
typedef struct
|
||||
{
|
||||
char patch[9];
|
||||
|
|
Loading…
Reference in a new issue