X-Git-Url: http://shamusworld.gotdns.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fsound.cpp;h=4cab23ec0aad0ec7a353e97869cf6ed53d1e5179;hb=c0001155bc0909da61f6c849c0be9b16e9b7f4b6;hp=b708b2dd14704532546a8ddfd3152e9c7cffa776;hpb=b2f84b05826e7ae1c857ef0dc5f34800506f7eca;p=apple2 diff --git a/src/sound.cpp b/src/sound.cpp index b708b2d..4cab23e 100755 --- a/src/sound.cpp +++ b/src/sound.cpp @@ -17,46 +17,72 @@ // STILL TO DO: // // - Figure out why it's losing samples (Bard's Tale) [DONE] +// - Figure out why it's playing too fast // #include "sound.h" #include // For memset, memcpy -#include +#include #include "log.h" +// Useful defines + +//#define DEBUG +//#define WRITE_OUT_WAVE + +// This is odd--seems to be working properly now! Maybe a bug in the SDL sound code? +// Actually, it still doesn't sound right... Sounds too slow now. :-/ +// But then again, it's difficult to tell. Sometimes it slows waaaaaay down, but generally +// seems to be OK other than that +// Also, it could be that the discrepancy in pitch is due to the V65C02 and it's lack of +// cycle accuracy... //#define SAMPLE_RATE (44100.0) #define SAMPLE_RATE (48000.0) #define SAMPLES_PER_FRAME (SAMPLE_RATE / 60.0) +// This works for AppleWin but not here... ??? WHY ??? +// ~ 21 #define CYCLES_PER_SAMPLE (1024000.0 / SAMPLE_RATE) -#define SOUND_BUFFER_SIZE (8192) -//#define AMPLITUDE (16) // -32 - +32 seems to be plenty loud! +// ~ 17 (lower pitched than above...!) +// Makes sense, as this is the divisor for # of cycles passed +//#define CYCLES_PER_SAMPLE (800000.0 / SAMPLE_RATE) +// This seems about right, compared to AppleWin--but AW runs @ 1.024 MHz +// 23 (1.024) vs. 20 (0.900) +//#define CYCLES_PER_SAMPLE (900000.0 / SAMPLE_RATE) +//nope, too high #define CYCLES_PER_SAMPLE (960000.0 / SAMPLE_RATE) +//#define CYCLES_PER_SAMPLE 21 +//#define SOUND_BUFFER_SIZE (8192) +#define SOUND_BUFFER_SIZE (32768) // Global variables // Local variables -static SDL_AudioSpec desired; +static SDL_AudioSpec desired, obtained; +static SDL_AudioDeviceID device; static bool soundInitialized = false; static bool speakerState = false; -static uint8 soundBuffer[SOUND_BUFFER_SIZE]; -static uint32 soundBufferPos; -static uint32 sampleBase; -static uint64 lastToggleCycles; -static uint64 samplePosition; +static int16_t soundBuffer[SOUND_BUFFER_SIZE]; +static uint32_t soundBufferPos; +static uint64_t lastToggleCycles; static SDL_cond * conditional = NULL; static SDL_mutex * mutex = NULL; static SDL_mutex * mutex2 = NULL; -static uint8 ampPtr = 5; -static uint16 amplitude[17] = { 0, 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, - 4096, 8192, 16384, 32768 }; +static int16_t sample; +static uint8_t ampPtr = 12; // Start with -2047 - +2047 +static int16_t amplitude[17] = { 0, 1, 2, 3, 7, 15, 31, 63, 127, 255, 511, 1023, 2047, + 4095, 8191, 16383, 32767 }; +#ifdef WRITE_OUT_WAVE +static FILE * fp = NULL; +#endif // Private function prototypes static void SDLSoundCallback(void * userdata, Uint8 * buffer, int length); + // // Initialize the SDL sound system // @@ -66,17 +92,16 @@ void SoundInit(void) // To weed out problems for now... return; #endif - + SDL_zero(desired); desired.freq = SAMPLE_RATE; // SDL will do conversion on the fly, if it can't get the exact rate. Nice! - desired.format = AUDIO_S8; // This uses the native endian (for portability)... -// desired.format = AUDIO_S16SYS; // This uses the native endian (for portability)... + desired.format = AUDIO_S16SYS; // This uses the native endian (for portability)... desired.channels = 1; -// 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.samples = 1024; // Let's try a 1K buffer (can always go lower) + desired.samples = 512; // Let's try a 1/2K buffer (can always go lower) desired.callback = SDLSoundCallback; - if (SDL_OpenAudio(&desired, NULL) < 0) // NULL means SDL guarantees what we want + device = SDL_OpenAudioDevice(NULL, 0, &desired, &obtained, 0); + + if (device == 0) { WriteLog("Sound: Failed to initialize SDL sound.\n"); return; @@ -85,17 +110,20 @@ return; conditional = SDL_CreateCond(); mutex = SDL_CreateMutex(); mutex2 = SDL_CreateMutex();// Let's try real signalling... - SDL_mutexP(mutex); // Must lock the mutex for the cond to work properly... soundBufferPos = 0; - sampleBase = 0; lastToggleCycles = 0; - samplePosition = 0; + sample = desired.silence; // ? wilwok ? yes - SDL_PauseAudio(false); // Start playback! + SDL_PauseAudioDevice(device, 0); // Start playback! soundInitialized = true; WriteLog("Sound: Successfully initialized.\n"); + +#ifdef WRITE_OUT_WAVE + fp = fopen("./apple2.wav", "wb"); +#endif } + // // Close down the SDL sound subsystem // @@ -103,65 +131,117 @@ void SoundDone(void) { if (soundInitialized) { - SDL_PauseAudio(true); - SDL_CloseAudio(); +// SDL_PauseAudio(true); + SDL_PauseAudioDevice(device, 1); +// SDL_CloseAudio(); + SDL_CloseAudioDevice(device); SDL_DestroyCond(conditional); SDL_DestroyMutex(mutex); SDL_DestroyMutex(mutex2); WriteLog("Sound: Done.\n"); + +#ifdef WRITE_OUT_WAVE + fclose(fp); +#endif } } + +void SoundPause(void) +{ + if (soundInitialized) + SDL_PauseAudioDevice(device, 1); +} + + +void SoundResume(void) +{ + if (soundInitialized) + SDL_PauseAudioDevice(device, 0); +} + + // // Sound card callback handler // -static void SDLSoundCallback(void * userdata, Uint8 * buffer, int length) +static void SDLSoundCallback(void * /*userdata*/, Uint8 * buffer8, int length8) { +//WriteLog("SDLSoundCallback(): begin (soundBufferPos=%i)\n", soundBufferPos); // The sound buffer should only starve when starting which will cause it to // lag behind the emulation at most by around 1 frame... // (Actually, this should never happen since we fill the buffer beforehand.) // (But, then again, if the sound hasn't been toggled for a while, then this // makes perfect sense as the buffer won't have been filled at all!) + // (Should NOT starve now, now that we properly handle frame edges...) // Let's try using a mutex for shared resource consumption... +//Actually, I think Lock/UnlockAudio() does this already... +//WriteLog("SDLSoundCallback: soundBufferPos = %i\n", soundBufferPos); SDL_mutexP(mutex2); - if (soundBufferPos < (uint32)length) // The sound buffer is starved... + // Recast this as a 16-bit type... + int16_t * buffer = (int16_t *)buffer8; + uint32_t length = (uint32_t)length8 / 2; + +//WriteLog("SDLSoundCallback(): filling buffer...\n"); + if (soundBufferPos < length) // The sound buffer is starved... { -//printf("Sound buffer starved!\n"); -//fflush(stdout); - for(uint32 i=0; i= (SOUND_BUFFER_SIZE - 1)) + { +//WriteLog("WriteSampleToBuffer(): Waiting for sound thread. soundBufferPos=%i, SOUNDBUFFERSIZE-1=%i\n", soundBufferPos, SOUND_BUFFER_SIZE-1); + SDL_mutexV(mutex2); // Release it so sound thread can get it, + SDL_mutexP(mutex); // Must lock the mutex for the cond to work properly... + SDL_CondWait(conditional, mutex); // Sleep/wait for the sound thread + SDL_mutexV(mutex); // Must unlock the mutex for the cond to work properly... + SDL_mutexP(mutex2); // Re-lock it until we're done with it... + } + + soundBuffer[soundBufferPos++] = sample; +//WriteLog("WriteSampleToBuffer(): SDL_mutexV(mutex2)\n"); + SDL_mutexV(mutex2); } + // Need some interface functions here to take care of flipping the // waveform at the correct time in the sound stream... @@ -178,116 +258,107 @@ So... I guess what we could do is this: the time position back (or copies data down from what it took out) */ -void ToggleSpeaker(uint64 elapsedCycles) +void HandleBuffer(uint64_t elapsedCycles) { - if (!soundInitialized) - return; - - uint64 deltaCycles = elapsedCycles - lastToggleCycles; - -#if 0 -if (time > 95085)//(time & 0x80000000) -{ - WriteLog("ToggleSpeaker() given bad time value: %08X (%u)!\n", time, time); -// fflush(stdout); -} -#endif + // Step 1: Calculate delta time + uint64_t deltaCycles = elapsedCycles - lastToggleCycles; - // 1.024 MHz / 60 = 17066.6... cycles (23.2199 cycles per sample) - // Need the last frame position in order to calculate correctly... - // (or do we?) + // Step 2: Calculate new buffer position + uint32_t currentPos = (uint32_t)((double)deltaCycles / CYCLES_PER_SAMPLE); -// SDL_LockAudio(); + // Step 3: Make sure there's room for it + // We need to lock since we touch both soundBuffer and soundBufferPos SDL_mutexP(mutex2); -// uint32 currentPos = sampleBase + (uint32)((double)elapsedCycles / CYCLES_PER_SAMPLE); - uint32 currentPos = (uint32)((double)deltaCycles / CYCLES_PER_SAMPLE); - -/* -The problem: - - ______ | ______________ | ______ -____| | | |_______ - -Speaker is toggled, then not toggled for a while. How to find buffer position in the -last frame? - -IRQ buffer len is 1024. -Could check current CPU clock, take delta. If delta > 1024, then ... - -Could add # of cycles in IRQ to lastToggleCycles, then currentPos will be guaranteed -to fall within acceptable limits. -*/ + while ((soundBufferPos + currentPos) > (SOUND_BUFFER_SIZE - 1)) + { + SDL_mutexV(mutex2); // Release it so sound thread can get it, + SDL_mutexP(mutex); // Must lock the mutex for the cond to work properly... + SDL_CondWait(conditional, mutex); // Sleep/wait for the sound thread + SDL_mutexV(mutex); // Must unlock the mutex for the cond to work properly... + SDL_mutexP(mutex2); // Re-lock it until we're done with it... + } + // Step 4: Backfill and adjust lastToggleCycles + // currentPos is position from "zero" or soundBufferPos... + currentPos += soundBufferPos; - if (currentPos > SOUND_BUFFER_SIZE - 1) - { -#if 0 -WriteLog("ToggleSpeaker() about to go into spinlock at time: %08X (%u) (sampleBase=%u)!\n", time, time, sampleBase); +#ifdef WRITE_OUT_WAVE + uint32_t sbpSave = soundBufferPos; #endif -// Still hanging on this spinlock... -// That could be because the "time" value is too high and so the buffer will NEVER be -// empty enough... -// Now that we're using a conditional, it seems to be working OK--though not perfectly... -/* -ToggleSpeaker() about to go into spinlock at time: 00004011 (16401) (sampleBase=3504)! -16401 -> 706 samples, 3504 + 706 = 4210 - -And it still thrashed the sound even though it didn't run into a spinlock... + // Backfill with current toggle state + while (soundBufferPos < currentPos) + soundBuffer[soundBufferPos++] = sample; -Seems like it's OK now that I've fixed the buffer-less-than-length bug... -*/ -// SDL_UnlockAudio(); -// SDL_CondWait(conditional, mutex); -// SDL_LockAudio(); -// Hm. -SDL_mutexV(mutex2);//Release it so sound thread can get it, -SDL_CondWait(conditional, mutex);//Sleep/wait for the sound thread -SDL_mutexP(mutex2);//Re-lock it until we're done with it... - - currentPos = sampleBase + (uint32)((double)elapsedCycles / CYCLES_PER_SAMPLE); -#if 0 -WriteLog("--> after spinlock (sampleBase=%u)...\n", sampleBase); +#ifdef WRITE_OUT_WAVE + fwrite(&soundBuffer[sbpSave], sizeof(int16_t), currentPos - sbpSave, fp); #endif - } - int8 sample = (speakerState ? amplitude[ampPtr] : -amplitude[ampPtr]); + SDL_mutexV(mutex2); + lastToggleCycles = elapsedCycles; +} - while (soundBufferPos < currentPos) - soundBuffer[soundBufferPos++] = (uint8)sample; - // This is done *after* in case the buffer had a long dead spot (I think...) +void ToggleSpeaker(uint64_t elapsedCycles) +{ + if (!soundInitialized) + return; + +// HandleBuffer(elapsedCycles); speakerState = !speakerState; - SDL_mutexV(mutex2); -// SDL_UnlockAudio(); + sample = (speakerState ? amplitude[ampPtr] : -amplitude[ampPtr]); } -void AddToSoundTimeBase(uint32 cycles) + +void AdjustLastToggleCycles(uint64_t elapsedCycles) { if (!soundInitialized) return; +/* +BOOKKEEPING -// SDL_LockAudio(); - SDL_mutexP(mutex2); - sampleBase += (uint32)((double)cycles / CYCLES_PER_SAMPLE); - SDL_mutexV(mutex2); -// SDL_UnlockAudio(); +We need to know the following: + + o Where in the sound buffer the base or "zero" time is + o At what CPU timestamp the speaker was last toggled + NOTE: we keep things "right" by advancing this number every frame, even + if nothing happened! That way, we can keep track without having + to detect whether or not several frames have gone by without any + activity. + +How to do it: + +Every time the speaker is toggled, we move the base or "zero" time to the +current spot in the buffer. We also backfill the buffer up to that point with +the old toggle value. The next time the speaker is toggled, we measure the +difference in time between the last time it was toggled (the "zero") and now, +and repeat the cycle. + +We handle dead spots by backfilling the buffer with the current toggle value +every frame--this way we don't have to worry about keeping current time and +crap like that. So, we have to move the "zero" the right amount, just like +in ToggleSpeaker(), and backfill only without toggling. +*/ + HandleBuffer(elapsedCycles); } + void VolumeUp(void) { - // Currently set for 8-bit samples - if (ampPtr < 8) + // Currently set for 16-bit samples + if (ampPtr < 16) ampPtr++; } + void VolumeDown(void) { if (ampPtr > 0) ampPtr--; } -uint8 GetVolume(void) + +uint8_t GetVolume(void) { return ampPtr; } @@ -355,9 +426,3 @@ Still getting random clicks when running... (This may be due to the lock/unlock sound happening in ToggleSpeaker()...) */ - - - - - -