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

diff --git a/src/dac.cpp b/src/dac.cpp
index be2f2c5..54bc50b 100644
--- a/src/dac.cpp
+++ b/src/dac.cpp
@@ -9,6 +9,9 @@
 #include <SDL.h>
 #include "jaguar.h"
 #include "dac.h"
+#include "settings.h"
+
+//#define DEBUG_DAC
 
 #define BUFFER_SIZE		0x8000						// Make the DAC buffers 32K x 16 bits
 
@@ -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
@@ -86,6 +89,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,10 +103,19 @@ 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);
@@ -110,12 +124,16 @@ void SDLSoundCallback(void * userdata, Uint8 * buffer, int length)
 			((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;
+		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 +141,8 @@ 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);
+//	extern bool hardwareTypeNTSC;
+	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,7 +154,9 @@ 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)
@@ -147,17 +167,21 @@ void DACWriteWord(uint32 offset, uint16 data)
 		{
 			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...!
+			// 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;
 // 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...
+//Looks like a cheap & dirty way to convert signed samples to unsigned...
 //			DACBuffer[LeftFIFOTailPtr] = data ^ 0x8000;
 			SDL_UnlockAudio();
 		}
+#ifdef DEBUG_DAC
 		else
 			WriteLog("DAC: Ran into FIFO's left tail pointer!\n");
+#endif
 	}
 	else if (offset == RTXD + 2)
 	{
@@ -170,27 +194,34 @@ void DACWriteWord(uint32 offset, uint16 data)
 //			DACBuffer[RightFIFOTailPtr] = data ^ 0x8000;
 			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);
+
+				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!
 			}
-
-			DACReset();
-			SDL_PauseAudio(false);					// Start playback!
 		}
 	}
 	else if (offset == SMODE + 2)