![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sb.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 sb.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 Sound Blaster interface. ! 5: * ! 6: * (c) 1996 Peter Remmers ! 7: * ! 8: * Changes by Gustavo Goedert and Michael Sontheimer ***MS ! 9: */ ! 10: ! 11: ! 12: #include "sysconfig.h" ! 13: #include "sysdeps.h" ! 14: ! 15: #include <stdlib.h> ! 16: #include <stdio.h> ! 17: #include <string.h> ! 18: #include <ctype.h> ! 19: #include <dos.h> ! 20: #include <pc.h> ! 21: #include <sys/farptr.h> ! 22: #include <dpmi.h> ! 23: #include <go32.h> ! 24: ! 25: #include "sound/sb.h" ! 26: #include "sound/dma.h" ! 27: ! 28: /* some useful macros */ ! 29: #define LOBYTE(x) ((UBYTE)(((UWORD)(x)) & 0xFF)) ! 30: #define HIBYTE(x) ((UBYTE)(((UWORD)(x)) >> 8)) ! 31: #define LOWORD(x) ((UWORD)(((ULONG)(x)) & 0xFFFF)) ! 32: #define HIWORD(x) ((UWORD)(((ULONG)(x)) >> 16)) ! 33: #define NUMPARAS(bytesize) (((bytesize)+15) >> 4) ! 34: ! 35: #ifndef TRUE ! 36: #define TRUE 1 ! 37: #endif ! 38: #ifndef FALSE ! 39: #define FALSE 0 ! 40: #endif ! 41: ! 42: /* Offsets relative to base I/O address. */ ! 43: #define SB_MIXER_ADDRESS 0x04 ! 44: #define SB_MIXER_DATA 0x05 ! 45: #define SB_DSP_RESET 0x06 ! 46: #define SB_DSP_READ_DATA 0x0A ! 47: #define SB_DSP_WRITE_DATA 0x0C ! 48: #define SB_DSP_WRITE_STATUS 0x0C ! 49: #define SB_DSP_DATA_AVAIL 0x0E ! 50: #define SB_DSP_INT_CLEAR 0x0F ! 51: ! 52: /* DSP Commands */ ! 53: #define CMD_PLAY_8BIT 0x14 ! 54: #define CMD_SET_TIME_CONSTANT 0x40 ! 55: #define CMD_DEFINE_SILENCE_BLOCK 0x80 ! 56: #define CMD_PAUSE_8BIT_DMA 0xD0 ! 57: #define CMD_CONTINUE_8BIT_DMA 0xD4 ! 58: #define CMD_SPEAKER_ON 0xD1 ! 59: #define CMD_SPEAKER_OFF 0xD3 ! 60: #define CMD_GET_SPEAKER_SETTING 0xD8 ! 61: #define CMD_DSP_VER 0xE1 ! 62: ! 63: /* SbPro-only commands */ ! 64: #define CMD_SET_BLOCK_SIZE 0x48 ! 65: #define CMD_PLAY_8BIT_HISPEED 0x91 ! 66: ! 67: /* SB16-only commands */ ! 68: #define CMD_SET_OUTPUT_RATE 0x41 ! 69: #define CMD_PLAY_16BIT_SINGLE 0xB0 ! 70: #define CMD_PLAY_16BIT_AUTOINIT 0xB6 ! 71: #define CMD_PLAY_8BIT_SINGLE 0xC0 ! 72: #define CMD_PLAY_8BIT_AUTOINIT 0xC6 ! 73: #define CMD_PAUSE_16BIT_DMA 0xD5 ! 74: #define CMD_CONTINUE_16BIT_DMA 0xD6 ! 75: ! 76: #define DMA_BUF_SIZE 14700 /* absolute maximum (FIFO_BUF_SIZE / 3) */ ! 77: #define FIFO_BUF_SIZE 58800 /* max size for 1/4th second sound at */ ! 78: /* 44100Hz 16Bits Stereo */ ! 79: #define DESIRED_INT_RATE 70 /* The interrupt rate in Hz. The block size is */ ! 80: /* calculated from sampling rate and this value */ ! 81: ! 82: typedef void (*tPlayProc)(UWORD bytes); ! 83: typedef struct ! 84: { ! 85: ULONG Data; ! 86: UWORD Size; ! 87: } ! 88: tDMABuffer; ! 89: ! 90: tSBType SB_Type; ! 91: ! 92: UWORD SB_Base; /* the Base Address e.g. 220h */ ! 93: UWORD SB_IRQ; /* The IRQ e.g. 5 */ ! 94: UWORD SB_DMAlo; /* Low DMA channel e.g. 1 */ ! 95: UWORD SB_DMAhi; /* high DMA channel e.g. 5 */ ! 96: UWORD SB_INT; /* The Interrupt vector corresponding to IRQ e.g. 0Dh */ ! 97: UWORD SB_DMA; /* The current DMA channel */ ! 98: /* (depends on if we're playing 8Bit or 16Bit sound) */ ! 99: UBYTE SB_VersMaj; /* Major DSP Version byte */ ! 100: UBYTE SB_VersMin; /* Minor DSP Version byte */ ! 101: UBYTE SB_ModeByte; /* Mode Byte for SB16 (Mono/Stereo, Signed/Unsigned ) */ ! 102: UBYTE SB_StopByte; /* DSP command to stop DMA */ ! 103: UBYTE SB_ContByte; /* DSP command to continue DMA */ ! 104: UWORD SB_IntClearPort; /* SB Port to read from to acknoledge interrupt */ ! 105: ! 106: tPlayProc SB_Single_Play_Proc; /* single-cycle play function */ ! 107: tPlayProc SB_Play_Proc; /* autoinitialized DMA play function */ ! 108: ! 109: volatile int SB_Playing; /* Sound is currently playing */ ! 110: volatile unsigned long SB_Bytes_Played; /* number of bytes played so far */ ! 111: ! 112: volatile tDMABuffer dma_buf[2]; /* the two DMA buffers */ ! 113: volatile UBYTE active_buf; /* the currently playing buffer */ ! 114: volatile UBYTE last_buf; /* last buffer to play */ ! 115: volatile UWORD last_block_size; /* size of the previously played block */ ! 116: UWORD dma_block_size; /* size of one DMA block */ ! 117: ! 118: UBYTE fifobuf[FIFO_BUF_SIZE]; /* a ring buffer for sound buffering */ ! 119: UWORD fifo_max; /* max fill size of fifo buffer */ ! 120: UWORD fifo_write_index; /* the index to write to the fifo buffer */ ! 121: UWORD fifo_read_index; /* the index to read from the fifo buffer */ ! 122: volatile UWORD fifo_size; /* the current fill size */ ! 123: ! 124: BOOL SB_Autoinit; /* we're currently using autoinitialized DMA mode */ ! 125: BOOL SB_Stopped; /* Sound is stopped */ ! 126: BOOL SB_16Bit; /* we're playing in 16 Bits */ ! 127: BOOL SB_Stereo; /* we're playing in stereo */ ! 128: UWORD SB_Active_Rate; /* the active sampling rate */ ! 129: ! 130: volatile UBYTE IRQ_Detected; /* the detected IRQ number */ ! 131: ! 132: _go32_dpmi_registers cb_regs; /* the registers for the int handler */ ! 133: _go32_dpmi_seginfo old_pmint; /* the old interrupt handler */ ! 134: _go32_dpmi_seginfo pm_wrapper; /* the new interrupt handler */ ! 135: _go32_dpmi_seginfo dma_mem; /* info for DMA memory */ ! 136: ! 137: /* Reset SB at SB_Base, returns TRUE if it worked */ ! 138: BOOL SB_Reset(void) ! 139: { ! 140: outportb (SB_Base+SB_DSP_RESET, 1); ! 141: delay(100); // ***MS We should wait 100ms, not 10ms ! 142: outportb (SB_Base+SB_DSP_RESET, 0); ! 143: delay(100); ! 144: return (inportb(SB_Base+SB_DSP_READ_DATA) == 0xAA); ! 145: } ! 146: ! 147: /* Write a command to DSP chip */ ! 148: void SB_WriteDSP (UBYTE value) ! 149: { ! 150: while (inportb(SB_Base + SB_DSP_WRITE_STATUS) & 0x80); ! 151: outportb (SB_Base + SB_DSP_WRITE_DATA, value); ! 152: } ! 153: ! 154: /* read a byte from DSP chip */ ! 155: UBYTE SB_ReadDSP (void) ! 156: { ! 157: while (!(inportb (SB_Base + SB_DSP_DATA_AVAIL) & 0x80)); ! 158: return (inportb (SB_Base + SB_DSP_READ_DATA)); ! 159: } ! 160: ! 161: /* write a value to the mixer chip */ ! 162: void SB_WriteMixer (UBYTE reg, UBYTE data) ! 163: { ! 164: outportb (SB_Base + SB_MIXER_ADDRESS, reg); ! 165: outportb (SB_Base + SB_MIXER_DATA, data); ! 166: } ! 167: ! 168: /* read a value from the mixer chip */ ! 169: UBYTE SB_ReadMixer (UBYTE reg) ! 170: { ! 171: outportb (SB_Base + SB_MIXER_ADDRESS, reg); ! 172: return (inportb (SB_Base + SB_MIXER_DATA)); ! 173: } ! 174: ! 175: /* try to detect, if SB has a mixer chip, returns TRUE if found */ ! 176: BOOL SB_DetectMixer (void) ! 177: { ! 178: UBYTE orgval; ! 179: ! 180: orgval = SB_ReadMixer (0x22); ! 181: ! 182: // ***MS ! 183: // Some SB-Pro-clones always set the bit 0 and 4, if reading ! 184: // the volume (the bit 0 and 4 aren't used for setting the volume) ! 185: ! 186: SB_WriteMixer (0x22, 0); ! 187: delay(200); ! 188: if ((SB_ReadMixer (0x22)&(0xee)) != 0) ! 189: return (FALSE); ! 190: ! 191: SB_WriteMixer (0x22, 0xEE); ! 192: delay(200); ! 193: if ((SB_ReadMixer (0x22)&(0xee)) != 0xEE) ! 194: return (FALSE); ! 195: ! 196: // SB_WriteMixer (0x22, orgval); // Why not setting the volume to maximum ? ! 197: ! 198: return (TRUE); ! 199: } ! 200: ! 201: /* read a byte from the fifo buffer */ ! 202: UBYTE fifo_read (void) ! 203: { ! 204: UBYTE ret; ! 205: ! 206: if (fifo_size == 0) return(0); ! 207: ret = fifobuf[fifo_read_index++]; ! 208: if (fifo_read_index == fifo_max) fifo_read_index = 0; ! 209: fifo_size--; ! 210: ! 211: return (ret); ! 212: } ! 213: ! 214: /* write a byte to the fifo buffer */ ! 215: void fifo_write (UBYTE val) ! 216: { ! 217: if (fifo_size == fifo_max) return; ! 218: fifobuf[fifo_write_index++] = val; ! 219: if (fifo_write_index == fifo_max) fifo_write_index = 0; ! 220: fifo_size++; ! 221: } ! 222: ! 223: /* fill a DMA buffer with data from the fifo buffer */ ! 224: /* if fifo buffer is empty after this, the DMA buffer */ ! 225: /* is marked to be the last one to be played */ ! 226: void fill_buffer (UBYTE buf) ! 227: { ! 228: register int i; ! 229: register UWORD size; ! 230: register ULONG p; ! 231: ! 232: if (fifo_size == 0) return; ! 233: ! 234: disable(); ! 235: ! 236: if (fifo_size < dma_block_size) size = fifo_size; ! 237: else size = dma_block_size; ! 238: dma_buf[buf].Size = size; ! 239: ! 240: p = dma_buf[buf].Data; ! 241: ! 242: _farsetsel (_dos_ds); ! 243: for (i=0; i < size; i++) _farnspokeb (p++, fifo_read()); ! 244: ! 245: if (fifo_size == 0) last_buf = buf; ! 246: ! 247: enable (); ! 248: } ! 249: ! 250: /* play a block in 8 Bits on a Standard SB */ ! 251: void SB_Play_8Bit_Std (UWORD bytes) ! 252: { ! 253: SB_WriteDSP (CMD_PLAY_8BIT); ! 254: SB_WriteDSP (LOBYTE (bytes-1)); ! 255: SB_WriteDSP (HIBYTE (bytes-1)); ! 256: } ! 257: ! 258: /* Play a block in 8 Bits on an SB PRO */ ! 259: void SB_Play_8Bit_SbPro (UWORD bytes) ! 260: { ! 261: if (bytes != last_block_size) ! 262: { ! 263: SB_WriteDSP (CMD_SET_BLOCK_SIZE); ! 264: SB_WriteDSP (LOBYTE (bytes-1)); ! 265: SB_WriteDSP (HIBYTE (bytes-1)); ! 266: last_block_size = bytes; ! 267: } ! 268: SB_WriteDSP (CMD_PLAY_8BIT_HISPEED); ! 269: } ! 270: ! 271: /* play a block in 8 Bits on an SB 16 */ ! 272: void SB_Play_8Bit_SB16 (UWORD bytes) ! 273: { ! 274: SB_WriteDSP (CMD_PLAY_8BIT_SINGLE); ! 275: SB_WriteDSP (SB_ModeByte); ! 276: SB_WriteDSP (LOBYTE (bytes-1)); ! 277: SB_WriteDSP (HIBYTE (bytes-1)); ! 278: } ! 279: ! 280: /* play a block in 8 Bits on an SB 16 using autoinitialized DMA */ ! 281: void SB_Play_8Bit_SB16_Autoinit (UWORD bytes) ! 282: { ! 283: SB_WriteDSP (CMD_PLAY_8BIT_AUTOINIT); ! 284: SB_WriteDSP (SB_ModeByte); ! 285: SB_WriteDSP (LOBYTE (bytes-1)); ! 286: SB_WriteDSP (HIBYTE (bytes-1)); ! 287: } ! 288: ! 289: /* play a block in 16 Bits on an SB 16 */ ! 290: void SB_Play_16Bit (UWORD bytes) ! 291: { ! 292: SB_WriteDSP (CMD_PLAY_16BIT_SINGLE); ! 293: SB_WriteDSP (SB_ModeByte); ! 294: SB_WriteDSP (LOBYTE ((bytes>>1) -1)); ! 295: SB_WriteDSP (HIBYTE ((bytes>>1) -1)); ! 296: } ! 297: ! 298: /* play a block in 16 Bits on an SB 16 using autoinitialized DMA */ ! 299: void SB_Play_16Bit_Autoinit (UWORD bytes) ! 300: { ! 301: SB_WriteDSP (CMD_PLAY_16BIT_AUTOINIT); ! 302: SB_WriteDSP (SB_ModeByte); ! 303: SB_WriteDSP (LOBYTE ((bytes>>1) -1)); ! 304: SB_WriteDSP (HIBYTE ((bytes>>1) -1)); ! 305: } ! 306: ! 307: /* the interrupt handler for playing in single-cycle mode */ ! 308: void SB_IntHandler_Single (void) ! 309: { ! 310: UBYTE h = 1-active_buf; ! 311: ! 312: if (last_buf != 0xFF && fifo_size > 0) ! 313: { ! 314: last_buf = 0xFF; ! 315: last_block_size = 0; ! 316: ! 317: /* if we just played the last block and there's already new data */ ! 318: /* in the fifo buffer, then continue playing with the new data */ ! 319: if (active_buf == last_buf) ! 320: { ! 321: fill_buffer (0); ! 322: DMA_InitTransfer (SB_DMA, DMA_READ_AUTOINIT, ! 323: dma_buf[0].Data, dma_block_size*2); ! 324: h = 0; ! 325: } ! 326: } ! 327: ! 328: (*SB_Single_Play_Proc) (dma_buf[h].Size); ! 329: fill_buffer (active_buf); ! 330: active_buf = h; ! 331: } ! 332: ! 333: /* interrupt handler for playing in autoinitialized DMA mode */ ! 334: void SB_IntHandler_Autoinit (void) ! 335: { ! 336: if (last_buf != 0xFF) ! 337: { ! 338: if (active_buf == last_buf && fifo_size > 0) ! 339: { ! 340: last_buf = 0xFF; ! 341: active_buf = 0; ! 342: ! 343: DMA_InitTransfer (SB_DMA, DMA_READ_AUTOINIT, ! 344: dma_buf[0].Data, dma_block_size*2); ! 345: ! 346: fill_buffer (0); ! 347: if (fifo_size == 0) ! 348: (*SB_Single_Play_Proc) (dma_buf[0].Size); ! 349: else ! 350: { ! 351: (*SB_Play_Proc) (dma_block_size); ! 352: fill_buffer(1); ! 353: if (fifo_size == 0) ! 354: (*SB_Single_Play_Proc) (dma_buf[1].Size); ! 355: } ! 356: } ! 357: else active_buf = 1 - active_buf; ! 358: } ! 359: else ! 360: { ! 361: fill_buffer (active_buf); ! 362: ! 363: if (active_buf == last_buf) ! 364: (*SB_Single_Play_Proc) (dma_buf[active_buf].Size); ! 365: ! 366: active_buf = 1 - active_buf; ! 367: } ! 368: } ! 369: ! 370: /* the main interrupt handler */ ! 371: void SB_IntHandler (void) ! 372: { ! 373: SB_Bytes_Played += dma_buf[active_buf].Size; ! 374: ! 375: if (active_buf == last_buf && fifo_size == 0) SB_Playing = FALSE; ! 376: else if (SB_Autoinit) SB_IntHandler_Autoinit(); ! 377: else SB_IntHandler_Single(); ! 378: ! 379: inportb (SB_IntClearPort); ! 380: if (SB_IRQ > 7) outportb (0xA0, 0x20); ! 381: ! 382: outportb (0x20, 0x20); ! 383: enable(); ! 384: } ! 385: ! 386: /* set sampling rate on a standard SB */ ! 387: void SB_SetRate_LoSpeed (UWORD rate) ! 388: { ! 389: SB_WriteDSP (CMD_SET_TIME_CONSTANT); ! 390: SB_WriteDSP (0x100 - 1000000 / rate); ! 391: } ! 392: ! 393: /* set sampling rate on a SB PRO */ ! 394: void SB_SetRate_HiSpeed (UWORD rate) ! 395: { ! 396: SB_WriteDSP (CMD_SET_TIME_CONSTANT); ! 397: SB_WriteDSP (HIBYTE (0x10000 - 256000000 / rate)); ! 398: } ! 399: ! 400: /* set sampling rate on an SB 16 */ ! 401: void SB_SetRate_SB16 (UWORD rate) ! 402: { ! 403: SB_WriteDSP (CMD_SET_OUTPUT_RATE); ! 404: SB_WriteDSP (HIBYTE (rate)); ! 405: SB_WriteDSP (LOBYTE (rate)); ! 406: } ! 407: ! 408: /* calculates the DMA block size and the fifo size */ ! 409: /* from sampling rate and the desired interrupt rate */ ! 410: void calculate_buf_sizes(void) ! 411: { ! 412: ULONG rate; ! 413: ! 414: rate = SB_Active_Rate; ! 415: if (SB_16Bit) rate <<= 1; ! 416: if (SB_Stereo) rate <<= 1; ! 417: /* rate is now bytes per second */ ! 418: dma_block_size = (rate / DESIRED_INT_RATE) & ~3; /* make multiples of 4 */ ! 419: dma_buf[1].Data = dma_buf[0].Data + dma_block_size; ! 420: fifo_max = rate / 4; /* make fifo size 1/4th second of sound */ ! 421: } ! 422: ! 423: /* set the sampling rate */ ! 424: int SB_SetRate (unsigned short rate) ! 425: { ! 426: if (rate > 23000 && SB_Type < SB_Type_SbPro) return(FALSE); ! 427: ! 428: switch (SB_Type) ! 429: { ! 430: case SB_Type_StdSB: SB_SetRate_LoSpeed (rate); break; ! 431: case SB_Type_SbPro: SB_SetRate_HiSpeed (rate); break; ! 432: case SB_Type_SB16: SB_SetRate_SB16 (rate); break; ! 433: } ! 434: ! 435: SB_Active_Rate = rate; ! 436: ! 437: calculate_buf_sizes(); ! 438: ! 439: return (TRUE); ! 440: } ! 441: ! 442: /* set the number of bits, i.e. 8 Bit / 16 Bit mode */ ! 443: int SB_SetBits (unsigned char bits) ! 444: { ! 445: if (bits==16 && SB_Type < SB_Type_SB16) return (FALSE); ! 446: ! 447: if (SB_Type == SB_Type_SB16) ! 448: { ! 449: if (bits==16) ! 450: { ! 451: SB_Play_Proc = SB_Play_16Bit_Autoinit; ! 452: SB_Single_Play_Proc = SB_Play_16Bit; ! 453: SB_IntClearPort = SB_Base + SB_DSP_INT_CLEAR; ! 454: SB_DMA = SB_DMAhi; ! 455: SB_StopByte = CMD_PAUSE_16BIT_DMA; ! 456: SB_ContByte = CMD_CONTINUE_16BIT_DMA; ! 457: SB_16Bit = TRUE; ! 458: } ! 459: else ! 460: { ! 461: SB_Play_Proc = SB_Play_8Bit_SB16_Autoinit; ! 462: SB_Single_Play_Proc = SB_Play_8Bit_SB16; ! 463: SB_IntClearPort = SB_Base + SB_DSP_DATA_AVAIL; ! 464: SB_DMA = SB_DMAlo; ! 465: SB_StopByte = CMD_PAUSE_8BIT_DMA; ! 466: SB_ContByte = CMD_CONTINUE_8BIT_DMA; ! 467: SB_16Bit = FALSE; ! 468: } ! 469: } ! 470: ! 471: calculate_buf_sizes(); ! 472: ! 473: return (TRUE); ! 474: } ! 475: ! 476: /* set the number of channels, i.e. Mono / Stereo */ ! 477: int SB_SetChannels (unsigned char channels) ! 478: { ! 479: if (channels==2 && SB_Type < SB_Type_SbPro) return (FALSE); ! 480: ! 481: switch (SB_Type) ! 482: { ! 483: case SB_Type_StdSB: break; ! 484: ! 485: case SB_Type_SbPro: ! 486: if (channels==2) SB_WriteMixer (0x0E, SB_ReadMixer (0x0E) | 0x02); ! 487: else SB_WriteMixer (0x0E, SB_ReadMixer (0x0E) & 0xFD); ! 488: break; ! 489: ! 490: case SB_Type_SB16: ! 491: if (channels==2) SB_ModeByte |= 0x20; ! 492: else SB_ModeByte &= 0xDF; ! 493: break; ! 494: } ! 495: SB_Stereo = (channels==2); ! 496: ! 497: calculate_buf_sizes(); ! 498: ! 499: return (TRUE); ! 500: } ! 501: ! 502: /* set Signed / Unsigned mode (only on SB 16) */ ! 503: int SB_SetSigned (int sign) ! 504: { ! 505: if (sign && SB_Type < SB_Type_SB16) return (FALSE); ! 506: ! 507: if (SB_Type == SB_Type_SB16) ! 508: { ! 509: if (sign) SB_ModeByte |= 0x10; ! 510: else SB_ModeByte &= 0xEF; ! 511: } ! 512: return (TRUE); ! 513: } ! 514: ! 515: /* turn speaker off (doesn't seem to work on SB 16) */ ! 516: void SB_SpeakerOff(void) ! 517: { ! 518: SB_WriteDSP(CMD_SPEAKER_OFF); ! 519: } ! 520: ! 521: /* turn speaker on (doesn't seem to work on SB 16) */ ! 522: void SB_SpeakerOn(void) ! 523: { ! 524: SB_WriteDSP(CMD_SPEAKER_ON); ! 525: } ! 526: ! 527: /* start playing the sound data in the fifo buffer */ ! 528: void SB_Play (void) ! 529: { ! 530: if (fifo_size == 0) return; ! 531: ! 532: active_buf = 0; ! 533: last_buf = 0xFF; ! 534: last_block_size = 0; ! 535: ! 536: DMA_InitTransfer (SB_DMA, DMA_READ_AUTOINIT, ! 537: dma_buf[0].Data, dma_block_size*2); ! 538: if (SB_Autoinit) ! 539: { ! 540: fill_buffer (0); ! 541: if (fifo_size == 0) ! 542: (*SB_Single_Play_Proc) (dma_buf[0].Size); ! 543: else ! 544: { ! 545: (*SB_Play_Proc) (dma_block_size); ! 546: fill_buffer(1); ! 547: if (fifo_size == 0) (*SB_Single_Play_Proc) (dma_buf[1].Size); ! 548: } ! 549: } ! 550: else ! 551: { ! 552: fill_buffer(0); ! 553: (*SB_Single_Play_Proc) (dma_buf[0].Size); ! 554: fill_buffer(1); ! 555: } ! 556: ! 557: SB_Playing = TRUE; ! 558: } ! 559: ! 560: /* interrupt handler functions used for IRQ/DMA detection */ ! 561: void irq2 (void) ! 562: { ! 563: IRQ_Detected = 2; ! 564: inportb (SB_IntClearPort); ! 565: outportb (0x20, 0x20); ! 566: } ! 567: void irq5 (void) ! 568: { ! 569: IRQ_Detected = 5; ! 570: inportb (SB_IntClearPort); ! 571: outportb (0x20, 0x20); ! 572: } ! 573: void irq7 (void) ! 574: { ! 575: IRQ_Detected = 7; ! 576: inportb (SB_IntClearPort); ! 577: outportb (0x20, 0x20); ! 578: } ! 579: void irq10 (void) ! 580: { ! 581: IRQ_Detected = 10; ! 582: inportb (SB_IntClearPort); ! 583: outportb (0xA0, 0x20); ! 584: outportb (0x20, 0x20); ! 585: } ! 586: ! 587: /* detect the sound blaster Base/IRQ/DMA settings (may hang computer) */ ! 588: int SB_Detect (unsigned short *base, unsigned short *irq, ! 589: unsigned short *dmalo, unsigned short *dmahi) ! 590: { ! 591: #define TESTBUFSIZE 0x80 ! 592: static const UBYTE lowdma[3] = { 1,3,0 }; ! 593: static const UBYTE highdma[3] = { 5,6,7 }; ! 594: ! 595: UBYTE old21,oldA1,old0F,oldDE; ! 596: _go32_dpmi_seginfo oldirq2,oldirq5,oldirq7,oldirq10; ! 597: _go32_dpmi_seginfo newirq2,newirq5,newirq7,newirq10; ! 598: _go32_dpmi_seginfo testbuf_info; ! 599: ULONG testbuf; ! 600: int ret1,ret2,ret3,ret4; ! 601: UBYTE i; ! 602: BOOL found; ! 603: ! 604: found = FALSE; ! 605: ! 606: *base = 0; ! 607: *irq = 0; ! 608: *dmalo = 0; ! 609: *dmahi = 0; ! 610: ! 611: SB_Base = 0x210; ! 612: while (SB_Base != 0x290) ! 613: { ! 614: if (SB_Reset()) break; ! 615: SB_Base += 0x10; ! 616: } ! 617: if (SB_Base == 0x290) return (FALSE); ! 618: *base = SB_Base; ! 619: ! 620: /* install detection interrupt handlers */ ! 621: newirq2.pm_offset = (int) irq2; ! 622: newirq5.pm_offset = (int) irq5; ! 623: newirq7.pm_offset = (int) irq7; ! 624: newirq10.pm_offset = (int) irq10; ! 625: ! 626: ret1 = _go32_dpmi_allocate_iret_wrapper (&newirq2); ! 627: ret2 = _go32_dpmi_allocate_iret_wrapper (&newirq5); ! 628: ret3 = _go32_dpmi_allocate_iret_wrapper (&newirq7); ! 629: ret4 = _go32_dpmi_allocate_iret_wrapper (&newirq10); ! 630: ! 631: if (ret1|ret2|ret3|ret4) ! 632: { ! 633: if (!ret1) _go32_dpmi_free_iret_wrapper (&newirq2); ! 634: if (!ret2) _go32_dpmi_free_iret_wrapper (&newirq5); ! 635: if (!ret3) _go32_dpmi_free_iret_wrapper (&newirq7); ! 636: if (!ret4) _go32_dpmi_free_iret_wrapper (&newirq10); ! 637: return (FALSE); ! 638: } ! 639: _go32_dpmi_lock_code (irq2, (int)SB_Detect - (int)irq2); ! 640: _go32_dpmi_lock_data ((void*)&IRQ_Detected, sizeof(IRQ_Detected)); ! 641: _go32_dpmi_lock_data (&SB_IntClearPort, sizeof(SB_IntClearPort)); ! 642: ! 643: _go32_dpmi_get_protected_mode_interrupt_vector (0x0A, &oldirq2); ! 644: _go32_dpmi_get_protected_mode_interrupt_vector (0x0D, &oldirq5); ! 645: _go32_dpmi_get_protected_mode_interrupt_vector (0x0F, &oldirq7); ! 646: _go32_dpmi_get_protected_mode_interrupt_vector (0x72, &oldirq10); ! 647: ! 648: _go32_dpmi_set_protected_mode_interrupt_vector (0x0A, &newirq2); ! 649: _go32_dpmi_set_protected_mode_interrupt_vector (0x0D, &newirq5); ! 650: _go32_dpmi_set_protected_mode_interrupt_vector (0x0F, &newirq7); ! 651: _go32_dpmi_set_protected_mode_interrupt_vector (0x72, &newirq10); ! 652: ! 653: testbuf_info.size = NUMPARAS(TESTBUFSIZE); ! 654: testbuf = DMA_AllocDMABuf (&testbuf_info); ! 655: ! 656: /* turn on interrupts 2,5,7 and 10 */ ! 657: old21 = inportb (0x21); ! 658: oldA1 = inportb (0xA1); ! 659: outportb (0x21, old21 & 0x5B); ! 660: outportb (0xA1, oldA1 & 0xFB); ! 661: ! 662: /* turn off DMA 0,1,3,5,6 and 7 */ ! 663: old0F = inportb (0x0F); ! 664: oldDE = inportb (0xDE); ! 665: outportb (0x0F, old0F | 0x0B); ! 666: outportb (0xDE, oldDE | 0x0E); ! 667: ! 668: /* fill testbuffer with silence */ ! 669: _farsetsel (_dos_ds); ! 670: for (i=0; i<TESTBUFSIZE; i++) _farnspokeb (testbuf+i, 128); ! 671: ! 672: /* detect low DMA and IRQ */ ! 673: SB_IntClearPort = SB_Base + SB_DSP_DATA_AVAIL; ! 674: SB_SetRate_LoSpeed (22050); ! 675: /* program SB to play testbuffer, will start playing */ ! 676: /* when we hit the right DMA channel */ ! 677: SB_Play_8Bit_Std (TESTBUFSIZE); ! 678: ! 679: /* test all DMA channels */ ! 680: IRQ_Detected = 0; ! 681: for (i=0; i<3; i++) ! 682: { ! 683: DMA_InitTransfer (lowdma[i], DMA_READ, testbuf, TESTBUFSIZE); ! 684: delay (TESTBUFSIZE*2000 / 22050); ! 685: if (IRQ_Detected) ! 686: { ! 687: *dmalo = lowdma[i]; ! 688: *irq = IRQ_Detected; ! 689: break; ! 690: } ! 691: } ! 692: ! 693: if (IRQ_Detected) ! 694: { ! 695: found = TRUE; ! 696: ! 697: SB_WriteDSP (CMD_DSP_VER); ! 698: SB_VersMaj = SB_ReadDSP(); ! 699: SB_VersMin = SB_ReadDSP(); ! 700: ! 701: /* if SoundBlaster is an SB16 then test high DMA channel */ ! 702: if (SB_VersMaj >= 4) ! 703: { ! 704: outportb (0x0F, old0F | 0x0B); ! 705: outportb (0xDE, oldDE | 0x0E); ! 706: ! 707: _farsetsel (_dos_ds); ! 708: for (i=0; i<TESTBUFSIZE; i+=2) _farnspokew (testbuf+i, 0x8000); ! 709: ! 710: SB_ModeByte = 0x00; ! 711: SB_IntClearPort = SB_Base + SB_DSP_INT_CLEAR; ! 712: SB_SetRate_SB16(44100); ! 713: SB_Play_16Bit(TESTBUFSIZE); ! 714: ! 715: IRQ_Detected = 0; ! 716: for (i=0; i<3; i++) ! 717: { ! 718: DMA_InitTransfer (highdma[i], DMA_READ, testbuf, TESTBUFSIZE); ! 719: delay (TESTBUFSIZE*1000 / 44100); ! 720: if (IRQ_Detected) ! 721: { ! 722: *dmahi = highdma[i]; ! 723: break; ! 724: } ! 725: } ! 726: if (!IRQ_Detected) *dmahi = *dmalo; ! 727: } ! 728: } ! 729: ! 730: /* clean up */ ! 731: _go32_dpmi_free_dos_memory (&testbuf_info); ! 732: ! 733: outportb (0x0F, old0F); ! 734: outportb (0xDE, oldDE); ! 735: outportb (0x21, old21); ! 736: outportb (0xA1, oldA1); ! 737: ! 738: _go32_dpmi_set_protected_mode_interrupt_vector (0x0A, &oldirq2); ! 739: _go32_dpmi_set_protected_mode_interrupt_vector (0x0D, &oldirq5); ! 740: _go32_dpmi_set_protected_mode_interrupt_vector (0x0F, &oldirq7); ! 741: _go32_dpmi_set_protected_mode_interrupt_vector (0x72, &oldirq10); ! 742: ! 743: _go32_dpmi_free_iret_wrapper (&newirq2); ! 744: _go32_dpmi_free_iret_wrapper (&newirq5); ! 745: _go32_dpmi_free_iret_wrapper (&newirq7); ! 746: _go32_dpmi_free_iret_wrapper (&newirq10); ! 747: ! 748: return (found); ! 749: } ! 750: ! 751: /* init Sound blaster using the given settings */ ! 752: int SB_Init (unsigned short base, unsigned short irq, ! 753: unsigned short dmalo, unsigned short dmahi) ! 754: { ! 755: SB_Base = base; ! 756: SB_IRQ = irq; ! 757: SB_DMAlo = dmalo; ! 758: SB_DMAhi = dmahi; ! 759: ! 760: if (SB_IRQ > 7) SB_INT = 0x68 + SB_IRQ; ! 761: else SB_INT = 0x08 + SB_IRQ; ! 762: ! 763: ! 764: if (!SB_Reset()) return (FALSE); ! 765: ! 766: dma_mem.size = NUMPARAS(DMA_BUF_SIZE); ! 767: dma_buf[0].Data = DMA_AllocDMABuf (&dma_mem); ! 768: ! 769: if (dma_buf[0].Data == NULL) ! 770: { ! 771: printf ("Cannot allocate DOS Memory for DMA buffers!\n"); ! 772: return (FALSE); ! 773: } ! 774: ! 775: fifo_write_index = 0; ! 776: fifo_read_index = 0; ! 777: fifo_size = 0; ! 778: ! 779: pm_wrapper.pm_offset = (int) SB_IntHandler; ! 780: if (_go32_dpmi_allocate_iret_wrapper (&pm_wrapper)) ! 781: { ! 782: printf ("Cannot allocate protected mode wrapper for SB interrupt!\n"); ! 783: _go32_dpmi_free_dos_memory (&dma_mem); ! 784: return (FALSE); ! 785: } ! 786: ! 787: _go32_dpmi_lock_code (SB_WriteDSP, (ULONG)SB_WriteMixer - (ULONG)SB_WriteDSP); ! 788: _go32_dpmi_lock_code (fifo_read, (ULONG)SB_SetRate_LoSpeed - (ULONG)fifo_read); ! 789: _go32_dpmi_lock_data (&SB_Base, (ULONG)&old_pmint - (ULONG)&SB_Base); ! 790: ! 791: _go32_dpmi_get_protected_mode_interrupt_vector (SB_INT, &old_pmint); ! 792: _go32_dpmi_set_protected_mode_interrupt_vector (SB_INT, &pm_wrapper); ! 793: ! 794: if (SB_IRQ>7) ! 795: outportb(0xA1, inportb(0xA1) & ~(1 << (SB_IRQ-8))); ! 796: else ! 797: outportb(0x21, inportb(0x21) & ~(1 << SB_IRQ)); ! 798: ! 799: SB_Type = SB_Type_StdSB; ! 800: ! 801: if( SB_DetectMixer() != FALSE ) ! 802: SB_Type = SB_Type_SbPro; ! 803: ! 804: SB_WriteDSP (CMD_DSP_VER); ! 805: SB_VersMaj = SB_ReadDSP (); ! 806: SB_VersMin = SB_ReadDSP (); ! 807: ! 808: if (SB_VersMaj >= 4) SB_Type = SB_Type_SB16; ! 809: ! 810: // SB_Type = SB_Type_SbPro; /* for testing */ ! 811: ! 812: /* initialize SB to default 8Bit Mono 22050Hz */ ! 813: /* (available on all SoundBlaster Versions) */ ! 814: switch (SB_Type) ! 815: { ! 816: case SB_Type_StdSB: ! 817: SB_Single_Play_Proc = SB_Play_8Bit_Std; ! 818: SB_Autoinit = FALSE; ! 819: SB_SetRate_LoSpeed(22050); ! 820: break; ! 821: case SB_Type_SbPro: ! 822: SB_Single_Play_Proc = SB_Play_8Bit_SbPro; ! 823: SB_Autoinit = FALSE; ! 824: SB_SetRate_HiSpeed(22050); ! 825: break; ! 826: case SB_Type_SB16: ! 827: SB_Single_Play_Proc = SB_Play_8Bit_SB16; ! 828: SB_Play_Proc = SB_Play_8Bit_SB16_Autoinit; ! 829: SB_Autoinit = TRUE; ! 830: SB_SetRate_SB16(22050); ! 831: break; ! 832: } ! 833: SB_IntClearPort = SB_Base + SB_DSP_DATA_AVAIL; ! 834: SB_DMA = SB_DMAlo; ! 835: SB_Playing = FALSE; ! 836: SB_Stopped = FALSE; ! 837: SB_16Bit = FALSE; ! 838: SB_Stereo = FALSE; ! 839: SB_Active_Rate = 22050; ! 840: SB_ModeByte = 0x00; ! 841: SB_StopByte = CMD_PAUSE_8BIT_DMA; ! 842: SB_ContByte = CMD_CONTINUE_8BIT_DMA; ! 843: SB_Bytes_Played = 0; ! 844: ! 845: calculate_buf_sizes(); ! 846: ! 847: SB_SpeakerOn(); ! 848: SB_SetVolume(6); ! 849: ! 850: return (TRUE); ! 851: } ! 852: ! 853: /* clean up Sound Blaster */ ! 854: void SB_Done (void) ! 855: { ! 856: SB_Reset (); ! 857: if (SB_IRQ > 7) ! 858: outportb (0xA1, inportb(0xA1) | (1 << (SB_IRQ-8))); ! 859: else ! 860: outportb (0x21, inportb(0x21) | (1 << SB_IRQ)); ! 861: ! 862: _go32_dpmi_set_protected_mode_interrupt_vector (SB_INT, &old_pmint); ! 863: _go32_dpmi_free_iret_wrapper (&pm_wrapper); ! 864: _go32_dpmi_free_dos_memory (&dma_mem); ! 865: } ! 866: ! 867: /* write sound data to be played to the fifo buffer */ ! 868: void SB_Write (void *buf, unsigned long size) ! 869: { ! 870: #define MIN(a,b) ((a)<(b) ? (a) : (b)) ! 871: ! 872: UWORD s; ! 873: int i; ! 874: ! 875: if (SB_Stopped) SB_Continue(); ! 876: while (size > 0) ! 877: { ! 878: s = MIN (size, (UWORD) (fifo_max - dma_block_size)); ! 879: ! 880: while (fifo_size+s > fifo_max); ! 881: ! 882: disable (); ! 883: for (i=0; i<s; i++) fifo_write (*((UBYTE*)buf)++); ! 884: enable (); ! 885: ! 886: if (!SB_Playing && fifo_size > dma_block_size*2) SB_Play(); ! 887: ! 888: size -= s; ! 889: } ! 890: } ! 891: ! 892: /* start any unplayed sound */ ! 893: void SB_Flush (void) ! 894: { ! 895: if (SB_Stopped) SB_Continue(); ! 896: if (fifo_size>0 && !SB_Playing) SB_Play(); ! 897: } ! 898: ! 899: /* stop/pause sound output */ ! 900: void SB_Stop (void) ! 901: { ! 902: if (SB_Stopped) return; ! 903: SB_WriteDSP (SB_StopByte); ! 904: SB_Stopped = TRUE; ! 905: } ! 906: ! 907: /* continue sound output */ ! 908: void SB_Continue (void) ! 909: { ! 910: if (!SB_Stopped) return; ! 911: SB_WriteDSP (SB_ContByte); ! 912: SB_Stopped = FALSE; ! 913: } ! 914: ! 915: /* return thee DSP chip version */ ! 916: void SB_GetVersion (unsigned char *Maj, unsigned char *Min) ! 917: { ! 918: *Maj = SB_VersMaj; ! 919: *Min = SB_VersMin; ! 920: } ! 921: ! 922: /* return the current DMA block size */ ! 923: unsigned short SB_GetFragmentSize (void) ! 924: { ! 925: return (dma_block_size); ! 926: } ! 927: ! 928: /* return the current fifo buffer size (not the fifo fill size) */ ! 929: UWORD SB_GetBufferSize (void) ! 930: { ! 931: return (fifo_max); ! 932: } ! 933: ! 934: /* set sound blaster master volume, range from 0 to 7 by */ ! 935: void SB_SetVolume(UBYTE vol) { ! 936: ! 937: /* no mixer on standard sb */ ! 938: if (SB_Type < SB_Type_SbPro) ! 939: return; ! 940: ! 941: if (vol>7) ! 942: vol = 7; ! 943: vol = (vol<<1); ! 944: if (SB_Type == SB_Type_SbPro) ! 945: vol = vol | 1; ! 946: vol = vol | (vol<<4); ! 947: ! 948: SB_WriteMixer (0x22, vol); ! 949: } ! 950: ! 951: /* Detection Routine */ ! 952: int SB_DetectInitSound(int *dspbits, int *dsprate, int *sndbufsize) ! 953: { ! 954: UWORD base,irq,dmalo,dmahi; ! 955: char *blaster; ! 956: char *tok; ! 957: int have_sound; ! 958: extern void (*SND_Write)(void *buf, unsigned long size); ! 959: ! 960: blaster = getenv ("BLASTER"); ! 961: if (blaster == NULL) ! 962: { ! 963: printf ("No BLASTER variable found!\n" ! 964: "Detecting SoundBlaster Settings...."); fflush (stdout); ! 965: have_sound = SB_Detect (&base, &irq, &dmalo, &dmahi); ! 966: if (!have_sound) ! 967: { ! 968: printf ("Not found!!\n"); ! 969: return (0); ! 970: } ! 971: printf ("Found! Base: %hx IRQ: %hd DMA: %hd,%hd\n", ! 972: base, irq, dmalo,dmahi); ! 973: } ! 974: else ! 975: { ! 976: base = 0; irq = 0; dmalo = 0; dmahi = 0; ! 977: ! 978: tok = strtok(blaster, " \t"); ! 979: while (tok != NULL) ! 980: { ! 981: switch (toupper(*tok)) ! 982: { ! 983: case 'A': sscanf(tok+1, "%hx", &base); break; ! 984: case 'I': sscanf(tok+1, "%hd", &irq); break; ! 985: case 'D': sscanf(tok+1, "%hd", &dmalo); break; ! 986: case 'H': sscanf(tok+1, "%hd", &dmahi); break; ! 987: default: break; ! 988: } ! 989: tok = strtok (NULL, " \t"); ! 990: } ! 991: printf ("SoundBlaster Settings taken from BLASTER variable:\n" ! 992: " Base: %hx IRQ: %hd DMA: %hd,%hd\n", base,irq,dmalo,dmahi); ! 993: } ! 994: ! 995: have_sound = SB_Init (base, irq, dmalo, dmahi); ! 996: if (!have_sound) ! 997: { ! 998: printf ("Cannot Initialize Soundblaster!\n"); ! 999: return (0); ! 1000: } ! 1001: ! 1002: if (((*dspbits) == 16) && (SB_SetBits (16))) ! 1003: SB_SetSigned (1); ! 1004: else ! 1005: *dspbits = 8; ! 1006: ! 1007: SB_SetRate(22050); ! 1008: ! 1009: if (((*dsprate) == 44100) && (!SB_SetRate(44100))) ! 1010: { ! 1011: printf ("SoundCard does not support playing at 44100 Hz, using 22050 Hz\n"); ! 1012: SB_SetRate(22050); ! 1013: *dsprate = 22050; ! 1014: } ! 1015: ! 1016: *sndbufsize = SB_GetFragmentSize(); ! 1017: ! 1018: printf ("SoundBlaster%s found and configured for %d bits at %d Hz,\n" ! 1019: " Fragment size is %d Bytes, Buffer size is %d bytes.\n", ! 1020: SB_Type==SB_Type_StdSB ? "" : ! 1021: (SB_Type==SB_Type_SbPro ? " PRO" : " 16"), ! 1022: *dspbits, *dsprate, *sndbufsize, SB_GetBufferSize()); ! 1023: ! 1024: SND_Write = SB_Write; ! 1025: ! 1026: atexit (SB_Done); ! 1027: ! 1028: return 1; ! 1029: } ! 1030: ! 1031: /* that's it... */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.