./0000755000076600007660000000000010433400375010620 5ustar patpat00000000000000./Makefile0000644000076600007660000000537410433400375012271 0ustar patpat00000000000000 # # pre-declare all as the primary target # all: # # pick a platform # UNAME := $(shell uname -s) ifeq "$(UNAME)" "Darwin" ARCH := macosx endif MKDIR_CMD = test -d "`dirname $@`" || mkdir -p "`dirname $@`" DEP_TO_OBJ_CMD = $(shell dirname $@ | sed -e s@$(DEPDIR)@$(OBJDIR)@) DEP_CMD = sed -e 's@^\([^:]*\):@$(@) $(DEP_TO_OBJ_CMD)/\1:@' > $@ # # Set up basic directories # SRCDIR := src IMPORTDIR := import BUILDDIR := Build RELEASEDIR := Release DATADIR := $(RELEASEDIR)/data OBJDIR := $(BUILDDIR)/$(ARCH)/objs DEPDIR := $(BUILDDIR)/$(ARCH)/deps LIBRARY := $(BUILDDIR)/$(ARCH)/librmusic++.a TARGETS := $(RELEASEDIR)/$(ARCH)/swarm # # Include platform specific stuff if needed # include src/platform_$(ARCH)/Makefile # # Choose an optimization level # (must be after platform-specifics to get proper flags) # OPTFLG := $(OPTIMIZE_FLAG) #OPTFLG := $(DEBUG_FLAG) # # Concatenate all of the specific flags # CPPFLAGS := $(CPP_PLATFORM) \ $(CPP_SDL) \ $(CPP_GL) LDFLAGS := $(LD_PLATFORM) \ $(LD_SDL) \ $(LD_GL) # # Object files and dependencies # OBJS := $(PLATFORM_OBJS) \ $(OBJDIR)/soundDev/soundDev.o \ $(OBJDIR)/pipes/streamPipe.o \ $(OBJDIR)/elements/streamElement.o \ $(OBJDIR)/elements/tone.o \ $(OBJDIR)/elements/swarmElement.o \ $(OBJDIR)/swarm/swarm.o DEPS := $(patsubst %.o,%.d, $(patsubst $(OBJDIR)/%,$(DEPDIR)/%,$(OBJS) ) ) # # major targets # all: $(TARGETS) $(RELEASEDIR)/$(ARCH)/%: $(OBJDIR)/%.o $(LIBRARY) @$(MKDIR_CMD) $(CXX) $(OPTFLG) $(CXXFLAGS) -o $@ $< $(LIBRARY) $(LDFLAGS) $(LIBRARY): $(OBJS) @$(MKDIR_CMD) $(AR) $@ $(LIBRARY) $(OBJS) $(RANLIB) $(LIBRARY) spotless: clean rm -rf $(BUILDDIR) rm -rf $(RELEASEDIR) clean: rm -rf $(OBJDIR) # # Generic rules... # # # C++ # $(OBJDIR)/%.o: $(SRCDIR)/%.cpp @$(MKDIR_CMD) $(CXX) $(OPTFLG) $(CPPFLAGS) $(CXXFLAGS) -c $< -o $@ $(DEPDIR)/%.d: $(SRCDIR)/%.cpp @$(MKDIR_CMD) @$(CXX) $(CXXDEP) $(OPTFLG) $(CPPFLAGS) $(CXXFLAGS) -c $< | $(DEP_CMD) # # C # $(OBJDIR)/%.o: $(SRCDIR)/%.c @$(MKDIR_CMD) $(CC) $(OPTFLG) $(CPPFLAGS) $(CCFLAGS) -c $< -o $@ $(DEPDIR)/%.d: $(SRCDIR)/%.c @$(MKDIR_CMD) @$(CC) $(CCDEP) $(OPTFLG) $(CPPFLAGS) $(CCFLAGS) -c $< | $(DEP_CMD) $(OBJDIR)/import/%.o: $(IMPORTDIR)/%.c @$(MKDIR_CMD) $(CC) $(OPTFLG) $(CPPFLAGS) $(CCFLAGS) -c $< -o $@ $(DEPDIR)/import/%.d: $(IMPORTDIR)/%.c @$(MKDIR_CMD) @$(CC) $(CCDEP) $(OPTFLG) $(CPPFLAGS) $(CCFLAGS) -c $< | $(DEP_CMD) # # Objective-C # $(OBJDIR)/%.o: $(SRCDIR)/%.m @$(MKDIR_CMD) $(OCC) $(OPTFLG) $(CPPFLAGS) $(OCCFLAGS) -c $< -o $@ $(DEPDIR)/%.d: $(SRCDIR)/%.m @$(MKDIR_CMD) @$(OCC) $(OCCDEP) $(OPTFLG) $(CPPFLAGS) $(OCCFLAGS) -c $< | $(DEP_CMD) # # Gnu make specific dependencies # .PHONY: all .PHONY: clean .PHONY: spotless # # project-specific dependencies # include $(DEPS) ./src/0000755000076600007660000000000010433400375011407 5ustar patpat00000000000000./src/elements/0000755000076600007660000000000010433400375013223 5ustar patpat00000000000000./src/elements/streamElement.cpp0000644000076600007660000000146610433400375016543 0ustar patpat00000000000000#include #include #include "../pipes/streamPipe.h" #include "streamElement.h" StreamElement::StreamElement( StreamPipe* _in, StreamPipe* _out ) : in( _in ), out( _out ), thr( 0 ) { } StreamElement::~StreamElement( void ) { if ( this->in not_eq 0 ) { this->in->readClose(); } if ( this->out not_eq 0 ) { this->out->writeClose(); } if ( this->thr not_eq 0 ) { this->waitForThread(); } } void StreamElement::startThread( void ) { this->thr = ::SDL_CreateThread( runTrampoline, this ); } void StreamElement::waitForThread( void ) { if ( this->thr not_eq 0 ) { int status; ::SDL_WaitThread( this->thr, &status ); this->thr = 0; } } int StreamElement::runTrampoline( void* data ) { StreamElement* el = (StreamElement*)data; return el->run(); } ./src/elements/streamElement.h0000644000076600007660000000056310433400375016205 0ustar patpat00000000000000 class StreamPipe; class StreamElement { public: StreamElement( StreamPipe* _in, StreamPipe* _out ); virtual ~StreamElement( void ); void startThread( void ); void waitForThread( void ); protected: virtual int run( void ) = 0; StreamPipe* in; StreamPipe* out; private: SDL_Thread* thr; static int runTrampoline( void* data ); }; ./src/elements/swarmElement.cpp0000644000076600007660000000371710433400375016402 0ustar patpat00000000000000#include #include #include #include "../swarm/swarm.h" #include "../pipes/streamPipe.h" #include "streamElement.h" #include "swarmElement.h" SwarmElement::SwarmElement( StreamPipe* out, double linesPerSecond, unsigned int _lines, double _gain, bool _doAbs, unsigned int _Dims, unsigned int GnatCount, double accelFactor ) : StreamElement( 0, out ), Dims( _Dims ), lineTime( 1.0 / linesPerSecond ), lines( _lines ), gain( _gain / (double)( GnatCount + 1 ) ), doAbs( _doAbs ) { this->swarm = new Swarm( this->Dims, GnatCount, accelFactor ); this->coefs = new double[ this->Dims ]; this->outBuffer = new unsigned char[ this->Dims ]; } SwarmElement::~SwarmElement( void ) { delete[] this->outBuffer; delete[] this->coefs; delete this->swarm; } void SwarmElement::clearCoefs( void ) { for ( unsigned int ii=0; ii < this->Dims; ++ii ) { this->coefs[ ii ] = 0.0; } } void SwarmElement::incCoefs( const double* incs ) { for ( unsigned int ii=0; ii < this->Dims; ++ii ) { this->coefs[ ii ] += incs[ ii ]; } } void SwarmElement::emitCoefs( void ) { for ( unsigned int ii=0; ii < this->Dims; ++ii ) { int val = (int)( this->gain * this->coefs[ ii ] ); if ( this->doAbs ) { if ( val < 0 ) { val = -val; } } else if ( val < 0 ) { val = 0; } if ( val > 255 ) { val = 255; } this->outBuffer[ ii ] = (unsigned char)val; } this->out->write( this->outBuffer, this->Dims ); } int SwarmElement::run( void ) { unsigned int GnatCount = this->swarm->getGnatCount(); this->out->write( &this->Dims, sizeof( this->Dims ) ); for ( unsigned int ii=0; ( this->lines == 0 ) or ii < this->lines; ++ii ) { this->clearCoefs(); this->incCoefs( this->swarm->getWaspPosition() ); for ( unsigned int jj=0; jj < GnatCount; ++jj ) { this->incCoefs( this->swarm->getGnatPosition( jj ) ); } this->emitCoefs(); this->swarm->update( lineTime ); } return 0; } ./src/elements/swarmElement.h0000644000076600007660000000122010433400375016032 0ustar patpat00000000000000 class StreamPipe; class StreamElement; class Swarm; class SwarmElement : public StreamElement { public: SwarmElement( StreamPipe* out, double linesPerSecond = 32.0, unsigned int _lines = 0, double _gain = 10.0, bool _doAbs = false, unsigned int Dims = 32, unsigned int GnatCount = 7, double accelFactor = 1.0 ); ~SwarmElement( void ); int run( void ); private: void clearCoefs( void ); void incCoefs( const double* incs ); void emitCoefs( void ); unsigned int Dims; Swarm* swarm; double* coefs; unsigned char* outBuffer; double lineTime; unsigned int lines; double gain; bool doAbs; }; ./src/elements/tone.cpp0000644000076600007660000000705610433400375014704 0ustar patpat00000000000000 #include #include #include #include #include #include "../pipes/streamPipe.h" #include "streamElement.h" #include "tone.h" Tone::Tone( StreamPipe* in, StreamPipe* out, double _freq, double _linesPerSecond, double _gain, unsigned int _waveType, double gamma, double _minHz, double _maxHz ) : StreamElement( in, out ), freq( _freq ), linesPerSecond( _linesPerSecond ), gain( _gain ), waveType( _waveType ), minHz( _minHz ), maxHz( _maxHz ) { for ( unsigned int ii=0; ii < 256; ++ii ) { this->intensityMap[ ii ] = pow( (double)ii / 255.0, 1.0 / gamma ); } } Tone::~Tone( void ) { } static double triangleWave( double angle ) { double waveNumber; double proportion = modf( angle / ( 2.0 * M_PI ), &waveNumber ); if ( proportion < 0.5 ) { return -proportion * 4.0 + 1.0; } else { return proportion * 4.0 - 3.0; } } static double squareWave( double angle ) { double waveNumber; double proportion = modf( angle / ( 2.0 * M_PI ), &waveNumber ); if ( proportion < 0.5 ) { return 1.0; } else { return -1.0; } } static double sawtoothWave( double angle ) { double waveNumber; double proportion = modf( angle / ( 2.0 * M_PI ), &waveNumber ); return proportion * 2.0 - 1.0; } static double toothsawWave( double angle ) { double waveNumber; double proportion = modf( angle / ( 2.0 * M_PI ), &waveNumber ); return -proportion * 2.0 + 1.0; } int Tone::run( void ) { int rLen; unsigned int width; rLen = this->in->read( (unsigned char*)&width, sizeof( width ) ); if ( rLen not_eq sizeof( width ) ) { std::cerr << "Tone couldn't read width" << std::endl; return __LINE__; } double* hzTable = new double[ width ]; double logMinHz = log( this->minHz ); double logMaxHz = log( this->maxHz ); for ( unsigned int ii=0; ii < width; ++ii ) { double horz = (double) ii / (double)width; double logHz = logMinHz + horz * ( logMaxHz - logMinHz ); hzTable[ ii ] = exp( logHz ); } double realGain = gain / (double)width; unsigned char* buf[2]; buf[ 0 ] = new unsigned char[ width ]; buf[ 1 ] = new unsigned char[ width ]; double (*waveForm)( double angle ) = sin; switch ( this->waveType ) { case TRIANGLE: waveForm = triangleWave; break; case SQUARE: waveForm = squareWave; break; case SAWTOOTH: waveForm = sawtoothWave; break; case TOOTHSAW: waveForm = toothsawWave; break; } rLen = this->in->read( buf[ 0 ], width ); int previousRow = -1; unsigned int yy=0; while ( rLen == width ) { double vert = ( (double) yy * this->linesPerSecond ) / (double) this->freq; double realRow; double proportion = modf( vert, &realRow ); int otherRow = ( (int)realRow ) % 2; int row = ( otherRow + 1 ) % 2; if ( row not_eq previousRow ) { previousRow = row; rLen = this->in->read( buf[ row ], width ); if ( rLen not_eq width ) { break; } } unsigned char* aPtr = buf[ row ]; unsigned char* bPtr = buf[ otherRow ]; double angleFactor = (double) yy * 2.0 * M_PI / this->freq; double samp = 0.0; for ( unsigned int ii=0; ii < width; ++ii ) { double partA = this->intensityMap[ *aPtr++ ]; double partB = this->intensityMap[ *bPtr++ ]; double intensity = proportion * partA + ( 1.0 - proportion ) * partB; samp += intensity * (*waveForm)( hzTable[ ii ] * angleFactor ); } samp *= realGain; this->out->write( &samp, sizeof( samp ) ); ++yy; } delete[] buf[1]; delete[] buf[0]; delete[] hzTable; return 0; } ./src/elements/tone.h0000644000076600007660000000107510433400375014344 0ustar patpat00000000000000 class StreamPipe; class Tone : public StreamElement { public: enum { SINE, TRIANGLE, SQUARE, SAWTOOTH, TOOTHSAW }; Tone( StreamPipe* in, StreamPipe* out, double _freq, double _linesPerSecond = 64.0, double _gain = 1.0, unsigned int _waveType = SINE, double _gamma = 0.44, double _minHz = 128.0, double _maxHz = 4096.0 ); ~Tone( void ); protected: int run( void ); private: double freq; double linesPerSecond; double gain; unsigned int waveType; double minHz; double maxHz; double intensityMap[ 256 ]; }; ./src/pipes/0000755000076600007660000000000010433400375012527 5ustar patpat00000000000000./src/pipes/streamPipe.cpp0000644000076600007660000001543310433400375015352 0ustar patpat00000000000000 #include #include #include #ifdef TEST #include #endif /* TEST */ #include "streamPipe.h" StreamPipe::StreamPipe( unsigned int _maxBufLen ) : maxBufLen( _maxBufLen+1 ), curWriteIndex( 0 ), curReadIndex( 0 ), writeIsClosed( false ), readIsClosed( false ) { this->buffer = new unsigned char[ this->maxBufLen ]; this->mutex = ::SDL_CreateMutex(); this->writeBytesAvailable = ::SDL_CreateCond(); this->readBytesAvailable = ::SDL_CreateCond(); } StreamPipe::~StreamPipe( void ) { ::SDL_DestroyCond( this->readBytesAvailable ); ::SDL_DestroyCond( this->writeBytesAvailable ); ::SDL_DestroyMutex( this->mutex ); delete[] this->buffer; } int StreamPipe::writeBytesCount( void ) const { if ( this->readIsClosed || this->writeIsClosed ) { return -1; } else if ( this->curWriteIndex < this->curReadIndex ) { return this->curReadIndex - this->curWriteIndex - 1; } else { return this->maxBufLen - this->curWriteIndex + this->curReadIndex - 1; } } int StreamPipe::readBytesCount( void ) const { int count; if ( this->readIsClosed ) { count = -1; } else if ( this->curWriteIndex >= this->curReadIndex ) { count = this->curWriteIndex - this->curReadIndex; if ( count == 0 && this->writeIsClosed ) { count = -1; } } else { count = this->maxBufLen - this->curReadIndex + this->curWriteIndex; } return count; } int StreamPipe::write( const void* buf, unsigned int len ) { const unsigned char* bufPtr = (const unsigned char*)buf; int ret = 0; while ( len > 0 ) { int rawRet = this->rawWrite( bufPtr, len ); if ( rawRet <= 0 ) { break; } else { bufPtr = &bufPtr[ rawRet ]; ret += rawRet; len -= rawRet; } } return ret; } int StreamPipe::read( void* buf, unsigned int len ) { unsigned char* bufPtr = (unsigned char*)buf; int ret = 0; while ( len > 0 ) { int rawRet = this->rawRead( bufPtr, len ); if ( rawRet <= 0 ) { break; } else { bufPtr = &bufPtr[ rawRet ]; ret += rawRet; len -= rawRet; } } return ret; } void StreamPipe::writeClose( void ) { this->writeIsClosed = true; } void StreamPipe::readClose( void ) { this->readIsClosed = true; } int StreamPipe::rawWrite( const void* buf, unsigned int len ) { const unsigned char* bufPtr = (const unsigned char*)buf; ::SDL_LockMutex( this->mutex ); int wbCount; for (;;) { wbCount = this->writeBytesCount(); if ( wbCount == 0 ) { ::SDL_CondWait( this->writeBytesAvailable, this->mutex ); } else { break; } } if ( wbCount < 0 ) { return wbCount; } else if ( wbCount < len ) { len = (unsigned int)wbCount; } if ( this->curWriteIndex + len <= this->maxBufLen ) { ::memcpy( &this->buffer[ this->curWriteIndex ], &bufPtr[ 0 ], len ); this->curWriteIndex += len; if ( this->curWriteIndex == this->maxBufLen ) { this->curWriteIndex = 0; } } else { unsigned int endLen = this->maxBufLen - this->curWriteIndex; ::memcpy( &this->buffer[ this->curWriteIndex ], &bufPtr[ 0 ], endLen ); ::memcpy( &this->buffer[ 0 ], &bufPtr[ endLen ], len - endLen ); this->curWriteIndex = len - endLen; } ::SDL_CondSignal( this->readBytesAvailable ); ::SDL_UnlockMutex( this->mutex ); return (int)len; } int StreamPipe::rawRead( void* buf, unsigned int len ) { unsigned char* bufPtr = (unsigned char*)buf; ::SDL_LockMutex( this->mutex ); int rbCount; for (;;) { rbCount = this->readBytesCount(); if ( rbCount == 0 ) { ::SDL_CondWait( this->readBytesAvailable, this->mutex ); } else { break; } } if ( rbCount < 0 ) { return rbCount; } else if ( rbCount < len ) { len = (unsigned int)rbCount; } if ( this->curReadIndex + len <= this->maxBufLen ) { ::memcpy( &bufPtr[ 0 ], &this->buffer[ this->curReadIndex ], len ); this->curReadIndex += len; if ( this->curReadIndex == this->maxBufLen ) { this->curReadIndex = 0; } } else { unsigned int endLen = this->maxBufLen - this->curReadIndex; ::memcpy( &bufPtr[ 0 ], &this->buffer[ this->curReadIndex ], endLen ); ::memcpy( &bufPtr[ endLen ], &this->buffer[ 0 ], len - endLen ); this->curReadIndex = len - endLen; } ::SDL_CondSignal( this->writeBytesAvailable ); ::SDL_UnlockMutex( this->mutex ); return (int)len; } #ifdef TEST typedef struct { StreamPipe* pipe; unsigned int writeDelay; unsigned int readDelay; unsigned int writeLen; unsigned int readLen; } MyThreadArgs; static int writerFunc( void* data ) { MyThreadArgs* args = (MyThreadArgs*)data; unsigned int num = 0; for ( unsigned int ii=0; ii < 10; ++ii ) { if ( args->writeDelay not_eq 0 ) { ::SDL_Delay( args->writeDelay ); } unsigned char buf[ 64 ]; for ( unsigned int jj=0; jj < args->writeLen; ++jj ) { buf[ jj ] = num++; } int len = args->pipe->write( buf, args->writeLen ); } args->pipe->writeClose(); return 0; } static int readerFunc( void* data ) { bool ret = true; MyThreadArgs* args = (MyThreadArgs*)data; unsigned int nextExpected = 0; for (;;) { if ( args->readDelay not_eq 0 ) { ::SDL_Delay( args->readDelay ); } unsigned char buf[ 64 ]; int len = args->pipe->read( buf, args->readLen ); if ( len < 0 ) { ret = false; } else if ( len == 0 ) { if ( nextExpected not_eq args->writeLen * 10 ) { std::cerr << "Didn't make it: " << nextExpected << std::endl; ret = false; } args->pipe->readClose(); return ( ret ) ? 0 : 1; } else { for ( unsigned int ii=0; ii < len; ++ii ) { if ( buf[ ii ] not_eq nextExpected++ ) { ret = false; } } } } } static int runTest( unsigned int writeDelay, unsigned int readDelay, unsigned int writeLen, unsigned int readLen ) { MyThreadArgs args; StreamPipe pipe( 20 ); args.pipe = &pipe; args.writeDelay = writeDelay; args.readDelay = readDelay; args.writeLen = writeLen; args.readLen = readLen; SDL_Thread* reader = ::SDL_CreateThread( readerFunc, &args ); SDL_Thread* writer = ::SDL_CreateThread( writerFunc, &args ); int writeStatus; int readStatus; ::SDL_WaitThread( writer, &writeStatus ); ::SDL_WaitThread( reader, &readStatus ); return writeStatus | readStatus; } int StreamPipe::test( void ) { int ret; ret = runTest( 250U, 0U, 10, 10 ); if ( ret != 0 ) { return __LINE__; } ret = runTest( 250U, 0U, 1, 1 ); if ( ret != 0 ) { return __LINE__; } ret = runTest( 250U, 0U, 12, 7 ); if ( ret != 0 ) { return __LINE__; } ret = runTest( 0U, 250U, 7, 12 ); if ( ret != 0 ) { return __LINE__; } ret = runTest( 0U, 250U, 24, 24 ); if ( ret != 0 ) { return __LINE__; } return 0; } #endif /* TEST */ ./src/pipes/streamPipe.h0000644000076600007660000000137310433400375015015 0ustar patpat00000000000000 class StreamPipe { public: StreamPipe( unsigned int _maxBufLen = 8192U ); ~StreamPipe( void ); int write( const void* src, unsigned int len ); int read( void* src, unsigned int len ); int rawWrite( const void* src, unsigned int len ); int rawRead( void* src, unsigned int len ); void writeClose( void ); void readClose( void ); #ifdef TEST static int test( void ); #endif private: int writeBytesCount( void ) const; int readBytesCount( void ) const; unsigned char* buffer; unsigned int maxBufLen; unsigned int curWriteIndex; unsigned int curReadIndex; SDL_mutex* mutex; SDL_cond* writeBytesAvailable; SDL_cond* readBytesAvailable; bool writeIsClosed; bool readIsClosed; }; ./src/platform_macosx/0000755000076600007660000000000010433400375014605 5ustar patpat00000000000000./src/platform_macosx/Makefile0000644000076600007660000000060710433400375016250 0ustar patpat00000000000000 # # Utilities and their options # CXX := c++ -pipe CC := cc -pipe OCC := cc -pipe AR := ar -cr RANLIB := ranlib CXXDEP := -M CCDEP := -M OCCDEP := -M OPTIMIZE_FLAG := -O DEBUG_FLAG := -g CPP_PLATFORM := LD_PLATFORM := -arch ppc # # Options needed for various packages # CPP_SDL := $(shell sdl-config --cflags) LD_SDL := $(shell sdl-config --libs) # # Platform-specific objects # ./src/soundDev/0000755000076600007660000000000010433400375013176 5ustar patpat00000000000000./src/soundDev/soundDev.cpp0000644000076600007660000000544710433400375015503 0ustar patpat00000000000000 #include #include #include #include "../pipes/streamPipe.h" #include "../elements/streamElement.h" #include "soundDev.h" SoundDev::SoundDev( StreamPipe* in, unsigned int freq, unsigned int channels, unsigned int samples, double _gain ) : StreamElement( in, 0 ), gain( _gain ), isFinished( false ) { SDL_AudioSpec desired; desired.freq = freq; desired.format = AUDIO_S16SYS; desired.channels = channels; desired.samples = samples; desired.callback = SoundDev::callbackTrampoline; desired.userdata = this; if ( ::SDL_OpenAudio( &desired, &this->obtained ) < 0 ) { std::cerr << "Couldn't open Audio: " << ::SDL_GetError() << std::endl; this->gotAudio = false; this->obtained.samples = 0; this->inBuf = 0; } else { this->gotAudio = true; this->inBuf = new double[ this->obtained.samples ]; } this->mutex = ::SDL_CreateMutex(); this->finishedCond = ::SDL_CreateCond(); } SoundDev::~SoundDev( void ) { delete[] this->inBuf; if ( this->gotAudio ) { ::SDL_PauseAudio( 1 ); ::SDL_CloseAudio(); } ::SDL_DestroyCond( this->finishedCond ); ::SDL_DestroyMutex( this->mutex ); } void SoundDev::finish( void ) { ::SDL_LockMutex( this->mutex ); if ( not this->isFinished ) { ::SDL_CondWait( this->finishedCond, this->mutex ); } ::SDL_UnlockMutex( this->mutex ); } void SoundDev::callback( Uint8* buf, unsigned int len ) { int rLen = this->obtained.samples; len /= sizeof( Sint16 ); if ( rLen >= len ) { rLen = len; } rLen *= sizeof( this->inBuf[ 0 ] ); ::SDL_LockMutex( this->mutex ); if ( this->in not_eq 0 ) { rLen = this->in->read( (unsigned char*)this->inBuf, rLen ); if ( rLen <= 0 ) { this->isFinished = true; this->in->readClose(); ::SDL_CondBroadcast( this->finishedCond ); ::SDL_PauseAudio( 1 ); } else { rLen /= sizeof( this->inBuf[ 0 ] ); } } else { rLen = 0; } double* inPtr = this->inBuf; Sint16* ptr = (Sint16*)buf; for ( unsigned int ii=0; ii < rLen; ++ii ) { int iVal = (int)( *inPtr++ * this->gain * 32767.0 ); if ( iVal < -32768 ) { iVal = -32768; } else if ( iVal > 32767 ) { iVal = 32767; } *ptr++ = iVal; } ::SDL_UnlockMutex( this->mutex ); } unsigned int SoundDev::getFreq( void ) const { unsigned int ret = 0; ::SDL_LockMutex( this->mutex ); if ( this->gotAudio ) { ret = this->obtained.freq; } ::SDL_UnlockMutex( this->mutex ); return ret; } unsigned int SoundDev::getChannels( void ) const { unsigned int ret = 0; ::SDL_LockMutex( this->mutex ); if ( this->gotAudio ) { return this->obtained.channels; } ::SDL_UnlockMutex( this->mutex ); return ret; } int SoundDev::run( void ) { ::SDL_PauseAudio( 0 ); this->finish(); } ./src/soundDev/soundDev.h0000644000076600007660000000140310433400375015134 0ustar patpat00000000000000 class StreamPipe; class SoundDev : public StreamElement { public: SoundDev( StreamPipe* in, unsigned int freq = 8192U, unsigned int channels = 1U, unsigned int samples = 8192U, double _gain = 1.0 ); ~SoundDev( void ); unsigned int getFreq( void ) const; unsigned int getChannels( void ) const; void finish( void ); inline static void callbackTrampoline( void* userData, Uint8* stream, int len ) { SoundDev* dev = (SoundDev*)userData; dev->callback( stream, len ); }; protected: int run( void ); private: void callback( Uint8* stream, unsigned int len ); SDL_AudioSpec obtained; bool gotAudio; double* inBuf; double gain; SDL_mutex* mutex; SDL_cond* finishedCond; bool isFinished; }; ./src/swarm/0000755000076600007660000000000010433400375012540 5ustar patpat00000000000000./src/swarm/swarm.cpp0000644000076600007660000001012110433400375014370 0ustar patpat00000000000000 #include #include #include #include #include extern "C" double drand48( void ); #include "swarm.h" class Bug { public: Bug( bool _randomize = true ); virtual ~Bug( void ); void init( unsigned int _Dims, double mv, double ma, double af=1.0 ); inline const double* getPosition( void ) const { return pos; } virtual void update( double elapsed, const double* target ); protected: bool randomize; unsigned int Dims; double* pos; double* vel; double* acc; double maxVelocity; double maxAcceleration; double accelFactor; }; Bug::Bug( bool _randomize ) : randomize( _randomize ), pos( 0 ), vel( 0 ), acc( 0 ) { } Bug::~Bug( void ) { delete[] this->acc; delete[] this->vel; delete[] this->pos; } void Bug::init( unsigned int _Dims, double mv, double ma, double af ) { this->Dims = _Dims; this->maxVelocity = mv; this->maxAcceleration = ma; this->accelFactor = af; this->pos = new double[ Dims ]; this->vel = new double[ Dims ]; this->acc = new double[ Dims ]; for ( unsigned int ii=0; ii < Dims; ++ii ) { this->pos[ ii ] = Swarm::randomCoord(); this->vel[ ii ] = Swarm::randomVelocity(); this->acc[ ii ] = Swarm::randomAcceleration(); } } void Bug::update( double elapsed, const double* target ) { double mag = 0.0; for ( unsigned int ii=0; ii < this->Dims; ++ii ) { this->vel[ ii ] += this->acc[ ii ] * elapsed; mag += this->vel[ ii ] * this->vel[ ii ]; } if ( mag > this->maxVelocity * this->maxVelocity ) { double factor = this->maxVelocity / sqrt( mag ); for ( unsigned int ii=0; ii < this->Dims; ++ii ) { this->vel[ ii ] *= factor; } } for ( unsigned int ii=0; ii < this->Dims; ++ii ) { this->pos[ ii ] += this->vel[ ii ] * elapsed; } mag = 0.0; for ( unsigned int ii=0; ii < this->Dims; ++ii ) { this->acc[ ii ] = this->accelFactor * ( target[ ii ]-this->pos[ ii ] ); if ( this->randomize ) { this->acc[ ii ] *= Swarm::drand(); } mag += this->acc[ ii ] * this->acc[ ii ]; } if ( mag > this->maxAcceleration * this->maxAcceleration ) { double factor = this->maxAcceleration / sqrt( mag ); for ( unsigned int ii=0; ii < this->Dims; ++ii ) { this->acc[ ii ] *= factor; } } } Swarm::Swarm( unsigned int _Dims, unsigned int _GnatCount, double duration ) : Dims( _Dims ), GnatCount( _GnatCount ), PointDuration( duration ) { this->wasp = new Bug( false ); this->wasp->init( this->Dims, 30.0, 10.0, 1.0 ); this->gnats = new Bug[ this->GnatCount ]; for ( unsigned int ii=0; ii < this->GnatCount; ++ii ) { this->gnats[ ii ].init( this->Dims, 29.0 + randomVelocity(), 30.0 + randomAcceleration(), 1.5 ); } this->target = new double[ this->Dims ]; this->timeUntilNextTarget = -2.0; } Swarm::~Swarm( void ) { delete[] target; delete[] gnats; delete wasp; } const double* Swarm::getWaspPosition( void ) const { return this->wasp->getPosition(); } const double* Swarm::getGnatPosition( unsigned int index ) const { return this->gnats[ index ].getPosition(); } void Swarm::update( double elapsed ) { const double* waspPosition = this->wasp->getPosition(); for ( unsigned int ii=0; ii < this->GnatCount; ++ii ) { this->gnats[ ii ].update( elapsed, waspPosition ); } double mag = 0.0; for ( unsigned int ii=0; ii < this->Dims; ++ii ) { double dd = waspPosition[ ii ] - this->target[ ii ]; mag += dd * dd; } this->timeUntilNextTarget -= elapsed; if ( mag < 100.0 or this->timeUntilNextTarget < 0.0 ) { for ( unsigned int ii=0; ii < this->Dims; ++ii ) { this->target[ ii ] = Swarm::randomCoord() / 2.0; } this->timeUntilNextTarget = this->PointDuration; } this->wasp->update( elapsed, this->target ); } double Swarm::drand( void ) { return ::drand48(); } double Swarm::randomCoord( void ) { return Swarm::drand() * 15.0 - 7.5; } double Swarm::randomVelocity( void ) { return Swarm::drand() * 6.0 - 3.0; } double Swarm::randomAcceleration( void ) { return Swarm::drand() * 3.0 - 1.5; } ./src/swarm/swarm.h0000644000076600007660000000157410433400375014051 0ustar patpat00000000000000 class Bug; class Swarm { public: Swarm( unsigned int _Dims = 32, unsigned int _Gnats = 7, double duration = 1.5 ); ~Swarm( void ); inline unsigned int getDims( void ) const { return this->Dims; }; inline unsigned int getGnatCount( void ) const { return this->GnatCount; }; inline const double* getTargetPos( void ) const { return this->target; }; const double* getWaspPosition( void ) const; const double* getGnatPosition( unsigned int index ) const; void update( double elapsed ); static double drand( void ); static double randomCoord( void ); static double randomVelocity( void ); static double randomAcceleration( void ); private: bool done; unsigned int Dims; unsigned int GnatCount; double PointDuration; Bug* wasp; Bug* gnats; double* target; double timeUntilNextTarget; }; ./src/swarm.cpp0000644000076600007660000000274410433400375013253 0ustar patpat00000000000000 #include #include #include #include #include #include #include "pipes/streamPipe.h" #include "elements/streamElement.h" #include "elements/swarmElement.h" #include "elements/tone.h" #include "soundDev/soundDev.h" #ifdef main #undef main #endif int main( int argc, char* argv[] ) { unsigned int initFlags = 0U; ::srand48( ::time( 0 ) ); initFlags |= SDL_INIT_AUDIO; if ( ::SDL_Init( initFlags ) < 0 ) { std::cerr << "Couldn't init SDL: " << ::SDL_GetError() << std::endl; return __LINE__; } StreamPipe pB( 8192U * 7U * sizeof( double ) ); StreamPipe pA( 32U * 128U * 3U * sizeof( unsigned char ) ); SoundDev dev( &pB, // input 8192U, // frequency 1U, // channels 2U * 8192U, // samples in the buffer 2.0 // gain ); Tone tone( &pA, &pB, // input, output dev.getFreq(), // frequency 10.0, // linesPerSecond 1.0, // gain Tone::SINE, // wave form 0.44, // gamma 128.0,//128.0, // minHz 1024.0//2048.0 // maxHz ); SwarmElement swarm( &pA, // input 10.0, //128.0, // lines per second 0, // total lines 10.0, // gain false, // doAbs 32, //4, // dimensions 20,//7, // gnats 1.5//1.0 // accelFactor ); swarm.startThread(); tone.startThread(); dev.startThread(); // XXX could do other stuff here.... dev.finish(); dev.waitForThread(); tone.waitForThread(); swarm.waitForThread(); ::SDL_Quit(); return 0; }