initial commit

diff --git a/.gitignore b/.gitignore
new file mode 100644 (file)
index 0000000..3fdcdb5
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,5 @@
+*.obj
+*.swp
+*.map
+*.lnk
+*.exe

diff --git a/Makefile b/Makefile
new file mode 100644 (file)
index 0000000..8d9951e
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,42 @@
+src = $(wildcard src/*.c)\r
+\r
+ifeq ($(findstring COMMAND.COM, $(SHELL)), COMMAND.COM)\r
+       hostsys = dos\r
+       obj = $(subst /,\,$(src:.c=.obj))\r
+       RM = del\r
+else\r
+       hostsys = unix\r
+       obj = $(src:.c=.obj)\r
+endif\r
+bin = auplay.exe\r
+\r
+opt = -5\r
+dbg = -d1\r
+def = -dLITTLEENDIAN\r
+\r
+incpath = -Isrc\r
+\r
+AS = nasm\r
+CC = wcc386\r
+ASFLAGS = -fobj\r
+CFLAGS = $(dbg) $(opt) $(def) -zq -bt=dos $(incpath)\r
+LDFLAGS = option map\r
+LD = wlink\r
+\r
+$(bin): $(obj)\r
+       $(file >objlist.lnk,$(obj))\r
+       $(LD) debug all name $@ system dos4g file { @objlist } $(LDFLAGS)\r
+\r
+%.obj: %.c\r
+       $(CC) -fo=$@ $(CFLAGS) $<\r
+\r
+%.obj: %.asm\r
+       $(AS) $(ASFLAGS) -o $@ $<\r
+\r
+clean:\r
+       $(RM) $(obj)\r
+       $(RM) *.obj\r
+       $(RM) src\*.obj\r
+       $(RM) $(bin)\r
+       $(RM) objlist.lnk\r
+       $(RM) auplay.map\r

diff --git a/Makefile.wat b/Makefile.wat
new file mode 100644 (file)
index 0000000..48ce6ac
--- /dev/null
+++ b/Makefile.wat
@@ -0,0 +1,40 @@
+obj = main.obj audio.obj aufile.obj auwav.obj dma.obj au_sb.obj dpmi.obj
+bin = auplay.exe
+
+opt = -5
+dbg = -d1
+def = -dLITTLEENDIAN
+
+incpath = -Isrc
+
+!ifdef __UNIX__
+RM = rm -f
+!else
+RM = del
+!endif
+
+AS = nasm
+CC = wcc386
+ASFLAGS = -fobj
+CFLAGS = $(dbg) $(opt) $(def) -zq -bt=dos $(incpath)
+LDFLAGS = option map
+LD = wlink
+
+$(bin): $(obj)
+       %write objlist.lnk $(obj)
+       $(LD) debug all name $@ system dos4g file { @objlist } $(LDFLAGS)
+
+.c: src
+.asm: src
+
+.c.obj: .autodepend
+       $(CC) -fo=$@ $(CFLAGS) $[*
+
+.asm.obj:
+       $(AS) $(ASFLAGS) -o $@ $[*.asm
+
+clean: .symbolic
+       $(RM) *.obj
+       $(RM) *.lnk
+       $(RM) *.map
+       $(RM) $(bin)

diff --git a/src/au_sb.c b/src/au_sb.c
new file mode 100644 (file)
index 0000000..d733f20
--- /dev/null
+++ b/src/au_sb.c
@@ -0,0 +1,516 @@
+#include <stdio.h>\r
+#include <stdlib.h>\r
+#include <assert.h>\r
+#include <dos.h>\r
+#include <conio.h>\r
+#include "audio.h"\r
+#include "au_sb.h"\r
+#include "dpmi.h"\r
+#include "dma.h"\r
+#include "intr.h"\r
+\r
+#define REG_MIXPORT            (base_port + 0x4)\r
+#define REG_MIXDATA            (base_port + 0x5)\r
+#define REG_RESET              (base_port + 0x6)\r
+#define REG_RDATA              (base_port + 0xa)\r
+#define REG_WDATA              (base_port + 0xc)\r
+#define REG_WSTAT              (base_port + 0xc)\r
+#define REG_RSTAT              (base_port + 0xe)\r
+#define REG_INTACK             (base_port + 0xe)\r
+#define REG_INT16ACK   (base_port + 0xf)\r
+\r
+#define WSTAT_BUSY             0x80\r
+#define RSTAT_RDY              0x80\r
+\r
+#define DSP_RATE                       0x40\r
+#define DSP4_OUT_RATE          0x41\r
+#define DSP4_IN_RATE           0x42\r
+#define DSP_GET_VER                    0xe1\r
+\r
+/* start DMA playback/recording. combine with fifo/auto/input flags */\r
+#define DSP4_START_DMA8                0xc0\r
+#define DSP4_START_DMA16       0xb0\r
+#define DSP4_FIFO                      0x02\r
+#define DSP4_AUTO                      0x04\r
+#define DSP4_INPUT                     0x08\r
+\r
+/* transfer mode commands */\r
+#define DSP4_MODE_SIGNED       0x10\r
+#define DSP4_MODE_STEREO       0x20\r
+\r
+/* immediately pause/continue */\r
+#define DSP_PAUSE_DMA8         0xd0\r
+#define DSP_ENABLE_OUTPUT      0xd1\r
+#define DSP_DISABLE_OUTPUT     0xd3\r
+#define DSP_CONT_DMA8          0xd4\r
+#define DSP_PAUSE_DMA16                0xd5\r
+#define DSP_CONT_DMA16         0xd6\r
+\r
+/* end the playback at the end of the current buffer */\r
+#define DSP_END_DMA16          0xd9\r
+#define DSP_END_DMA8           0xda\r
+\r
+/* mixer registers */\r
+#define MIX_MASTER                     0x02\r
+#define MIX_VOICE                      0x0a\r
+#define MIX_SBPRO_VOICE                0x04\r
+#define MIX_SBPRO_MASTER       0x22\r
+#define MIX_SB16_MASTER_L      0x30\r
+#define MIX_SB16_MASTER_R      0x31\r
+#define MIX_SB16_VOICE_L       0x32\r
+#define MIX_SB16_VOICE_R       0x33\r
+#define MIX_SB16_IRQ_SEL       0x80\r
+#define MIX_SB16_DMA_SEL       0x81\r
+\r
+#define VER_MAJOR(x)   ((x) >> 8)\r
+#define VER_MINOR(x)   ((x) & 0xff)\r
+\r
+/* delay for about 1us */\r
+#define iodelay()      outp(0x80, 0)\r
+\r
+static void INTERRUPT intr_handler();\r
+static void start_dsp4(int bits, unsigned int mode, int num_samples);\r
+static void start_dsp(int nchan, int num_samples);\r
+static void write_dsp(unsigned char val);\r
+static unsigned char read_dsp(void);\r
+static void write_mix(unsigned char val, int reg);\r
+static unsigned char read_mix(int reg);\r
+static int get_dsp_version(void);\r
+static int dsp4_detect_irq(void);\r
+static int dsp4_detect_dma(void);\r
+static void print_dsp_info(void);\r
+static const char *sbname(int ver);\r
+\r
+static int base_port;\r
+static int irq, dma_chan, dma16_chan, dsp_ver;\r
+static int dsp4;\r
+static void *buffer;\r
+static int xfer_mode;\r
+\r
+static int isplaying;\r
+static int cur_bits, cur_mode;\r
+static int curblk;\r
+\r
+static void (INTERRUPT *prev_intr_handler)();\r
+\r
+\r
+int sb_detect(void)\r
+{\r
+       int i;\r
+       char *env;\r
+\r
+       if((env = getenv("BLASTER"))) {\r
+               dma16_chan = -1;\r
+               if(sscanf(env, "A%x I%d D%d H%d", &base_port, &irq, &dma_chan, &dma16_chan) >= 3) {\r
+                       if(sb_reset_dsp() == 0) {\r
+                               dsp_ver = get_dsp_version();\r
+                               dsp4 = VER_MAJOR(dsp_ver) >= 4 ? 1 : 0;\r
+                               print_dsp_info();\r
+                               return 1;\r
+                       }\r
+               } else {\r
+                       printf("sb_detect: malformed BLASTER environment variable. Fallback to probing.\n");\r
+               }\r
+       }\r
+\r
+       for(i=0; i<6; i++) {\r
+               base_port = 0x200 + ((i + 1) << 4);\r
+               if(sb_reset_dsp() == 0) {\r
+                       dsp_ver = get_dsp_version();\r
+                       dsp4 = VER_MAJOR(dsp_ver) >= 4 ? 1 : 0;\r
+\r
+                       if(dsp4) {\r
+                               if(dsp4_detect_irq() == -1) {\r
+                                       printf("sb_detect: failed to configure IRQ\n");\r
+                                       return 0;\r
+                               }\r
+                               if(dsp4_detect_dma() == -1) {\r
+                                       printf("sb_detect: failed to configure DMA\n");\r
+                                       return 0;\r
+                               }\r
+\r
+                       } else {\r
+                               /* XXX for old sound blasters, hard-code to IRQ 5 DMA 1 for now */\r
+                               irq = 5;\r
+                               dma_chan = 1;\r
+                               dma16_chan = -1;\r
+\r
+                               printf("sb_detect: old sound blaster dsp. assuming: irq 5, dma 1\n");\r
+                       }\r
+                       print_dsp_info();\r
+\r
+                       return 1;\r
+               }\r
+       }\r
+\r
+       return 0;\r
+}\r
+\r
+int sb_reset_dsp(void)\r
+{\r
+       int i;\r
+\r
+       outp(REG_RESET, 1);\r
+       for(i=0; i<3; i++) iodelay();\r
+       outp(REG_RESET, 0);\r
+\r
+       for(i=0; i<128; i++) {\r
+               if(inp(REG_RSTAT) & RSTAT_RDY) {\r
+                       if(inp(REG_RDATA) == 0xaa) {\r
+                               return 0;\r
+                       }\r
+               }\r
+       }\r
+\r
+       return -1;\r
+}\r
+\r
+void sb_set_output_rate(int rate)\r
+{\r
+       if(dsp4) {\r
+               write_dsp(DSP4_OUT_RATE);\r
+               write_dsp(rate >> 8);\r
+               write_dsp(rate & 0xff);\r
+       } else {\r
+               int tcon = 256 - 1000000 / rate;\r
+               write_dsp(DSP_RATE);\r
+               write_dsp(tcon);\r
+       }\r
+}\r
+\r
+void *sb_buffer(int *size)\r
+{\r
+       *size = 32768;\r
+       return (char*)buffer + curblk * 32768;\r
+}\r
+\r
+void sb_start(int rate, int bits, int nchan)\r
+{\r
+       uint16_t seg, pmsel;\r
+       uint32_t addr;\r
+       int size;\r
+\r
+       if(!buffer) {\r
+               /* allocate a 64k-aligned 64k buffer in low memory */\r
+               if(!(seg = dpmi_alloc(65536 * 2 / 16, &pmsel))) {\r
+                       fprintf(stderr, "sb_start: failed to allocate DMA buffer\n");\r
+                       return;\r
+               }\r
+\r
+               printf("DBG allocated seg: %x, addr: %lx\n", (unsigned int)seg,\r
+                               (unsigned long)seg << 4);\r
+\r
+               addr = ((uint32_t)(seg << 4) + 0xffff) & 0xffff0000;\r
+               printf("DBG aligned: %lx\n", (unsigned long)addr);\r
+               buffer = (void*)addr;\r
+       } else {\r
+               addr = (uint32_t)buffer;\r
+       }\r
+\r
+       if(!(size = audio_callback(buffer, 32768))) {\r
+               return;\r
+       }\r
+       curblk = 1;\r
+\r
+       _disable();\r
+       if(!prev_intr_handler) {\r
+               prev_intr_handler = _dos_getvect(IRQ_TO_INTR(irq));\r
+       }\r
+       printf("setting interrupt vector: %d\n", IRQ_TO_INTR(irq));\r
+       _dos_setvect(IRQ_TO_INTR(irq), intr_handler);\r
+       _enable();\r
+\r
+       unmask_irq(irq);\r
+\r
+       cur_bits = bits;\r
+       cur_mode = 0;   /* TODO */\r
+       if(nchan > 1) {\r
+               cur_mode |= DSP4_MODE_STEREO;\r
+       }\r
+\r
+       write_dsp(DSP_ENABLE_OUTPUT);\r
+       dma_out(dma_chan, addr, size, DMA_SINGLE);\r
+       sb_set_output_rate(rate);\r
+       start_dsp4(cur_bits, cur_mode, size);\r
+       isplaying = 1;\r
+}\r
+\r
+static void start_dsp4(int bits, unsigned int mode, int num_samples)\r
+{\r
+       unsigned char cmd = bits == 8 ? DSP4_START_DMA8 : DSP4_START_DMA16;\r
+       assert(bits == 8 || bits == 16);\r
+\r
+       /*cmd |= DSP4_AUTO | DSP4_FIFO;*/\r
+\r
+       /* program the DSP to start the DMA transfer */\r
+       write_dsp(cmd);\r
+       write_dsp(mode);\r
+       num_samples--;\r
+       write_dsp(num_samples & 0xff);\r
+       write_dsp((num_samples >> 8) & 0xff);\r
+}\r
+\r
+static void start_dsp(int nchan, int num_samples)\r
+{\r
+       /* program the DSP to start the DMA transfer */\r
+       /* TODO */\r
+}\r
+\r
+void sb_pause(void)\r
+{\r
+       write_dsp(cur_bits == 8 ? DSP_PAUSE_DMA8 : DSP_PAUSE_DMA16);\r
+}\r
+\r
+void sb_continue(void)\r
+{\r
+       write_dsp(cur_bits == 8 ? DSP_CONT_DMA8 : DSP_CONT_DMA16);\r
+}\r
+\r
+void sb_stop(void)\r
+{\r
+       write_dsp(DSP_DISABLE_OUTPUT);\r
+\r
+       mask_irq(irq);\r
+       /* TODO: don't _enable, restore state */\r
+       _disable();\r
+       _dos_setvect(IRQ_TO_INTR(irq), prev_intr_handler);\r
+       _enable();\r
+\r
+       /* no need to stop anything if we're in single-cycle mode */\r
+       if(cur_mode & DSP4_AUTO) {\r
+               write_dsp(cur_bits == 8 ? DSP_END_DMA8 : DSP_END_DMA16);\r
+       }\r
+       isplaying = 0;\r
+}\r
+\r
+int sb_isplaying(void)\r
+{\r
+       return isplaying;\r
+}\r
+\r
+void sb_volume(int vol)\r
+{\r
+       /* TODO */\r
+}\r
+\r
+static void INTERRUPT intr_handler()\r
+{\r
+       int size;\r
+       void *bptr = (unsigned char*)buffer + curblk * 32768;\r
+\r
+       curblk = (curblk + 1) & 1;\r
+\r
+       /* ask for more data */\r
+       if(!(size = audio_callback(bptr, 32768))) {\r
+               sb_stop();\r
+       } else {\r
+               dma_out(dma_chan, (uint32_t)bptr, size, DMA_SINGLE);\r
+               start_dsp4(cur_bits, cur_mode, size);\r
+       }\r
+\r
+       /* acknowledge the interrupt */\r
+       inp(REG_INTACK);\r
+\r
+       if(irq > 7) {\r
+               outp(PIC2_CMD, OCW2_EOI);\r
+       }\r
+       outp(PIC1_CMD, OCW2_EOI);\r
+}\r
+\r
+static void write_dsp(unsigned char val)\r
+{\r
+       while(inp(REG_WSTAT) & WSTAT_BUSY);\r
+       outp(REG_WDATA, val);\r
+}\r
+\r
+static unsigned char read_dsp(void)\r
+{\r
+       while((inp(REG_RSTAT) & RSTAT_RDY) == 0);\r
+       return inp(REG_RDATA);\r
+}\r
+\r
+static void write_mix(unsigned char val, int reg)\r
+{\r
+       outp(REG_MIXPORT, reg);\r
+       outp(REG_MIXDATA, val);\r
+}\r
+\r
+static unsigned char read_mix(int reg)\r
+{\r
+       outp(REG_MIXPORT, reg);\r
+       return inp(REG_MIXDATA);\r
+}\r
+\r
+static int get_dsp_version(void)\r
+{\r
+       int major, minor;\r
+\r
+       write_dsp(DSP_GET_VER);\r
+       major = read_dsp();\r
+       minor = read_dsp();\r
+\r
+       return (major << 8) | minor;\r
+}\r
+\r
+static int dsp4_detect_irq(void)\r
+{\r
+       int i, irqsel;\r
+       static int irqtab[] = {2, 5, 7, 10};\r
+\r
+       irq = 0;\r
+       irqsel = read_mix(MIX_SB16_IRQ_SEL);\r
+       for(i=0; i<4; i++) {\r
+               if(irqsel & (1 << i)) {\r
+                       irq = irqtab[i];\r
+                       break;\r
+               }\r
+       }\r
+       if(!irq) {\r
+               /* try to force IRQ 5 */\r
+               write_mix(2, MIX_SB16_IRQ_SEL); /* bit1 selects irq 5 */\r
+\r
+               /* re-read to verify */\r
+               irqsel = read_mix(MIX_SB16_IRQ_SEL);\r
+               if(irqsel != 2) {\r
+                       return -1;\r
+               }\r
+               irq = 5;\r
+       }\r
+\r
+       return irq;\r
+}\r
+\r
+static int dsp4_detect_dma(void)\r
+{\r
+       int i, dmasel, tmp;\r
+       static int dmatab[] = {0, 1, -1, 3, -1, 5, 6, 7};\r
+\r
+       dma_chan = -1;\r
+       dma16_chan = -1;\r
+       dmasel = read_mix(MIX_SB16_DMA_SEL);\r
+       for(i=0; i<4; i++) {\r
+               if(dmasel & (1 << i)) {\r
+                       dma_chan = dmatab[i];\r
+                       break;\r
+               }\r
+       }\r
+       for(i=5; i<8; i++) {\r
+               if(dmasel & (1 << i)) {\r
+                       dma16_chan = dmatab[i];\r
+                       break;\r
+               }\r
+       }\r
+       if(dma_chan == -1) {\r
+               /* try to force DMA 1 */\r
+               dmasel |= 2;\r
+       }\r
+       if(dma16_chan == -1) {\r
+               /* try to force 16bit DMA 5 */\r
+               dmasel |= 0x20;\r
+       }\r
+\r
+       if(dma_chan == -1 || dma16_chan == -1) {\r
+               write_mix(dmasel, MIX_SB16_DMA_SEL);\r
+\r
+               /* re-read to verify */\r
+               tmp = read_mix(MIX_SB16_DMA_SEL);\r
+               if(tmp != dmasel) {\r
+                       return -1;\r
+               }\r
+               dma_chan = 1;\r
+               dma16_chan = 5;\r
+       }\r
+\r
+       return dma_chan;\r
+}\r
+\r
+static void print_dsp_info(void)\r
+{\r
+       int master[2], voice[2];\r
+       int val;\r
+\r
+       printf("sb_detect: %s (DSP v%d.%02d) port %xh, irq %d", sbname(dsp_ver),\r
+                       VER_MAJOR(dsp_ver), VER_MINOR(dsp_ver), base_port, irq);\r
+       if(VER_MAJOR(dsp_ver) >= 4) {\r
+               printf(" dma %d/%d\n", dma_chan, dma16_chan);\r
+       } else {\r
+               printf(" dma %d\n", dma_chan);\r
+       }\r
+\r
+       if(VER_MAJOR(dsp_ver) >= 4) {\r
+               master[0] = 100 * (int)(read_mix(MIX_SB16_MASTER_L) >> 3) / 31;\r
+               master[1] = 100 * (int)(read_mix(MIX_SB16_MASTER_R) >> 3) / 31;\r
+               voice[0] = 100 * (int)(read_mix(MIX_SB16_VOICE_L) >> 3) / 31;\r
+               voice[1] = 100 * (int)(read_mix(MIX_SB16_VOICE_R) >> 3) / 31;\r
+       } else if(VER_MAJOR(dsp_ver) >= 3) {\r
+               val = read_mix(MIX_SBPRO_MASTER);\r
+               master[0] = 100 * (val >> 5) / 7;\r
+               master[1] = 100 * ((val >> 1) & 7) / 7;\r
+               val = read_mix(MIX_SBPRO_VOICE);\r
+               voice[0] = 100 * (val >> 5) / 7;\r
+               voice[1] = 100 * ((val >> 1) & 7) / 7;\r
+       } else {\r
+               val = read_mix(MIX_MASTER);\r
+               master[0] = master[1] = 100 * ((val >> 1) & 7) / 7;\r
+               val = read_mix(MIX_VOICE);\r
+               voice[0] = voice[1] = 100 * ((val >> 1) & 3) / 3;\r
+       }\r
+       printf("  mixer: master(%d|%d) voice(%d|%d)\n", master[0], master[1],\r
+                       voice[0], voice[1]);\r
+}\r
+\r
+#define V(maj, min)    (((maj) << 8) | (min))\r
+\r
+static const char *sbname(int ver)\r
+{\r
+       int major = VER_MAJOR(ver);\r
+       int minor = VER_MINOR(ver);\r
+\r
+       switch(major) {\r
+       case 1:\r
+               if(minor == 5) {\r
+                       return "Sound Blaster 1.5";\r
+               }\r
+               return "Sound Blaster 1.0";\r
+\r
+       case 2:\r
+               if(minor == 1 || minor == 2) {\r
+                       return "Sound Blaster 2.0";\r
+               }\r
+               break;\r
+\r
+       case 3:\r
+               switch(minor) {\r
+               case 0:\r
+                       return "Sound Blaster Pro";\r
+               case 1:\r
+               case 2:\r
+                       return "Sound Blaster Pro 2";\r
+               case 5:\r
+                       return "Gallant SC-6000";\r
+               default:\r
+                       break;\r
+               }\r
+               break;\r
+\r
+       case 4:\r
+               switch(minor) {\r
+               case 4:\r
+               case 5:\r
+                       return "Sound Blaster 16";\r
+               case 11:\r
+                       return "Sound Blaster 16 SCSI-2";\r
+               case 12:\r
+                       return "Sound Blaster AWE 32";\r
+               case 13:\r
+                       return "Sound Blaster ViBRA16C";\r
+               case 16:\r
+                       return "Sound Blaster AWE 64";\r
+               default:\r
+                       break;\r
+               }\r
+               break;\r
+       }\r
+\r
+       return "Unknown Sound Blaster";\r
+}\r

diff --git a/src/au_sb.h b/src/au_sb.h
new file mode 100644 (file)
index 0000000..4766b44
--- /dev/null
+++ b/src/au_sb.h
@@ -0,0 +1,26 @@
+#ifndef AU_SB_H_\r
+#define AU_SB_H_\r
+\r
+/* returns true (nonzero) if a sound blaster DSP is detected in the ISA bus\r
+ * and sets the internal base_port so that subsequent calls can find it\r
+ */\r
+int sb_detect(void);\r
+\r
+/* returns 0 for success, non-zero if the DSP isn't responding at the currently\r
+ * selected base port\r
+ */\r
+int sb_reset_dsp(void);\r
+\r
+void *sb_buffer(int *size);\r
+\r
+void sb_set_output_rate(int rate);\r
+\r
+void sb_start(int rate, int bits, int nchan);\r
+void sb_pause(void);\r
+void sb_continue(void);\r
+void sb_stop(void);\r
+int sb_isplaying(void);\r
+\r
+void sb_volume(int vol);\r
+\r
+#endif /* AU_SB_H_ */\r

diff --git a/src/audio.c b/src/audio.c
new file mode 100644 (file)
index 0000000..88b8400
--- /dev/null
+++ b/src/audio.c
@@ -0,0 +1,78 @@
+#include <stdio.h>\r
+#include "audio.h"\r
+#include "au_sb.h"\r
+\r
+struct audrv {\r
+       void *(*get_buffer)(int *size);\r
+       void (*start)(int rate, int bits, int nchan);\r
+       void (*pause)(void);\r
+       void (*cont)(void);\r
+       void (*stop)(void);\r
+       void (*volume)(int vol);\r
+       int (*isplaying)(void);\r
+};\r
+\r
+static struct audrv drv;\r
+\r
+static audio_callback_func cbfunc;\r
+static void *cbcls;\r
+\r
+void audio_init(void)\r
+{\r
+       if(sb_detect()) {\r
+               drv.get_buffer = sb_buffer;\r
+               drv.start = sb_start;\r
+               drv.pause = sb_pause;\r
+               drv.cont = sb_continue;\r
+               drv.stop = sb_stop;\r
+               drv.volume = sb_volume;\r
+               drv.isplaying = sb_isplaying;\r
+               return;\r
+       }\r
+\r
+       printf("No supported audio device detected\n");\r
+}\r
+\r
+void audio_set_callback(audio_callback_func func, void *cls)\r
+{\r
+       cbfunc = func;\r
+       cbcls = cls;\r
+}\r
+\r
+int audio_callback(void *buf, int sz)\r
+{\r
+       if(!cbfunc) {\r
+               return 0;\r
+       }\r
+       return cbfunc(buf, sz, cbcls);\r
+}\r
+\r
+void audio_play(int rate, int bits, int nchan)\r
+{\r
+       drv.start(rate, bits, nchan);\r
+}\r
+\r
+void audio_pause(void)\r
+{\r
+       drv.pause();\r
+}\r
+\r
+void audio_resume(void)\r
+{\r
+       drv.cont();\r
+}\r
+\r
+void audio_stop(void)\r
+{\r
+       drv.stop();\r
+}\r
+\r
+void audio_volume(int vol)\r
+{\r
+       drv.volume(vol);\r
+}\r
+\r
+int audio_isplaying(void)\r
+{\r
+       return drv.isplaying();\r
+}\r

diff --git a/src/audio.h b/src/audio.h
new file mode 100644 (file)
index 0000000..c522134
--- /dev/null
+++ b/src/audio.h
@@ -0,0 +1,19 @@
+#ifndef AUDIO_H_\r
+#define AUDIO_H_\r
+\r
+typedef int (*audio_callback_func)(void *buffer, int size, void *cls);\r
+\r
+void audio_init(void);\r
+\r
+void audio_set_callback(audio_callback_func func, void *cls);\r
+int audio_callback(void *buf, int sz);\r
+\r
+void audio_play(int rate, int bits, int nchan);\r
+void audio_pause(void);\r
+void audio_resume(void);\r
+void audio_stop(void);\r
+int audio_isplaying(void);\r
+\r
+void audio_volume(int vol);\r
+\r
+#endif /* AUDIO_H_ */\r

diff --git a/src/aufile.c b/src/aufile.c
new file mode 100644 (file)
index 0000000..b67925b
--- /dev/null
+++ b/src/aufile.c
@@ -0,0 +1,51 @@
+#include <stdio.h>\r
+#include <stdlib.h>\r
+#include <string.h>\r
+#include <errno.h>\r
+#include "aufile.h"\r
+\r
+int au_open_wav(struct au_file *au);\r
+\r
+struct au_file *au_open(const char *fname)\r
+{\r
+       FILE *fp;\r
+       struct au_file *au;\r
+\r
+       if(!(fp = fopen(fname, "rb"))) {\r
+               fprintf(stderr, "au_open: failed to open file: %s: %s\n", fname, strerror(errno));\r
+               return 0;\r
+       }\r
+\r
+       if(!(au = malloc(sizeof *au))) {\r
+               fclose(fp);\r
+               fprintf(stderr, "au_open: failed to allocate file structure: %s\n", strerror(errno));\r
+               return 0;\r
+       }\r
+       au->fp = fp;\r
+\r
+       if(au_open_wav(au) != -1) {\r
+               return au;\r
+       }\r
+\r
+       fprintf(stderr, "au_open: invalid file: %s\n", fname);\r
+       fclose(fp);\r
+       free(au);\r
+       return 0;\r
+}\r
+\r
+void au_close(struct au_file *au)\r
+{\r
+       au->close(au);\r
+       fclose(au->fp);\r
+       free(au);\r
+}\r
+\r
+void au_reset(struct au_file *au)\r
+{\r
+       au->reset(au);\r
+}\r
+\r
+int au_read(struct au_file *au, void *buf, int size)\r
+{\r
+       return au->read(au, buf, size);\r
+}\r

diff --git a/src/aufile.h b/src/aufile.h
new file mode 100644 (file)
index 0000000..faca4c8
--- /dev/null
+++ b/src/aufile.h
@@ -0,0 +1,20 @@
+#ifndef AUFILE_H_\r
+#define AUFILE_H_\r
+\r
+struct au_file {\r
+       int rate, bits, chan;\r
+       void *data;\r
+\r
+       FILE *fp;\r
+       void (*close)(struct au_file*);\r
+       void (*reset)(struct au_file*);\r
+       int (*read)(struct au_file*, void*, int);\r
+};\r
+\r
+struct au_file *au_open(const char *fname);\r
+void au_close(struct au_file *au);\r
+\r
+void au_reset(struct au_file *au);\r
+int au_read(struct au_file *au, void *buf, int size);\r
+\r
+#endif /* AUFILE_H_ */\r

diff --git a/src/auwav.c b/src/auwav.c
new file mode 100644 (file)
index 0000000..eca5a76
--- /dev/null
+++ b/src/auwav.c
@@ -0,0 +1,146 @@
+#include <stdio.h>\r
+#include <stdlib.h>\r
+#include "aufile.h"\r
+#include "inttypes.h"\r
+\r
+struct format {\r
+       uint16_t fmt;\r
+       uint16_t nchan;\r
+       uint32_t rate;\r
+       uint16_t avgbaud;\r
+       uint16_t block_align;\r
+       uint16_t sample_bytes;\r
+};\r
+\r
+struct playback_data {\r
+       uint32_t start, size;\r
+       uint32_t bytes_left;\r
+};\r
+\r
+#define FOURCC(a, b, c, d) \\r
+       ((uint32_t)(a) | ((uint32_t)(b) << 8) | ((uint32_t)(c) << 16) | ((uint32_t)(d) << 24))\r
+\r
+enum {\r
+       ID_RIFF = FOURCC('R', 'I', 'F', 'F'),\r
+       ID_WAVE = FOURCC('W', 'A', 'V', 'E'),\r
+       ID_FMT = FOURCC('f', 'm', 't', ' '),\r
+       ID_DATA = FOURCC('d', 'a', 't', 'a')\r
+};\r
+\r
+static void close_wav(struct au_file *au);\r
+static void reset_wav(struct au_file *au);\r
+static int read_wav(struct au_file *au, void *buf, int size);\r
+static int read_uint32(uint32_t *res, FILE *fp);\r
+static int read_format(struct format *fmt, int fmtsize, FILE *fp);\r
+\r
+\r
+int au_open_wav(struct au_file *au)\r
+{\r
+       uint32_t id, len;\r
+       struct format fmt;\r
+       struct playback_data *pb;\r
+\r
+       if(read_uint32(&id, au->fp) == -1 || id != ID_RIFF)\r
+               return -1;\r
+       fseek(au->fp, 4, SEEK_CUR);\r
+       if(read_uint32(&id, au->fp) == -1 || id != ID_WAVE)\r
+               return -1;\r
+       if(read_uint32(&id, au->fp) == -1 || id != ID_FMT)\r
+               return -1;\r
+       if(read_uint32(&len, au->fp) == -1)\r
+               return -1;\r
+       if(read_format(&fmt, len, au->fp) == -1)\r
+               return -1;\r
+       if(read_uint32(&id, au->fp) == -1 || id != ID_DATA)\r
+               return -1;\r
+       if(read_uint32(&len, au->fp) == -1)\r
+               return -1;\r
+\r
+       if(!(pb = malloc(sizeof *pb))) {\r
+               fprintf(stderr, "failed to allocate wav playback data block\n");\r
+               return -1;\r
+       }\r
+       pb->start = ftell(au->fp);\r
+       pb->size = pb->bytes_left = len;\r
+\r
+       au->rate = fmt.rate;\r
+       au->bits = fmt.sample_bytes * 8;\r
+       au->chan = fmt.nchan;\r
+       au->data = pb;\r
+\r
+       au->close = close_wav;\r
+       au->reset = reset_wav;\r
+       au->read = read_wav;\r
+       return 0;\r
+}\r
+\r
+static void close_wav(struct au_file *au)\r
+{\r
+       free(au->data);\r
+}\r
+\r
+static void reset_wav(struct au_file *au)\r
+{\r
+       struct playback_data *pb = au->data;\r
+       pb->bytes_left = pb->size;\r
+       fseek(au->fp, pb->start, SEEK_SET);\r
+}\r
+\r
+static int read_wav(struct au_file *au, void *buf, int size)\r
+{\r
+       struct playback_data *pb = au->data;\r
+       size_t rd;\r
+\r
+       if(size > pb->bytes_left) {\r
+               size = pb->bytes_left;\r
+       }\r
+       if(size <= 0) {\r
+               return 0;\r
+       }\r
+       if((rd = fread(buf, 1, size, au->fp)) == -1) {\r
+               pb->bytes_left = 0;\r
+               return -1;\r
+       }\r
+       pb->bytes_left -= rd;\r
+       return rd;\r
+}\r
+\r
+#ifdef BIGENDIAN\r
+static void swap_uint32(uint32_t *val)\r
+{\r
+       uint32_t x = *val;\r
+       *val = (x << 24) | ((x & 0xff00) << 8) | ((x & 0xff0000) >> 8) | (x >> 24);\r
+}\r
+\r
+static void swap_uint16(uint16_t *val)\r
+{\r
+       uint16_t x = *val;\r
+       *val = (x << 8) | (x >> 8);\r
+}\r
+#endif\r
+\r
+static int read_uint32(uint32_t *res, FILE *fp)\r
+{\r
+       if(fread(res, 4, 1, fp) < 1) {\r
+               return -1;\r
+       }\r
+#ifdef BIGENDIAN\r
+       swap_uint32(res);\r
+#endif\r
+       return 0;\r
+}\r
+\r
+static int read_format(struct format *fmt, int fmtsize, FILE *fp)\r
+{\r
+       if(fread(fmt, 1, fmtsize, fp) < fmtsize) {\r
+               return -1;\r
+       }\r
+#ifdef BIGENDIAN\r
+       swap_uint16(&fmt->fmt);\r
+       swap_uint16(&fmt->nchan);\r
+       swap_uint32(&fmt->rate);\r
+       swap_uint16(&fmt->avgbaud);\r
+       swap_uint16(&fmt->block_align);\r
+#endif\r
+       return 0;\r
+}\r

diff --git a/src/dma.c b/src/dma.c
new file mode 100644 (file)
index 0000000..356836a
--- /dev/null
+++ b/src/dma.c
@@ -0,0 +1,133 @@
+#include <conio.h>\r
+#include "dma.h"\r
+\r
+/* 8bit DMA ports */\r
+#define DMA_0_ADDR     0x00\r
+#define DMA_0_COUNT    0x01\r
+#define DMA_1_ADDR     0x02\r
+#define DMA_1_COUNT    0x03\r
+#define DMA_2_ADDR     0x04\r
+#define DMA_2_COUNT    0x05\r
+#define DMA_3_ADDR     0x06\r
+#define DMA_3_COUNT    0x07\r
+/* 16bit DMA ports */\r
+#define DMA_4_ADDR     0xc0\r
+#define DMA_4_COUNT    0xc2\r
+#define DMA_5_ADDR     0xc4\r
+#define DMA_5_COUNT    0xc6\r
+#define DMA_6_ADDR     0xc8\r
+#define DMA_6_COUNT    0xca\r
+#define DMA_7_ADDR     0xcc\r
+#define DMA_7_COUNT    0xce\r
+\r
+#define DMA_ADDR(c)    \\r
+       ((c < 4) ? DMA_0_ADDR + ((c) << 1) : (DMA_4_ADDR + ((c) << 2)))\r
+#define DMA_COUNT(c) \\r
+       ((c < 4) ? DMA_0_COUNT + ((c) << 1) : (DMA_4_COUNT + ((c) << 2)))\r
+\r
+#define DMA8_MASK                      0x0a\r
+#define DMA8_MODE                      0x0b\r
+#define DMA8_CLR_FLIPFLOP      0x0c\r
+#define DMA8_RESET                     0x0d\r
+#define DMA8_MASK_RST          0x0e\r
+#define DMA8_RMASK                     0x0f\r
+#define DMA16_MASK                     0xd4\r
+#define DMA16_MODE                     0xd6\r
+#define DMA16_CLR_FLIPFLOP     0xd8\r
+#define DMA16_RESET                    0xda\r
+#define DMA16_MASK_RST         0xdc\r
+#define DMA16_RMASK            0xde\r
+\r
+#define DMA_MASK(c)    ((c) < 4 ? DMA8_MASK : DMA16_MASK)\r
+#define DMA_MODE(c)    ((c) < 4 ? DMA8_MODE : DMA16_MODE)\r
+#define DMA_CLR_FLIPFLOP(c)    ((c) < 4 ? DMA8_CLR_FLIPFLOP : DMA16_CLR_FLIPFLOP)\r
+#define DMA_RESET(c)   ((c) < 4 ? DMA8_RESET : DMA16_RESET)\r
+#define DMA_MASK_RST(c)        ((c) < 4 ? DMA8_MASK_RST : DMA16_MASK_RST)\r
+#define DMA_RMASK(c)   ((c) < 4 ? DMA8_RMASK : DMA16_RMASK)\r
+\r
+#define DMA_0_PAGE             0x87\r
+#define DMA_1_PAGE             0x83\r
+#define DMA_2_PAGE             0x81\r
+#define DMA_3_PAGE             0x82\r
+#define DMA_4_PAGE             0x8f\r
+#define DMA_5_PAGE             0x8b\r
+#define DMA_6_PAGE             0x89\r
+#define DMA_7_PAGE             0x8a\r
+\r
+#define MODE_CHAN(x)   ((x) & 3)\r
+#define MODE_WRITE             0x04\r
+#define MODE_READ              0x08\r
+#define MODE_AUTO              0x10\r
+#define MODE_DECR              0x20\r
+#define MODE_SINGLE            0x40\r
+#define MODE_BLOCK             0x80\r
+#define MODE_CASCADE   0xc0\r
+\r
+#define MASK_CHAN(x)   ((x) & 3)\r
+#define MASK_DISABLE   0x04\r
+\r
+#define RMASK_CHAN(x)  (1 << ((x) & 3))\r
+\r
+#define IS_16BIT(c)    ((c) >= 4)\r
+\r
+static void dma_io(int chan, uint32_t phyaddr, int size, unsigned int flags, unsigned int dir);\r
+static __inline void mask(int chan);\r
+static __inline void unmask(int chan);\r
+\r
+static int page_port[] = {\r
+       DMA_0_PAGE, DMA_1_PAGE, DMA_2_PAGE, DMA_3_PAGE,\r
+       DMA_4_PAGE, DMA_5_PAGE, DMA_6_PAGE, DMA_7_PAGE\r
+};\r
+\r
+void dma_out(int chan, uint32_t phyaddr, int size, unsigned int flags)\r
+{\r
+       dma_io(chan, phyaddr, size, flags, MODE_READ);\r
+}\r
+\r
+void dma_in(int chan, uint32_t phyaddr, int size, unsigned int flags)\r
+{\r
+       dma_io(chan, phyaddr, size, flags, MODE_WRITE);\r
+}\r
+\r
+static void dma_io(int chan, uint32_t phyaddr, int size, unsigned int flags, unsigned int dir)\r
+{\r
+       unsigned int mode;\r
+       int addr_port, count_port;\r
+\r
+       addr_port = DMA_ADDR(chan);\r
+       count_port = DMA_COUNT(chan);\r
+\r
+       mask(chan);\r
+       outp(DMA_CLR_FLIPFLOP(chan), 0);\r
+\r
+       /* first 2 bits of flags correspond to the mode bits 6,7 */\r
+       mode = ((flags & 3) << 6) | dir | MODE_CHAN(chan);\r
+       if(flags & DMA_DECR) mode |= MODE_DECR;\r
+       if(flags & DMA_AUTO) mode |= MODE_AUTO;\r
+       outp(DMA_MODE(chan), mode);\r
+\r
+       if(IS_16BIT(chan)) {\r
+               phyaddr >>= 1;\r
+               size >>= 1;\r
+       }\r
+\r
+       outp(addr_port, phyaddr & 0xff);\r
+       outp(addr_port, (phyaddr >> 8) & 0xff);\r
+       outp(page_port[chan], (phyaddr >> 16) & 0xff);\r
+\r
+       size--;\r
+       outp(count_port, size & 0xff);\r
+       outp(count_port, (size >> 8) & 0xff);\r
+\r
+       unmask(chan);\r
+}\r
+\r
+static __inline void mask(int chan)\r
+{\r
+       outp(DMA_MASK(chan), MASK_CHAN(chan) | MASK_DISABLE);\r
+}\r
+\r
+static __inline void unmask(int chan)\r
+{\r
+       outp(DMA_MASK(chan), MASK_CHAN(chan));\r
+}\r

diff --git a/src/dma.h b/src/dma.h
new file mode 100644 (file)
index 0000000..93cfa5d
--- /dev/null
+++ b/src/dma.h
@@ -0,0 +1,17 @@
+#ifndef DMA_H_\r
+#define DMA_H_\r
+\r
+#include <inttypes.h>\r
+\r
+enum {\r
+       DMA_SINGLE      = 0x01,\r
+       DMA_BLOCK       = 0x02,\r
+       DMA_CASCADE = DMA_SINGLE | DMA_BLOCK,\r
+       DMA_DECR        = 0x08,\r
+       DMA_AUTO        = 0x10\r
+};\r
+\r
+void dma_out(int chan, uint32_t phyaddr, int size, unsigned int flags);\r
+void dma_in(int chan, uint32_t phyaddr, int size, unsigned int flags);\r
+\r
+#endif /* DMA_H_ */\r

diff --git a/src/dpmi.c b/src/dpmi.c
new file mode 100644 (file)
index 0000000..7d2c2b5
--- /dev/null
+++ b/src/dpmi.c
@@ -0,0 +1,55 @@
+#include "dpmi.h"
+
+void dpmi_real_int(int inum, struct dpmi_real_regs *regs)
+{
+       unsigned char int_num = (unsigned char)inum;
+       __asm {
+               mov eax, 0x300
+               mov edi, regs
+               mov bl, int_num
+               mov bh, 0
+               xor ecx, ecx
+               int 0x31
+       }
+}
+
+void *dpmi_mmap(uint32_t phys_addr, unsigned int size)
+{
+       uint16_t mem_high, mem_low;
+       uint16_t phys_high = phys_addr >> 16;
+       uint16_t phys_low = phys_addr & 0xffff;
+       uint16_t size_high = size >> 16;
+       uint16_t size_low = size & 0xffff;
+       unsigned int err, res = 0;
+
+       __asm {
+               mov eax, 0x800
+               mov bx, phys_high
+               mov cx, phys_low
+               mov si, size_high
+               mov di, size_low
+               int 0x31
+               add res, 1
+               mov err, eax
+               mov mem_high, bx
+               mov mem_low, cx
+       }
+
+       if(res == 2) {
+               return 0;
+       }
+       return (void*)(((uint32_t)mem_high << 16) | ((uint32_t)mem_low));
+}
+
+void dpmi_munmap(void *addr)
+{
+       uint16_t mem_high = (uint32_t)addr >> 16;
+       uint16_t mem_low = (uint16_t)addr;
+
+       __asm {
+               mov eax, 0x801
+               mov bx, mem_high
+               mov cx, mem_low
+               int 0x31
+       }
+}

diff --git a/src/dpmi.h b/src/dpmi.h
new file mode 100644 (file)
index 0000000..5f06823
--- /dev/null
+++ b/src/dpmi.h
@@ -0,0 +1,34 @@
+#ifndef DPMI_H_
+#define DPMI_H_
+
+#include "inttypes.h"
+
+struct dpmi_real_regs {
+       uint32_t edi, esi, ebp;
+       uint32_t reserved;
+       uint32_t ebx, edx, ecx, eax;
+       uint16_t flags;
+       uint16_t es, ds, fs, gs;
+       uint16_t ip, cs, sp, ss;
+};
+
+uint16_t dpmi_alloc(unsigned int par, uint16_t *sel);
+void dpmi_free(uint16_t sel);
+
+#pragma aux dpmi_alloc = \
+               "mov eax, 0x100" \
+               "int 0x31" \
+               "mov [edi], dx" \
+               value[ax] parm[ebx][edi];
+
+#pragma aux dpmi_free = \
+               "mov eax, 0x101" \
+               "int 0x31" \
+               parm[dx];
+
+void dpmi_real_int(int inum, struct dpmi_real_regs *regs);
+
+void *dpmi_mmap(uint32_t phys_addr, unsigned int size);
+void dpmi_munmap(void *addr);
+
+#endif /* DPMI_H_ */

diff --git a/src/intr.h b/src/intr.h
new file mode 100644 (file)
index 0000000..3345324
--- /dev/null
+++ b/src/intr.h
@@ -0,0 +1,60 @@
+#ifndef INTR_H_\r
+#define INTR_H_\r
+\r
+#define INTERRUPT      __interrupt __far\r
+\r
+#define IRQ_TO_INTR(x) ((x) + 8)\r
+\r
+/* PIC command and data ports */\r
+#define PIC1_CMD       0x20\r
+#define PIC1_DATA      0x21\r
+#define PIC2_CMD       0xa0\r
+#define PIC2_DATA      0xa1\r
+/* PIC operation command word 2 bits */\r
+#define OCW2_EOI       (1 << 5)\r
+\r
+unsigned char get_irq_mask(int pic);\r
+#pragma aux get_irq_mask = \\r
+               "cmp bx, 0" \\r
+               "jnz getpic2" \\r
+               "in al, 0x21" \\r
+               "jmp getend" \\r
+               "getpic2:" \\r
+               "in al, 0xa1" \\r
+               "getend:" \\r
+               value[al] parm[ebx];\r
+\r
+void mask_irq(int irq);\r
+#pragma aux mask_irq = \\r
+               "mov dx, 0x21" \\r
+               "cmp ax, 8" \\r
+               "jb skip_mask_pic2" \\r
+               "mov dx, 0xa1" \\r
+               "sub ax, 8" \\r
+               "skip_mask_pic2:" \\r
+               "mov cl, al" \\r
+               "mov ah, 1" \\r
+               "shl ah, cl" \\r
+               "in al, dx" \\r
+               "or al, ah" \\r
+               "out dx, al" \\r
+               parm[eax] modify[cl dx];\r
+\r
+void unmask_irq(int irq);\r
+#pragma aux unmask_irq = \\r
+               "mov dx, 0x21" \\r
+               "cmp ax, 8" \\r
+               "jb skip_unmask_pic2" \\r
+               "mov dx, 0xa1" \\r
+               "sub ax, 8" \\r
+               "skip_unmask_pic2:" \\r
+               "mov cl, al" \\r
+               "mov ah, 1" \\r
+               "shl ah, cl" \\r
+               "not ah" \\r
+               "in al, dx" \\r
+               "and al, ah" \\r
+               "out dx, al" \\r
+               parm[eax] modify[cl dx];\r
+\r
+#endif /* INTR_H_ */\r

diff --git a/src/inttypes.h b/src/inttypes.h
new file mode 100644 (file)
index 0000000..1742166
--- /dev/null
+++ b/src/inttypes.h
@@ -0,0 +1,18 @@
+#ifndef INT_TYPES_H_
+#define INT_TYPES_H_
+
+#if defined(__DOS__) || defined(WIN32)
+typedef char int8_t;
+typedef short int16_t;
+typedef long int32_t;
+
+typedef unsigned char uint8_t;
+typedef unsigned short uint16_t;
+typedef unsigned long uint32_t;
+
+typedef unsigned long intptr_t;
+#else
+#include <stdint.h>
+#endif
+
+#endif /* INT_TYPES_H_ */

diff --git a/src/main.c b/src/main.c
new file mode 100644 (file)
index 0000000..2015a10
--- /dev/null
+++ b/src/main.c
@@ -0,0 +1,47 @@
+#include <stdio.h>\r
+#include <string.h>\r
+#include "aufile.h"\r
+\r
+static int play_file(const char *fname);\r
+static void print_usage(const char *argv0);\r
+\r
+int main(int argc, char **argv)\r
+{\r
+       int i;\r
+\r
+       play_file("namarie.wav");       /* TODO remove */\r
+\r
+       for(i=1; i<argc; i++) {\r
+               if(argv[i][0] == '-') {\r
+                       if(strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "-help") == 0) {\r
+                               print_usage(argv[0]);\r
+                               return 0;\r
+                       } else {\r
+                               fprintf(stderr, "invalid option: %s\n", argv[i]);\r
+                               return 1;\r
+                       }\r
+               } else {\r
+                       play_file(argv[i]);\r
+               }\r
+       }\r
+       return 0;\r
+}\r
+\r
+static int play_file(const char *fname)\r
+{\r
+       struct au_file *au;\r
+\r
+       if(!(au = au_open(fname))) {\r
+               return -1;\r
+       }\r
+       /* TODO: cont */\r
+       au_close(au);\r
+       return 0;\r
+}\r
+\r
+static void print_usage(const char *argv0)\r
+{\r
+       printf("Usage: %s [options] <file1> <file2> ... <filen>\n", argv0);\r
+       printf("options:\n");\r
+       printf(" -h,-help: print usage and exit\n");\r
+}\r