SVGA BMP

#include <stdio.h>
#include <string.h>
#include <dos.h>
#include <stdlib.h>
#include <conio.h>
#include <malloc.h>
#include <share.h>
#include <io.h>
#include <sys\types.h>
#include <sys\stat.h>
#include <fcntl.h>
#include <i86.h>
#include <math.h>
#include <time.h>

// Bildspeicheradresse
#define SCREEN_AREA 0xa000
#define SCREEN_LIN_ADDR ((SCREEN_AREA) << 4)

void grafik_ein();
void grafik_aus();

void loadBMPFile(short x, short y ,char *filename);

void putvgaicon( short x1, short y1, short breite, short hoehe, int *pointer);
void putvgapixelpart( short x1, short y1, short breite, short hoehe,short part_x1, short part_y1, short part_breite, short part_hoehe, int *pointer);
void pressvgapixel( short x1, short y1, short neue_breite, short neue_hoehe, short breite, short hoehe, int *pointer);
void putvgapixel( short x1, short y1, short breite, short hoehe, int *pointer);
void getvgapixel( short x1, short y1, short breite, short hoehe, int *pointer);

void bar ( short int _x, short int _y, short int _breite, short int _hoehe, char _pixelfarbe);
void line ( short int x1, short int y1, short int x2, short int y2, char _pixelfarbe);

void setpalette (short int anzahl);
void setpalettecolor (short int color,char rot, char gruen, char blau);

void blendingallup();
void blendingalldown();

void grafik_main();
void select_bildstartadresse(short int x, short int y);

void warte(short int zeit);

struct vesa_info_ {
short int fensterA;
char fensterAwrite,fensterAread;
short int fensterB;
char fensterBwrite,fensterBread;
char virtuell;
short int bankgranu;
short int videomodus;
};

struct bmp_header_ {
short int signatur;
int flen;
short int dummy1,dummy2;
int offset,info_size,xmax,ymax;
short int polanes,bit_per_pixel,compress;
int xsize,hdpi,vdpi,cols,coli;
};

struct vesa_info_ vesa_info;
struct bmp_header_ bmp_header;
char pal_array [256] [3];
char pal_res [256];
char *_ptr;
int bildbreite;
char schreibfenster,lesefenster;
short int aktuelle_bank;
short int helligkeit;
unsigned int toffset1,OfsA000;
unsigned short int tsegment1,SegA000;

void select_bildstartadresse(short int x, short int y)
{
union REGS _regs;

_regs.h.ah = 0x4F;
_regs.h.al = 0x07;
_regs.h.bh = 0x00;
_regs.h.bl = 0x00;
_regs.w.cx = x;
_regs.w.dx = y;
int386( 0x10, &_regs, &_regs);
}

void select_schreibbank(short int bank)
{
union REGS _regs;

bank=bank * vesa_info.bankgranu;
_regs.h.ah = 0x4F;
_regs.h.al = 0x05;
_regs.h.bh = 0x00;
_regs.h.bl = schreibfenster;
_regs.w.dx = bank;
int386( 0x10, &_regs, &_regs);
}

void schreibbank_verwaltung(short int y)
{
if (y<=63){
if (aktuelle_bank!=0){
select_schreibbank(0);
aktuelle_bank=0;
}
}
if ((y>63)&(y<=127)){
if (aktuelle_bank!=1){
select_schreibbank(1);
aktuelle_bank=1;
}
}
if ((y>127)&(y<=191)){
if (aktuelle_bank!=2){
select_schreibbank(2);
aktuelle_bank=2;
}
}
if ((y>191)&(y<=255)){
if (aktuelle_bank!=3){
select_schreibbank(3);
aktuelle_bank=3;
}
}
if ((y>255)&(y<=319)){
if (aktuelle_bank!=4){
select_schreibbank(4);
aktuelle_bank=4;
}
}
if ((y>319)&(y<=383)){
if (aktuelle_bank!=5){
select_schreibbank(5);
aktuelle_bank=5;
}
}
if ((y>383)&(y<=447)){
if (aktuelle_bank!=6){
select_schreibbank(6);
aktuelle_bank=6;
}
}
if ((y>447)&(y<=511)){
if (aktuelle_bank!=7){
select_schreibbank(7);
aktuelle_bank=7;
}
}
if ((y>511)&(y<=575)){
if (aktuelle_bank!=8){
select_schreibbank(8);
aktuelle_bank=8;
}
}
if ((y>575)&(y<=639)){
if (aktuelle_bank!=9){
select_schreibbank(9);
aktuelle_bank=9;
}
}
if ((y>639)&(y<=703)){
if (aktuelle_bank!=10){
select_schreibbank(10);
aktuelle_bank=10;
}
}
if ((y>703)&(y<=768)){
if (aktuelle_bank!=11){
select_schreibbank(11);
aktuelle_bank=11;
}
}
}

void putvgaicon( short x1, short y1, short breite, short hoehe, int *pointer)
{
short qtsegment1;
int c2,qtoffset1;
short int zoffset2;
int zaehler,y;

#pragma aux put_iconasm = \
"push es"\
"push ds"\
"mov esi,qtoffset1"\
"add esi,c2"\
"mov ax,qtsegment1"\
"mov ds,ax"\
"mov ax,SegA000"\
"mov es,ax"\
"mov edi,OfsA000"\
"add di,zoffset2"\
"mov ecx,zaehler"\
"s: mov al,ds:[esi]"\
"cmp al,10"\
"je sende"\
"movsb"\
"jmp lloop"\
"sende: inc edi"\
"inc esi"\
"lloop: loop s"\
"pop ds"\
"pop es"\
modify [ax ecx esi edi]\

// Links korrigieren
if (x1<0) x1=0;
if (y1<0) y1=0;

zaehler=breite/4*4;

qtsegment1=FP_SEG( pointer );
qtoffset1=FP_OFF( pointer );

for (y=y1;y<y1+hoehe-1;y++){
c2=breite*(y-y1);
zoffset2=bildbreite*y+x1;
schreibbank_verwaltung(y);
put_iconasm();
}
}

void select_lesebank(short int bank)
{
union REGS _regs;

bank=bank * vesa_info.bankgranu;
_regs.h.ah = 0x4F;
_regs.h.al = 0x05;
_regs.h.bh = 0x00;
_regs.h.bl = lesefenster;
_regs.w.dx = bank;
int386( 0x10, &_regs, &_regs);
}

void lesebank_verwaltung(short int y)
{
if (y<=63){
if (aktuelle_bank!=0){
select_lesebank(0);
aktuelle_bank=0;
}
}
if ((y>63)&(y<=127)){
if (aktuelle_bank!=1){
select_lesebank(1);
aktuelle_bank=1;
}
}
if ((y>127)&(y<=191)){
if (aktuelle_bank!=2){
select_lesebank(2);
aktuelle_bank=2;
}
}
if ((y>191)&(y<=255)){
if (aktuelle_bank!=3){
select_lesebank(3);
aktuelle_bank=3;
}
}
if ((y>255)&(y<=319)){
if (aktuelle_bank!=4){
select_lesebank(4);
aktuelle_bank=4;
}
}
if ((y>319)&(y<=383)){
if (aktuelle_bank!=5){
select_lesebank(5);
aktuelle_bank=5;
}
}
if ((y>383)&(y<=447)){
if (aktuelle_bank!=6){
select_lesebank(6);
aktuelle_bank=6;
}
}
if ((y>447)&(y<=511)){
if (aktuelle_bank!=7){
select_lesebank(7);
aktuelle_bank=7;
}
}
if ((y>511)&(y<=575)){
if (aktuelle_bank!=8){
select_lesebank(8);
aktuelle_bank=8;
}
}
if ((y>575)&(y<=639)){
if (aktuelle_bank!=9){
select_lesebank(9);
aktuelle_bank=9;
}
}
if ((y>639)&(y<=703)){
if (aktuelle_bank!=10){
select_lesebank(10);
aktuelle_bank=10;
}
}
if ((y>703)&(y<=768)){
if (aktuelle_bank!=11){
select_lesebank(11);
aktuelle_bank=11;
}
}
}

void pressvgapixel( short x1, short y1, short neue_breite, short neue_hoehe, short breite, short hoehe, int *pointer)
{
short qtsegment1;
int c2,qtoffset1;
short int zoffset2;
int xa,ya,x,zaehler2,zaehler3,y;

#pragma aux put_textureasm = \
"push es"\
"push ds"\
"mov esi,qtoffset1"\
"add esi,c2"\
"mov ax,qtsegment1"\
"mov ds,ax"\
"mov ax,SegA000"\
"mov es,ax"\
"mov edi,OfsA000"\
"add di,zoffset2"\
"movsb"\
"pop ds"\
"pop es"\
modify [ax ecx esi edi];

qtsegment1=FP_SEG( pointer );
qtoffset1=FP_OFF( pointer );

for (y=0;y<hoehe-1;y++){
for (x=0;x<breite-1;x++){
xa=(neue_breite*x)/ breite+x1;
ya=(neue_hoehe*y )/ hoehe +y1;
c2=breite*y+x;
zoffset2=bildbreite*ya+xa;
/* zaehler2=y*neue_hoehe/hoehe;
c2=breite*y+x;
zaehler3=x*neue_breite/breite;
zoffset2=bildbreite*(zaehler2+y1)+zaehler3+x1;
schreibbank_verwaltung(zaehler2+y1);
*/
schreibbank_verwaltung(ya);
put_textureasm();
}
}
}

void setpalette (short int anzahl)
{
short int merker,i;
char pl_array [256] [3];

merker=helligkeit;
helligkeit=helligkeit*2;
for (i=0;i<anzahl;i++){
pl_array[i][0]=(pal_array[i][2]*helligkeit /255 )>> 2;
pl_array[i][1]=(pal_array[i][1]*helligkeit /255 )>> 2;
pl_array[i][2]=(pal_array[i][0]*helligkeit /255 )>> 2;
}
outp(0x3C8,0);
for (i=0;i<anzahl;i++){
outp(0x3C9,pl_array[i][0]);
outp(0x3C9,pl_array[i][1]);
outp(0x3C9,pl_array[i][2]);
}
helligkeit=merker;
}

void setpalettecolor (short int color,char rot, char gruen, char blau)
{
short int merker;

merker=helligkeit;
helligkeit=helligkeit*2;

pal_array[color][0]=(rot*helligkeit /255 )>> 2;
pal_array[color][1]=(gruen*helligkeit /255 )>> 2;
pal_array[color][2]=(blau*helligkeit /255 )>> 2;

outp(0x3C8,color);
outp(0x3C9,pal_array[color][0]);
outp(0x3C9,pal_array[color][1]);
outp(0x3C9,pal_array[color][2]);

helligkeit=merker;
}

void bar ( short int _x, short int _y, short int _breite, short int _hoehe, char _pixelfarbe)
{
short int _zeile,_laenge;

_laenge= _breite / 2;

#pragma aux bar_asm = \
"mov eax, bildbreite"\
"imul ax, _zeile"\
"add ax, _x"\
"mov bx, SegA000"\
"mov es, bx"\
"mov edi, OfsA000"\
"add edi, eax"\
"mov al, _pixelfarbe"\
"mov ah, al"\
"mov ecx, 0"\
"mov cx, _laenge"\
"rep stosw"\
modify [eax ebx ecx edi];

aktuelle_bank=-1;
for( _zeile = _y; _zeile < _y+_hoehe; _zeile ++) {
schreibbank_verwaltung(_zeile);
bar_asm();
}
}

void grafik_ein()
{
union REGS _regs;

_regs.h.ah = 0x00;
_regs.h.al = 0x13;
int386( 0x10, &_regs, &_regs);
delay(500);
_regs.h.ah = 0x4F;
_regs.h.al = 0x02;
_regs.w.bx = vesa_info.videomodus;
int386( 0x10, &_regs, &_regs);
_regs.h.ah = 0x4F;
_regs.h.al = 0x06;
_regs.h.bl = 0x00;
_regs.w.cx = 1024;
int386( 0x10, &_regs, &_regs);
}

void putvgapixelpart( short x1, short y1, short breite, short hoehe,short part_x1, short part_y1, short part_breite, short part_hoehe, int *pointer)
{

short qtsegment1;
int c2,qtoffset1;
short int zoffset2;
int zaehler,y;

#pragma aux put_partasm = \
"push es"\
"push ds"\
"mov esi,qtoffset1"\
"add esi,c2"\
"mov ax,qtsegment1"\
"mov ds,ax"\
"mov ax,SegA000"\
"mov es,ax"\
"mov edi,OfsA000"\
"add di,zoffset2"\
"mov ecx,zaehler"\
"rep movsd"\
"pop ds"\
"pop es"\
modify [ax ecx esi edi];

zaehler=part_breite/4;
if (breite % 4 !=0){
breite=breite+(4-(breite % 4));
}

qtsegment1=FP_SEG( pointer );
qtoffset1=FP_OFF( pointer );

for (y=y1;y<y1+part_hoehe-1;y++){
c2=breite*(y-y1+part_y1)+part_x1;
zoffset2=bildbreite*y+x1;
schreibbank_verwaltung(y);
put_partasm();
}
}

void putvgapixel( short x1, short y1, short breite, short hoehe, int *pointer)
{
short qtsegment1;
int c2,qtoffset1;
short int zoffset2;
int zaehler,y;

#pragma aux put_asm = \
"push es"\
"push ds"\
"mov esi,qtoffset1"\
"add esi,c2"\
"mov ax,qtsegment1"\
"mov ds,ax"\
"mov ax,SegA000"\
"mov es,ax"\
"mov edi,OfsA000"\
"add di,zoffset2"\
"mov ecx,zaehler"\
"rep movsd"\
"pop ds"\
"pop es"\
modify [ax ecx esi edi];

if (x1<0) x1=0;
if (y1<0) y1=0;
zaehler=breite/4;
if (breite % 4 !=0){
breite=breite+(4-(breite % 4));
}

qtsegment1=FP_SEG( pointer );
qtoffset1=FP_OFF( pointer );

for (y=y1;y<y1+hoehe-1;y++){
c2=breite*(y-y1);
zoffset2=bildbreite*y+x1;
schreibbank_verwaltung(y);
put_asm();
}
}

void loadBMPFile(short x, short y ,char *filename)
{
int *buffer;
int handle;
int size;
short int i1;

handle = open(filename,O_RDONLY | O_BINARY);
if( handle != -1 ) {
read(handle,&bmp_header,sizeof(bmp_header_));
lseek(handle,54,SEEK_SET);
for( i1 = 1; i1 < 256; i1 ++) {
read(handle,&pal_array[i1-1][0],3);
read(handle,&pal_res[i1-1],1);
}
lseek(handle,1024+54,SEEK_SET);
buffer = (int *)calloc( filelength(handle), sizeof(char));
if (buffer==NULL){
grafik_aus();
puts("FEHLER: Zu wenig freier Hauptspeicher");
exit( EXIT_FAILURE );
}
size=filelength(handle)-lseek(handle,0,SEEK_CUR);
_fmemset(buffer,0,bmp_header.xmax*bmp_header.ymax);
read(handle,buffer,size);
setpalette(252);
close( handle );
putvgapixel(x,y,bmp_header.xmax,bmp_header.ymax,buffer);
free(buffer);
}
}

void grafik_aus()
{
union REGS _regs;

_regs.h.ah = 0x00;
_regs.h.al = 0x13;
int386( 0x10, &_regs, &_regs);
delay(500);
_regs.h.ah = 0x00;
_regs.h.al = 0x03;
int386( 0x10, &_regs, &_regs);
}

void blendingalldown()
{
short int i;
for (i=0;i<100;i ++){
helligkeit=100-i;
delay(10);
if (kbhit()){ break;
}
setpalette(252);
}
}

void line ( short int x1, short int y1, short int x2, short int y2, char _pixelfarbe)
{
short int dx1,dy1,xa,ya;
unsigned short int n,maxn;

#pragma aux _asm1 = \
"mov ax, x2"\
"sub ax, x1"\
"mov dx1, ax"\
"mov ax, y2"\
"sub ax, y1"\
"mov dy1, ax"\
modify [eax];

_asm1();
maxn=abs(dx1);

if (maxn<abs(dy1)){
maxn=abs(dy1);
}
if (maxn==0){
maxn=maxn+1;
}

for( n = 0; n < maxn-1; n ++) {
#pragma aux bn_line_asm3 = \
"mov eax,bildbreite"\
"imul ax,ya"\
"add ax,xa"\
"mov bx,SegA000"\
"mov es,bx"\
"mov edi,OfsA000"\
"add edi,eax"\
"mov al,_pixelfarbe"\
"stosb"\
modify [eax ebx edi];
xa=x1+(dx1*n)/ maxn;
ya=y1+(dy1*n)/ maxn;
schreibbank_verwaltung(ya);
bn_line_asm3();
}
}

void getvgapixel( short x1, short y1, short breite, short hoehe, int *pointer)
{
short qtsegment1;
int c2,qtoffset1;
short int zoffset2;
int zaehler,y;

// extern far *get_asm( void );
#pragma aux get_asm = \
"push es"\
"push ds"\
"mov edi,qtoffset1"\
"add edi,c2"\
"mov ax,qtsegment1"\
"mov es,ax"\
"mov esi,OfsA000"\
"add si,zoffset2"\
"mov ecx,zaehler"\
"mov ax,SegA000"\
"mov ds,ax"\
"rep movsd"\
"pop ds"\
"pop es"\
modify [ax ecx esi edi];
if (x1<0) x1=0;
if (y1<0) y1=0;

zaehler=breite/4;
if (breite % 4 !=0){
breite=breite+(4-(breite % 4));
}

qtsegment1=FP_SEG( pointer );
qtoffset1=FP_OFF( pointer );

for (y=y1;y<y1+hoehe-1;y++){
c2=breite*(y-y1);
zoffset2=bildbreite*y+x1;
lesebank_verwaltung(y);
get_asm();
}
}

void blendingallup()
{
short int i;
for (i=0;i<100;i ++){
helligkeit=i;
delay(10);
if (kbhit()){ break;
}
setpalette(252);
}
}

void grafik_main()
{
int handle;

_ptr = (char *)SCREEN_LIN_ADDR;
SegA000=FP_SEG( _ptr );
OfsA000=FP_OFF( _ptr );

helligkeit=0;
bildbreite=1024;
puts("\nVESA-Treiber (C)opyright Bernd Noetscher 1997. Alle Rechte vorbehalten.\n");
delay(1000);
handle = open("GRAFIK.CFG",O_RDONLY | O_BINARY);
if( handle == -1 ) {
puts("FEHLER: GRAFIK.CFG nicht gefunden. Programm angehalten.\n");
exit( EXIT_FAILURE );
}
read(handle,&vesa_info, sizeof(vesa_info));
close( handle );
if (vesa_info.fensterAwrite==1) schreibfenster=0;
if (vesa_info.fensterBwrite==1) schreibfenster=1;
if (vesa_info.fensterAread==1) lesefenster=0;
if (vesa_info.fensterBread==1) lesefenster=1;
vesa_info.bankgranu=64/vesa_info.bankgranu;

aktuelle_bank=-1;
grafik_ein();
}

void warte(short int zeit)
{
short int schl;

for( schl = 0; schl < zeit*100; schl++ ) {
if( kbhit() ) {
getch();
break;
}
delay(10);
}
}



Soundblaster WAV

#include <i86.h>
#include <stdio.h>
#include <string.h>
#include <dos.h>
#include <stdlib.h>
#include <conio.h>
#include <malloc.h>
#include <share.h>
#include <io.h>
#include <sys\types.h>
#include <sys\stat.h>
#include <fcntl.h>

#define STANDARD=0;
#define SND_LOOP=1;

void wave_main();
void load_wavesound(char *filename, short int number);
void play_wavesound(short int number, short int soundattribsel);
void stop_wavesound();

struct wave_header_ {
int riff,filelaenge,wave,fmt_,laenge;
short int formatart,kanalanzahl;
int samplefrequenz,bytes_pro_sek;
short int bytes_pro_sample,format_specific;
int data,datenlaenge;
};

struct loaded_wave_ {
struct wave_header_ wave_header;
int *zeiger;
};

struct sounddat_{
char soundsel;
short int baseadress,irqnumber;
};

struct memdat_{
int freespace;
char dummy[126];
};

struct loaded_wave_ loaded_wave [30];
struct sounddat_ sounddat;
struct memdat_ memdat;
short int aktuelle_wave;
short int base;
short int irqnumber;
short int global_wert;
short int _i;
union REGS _regs;
struct SREGS _sregs;
short int phigh,plow;
void far *_p;
void far *_p2;
int _z;
int _wert;
int _bufferz;
char _sound_plays;
short int _soundattrib;
// short int _real_intseg;
// short int _real_intoff;
void (__interrupt __far *alt_int)();

char lowbyte(short int adresse)
{
return(adresse & 255);
}

char highbyte(short int adresse)
{
return((adresse>>8) & 255);
}

short int loword( int adresse_ptr)
{
return((adresse_ptr << 16)>>16);
}

short int hiword( int adresse_ptr)
{
return(adresse_ptr >>16);
}

short int lowword( int adresse_ptr)
{
unsigned int adresse;
adresse = ((unsigned int)loword(adresse_ptr)<<4)+hiword(adresse_ptr);
return (adresse & 0x0FFFF);
}

short int highword( int adresse_ptr)
{
unsigned int adresse;
adresse = ((unsigned int)loword(adresse_ptr)<<4)+hiword(adresse_ptr);
return (adresse >> 16);
}

char lies_dsp()
{
short int ende=0;
short int counter=0;
while (!ende)
{
counter++;
ende =(inp(base +0x0E) & 0x080);
if (counter == 10000)
{
printf("DSP Lesefehler!");
exit(1);
}
}
return(inp(base +0x0a));
}

void init_dsp()
{
short int ende=0;
short int counter=0;

outp(base+0x06,0x01);
delay(1);
outp(base+0x06,0x00);
while(!ende)
{
counter++;
ende=(lies_dsp() == 0x0aa);
if (counter==100)
{
printf("DSP-Reset Fehler!");
exit(1);
}
}
}

void schreib_dsp(char wert)
{
short int ende=0;
short int counter=0;
while(!ende)
{
counter++;
ende = !(inp(base +0x0c) & 0x080);
if (counter == 10000)
{
printf("DSP Schreibfehler!");
exit(1);
}
}
outp(base+0x0c,wert);
}

short int dma_until64kPage(int lpmem, short int usize)
{
int ladr,lpageend;
ladr=(((lpmem >> 16) << 4)+lpmem & 0xFFFF);
lpageend=ladr+0xFFFF;
lpageend=lpageend & 0xFFFF0000;
lpageend=lpageend-ladr;
if (lpageend>usize)
{
return(usize);
}
else
{
return(lpageend);
}
}

void dma_AllocMem(short int usize)
{
static usegment=0xFFFF;
short int uoldsegment[11];
short int schl,u;

plow=0x0;
phigh=0x0;

for( schl = 1; schl < 10; schl++ ) {
uoldsegment[schl]=0xFFFF;
}
schl=1;
while (schl<50){
_regs.w.ax = 0x100;
_regs.w.bx = usize/16;
int386( 0x31, &_regs, &_regs);
if( _regs.x.cflag ) {
printf("Kein DOS-Speicher allokierbar... Programmabbruch! %d",schl);
printf("vorh. Speicher: %d\n",_regs.w.bx);
}
phigh = _regs.w.ax;
plow = _regs.w.dx;
usegment=phigh;
uoldsegment[schl]=plow;
if (dma_until64kPage(usegment << 16,usize)==usize)
{
for( u = 1; u < schl-1; u++ ) {
_regs.w.ax = 0x101;
_regs.w.dx = uoldsegment[u];
int386( 0x31, &_regs, &_regs);
plow=plow;
phigh=usegment;
goto ende;
}
}
schl++;
}

ende:
schl++;
}

void load_wavesound(char *filename, short int number)
{
int handle;
int size;

handle = open(filename,O_RDONLY | O_BINARY);
if( handle != -1 ) {
read(handle,&loaded_wave[number].wave_header,sizeof(loaded_wave[number].wave_header));
size=filelength(handle)-lseek(handle,0,SEEK_CUR);
loaded_wave[number].zeiger = (int *)calloc(size, sizeof(char) );
read(handle,loaded_wave[number].zeiger,size);
close( handle );
}
}

extern far *clear_irq( void );
#pragma aux clear_irq = \
"cli"\
modify [ax];

extern far *set_irq( void );
#pragma aux set_irq = \
"sti"\
modify [ax];

void kill_wavesound(short int number)
{
free(loaded_wave[number].zeiger);
}

void stop_wavesound()
{
if (sounddat.soundsel==1){
_fmemset(_p,128,_i);
_fmemset(_p2,128,_i);
schreib_dsp(0xDA);
_dos_setvect( 0x0d , alt_int);
schreib_dsp(0xD3);
_soundattrib=0;
_sound_plays=0;
}
}

void __interrupt __far neu_int()
{
inp(base+0x0E);
_sound_plays=0;
if (_z<=loaded_wave[aktuelle_wave].wave_header.datenlaenge-_i)
{
_sound_plays=1;
if (_bufferz % 2 !=0)
{
movedata(FP_SEG(loaded_wave[aktuelle_wave].zeiger),
FP_OFF(loaded_wave[aktuelle_wave].zeiger)+_z,FP_SEG(_p2),FP_OFF(_p2),_i);
}
else
{
movedata(FP_SEG(loaded_wave[aktuelle_wave].zeiger),
FP_OFF(loaded_wave[aktuelle_wave].zeiger)+_z,FP_SEG(_p),FP_OFF(_p),_i);
}
}
else
{
if (_bufferz % 2 !=0) {
_fmemset(_p2,128,_i);
}
else
{
_fmemset(_p,128,_i);
}
}

_z=_z+_i;
_bufferz=_bufferz+1;
if (_z>loaded_wave[aktuelle_wave].wave_header.datenlaenge)
{
if (_soundattrib==1)
{ /*if SND_LOOP --> Sound wiederholen*/
_z=0;
if (_bufferz % 2 !=0)
{_bufferz=1;}
else{ _bufferz=0;}
}
}

outp(0x20,0x20);
}
void freier_speicher()
{
memset( &_sregs, 0, sizeof(_sregs) );
_regs.x.eax = 0x00000500;
_sregs.es = FP_SEG(&memdat);
_regs.x.edi = FP_OFF(&memdat);
int386x( 0x31, &_regs, &_regs, &_sregs);
if( _regs.x.cflag ) {
printf("DMPI-Fehler!(500) \n");
}
printf("Freier Speicher: %d \n",memdat.freespace);
}

void play_wavesound(short int number, short int soundattribsel)
{
short int timer_start;

if (sounddat.soundsel==1){
_sound_plays=1;
_soundattrib=soundattribsel;
_fmemset(_p,128,_i);
_fmemset(_p2,128,_i);
aktuelle_wave=number;
_bufferz=0;
_z=0;
outp(0x21,inp(0x21)|(1 << irqnumber));
clear_irq();
alt_int = _dos_getvect( 0x0d );
_dos_setvect( 0x0d , neu_int );
timer_start=(256-1000000/loaded_wave[aktuelle_wave].wave_header.bytes_pro_sek
*8/loaded_wave[aktuelle_wave].wave_header.format_specific);
outp(0x21,inp(0x21)&~(1 << irqnumber));
set_irq();
init_dsp();
outp(0x0D,0x0);
outp(0x0C,0x0);
outp(0x0A,0x5);
outp(0x0C,0x0);
outp(0x0B,0x59);
outp(0x0C,0x0);
outp(0x02,lowbyte(lowword(_wert)));
outp(0x02,highbyte(lowword(_wert)));
outp(0x83,highword(_wert));
outp(0x0C,0x0);
outp(0x03,lowbyte(_i*2-2));
outp(0x03,highbyte(_i*2-2));
outp(0x0A,0x01);
schreib_dsp(0xD1);
schreib_dsp(0x40);
schreib_dsp(timer_start);
schreib_dsp(0x48);
schreib_dsp(lowbyte(_i-1));
schreib_dsp(highbyte(_i-1));
schreib_dsp(0x1c);
}
}

void wave_main()
{
int handle;

puts("\nSoundblaster-Treiber (C)opyright Bernd Noetscher 1997. Alle Rechte vorbehalten.");
delay(1000);
handle = open("SOUND.CFG",O_RDONLY | O_BINARY);
if( handle == -1 ) {
puts("FEHLER: SOUND.CFG nicht gefunden. Programm angehalten.\n");
exit( EXIT_FAILURE );
}
read(handle,&sounddat,sizeof(sounddat));
close( handle );

if (sounddat.baseadress==210){base=0x210;}
if (sounddat.baseadress==220){base=0x220;}
if (sounddat.baseadress==230){base=0x230;}
if (sounddat.baseadress==240){base=0x240;}
if (sounddat.baseadress==250){base=0x250;}
if (sounddat.baseadress==260){base=0x260;}

irqnumber=sounddat.irqnumber;
_i=16384/2;
_z=0;
dma_AllocMem(_i*2);
_p = MK_FP ( plow ,0 );
_p2 = MK_FP ( plow ,_i );
_fmemset(_p,128,_i);
_fmemset(_p2,128,_i);
_wert=phigh;
_sound_plays=0;
}