X-Git-Url: http://shamusworld.gotdns.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fdac.cpp;h=2faf2cd73b7dff7dd0f8e09ed39f9ba0108dcec2;hb=022ea8444d3a2ff684eadd759289ade3ead1acf9;hp=2ae3e69595f8f4708fb8caef3a106b895ad9aed4;hpb=67a5f1a40072983cf87ae2093ca95c271d14e706;p=virtualjaguar diff --git a/src/dac.cpp b/src/dac.cpp index 2ae3e69..2faf2cd 100644 --- a/src/dac.cpp +++ b/src/dac.cpp @@ -1,24 +1,34 @@ // // DAC (really, Synchronous Serial Interface) Handler // -// by cal2 +// Originally by David Raingeard // GCC/SDL port by Niels Wagenaar (Linux/WIN32) and Caz (BeOS) // Rewritten by James L. Hammons // -#include +#include "SDL.h" +#include "m68k.h" #include "jaguar.h" +#include "settings.h" #include "dac.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 #define LTXD 0xF1A148 #define RTXD 0xF1A14C +#define LRXD 0xF1A148 +#define RRXD 0xF1A14C #define SCLK 0xF1A150 #define SMODE 0xF1A154 +// Global variables + +uint16 lrxd, rrxd; // I2S ports (into Jaguar) + // Local variables uint32 LeftFIFOHeadPtr, LeftFIFOTailPtr, RightFIFOHeadPtr, RightFIFOTailPtr; @@ -37,7 +47,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 +56,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,12 +81,13 @@ void DACReset(void) } // -// Close down the SDL sound subsystem (?) (!) +// Close down the SDL sound subsystem // void DACDone(void) { SDL_PauseAudio(true); SDL_CloseAudio(); + memory_free(DACBuffer); WriteLog("DAC: Done.\n"); } @@ -117,15 +129,15 @@ void SDLSoundCallback(void * userdata, Uint8 * buffer, int 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 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... @@ -138,8 +150,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). @@ -149,48 +160,58 @@ int GetCalculatedFrequency(void) // // LTXD/RTXD/SCLK/SMODE ($F1A148/4C/50/54) // -void DACWriteByte(uint32 offset, uint8 data) +void DACWriteByte(uint32 offset, uint8 data, uint32 who/*= UNKNOWN*/) { - WriteLog("DAC: Writing %02X at %08X\n", data, offset); + WriteLog("DAC: %s writing BYTE %02X at %08X\n", whoName[who], data, offset); if (offset == SCLK + 3) DACWriteWord(offset - 3, (uint16)data); } -void DACWriteWord(uint32 offset, uint16 data) +void DACWriteWord(uint32 offset, uint16 data, uint32 who/*= UNKNOWN*/) { 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...! 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(); - } - 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 { @@ -199,7 +220,7 @@ void DACWriteWord(uint32 offset, uint16 data) { SCLKFrequencyDivider = (uint8)data; //Of course a better way would be to query the hardware to find the upper limit... - if (data > 7) // Anything less is too high! + if (data > 7) // Anything less than 8 is too high! { SDL_CloseAudio(); desired.freq = GetCalculatedFrequency();// SDL will do conversion on the fly, if it can't get the exact rate. Nice! @@ -220,24 +241,40 @@ void DACWriteWord(uint32 offset, uint16 data) else if (offset == SMODE + 2) { serialMode = data; - WriteLog("DAC: Writing to SMODE. Bits: %s%s%s%s%s%s\n", + WriteLog("DAC: %s writing to SMODE. Bits: %s%s%s%s%s%s [68K PC=%08X]\n", whoName[who], (data & 0x01 ? "INTERNAL " : ""), (data & 0x02 ? "MODE " : ""), (data & 0x04 ? "WSEN " : ""), (data & 0x08 ? "RISING " : ""), - (data & 0x10 ? "FALLING " : ""), (data & 0x20 ? "EVERYWORD" : "")); + (data & 0x10 ? "FALLING " : ""), (data & 0x20 ? "EVERYWORD" : ""), + m68k_get_reg(NULL, M68K_REG_PC)); } } // // LRXD/RRXD/SSTAT ($F1A148/4C/50) // -uint8 DACReadByte(uint32 offset) +uint8 DACReadByte(uint32 offset, uint32 who/*= UNKNOWN*/) { -// WriteLog("DAC: Reading byte from %08X\n", offset); +// WriteLog("DAC: %s reading byte from %08X\n", whoName[who], offset); return 0xFF; } -uint16 DACReadWord(uint32 offset) +//static uint16 fakeWord = 0; +uint16 DACReadWord(uint32 offset, uint32 who/*= UNKNOWN*/) { -// WriteLog("DAC: Reading word from %08X\n", offset); - return 0xFFFF; +// WriteLog("DAC: %s reading word from %08X\n", whoName[who], offset); +// return 0xFFFF; +// WriteLog("DAC: %s reading WORD %04X from %08X\n", whoName[who], fakeWord, offset); +// return fakeWord++; +//NOTE: This only works if a bunch of things are set in BUTCH which we currently don't +// check for. !!! FIX !!! +// Partially fixed: We check for I2SCNTRL in the JERRY I2S routine... +// return GetWordFromButchSSI(offset, who); + if (offset == LRXD || offset == RRXD) + return 0x0000; + else if (offset == LRXD + 2) + return lrxd; + else if (offset == RRXD + 2) + return rrxd; + + return 0xFFFF; // May need SSTAT as well... (but may be a Jaguar II only feature) }