X-Git-Url: http://shamusworld.gotdns.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fdac.cpp;h=e85d858cd4e979698ed3382491fe49920e3e343d;hb=97049d3cb9e3f80db99576b98de060745148adad;hp=be2f2c522a2ca62ce5545d6ad2a0da9271d5637e;hpb=2d57a03aa1aa1f1ee55bfaed762fabe6d6154992;p=virtualjaguar

diff --git a/src/dac.cpp b/src/dac.cpp
index be2f2c5..e85d858 100644
--- a/src/dac.cpp
+++ b/src/dac.cpp
@@ -1,7 +1,7 @@
 //
 // DAC (really, Synchronous Serial Interface) Handler
 //
-// by cal2
+// Original by Cal2
 // GCC/SDL port by Niels Wagenaar (Linux/WIN32) and Caz (BeOS)
 // Rewritten by James L. Hammons
 //
@@ -9,8 +9,11 @@
 #include <SDL.h>
 #include "jaguar.h"
 #include "dac.h"
+#include "settings.h"
 
-#define BUFFER_SIZE		0x8000						// Make the DAC buffers 32K x 16 bits
+//#define DEBUG_DAC
+
+#define BUFFER_SIZE		0x10000						// Make the DAC buffers 64K x 16 bits
 
 // Jaguar memory locations
 
@@ -25,10 +28,10 @@ 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.
+// endian 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)
+uint8 SCLKFrequencyDivider = 19;						// Default is roughly 22 KHz (20774 Hz in NTSC mode)
 uint16 serialMode = 0;
 
 // Private function prototypes
@@ -37,7 +40,7 @@ void SDLSoundCallback(void * userdata, Uint8 * buffer, int length);
 int GetCalculatedFrequency(void);
 
 //
-// Initialize the SDL sound system (?) (!)
+// Initialize the SDL sound system
 //
 void DACInit(void)
 {
@@ -46,7 +49,8 @@ void DACInit(void)
 	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.samples = 4096;							// Let's try a 4K buffer (can always go lower)
+	desired.samples = 2048;							// Let's try a 2K buffer (can always go lower)
 	desired.callback = SDLSoundCallback;
 
 	if (SDL_OpenAudio(&desired, NULL) < 0)			// NULL means SDL guarantees what we want
@@ -70,7 +74,7 @@ void DACReset(void)
 }
 
 //
-// Close down the SDL sound subsystem (?) (!)
+// Close down the SDL sound subsystem
 //
 void DACDone(void)
 {
@@ -86,6 +90,8 @@ void DACDone(void)
 //
 void SDLSoundCallback(void * userdata, Uint8 * buffer, int length)
 {
+	// Clear the buffer to silence, in case the DAC buffer is empty (or short)
+	memset(buffer, desired.silence, length);
 //WriteLog("DAC: Inside callback...\n");
 	if (LeftFIFOHeadPtr != LeftFIFOTailPtr)
 	{
@@ -98,24 +104,37 @@ void SDLSoundCallback(void * userdata, Uint8 * buffer, int length)
 				- RightFIFOHeadPtr;
 		int numSamplesReady
 			= (numLeftSamplesReady < numRightSamplesReady
-				? numLeftSamplesReady : numRightSamplesReady) * 2;
+				? numLeftSamplesReady : numRightSamplesReady);//Hmm. * 2;
+
+//The numbers look good--it's just that the DSP can't get enough samples in the DAC buffer!
+//WriteLog("DAC: Left/RightFIFOHeadPtr: %u/%u, Left/RightFIFOTailPtr: %u/%u\n", LeftFIFOHeadPtr, RightFIFOHeadPtr, LeftFIFOTailPtr, RightFIFOTailPtr);
+//WriteLog("     numLeft/RightSamplesReady: %i/%i, numSamplesReady: %i, length of buffer: %i\n", numLeftSamplesReady, numRightSamplesReady, numSamplesReady, length);
 
-		if (numSamplesReady > length)
-			numSamplesReady = length;
+/*		if (numSamplesReady > length)
+			numSamplesReady = length;//*/
+		if (numSamplesReady > length / 2)	// length / 2 because we're comparing 16-bit lengths
+			numSamplesReady = length / 2;
+//else
+//	WriteLog("     Not enough samples to fill the buffer (short by %u L/R samples)...\n", (length / 2) - numSamplesReady);
+//WriteLog("DAC: %u samples ready.\n", numSamplesReady);
 
 		// 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];
+			// Could also use (as long as BUFFER_SIZE is a multiple of 2):
 //			buffer[i] = DACBuffer[(LeftFIFOHeadPtr + i) & (BUFFER_SIZE - 1)];
 
-		LeftFIFOHeadPtr = (LeftFIFOHeadPtr + (numSamplesReady / 2)) % BUFFER_SIZE;
-		RightFIFOHeadPtr = (RightFIFOHeadPtr + (numSamplesReady / 2)) % BUFFER_SIZE;
+		LeftFIFOHeadPtr = (LeftFIFOHeadPtr + numSamplesReady) % BUFFER_SIZE;
+		RightFIFOHeadPtr = (RightFIFOHeadPtr + numSamplesReady) % 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);
+//		LeftFIFOHeadPtr = (LeftFIFOHeadPtr + numSamplesReady) & (BUFFER_SIZE - 1);
+//		RightFIFOHeadPtr = (RightFIFOHeadPtr + numSamplesReady) & (BUFFER_SIZE - 1);
+//WriteLog("  -> Left/RightFIFOHeadPtr: %u/%u, Left/RightFIFOTailPtr: %u/%u\n", LeftFIFOHeadPtr, RightFIFOHeadPtr, LeftFIFOTailPtr, RightFIFOTailPtr);
 	}
+//Hmm. Seems that the SDL buffer isn't being starved by the DAC buffer...
+//	else
+//		WriteLog("DAC: Silence...!\n");
 }
 
 //
@@ -123,8 +142,7 @@ void SDLSoundCallback(void * userdata, Uint8 * buffer, int length)
 //
 int GetCalculatedFrequency(void)
 {
-	extern bool hardwareTypeNTSC;
-	int systemClockFrequency = (hardwareTypeNTSC ? RISC_CLOCK_RATE_NTSC : RISC_CLOCK_RATE_PAL);
+	int systemClockFrequency = (vjs.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).
@@ -136,61 +154,80 @@ int GetCalculatedFrequency(void)
 //
 void DACWriteByte(uint32 offset, uint8 data)
 {
-//	WriteLog("DAC: Writing %02X at %08X\n", data, offset);
+	WriteLog("DAC: Writing %02X at %08X\n", data, offset);
+	if (offset == SCLK + 3)
+		DACWriteWord(offset - 3, (uint16)data);
 }
 
 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");
+		// Spin until buffer has been drained (for too fast processors!)...
+//Small problem--if Head == 0 and Tail == buffer end, then this will fail... !!! FIX !!!
+//[DONE]
+		// Also, we're taking advantage of the fact that the buffer is a multiple of two
+		// in this check...
+		while ((LeftFIFOTailPtr + 2) & (BUFFER_SIZE - 1) == 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...! Also note that we're writing
+		// the samples in the buffer in an interleaved L/R format.
+		LeftFIFOTailPtr = (LeftFIFOTailPtr + 2) % BUFFER_SIZE;
+		DACBuffer[LeftFIFOTailPtr] = data;
+		SDL_UnlockAudio();
 	}
 	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();
-		}
+		// Spin until buffer has been drained (for too fast processors!)...
+//uint32 spin = 0;
+		while ((RightFIFOTailPtr + 2) & (BUFFER_SIZE - 1) == RightFIFOHeadPtr);
+/*		{
+spin++;
+if (spin == 0x10000000)
+{
+	WriteLog("\nStuck in right DAC spinlock! Tail=%u, Head=%u\nAborting!\n", RightFIFOTailPtr, RightFIFOHeadPtr);
+	log_done();
+	exit(0);
+}
+		}*/
+
+//This is wrong		if (RightFIFOTailPtr + 2 != RightFIFOHeadPtr)
+//		{
+		SDL_LockAudio();
+		RightFIFOTailPtr = (RightFIFOTailPtr + 2) % BUFFER_SIZE;
+		DACBuffer[RightFIFOTailPtr] = data;
+		SDL_UnlockAudio();
+//		}
+/*#ifdef DEBUG_DAC
 		else
 			WriteLog("DAC: Ran into FIFO's right tail pointer!\n");
+#endif*/
 	}
 	else if (offset == SCLK + 2)					// Sample rate
 	{
+		WriteLog("DAC: Writing %u to SCLK...\n", data);
 		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
+//Of course a better way would be to query the hardware to find the upper limit...
+			if (data > 7)	// Anything less than 8 is too high!
 			{
-				WriteLog("DAC: Failed to initialize SDL sound. Shutting down!\n");
-				log_done();
-				exit(1);
-			}
+				SDL_CloseAudio();
+				desired.freq = GetCalculatedFrequency();// SDL will do conversion on the fly, if it can't get the exact rate. Nice!
+				WriteLog("DAC: Changing sample rate to %u Hz!\n", desired.freq);
 
-			DACReset();
-			SDL_PauseAudio(false);					// Start playback!
+				if (SDL_OpenAudio(&desired, NULL) < 0)	// NULL means SDL guarantees what we want
+				{
+					WriteLog("DAC: Failed to initialize SDL sound: %s.\nDesired freq: %u\nShutting down!\n", SDL_GetError(), desired.freq);
+					log_done();
+					exit(1);
+				}
+
+				DACReset();
+				SDL_PauseAudio(false);				// Start playback!
+			}
 		}
 	}
 	else if (offset == SMODE + 2)