// All listings are for Watcom C++ 10.6 and are unoptimized to increase 
// readability.  Copyright (C)1998 Robert Basler

// Listing 1 - LoadWav

int16 LoadWav(FILE *wav, dword *flags, dword *dataposition, dword *datasize) {

*flags=0;
*dataposition=0;
*datasize=0;

dword riffsignature, chunkid, chunksize, nextseek, filesize, hd32;
int16 hd16;
fread(&riffsignature,1,sizeof(riffsignature),wav);
// Make sure is a RIFF file
if(riffsignature!=0x46464952)  return(-1); // RIFF
// Get the size of the first chunk, not including the chunk size and id.
fread(&chunksize,1,sizeof(filesize),wav);
// Get the chunk id, make sure it is a WAV file.
fread(&chunkid,1,sizeof(chunkid),wav);
if(chunkid!=0x45564157)  return(S3DE_BADTRACK); // WAVE
filesize=chunksize+sizeof(riffsignature)+sizeof(chunksize);
nextseek=sizeof(chunksize)+sizeof(riffsignature)+sizeof(chunkid);
while(nextseek<filesize) {
      fseek(wav,nextseek,SEEK_SET);
      if (fread(&chunkid,1,sizeof(chunkid),buf)!=sizeof(chunkid)) return(-1);
      if (fread(&chunksize,1,sizeof(chunksize),wav)!=sizeof(chunksize)) 
           return(-1);
      switch(chunkid) {
          case 0x20746D66: {//Format Chunk
              fread(&hd16,1,sizeof(hd16),wav);
               if (hd16!=0x0001) return(-1);    // Only accept PCM WAVE data
              fread(&hd16,1,sizeof(hd16),wav);  // Number of channels
              if (hd16>2) return(-1);
              if (hd16==2) *flags|=S3DF_STEREO;
              // Samples per second - values seem to vary from exact values 
              fread(&hd32,1,sizeof(hd32),wav);         // so accept ranges.
              if (hd32<=10512) *flags|=S3DF_8000;
              else if ((hd32>10512) && (hd32<=16537)) *flags|=S3DF_11025;
              else if ((hd32>16537) && (hd32<=33075)) *flags|=S3DF_22050;
              else *flags|=S3DF_44100;
              fread(&hd32,1,sizeof(hd32),wav); // Throughput bytes per second
              fread(&hd16,1,sizeof(hd16),wav); // Block alignment
              fread(&hd16,1,sizeof(hd16),wav); // Bits per sample
              if (hd16==8) *flags|=S3DF_8bit;
              else if (hd16==16) *flags|=S3DF_16bit;
              else return(-1);
              break;
          };
          case 0x61746164: {//Data Chunk
              *dataposition=nextseek+sizeof(chunksize)+sizeof(chunkid);
              *datasize=chunksize;
              break;
          };
          default: break;
    }
    nextseek=chunksize+nextseek+sizeof(chunkid)+sizeof(chunksize);
}
if ((*flags==0) || (*dataposition==0) || (*datasize==0)) return(-1);
return(0);
};

// Listing 2 - convert16to8

// Convert 16 bit sample buffer to 8 bit sample buffer.
void convert16to8(void *inbuf16, void *outbuf8, dword bufsize8);
/#pragma aux convert16to8 = \
 "    pushf"   /* Save flags register and check parameters */ \
 "    or esi,esi"\
 "    jz done"\
 "    or edi,edi"\
 "    jz done"\
 "    or ecx,ecx"\
 "    jz done"\
 "    cld"     /* Make sure we are going the right way for the loop */ \
 "top:"\
 "    mov ax,word ptr [esi]"  /* Get 16-bit signed sample */ \       
 "    add esi,2"              /* On to next sample */ \                    
 "    xor ah,0x80"            /* Invert high bit of high byte of sample */ \
 "    mov byte ptr [edi],ah"  /* Save the converted sample */ \         
 "    inc edi"                /* And so on and so on... */ \
 "    loop top"\
 "done:"\
 "    popf"\
 parm [esi] [edi] [ecx]\
 modify [ax esi edi ecx];

// Listing 3 - initvolumetable

void initvolumetable(void) {
for (int32 volume=0;volume<VOLUME_LEVELS;volume++) 
     for (int32 sample=-128;sample<=127;sample++) 
          volume_table[volume][sample+128]=volume*sample*256/(VOLUME_LEVELS-1);
};


// Listing 4 - swapchannels

// Assumes buffer is a multiple of 4 bytes.
// get channel 0 info in ax, get channel 1 info into channel 0 slot
// save channel 0 into channel 1 slot, round and round she goes
void swapchannels(void *outbuf16, dword bufsize8);
#pragma aux swapchannels = \
"     pushf"\
"     mov edi,esi"\   
"     shr ecx,1"\
"     shr ecx,1"\
"     cld"\
"top:"\
"     mov ax,word ptr [esi]" /* Reverse order of each pair of words */ \
"     add esi,2"\
"     mov bx,word ptr [esi]"\
"     mov word ptr [esi],ax"\
"     mov word ptr [edi],bx"\
"     add esi,2"\
"     add edi,4"\
"     loop top"\        
"     popf"\
parm [esi] [ecx]\
modify [ax bx ecx edi esi];

// Listing 5 - Mixing functions

// C declarations for mixing functions in Watcom C++ - these took a while 

// mt8m16s - Mix 8-bit mono track into 16 bit stereo buffer
int32 mt8m16s(void *trackbuf, void *mixbuf16, dword bufsize8, int16 *v0, 
              int16 *v1);
#pragma aux mt8m16s "*_" parm [esi] [edi] [ecx] [edx] [ebx] value [eax] modify
[esi edi edx ecx ebx eax];

// mts8m16s - Mix 8-bit mono track into surround channel of 16 bit stereo buffer
int32 mts8m16s(void *trackbuf, void *mixbuf16, dword bufsize8, int16 *v2);
#pragma aux mts8m16s "*_" parm [esi] [edi] [ecx] [edx] value [eax] modify [esi
edi edx ecx ebx eax];

.386
.model flat
_TEXT SEGMENT PUBLIC 'CODE' USE32
assume cs:_TEXT, ds:_DATA

;// mt8m16s - Mix 8-bit mono track into 16 bit stereo buffer
;int32 mt8m16s(void *trackbuf, void *mixbuf16, dword bufsize8, 
;              int16 *v0, int16 *v1);
; esi trackbuf - source track 8-bit mono audio data input
; edi mixbuf16 - mixing buffer 16-bit stereo audio data output
; ecx bufsize8 - size of trackbuf in bytes
; edx v0       - base address of channel 0 volume lookup table
; ebx v1       - base address of channel 1 volume lookup table
; Returns number of bytes of source buffer that were mixed in EAX
mt8m16s_ proc public 
     pushf
     cld                      ; Make sure we are going in the right direction
     mov eax,ebx              ; save channel 1 volume table pointer in eax
     shr ecx,1                ; Divide bufsize8 by 4 to get # samples to mix  
     shr ecx,1     
     push ecx                 ; Save number of samples to return later in eax          
     jecxz badparm            ; Just in case we have nothing to do
     or esi,esi               ; sanity check pointers
     jz badparm
     or edi,edi
     jz badparm
     or edx,edx
     jz badparm
     or ebx,ebx
     jnz mixnext
badparm:
     jmp done
mixnext:
     ; Mix channel 0 with destination buffer
     mov ebx,0               ; ebx gets the 8-bit source sample byte            
     mov bl, byte ptr [esi]
     inc esi                 ; increment input wave data ptr        
     shl bx,1                ; multiply to get offset into volume table         
     push ebx                ; and volume table index
     add ebx,edx             ; get pointer to chanl 0 volume table  
     mov bx,word ptr [ebx]   ; load channel 0 source data into bx
     add bx,word ptr [edi]   ; add to mixing buffer                 
     mov word ptr [edi],bx   ; save back to mixing buffer           
     ; Mix channel 1 with destination buffer
     add edi,2               ; increment mixing buffer pointer      
     pop ebx                 ; get table offset back                
     add ebx,eax             ; get final pointer to table           
     mov bx,word ptr [ebx]   ; get volume-adjusted value from table   
     add bx,word ptr [edi]   ; add to mixing buffer                 
     mov word ptr [edi],bx   ; save value to mixing buffer          
     add edi,2               ; on to the next sample                
     loop mixnext
done:
     pop eax                 ; return number of samples mixed
     popf
     ret
mt8m16s_ endp

;// mts8m16s - Surround mix 8-bit mono track into 16 bit stereo buffer
;int32 mts8m16s(void *trackbuf, void *mixbuf16, dword bufsize8, int16 *v2);
; esi trackbuf - source track 8-bit mono audio data input
; edi mixbuf16 - mixing buffer 16-bit stereo audio data output
; ecx bufsize8 - size of trackbuf in bytes
; edx v2       - base address of channel 2 (surround) volume lookup table
mts8m16s_ proc public 
     pushf
     cld                    ; make sure we are going in the right direction
     shr ecx,1              ; Divide bufsize8 by 4 to get # samples to mix  
     shr ecx,1     
     push ecx               ; Save number of samples to return later in eax          
     jecxz badparm@1        ; Just in case we have nothing to do
     or esi,esi             ; sanity check audio buffer pointers
     jz badparm@1
     or edi,edi
     jz badparm@1
     or edx,edx
     jnz mixnext@1
badparm@1:
     jmp done@1
mixnext@1:
     ; Mix Channel 2 with destination buffer
     mov ebx,0             ; ebx gets the 8-bit source sample byte            
     mov bl,byte ptr [esi]
     inc esi               ; increment input wave data ptr        
     shl bx,1              ; multiply to get offset into volume table         
     add ebx,edx           ; get pointer to volume adjusted sample in table
     mov bx,word ptr [ebx] ; load surround source data into bx
     mov ax,bx             ; save volume adjusted source for other channel
     add bx,word ptr [edi] ; add to mixing buffer                 
     mov word ptr [edi],bx ; save back to mixing buffer           
     add edi,2             ; increment mixing buffer pointer and invert
     neg ax                ; sample. This is where the magic happens Timmy!
     add ax,word ptr [edi] ; add to mixing buffer                 
     mov word ptr [edi],ax ; save value to mixing buffer          
     add edi,2             ; on to the next sample                
     loop mixnext@1
done@1:
     pop eax               ; return number of samples mixed
     popf
     ret
mts8m16s_ endp
_TEXT ends
end