From 06861bece014b2b3d40c4ec3ef4e9649b93921e6 Mon Sep 17 00:00:00 2001
From: Altheos <ardef@free.fr>
Date: Fri, 30 Nov 2018 14:32:41 +0100
Subject: [PATCH] Minor changes

---
 src/devices/sound/snd_cs423x.c |  462 +++++-----
 src/devices/sound/snd_cs423x.h |   46 +-
 src/devices/sound/snd_gus.c    | 1452 ++++++++++++++++----------------
 3 files changed, 989 insertions(+), 971 deletions(-)

diff --git a/src/devices/sound/snd_cs423x.c b/src/devices/sound/snd_cs423x.c
index 691247c..42be136 100644
--- a/src/devices/sound/snd_cs423x.c
+++ b/src/devices/sound/snd_cs423x.c
@@ -60,277 +60,277 @@ static int cs423x_vols[64];
 
 void cs423x_setirq(cs423x_t *cs423x, int irq_ch)
 {
-        cs423x->irq = irq_ch;
+	cs423x->irq = irq_ch;
 }
 
 void cs423x_setdma(cs423x_t *cs423x, int dma_ch)
 {
-        cs423x->dma = dma_ch;
+	cs423x->dma = dma_ch;
 }
 
 uint8_t cs423x_read(uint16_t addr, void *p)
 {
-        cs423x_t *cs423x = (cs423x_t *)p;
-        uint8_t temp = 0xff;
+	cs423x_t *cs423x = (cs423x_t *)p;
+	uint8_t temp = 0xff;
 
-	if(cs423x->initb)
+	if (cs423x->initb)
 		return 0x80;
-        
+
 	switch (addr & 3)
-        {
-			case 0: /*Index*/
-			if(cs423x->mode2)
-				temp = cs423x->index | cs423x->trd | cs423x->mce | cs423x->ia4 | cs423x->initb;
-			else
-				temp = cs423x->index | cs423x->trd | cs423x->mce | cs423x->initb;
-            break;
-			case 1:
-            temp = cs423x->regs[cs423x->index];
-			if (cs423x->index == 0x0b) { 
-				temp ^= 0x20;
-				cs423x->regs[cs423x->index] = temp;					
-			}
-            break;               
-			case 2:
-            temp = cs423x->status;
-            break;
-			case 3: // Todo Capture I/O read
-			break;
-        }
-        return temp;
+	{
+	case 0: /*Index*/
+		if (cs423x->mode2)
+			temp = cs423x->index | cs423x->trd | cs423x->mce | cs423x->ia4 | cs423x->initb;
+		else
+			temp = cs423x->index | cs423x->trd | cs423x->mce | cs423x->initb;
+		break;
+	case 1:
+		temp = cs423x->regs[cs423x->index];
+		if (cs423x->index == 0x0b) {
+			temp ^= 0x20;
+			cs423x->regs[cs423x->index] = temp;
+		}
+		break;
+	case 2:
+		temp = cs423x->status;
+		break;
+	case 3: // Todo Capture I/O read
+		break;
+	}
+	return temp;
 }
 
 void cs423x_write(uint16_t addr, uint8_t val, void *p)
 {
-        cs423x_t *cs423x = (cs423x_t *)p;
-        double freq;
+	cs423x_t *cs423x = (cs423x_t *)p;
+	double freq;
 
-        switch (addr & 3)
-        {
-			case 0: /*Index*/
-			cs423x->index = val & (cs423x->mode2 ? 0x1F : 0x0F);
-            cs423x->trd   = val & 0x20;
-            cs423x->mce   = val & 0x40;
-			cs423x->ia4   = val & 0x10;
-			cs423x->initb = val & 0x80;
-            break;
-            case 1:
-            switch (cs423x->index)
-            {
-				case 8:
-				freq = (double) ((val & 1) ? 16934400LL : 24576000LL);
-                switch ((val >> 1) & 7)
-                {
-					case 0: freq /= 3072; break;
-                    case 1: freq /= 1536; break;
-                    case 2: freq /= 896;  break;
-                    case 3: freq /= 768;  break;
-                    case 4: freq /= 448;  break;
-                    case 5: freq /= 384;  break;
-                    case 6: freq /= 512;  break;
-                    case 7: freq /= 2560; break;
-                }
-                cs423x->freq = (int64_t)freq;
-                cs423x->timer_latch = (int64_t)((double)TIMER_USEC * (1000000.0 / (double)cs423x->freq));
-                break;
-                        
-                case 9:
-				cs423x->enable = ((val & 0x41) == 0x01);
-                if (!cs423x->enable)
-					cs423x->out_l = cs423x->out_r = 0;
-                break;
-                              
-				case 11:
-				break;
-			
-                case 12:
-				val |= 0x8a; 
-				cs423x->mode2 = (val >> 6) & 1;
-				break;
-                        
-                case 14:
-                cs423x->count = cs423x->regs[15] | (val << 8);
-                break;				
-					
-				case 24:
-				if (!(val & 0x70))
-					cs423x->status &= 0xfe;
-				break;
-						
-				case 25:
-				break;
-                }
-                cs423x->regs[cs423x->index] = val;
-                break;
-            case 2:
-            cs423x->status &= 0xfe;
-            break;              
-			case 3: // Todo Playback I/O Write
+	switch (addr & 3)
+	{
+	case 0: /*Index*/
+		cs423x->index = val & (cs423x->mode2 ? 0x1F : 0x0F);
+		cs423x->trd = val & 0x20;
+		cs423x->mce = val & 0x40;
+		cs423x->ia4 = val & 0x10;
+		cs423x->initb = val & 0x80;
+		break;
+	case 1:
+		switch (cs423x->index)
+		{
+		case 8:
+			freq = (double)((val & 1) ? 16934400LL : 24576000LL);
+			switch ((val >> 1) & 7)
+			{
+			case 0: freq /= 3072; break;
+			case 1: freq /= 1536; break;
+			case 2: freq /= 896;  break;
+			case 3: freq /= 768;  break;
+			case 4: freq /= 448;  break;
+			case 5: freq /= 384;  break;
+			case 6: freq /= 512;  break;
+			case 7: freq /= 2560; break;
+			}
+			cs423x->freq = (int64_t)freq;
+			cs423x->timer_latch = (int64_t)((double)TIMER_USEC * (1000000.0 / (double)cs423x->freq));
 			break;
-        }
+
+		case 9:
+			cs423x->enable = ((val & 0x41) == 0x01);
+			if (!cs423x->enable)
+				cs423x->out_l = cs423x->out_r = 0;
+			break;
+
+		case 11:
+			break;
+
+		case 12:
+			val |= 0x8a;
+			cs423x->mode2 = (val >> 6) & 1;
+			break;
+
+		case 14:
+			cs423x->count = cs423x->regs[15] | (val << 8);
+			break;
+
+		case 24:
+			if (!(val & 0x70))
+				cs423x->status &= 0xfe;
+			break;
+
+		case 25:
+			break;
+		}
+		cs423x->regs[cs423x->index] = val;
+		break;
+	case 2:
+		cs423x->status &= 0xfe;
+		break;
+	case 3: // Todo Playback I/O Write
+		break;
+	}
 }
 
 void cs423x_speed_changed(cs423x_t *cs423x)
 {
-       cs423x->timer_latch = (int64_t)((double)TIMER_USEC * (1000000.0 / (double)cs423x->freq));
+	cs423x->timer_latch = (int64_t)((double)TIMER_USEC * (1000000.0 / (double)cs423x->freq));
 }
 
 void cs423x_update(cs423x_t *cs423x)
 {
-        for (; cs423x->pos < sound_pos_global; cs423x->pos++)
-        {
-                cs423x->buffer[cs423x->pos*2]     = cs423x->out_l;
-                cs423x->buffer[cs423x->pos*2 + 1] = cs423x->out_r;
-        }
+	for (; cs423x->pos < sound_pos_global; cs423x->pos++)
+	{
+		cs423x->buffer[cs423x->pos * 2] = cs423x->out_l;
+		cs423x->buffer[cs423x->pos * 2 + 1] = cs423x->out_r;
+	}
 }
 
 static void cs423x_poll(void *p)
 {
-        cs423x_t *cs423x = (cs423x_t *)p;
- 
-        if (cs423x->timer_latch)
-                cs423x->timer_count += cs423x->timer_latch;
-        else
-                cs423x->timer_count = TIMER_USEC;
-        
-        cs423x_update(cs423x);
-        
-        if (cs423x->enable)
-        {
-                int32_t temp;
-                
-                 if(!(cs423x->mode2))	{
-					switch (cs423x->regs[8] & 0x70)
-					{
-						case 0x00: /*Mono, 8-bit PCM*/
-						cs423x->out_l = cs423x->out_r = (dma_channel_read(cs423x->dma) ^ 0x80) * 256;
-						break;
-				
-						case 0x10: /*Stereo, 8-bit PCM*/
-						cs423x->out_l = (dma_channel_read(cs423x->dma) ^ 0x80)  * 256;
-						cs423x->out_r = (dma_channel_read(cs423x->dma) ^ 0x80)  * 256;
-						break;
-                
-						case 0x40: /*Mono, 16-bit PCM*/
-						temp = dma_channel_read(cs423x->dma);
-						cs423x->out_l = cs423x->out_r = (dma_channel_read(cs423x->dma) << 8) | temp;
-						break;
-				
-						case 0x50: /*Stereo, 16-bit PCM*/
-						temp = dma_channel_read(cs423x->dma);
-						cs423x->out_l = (dma_channel_read(cs423x->dma) << 8) | temp;
-						temp = dma_channel_read(cs423x->dma);
-						cs423x->out_r = (dma_channel_read(cs423x->dma) << 8) | temp;
-						break;
-					}
-				}
-				 else {
-					switch (cs423x->regs[8] & 0xf0)
-					{
-						case 0x00: /*Mono, 8-bit PCM*/
-						cs423x->out_l = cs423x->out_r = (dma_channel_read(cs423x->dma) ^ 0x80) * 256;
-						break;
-				
-						case 0x10: /*Stereo, 8-bit PCM*/
-						cs423x->out_l = (dma_channel_read(cs423x->dma) ^ 0x80)  * 256;
-						cs423x->out_r = (dma_channel_read(cs423x->dma) ^ 0x80)  * 256;
-						break;
-                
-						case 0x40: /*Mono, 16-bit PCM*/
-						case 0xc0: /*Mono, 16-bit PCM Big-Endian should not happen on x86*/
-						temp = dma_channel_read(cs423x->dma);
-						cs423x->out_l = cs423x->out_r = (dma_channel_read(cs423x->dma) << 8) | temp;
-						break;
-				
-						case 0x50: /*Stereo, 16-bit PCM*/
-						case 0xd0: /*Stereo, 16-bit PCM Big-Endian. Should not happen on x86*/
-						temp = dma_channel_read(cs423x->dma);
-						cs423x->out_l = (dma_channel_read(cs423x->dma) << 8) | temp;
-						temp = dma_channel_read(cs423x->dma);
-						cs423x->out_r = (dma_channel_read(cs423x->dma) << 8) | temp;
-						break;
-							
-						case 0xa0: /*TODO Mono, ADPCM, 4-bit*/
-						case 0xb0: /*TODO Stereo, ADPCM, 4-bit*/
-						break;
-					}
-				}
+	cs423x_t *cs423x = (cs423x_t *)p;
 
-                 if (cs423x->regs[6] & 0x80) // Mute Left-Channel
-                        cs423x->out_l = 0;
-                 else
-                        cs423x->out_l = (cs423x->out_l * cs423x_vols[cs423x->regs[6] & 0x3f]) >> 16;
+	if (cs423x->timer_latch)
+		cs423x->timer_count += cs423x->timer_latch;
+	else
+		cs423x->timer_count = TIMER_USEC;
 
-                 if (cs423x->regs[7] & 0x80) // Mute Right-Channel
-                        cs423x->out_r = 0;
-                 else
-                        cs423x->out_r = (cs423x->out_r * cs423x_vols[cs423x->regs[7] & 0x3f]) >> 16;
-                
-                 if (cs423x->regs[26] & 0x40) // Mono Output Mute
-						cs423x->out_l = cs423x->out_r = 0;
-		
-		if (cs423x->count < 0)  {
-            cs423x->count = cs423x->regs[15] | (cs423x->regs[14] << 8);
-			if (!(cs423x->status & 0x01))	{
+	cs423x_update(cs423x);
+
+	if (cs423x->enable)
+	{
+		int32_t temp;
+
+		if (!(cs423x->mode2)) {
+			switch (cs423x->regs[8] & 0x70)
+			{
+			case 0x00: /*Mono, 8-bit PCM*/
+				cs423x->out_l = cs423x->out_r = (dma_channel_read(cs423x->dma) ^ 0x80) * 256;
+				break;
+
+			case 0x10: /*Stereo, 8-bit PCM*/
+				cs423x->out_l = (dma_channel_read(cs423x->dma) ^ 0x80) * 256;
+				cs423x->out_r = (dma_channel_read(cs423x->dma) ^ 0x80) * 256;
+				break;
+
+			case 0x40: /*Mono, 16-bit PCM*/
+				temp = dma_channel_read(cs423x->dma);
+				cs423x->out_l = cs423x->out_r = (dma_channel_read(cs423x->dma) << 8) | temp;
+				break;
+
+			case 0x50: /*Stereo, 16-bit PCM*/
+				temp = dma_channel_read(cs423x->dma);
+				cs423x->out_l = (dma_channel_read(cs423x->dma) << 8) | temp;
+				temp = dma_channel_read(cs423x->dma);
+				cs423x->out_r = (dma_channel_read(cs423x->dma) << 8) | temp;
+				break;
+			}
+		}
+		else {
+			switch (cs423x->regs[8] & 0xf0)
+			{
+			case 0x00: /*Mono, 8-bit PCM*/
+				cs423x->out_l = cs423x->out_r = (dma_channel_read(cs423x->dma) ^ 0x80) * 256;
+				break;
+
+			case 0x10: /*Stereo, 8-bit PCM*/
+				cs423x->out_l = (dma_channel_read(cs423x->dma) ^ 0x80) * 256;
+				cs423x->out_r = (dma_channel_read(cs423x->dma) ^ 0x80) * 256;
+				break;
+
+			case 0x40: /*Mono, 16-bit PCM*/
+			case 0xc0: /*Mono, 16-bit PCM Big-Endian should not happen on x86*/
+				temp = dma_channel_read(cs423x->dma);
+				cs423x->out_l = cs423x->out_r = (dma_channel_read(cs423x->dma) << 8) | temp;
+				break;
+
+			case 0x50: /*Stereo, 16-bit PCM*/
+			case 0xd0: /*Stereo, 16-bit PCM Big-Endian. Should not happen on x86*/
+				temp = dma_channel_read(cs423x->dma);
+				cs423x->out_l = (dma_channel_read(cs423x->dma) << 8) | temp;
+				temp = dma_channel_read(cs423x->dma);
+				cs423x->out_r = (dma_channel_read(cs423x->dma) << 8) | temp;
+				break;
+
+			case 0xa0: /*TODO Mono, ADPCM, 4-bit*/
+			case 0xb0: /*TODO Stereo, ADPCM, 4-bit*/
+				break;
+			}
+		}
+
+		if (cs423x->regs[6] & 0x80) // Mute Left-Channel
+			cs423x->out_l = 0;
+		else
+			cs423x->out_l = (cs423x->out_l * cs423x_vols[cs423x->regs[6] & 0x3f]) >> 16;
+
+		if (cs423x->regs[7] & 0x80) // Mute Right-Channel
+			cs423x->out_r = 0;
+		else
+			cs423x->out_r = (cs423x->out_r * cs423x_vols[cs423x->regs[7] & 0x3f]) >> 16;
+
+		if (cs423x->regs[26] & 0x40) // Mono Output Mute
+			cs423x->out_l = cs423x->out_r = 0;
+
+		if (cs423x->count < 0) {
+			cs423x->count = cs423x->regs[15] | (cs423x->regs[14] << 8);
+			if (!(cs423x->status & 0x01)) {
 				cs423x->status |= 0x01;
 				if (cs423x->regs[0xa] & 2)
 					picint(1 << cs423x->irq);
 			}
-        }
+		}
 
 		cs423x->count--;
-        }
-        else  {
-			cs423x->out_l = cs423x->out_r = 0;
-        }
+	}
+	else {
+		cs423x->out_l = cs423x->out_r = 0;
+	}
 }
 
 void cs423x_init(cs423x_t *cs423x)
 {
-        int c;
-        double attenuation;
+	int c;
+	double attenuation;
 
-        cs423x->enable = 0;
-                        
-        cs423x->status = 0xcc;
-        cs423x->index = cs423x->trd = 0;
-        cs423x->mce = 0x40;
-		cs423x->initb = 0;
-		cs423x->mode2 = 0;
-        
-        cs423x->regs[0] = cs423x->regs[1] = 0;
-        cs423x->regs[2] = cs423x->regs[3] = 0x88;
-        cs423x->regs[4] = cs423x->regs[5] = 0x88;
-        cs423x->regs[6] = cs423x->regs[7] = 0x80;
-        cs423x->regs[8] = 0;
-        cs423x->regs[9] = 0x08;
-        cs423x->regs[10] = cs423x->regs[11] = 0;
-		cs423x->regs[12] = 0x8a;
-        cs423x->regs[13] = 0;
-        cs423x->regs[14] = cs423x->regs[15] = 0;
-		cs423x->regs[16] = cs423x->regs[17] = 0;
-		cs423x->regs[18] = cs423x->regs[19] = 0x88;
-		cs423x->regs[22] = 0x80;
-		cs423x->regs[24] = 0;
-		cs423x->regs[25] = CS4231; //CS4231 for GUS MAX
-		cs423x->regs[26] = 0x80;
-		cs423x->regs[29] = 0x80;        
-        
-        cs423x->out_l = 0;
-        cs423x->out_r = 0;
-        
-        for (c = 0; c < 64; c++) // DAC and Loopback attenuation
-        {
-                attenuation = 0.0;
-                if (c & 0x01) attenuation -= 1.5;
-                if (c & 0x02) attenuation -= 3.0;
-                if (c & 0x04) attenuation -= 6.0;
-                if (c & 0x08) attenuation -= 12.0;
-                if (c & 0x10) attenuation -= 24.0;
-                if (c & 0x20) attenuation -= 48.0;
-                
-                attenuation = pow(10, attenuation / 10);      
-                cs423x_vols[c] = (int)(attenuation * 65536);
-        }       
-        timer_add(cs423x_poll, &cs423x->timer_count, &cs423x->enable, cs423x);
+	cs423x->enable = 0;
+
+	cs423x->status = 0xcc;
+	cs423x->index = cs423x->trd = 0;
+	cs423x->mce = 0x40;
+	cs423x->initb = 0;
+	cs423x->mode2 = 0;
+
+	cs423x->regs[0] = cs423x->regs[1] = 0;
+	cs423x->regs[2] = cs423x->regs[3] = 0x88;
+	cs423x->regs[4] = cs423x->regs[5] = 0x88;
+	cs423x->regs[6] = cs423x->regs[7] = 0x80;
+	cs423x->regs[8] = 0;
+	cs423x->regs[9] = 0x08;
+	cs423x->regs[10] = cs423x->regs[11] = 0;
+	cs423x->regs[12] = 0x8a;
+	cs423x->regs[13] = 0;
+	cs423x->regs[14] = cs423x->regs[15] = 0;
+	cs423x->regs[16] = cs423x->regs[17] = 0;
+	cs423x->regs[18] = cs423x->regs[19] = 0x88;
+	cs423x->regs[22] = 0x80;
+	cs423x->regs[24] = 0;
+	cs423x->regs[25] = CS4231; //CS4231 for GUS MAX
+	cs423x->regs[26] = 0x80;
+	cs423x->regs[29] = 0x80;
+
+	cs423x->out_l = 0;
+	cs423x->out_r = 0;
+
+	for (c = 0; c < 64; c++) // DAC and Loopback attenuation
+	{
+		attenuation = 0.0;
+		if (c & 0x01) attenuation -= 1.5;
+		if (c & 0x02) attenuation -= 3.0;
+		if (c & 0x04) attenuation -= 6.0;
+		if (c & 0x08) attenuation -= 12.0;
+		if (c & 0x10) attenuation -= 24.0;
+		if (c & 0x20) attenuation -= 48.0;
+
+		attenuation = pow(10, attenuation / 10);
+		cs423x_vols[c] = (int)(attenuation * 65536);
+	}
+	timer_add(cs423x_poll, &cs423x->timer_count, &cs423x->enable, cs423x);
 }
diff --git a/src/devices/sound/snd_cs423x.h b/src/devices/sound/snd_cs423x.h
index 0ecc0a1..33cb266 100644
--- a/src/devices/sound/snd_cs423x.h
+++ b/src/devices/sound/snd_cs423x.h
@@ -32,33 +32,33 @@
  *   Boston, MA 02111-1307
  *   USA.
  */
- 
+
 typedef struct cs423x_t
 {
-        int index;
-		uint8_t regs[32];
-        uint8_t status;
-        
-        int trd;
-        int mce;
-		int ia4;
-		int mode2;
-		int initb;
-        
-        int count;
-        
-        int16_t out_l, out_r;
-                
-        int64_t enable;
+	int index;
+	uint8_t regs[32];
+	uint8_t status;
 
-        int irq, dma;
-        
-        int64_t freq;
-        
-        int64_t timer_count, timer_latch;
+	int trd;
+	int mce;
+	int ia4;
+	int mode2;
+	int initb;
 
-        int16_t buffer[SOUNDBUFLEN * 2];
-        int pos;
+	int count;
+
+	int16_t out_l, out_r;
+
+	int64_t enable;
+
+	int irq, dma;
+
+	int64_t freq;
+
+	int64_t timer_count, timer_latch;
+
+	int16_t buffer[SOUNDBUFLEN * 2];
+	int pos;
 } cs423x_t;
 
 void cs423x_setirq(cs423x_t *cs423x, int irq);
diff --git a/src/devices/sound/snd_gus.c b/src/devices/sound/snd_gus.c
index 1e5ca84..40e16b4 100644
--- a/src/devices/sound/snd_gus.c
+++ b/src/devices/sound/snd_gus.c
@@ -57,103 +57,103 @@
 
 
 typedef struct {
-    int		reset;
+	int		reset;
 
-    int		global;
-    uint32_t	addr,
+	int		global;
+	uint32_t	addr,
 		dmaaddr;
-    int		voice;
-    uint32_t	start[32],
+	int		voice;
+	uint32_t	start[32],
 		end[32],
 		cur[32];
-    uint32_t	startx[32],
+	uint32_t	startx[32],
 		endx[32],
 		curx[32];
-    int		rstart[32],
+	int		rstart[32],
 		rend[32];
-    int		rcur[32];
-    uint16_t	freq[32];
-    uint16_t	rfreq[32];
-    uint8_t	ctrl[32];
-    uint8_t	rctrl[32];
-    int		curvol[32];
-    int		pan_l[32],
+	int		rcur[32];
+	uint16_t	freq[32];
+	uint16_t	rfreq[32];
+	uint8_t	ctrl[32];
+	uint8_t	rctrl[32];
+	int		curvol[32];
+	int		pan_l[32],
 		pan_r[32];
-    int		t1on,
+	int		t1on,
 		t2on;
-    uint8_t	tctrl;
-    uint16_t	t1,
+	uint8_t	tctrl;
+	uint16_t	t1,
 		t2,
 		t1l,
 		t2l;
-    uint8_t	irqstatus,
+	uint8_t	irqstatus,
 		irqstatus2;
-    uint8_t	adcommand;
-    int		waveirqs[32],
+	uint8_t	adcommand;
+	int		waveirqs[32],
 		rampirqs[32];
-    int		voices;
-    uint8_t	dmactrl;
+	int		voices;
+	uint8_t	dmactrl;
 
-    int32_t	out_l,
+	int32_t	out_l,
 		out_r;
 
-    int64_t	samp_timer,
+	int64_t	samp_timer,
 		samp_latch;
 
-    uint8_t	*ram;
+	uint8_t	*ram;
 
-    int pos;
-    int16_t	buffer[2][SOUNDBUFLEN];
+	int pos;
+	int16_t	buffer[2][SOUNDBUFLEN];
 
-    int		irqnext;
+	int		irqnext;
 
-    int64_t	timer_1,
+	int64_t	timer_1,
 		timer_2;
 
-    int		irq,
+	int		irq,
 		dma,
 		irq_midi;
-    int		latch_enable;
+	int		latch_enable;
 
-    uint8_t	sb_2xa,
+	uint8_t	sb_2xa,
 		sb_2xc,
 		sb_2xe;
-    uint8_t	sb_ctrl;
-    int		sb_nmi;
+	uint8_t	sb_ctrl;
+	int		sb_nmi;
 
-    uint8_t	reg_ctrl;
+	uint8_t	reg_ctrl;
 
-    uint8_t	ad_status,
+	uint8_t	ad_status,
 		ad_data;
-    uint8_t	ad_timer_ctrl;
+	uint8_t	ad_timer_ctrl;
 
-    uint8_t	midi_ctrl,
+	uint8_t	midi_ctrl,
 		midi_status;
-    uint8_t	midi_data;
-    int		midi_loopback;
+	uint8_t	midi_data;
+	int		midi_loopback;
 
-    uint8_t	gp1,
+	uint8_t	gp1,
 		gp2;
-    uint16_t	gp1_addr,
+	uint16_t	gp1_addr,
 		gp2_addr;
 
-    uint8_t	usrr;
+	uint8_t	usrr;
 
-    uint8_t	max_ctrl;
+	uint8_t	max_ctrl;
 #if defined(DEV_BRANCH) && defined(USE_GUSMAX)
-    cs423x_t    cs423x; 
+	cs423x_t    cs423x;
 #endif    
 
 } gus_t;
 
 
-static const int gus_irqs[8] = {-1, 2, 5, 3, 7, 11, 12, 15};
-static const int gus_irqs_midi[8] = {-1, 2, 5, 3, 7, 11, 12, 15};
-static const int gus_dmas[8] = {-1, 1, 3, 5, 6, 7, -1, -1};
+static const int gus_irqs[8] = { -1, 2, 5, 3, 7, 11, 12, 15 };
+static const int gus_irqs_midi[8] = { -1, 2, 5, 3, 7, 11, 12, 15 };
+static const int gus_dmas[8] = { -1, 1, 3, 5, 6, 7, -1, -1 };
 static const int gusfreqs[] = {
-    44100, 41160, 38587, 36317, 34300, 32494, 30870, 29400,
-    28063, 26843, 25725, 24696, 23746, 22866, 22050, 21289,
-    20580, 19916, 19293
+	44100, 41160, 38587, 36317, 34300, 32494, 30870, 29400,
+	28063, 26843, 25725, 24696, 23746, 22866, 22050, 21289,
+	20580, 19916, 19293
 };
 
 
@@ -163,96 +163,98 @@ static double vol16bit[4096];
 static void
 poll_irqs(gus_t *dev)
 {
-    int c;
+	int c;
 
-    dev->irqstatus &= ~0x60;
-    for (c = 0; c < 32; c++) {
-	if (dev->waveirqs[c]) {
-		dev->irqstatus2 = 0x60 | c;
-		if (dev->rampirqs[c])
-			dev->irqstatus2 |= 0x80;
-		dev->irqstatus |= 0x20;
-		if (dev->irq != -1)
-			picint(1 << dev->irq);
-		return;
+	dev->irqstatus &= ~0x60;
+	for (c = 0; c < 32; c++) {
+		if (dev->waveirqs[c]) {
+			dev->irqstatus2 = 0x60 | c;
+			if (dev->rampirqs[c])
+				dev->irqstatus2 |= 0x80;
+			dev->irqstatus |= 0x20;
+			if (dev->irq != -1)
+				picint(1 << dev->irq);
+			return;
+		}
+
+		if (dev->rampirqs[c]) {
+			dev->irqstatus2 = 0xA0 | c;
+			dev->irqstatus |= 0x40;
+			if (dev->irq != -1)
+				picint(1 << dev->irq);
+			return;
+		}
 	}
 
-	if (dev->rampirqs[c]) {
-		dev->irqstatus2 = 0xA0 | c;
-		dev->irqstatus |= 0x40;
-		if (dev->irq != -1)
-			picint(1 << dev->irq);
-		return;
-	}
-    }
+	dev->irqstatus2 = 0xE0;
 
-    dev->irqstatus2 = 0xE0;
-
-    if (!dev->irqstatus && dev->irq != -1)
-	picintc(1 << dev->irq);
+	if (!dev->irqstatus && dev->irq != -1)
+		picintc(1 << dev->irq);
 }
 
 
 enum {
-    MIDI_INT_RECEIVE = 0x01,
-    MIDI_INT_TRANSMIT = 0x02,
-    MIDI_INT_MASTER = 0x80
+	MIDI_INT_RECEIVE = 0x01,
+	MIDI_INT_TRANSMIT = 0x02,
+	MIDI_INT_MASTER = 0x80
 };
 
 enum {
-    MIDI_CTRL_TRANSMIT_MASK = 0x60,
-    MIDI_CTRL_TRANSMIT = 0x20,
-    MIDI_CTRL_RECEIVE = 0x80
+	MIDI_CTRL_TRANSMIT_MASK = 0x60,
+	MIDI_CTRL_TRANSMIT = 0x20,
+	MIDI_CTRL_RECEIVE = 0x80
 };
 
 enum {
-    GUS_INT_MIDI_TRANSMIT = 0x01,
-    GUS_INT_MIDI_RECEIVE  = 0x02
+	GUS_INT_MIDI_TRANSMIT = 0x01,
+	GUS_INT_MIDI_RECEIVE = 0x02
 };
 
 enum {
-    GUS_TIMER_CTRL_AUTO = 0x01
+	GUS_TIMER_CTRL_AUTO = 0x01
 };
 
 
 static void
 midi_update_int_status(gus_t *dev)
 {
-    dev->midi_status &= ~MIDI_INT_MASTER;
+	dev->midi_status &= ~MIDI_INT_MASTER;
 
-    if ((dev->midi_ctrl & MIDI_CTRL_TRANSMIT_MASK) == MIDI_CTRL_TRANSMIT && (dev->midi_status & MIDI_INT_TRANSMIT)) {
-	dev->midi_status |= MIDI_INT_MASTER;
-	dev->irqstatus |= GUS_INT_MIDI_TRANSMIT;
-    } else
-	dev->irqstatus &= ~GUS_INT_MIDI_TRANSMIT;
+	if ((dev->midi_ctrl & MIDI_CTRL_TRANSMIT_MASK) == MIDI_CTRL_TRANSMIT && (dev->midi_status & MIDI_INT_TRANSMIT)) {
+		dev->midi_status |= MIDI_INT_MASTER;
+		dev->irqstatus |= GUS_INT_MIDI_TRANSMIT;
+	}
+	else
+		dev->irqstatus &= ~GUS_INT_MIDI_TRANSMIT;
 
-    if ((dev->midi_ctrl & MIDI_CTRL_RECEIVE) && (dev->midi_status & MIDI_INT_RECEIVE)) {
-	dev->midi_status |= MIDI_INT_MASTER;
-	dev->irqstatus |= GUS_INT_MIDI_RECEIVE;
-    } else
-	dev->irqstatus &= ~GUS_INT_MIDI_RECEIVE;
+	if ((dev->midi_ctrl & MIDI_CTRL_RECEIVE) && (dev->midi_status & MIDI_INT_RECEIVE)) {
+		dev->midi_status |= MIDI_INT_MASTER;
+		dev->irqstatus |= GUS_INT_MIDI_RECEIVE;
+	}
+	else
+		dev->irqstatus &= ~GUS_INT_MIDI_RECEIVE;
 
-    if ((dev->midi_status & MIDI_INT_MASTER) && (dev->irq_midi != -1)) {
-	picint(1 << dev->irq_midi);
-    }
+	if ((dev->midi_status & MIDI_INT_MASTER) && (dev->irq_midi != -1)) {
+		picint(1 << dev->irq_midi);
+	}
 }
 
 
 static void
 gus_write(uint16_t addr, uint8_t val, void *priv)
 {
-    gus_t *dev = (gus_t *)priv;
-    int c, d;
-    int old;
+	gus_t *dev = (gus_t *)priv;
+	int c, d;
+	int old;
 
-    if (dev->latch_enable && addr != 0x24b)
-	dev->latch_enable = 0;
+	if (dev->latch_enable && addr != 0x24b)
+		dev->latch_enable = 0;
 
-    switch (addr) {
+	switch (addr) {
 	case 0x340: /*MIDI control*/
 		old = dev->midi_ctrl;
 		dev->midi_ctrl = val;
-		
+
 		if ((val & 3) == 3)
 			dev->midi_status = 0;
 		else if ((old & 3) == 3)
@@ -264,7 +266,8 @@ gus_write(uint16_t addr, uint8_t val, void *priv)
 		if (dev->midi_loopback) {
 			dev->midi_status |= MIDI_INT_RECEIVE;
 			dev->midi_data = val;
-		} else
+		}
+		else
 			dev->midi_status |= MIDI_INT_TRANSMIT;
 		break;
 
@@ -278,253 +281,256 @@ gus_write(uint16_t addr, uint8_t val, void *priv)
 
 	case 0x344: /*Global low*/
 		switch (dev->global) {
-			case 0: /*Voice control*/
-				dev->ctrl[dev->voice] = val;
-				break;
+		case 0: /*Voice control*/
+			dev->ctrl[dev->voice] = val;
+			break;
 
-			case 1: /*Frequency control*/
-				dev->freq[dev->voice] = (dev->freq[dev->voice]&0xFF00)|val;
-				break;
+		case 1: /*Frequency control*/
+			dev->freq[dev->voice] = (dev->freq[dev->voice] & 0xFF00) | val;
+			break;
 
-			case 2: /*Start addr high*/
-				dev->startx[dev->voice] = (dev->startx[dev->voice]&0xF807F)|(val<<7);
-				dev->start[dev->voice] = (dev->start[dev->voice]&0x1F00FFFF)|(val<<16);
-				break;
+		case 2: /*Start addr high*/
+			dev->startx[dev->voice] = (dev->startx[dev->voice] & 0xF807F) | (val << 7);
+			dev->start[dev->voice] = (dev->start[dev->voice] & 0x1F00FFFF) | (val << 16);
+			break;
 
-			case 3: /*Start addr low*/
-				dev->start[dev->voice] = (dev->start[dev->voice]&0x1FFFFF00)|val;
-				break;
+		case 3: /*Start addr low*/
+			dev->start[dev->voice] = (dev->start[dev->voice] & 0x1FFFFF00) | val;
+			break;
 
-			case 4: /*End addr high*/
-				dev->endx[dev->voice] = (dev->endx[dev->voice]&0xF807F)|(val<<7);
-				dev->end[dev->voice] = (dev->end[dev->voice]&0x1F00FFFF)|(val<<16);
-				break;
+		case 4: /*End addr high*/
+			dev->endx[dev->voice] = (dev->endx[dev->voice] & 0xF807F) | (val << 7);
+			dev->end[dev->voice] = (dev->end[dev->voice] & 0x1F00FFFF) | (val << 16);
+			break;
 
-			case 5: /*End addr low*/
-				dev->end[dev->voice] = (dev->end[dev->voice]&0x1FFFFF00)|val;
-				break;
+		case 5: /*End addr low*/
+			dev->end[dev->voice] = (dev->end[dev->voice] & 0x1FFFFF00) | val;
+			break;
 
-			case 0x6: /*Ramp frequency*/
-				dev->rfreq[dev->voice] = (int)( (double)((val & 63)*512)/(double)(1 << (3*(val >> 6))));
-				break;
+		case 0x6: /*Ramp frequency*/
+			dev->rfreq[dev->voice] = (int)((double)((val & 63) * 512) / (double)(1 << (3 * (val >> 6))));
+			break;
 
-			case 0x9: /*Current volume*/
-				dev->curvol[dev->voice] = dev->rcur[dev->voice] = (dev->rcur[dev->voice] & ~(0xff << 6)) | (val << 6);
-				break;
+		case 0x9: /*Current volume*/
+			dev->curvol[dev->voice] = dev->rcur[dev->voice] = (dev->rcur[dev->voice] & ~(0xff << 6)) | (val << 6);
+			break;
 
-			case 0xA: /*Current addr high*/
-				dev->cur[dev->voice] = (dev->cur[dev->voice]&0x1F00FFFF)|(val<<16);
-				dev->curx[dev->voice] = (dev->curx[dev->voice]&0xF807F00)|((val<<7)<<8);
-				break;
+		case 0xA: /*Current addr high*/
+			dev->cur[dev->voice] = (dev->cur[dev->voice] & 0x1F00FFFF) | (val << 16);
+			dev->curx[dev->voice] = (dev->curx[dev->voice] & 0xF807F00) | ((val << 7) << 8);
+			break;
 
-			case 0xB: /*Current addr low*/
-				dev->cur[dev->voice] = (dev->cur[dev->voice]&0x1FFFFF00)|val;
-				break;
+		case 0xB: /*Current addr low*/
+			dev->cur[dev->voice] = (dev->cur[dev->voice] & 0x1FFFFF00) | val;
+			break;
 
-			case 0x42: /*DMA address low*/
-				dev->dmaaddr = (dev->dmaaddr&0xFF000)|(val<<4);
-				break;
+		case 0x42: /*DMA address low*/
+			dev->dmaaddr = (dev->dmaaddr & 0xFF000) | (val << 4);
+			break;
 
-			case 0x43: /*Address low*/
-				dev->addr = (dev->addr&0xFFF00)|val;
-				break;
+		case 0x43: /*Address low*/
+			dev->addr = (dev->addr & 0xFFF00) | val;
+			break;
 
-			case 0x45: /*Timer control*/
-				dev->tctrl = val;
-				break;
+		case 0x45: /*Timer control*/
+			dev->tctrl = val;
+			break;
 		}
 		break;
 
 	case 0x345: /*Global high*/
 		switch (dev->global) {
-			case 0: /*Voice control*/
-				if (!(val&1) && dev->ctrl[dev->voice]&1) {
-				}
+		case 0: /*Voice control*/
+			if (!(val & 1) && dev->ctrl[dev->voice] & 1) {
+			}
 
-				dev->ctrl[dev->voice] = val & 0x7f;
+			dev->ctrl[dev->voice] = val & 0x7f;
 
-				old = dev->waveirqs[dev->voice];
-				dev->waveirqs[dev->voice] = ((val & 0xa0) == 0xa0) ? 1 : 0;			
-				if (dev->waveirqs[dev->voice] != old) 
-					poll_irqs(dev);
-				break;
+			old = dev->waveirqs[dev->voice];
+			dev->waveirqs[dev->voice] = ((val & 0xa0) == 0xa0) ? 1 : 0;
+			if (dev->waveirqs[dev->voice] != old)
+				poll_irqs(dev);
+			break;
 
-			case 1: /*Frequency control*/
-				dev->freq[dev->voice] = (dev->freq[dev->voice]&0xFF)|(val<<8);
-				break;
+		case 1: /*Frequency control*/
+			dev->freq[dev->voice] = (dev->freq[dev->voice] & 0xFF) | (val << 8);
+			break;
 
-			case 2: /*Start addr high*/
-				dev->startx[dev->voice] = (dev->startx[dev->voice]&0x07FFF)|(val<<15);
-				dev->start[dev->voice] = (dev->start[dev->voice]&0x00FFFFFF)|((val&0x1F)<<24);
-				break;
+		case 2: /*Start addr high*/
+			dev->startx[dev->voice] = (dev->startx[dev->voice] & 0x07FFF) | (val << 15);
+			dev->start[dev->voice] = (dev->start[dev->voice] & 0x00FFFFFF) | ((val & 0x1F) << 24);
+			break;
 
-			case 3: /*Start addr low*/
-				dev->startx[dev->voice] = (dev->startx[dev->voice]&0xFFF80)|(val&0x7F);
-				dev->start[dev->voice] = (dev->start[dev->voice]&0x1FFF00FF)|(val<<8);
-				break;
+		case 3: /*Start addr low*/
+			dev->startx[dev->voice] = (dev->startx[dev->voice] & 0xFFF80) | (val & 0x7F);
+			dev->start[dev->voice] = (dev->start[dev->voice] & 0x1FFF00FF) | (val << 8);
+			break;
 
-			case 4: /*End addr high*/
-				dev->endx[dev->voice] = (dev->endx[dev->voice]&0x07FFF)|(val<<15);
-				dev->end[dev->voice] = (dev->end[dev->voice]&0x00FFFFFF)|((val&0x1F)<<24);
-				break;
+		case 4: /*End addr high*/
+			dev->endx[dev->voice] = (dev->endx[dev->voice] & 0x07FFF) | (val << 15);
+			dev->end[dev->voice] = (dev->end[dev->voice] & 0x00FFFFFF) | ((val & 0x1F) << 24);
+			break;
 
-			case 5: /*End addr low*/
-				dev->endx[dev->voice] = (dev->endx[dev->voice]&0xFFF80)|(val&0x7F);
-				dev->end[dev->voice] = (dev->end[dev->voice]&0x1FFF00FF)|(val<<8);
-				break;
+		case 5: /*End addr low*/
+			dev->endx[dev->voice] = (dev->endx[dev->voice] & 0xFFF80) | (val & 0x7F);
+			dev->end[dev->voice] = (dev->end[dev->voice] & 0x1FFF00FF) | (val << 8);
+			break;
 
-			case 0x6: /*Ramp frequency*/
-				dev->rfreq[dev->voice] = (int)( (double)((val & 63) * (1 << 10))/(double)(1 << (3 * (val >> 6))));
-				break;
+		case 0x6: /*Ramp frequency*/
+			dev->rfreq[dev->voice] = (int)((double)((val & 63) * (1 << 10)) / (double)(1 << (3 * (val >> 6))));
+			break;
 
-			case 0x7: /*Ramp start*/
-				dev->rstart[dev->voice] = val << 14;
-				break;
+		case 0x7: /*Ramp start*/
+			dev->rstart[dev->voice] = val << 14;
+			break;
 
-			case 0x8: /*Ramp end*/
-				dev->rend[dev->voice] = val << 14;
-				break;
+		case 0x8: /*Ramp end*/
+			dev->rend[dev->voice] = val << 14;
+			break;
 
-			case 0x9: /*Current volume*/
-				dev->curvol[dev->voice] = dev->rcur[dev->voice] = (dev->rcur[dev->voice] & ~(0xff << 14)) | (val << 14);
-				break;
+		case 0x9: /*Current volume*/
+			dev->curvol[dev->voice] = dev->rcur[dev->voice] = (dev->rcur[dev->voice] & ~(0xff << 14)) | (val << 14);
+			break;
 
-			case 0xA: /*Current addr high*/
-				dev->cur[dev->voice] = (dev->cur[dev->voice]&0x00FFFFFF)|((val&0x1F)<<24);
-				dev->curx[dev->voice] = (dev->curx[dev->voice]&0x07FFF00)|((val<<15)<<8);
-				break;
+		case 0xA: /*Current addr high*/
+			dev->cur[dev->voice] = (dev->cur[dev->voice] & 0x00FFFFFF) | ((val & 0x1F) << 24);
+			dev->curx[dev->voice] = (dev->curx[dev->voice] & 0x07FFF00) | ((val << 15) << 8);
+			break;
 
-			case 0xB: /*Current addr low*/
-				dev->cur[dev->voice] = (dev->cur[dev->voice]&0x1FFF00FF)|(val<<8);
-				dev->curx[dev->voice] = (dev->curx[dev->voice]&0xFFF8000)|((val&0x7F)<<8);
-				break;
+		case 0xB: /*Current addr low*/
+			dev->cur[dev->voice] = (dev->cur[dev->voice] & 0x1FFF00FF) | (val << 8);
+			dev->curx[dev->voice] = (dev->curx[dev->voice] & 0xFFF8000) | ((val & 0x7F) << 8);
+			break;
 
-			case 0xC: /*Pan*/
-				dev->pan_l[dev->voice] = 15 - (val & 0xf);
-				dev->pan_r[dev->voice] = (val & 0xf);
-				break;
+		case 0xC: /*Pan*/
+			dev->pan_l[dev->voice] = 15 - (val & 0xf);
+			dev->pan_r[dev->voice] = (val & 0xf);
+			break;
 
-			case 0xD: /*Ramp control*/
-				old = dev->rampirqs[dev->voice];
-				dev->rctrl[dev->voice] = val & 0x7F;
-				dev->rampirqs[dev->voice] = ((val & 0xa0) == 0xa0) ? 1 : 0;			
-				if (dev->rampirqs[dev->voice] != old)
-					poll_irqs(dev);
-				break;
+		case 0xD: /*Ramp control*/
+			old = dev->rampirqs[dev->voice];
+			dev->rctrl[dev->voice] = val & 0x7F;
+			dev->rampirqs[dev->voice] = ((val & 0xa0) == 0xa0) ? 1 : 0;
+			if (dev->rampirqs[dev->voice] != old)
+				poll_irqs(dev);
+			break;
 
-			case 0xE:
-				dev->voices = (val & 63) + 1;
-				if (dev->voices>32) dev->voices = 32;
-				if (dev->voices<14) dev->voices = 14;
-				dev->global = val;
-				if (dev->voices < 14)
-					dev->samp_latch = (int)(TIMER_USEC * (1000000.0 / 44100.0));
-				else
-					dev->samp_latch = (int)(TIMER_USEC * (1000000.0 / gusfreqs[dev->voices - 14]));
-				break;
+		case 0xE:
+			dev->voices = (val & 63) + 1;
+			if (dev->voices > 32) dev->voices = 32;
+			if (dev->voices < 14) dev->voices = 14;
+			dev->global = val;
+			if (dev->voices < 14)
+				dev->samp_latch = (int)(TIMER_USEC * (1000000.0 / 44100.0));
+			else
+				dev->samp_latch = (int)(TIMER_USEC * (1000000.0 / gusfreqs[dev->voices - 14]));
+			break;
 
-			case 0x41: /*DMA*/
-				if (val&1 && dev->dma != -1) {
-					if (val & 2) {
-						c = 0;
-						while (c < 65536) {
-							int dma_result;
+		case 0x41: /*DMA*/
+			if (val & 1 && dev->dma != -1) {
+				if (val & 2) {
+					c = 0;
+					while (c < 65536) {
+						int dma_result;
 
-							if (val & 0x04) {
-								uint32_t gus_addr = (dev->dmaaddr & 0xc0000) | ((dev->dmaaddr & 0x1ffff) << 1);
-								d = dev->ram[gus_addr] | (dev->ram[gus_addr + 1] << 8);
-								if (val & 0x80)
-									d ^= 0x8080;
-								dma_result = dma_channel_write(dev->dma, d);
-								if (dma_result == DMA_NODATA)
-									break;
-							} else {
-								d = dev->ram[dev->dmaaddr];
-								if (val & 0x80)
-									d ^= 0x80;
-								dma_result = dma_channel_write(dev->dma, d);
-								if (dma_result == DMA_NODATA)
-									break;
-							}
-							dev->dmaaddr++;
-							dev->dmaaddr &= 0xFFFFF;
-							c++;
-							if (dma_result & DMA_OVER)
+						if (val & 0x04) {
+							uint32_t gus_addr = (dev->dmaaddr & 0xc0000) | ((dev->dmaaddr & 0x1ffff) << 1);
+							d = dev->ram[gus_addr] | (dev->ram[gus_addr + 1] << 8);
+							if (val & 0x80)
+								d ^= 0x8080;
+							dma_result = dma_channel_write(dev->dma, d);
+							if (dma_result == DMA_NODATA)
 								break;
 						}
-						dev->dmactrl = val & ~0x40;
-						if (val & 0x20)
-							dev->irqnext = 1;
-					} else {
-						c = 0;
-						while (c < 65536) {
-							d = dma_channel_read(dev->dma);
-							if (d == DMA_NODATA)
-								break;
-							if (val & 0x04) {
-								uint32_t gus_addr = (dev->dmaaddr & 0xc0000) | ((dev->dmaaddr & 0x1ffff) << 1);
-								if (val & 0x80)
-									d ^= 0x8080;
-								dev->ram[gus_addr] = d & 0xff;
-								dev->ram[gus_addr +1] = (d >> 8) & 0xff;
-							} else {
-								if (val & 0x80)
-									d ^= 0x80;
-								dev->ram[dev->dmaaddr] = d;
-							}
-							dev->dmaaddr++;
-							dev->dmaaddr &= 0xFFFFF;
-							c++;
-							if (d & DMA_OVER)
+						else {
+							d = dev->ram[dev->dmaaddr];
+							if (val & 0x80)
+								d ^= 0x80;
+							dma_result = dma_channel_write(dev->dma, d);
+							if (dma_result == DMA_NODATA)
 								break;
 						}
-						dev->dmactrl = val & ~0x40;
-						if (val & 0x20)
-							dev->irqnext = 1;
+						dev->dmaaddr++;
+						dev->dmaaddr &= 0xFFFFF;
+						c++;
+						if (dma_result & DMA_OVER)
+							break;
 					}
+					dev->dmactrl = val & ~0x40;
+					if (val & 0x20)
+						dev->irqnext = 1;
 				}
-				break;
-
-			case 0x42: /*DMA address low*/
-				dev->dmaaddr = (dev->dmaaddr&0xFF0)|(val<<12);
-				break;
-
-			case 0x43: /*Address low*/
-				dev->addr = (dev->addr&0xF00FF)|(val<<8);
-				break;
-
-			case 0x44: /*Address high*/
-				dev->addr = (dev->addr&0xFFFF)|((val<<16)&0xF0000);
-				break;
-
-			case 0x45: /*Timer control*/
-				if (! (val & 4)) dev->irqstatus &= ~4;
-				if (! (val & 8)) dev->irqstatus &= ~8;
-				if (! (val & 0x20)) {
-					dev->ad_status &= ~0x18;
-					nmi = 0;
+				else {
+					c = 0;
+					while (c < 65536) {
+						d = dma_channel_read(dev->dma);
+						if (d == DMA_NODATA)
+							break;
+						if (val & 0x04) {
+							uint32_t gus_addr = (dev->dmaaddr & 0xc0000) | ((dev->dmaaddr & 0x1ffff) << 1);
+							if (val & 0x80)
+								d ^= 0x8080;
+							dev->ram[gus_addr] = d & 0xff;
+							dev->ram[gus_addr + 1] = (d >> 8) & 0xff;
+						}
+						else {
+							if (val & 0x80)
+								d ^= 0x80;
+							dev->ram[dev->dmaaddr] = d;
+						}
+						dev->dmaaddr++;
+						dev->dmaaddr &= 0xFFFFF;
+						c++;
+						if (d & DMA_OVER)
+							break;
+					}
+					dev->dmactrl = val & ~0x40;
+					if (val & 0x20)
+						dev->irqnext = 1;
 				}
-				if (! (val & 0x02)) {
-					dev->ad_status &= ~0x01;
-					nmi = 0;
-				}
-				dev->tctrl = val;
-				dev->sb_ctrl = val;
-				break;
+			}
+			break;
 
-			case 0x46: /*Timer 1*/
-				dev->t1 = dev->t1l = val;
-				dev->t1on = 1;
-				break;
+		case 0x42: /*DMA address low*/
+			dev->dmaaddr = (dev->dmaaddr & 0xFF0) | (val << 12);
+			break;
 
-			case 0x47: /*Timer 2*/
-				dev->t2 = dev->t2l = val;
-				dev->t2on = 1;
-				break;
+		case 0x43: /*Address low*/
+			dev->addr = (dev->addr & 0xF00FF) | (val << 8);
+			break;
 
-			case 0x4c: /*Reset*/
-				dev->reset = val;
-				break;
+		case 0x44: /*Address high*/
+			dev->addr = (dev->addr & 0xFFFF) | ((val << 16) & 0xF0000);
+			break;
+
+		case 0x45: /*Timer control*/
+			if (!(val & 4)) dev->irqstatus &= ~4;
+			if (!(val & 8)) dev->irqstatus &= ~8;
+			if (!(val & 0x20)) {
+				dev->ad_status &= ~0x18;
+				nmi = 0;
+			}
+			if (!(val & 0x02)) {
+				dev->ad_status &= ~0x01;
+				nmi = 0;
+			}
+			dev->tctrl = val;
+			dev->sb_ctrl = val;
+			break;
+
+		case 0x46: /*Timer 1*/
+			dev->t1 = dev->t1l = val;
+			dev->t1on = 1;
+			break;
+
+		case 0x47: /*Timer 2*/
+			dev->t2 = dev->t2l = val;
+			dev->t2on = 1;
+			break;
+
+		case 0x4c: /*Reset*/
+			dev->reset = val;
+			break;
 		}
 		break;
 
@@ -534,8 +540,8 @@ gus_write(uint16_t addr, uint8_t val, void *priv)
 		break;
 
 	case 0x248:
-	case 0x388: 
-		dev->adcommand = val; 
+	case 0x388:
+		dev->adcommand = val;
 		break;
 
 	case 0x389:
@@ -548,12 +554,14 @@ gus_write(uint16_t addr, uint8_t val, void *priv)
 				else if (dev->irq != -1)
 					picint(1 << dev->irq);
 			}
-		} else if (!(dev->tctrl & GUS_TIMER_CTRL_AUTO) && dev->adcommand == 4) {
+		}
+		else if (!(dev->tctrl & GUS_TIMER_CTRL_AUTO) && dev->adcommand == 4) {
 			if (val & 0x80) {
 				dev->ad_status &= ~0x60;
-			} else {
+			}
+			else {
 				dev->ad_timer_ctrl = val;
-			
+
 				if (val & 0x01)
 					dev->t1on = 1;
 				else
@@ -574,53 +582,54 @@ gus_write(uint16_t addr, uint8_t val, void *priv)
 
 	case 0x24b:
 		switch (dev->reg_ctrl & 0x07) {
-			case 0:
-				if (dev->latch_enable == 1)
-					dev->dma = gus_dmas[val & 7];
+		case 0:
+			if (dev->latch_enable == 1)
+				dev->dma = gus_dmas[val & 7];
 #if defined(DEV_BRANCH) && defined(USE_GUSMAX)
-					cs423x_setdma(&dev->cs423x, dev->dma);
+			cs423x_setdma(&dev->cs423x, dev->dma);
 #endif					
-				if (dev->latch_enable == 2) {
-					dev->irq = gus_irqs[val & 7];
+			if (dev->latch_enable == 2) {
+				dev->irq = gus_irqs[val & 7];
 
-					if (val & 0x40) {
-						if (dev->irq == -1)
-							dev->irq = dev->irq_midi = gus_irqs[(val >> 3) & 7];
-						else
-							dev->irq_midi = dev->irq;
-					} else
-						dev->irq_midi = gus_irqs_midi[(val >> 3) & 7];
-#if defined(DEV_BRANCH) && defined(USE_GUSMAX)		
-						cs423x_setirq(&dev->cs423x, dev->irq);			
-#endif
-					dev->sb_nmi = val & 0x80;
+				if (val & 0x40) {
+					if (dev->irq == -1)
+						dev->irq = dev->irq_midi = gus_irqs[(val >> 3) & 7];
+					else
+						dev->irq_midi = dev->irq;
 				}
-				dev->latch_enable = 0;
-				break;
+				else
+					dev->irq_midi = gus_irqs_midi[(val >> 3) & 7];
+#if defined(DEV_BRANCH) && defined(USE_GUSMAX)		
+				cs423x_setirq(&dev->cs423x, dev->irq);
+#endif
+				dev->sb_nmi = val & 0x80;
+			}
+			dev->latch_enable = 0;
+			break;
 
-			case 1:
-				dev->gp1 = val;
-				break;
+		case 1:
+			dev->gp1 = val;
+			break;
 
-			case 2:
-				dev->gp2 = val;
-				break;
+		case 2:
+			dev->gp2 = val;
+			break;
 
-			case 3:
-				dev->gp1_addr = val;
-				break;
+		case 3:
+			dev->gp1_addr = val;
+			break;
 
-			case 4:
-				dev->gp2_addr = val;
-				break;
+		case 4:
+			dev->gp2_addr = val;
+			break;
 
-			case 5:
-				dev->usrr = 0;
-				break;
+		case 5:
+			dev->usrr = 0;
+			break;
 
-			case 6:
-				break;			
-		}		
+		case 6:
+			break;
+		}
 		break;
 
 	case 0x246:
@@ -658,28 +667,28 @@ gus_write(uint16_t addr, uint8_t val, void *priv)
 	case 0x24f:
 		dev->reg_ctrl = val;
 		break;
-	
+
 	case 0x346:
 		if (dev->dma >= 4)
 			val |= 0x30;
 		dev->max_ctrl = (val >> 6) & 1;
-		pclog (0,"Enable CS4231 %X, val %02X\n", dev->max_ctrl,val);	
+		pclog(0, "Enable CS4231 %X, val %02X\n", dev->max_ctrl, val);
 		if (val & 0x40) {
-			 if ((val & 0xF) != ((addr >> 4) & 0xF)) 
-				 pclog(0,"DOS application is attempting to relocate the CS4231 codec\n");
+			if ((val & 0xF) != ((addr >> 4) & 0xF))
+				pclog(0, "DOS application is attempting to relocate the CS4231 codec\n");
 		}
 		break;
-    }
+	}
 }
 
 
 static uint8_t
 gus_read(uint16_t addr, void *priv)
 {
-    gus_t *dev = (gus_t *)priv;
-    uint8_t val = 0xff;
+	gus_t *dev = (gus_t *)priv;
+	uint8_t val = 0xff;
 
-    switch (addr) {
+	switch (addr) {
 	case 0x340: /*MIDI status*/
 		val = dev->midi_status;
 		break;
@@ -701,7 +710,7 @@ gus_read(uint16_t addr, void *priv)
 		break;
 
 	case 0x24F:
-		if(dev->max_ctrl)
+		if (dev->max_ctrl)
 			val = 0x02;
 		else
 			val = 0x00;
@@ -717,103 +726,103 @@ gus_read(uint16_t addr, void *priv)
 
 	case 0x344: /*Global low*/
 		switch (dev->global) {
-			case 0x82: /*Start addr high*/
-				val = dev->start[dev->voice]>>16;
-				break;
+		case 0x82: /*Start addr high*/
+			val = dev->start[dev->voice] >> 16;
+			break;
 
-			case 0x83: /*Start addr low*/
-				val = dev->start[dev->voice]&0xFF;
-				break;
+		case 0x83: /*Start addr low*/
+			val = dev->start[dev->voice] & 0xFF;
+			break;
 
-			case 0x89: /*Current volume*/
-				val = dev->rcur[dev->voice]>>6;
-				break;
+		case 0x89: /*Current volume*/
+			val = dev->rcur[dev->voice] >> 6;
+			break;
 
-			case 0x8A: /*Current addr high*/
-				val = dev->cur[dev->voice]>>16;
-				break;
+		case 0x8A: /*Current addr high*/
+			val = dev->cur[dev->voice] >> 16;
+			break;
 
-			case 0x8B: /*Current addr low*/
-				val = dev->cur[dev->voice]&0xFF;
-				break;
+		case 0x8B: /*Current addr low*/
+			val = dev->cur[dev->voice] & 0xFF;
+			break;
 
-			case 0x8F: /*IRQ status*/
-				val = dev->irqstatus2;
-				dev->rampirqs[dev->irqstatus2 & 0x1F] = 0;
-				dev->waveirqs[dev->irqstatus2 & 0x1F] = 0;
-				poll_irqs(dev);
-				break;
-			
-			case 0x00: case 0x01: case 0x02: case 0x03:
-			case 0x04: case 0x05: case 0x06: case 0x07:
-			case 0x08: case 0x09: case 0x0a: case 0x0b:
-			case 0x0c: case 0x0d: case 0x0e: case 0x0f:
-				val = 0xff;
-				break;
+		case 0x8F: /*IRQ status*/
+			val = dev->irqstatus2;
+			dev->rampirqs[dev->irqstatus2 & 0x1F] = 0;
+			dev->waveirqs[dev->irqstatus2 & 0x1F] = 0;
+			poll_irqs(dev);
+			break;
+
+		case 0x00: case 0x01: case 0x02: case 0x03:
+		case 0x04: case 0x05: case 0x06: case 0x07:
+		case 0x08: case 0x09: case 0x0a: case 0x0b:
+		case 0x0c: case 0x0d: case 0x0e: case 0x0f:
+			val = 0xff;
+			break;
 		}
 		break;
 
 	case 0x345: /*Global high*/
 		switch (dev->global) {
-			case 0x80: /*Voice control*/
-				val = dev->ctrl[dev->voice]|(dev->waveirqs[dev->voice]?0x80:0);
-				break;
+		case 0x80: /*Voice control*/
+			val = dev->ctrl[dev->voice] | (dev->waveirqs[dev->voice] ? 0x80 : 0);
+			break;
 
-			case 0x82: /*Start addr high*/
-				val = dev->start[dev->voice]>>24;
-				break;
+		case 0x82: /*Start addr high*/
+			val = dev->start[dev->voice] >> 24;
+			break;
 
-			case 0x83: /*Start addr low*/
-				val = dev->start[dev->voice]>>8;
-				break;
+		case 0x83: /*Start addr low*/
+			val = dev->start[dev->voice] >> 8;
+			break;
 
-			case 0x89: /*Current volume*/
-				val = dev->rcur[dev->voice]>>14;
-				break;
+		case 0x89: /*Current volume*/
+			val = dev->rcur[dev->voice] >> 14;
+			break;
 
-			case 0x8A: /*Current addr high*/
-				val = dev->cur[dev->voice]>>24;
-				break;
+		case 0x8A: /*Current addr high*/
+			val = dev->cur[dev->voice] >> 24;
+			break;
 
-			case 0x8B: /*Current addr low*/
-				val = dev->cur[dev->voice]>>8;
-				break;
+		case 0x8B: /*Current addr low*/
+			val = dev->cur[dev->voice] >> 8;
+			break;
 
-			case 0x8C: /*Pan*/
-				val = dev->pan_r[dev->voice];
-				break;
+		case 0x8C: /*Pan*/
+			val = dev->pan_r[dev->voice];
+			break;
 
-			case 0x8D:
-				val = dev->rctrl[dev->voice]|(dev->rampirqs[dev->voice]?0x80:0);
-				break;
+		case 0x8D:
+			val = dev->rctrl[dev->voice] | (dev->rampirqs[dev->voice] ? 0x80 : 0);
+			break;
 
-			case 0x8F: /*IRQ status*/
-				val = dev->irqstatus2;
-				dev->rampirqs[dev->irqstatus2&0x1F] = 0;
-				dev->waveirqs[dev->irqstatus2&0x1F] = 0;
-				poll_irqs(dev);
-				break;
+		case 0x8F: /*IRQ status*/
+			val = dev->irqstatus2;
+			dev->rampirqs[dev->irqstatus2 & 0x1F] = 0;
+			dev->waveirqs[dev->irqstatus2 & 0x1F] = 0;
+			poll_irqs(dev);
+			break;
 
-			case 0x41: /*DMA control*/
-				val = dev->dmactrl|((dev->irqstatus&0x80)?0x40:0);
-				dev->irqstatus &= ~0x80;
-				break;
+		case 0x41: /*DMA control*/
+			val = dev->dmactrl | ((dev->irqstatus & 0x80) ? 0x40 : 0);
+			dev->irqstatus &= ~0x80;
+			break;
 
-			case 0x45: /*Timer control*/
-				val = dev->tctrl;
-				break;
+		case 0x45: /*Timer control*/
+			val = dev->tctrl;
+			break;
 
-			case 0x49: /*Sampling control*/
-				val = 0x00;
-				break;
+		case 0x49: /*Sampling control*/
+			val = 0x00;
+			break;
 
-			case 0x00: case 0x01: case 0x02: case 0x03:
-			case 0x04: case 0x05: case 0x06: case 0x07:
-			case 0x08: case 0x09: case 0x0a: case 0x0b:
-			case 0x0c: case 0x0d: case 0x0e: case 0x0f:
-				val = 0xff;
-				break;
-		}		
+		case 0x00: case 0x01: case 0x02: case 0x03:
+		case 0x04: case 0x05: case 0x06: case 0x07:
+		case 0x08: case 0x09: case 0x0a: case 0x0b:
+		case 0x0c: case 0x0d: case 0x0e: case 0x0f:
+			val = 0xff;
+			break;
+		}
 		break;
 
 	case 0x346:
@@ -841,22 +850,22 @@ gus_read(uint16_t addr, void *priv)
 
 	case 0x24b:
 		switch (dev->reg_ctrl & 0x07) {
-			case 1:
-				val = dev->gp1;
-				break;
+		case 1:
+			val = dev->gp1;
+			break;
 
-			case 2:
-				val = dev->gp2;
-				break;
+		case 2:
+			val = dev->gp2;
+			break;
 
-			case 3:
-				val = (uint8_t)(dev->gp1_addr & 0xff);
-				break;
+		case 3:
+			val = (uint8_t)(dev->gp1_addr & 0xff);
+			break;
 
-			case 4:
-				val = (uint8_t)(dev->gp2_addr & 0xff);
-				break;
-		}		
+		case 4:
+			val = (uint8_t)(dev->gp2_addr & 0xff);
+			break;
+		}
 		break;
 
 	case 0x24c:
@@ -880,7 +889,7 @@ gus_read(uint16_t addr, void *priv)
 		}
 		break;
 
-	case 0x249: 
+	case 0x249:
 		dev->ad_status &= ~0x01;
 		nmi = 0;
 		/*FALLTHROUGH?*/
@@ -893,406 +902,415 @@ gus_read(uint16_t addr, void *priv)
 		val = dev->adcommand;
 		break;
 
-    }
+	}
 
-    return(val);
+	return(val);
 }
 
 
 static void
 poll_timer_1(void *priv)
 {
-    gus_t *dev = (gus_t *)priv;
-	
-    dev->timer_1 += (TIMER_USEC * 80LL);
-    if (dev->t1on) {
-	dev->t1++;
-	if (dev->t1 > 0xFF) {			
-		dev->t1 = dev->t1l;
-		dev->ad_status |= 0x40;
-		if (dev->tctrl & 4) {
-			if (dev->irq != -1)
-				picint(1 << dev->irq);
-			dev->ad_status |= 0x04;
-			dev->irqstatus |= 0x04;
+	gus_t *dev = (gus_t *)priv;
+
+	dev->timer_1 += (TIMER_USEC * 80LL);
+	if (dev->t1on) {
+		dev->t1++;
+		if (dev->t1 > 0xFF) {
+			dev->t1 = dev->t1l;
+			dev->ad_status |= 0x40;
+			if (dev->tctrl & 4) {
+				if (dev->irq != -1)
+					picint(1 << dev->irq);
+				dev->ad_status |= 0x04;
+				dev->irqstatus |= 0x04;
+			}
 		}
 	}
-    }
 
-    if (dev->irqnext) {
-	dev->irqnext = 0;
-	dev->irqstatus |= 0x80;
-	if (dev->irq != -1)
-		picint(1 << dev->irq);
-    }
+	if (dev->irqnext) {
+		dev->irqnext = 0;
+		dev->irqstatus |= 0x80;
+		if (dev->irq != -1)
+			picint(1 << dev->irq);
+	}
 
-    midi_update_int_status(dev);
+	midi_update_int_status(dev);
 }
 
 
 static void
 poll_timer_2(void *priv)
 {
-    gus_t *dev = (gus_t *)priv;
-	
-    dev->timer_2 += (TIMER_USEC * 320LL);
-    if (dev->t2on) {
-	dev->t2++;
-	if (dev->t2 > 0xFF) {			
-		dev->t2 = dev->t2l;
-		dev->ad_status |= 0x20;
-		if (dev->tctrl & 8) {
-			if (dev->irq != -1)
-				picint(1 << dev->irq);
-			dev->ad_status |= 0x02;
-			dev->irqstatus |= 0x08;
+	gus_t *dev = (gus_t *)priv;
+
+	dev->timer_2 += (TIMER_USEC * 320LL);
+	if (dev->t2on) {
+		dev->t2++;
+		if (dev->t2 > 0xFF) {
+			dev->t2 = dev->t2l;
+			dev->ad_status |= 0x20;
+			if (dev->tctrl & 8) {
+				if (dev->irq != -1)
+					picint(1 << dev->irq);
+				dev->ad_status |= 0x02;
+				dev->irqstatus |= 0x08;
+			}
 		}
 	}
-    }
 
-    if (dev->irqnext) {
-	dev->irqnext = 0;
-	dev->irqstatus |= 0x80;
-	if (dev->irq != -1)
-		picint(1 << dev->irq);
-    }
+	if (dev->irqnext) {
+		dev->irqnext = 0;
+		dev->irqstatus |= 0x80;
+		if (dev->irq != -1)
+			picint(1 << dev->irq);
+	}
 }
 
 
 static void
 gus_update(gus_t *dev)
 {
-    for (; dev->pos < sound_pos_global; dev->pos++) {
-	if (dev->out_l < -32768)
-		dev->buffer[0][dev->pos] = -32768;
-	else if (dev->out_l > 32767)
-		dev->buffer[0][dev->pos] = 32767;
-	else
-		dev->buffer[0][dev->pos] = dev->out_l;
-	if (dev->out_r < -32768)
-		dev->buffer[1][dev->pos] = -32768;
-	else if (dev->out_r > 32767)
-		dev->buffer[1][dev->pos] = 32767;
-	else
-		dev->buffer[1][dev->pos] = dev->out_r;
-    }
+	for (; dev->pos < sound_pos_global; dev->pos++) {
+		if (dev->out_l < -32768)
+			dev->buffer[0][dev->pos] = -32768;
+		else if (dev->out_l > 32767)
+			dev->buffer[0][dev->pos] = 32767;
+		else
+			dev->buffer[0][dev->pos] = dev->out_l;
+		if (dev->out_r < -32768)
+			dev->buffer[1][dev->pos] = -32768;
+		else if (dev->out_r > 32767)
+			dev->buffer[1][dev->pos] = 32767;
+		else
+			dev->buffer[1][dev->pos] = dev->out_r;
+	}
 }
 
 
 static void
 poll_wave(void *priv)
 {
-    gus_t *dev = (gus_t *)priv;
-    uint32_t addr;
-    int d;
-    int16_t v;
-    int32_t vl;
-    int update_irqs = 0;
+	gus_t *dev = (gus_t *)priv;
+	uint32_t addr;
+	int d;
+	int16_t v;
+	int32_t vl;
+	int update_irqs = 0;
 
-    gus_update(dev);
+	gus_update(dev);
 
-    dev->samp_timer += dev->samp_latch;
+	dev->samp_timer += dev->samp_latch;
 
-    dev->out_l = dev->out_r = 0;
+	dev->out_l = dev->out_r = 0;
 
-    if ((dev->reset & 3) != 3)
-	return;
+	if ((dev->reset & 3) != 3)
+		return;
 
-    for (d = 0; d < 32; d++) {
-	if (! (dev->ctrl[d] & 3)) {
-		if (dev->ctrl[d] & 4) {
-			addr = dev->cur[d] >> 9;
-			addr = (addr & 0xC0000) | ((addr << 1) & 0x3FFFE);
+	for (d = 0; d < 32; d++) {
+		if (!(dev->ctrl[d] & 3)) {
+			if (dev->ctrl[d] & 4) {
+				addr = dev->cur[d] >> 9;
+				addr = (addr & 0xC0000) | ((addr << 1) & 0x3FFFE);
 
-			if (! (dev->freq[d] >> 10)) {	/*Interpolate*/
-				vl  = (int16_t)(int8_t)((dev->ram[(addr + 1) & 0xFFFFF] ^ 0x80) - 0x80) * (511 - (dev->cur[d] & 511));
-				vl += (int16_t)(int8_t)((dev->ram[(addr + 3) & 0xFFFFF] ^ 0x80) - 0x80) * (dev->cur[d] & 511);
-				v = vl >> 9;
-			} else
-				v = (int16_t)(int8_t)((dev->ram[(addr + 1) & 0xFFFFF] ^ 0x80) - 0x80);
-		} else {
-			if (! (dev->freq[d] >> 10)) {	/*Interpolate*/
-				vl  = ((int8_t)((dev->ram[(dev->cur[d] >> 9) & 0xFFFFF] ^ 0x80) - 0x80)) * (511 - (dev->cur[d] & 511));
-				vl += ((int8_t)((dev->ram[((dev->cur[d] >> 9) + 1) & 0xFFFFF] ^ 0x80) - 0x80)) * (dev->cur[d] & 511);
-				v = vl >> 9;
-			} else
-				v = (int16_t)(int8_t)((dev->ram[(dev->cur[d] >> 9) & 0xFFFFF] ^ 0x80) - 0x80);
-		}
+				if (!(dev->freq[d] >> 10)) {	/*Interpolate*/
+					vl = (int16_t)(int8_t)((dev->ram[(addr + 1) & 0xFFFFF] ^ 0x80) - 0x80) * (511 - (dev->cur[d] & 511));
+					vl += (int16_t)(int8_t)((dev->ram[(addr + 3) & 0xFFFFF] ^ 0x80) - 0x80) * (dev->cur[d] & 511);
+					v = vl >> 9;
+				}
+				else
+					v = (int16_t)(int8_t)((dev->ram[(addr + 1) & 0xFFFFF] ^ 0x80) - 0x80);
+			}
+			else {
+				if (!(dev->freq[d] >> 10)) {	/*Interpolate*/
+					vl = ((int8_t)((dev->ram[(dev->cur[d] >> 9) & 0xFFFFF] ^ 0x80) - 0x80)) * (511 - (dev->cur[d] & 511));
+					vl += ((int8_t)((dev->ram[((dev->cur[d] >> 9) + 1) & 0xFFFFF] ^ 0x80) - 0x80)) * (dev->cur[d] & 511);
+					v = vl >> 9;
+				}
+				else
+					v = (int16_t)(int8_t)((dev->ram[(dev->cur[d] >> 9) & 0xFFFFF] ^ 0x80) - 0x80);
+			}
 
-		if ((dev->rcur[d] >> 14) > 4095)
-			v = (int16_t)((float)v * 24.0 * vol16bit[4095]);
-		else
-			v = (int16_t)((float)v * 24.0 * vol16bit[(dev->rcur[d]>>10) & 4095]);
+			if ((dev->rcur[d] >> 14) > 4095)
+				v = (int16_t)((float)v * 24.0 * vol16bit[4095]);
+			else
+				v = (int16_t)((float)v * 24.0 * vol16bit[(dev->rcur[d] >> 10) & 4095]);
 
-		dev->out_l += (v * dev->pan_l[d]) / 7;
-		dev->out_r += (v * dev->pan_r[d]) / 7;
+			dev->out_l += (v * dev->pan_l[d]) / 7;
+			dev->out_r += (v * dev->pan_r[d]) / 7;
 
-		if (dev->ctrl[d] & 0x40) {
-			dev->cur[d] -= (dev->freq[d] >> 1);
-			if (dev->cur[d] <= dev->start[d]) {
-				int diff = dev->start[d] - dev->cur[d];
+			if (dev->ctrl[d] & 0x40) {
+				dev->cur[d] -= (dev->freq[d] >> 1);
+				if (dev->cur[d] <= dev->start[d]) {
+					int diff = dev->start[d] - dev->cur[d];
 
-				if (dev->ctrl[d] & 8) {
-					if (dev->ctrl[d]&0x10)
-						dev->ctrl[d]^=0x40;
-					dev->cur[d] = (dev->ctrl[d] & 0x40) ? (dev->end[d] - diff) : (dev->start[d] + diff);
-				} else if (! (dev->rctrl[d] & 4)) {
-					dev->ctrl[d] |= 1;
-					dev->cur[d] = (dev->ctrl[d] & 0x40) ? dev->end[d] : dev->start[d];
-				}						
+					if (dev->ctrl[d] & 8) {
+						if (dev->ctrl[d] & 0x10)
+							dev->ctrl[d] ^= 0x40;
+						dev->cur[d] = (dev->ctrl[d] & 0x40) ? (dev->end[d] - diff) : (dev->start[d] + diff);
+					}
+					else if (!(dev->rctrl[d] & 4)) {
+						dev->ctrl[d] |= 1;
+						dev->cur[d] = (dev->ctrl[d] & 0x40) ? dev->end[d] : dev->start[d];
+					}
 
-				if ((dev->ctrl[d] & 0x20) && !dev->waveirqs[d]) {
-					dev->waveirqs[d] = 1;
-					update_irqs = 1;
+					if ((dev->ctrl[d] & 0x20) && !dev->waveirqs[d]) {
+						dev->waveirqs[d] = 1;
+						update_irqs = 1;
+					}
 				}
 			}
-		} else {
-			dev->cur[d] += (dev->freq[d] >> 1);
+			else {
+				dev->cur[d] += (dev->freq[d] >> 1);
 
-			if (dev->cur[d] >= dev->end[d]) {
-				int diff = dev->cur[d] - dev->end[d];
+				if (dev->cur[d] >= dev->end[d]) {
+					int diff = dev->cur[d] - dev->end[d];
 
-				if (dev->ctrl[d] & 8) {
-					if (dev->ctrl[d]&0x10)
-						dev->ctrl[d]^=0x40;
-					dev->cur[d] = (dev->ctrl[d] & 0x40) ? (dev->end[d] - diff) : (dev->start[d] + diff);
-				} else if (! (dev->rctrl[d] & 4)) {
-					dev->ctrl[d] |= 1;
-					dev->cur[d] = (dev->ctrl[d] & 0x40) ? dev->end[d] : dev->start[d];
-				} 
+					if (dev->ctrl[d] & 8) {
+						if (dev->ctrl[d] & 0x10)
+							dev->ctrl[d] ^= 0x40;
+						dev->cur[d] = (dev->ctrl[d] & 0x40) ? (dev->end[d] - diff) : (dev->start[d] + diff);
+					}
+					else if (!(dev->rctrl[d] & 4)) {
+						dev->ctrl[d] |= 1;
+						dev->cur[d] = (dev->ctrl[d] & 0x40) ? dev->end[d] : dev->start[d];
+					}
 
-				if ((dev->ctrl[d] & 0x20) && !dev->waveirqs[d]) {
-					dev->waveirqs[d] = 1;
-					update_irqs = 1;
+					if ((dev->ctrl[d] & 0x20) && !dev->waveirqs[d]) {
+						dev->waveirqs[d] = 1;
+						update_irqs = 1;
+					}
+				}
+			}
+		}
+
+		if (!(dev->rctrl[d] & 3)) {
+			if (dev->rctrl[d] & 0x40) {
+				dev->rcur[d] -= dev->rfreq[d];
+				if (dev->rcur[d] <= dev->rstart[d]) {
+					int diff = dev->rstart[d] - dev->rcur[d];
+
+					if (!(dev->rctrl[d] & 8)) {
+						dev->rctrl[d] |= 1;
+						dev->rcur[d] = (dev->rctrl[d] & 0x40) ? dev->rstart[d] : dev->rend[d];
+					}
+					else {
+						if (dev->rctrl[d] & 0x10)
+							dev->rctrl[d] ^= 0x40;
+						dev->rcur[d] = (dev->rctrl[d] & 0x40) ? (dev->rend[d] - diff) : (dev->rstart[d] + diff);
+					}
+
+					if ((dev->rctrl[d] & 0x20) && !dev->rampirqs[d]) {
+						dev->rampirqs[d] = 1;
+						update_irqs = 1;
+					}
+				}
+			}
+			else {
+				dev->rcur[d] += dev->rfreq[d];
+				if (dev->rcur[d] >= dev->rend[d]) {
+					int diff = dev->rcur[d] - dev->rend[d];
+
+					if (!(dev->rctrl[d] & 8)) {
+						dev->rctrl[d] |= 1;
+						dev->rcur[d] = (dev->rctrl[d] & 0x40) ? dev->rstart[d] : dev->rend[d];
+					}
+					else {
+						if (dev->rctrl[d] & 0x10)
+							dev->rctrl[d] ^= 0x40;
+						dev->rcur[d] = (dev->rctrl[d] & 0x40) ? (dev->rend[d] - diff) : (dev->rstart[d] + diff);
+					}
+
+					if ((dev->rctrl[d] & 0x20) && !dev->rampirqs[d]) {
+						dev->rampirqs[d] = 1;
+						update_irqs = 1;
+					}
 				}
 			}
 		}
 	}
 
-	if (! (dev->rctrl[d] & 3)) {
-		if (dev->rctrl[d] & 0x40) {
-			dev->rcur[d] -= dev->rfreq[d];
-			if (dev->rcur[d] <= dev->rstart[d]) {
-				int diff = dev->rstart[d] - dev->rcur[d];
-
-				if (! (dev->rctrl[d] & 8)) {
-					dev->rctrl[d] |= 1;
-					dev->rcur[d] = (dev->rctrl[d] & 0x40) ? dev->rstart[d] : dev->rend[d];
-				} else {
-					if (dev->rctrl[d] & 0x10)
-						dev->rctrl[d] ^= 0x40;
-					dev->rcur[d] = (dev->rctrl[d] & 0x40) ? (dev->rend[d] - diff) : (dev->rstart[d] + diff);
-				}
-
-				if ((dev->rctrl[d] & 0x20) && !dev->rampirqs[d]) {
-					dev->rampirqs[d] = 1;
-					update_irqs = 1;
-				}
-			}
-		} else {
-			dev->rcur[d] += dev->rfreq[d];
-			if (dev->rcur[d] >= dev->rend[d]) {
-				int diff = dev->rcur[d] - dev->rend[d];
-
-				if (! (dev->rctrl[d] & 8)) {
-					dev->rctrl[d] |= 1;
-					dev->rcur[d] = (dev->rctrl[d] & 0x40) ? dev->rstart[d] : dev->rend[d];
-				} else {
-					if (dev->rctrl[d] & 0x10)
-						dev->rctrl[d] ^= 0x40;
-					dev->rcur[d] = (dev->rctrl[d] & 0x40) ? (dev->rend[d] - diff) : (dev->rstart[d] + diff);
-				}
-
-				if ((dev->rctrl[d] & 0x20) && !dev->rampirqs[d]) {
-					dev->rampirqs[d] = 1;
-					update_irqs = 1;
-				}
-			}
-		}
-	}
-    }
-
-    if (update_irqs)
-	poll_irqs(dev);
+	if (update_irqs)
+		poll_irqs(dev);
 }
 
 
 static void
 get_buffer(int32_t *buffer, int len, void *priv)
 {
-    gus_t *dev = (gus_t *)priv;
-    int c;
+	gus_t *dev = (gus_t *)priv;
+	int c;
 
 #if defined(DEV_BRANCH) && defined(USE_GUSMAX)  
-    if(dev->max_ctrl)	
+	if (dev->max_ctrl)
 		cs423x_update(&dev->cs423x);
 #endif	
-    gus_update(dev);
+	gus_update(dev);
 
-    for (c = 0; c < len * 2; c++) {
+	for (c = 0; c < len * 2; c++) {
 #if defined(DEV_BRANCH) && defined(USE_GUSMAX)    
-	if (dev->max_ctrl) 
-		buffer[c] += (int32_t)(dev->cs423x.buffer[c] / 2); 
+		if (dev->max_ctrl)
+			buffer[c] += (int32_t)(dev->cs423x.buffer[c] / 2);
 #endif		
-	buffer[c] += (int32_t)dev->buffer[c & 1][c >> 1];
-    }
+		buffer[c] += (int32_t)dev->buffer[c & 1][c >> 1];
+	}
 
 #if defined(DEV_BRANCH) && defined(USE_GUSMAX)    
-    if(dev->max_ctrl)
-	dev->cs423x.pos = 0;
+	if (dev->max_ctrl)
+		dev->cs423x.pos = 0;
 #endif	
 
-    dev->pos = 0;
+	dev->pos = 0;
 }
 
 
 static void *
 gus_init(const device_t *info)
 {
-    int c;
-    double out = 1.0;
-    gus_t *dev = (gus_t *)mem_alloc(sizeof(gus_t));
+	int c;
+	double out = 1.0;
+	gus_t *dev = (gus_t *)mem_alloc(sizeof(gus_t));
 
-    memset(dev, 0x00, sizeof(gus_t));
+	memset(dev, 0x00, sizeof(gus_t));
 
-    dev->ram = (uint8_t *)mem_alloc(1 << 20);
-    memset(dev->ram, 0x00, 1 << 20);
+	dev->ram = (uint8_t *)mem_alloc(1 << 20);
+	memset(dev->ram, 0x00, 1 << 20);
 
-    for (c = 0; c < 32; c++) {
-	dev->ctrl[c] = 1;
-	dev->rctrl[c] = 1;
-	dev->rfreq[c] = 63*512;
-    }
+	for (c = 0; c < 32; c++) {
+		dev->ctrl[c] = 1;
+		dev->rctrl[c] = 1;
+		dev->rfreq[c] = 63 * 512;
+	}
 
-    for (c = 4095; c >= 0; c--) {
-	vol16bit[c] = out;
-	out /= 1.002709201;		/* 0.0235 dB Steps */
-    }
+	for (c = 4095; c >= 0; c--) {
+		vol16bit[c] = out;
+		out /= 1.002709201;		/* 0.0235 dB Steps */
+	}
 
-//   DEBUG("GUS: top volume %f %f %f %f\n",vol16bit[4095],vol16bit[3800],vol16bit[3000],vol16bit[2048]);
-    dev->voices=14;
+	//   DEBUG("GUS: top volume %f %f %f %f\n",vol16bit[4095],vol16bit[3800],vol16bit[3000],vol16bit[2048]);
+	dev->voices = 14;
 
-    dev->samp_timer = dev->samp_latch = (int64_t)(TIMER_USEC * (1000000.0 / 44100.0));
+	dev->samp_timer = dev->samp_latch = (int64_t)(TIMER_USEC * (1000000.0 / 44100.0));
 
-    dev->t1l = dev->t2l = 0xff;
+	dev->t1l = dev->t2l = 0xff;
 
-    io_sethandler(0x0240, 16,
-		  gus_read,NULL,NULL, gus_write,NULL,NULL, dev);
-    io_sethandler(0x0340, 16,
-		  gus_read,NULL,NULL, gus_write,NULL,NULL, dev);
-    io_sethandler(0x0746, 1,
-		  gus_read,NULL,NULL, gus_write,NULL,NULL, dev);	
-    io_sethandler(0x0388, 2,
-		  gus_read,NULL,NULL, gus_write,NULL,NULL, dev);
+	io_sethandler(0x0240, 16,
+		gus_read, NULL, NULL, gus_write, NULL, NULL, dev);
+	io_sethandler(0x0340, 16,
+		gus_read, NULL, NULL, gus_write, NULL, NULL, dev);
+	io_sethandler(0x0746, 1,
+		gus_read, NULL, NULL, gus_write, NULL, NULL, dev);
+	io_sethandler(0x0388, 2,
+		gus_read, NULL, NULL, gus_write, NULL, NULL, dev);
 
-    timer_add(poll_wave, &dev->samp_timer, TIMER_ALWAYS_ENABLED, dev);
-    timer_add(poll_timer_1, &dev->timer_1, TIMER_ALWAYS_ENABLED, dev);
-    timer_add(poll_timer_2, &dev->timer_2, TIMER_ALWAYS_ENABLED, dev);
+	timer_add(poll_wave, &dev->samp_timer, TIMER_ALWAYS_ENABLED, dev);
+	timer_add(poll_timer_1, &dev->timer_1, TIMER_ALWAYS_ENABLED, dev);
+	timer_add(poll_timer_2, &dev->timer_2, TIMER_ALWAYS_ENABLED, dev);
 
-    sound_add_handler(get_buffer, dev);
+	sound_add_handler(get_buffer, dev);
 
-    return(dev);
+	return(dev);
 }
 
 #if defined(DEV_BRANCH) && defined(USE_GUSMAX)
 static void *
 gus_max_init(const device_t *info)
 {
-    int c;
+	int c;
 	double out = 1.0;
-    gus_t *dev = (gus_t *)mem_alloc(sizeof(gus_t)); 
-	
-    memset(dev, 0x00, sizeof(gus_t));
+	gus_t *dev = (gus_t *)mem_alloc(sizeof(gus_t));
+
+	memset(dev, 0x00, sizeof(gus_t));
 
 	dev->ram = (uint8_t *)mem_alloc(1 << 20); // Maximum 1 Mb RAM
 	memset(dev->ram, 0x00, 1 << 20);
-               
-    for (c=0;c<32;c++)  {
-                dev->ctrl[c]=1;
-                dev->rctrl[c]=1;
-                dev->rfreq[c]=63*512;
-    }
 
-	for (c=4095;c>=0;c--) {
-		vol16bit[c]=out;
-		out/=1.002709201;		
+	for (c = 0;c < 32;c++) {
+		dev->ctrl[c] = 1;
+		dev->rctrl[c] = 1;
+		dev->rfreq[c] = 63 * 512;
 	}
 
-	dev->voices=14;
+	for (c = 4095;c >= 0;c--) {
+		vol16bit[c] = out;
+		out /= 1.002709201;
+	}
 
-    dev->samp_timer = dev->samp_latch = (int)(TIMER_USEC * (1000000.0 / 44100.0));
+	dev->voices = 14;
 
-    dev->t1l = dev->t2l = 0xff;
+	dev->samp_timer = dev->samp_latch = (int)(TIMER_USEC * (1000000.0 / 44100.0));
+
+	dev->t1l = dev->t2l = 0xff;
 
 	cs423x_init(&dev->cs423x);
 	cs423x_setirq(&dev->cs423x, 7);
-    cs423x_setdma(&dev->cs423x, 3);   
-		
-    io_sethandler(0x0240, 16,
-	      gus_read,NULL,NULL, gus_write,NULL,NULL, dev);
-    io_sethandler(0x0340, 9,
-	      gus_read,NULL,NULL, gus_write,NULL,NULL, dev);
-    io_sethandler(0x0746, 1,
-	      gus_read,NULL,NULL, gus_write,NULL,NULL, dev);      
-    io_sethandler(0x0388, 2,
-	      gus_read, NULL, NULL, gus_write, NULL, NULL,  dev);         
-	io_sethandler(0x034c, 4,
-          cs423x_read, NULL, NULL, cs423x_write, NULL, NULL, &dev->cs423x);    
-		      
-    timer_add(poll_wave, &dev->samp_timer, TIMER_ALWAYS_ENABLED,  dev);
-    timer_add(poll_timer_1, &dev->timer_1, TIMER_ALWAYS_ENABLED,  dev);
-    timer_add(poll_timer_2, &dev->timer_2, TIMER_ALWAYS_ENABLED,  dev);
+	cs423x_setdma(&dev->cs423x, 3);
 
-    sound_add_handler(get_buffer, dev);
-        
-    return(dev);
+	io_sethandler(0x0240, 16,
+		gus_read, NULL, NULL, gus_write, NULL, NULL, dev);
+	io_sethandler(0x0340, 9,
+		gus_read, NULL, NULL, gus_write, NULL, NULL, dev);
+	io_sethandler(0x0746, 1,
+		gus_read, NULL, NULL, gus_write, NULL, NULL, dev);
+	io_sethandler(0x0388, 2,
+		gus_read, NULL, NULL, gus_write, NULL, NULL, dev);
+	io_sethandler(0x034c, 4,
+		cs423x_read, NULL, NULL, cs423x_write, NULL, NULL, &dev->cs423x);
+
+	timer_add(poll_wave, &dev->samp_timer, TIMER_ALWAYS_ENABLED, dev);
+	timer_add(poll_timer_1, &dev->timer_1, TIMER_ALWAYS_ENABLED, dev);
+	timer_add(poll_timer_2, &dev->timer_2, TIMER_ALWAYS_ENABLED, dev);
+
+	sound_add_handler(get_buffer, dev);
+
+	return(dev);
 }
 #endif
 
 static void
 gus_close(void *priv)
 {
-    gus_t *dev = (gus_t *)priv;
-	
-    free(dev->ram);
+	gus_t *dev = (gus_t *)priv;
 
-    free(dev);
+	free(dev->ram);
+
+	free(dev);
 }
 
 
 static void
 speed_changed(void *priv)
 {
-    gus_t *dev = (gus_t *)priv;
+	gus_t *dev = (gus_t *)priv;
+
+	if (dev->voices < 14)
+		dev->samp_latch = (int)(TIMER_USEC * (1000000.0 / 44100.0));
+	else
+		dev->samp_latch = (int)(TIMER_USEC * (1000000.0 / gusfreqs[dev->voices - 14]));
 
-    if (dev->voices < 14)
-	dev->samp_latch = (int)(TIMER_USEC * (1000000.0 / 44100.0));
-    else
-	dev->samp_latch = (int)(TIMER_USEC * (1000000.0 / gusfreqs[dev->voices - 14]));
-	
 #if defined(DEV_BRANCH) && defined(USE_GUSMAX)
-    if (dev->max_ctrl)			 
+	if (dev->max_ctrl)
 		cs423x_speed_changed(&dev->cs423x);
 #endif
 }
 
 
 const device_t gus_device = {
-    "Gravis UltraSound",
-    DEVICE_ISA,
-    0,
-    gus_init, gus_close, NULL, NULL,
-    speed_changed, NULL, NULL,
-    NULL
+	"Gravis UltraSound",
+	DEVICE_ISA,
+	0,
+	gus_init, gus_close, NULL, NULL,
+	speed_changed, NULL, NULL,
+	NULL
 };
 
 #if defined(DEV_BRANCH) && defined(USE_GUSMAX)
 const device_t gusmax_device = {
-    "Gravis UltraSound MAX",
-    DEVICE_ISA, 
-    0,
-    gus_max_init, gus_close, NULL, NULL, 
-    speed_changed, NULL, NULL,
-    NULL
+	"Gravis UltraSound MAX",
+	DEVICE_ISA,
+	0,
+	gus_max_init, gus_close, NULL, NULL,
+	speed_changed, NULL, NULL,
+	NULL
 };
 #endif