X-Git-Url: http://shamusworld.gotdns.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fsound.cpp;h=75f9ba2bae9779c3493752f28867905f59fd0d8d;hb=f36d026c7b8b398b88765ec5b67a3c767fe5fbad;hp=8dfbcb3c5370ee841fafc85a36ca24b6c4040e82;hpb=eeb2935c12ef41a63049126748c2574b324403a5;p=apple2 diff --git a/src/sound.cpp b/src/sound.cpp old mode 100755 new mode 100644 index 8dfbcb3..75f9ba2 --- a/src/sound.cpp +++ b/src/sound.cpp @@ -1,233 +1,255 @@ -// -// Sound Interface -// -// by James L. Hammons -// (C) 2005 Underground Software -// -// JLH = James L. Hammons -// -// WHO WHEN WHAT -// --- ---------- ------------------------------------------------------------ -// JLH 12/02/2005 Fixed a problem with sound callback thread signaling the -// main thread -// JLH 12/03/2005 Fixed sound callback dropping samples when the sample buffer -// is shorter than the callback sample buffer -// - -// STILL TO DO: -// -// - Figure out why it's losing samples (Bard's Tale) [DONE] -// - -#include "sound.h" - -#include // For memset, memcpy -#include -#include "log.h" - -using namespace std; - -// Global variables - - -// Local variables - -static SDL_AudioSpec desired; -static bool soundInitialized = false; -static uint8 amplitude = 0x88; // $78 - $88 seems to be plenty loud! -//static uint8 lastValue; - -static bool speakerState; -static uint8 soundBuffer[4096]; -static uint32 soundBufferPos; -static uint32 sampleBase; -static SDL_cond * conditional = NULL; -static SDL_mutex * mutex = NULL; - -// Private function prototypes - -static void SDLSoundCallback(void * userdata, Uint8 * buffer, int length); - -// -// Initialize the SDL sound system -// -void SoundInit(void) -{ -// To weed out problems for now... -#if 0 -return; -#endif - - desired.freq = 44100; // SDL will do conversion on the fly, if it can't get the exact rate. Nice! - desired.format = AUDIO_U8; // 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.callback = SDLSoundCallback; - - if (SDL_OpenAudio(&desired, NULL) < 0) // NULL means SDL guarantees what we want - { - WriteLog("Sound: Failed to initialize SDL sound.\n"); -// exit(1); - return; - } - - conditional = SDL_CreateCond(); - mutex = SDL_CreateMutex(); - SDL_mutexP(mutex); // Must lock the mutex for the cond to work properly... -// lastValue = (speakerState ? amplitude : 0xFF - amplitude); - soundBufferPos = 0; - sampleBase = 0; - - SDL_PauseAudio(false); // Start playback! - soundInitialized = true; - WriteLog("Sound: Successfully initialized.\n"); -} - -// -// Close down the SDL sound subsystem -// -void SoundDone(void) -{ - if (soundInitialized) - { - SDL_PauseAudio(true); - SDL_CloseAudio(); - SDL_DestroyCond(conditional); - SDL_DestroyMutex(mutex); - WriteLog("Sound: Done.\n"); - } -} - -// -// Sound card callback handler -// -static void SDLSoundCallback(void * userdata, Uint8 * buffer, int length) -{ - // The sound buffer should only starve when starting which will cause it to - // lag behind the emulation at most by around 1 frame... - - if (soundBufferPos < (uint32)length) // The sound buffer is starved... - { -//printf("Sound buffer starved!\n"); -//fflush(stdout); - for(uint32 i=0; i 0) -// memcpy(soundBuffer, soundBuffer + length, soundBufferPos); // Move current buffer down to start -// memcpy(soundBuffer, soundBuffer + length, length); - // Move current buffer down to start - for(uint32 i=0; i 95085)//(time & 0x80000000) -{ - WriteLog("ToggleSpeaker() given bad time value: %08X (%u)!\n", time, time); -// fflush(stdout); -} -#endif - -// 1.024 MHz / 60 = 17066.6... cycles (23.2199 cycles per sample) -// Need the last frame position in order to calculate correctly... - - SDL_LockAudio(); - uint8 sample = (speakerState ? amplitude : 0xFF - amplitude); -// uint8 sample = (speakerState ? amplitude : amplitude ^ 0xFF); - uint32 currentPos = sampleBase + (uint32)((double)time / 23.2199); - - if (currentPos > 4095) - { -#if 0 -WriteLog("ToggleSpeaker() about to go into spinlock at time: %08X (%u) (sampleBase=%u)!\n", time, time, sampleBase); -#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... - -Seems like it's OK now that I've fixed the buffer-less-than-length bug... -*/ - SDL_UnlockAudio(); - SDL_CondWait(conditional, mutex); - -// while (currentPos > 4095) // Spin until buffer empties a bit... - currentPos = sampleBase + (uint32)((double)time / 23.2199); - SDL_LockAudio(); -#if 0 -WriteLog("--> after spinlock (sampleBase=%u)...\n", sampleBase); -#endif - } - - while (soundBufferPos < currentPos) - soundBuffer[soundBufferPos++] = sample; - - speakerState = !speakerState; - SDL_UnlockAudio(); -} - -void HandleSoundAtFrameEdge(void) -{ - if (!soundInitialized) - return; - - SDL_LockAudio(); - sampleBase += 735; - SDL_UnlockAudio(); -/* uint8 sample = (speakerState ? amplitude : 0xFF - amplitude); - -//This shouldn't happen (buffer overflow), but it seems like it *is* happening... - if (sampleBase >= 4096) -// sampleBase = 4095; -//Kludge, for now... Until I can figure out why it's still stomping on the buffer... - sampleBase = 0; - - while (soundBufferPos < sampleBase) - soundBuffer[soundBufferPos++] = sample;//*/ -} +// +// Sound Interface +// +// by James Hammons +// (C) 2005 Underground Software +// +// JLH = James Hammons +// +// WHO WHEN WHAT +// --- ---------- ------------------------------------------------------------ +// JLH 12/02/2005 Fixed a problem with sound callback thread signaling the +// main thread +// JLH 12/03/2005 Fixed sound callback dropping samples when the sample buffer +// is shorter than the callback sample buffer +// + +// STILL TO DO: +// +// - Figure out why it's losing samples (Bard's Tale) [DONE] +// - Figure out why it's playing too fast [DONE] +// + +#include "sound.h" + +#include // For memset, memcpy +#include +#include "log.h" + +// Useful defines + +//#define DEBUG +//#define WRITE_OUT_WAVE + +//#define SAMPLE_RATE (44100.0) +#define SAMPLE_RATE (48000.0) +#define SAMPLES_PER_FRAME (SAMPLE_RATE / 60.0) +#define CYCLES_PER_SAMPLE (1024000.0 / SAMPLE_RATE) +//#define SOUND_BUFFER_SIZE (8192) +#define SOUND_BUFFER_SIZE (32768) + +// Global variables + + +// Local variables + +static SDL_AudioSpec desired, obtained; +static SDL_AudioDeviceID device; +static bool soundInitialized = false; +static bool speakerState = false; +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 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 +// +void SoundInit(void) +{ +#if 0 +// 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_S16SYS; // This uses the native endian (for portability)... + desired.channels = 1; + desired.samples = 512; // Let's try a 1/2K buffer (can always go lower) + desired.callback = SDLSoundCallback; + + device = SDL_OpenAudioDevice(NULL, 0, &desired, &obtained, 0); + + if (device == 0) + { + WriteLog("Sound: Failed to initialize SDL sound.\n"); + return; + } + + conditional = SDL_CreateCond(); + mutex = SDL_CreateMutex(); + mutex2 = SDL_CreateMutex();// Let's try real signalling... + soundBufferPos = 0; + lastToggleCycles = 0; + sample = desired.silence; // ? wilwok ? yes + + 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 +// +void SoundDone(void) +{ + if (soundInitialized) + { + SDL_PauseAudioDevice(device, 1); + 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 * 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); + + // 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... + for(uint32_t 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); +} + + +void ToggleSpeaker(void) +{ + if (!soundInitialized) + return; + + speakerState = !speakerState; + sample = (speakerState ? amplitude[ampPtr] : -amplitude[ampPtr]); +} + + +void VolumeUp(void) +{ + // Currently set for 16-bit samples + if (ampPtr < 16) + ampPtr++; +} + + +void VolumeDown(void) +{ + if (ampPtr > 0) + ampPtr--; +} + + +uint8_t GetVolume(void) +{ + return ampPtr; +} +