![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gus.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [UNIX Amiga Emulator] / uae / src / md-i386-dos / sound|
Return to gus.c CVS log | Up to [UNIX Amiga Emulator] / uae / src / md-i386-dos / sound |
1.1 ! root 1: /* ! 2: * UAE - The Un*x Amiga Emulator ! 3: * ! 4: * DOS Gravis Ultrasound interface. ! 5: * ! 6: * Version 0.2 ! 7: * ! 8: * (c) 1996 Michael Sontheimer ! 9: * ! 10: * Please, do not change the code ! Write a email to me with the bugfix, ! 11: * the improvement or the suggestion. My email: [email protected] ! 12: * ! 13: */ ! 14: ! 15: ! 16: //#define DEBUG ! 17: ! 18: #include <stdlib.h> ! 19: #include <stdio.h> ! 20: #include <string.h> ! 21: #include <ctype.h> ! 22: #include <dos.h> ! 23: #include <pc.h> ! 24: #include <sys/farptr.h> ! 25: #include <dpmi.h> ! 26: #include <go32.h> ! 27: ! 28: ! 29: #include "sysconfig.h" ! 30: #include "sysdeps.h" ! 31: #include "sound/gus.h" ! 32: #include "sound/dma.h" ! 33: ! 34: ! 35: ! 36: #ifndef TRUE ! 37: #define TRUE 1 ! 38: #endif ! 39: #ifndef FALSE ! 40: #define FALSE 0 ! 41: #endif ! 42: ! 43: ! 44: // GUS Ports ! 45: ! 46: #define GUS_COMMAND 0x103 ! 47: #define GUS_DATAHI 0x105 ! 48: #define GUS_DATALO 0x104 ! 49: #define GUS_IRQSTATE 0x006 ! 50: #define GUS_TIMERCTRL 0x008 ! 51: #define GUS_TIMERDATA 0x009 ! 52: #define GUS_VOICE 0x102 ! 53: #define GUS_DRAM 0x107 ! 54: #define GUS_MIXER 0x000 ! 55: #define GUS_DMACTRL 0x00b // Beide Adressen sind identisch !!! ! 56: #define GUS_IRQCTRL 0x00b ! 57: #define GUS_REGISTERCTRL 0x00f ! 58: ! 59: // GUS Kommandos ! 60: ! 61: #define GUS_CMD_RESET 0x4c ! 62: #define GUS_CMD_DRAMDMACTRL 0x41 ! 63: #define GUS_CMD_DMASTARTADR 0x42 ! 64: #define GUS_CMD_DRAMIOADRLO 0x43 ! 65: #define GUS_CMD_DRAMIOADRHI 0x44 ! 66: #define GUS_CMD_TIMERCTRL 0x45 ! 67: #define GUS_CMD_COUNTER1 0x46 ! 68: #define GUS_CMD_COUNTER2 0x47 ! 69: #define GUS_CMD_SAMPLEFREQ 0x48 ! 70: #define GUS_CMD_SAMPLECTRL 0x49 ! 71: ! 72: #define GUS_CMD_VOICECTRLW 0x00 ! 73: #define GUS_CMD_FREQUCTRLW 0x01 ! 74: #define GUS_CMD_STARTHIW 0x02 ! 75: #define GUS_CMD_STARTLOW 0x03 ! 76: #define GUS_CMD_ENDHIW 0x04 ! 77: #define GUS_CMD_ENDLOW 0x05 ! 78: #define GUS_CMD_RAMPRATEW 0x06 ! 79: #define GUS_CMD_VOLUMEW 0x09 ! 80: #define GUS_CMD_CURRENTHIW 0x0a ! 81: #define GUS_CMD_CURRENTLOW 0x0b ! 82: #define GUS_CMD_PANPOSW 0x0c ! 83: #define GUS_CMD_VOLUMECTRLW 0x0d ! 84: #define GUS_CMD_ACTIVEVOICESW 0x0e ! 85: ! 86: #define GUS_CMD_VOICECTRLR 0x80 ! 87: #define GUS_CMD_FREQUCTRLR 0x81 ! 88: #define GUS_CMD_STARTHIR 0x82 ! 89: #define GUS_CMD_STARTLOR 0x83 ! 90: #define GUS_CMD_ENDHIR 0x84 ! 91: #define GUS_CMD_ENDLOR 0x85 ! 92: #define GUS_CMD_VOLUMER 0x89 ! 93: #define GUS_CMD_CURRENTHIR 0x8a ! 94: #define GUS_CMD_CURRENTLOR 0x8b ! 95: #define GUS_CMD_PANPOSR 0x8c ! 96: #define GUS_CMD_VOLUMECTRLR 0x8d ! 97: #define GUS_CMD_ACTIVEVOICESR 0x8e ! 98: #define GUS_CMD_IRQSOURCER 0x8f ! 99: ! 100: #define ADDR_HI(x) ((UWORD)((((ULONG)(x))>>7L)&0x1fffL)) ! 101: #define ADDR_LO(x) ((UWORD)((((ULONG)(x))&0x7fL)<<9L)) ! 102: ! 103: ! 104: #define LSW( x ) ((UWORD)(((ULONG)(x))&0xffffL)) ! 105: #define MSW( x ) ((UWORD)(((ULONG)(x))>>16L)) ! 106: #define LSB( x ) ((UBYTE)(((UWORD)(x))&0xffL)) ! 107: #define MSB( x ) ((UBYTE)(((UWORD)(x))>>8)) ! 108: #define CONVTO16B( x ) ((((x)>>1L)&0x0001ffffL)|((x)&0x000c0000L)) ! 109: #define NUMPARAS(bytesize) (((bytesize)+15) >> 4) ! 110: ! 111: ! 112: ! 113: // Variablen ! 114: ! 115: ! 116: UWORD uwGUSPort; ! 117: UBYTE ubGUSGF1Int; ! 118: UBYTE ubGUSMIDIInt; ! 119: UBYTE ubGUSDMA1; ! 120: UBYTE ubGUSDMA2; ! 121: UBYTE ubGUSUsedBits; // 0 if 8 bit or 4 if 16 bit ! 122: UWORD uwGUSUsedFreq; ! 123: UBYTE ubGUSGF1IRQVector; // Physikalischer Vektor des GF1 IRQ's ! 124: UBYTE *pGUSBuffer; // Zwischenpuffer ! 125: ULONG nGUSBufferWriteIndex; ! 126: ULONG nGUSBufferReadIndex; ! 127: ULONG ulBytesInBuffer; // Anzahl der Bytes im Puffer ! 128: ULONG ulGUSSndBufSize; ! 129: ULONG ulDMABufMaxSize; ! 130: ULONG ulFragSize; // Elementgroesse, die ich haben will ! 131: ! 132: int bIgnoreGF1IRQ=TRUE; ! 133: int bDMAInProgress=FALSE; ! 134: int bVoicesFast=FALSE; // Wird schneller abgespielt als normal ? ! 135: ! 136: ! 137: _go32_dpmi_seginfo old_pmintGF1; /* the old interrupt handler */ ! 138: _go32_dpmi_seginfo pm_wrapperGF1; /* the new interrupt handler */ ! 139: ! 140: UBYTE ubDummy; ! 141: ! 142: static __inline__ void WriteGUSb( UWORD uwReg, UBYTE ubByte ) ! 143: { ! 144: outportb( uwGUSPort+uwReg, ubByte ); ! 145: } ! 146: ! 147: static __inline__ UBYTE ReadGUSb( UWORD uwReg ) ! 148: { ! 149: return inportb( uwGUSPort+uwReg ); ! 150: } ! 151: ! 152: static __inline__ void WriteGUSw( UWORD uwReg, UWORD uwWord ) ! 153: { ! 154: outportw( uwGUSPort+uwReg, uwWord ); ! 155: } ! 156: ! 157: static __inline__ UWORD ReadGUSw( UWORD uwReg ) ! 158: { ! 159: return inportw( uwGUSPort+uwReg ); ! 160: } ! 161: ! 162: ! 163: _go32_dpmi_seginfo dma_mem; // Zeiger auf DMA-Speicher ! 164: ULONG dmabufadr; ! 165: ! 166: void GUS_GF1Delay( void ) ! 167: { ! 168: ! 169: int i; ! 170: ! 171: for( i=0; i<6; i++ ) ! 172: inportb( uwGUSPort+GUS_DATAHI ); ! 173: ! 174: ! 175: } ! 176: ! 177: /******************************* ! 178: ! 179: void GUS_Reset( UBYTE ubGUSDMA1, UBYTE ubGUSDMA2, ubGUSGF1Int ) ! 180: ! 181: *******************************/ ! 182: ! 183: void GUS_Reset( UBYTE ubGUSDMA1, UBYTE ubGUSDMA2, UBYTE ubGUSGF1Int ) ! 184: { ! 185: int i, j; ! 186: UBYTE nDMA, nInt; ! 187: ! 188: WriteGUSb( GUS_MIXER, 1|2 ); // Latches aus, Alle Aus/Eingaben aus ! 189: ! 190: // Reset ! 191: WriteGUSb( GUS_COMMAND, GUS_CMD_RESET ); ! 192: WriteGUSb( GUS_DATAHI, 0 ); ! 193: delay( 100 ); ! 194: WriteGUSb( GUS_COMMAND, GUS_CMD_RESET ); ! 195: WriteGUSb( GUS_DATAHI, 1 ); ! 196: delay( 100 ); ! 197: ! 198: // DMA Control Register reset ! 199: WriteGUSb( GUS_COMMAND, GUS_CMD_DRAMDMACTRL ); ! 200: WriteGUSb( GUS_DATAHI, 0 ); ! 201: delay( 10 ); ! 202: ! 203: // Timer Control Register ! 204: WriteGUSb( GUS_COMMAND, GUS_CMD_TIMERCTRL ); ! 205: WriteGUSb( GUS_DATAHI, 0 ); ! 206: delay( 10 ); ! 207: ! 208: // Sampling Control Register ! 209: WriteGUSb( GUS_COMMAND, GUS_CMD_SAMPLECTRL ); ! 210: WriteGUSb( GUS_DATAHI, 0 ); ! 211: delay( 10 ); ! 212: ! 213: // Number of Voices ! 214: WriteGUSb( GUS_COMMAND, GUS_CMD_ACTIVEVOICESW ); ! 215: WriteGUSb( GUS_DATAHI, 0xc0 | (14-1) ); // 14 Voices (left/right) ! 216: ! 217: // Evtl. anstehende DMA-IRQ's holen ! 218: ReadGUSb( GUS_IRQSTATE ); ! 219: WriteGUSb( GUS_COMMAND, GUS_CMD_DRAMDMACTRL ); ! 220: ReadGUSb( GUS_DATAHI ); ! 221: ! 222: // Evtl. Sampleinterrupts lesen ! 223: WriteGUSb( GUS_COMMAND, GUS_CMD_SAMPLECTRL ); ! 224: ReadGUSb( GUS_DATAHI ); ! 225: ! 226: // IRQ-Status lesen ! 227: WriteGUSb( GUS_COMMAND, GUS_CMD_IRQSOURCER ); ! 228: ReadGUSb( GUS_DATAHI ); ! 229: ! 230: // Alle Stimmen abschalten ! 231: ! 232: for( i=0; i<32; i++ ) ! 233: { ! 234: WriteGUSb( GUS_VOICE, (UBYTE)i ); ! 235: WriteGUSb( GUS_COMMAND, GUS_CMD_VOICECTRLW ); ! 236: WriteGUSb( GUS_DATAHI, 3 ); // Stimme stoppen ! 237: WriteGUSb( GUS_COMMAND, GUS_CMD_VOLUMECTRLW ); ! 238: WriteGUSb( GUS_DATAHI, 3 ); // Lautstaerke 0 ! 239: WriteGUSb( GUS_COMMAND, GUS_CMD_RAMPRATEW ); ! 240: WriteGUSb( GUS_DATAHI, 0 ); // Ramp 0 ! 241: ! 242: } ! 243: ! 244: // Evtl. anstehende DMA-IRQ's holen ! 245: ReadGUSb( GUS_IRQSTATE ); ! 246: WriteGUSb( GUS_COMMAND, GUS_CMD_DRAMDMACTRL ); ! 247: ReadGUSb( GUS_DATAHI ); ! 248: ! 249: // Evtl. Sampleinterrupts lesen ! 250: WriteGUSb( GUS_COMMAND, GUS_CMD_SAMPLECTRL ); ! 251: ReadGUSb( GUS_DATAHI ); ! 252: ! 253: // IRQ-Status lesen ! 254: WriteGUSb( GUS_COMMAND, GUS_CMD_IRQSOURCER ); ! 255: ReadGUSb( GUS_DATAHI ); ! 256: ! 257: ! 258: // Reset beenden und GF1 Master IRQ einschalten ! 259: WriteGUSb( GUS_COMMAND, GUS_CMD_RESET ); ! 260: WriteGUSb( GUS_DATAHI, 7 ); ! 261: ! 262: ! 263: if( ubGUSDMA1 == 0 ) // IRQ's und DMA einstellen ? ! 264: return; // Nein, dann Ende ! 265: ! 266: ! 267: // Digital ASIC einstellen ! 268: ! 269: WriteGUSb( GUS_REGISTERCTRL, 5 ); // IRQ's-Register waehlen ! 270: WriteGUSb( GUS_MIXER, 1|2 ); // Alles Abschalten ! 271: WriteGUSb( GUS_IRQCTRL, 0 ); // IRQ's loeschen ! 272: WriteGUSb( GUS_REGISTERCTRL, 0 ); // Alte Registerkonfig wieder einschalten ! 273: ! 274: // DMA selektieren ! 275: ! 276: nDMA=0; ! 277: for( j=0; j<2; j++ ) ! 278: { ! 279: switch( ((j!=0)?(ubGUSDMA1):(ubGUSDMA2)) ) ! 280: { ! 281: case 1: ! 282: nDMA |= 1; ! 283: break; ! 284: case 3: ! 285: nDMA |= 2; ! 286: break; ! 287: case 5: ! 288: nDMA |= 3; ! 289: break; ! 290: case 6: ! 291: nDMA |= 4; ! 292: break; ! 293: case 7: ! 294: nDMA |= 5; ! 295: break; ! 296: } ! 297: if( j==0 ) ! 298: nDMA=nDMA<<3; ! 299: } ! 300: ! 301: if( ubGUSDMA1 == ubGUSDMA2 ) // Gleichen DMA fuer beides ? ! 302: nDMA = (nDMA&0x3)|(1<<6); ! 303: ! 304: ! 305: // Interrupt der GUS setzen ! 306: ! 307: nInt=0; ! 308: for( j=0; j<2; j++ ) ! 309: { ! 310: switch( (j!=0)?(ubGUSGF1Int):(ubGUSMIDIInt) ) ! 311: { ! 312: case 2: ! 313: nInt |= 1; ! 314: break; ! 315: case 5: ! 316: nInt |= 2; ! 317: break; ! 318: case 3: ! 319: nInt |= 3; ! 320: break; ! 321: case 7: ! 322: nInt |= 4; ! 323: break; ! 324: case 11: ! 325: nInt |= 5; ! 326: break; ! 327: case 12: ! 328: nInt |= 6; ! 329: break; ! 330: case 15: ! 331: nInt |= 7; ! 332: break; ! 333: } ! 334: if( j==0 ) ! 335: nInt=nInt<<3; ! 336: } ! 337: ! 338: if( ubGUSGF1Int == ubGUSMIDIInt ) ! 339: nInt = (nInt&0x3)|(1<<6); ! 340: ! 341: ! 342: ! 343: disable(); ! 344: ! 345: WriteGUSb( GUS_MIXER, 1|2 ); // DMA-Einstellung aktivieren ! 346: WriteGUSb( GUS_DMACTRL, nDMA | 0x80 ); // DMA-Kanal selektieren, welcher im SET angegebe wurde ! 347: ! 348: ! 349: WriteGUSb( GUS_MIXER, 1|2|64 ); // IRQ's selektieren ! 350: WriteGUSb( GUS_IRQCTRL, nInt ); ! 351: ! 352: WriteGUSb( GUS_MIXER, 1|2 ); // DMA-Einstellung aktivieren ! 353: WriteGUSb( GUS_DMACTRL, nDMA ); // DMA-Kanal selektieren, welcher im SET angegebe wurde ! 354: ! 355: WriteGUSb( GUS_MIXER, 1|2|64 ); // IRQ's selektieren ! 356: WriteGUSb( GUS_IRQCTRL, nInt ); ! 357: ! 358: enable(); ! 359: ! 360: // IRQ/DMA locken ! 361: ! 362: WriteGUSb( GUS_VOICE, 0 ); ! 363: ! 364: WriteGUSb( GUS_MIXER, 8 | ((ubGUSGF1Int==ubGUSMIDIInt)?16:0 ) ); ! 365: ! 366: WriteGUSb( GUS_VOICE, 0 ); ! 367: ! 368: ! 369: ! 370: } ! 371: ! 372: ! 373: ! 374: /******************************* ! 375: ! 376: int GUS_Init( void ) ! 377: ! 378: *******************************/ ! 379: ! 380: int GUS_Init( int *dspbits, int *rate, int *sndbufsize ) ! 381: { ! 382: ! 383: char *szGUSENVStr, *pz; ! 384: int i, j; ! 385: extern void (*SND_Write)(void *buf, unsigned long size); ! 386: ! 387: ! 388: ! 389: szGUSENVStr = getenv( "ULTRASND" ); ! 390: if( szGUSENVStr == 0 ) ! 391: return 0; ! 392: ! 393: ! 394: if( (*dspbits != 8 ) && (*dspbits != 16 ) ) ! 395: { ! 396: printf( "%d bits are not supported on the GUS !\n", dspbits ); ! 397: return 0; ! 398: } ! 399: ! 400: ! 401: ubGUSUsedBits = (*dspbits==8)?0:4; ! 402: ! 403: if( (*rate < 1000) || (*rate > 44100 )) ! 404: { ! 405: fprintf( stderr, "%dHz are not supported on the GUS !\n", *rate ); ! 406: return 0; ! 407: } ! 408: ! 409: uwGUSUsedFreq = *rate; ! 410: ! 411: // Some settings for different depths and frequencies ! 412: ! 413: ! 414: if( uwGUSUsedFreq <= 12000 ) ! 415: { ! 416: ulDMABufMaxSize = 2048; ! 417: ulGUSSndBufSize = 32768; ! 418: } ! 419: else ! 420: { ! 421: if( uwGUSUsedFreq <= 24000 ) ! 422: { ! 423: ulDMABufMaxSize = 4096; ! 424: ulGUSSndBufSize = 65536; ! 425: } ! 426: else ! 427: { ! 428: ulDMABufMaxSize = 8192; ! 429: ulGUSSndBufSize = 128*1024; ! 430: } ! 431: } ! 432: ! 433: if( ubGUSUsedBits == 0 ) ! 434: { ! 435: *sndbufsize = 256; // 256 bytes, wenn 8 Bit ! 436: } ! 437: else ! 438: { ! 439: *sndbufsize = 512; ! 440: ulDMABufMaxSize *= 2; // Double it, if 16 bit ! 441: ulGUSSndBufSize *= 2; ! 442: } ! 443: ! 444: fprintf( stderr, "GUS configured for %d bits, %d Hz\n", *dspbits, *rate ); ! 445: fprintf( stderr, "Soundbuffersize: %d bytes\n", ulGUSSndBufSize ); ! 446: fprintf( stderr, "DMA-buffersize: %d bytes\n", ulDMABufMaxSize ); ! 447: fprintf( stderr, "Fragmentsize: %d bytes\n", *sndbufsize ); ! 448: ! 449: ! 450: uwGUSPort = (UWORD)strtol( szGUSENVStr, (char **)NULL, 16 ); ! 451: pz = strchr( szGUSENVStr, ',' ); ! 452: if( (pz == 0) || (uwGUSPort ==0) ) ! 453: return 0; ! 454: ! 455: ubGUSDMA1 = (UBYTE)atol( pz+1 ); ! 456: pz = strchr( pz+1, ',' ); ! 457: if( pz == 0 ) ! 458: return 0; ! 459: ! 460: ubGUSDMA2 = (UBYTE)atol( pz+1 ); ! 461: ! 462: pz = strchr( pz+1, ',' ); ! 463: if( pz == 0 ) ! 464: return 0; ! 465: ! 466: ubGUSGF1Int = (UBYTE)atol( pz+1 ); ! 467: if( ubGUSGF1Int == 0 ) ! 468: return 0; ! 469: ! 470: pz = strchr( pz+1, ',' ); ! 471: if( pz == 0 ) ! 472: return 0; ! 473: ! 474: ubGUSMIDIInt = (UBYTE)atol( pz+1 ); ! 475: if( ubGUSMIDIInt == 0 ) ! 476: return 0; ! 477: ! 478: // Speicher fuer DMA holen ! 479: ! 480: ! 481: memset( &dma_mem, 0, sizeof( _go32_dpmi_seginfo ) ); ! 482: dma_mem.size = NUMPARAS( ulDMABufMaxSize+1000 ); ! 483: dmabufadr = DMA_AllocDMABuf( &dma_mem ); ! 484: ! 485: ! 486: _go32_dpmi_lock_code( GUS_PlayBuffer, (ULONG)GUS_DummyFunc - (ULONG)GUS_PlayBuffer); ! 487: _go32_dpmi_lock_data( &uwGUSPort, (ULONG)&ubDummy - (ULONG)&uwGUSPort); ! 488: ! 489: ! 490: if( dmabufadr == NULL) ! 491: { ! 492: fprintf( stderr, "Cannot allocate DOS memory for DMA buffers!\n" ); ! 493: return 0; ! 494: } ! 495: ! 496: ! 497: // Zwischenpuffer allokieren ! 498: ! 499: pGUSBuffer = (UBYTE *)malloc( ulGUSSndBufSize+1000 ); ! 500: if( pGUSBuffer == 0 ) ! 501: { ! 502: fprintf( stderr, "Cannot allocate soundbuffer !\n" ); ! 503: return 0; ! 504: } ! 505: ! 506: nGUSBufferWriteIndex = nGUSBufferReadIndex = ulBytesInBuffer = 0; ! 507: ! 508: // GUS-Reset ! 509: ! 510: GUS_Reset( ubGUSDMA1, ubGUSDMA2, ubGUSGF1Int ); ! 511: ! 512: ! 513: // Test, ob wir in das GUS-RAM etwas schreiben koennen ! 514: ! 515: WriteGUSb( GUS_COMMAND, GUS_CMD_DRAMIOADRLO ); ! 516: WriteGUSw( GUS_DATALO, 0 ); ! 517: WriteGUSb( GUS_COMMAND, GUS_CMD_DRAMIOADRHI ); ! 518: WriteGUSw( GUS_DATAHI, 0 ); ! 519: ! 520: WriteGUSb( GUS_DRAM, 0x15 ); ! 521: delay( 100 ); ! 522: if( ReadGUSb( GUS_DRAM ) != 0x15 ) // Bytes unterschiedlich ? ! 523: return 0; ! 524: ! 525: // GUS-RAM loeschen ! 526: ! 527: j=-1; ! 528: for( i=0; i<(int)(ulDMABufMaxSize*2+1000); i++ ) ! 529: { ! 530: if( j != MSW(i) ) // Muss das Highword veraendert werden `? ! 531: { ! 532: j = MSW(i); ! 533: ! 534: WriteGUSb( GUS_COMMAND, GUS_CMD_DRAMIOADRHI ); ! 535: WriteGUSw( GUS_DATALO, MSW( i ) ); ! 536: } ! 537: ! 538: WriteGUSb( GUS_COMMAND, GUS_CMD_DRAMIOADRLO ); ! 539: WriteGUSw( GUS_DATALO, LSW( i ) ); ! 540: ! 541: WriteGUSb( GUS_DRAM, 0 ); ! 542: ! 543: } ! 544: ! 545: ! 546: // Interrupthandler installieren ! 547: ! 548: memset( &pm_wrapperGF1, 0, sizeof( _go32_dpmi_seginfo ) ); ! 549: pm_wrapperGF1.pm_offset = (int) GUS_GF1InterruptHandler; ! 550: if(_go32_dpmi_allocate_iret_wrapper( &pm_wrapperGF1 ) ) ! 551: { ! 552: fprintf( stderr, "Cannot allocate protected mode wrapper for GUS interrupt!\n"); ! 553: if( dmabufadr != 0 ) ! 554: _go32_dpmi_free_dos_memory( &dma_mem ); ! 555: ! 556: return 0; ! 557: } ! 558: ! 559: ! 560: ubGUSGF1IRQVector = (ubGUSGF1Int>7)?(ubGUSGF1Int+0x68):(ubGUSGF1Int+0x08); // Physik. Vektor berechnen ! 561: ! 562: _go32_dpmi_get_protected_mode_interrupt_vector( ubGUSGF1IRQVector, &old_pmintGF1 ); // Alten Interrupt merken ! 563: _go32_dpmi_set_protected_mode_interrupt_vector( ubGUSGF1IRQVector, &pm_wrapperGF1 ); // Neuen Interrupt merken ! 564: ! 565: ! 566: // Interrupt erlauben ! 567: ! 568: if( ubGUSGF1Int > 7 ) ! 569: { ! 570: outportb( 0xA1, inportb( 0xA1 ) & ~(1 << ( ubGUSGF1Int-8 ) ) ); ! 571: outportb( 0xA0, 0x20 ); ! 572: } ! 573: else ! 574: { ! 575: outportb( 0x21, inportb( 0x21 ) & ~(1 << ubGUSGF1Int)); ! 576: outportb( 0x20, 0x20 ); ! 577: } ! 578: ! 579: ! 580: // Hier wird die Stimme zum erstenmal gestertet ! 581: ! 582: ! 583: WriteGUSb( GUS_VOICE, 0 ); // Stimme0 ! 584: ! 585: WriteGUSb( GUS_COMMAND, GUS_CMD_VOLUMEW ); // Lautstaerke auf Maximum ! 586: WriteGUSw( GUS_DATALO, 61247 ); ! 587: ! 588: WriteGUSb( GUS_COMMAND, GUS_CMD_FREQUCTRLW ); // 14 Stimmen = x / 43! ! 589: WriteGUSw( GUS_DATALO, uwGUSUsedFreq/43 ); ! 590: ! 591: ! 592: WriteGUSb( GUS_COMMAND, GUS_CMD_CURRENTLOW ); // Current ! 593: WriteGUSw( GUS_DATALO, 32 ); ! 594: WriteGUSb( GUS_COMMAND, GUS_CMD_CURRENTHIW ); ! 595: WriteGUSw( GUS_DATALO, 0 ); ! 596: ! 597: WriteGUSb( GUS_COMMAND, GUS_CMD_STARTHIW ); // Start ! 598: WriteGUSw( GUS_DATALO, 0 ); ! 599: WriteGUSb( GUS_COMMAND, GUS_CMD_STARTLOW ); ! 600: WriteGUSw( GUS_DATALO, 32 ); ! 601: ! 602: if( ubGUSUsedBits == 0 ) // 8 oder 16 Bit ? ! 603: { ! 604: WriteGUSb( GUS_COMMAND, GUS_CMD_ENDHIW ); // Ende setzen ! 605: WriteGUSw( GUS_DATALO, ADDR_HI( ulDMABufMaxSize+32 ) ); ! 606: WriteGUSb( GUS_COMMAND, GUS_CMD_ENDLOW ); ! 607: WriteGUSw( GUS_DATALO, ADDR_LO( ulDMABufMaxSize+32 ) ); ! 608: } ! 609: else ! 610: { ! 611: WriteGUSb( GUS_COMMAND, GUS_CMD_ENDHIW ); // Ende ! 612: WriteGUSw( GUS_DATALO, ADDR_HI( CONVTO16B( ulDMABufMaxSize+32 ) ) ); ! 613: WriteGUSb( GUS_COMMAND, GUS_CMD_ENDLOW ); ! 614: WriteGUSw( GUS_DATALO, ADDR_LO( CONVTO16B( ulDMABufMaxSize+32 ) ) ); ! 615: } ! 616: ! 617: WriteGUSb( GUS_COMMAND, GUS_CMD_VOLUMECTRLW ); ! 618: WriteGUSb( GUS_DATAHI, 3|4 ); ! 619: GUS_GF1Delay(); ! 620: WriteGUSb( GUS_DATAHI, 3|4 ); // Rollover an ! 621: ! 622: ! 623: WriteGUSb( GUS_COMMAND, GUS_CMD_VOICECTRLW ); ! 624: WriteGUSb( GUS_DATAHI, 32|ubGUSUsedBits ); ! 625: GUS_GF1Delay(); ! 626: WriteGUSb( GUS_DATAHI, 32|ubGUSUsedBits ); // Stimme starten, Loop aus ! 627: ! 628: ! 629: bIgnoreGF1IRQ = FALSE; ! 630: ! 631: ! 632: // GUS-Initialisierung beendet, puhhh ! 633: ! 634: fprintf( stderr, "GUS found at port: %Xh, dma1: %d, dma2: %d, GF1-int: %d, MIDI-int: %d\n", uwGUSPort, ubGUSDMA1, ubGUSDMA2, ubGUSGF1Int, ubGUSMIDIInt ); ! 635: ! 636: ! 637: atexit( GUS_Cleanup ); ! 638: ! 639: ! 640: SND_Write = GUS_PlayBuffer; ! 641: ! 642: ! 643: return 1; ! 644: ! 645: } ! 646: ! 647: ! 648: /******************************* ! 649: ! 650: int GUS_Cleanup( void ) ! 651: ! 652: *******************************/ ! 653: ! 654: ! 655: void GUS_Cleanup( void ) ! 656: { ! 657: ! 658: ! 659: fprintf( stderr, "Freeing up all GUS-stuff\n" ); ! 660: ! 661: // Warten, bis DMA beendet ist ! 662: ! 663: if( bDMAInProgress == TRUE ) ! 664: { ! 665: do ! 666: { ! 667: delay( 10 ); ! 668: } ! 669: while( bDMAInProgress == TRUE ); ! 670: } ! 671: ! 672: ! 673: // Stimmen anhalten ! 674: ! 675: WriteGUSb( GUS_VOICE, 0 ); ! 676: ! 677: WriteGUSb( GUS_COMMAND, GUS_CMD_VOLUMECTRLW ); ! 678: WriteGUSb( GUS_DATAHI, 3 ); ! 679: GUS_GF1Delay(); ! 680: WriteGUSb( GUS_DATAHI, 3 ); ! 681: ! 682: ! 683: WriteGUSb( GUS_COMMAND, GUS_CMD_VOICECTRLW ); ! 684: WriteGUSb( GUS_DATAHI, 3 ); ! 685: GUS_GF1Delay(); ! 686: WriteGUSb( GUS_DATAHI, 3 ); ! 687: ! 688: // GUS resetten ! 689: ! 690: GUS_Reset( 0, 0, 0 ); ! 691: ! 692: // Interrupts wieder sperren ! 693: ! 694: if( ubGUSGF1Int > 7 ) ! 695: outportb (0xA1, inportb(0xA1) | (1 << (ubGUSGF1Int-8))); ! 696: else ! 697: outportb (0x21, inportb(0x21) | (1 << ubGUSGF1Int)); ! 698: ! 699: _go32_dpmi_set_protected_mode_interrupt_vector( ubGUSGF1IRQVector, &old_pmintGF1 ); ! 700: _go32_dpmi_free_iret_wrapper( &pm_wrapperGF1 ); ! 701: ! 702: ! 703: // Speicher freigeben ! 704: ! 705: if( pGUSBuffer != 0 ) ! 706: free( pGUSBuffer ); ! 707: ! 708: if( dmabufadr != 0 ) ! 709: _go32_dpmi_free_dos_memory( &dma_mem ); // Speicher fuer DMA freigeben ! 710: ! 711: GUS_Reset( 0, 0, 0 ); ! 712: ! 713: } ! 714: ! 715: /******************************* ! 716: ! 717: void GUS_PlayBuffer( void *buf, unsigned long size ) ! 718: ! 719: *******************************/ ! 720: ! 721: ! 722: // Diese Routine wird vom UAE aufgerufen, wenn der Soundbuffer ! 723: // zu leeren ist ! 724: ! 725: ! 726: void GUS_PlayBuffer( void *buf, unsigned long size ) ! 727: { ! 728: ULONG i; ! 729: ! 730: ! 731: ! 732: disable(); ! 733: ! 734: // Daten in den GUS-Buffer kopieren ! 735: ! 736: if( size+ulBytesInBuffer>ulGUSSndBufSize ) ! 737: { ! 738: fprintf( stderr, "Error: GUS-soundbuffer overflow !\n" ); ! 739: } ! 740: else ! 741: { ! 742: // Better playing the voice faster than getting an overflow ! ! 743: ! 744: if( (ulBytesInBuffer> (ulGUSSndBufSize/2+ulGUSSndBufSize/4) ) ! 745: && (bVoicesFast == TRUE ) ) ! 746: // Is the Buffer going ! 747: { // to overflow ? ! 748: ! 749: // fprintf( stderr, "Warping voice up ... (scotty, I need more power)\n" ); ! 750: ! 751: ! 752: WriteGUSb( GUS_VOICE, 0 ); ! 753: ! 754: WriteGUSb( GUS_COMMAND, GUS_CMD_FREQUCTRLW ); ! 755: WriteGUSw( GUS_DATALO, (uwGUSUsedFreq+(uwGUSUsedFreq>>2))/43 ); // 25% faster ! 756: } ! 757: ! 758: if( (ulBytesInBuffer> ulGUSSndBufSize/2 ) ! 759: && (bVoicesFast == FALSE ) ) ! 760: // Is the Buffer going ! 761: { // to overflow ? ! 762: ! 763: // fprintf( stderr, "Speeding voice up ...\n" ); ! 764: ! 765: ! 766: WriteGUSb( GUS_VOICE, 0 ); ! 767: ! 768: WriteGUSb( GUS_COMMAND, GUS_CMD_FREQUCTRLW ); ! 769: WriteGUSw( GUS_DATALO, (uwGUSUsedFreq+uwGUSUsedFreq/10)/43 ); // 10% faster ! 770: ! 771: ! 772: bVoicesFast = TRUE; ! 773: ! 774: } ! 775: ! 776: if( (bVoicesFast == TRUE) && (ulBytesInBuffer < ulGUSSndBufSize/4 ) ) ! 777: { ! 778: // fprintf( stderr, "Slowing voice down to normal speed\n" ); ! 779: ! 780: WriteGUSb( GUS_VOICE, 0 ); ! 781: ! 782: WriteGUSb( GUS_COMMAND, GUS_CMD_FREQUCTRLW ); ! 783: WriteGUSw( GUS_DATALO, uwGUSUsedFreq/43 ); // Normal speed ! 784: ! 785: bVoicesFast = FALSE; ! 786: ! 787: ! 788: } ! 789: ! 790: ! 791: // GUS-Buffer fuellen ! 792: ! 793: // Koennen wir auf einmal kopieren ? ! 794: ! 795: i = ulGUSSndBufSize-nGUSBufferWriteIndex; ! 796: if( i < size ) ! 797: { ! 798: memcpy( pGUSBuffer+nGUSBufferWriteIndex, buf, i ); ! 799: ! 800: memcpy( pGUSBuffer, ((UBYTE*)buf)+i, size-i ); ! 801: ! 802: } ! 803: else ! 804: { ! 805: memcpy( pGUSBuffer+nGUSBufferWriteIndex, buf, size ); ! 806: } ! 807: ! 808: nGUSBufferWriteIndex = (nGUSBufferWriteIndex+size)&(ulGUSSndBufSize-1); ! 809: ! 810: ulBytesInBuffer += size; ! 811: ! 812: } ! 813: ! 814: enable(); ! 815: ! 816: } ! 817: ! 818: ! 819: /******************************* ! 820: ! 821: void GUS_StartDMA( ULONG ulPosInGUSRAM ) ! 822: ! 823: *******************************/ ! 824: ! 825: ! 826: ! 827: void GUS_StartDMA( ULONG ulPosInGUSRAM, int bLoop ) ! 828: { ! 829: ! 830: ULONG i, pDMABuf, j; ! 831: ULONG ulTemp; ! 832: ! 833: // I hope, everything is aligned to 4 byte (32bit), otherwise ! 834: // the machine my crash :( ! 835: ! 836: ! 837: if( bDMAInProgress == TRUE ) ! 838: { ! 839: fprintf( stderr, "Error in StartDMA, DMA already im progress !\n" ); ! 840: return; ! 841: } ! 842: ! 843: bDMAInProgress=TRUE; ! 844: ! 845: // Kopiert die Daten aus dem Soundbuffer in den DMA-Puffer ! 846: ! 847: ! 848: _farsetsel( _dos_ds ); ! 849: ! 850: if( ulBytesInBuffer == 0 ) // Sind ueberhaupt Daten im Puffer ? ! 851: { // Nein, dann DMA-Buffer loeschen ! 852: pDMABuf = dmabufadr; ! 853: ! 854: if( ubGUSUsedBits == 0 ) // 8 Bit ? ! 855: ulTemp = 0x80808080; ! 856: else ! 857: ulTemp = 0; ! 858: ! 859: for( i=ulDMABufMaxSize/4; i>0; i-- ) ! 860: { ! 861: _farnspokel( pDMABuf, ulTemp ); ! 862: pDMABuf+=4; ! 863: } ! 864: ! 865: } ! 866: else ! 867: { ! 868: if( ulBytesInBuffer >= ulDMABufMaxSize ) // Sind mehr Daten da, als ! 869: { // der Puffer gross ist ? ! 870: ! 871: pDMABuf = dmabufadr; // Ja, DMA-Puffer vollmachen ! 872: ! 873: j = nGUSBufferReadIndex; ! 874: for( i=ulDMABufMaxSize/4; i>0; i-- ) ! 875: { ! 876: _farnspokel( pDMABuf, *((ULONG*)(pGUSBuffer+j)) ); // 32 bit-copy ! 877: pDMABuf+=4; ! 878: j = (j+4)&(ulGUSSndBufSize-1); ! 879: } ! 880: ! 881: nGUSBufferReadIndex = (nGUSBufferReadIndex+ulDMABufMaxSize)&(ulGUSSndBufSize-1); ! 882: ! 883: ulBytesInBuffer -= ulDMABufMaxSize; ! 884: } ! 885: else ! 886: { ! 887: pDMABuf = dmabufadr; // Nein, nur den vorhanden Teil ! 888: // kopieren ! 889: ! 890: j = nGUSBufferReadIndex; ! 891: for( i=ulBytesInBuffer/4; i>0; i-- ) ! 892: { ! 893: _farnspokel( pDMABuf, *((ULONG*)(pGUSBuffer+j)) ); ! 894: pDMABuf+=4; ! 895: j = (j+4)&(ulGUSSndBufSize-1); ! 896: } ! 897: nGUSBufferReadIndex = (nGUSBufferReadIndex+ulBytesInBuffer)&(ulGUSSndBufSize-1); ! 898: ! 899: ! 900: if( ubGUSUsedBits == 0 ) // 8 Bit ? ! 901: ulTemp = 0x80808080; ! 902: else ! 903: ulTemp = 0; ! 904: ! 905: ! 906: for( i=(ulDMABufMaxSize-ulBytesInBuffer)/4; i>0; i-- ) ! 907: { ! 908: _farnspokel( pDMABuf, ulTemp ); ! 909: pDMABuf+=4; ! 910: } ! 911: ! 912: ! 913: ulBytesInBuffer = 0; ! 914: } ! 915: ! 916: } ! 917: ! 918: ! 919: if( bLoop == TRUE ) // Byte/Word kopieren, um das Geklicke zu verhindern ? ! 920: { ! 921: ! 922: if( ubGUSUsedBits == 0 ) // 8 Bit ? ! 923: { ! 924: ! 925: WriteGUSb( GUS_COMMAND, GUS_CMD_DRAMIOADRHI ); ! 926: WriteGUSw( GUS_DATALO, MSW( ulPosInGUSRAM-ulDMABufMaxSize-1 ) ); ! 927: ! 928: WriteGUSb( GUS_COMMAND, GUS_CMD_DRAMIOADRLO ); ! 929: WriteGUSw( GUS_DATALO, LSW( ulPosInGUSRAM-ulDMABufMaxSize-1 ) ); ! 930: ! 931: WriteGUSb( GUS_DRAM, _farnspeekb( dmabufadr+ulDMABufMaxSize-1 )+0x80 ); ! 932: ! 933: } ! 934: else ! 935: { ! 936: WriteGUSb( GUS_COMMAND, GUS_CMD_DRAMIOADRHI ); ! 937: WriteGUSw( GUS_DATALO, MSW( ulPosInGUSRAM-ulDMABufMaxSize-2 ) ); ! 938: ! 939: WriteGUSb( GUS_COMMAND, GUS_CMD_DRAMIOADRLO ); ! 940: WriteGUSw( GUS_DATALO, LSW( ulPosInGUSRAM-ulDMABufMaxSize-2 ) ); ! 941: ! 942: WriteGUSb( GUS_DRAM, _farnspeekb( dmabufadr+ulDMABufMaxSize-2 ) ); ! 943: ! 944: WriteGUSb( GUS_COMMAND, GUS_CMD_DRAMIOADRHI ); ! 945: WriteGUSw( GUS_DATALO, MSW( ulPosInGUSRAM-ulDMABufMaxSize-1 ) ); ! 946: ! 947: WriteGUSb( GUS_COMMAND, GUS_CMD_DRAMIOADRLO ); ! 948: WriteGUSw( GUS_DATALO, LSW( ulPosInGUSRAM-ulDMABufMaxSize-1 ) ); ! 949: ! 950: WriteGUSb( GUS_DRAM, _farnspeekb( dmabufadr+ulDMABufMaxSize-1 ) ); ! 951: ! 952: } ! 953: ! 954: } ! 955: ! 956: ! 957: // DMA-Controller initialisieren ! 958: DMA_InitTransfer( ubGUSDMA1, DMA_READ, dmabufadr, ulDMABufMaxSize ); ! 959: ! 960: // GUS-Register initialisieren ! 961: WriteGUSb( GUS_COMMAND, GUS_CMD_DMASTARTADR ); ! 962: if( ubGUSDMA1>3 ) ! 963: WriteGUSw( GUS_DATALO, CONVTO16B(ulPosInGUSRAM>>4) ); // Adresse>>4 !!!! ! 964: else ! 965: WriteGUSw( GUS_DATALO, (UWORD)(ulPosInGUSRAM>>4) ); // Adresse>>4 !!!! ! 966: ! 967: if( ubGUSUsedBits == 0 ) ! 968: { // 8 Bit ! 969: if( ubGUSDMA1>3 ) ! 970: { ! 971: WriteGUSb( GUS_COMMAND, GUS_CMD_DRAMDMACTRL ); ! 972: WriteGUSb( GUS_DATAHI, 0x85 | 0x20 ); // Mit signed->unsigned kopieren ! 973: ! 974: } ! 975: else ! 976: { ! 977: WriteGUSb( GUS_COMMAND, GUS_CMD_DRAMDMACTRL ); ! 978: WriteGUSb( GUS_DATAHI, 0x81 | 0x20 ); ! 979: } ! 980: } ! 981: else ! 982: { // 16 Bit ! 983: if( ubGUSDMA1>3 ) ! 984: { ! 985: WriteGUSb( GUS_COMMAND, GUS_CMD_DRAMDMACTRL ); ! 986: WriteGUSb( GUS_DATAHI, 0x05 | 0x20 ); // Ohne signed->unsigned kopieren ! 987: ! 988: } ! 989: else ! 990: { ! 991: WriteGUSb( GUS_COMMAND, GUS_CMD_DRAMDMACTRL ); ! 992: WriteGUSb( GUS_DATAHI, 0x01 | 0x20 ); ! 993: } ! 994: ! 995: ! 996: } ! 997: ! 998: } ! 999: ! 1000: ! 1001: ! 1002: /******************************* ! 1003: ! 1004: void GUS_WorkOnVoices( void ) ! 1005: ! 1006: *******************************/ ! 1007: ! 1008: ! 1009: // Hier werden die Interrupts der einzelnen Stimmen bearbeitet ! 1010: ! 1011: void GUS_WorkOnVoices( void ) ! 1012: { ! 1013: ! 1014: UBYTE ubIntArt, ubTemp1, ubTemp2; ! 1015: int i, nVoice, nVoiceBit, nWaveIgnore=0, nVolumeIgnore=0; ! 1016: int nIntCounts=0; ! 1017: ! 1018: // Alle anstehenden Interrupts bearbeiten ! 1019: ! 1020: for(;;) ! 1021: { ! 1022: ! 1023: ! 1024: WriteGUSb( GUS_COMMAND, GUS_CMD_IRQSOURCER ); // IRQ-Art holen ! 1025: ubIntArt = ReadGUSb( GUS_DATAHI ); ! 1026: ! 1027: nVoice = ubIntArt & 0x1f; ! 1028: nVoiceBit = ((ULONG)1)<<((ULONG)nVoice); ! 1029: ! 1030: // Alle Interrupts abgearbeitet ? ! 1031: if( ( ubIntArt & 192) == 192 ) // Negative Logik !!!! ! 1032: { ! 1033: break; ! 1034: } ! 1035: ! 1036: nIntCounts++; ! 1037: ! 1038: if( nIntCounts>3 ) ! 1039: { ! 1040: #ifdef DEBUG ! 1041: fprintf( stderr, "!!!! Breche Int. ab, da mehr als 3 Anfragen !!!\n" ); ! 1042: #endif ! 1043: ! 1044: WriteGUSb( GUS_COMMAND, GUS_CMD_VOLUMECTRLW ); ! 1045: WriteGUSb( GUS_DATAHI, 3 ); ! 1046: GUS_GF1Delay(); ! 1047: WriteGUSb( GUS_DATAHI, 3 ); ! 1048: ! 1049: WriteGUSb( GUS_COMMAND, GUS_CMD_VOICECTRLW ); ! 1050: WriteGUSb( GUS_DATAHI, 3 ); ! 1051: GUS_GF1Delay(); ! 1052: WriteGUSb( GUS_DATAHI, 3 ); ! 1053: ! 1054: return; ! 1055: } ! 1056: ! 1057: if( bIgnoreGF1IRQ == TRUE ) ! 1058: { ! 1059: #ifdef DEBUG ! 1060: fprintf( stderr, "\t\tIgnoriere IRQ !\n" ); ! 1061: #endif ! 1062: ! 1063: WriteGUSb( GUS_COMMAND, GUS_CMD_VOICECTRLW ); ! 1064: WriteGUSb( GUS_DATAHI, 3 ); // Loop aus, IRQ aus ! 1065: ! 1066: WriteGUSb( GUS_COMMAND, GUS_CMD_VOLUMECTRLW ); ! 1067: WriteGUSb( GUS_DATAHI, 3 ); // Rollover an, IRQ an ! 1068: } ! 1069: ! 1070: #ifdef DEBUG ! 1071: fprintf( stderr, "\tBearbeite Stimme %d, IntArt: $%X\n", nVoice, ubIntArt ); ! 1072: #endif ! 1073: ! 1074: if( ! (ubIntArt & 128 ) ) // WAVE-Table-IRQ ? ! 1075: { ! 1076: if( !(nWaveIgnore & nVoiceBit )) ! 1077: { ! 1078: nWaveIgnore |= nVoiceBit; ! 1079: ! 1080: #ifdef DEBUG ! 1081: fprintf( stderr,"\t\tBearbeite WAVE-IRQ\n" ); ! 1082: #endif ! 1083: ! 1084: WriteGUSb( GUS_VOICE, nVoice ); ! 1085: WriteGUSb( GUS_COMMAND, GUS_CMD_VOICECTRLR ); ! 1086: ubTemp1 = ReadGUSb( GUS_DATAHI ); ! 1087: ! 1088: WriteGUSb( GUS_COMMAND, GUS_CMD_VOLUMECTRLR ); ! 1089: ubTemp2 = ReadGUSb( GUS_DATAHI ); ! 1090: ! 1091: ! 1092: if( ubTemp2&4 ) // Ist das Rollover an ? ! 1093: { // Ja ! 1094: ! 1095: // Das Ende neu setzen ! 1096: ! 1097: if( ubGUSUsedBits == 0 ) // 8 Bit ? ! 1098: { ! 1099: WriteGUSb( GUS_COMMAND, GUS_CMD_ENDHIW ); // Ende setzen ! 1100: WriteGUSw( GUS_DATALO, ADDR_HI( ulDMABufMaxSize*2+32 ) ); ! 1101: WriteGUSb( GUS_COMMAND, GUS_CMD_ENDLOW ); ! 1102: WriteGUSw( GUS_DATALO, ADDR_LO( ulDMABufMaxSize*2+32 ) ); ! 1103: } ! 1104: else ! 1105: { ! 1106: WriteGUSb( GUS_COMMAND, GUS_CMD_ENDHIW ); // Ende setzen ! 1107: WriteGUSw( GUS_DATALO, ADDR_HI( CONVTO16B( ulDMABufMaxSize*2+32 ) ) ); ! 1108: WriteGUSb( GUS_COMMAND, GUS_CMD_ENDLOW ); ! 1109: WriteGUSw( GUS_DATALO, ADDR_LO( CONVTO16B( ulDMABufMaxSize*2+32 ) ) ); ! 1110: } ! 1111: ! 1112: WriteGUSb( GUS_COMMAND, GUS_CMD_VOLUMECTRLW ); ! 1113: WriteGUSb( GUS_DATAHI, 3 ); ! 1114: GUS_GF1Delay(); ! 1115: WriteGUSb( GUS_DATAHI, 3 ); // Rollover aus ! 1116: ! 1117: WriteGUSb( GUS_COMMAND, GUS_CMD_VOICECTRLW ); ! 1118: WriteGUSb( GUS_DATAHI, 32|8|ubGUSUsedBits ); ! 1119: GUS_GF1Delay(); ! 1120: WriteGUSb( GUS_DATAHI, 32|8|ubGUSUsedBits ); // Loop an ! 1121: ! 1122: GUS_StartDMA( 32, FALSE ); ! 1123: ! 1124: } ! 1125: else ! 1126: { ! 1127: ! 1128: // Das Ende neu setzen ! 1129: ! 1130: if( ubGUSUsedBits == 0 ) ! 1131: { ! 1132: WriteGUSb( GUS_COMMAND, GUS_CMD_ENDHIW ); // Ende setzen ! 1133: WriteGUSw( GUS_DATALO, ADDR_HI( ulDMABufMaxSize+32 ) ); ! 1134: WriteGUSb( GUS_COMMAND, GUS_CMD_ENDLOW ); ! 1135: WriteGUSw( GUS_DATALO, ADDR_LO( ulDMABufMaxSize+32 ) ); ! 1136: } ! 1137: else ! 1138: { ! 1139: WriteGUSb( GUS_COMMAND, GUS_CMD_ENDHIW ); // Ende setzen ! 1140: WriteGUSw( GUS_DATALO, ADDR_HI( CONVTO16B( ulDMABufMaxSize+32 ) ) ); ! 1141: WriteGUSb( GUS_COMMAND, GUS_CMD_ENDLOW ); ! 1142: WriteGUSw( GUS_DATALO, ADDR_LO( CONVTO16B( ulDMABufMaxSize+32 ) ) ); ! 1143: } ! 1144: ! 1145: WriteGUSb( GUS_COMMAND, GUS_CMD_VOLUMECTRLW ); ! 1146: WriteGUSb( GUS_DATAHI, 3|4 ); ! 1147: GUS_GF1Delay(); ! 1148: WriteGUSb( GUS_DATAHI, 3|4 ); // Rollover an ! 1149: ! 1150: WriteGUSb( GUS_COMMAND, GUS_CMD_VOICECTRLW ); ! 1151: WriteGUSb( GUS_DATAHI, 32|ubGUSUsedBits ); ! 1152: GUS_GF1Delay(); ! 1153: WriteGUSb( GUS_DATAHI, 32|ubGUSUsedBits ); // Loop aus ! 1154: ! 1155: GUS_StartDMA( ulDMABufMaxSize+32, TRUE ); ! 1156: ! 1157: } ! 1158: ! 1159: } ! 1160: } ! 1161: ! 1162: if( ! (ubIntArt & 64 ) ) // Volume-IRQ ! 1163: { ! 1164: ! 1165: if( !(nVolumeIgnore & nVoiceBit )) ! 1166: { ! 1167: nVolumeIgnore |= nVoiceBit; ! 1168: #ifdef DEBUG ! 1169: fprintf( stderr, "\t\tBearbeite Volume-IRQ\n" ); ! 1170: #endif ! 1171: ! 1172: WriteGUSb( GUS_VOICE, nVoice ); ! 1173: WriteGUSb( GUS_COMMAND, GUS_CMD_VOLUMECTRLR ); ! 1174: ubTemp2 = ReadGUSb( GUS_DATAHI ); ! 1175: ! 1176: WriteGUSb(GUS_COMMAND, GUS_CMD_VOICECTRLR ); ! 1177: ubTemp1 = ReadGUSb( GUS_DATAHI ); ! 1178: ! 1179: ! 1180: WriteGUSb( GUS_COMMAND, GUS_CMD_VOLUMECTRLW ); ! 1181: WriteGUSb( GUS_DATAHI, (ubTemp2 & (~32)) | 3 ); ! 1182: ! 1183: } ! 1184: ! 1185: } ! 1186: ! 1187: } ! 1188: } ! 1189: ! 1190: ! 1191: ! 1192: /******************************* ! 1193: ! 1194: void GUS_GF1InterruptHandler( void ) ! 1195: ! 1196: *******************************/ ! 1197: ! 1198: ! 1199: // Hier werden alle Interrupts verarbeitet ! 1200: ! 1201: void GUS_GF1InterruptHandler( void ) ! 1202: { ! 1203: ! 1204: UBYTE ubIntArt, ubTemp; ! 1205: ! 1206: ! 1207: ! 1208: ! 1209: if( uwGUSPort == 0 ) ! 1210: return; ! 1211: ! 1212: #ifdef DEBUG ! 1213: fprintf( stderr, "- Interrupt aufgetreten. Zeit: %lf\n", ((double)clock())/((double)CLOCKS_PER_SEC) ); ! 1214: #endif ! 1215: ! 1216: for(;;) ! 1217: { ! 1218: ! 1219: ubIntArt = ReadGUSb( GUS_IRQSTATE ); ! 1220: ! 1221: #ifdef DEBUG ! 1222: fprintf( stderr, " IRQ-Status (2x6): $%X\n", ubIntArt ); ! 1223: #endif ! 1224: ! 1225: ! 1226: if( ubIntArt == 0 ) // Fertig ? ! 1227: break; ! 1228: ! 1229: if( ubIntArt & 128 ) // TC-IRQ ? ! 1230: { ! 1231: ! 1232: WriteGUSb( GUS_COMMAND, GUS_CMD_DRAMDMACTRL ); ! 1233: if( ReadGUSb( GUS_DATAHI ) & 0x40 ) ! 1234: { ! 1235: #ifdef DEBUG ! 1236: fprintf( stderr, " - Bearbeite DMA-Interrupt\n" ); ! 1237: #endif ! 1238: ! 1239: bDMAInProgress = FALSE; ! 1240: ! 1241: } ! 1242: ! 1243: WriteGUSb( GUS_COMMAND, GUS_CMD_SAMPLECTRL ); ! 1244: if( ReadGUSb( GUS_DATAHI ) & 0x40 ) ! 1245: { ! 1246: #ifdef DEBUG ! 1247: fprintf( stderr, " - Bearbeite Sample-Interrupt\n" ); ! 1248: #endif ! 1249: ! 1250: } ! 1251: ! 1252: } ! 1253: ! 1254: if( ubIntArt & 3 ) ! 1255: { ! 1256: #ifdef DEBUG ! 1257: fprintf( stderr, " - Bearbeite MIDI-IRQ\n" ); ! 1258: #endif ! 1259: ! 1260: } ! 1261: ! 1262: if( ubIntArt & 64 ) ! 1263: { ! 1264: #ifdef DEBUG ! 1265: fprintf( stderr, " - Bearbeite VOLUME-IRQ\n" ); ! 1266: #endif ! 1267: GUS_WorkOnVoices(); ! 1268: ! 1269: ! 1270: } ! 1271: ! 1272: if( ubIntArt & 32 ) ! 1273: { ! 1274: #ifdef DEBUG ! 1275: fprintf( stderr, " - Bearbeite WAVETABLE-IRQ\n" ); ! 1276: #endif ! 1277: GUS_WorkOnVoices(); ! 1278: ! 1279: } ! 1280: ! 1281: ! 1282: if( ubIntArt & 4 ) // Timer 1? ! 1283: { ! 1284: #ifdef DEBUG ! 1285: fprintf( stderr, " - Bearbeite Timer 1-IRQ\n" ); ! 1286: #endif ! 1287: ! 1288: WriteGUSb( GUS_COMMAND, GUS_CMD_TIMERCTRL ); ! 1289: ubTemp = ReadGUSb( GUS_DATAHI ); ! 1290: ! 1291: WriteGUSb( GUS_COMMAND, GUS_CMD_TIMERCTRL ); ! 1292: WriteGUSb( GUS_DATAHI, ubTemp & (~4) ); // Timer 1 aus ! 1293: } ! 1294: ! 1295: if( ubIntArt & 8 ) // Timer 2? ! 1296: { ! 1297: #ifdef DEBUG ! 1298: fprintf( stderr, " - Bearbeite Timer 2-IRQ\n" ); ! 1299: #endif ! 1300: ! 1301: WriteGUSb( GUS_COMMAND, GUS_CMD_TIMERCTRL ); ! 1302: ubTemp = ReadGUSb( GUS_DATAHI ); ! 1303: ! 1304: WriteGUSb( GUS_COMMAND, GUS_CMD_TIMERCTRL ); ! 1305: WriteGUSb( GUS_DATAHI, ubTemp & (~8) ); // Timer 2 aus ! 1306: } ! 1307: } ! 1308: ! 1309: #ifdef DEBUG ! 1310: fprintf( stderr, "- Interruptende\n\n" ); ! 1311: #endif ! 1312: ! 1313: if( ubGUSGF1Int > 7 ) ! 1314: outportb( 0xA0, 0x20 ); ! 1315: ! 1316: outportb( 0x20, 0x20 ); ! 1317: ! 1318: } ! 1319: ! 1320: ! 1321: // Dummy-Routine zum erkennen des Programmendes ! 1322: ! 1323: void GUS_DummyFunc( void ) ! 1324: { ! 1325: ; ! 1326: } ! 1327:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.