From 03c938b453b48680ee6dd837bc44bb86cbbfb37c Mon Sep 17 00:00:00 2001 From: cnlohr Date: Sat, 2 May 2020 20:47:09 -0700 Subject: [PATCH] Forgot to add some files that were used a while ago. --- colorchord2/esp32shirt.conf | 36 ++++++ colorchord2/sound_android.c | 212 ++++++++++++++++++++++++++++++++++++ 2 files changed, 248 insertions(+) create mode 100644 colorchord2/esp32shirt.conf create mode 100644 colorchord2/sound_android.c diff --git a/colorchord2/esp32shirt.conf b/colorchord2/esp32shirt.conf new file mode 100644 index 0000000..dd6001c --- /dev/null +++ b/colorchord2/esp32shirt.conf @@ -0,0 +1,36 @@ +outdrivers = DisplayArray,DisplayNetwork,OutputCells +#OutputVoronoi +leds = 199 +light_siding = 1.0 #Turn this to ~1.9 for more uniformity, ~1.0 for less. +satamp = 1.600 +is_loop=0 +led_floor = .1 #Turn to .25 for more uniformity, .1 for less. +#note_attach_amp_iir = .3 #.3000 +#note_attach_amp_iir2 = .15 #.1500 +#note_attach_freq_iir = .3 #0.3000 +steady_bright = 0 +#dft_iir = 0.0 +#dft_q = 20.0000 +#dft_speedup = 1000.0000 + +sourcename = default +# alsa_output.pci-0000_01_00.1.hdmi-stereo.monitor +# alsa_output.pci-0000_01_00.1.hdmi-stereo-extra1.monitor +#alsa_output.pci-0000_00_1f.3.analog-stereo.monitor +skipfirst = 0 +firstval = 0 +port = 7000 +address = 192.168.43.179 +#address = 192.168.0.245 + +slope=.10 +amplify=.9 + +headless = 00 +zigzag = 0 +lightx = 13 +lighty = 19 +qtyamp = 50 +timebased = 1 +snakey = 0 + diff --git a/colorchord2/sound_android.c b/colorchord2/sound_android.c new file mode 100644 index 0000000..36a6a4e --- /dev/null +++ b/colorchord2/sound_android.c @@ -0,0 +1,212 @@ +//Copyright 2019 <>< Charles Lohr under the ColorChord License. +// NOTE: this does not actually work!!! This driver needs more work!!! It is currently under work. + +#include "sound.h" +#include "os_generic.h" +#include "parameters.h" +#include //Using android threads not os_generic threads. +#include +#include +#include +#include + +//based on https://github.com/android/ndk-samples/blob/master/native-audio/app/src/main/cpp/native-audio-jni.c + +// for native audio +#include +#include + +#define RECORDER_FRAMES 1024 + +#define BUFFERSETS 4 + +#define BLOCKING + +//Across all sound systems. +static pthread_mutex_t audioEngineLock = PTHREAD_MUTEX_INITIALIZER; + +struct SoundDriverAndroid +{ + void (*CloseFn)( struct SoundDriverAndroid * object ); + int (*SoundStateFn)( struct SoundDriverAndroid * object ); + SoundCBType callback; + SLObjectItf engineObject; + SLEngineItf engineEngine; + SLRecordItf recorderRecord; + SLObjectItf recorderObject; + SLAndroidSimpleBufferQueueItf recorderBufferQueue; + unsigned recorderSize; + + short recorderBuffer[RECORDER_FRAMES]; +}; + + +void bqRecorderCallback(SLAndroidSimpleBufferQueueItf bq, void *context) +{ + struct SoundDriverAndroid * r = (struct SoundDriverAndroid*)context; + // for streaming recording, here we would call Enqueue to give recorder the next buffer to fill + // but instead, this is a one-time buffer so we stop recording + SLresult result; + result = (*r->recorderRecord)->SetRecordState(r->recorderRecord, SL_RECORDSTATE_STOPPED); + if (SL_RESULT_SUCCESS == result) { + r->recorderSize = 128 * sizeof(short); + } + pthread_mutex_unlock(&audioEngineLock); +} + +static struct SoundDriverAndroid* InitAndroidSound( struct SoundDriverAndroid * r ) +{ + SLresult result; + + // create engine + result = slCreateEngine(&r->engineObject, 0, NULL, 0, NULL, NULL); + assert(SL_RESULT_SUCCESS == result); + (void)result; + + // realize the engine + result = (*r->engineObject)->Realize(r->engineObject, SL_BOOLEAN_FALSE); + assert(SL_RESULT_SUCCESS == result); + (void)result; + + // get the engine interface, which is needed in order to create other objects + result = (*r->engineObject)->GetInterface(r->engineObject, SL_IID_ENGINE, &r->engineEngine); + assert(SL_RESULT_SUCCESS == result); + (void)result; + + + /////////////////////////////////////////////////////////////////////////////////////////////////////// + + + // configure audio source + SLDataLocator_IODevice loc_dev = {SL_DATALOCATOR_IODEVICE, SL_IODEVICE_AUDIOINPUT, + SL_DEFAULTDEVICEID_AUDIOINPUT, NULL}; + SLDataSource audioSrc = {&loc_dev, NULL}; + + // configure audio sink + SLDataLocator_AndroidSimpleBufferQueue loc_bq = {SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE, 2}; + SLDataFormat_PCM format_pcm = {SL_DATAFORMAT_PCM, 1, SL_SAMPLINGRATE_16, + SL_PCMSAMPLEFORMAT_FIXED_16, SL_PCMSAMPLEFORMAT_FIXED_16, + SL_SPEAKER_FRONT_CENTER, SL_BYTEORDER_LITTLEENDIAN}; + SLDataSink audioSnk = {&loc_bq, &format_pcm}; + + // create audio recorder + // (requires the RECORD_AUDIO permission) + const SLInterfaceID id[1] = {SL_IID_ANDROIDSIMPLEBUFFERQUEUE}; + const SLboolean req[1] = {SL_BOOLEAN_TRUE}; + result = (*r->engineEngine)->CreateAudioRecorder(r->engineEngine, &r->recorderObject, &audioSrc, + &audioSnk, 1, id, req); + if (SL_RESULT_SUCCESS != result) { + printf( "CreateAudioRecorder failed\n" ); + return JNI_FALSE; + } + + // realize the audio recorder + result = (*r->recorderObject)->Realize(r->recorderObject, SL_BOOLEAN_FALSE); + if (SL_RESULT_SUCCESS != result) { + printf( "AudioRecorder Realize failed\n" ); + return JNI_FALSE; + } + + // get the record interface + result = (*r->recorderObject)->GetInterface(r->recorderObject, SL_IID_RECORD, &r->recorderRecord); + assert(SL_RESULT_SUCCESS == result); + (void)result; + + // get the buffer queue interface + result = (*r->recorderObject)->GetInterface(r->recorderObject, SL_IID_ANDROIDSIMPLEBUFFERQUEUE, + &r->recorderBufferQueue); + assert(SL_RESULT_SUCCESS == result); + (void)result; + + // register callback on the buffer queue + result = (*r->recorderBufferQueue)->RegisterCallback(r->recorderBufferQueue, bqRecorderCallback, + NULL); + assert(SL_RESULT_SUCCESS == result); + (void)result; + + + assert( !pthread_mutex_trylock(&audioEngineLock)); + // in case already recording, stop recording and clear buffer queue + result = (*r->recorderRecord)->SetRecordState(r->recorderRecord, SL_RECORDSTATE_STOPPED); + assert(SL_RESULT_SUCCESS == result); + (void)result; + result = (*r->recorderBufferQueue)->Clear(r->recorderBufferQueue); + assert(SL_RESULT_SUCCESS == result); + (void)result; + + // the buffer is not valid for playback yet + r->recorderSize = 0; + + // enqueue an empty buffer to be filled by the recorder + // (for streaming recording, we would enqueue at least 2 empty buffers to start things off) + result = (*r->recorderBufferQueue)->Enqueue(r->recorderBufferQueue, r->recorderBuffer, + RECORDER_FRAMES * sizeof(short)); + // the most likely other result is SL_RESULT_BUFFER_INSUFFICIENT, + // which for this code example would indicate a programming error + assert(SL_RESULT_SUCCESS == result); + (void)result; + + // start recording + result = (*r->recorderRecord)->SetRecordState(r->recorderRecord, SL_RECORDSTATE_RECORDING); + assert(SL_RESULT_SUCCESS == result); + (void)result; + + printf( "Complete Init Sound Android\n" ); + return 0; +} + +void CloseSoundAndroid( struct SoundDriverAndroid * r ); + +int SoundStateAndroid( struct SoundDriverAndroid * soundobject ) +{ + return ((soundobject->recorderObject)?1:0) | ((soundobject->recorderObject)?2:0); +} + +void CloseSoundAndroid( struct SoundDriverAndroid * r ) +{ + // destroy audio recorder object, and invalidate all associated interfaces + if (r->recorderObject != NULL) { + (*r->recorderObject)->Destroy(r->recorderObject); + r->recorderObject = NULL; + r->recorderRecord = NULL; + r->recorderBufferQueue = NULL; + } + + + // destroy engine object, and invalidate all associated interfaces + if (r->engineObject != NULL) { + (*r->engineObject)->Destroy(r->engineObject); + r->engineObject = NULL; + r->engineEngine = NULL; + } + +} + +void * InitSoundAndroid( SoundCBType cb ) +{ + printf( "InitSoundAndroid\n" ); + struct SoundDriverAndroid * r = (struct SoundDriverAndroid *)malloc( sizeof( struct SoundDriverAndroid ) ); + memset( r, 0, sizeof( *r) ); + r->CloseFn = CloseSoundAndroid; + r->SoundStateFn = SoundStateAndroid; + r->callback = cb; + r->engineObject = 0; + r->engineEngine = 0; +/* + r->spsPlay = GetParameterI( "samplerate", 44100 ); + r->channelsPlay = GetParameterI( "channels", 2 ); + r->spsRec = r->spsPlay; + r->channelsRec = r->channelsPlay; + + r->playback_handle = 0; + r->record_handle = 0; + r->buffer = GetParameterI( "buffer", 1024 ); + + r->Android_fmt_s16le = 0; + +*/ + return InitAndroidSound(r); +} + +REGISTER_SOUND( AndroidSound, 10, "ANDROID", InitSoundAndroid ); +