2 // DAC (really, Synchronous Serial Interface) Handler
5 // GCC/SDL port by Niels Wagenaar (Linux/WIN32) and Caz (BeOS)
6 // Rewritten by James L. Hammons
16 #define BUFFER_SIZE 0x10000 // Make the DAC buffers 64K x 16 bits
18 // Jaguar memory locations
23 #define SMODE 0xF1A154
27 uint32 LeftFIFOHeadPtr, LeftFIFOTailPtr, RightFIFOHeadPtr, RightFIFOTailPtr;
28 SDL_AudioSpec desired;
30 // We can get away with using native endian here because we can tell SDL to use the native
31 // endian when looking at the sample buffer, i.e., no need to worry about it.
34 uint8 SCLKFrequencyDivider = 19; // Default is roughly 22 KHz (20774 Hz in NTSC mode)
35 uint16 serialMode = 0;
37 // Private function prototypes
39 void SDLSoundCallback(void * userdata, Uint8 * buffer, int length);
40 int GetCalculatedFrequency(void);
43 // Initialize the SDL sound system
47 memory_malloc_secure((void **)&DACBuffer, BUFFER_SIZE * sizeof(uint16), "DAC buffer");
49 desired.freq = GetCalculatedFrequency(); // SDL will do conversion on the fly, if it can't get the exact rate. Nice!
50 desired.format = AUDIO_S16SYS; // This uses the native endian (for portability)...
52 // desired.samples = 4096; // Let's try a 4K buffer (can always go lower)
53 desired.samples = 2048; // Let's try a 2K buffer (can always go lower)
54 desired.callback = SDLSoundCallback;
56 if (SDL_OpenAudio(&desired, NULL) < 0) // NULL means SDL guarantees what we want
58 WriteLog("DAC: Failed to initialize SDL sound. Shutting down!\n");
64 SDL_PauseAudio(false); // Start playback!
65 WriteLog("DAC: Successfully initialized.\n");
69 // Reset the sound buffer FIFOs
73 LeftFIFOHeadPtr = LeftFIFOTailPtr = 0, RightFIFOHeadPtr = RightFIFOTailPtr = 1;
77 // Close down the SDL sound subsystem
83 WriteLog("DAC: Done.\n");
87 // SDL callback routine to fill audio buffer
89 // Note: The samples are packed in the buffer in 16 bit left/16 bit right pairs.
91 void SDLSoundCallback(void * userdata, Uint8 * buffer, int length)
93 // Clear the buffer to silence, in case the DAC buffer is empty (or short)
94 memset(buffer, desired.silence, length);
95 //WriteLog("DAC: Inside callback...\n");
96 if (LeftFIFOHeadPtr != LeftFIFOTailPtr)
98 //WriteLog("DAC: About to write some data!\n");
99 int numLeftSamplesReady
100 = (LeftFIFOTailPtr + (LeftFIFOTailPtr < LeftFIFOHeadPtr ? BUFFER_SIZE : 0))
102 int numRightSamplesReady
103 = (RightFIFOTailPtr + (RightFIFOTailPtr < RightFIFOHeadPtr ? BUFFER_SIZE : 0))
106 = (numLeftSamplesReady < numRightSamplesReady
107 ? numLeftSamplesReady : numRightSamplesReady);//Hmm. * 2;
109 //The numbers look good--it's just that the DSP can't get enough samples in the DAC buffer!
110 //WriteLog("DAC: Left/RightFIFOHeadPtr: %u/%u, Left/RightFIFOTailPtr: %u/%u\n", LeftFIFOHeadPtr, RightFIFOHeadPtr, LeftFIFOTailPtr, RightFIFOTailPtr);
111 //WriteLog(" numLeft/RightSamplesReady: %i/%i, numSamplesReady: %i, length of buffer: %i\n", numLeftSamplesReady, numRightSamplesReady, numSamplesReady, length);
113 /* if (numSamplesReady > length)
114 numSamplesReady = length;//*/
115 if (numSamplesReady > length / 2) // length / 2 because we're comparing 16-bit lengths
116 numSamplesReady = length / 2;
118 // WriteLog(" Not enough samples to fill the buffer (short by %u L/R samples)...\n", (length / 2) - numSamplesReady);
119 //WriteLog("DAC: %u samples ready.\n", numSamplesReady);
121 // Actually, it's a bit more involved than this, but this is the general idea:
122 // memcpy(buffer, DACBuffer, length);
123 for(int i=0; i<numSamplesReady; i++)
124 ((uint16 *)buffer)[i] = DACBuffer[(LeftFIFOHeadPtr + i) % BUFFER_SIZE];
125 // Could also use (as long as BUFFER_SIZE is a multiple of 2):
126 // buffer[i] = DACBuffer[(LeftFIFOHeadPtr + i) & (BUFFER_SIZE - 1)];
128 LeftFIFOHeadPtr = (LeftFIFOHeadPtr + numSamplesReady) % BUFFER_SIZE;
129 RightFIFOHeadPtr = (RightFIFOHeadPtr + numSamplesReady) % BUFFER_SIZE;
130 // Could also use (as long as BUFFER_SIZE is a multiple of 2):
131 // LeftFIFOHeadPtr = (LeftFIFOHeadPtr + numSamplesReady) & (BUFFER_SIZE - 1);
132 // RightFIFOHeadPtr = (RightFIFOHeadPtr + numSamplesReady) & (BUFFER_SIZE - 1);
133 //WriteLog(" -> Left/RightFIFOHeadPtr: %u/%u, Left/RightFIFOTailPtr: %u/%u\n", LeftFIFOHeadPtr, RightFIFOHeadPtr, LeftFIFOTailPtr, RightFIFOTailPtr);
135 //Hmm. Seems that the SDL buffer isn't being starved by the DAC buffer...
137 // WriteLog("DAC: Silence...!\n");
141 // Calculate the frequency of SCLK * 32 using the divider
143 int GetCalculatedFrequency(void)
145 int systemClockFrequency = (vjs.hardwareTypeNTSC ? RISC_CLOCK_RATE_NTSC : RISC_CLOCK_RATE_PAL);
147 // We divide by 32 here in order to find the frequency of 32 SCLKs in a row (transferring
148 // 16 bits of left data + 16 bits of right data = 32 bits, 1 SCLK = 1 bit transferred).
149 return systemClockFrequency / (32 * (2 * (SCLKFrequencyDivider + 1)));
153 // LTXD/RTXD/SCLK/SMODE ($F1A148/4C/50/54)
155 void DACWriteByte(uint32 offset, uint8 data)
157 WriteLog("DAC: Writing %02X at %08X\n", data, offset);
158 if (offset == SCLK + 3)
159 DACWriteWord(offset - 3, (uint16)data);
162 void DACWriteWord(uint32 offset, uint16 data)
164 if (offset == LTXD + 2)
166 // Spin until buffer has been drained (for too fast processors!)...
167 //Small problem--if Head == 0 and Tail == buffer end, then this will fail... !!! FIX !!!
169 // Also, we're taking advantage of the fact that the buffer is a multiple of two
171 while ((LeftFIFOTailPtr + 2) & (BUFFER_SIZE - 1) == LeftFIFOHeadPtr);
173 SDL_LockAudio(); // Is it necessary to do this? Mebbe.
174 // We use a circular buffer 'cause it's easy. Note that the callback function
175 // takes care of dumping audio to the soundcard...! Also note that we're writing
176 // the samples in the buffer in an interleaved L/R format.
177 LeftFIFOTailPtr = (LeftFIFOTailPtr + 2) % BUFFER_SIZE;
178 DACBuffer[LeftFIFOTailPtr] = data;
181 else if (offset == RTXD + 2)
183 // Spin until buffer has been drained (for too fast processors!)...
185 while ((RightFIFOTailPtr + 2) & (BUFFER_SIZE - 1) == RightFIFOHeadPtr);
188 if (spin == 0x10000000)
190 WriteLog("\nStuck in right DAC spinlock! Tail=%u, Head=%u\nAborting!\n", RightFIFOTailPtr, RightFIFOHeadPtr);
196 //This is wrong if (RightFIFOTailPtr + 2 != RightFIFOHeadPtr)
199 RightFIFOTailPtr = (RightFIFOTailPtr + 2) % BUFFER_SIZE;
200 DACBuffer[RightFIFOTailPtr] = data;
205 WriteLog("DAC: Ran into FIFO's right tail pointer!\n");
208 else if (offset == SCLK + 2) // Sample rate
210 WriteLog("DAC: Writing %u to SCLK...\n", data);
211 if ((uint8)data != SCLKFrequencyDivider)
213 SCLKFrequencyDivider = (uint8)data;
214 //Of course a better way would be to query the hardware to find the upper limit...
215 if (data > 7) // Anything less than 8 is too high!
218 desired.freq = GetCalculatedFrequency();// SDL will do conversion on the fly, if it can't get the exact rate. Nice!
219 WriteLog("DAC: Changing sample rate to %u Hz!\n", desired.freq);
221 if (SDL_OpenAudio(&desired, NULL) < 0) // NULL means SDL guarantees what we want
223 WriteLog("DAC: Failed to initialize SDL sound: %s.\nDesired freq: %u\nShutting down!\n", SDL_GetError(), desired.freq);
229 SDL_PauseAudio(false); // Start playback!
233 else if (offset == SMODE + 2)
236 WriteLog("DAC: Writing to SMODE. Bits: %s%s%s%s%s%s\n",
237 (data & 0x01 ? "INTERNAL " : ""), (data & 0x02 ? "MODE " : ""),
238 (data & 0x04 ? "WSEN " : ""), (data & 0x08 ? "RISING " : ""),
239 (data & 0x10 ? "FALLING " : ""), (data & 0x20 ? "EVERYWORD" : ""));
244 // LRXD/RRXD/SSTAT ($F1A148/4C/50)
246 uint8 DACReadByte(uint32 offset)
248 // WriteLog("DAC: Reading byte from %08X\n", offset);
252 uint16 DACReadWord(uint32 offset)
254 // WriteLog("DAC: Reading word from %08X\n", offset);