From: Neils Wagenaar <sdlemu@ngemu.com>
Date: Sat, 16 Aug 2003 17:27:06 +0000 (+0000)
Subject: Brand new sound code uses SDL!
X-Git-Tag: 1.0.5~30
X-Git-Url: http://shamusworld.gotdns.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=2d57a03aa1aa1f1ee55bfaed762fabe6d6154992;p=virtualjaguar

Brand new sound code uses SDL!
---

diff --git a/src/dac.cpp b/src/dac.cpp
new file mode 100644
index 0000000..be2f2c5
--- /dev/null
+++ b/src/dac.cpp
@@ -0,0 +1,219 @@
+//
+// DAC (really, Synchronous Serial Interface) Handler
+//
+// by cal2
+// GCC/SDL port by Niels Wagenaar (Linux/WIN32) and Caz (BeOS)
+// Rewritten by James L. Hammons
+//
+
+#include <SDL.h>
+#include "jaguar.h"
+#include "dac.h"
+
+#define BUFFER_SIZE		0x8000						// Make the DAC buffers 32K x 16 bits
+
+// Jaguar memory locations
+
+#define LTXD			0xF1A148
+#define RTXD			0xF1A14C
+#define SCLK			0xF1A150
+#define SMODE			0xF1A154
+
+// Local variables
+
+uint32 LeftFIFOHeadPtr, LeftFIFOTailPtr, RightFIFOHeadPtr, RightFIFOTailPtr;
+SDL_AudioSpec desired;
+
+// We can get away with using native endian here because we can tell SDL to use the native
+// when looking at the sample buffer, i.e., no need to worry about it.
+
+uint16 * DACBuffer;
+uint8 SCLKFrequencyDivider = 9;						// Start out roughly 44.1K (46164 Hz in NTSC mode)
+uint16 serialMode = 0;
+
+// Private function prototypes
+
+void SDLSoundCallback(void * userdata, Uint8 * buffer, int length);
+int GetCalculatedFrequency(void);
+
+//
+// Initialize the SDL sound system (?) (!)
+//
+void DACInit(void)
+{
+	memory_malloc_secure((void **)&DACBuffer, BUFFER_SIZE * sizeof(uint16), "DAC buffer");
+
+	desired.freq = GetCalculatedFrequency();		// SDL will do conversion on the fly, if it can't get the exact rate. Nice!
+	desired.format = AUDIO_S16SYS;					// This uses the native endian (for portability)...
+	desired.channels = 2;
+	desired.samples = 4096;							// Let's try a 4K buffer (can always go lower)
+	desired.callback = SDLSoundCallback;
+
+	if (SDL_OpenAudio(&desired, NULL) < 0)			// NULL means SDL guarantees what we want
+	{
+		WriteLog("DAC: Failed to initialize SDL sound. Shutting down!\n");
+		log_done();
+		exit(1);
+	}
+
+	DACReset();
+	SDL_PauseAudio(false);							// Start playback!
+	WriteLog("DAC: Successfully initialized.\n");
+}
+
+//
+// Reset the sound buffer FIFOs
+//
+void DACReset(void)
+{
+	LeftFIFOHeadPtr = LeftFIFOTailPtr = 0, RightFIFOHeadPtr = RightFIFOTailPtr = 1;
+}
+
+//
+// Close down the SDL sound subsystem (?) (!)
+//
+void DACDone(void)
+{
+	SDL_PauseAudio(true);
+	SDL_CloseAudio();
+	WriteLog("DAC: Done.\n");
+}
+
+//
+// SDL callback routine to fill audio buffer
+//
+// Note: The samples are packed in the buffer in 16 bit left/16 bit right pairs.
+//
+void SDLSoundCallback(void * userdata, Uint8 * buffer, int length)
+{
+//WriteLog("DAC: Inside callback...\n");
+	if (LeftFIFOHeadPtr != LeftFIFOTailPtr)
+	{
+//WriteLog("DAC: About to write some data!\n");
+		int numLeftSamplesReady
+			= (LeftFIFOTailPtr + (LeftFIFOTailPtr < LeftFIFOHeadPtr ? BUFFER_SIZE : 0))
+				- LeftFIFOHeadPtr;
+		int numRightSamplesReady
+			= (RightFIFOTailPtr + (RightFIFOTailPtr < RightFIFOHeadPtr ? BUFFER_SIZE : 0))
+				- RightFIFOHeadPtr;
+		int numSamplesReady
+			= (numLeftSamplesReady < numRightSamplesReady
+				? numLeftSamplesReady : numRightSamplesReady) * 2;
+
+		if (numSamplesReady > length)
+			numSamplesReady = length;
+
+		// Actually, it's a bit more involved than this, but this is the general idea:
+//		memcpy(buffer, DACBuffer, length);
+		for(int i=0; i<numSamplesReady; i++)
+			// Could also use (as long as BUFFER_SIZE is a multiple of 2):
+			((uint16 *)buffer)[i] = DACBuffer[(LeftFIFOHeadPtr + i) % BUFFER_SIZE];
+//			buffer[i] = DACBuffer[(LeftFIFOHeadPtr + i) & (BUFFER_SIZE - 1)];
+
+		LeftFIFOHeadPtr = (LeftFIFOHeadPtr + (numSamplesReady / 2)) % BUFFER_SIZE;
+		RightFIFOHeadPtr = (RightFIFOHeadPtr + (numSamplesReady / 2)) % BUFFER_SIZE;
+		// Could also use (as long as BUFFER_SIZE is a multiple of 2):
+//		LeftFIFOHeadPtr = (LeftFIFOHeadPtr + (numSamplesReady / 2)) & (BUFFER_SIZE - 1);
+//		RightFIFOHeadPtr = (RightFIFOHeadPtr + (numSamplesReady / 2)) & (BUFFER_SIZE - 1);
+	}
+}
+
+//
+// Calculate the frequency of SCLK * 32 using the divider
+//
+int GetCalculatedFrequency(void)
+{
+	extern bool hardwareTypeNTSC;
+	int systemClockFrequency = (hardwareTypeNTSC ? RISC_CLOCK_RATE_NTSC : RISC_CLOCK_RATE_PAL);
+
+	// We divide by 32 here in order to find the frequency of 32 SCLKs in a row (transferring
+	// 16 bits of left data + 16 bits of right data = 32 bits, 1 SCLK = 1 bit transferred).
+	return systemClockFrequency / (32 * (2 * (SCLKFrequencyDivider + 1)));
+}
+
+//
+// LTXD/RTXD/SCLK/SMODE ($F1A148/4C/50/54)
+//
+void DACWriteByte(uint32 offset, uint8 data)
+{
+//	WriteLog("DAC: Writing %02X at %08X\n", data, offset);
+}
+
+void DACWriteWord(uint32 offset, uint16 data)
+{
+	if (offset == LTXD + 2)
+	{
+		if (LeftFIFOTailPtr + 2 != LeftFIFOHeadPtr)
+		{
+			SDL_LockAudio();						// Is it necessary to do this? Mebbe.
+			// We use a circular buffer 'cause it's easy. Note that the callback function
+			// takes care of dumping audio to the soundcard...!
+			LeftFIFOTailPtr = (LeftFIFOTailPtr + 2) % BUFFER_SIZE;
+			DACBuffer[LeftFIFOTailPtr] = data;
+// Aaron's code does this, but I don't know why...
+//Flipping this bit makes the audio MUCH louder. Need to look at the amplitude of the
+//waveform to see if any massaging is needed here...
+//			DACBuffer[LeftFIFOTailPtr] = data ^ 0x8000;
+			SDL_UnlockAudio();
+		}
+		else
+			WriteLog("DAC: Ran into FIFO's left tail pointer!\n");
+	}
+	else if (offset == RTXD + 2)
+	{
+		if (RightFIFOTailPtr + 2 != RightFIFOHeadPtr)
+		{
+			SDL_LockAudio();
+			RightFIFOTailPtr = (RightFIFOTailPtr + 2) % BUFFER_SIZE;
+			DACBuffer[RightFIFOTailPtr] = data;
+// Aaron's code does this, but I don't know why...
+//			DACBuffer[RightFIFOTailPtr] = data ^ 0x8000;
+			SDL_UnlockAudio();
+		}
+		else
+			WriteLog("DAC: Ran into FIFO's right tail pointer!\n");
+	}
+	else if (offset == SCLK + 2)					// Sample rate
+	{
+		if ((uint8)data != SCLKFrequencyDivider)
+		{
+WriteLog("DAC: Changing sample rate!\n");
+			SDL_CloseAudio();
+			SCLKFrequencyDivider = (uint8)data;
+			desired.freq = GetCalculatedFrequency();// SDL will do conversion on the fly, if it can't get the exact rate. Nice!
+
+			if (SDL_OpenAudio(&desired, NULL) < 0)	// NULL means SDL guarantees what we want
+			{
+				WriteLog("DAC: Failed to initialize SDL sound. Shutting down!\n");
+				log_done();
+				exit(1);
+			}
+
+			DACReset();
+			SDL_PauseAudio(false);					// Start playback!
+		}
+	}
+	else if (offset == SMODE + 2)
+	{
+		serialMode = data;
+		WriteLog("DAC: Writing to SMODE. Bits: %s%s%s%s%s%s\n",
+			(data & 0x01 ? "INTERNAL " : ""), (data & 0x02 ? "MODE " : ""),
+			(data & 0x04 ? "WSEN " : ""), (data & 0x08 ? "RISING " : ""),
+			(data & 0x10 ? "FALLING " : ""), (data & 0x20 ? "EVERYWORD" : ""));
+	}
+}
+
+//
+// LRXD/RRXD/SSTAT ($F1A148/4C/50)
+//
+uint8 DACReadByte(uint32 offset)
+{
+//	WriteLog("DAC: Reading byte from %08X\n", offset);
+	return 0xFF;
+}
+
+uint16 DACReadWord(uint32 offset)
+{
+//	WriteLog("DAC: Reading word from %08X\n", offset);
+	return 0xFFFF;
+}
diff --git a/src/include/dac.h b/src/include/dac.h
new file mode 100644
index 0000000..2af635f
--- /dev/null
+++ b/src/include/dac.h
@@ -0,0 +1,19 @@
+//
+// DAC.H: Header file
+//
+
+#ifndef __DAC_H__
+#define __DAC_H__
+
+void DACInit(void);
+void DACReset(void);
+void DACDone(void);
+
+// DAC memory access
+
+void DACWriteByte(uint32 offset, uint8 data);
+void DACWriteWord(uint32 offset, uint16 data);
+uint8 DACReadByte(uint32 offset);
+uint16 DACReadWord(uint32 offset);
+
+#endif	// __DAC_H__