Make Js callback synchronous with PortAudio callback

This greatly reduces to memory operations, and negates the need for a mutex. It will eliminate the need for extra, complicated, code to implement paFramesPerBufferUnspecified.

examples/pa_api_callback_sine.js

@@ -87,9 +87,9 @@ function callbackSine () {
   // log what we're doing
   console.log(`Play for ${numSeconds} seconds.\n`)
   // stop stream when timeout fires
-  //setTimeout(() => {
-    //JsAudio.closeStream(stream)             
-  //}, numSeconds * 1000)
+  setTimeout(() => {
+    JsAudio.closeStream(stream)             
+  }, numSeconds * 1000)
 }
 
 // Run it

src/callback.cc

@@ -15,40 +15,16 @@ JsPaStreamCallbackBridge::JsPaStreamCallbackBridge(Callback *callback_,
     , UVCallback
   );
   async->data = this;
-  uv_mutex_init(&async_lock);
+  uv_barrier_init(&async_barrier, 2);
 
   // Save userData to persistent object
   SaveToPersistent(ToLocString("userData"), userData);
 }
 
 JsPaStreamCallbackBridge::~JsPaStreamCallbackBridge() {
-  uv_mutex_destroy(&async_lock);
+  uv_barrier_destroy(&async_barrier);
   uv_close((uv_handle_t*)async, NULL);
 
-  //free buffer memory
-  if(m_inputBuffer != nullptr)
-      free(m_inputBuffer);
-  if(m_outputBuffer != nullptr)
-      free(m_outputBuffer);
-}
-
-int JsPaStreamCallbackBridge::sendToCallback(const void* input, unsigned long frameCount) {
-  uv_mutex_lock(&async_lock);
-    m_frameCount = frameCount;
-
-    if(m_inputBuffer != nullptr)
-      free(m_inputBuffer);
-    m_inputBuffer = malloc(sizeof(float) * frameCount * 2);
-
-    memmove(
-      m_inputBuffer,
-      input,
-      m_bytesPerFrameIn * frameCount
-    );
-  uv_mutex_unlock(&async_lock);
-
-  uv_async_send(async);
-  return 0;
 }
 
 void JsPaStreamCallbackBridge::dispatchJSCallback() {
@@ -58,74 +34,47 @@ void JsPaStreamCallbackBridge::dispatchJSCallback() {
   v8::Local<v8::ArrayBuffer> output;
   v8::Local<v8::Value> callbackReturn;
 
-  uv_mutex_lock(&async_lock);
-
-    frameCount = m_frameCount;
-
-    // Setup ArrayBuffer for input audio data
-    input = v8::ArrayBuffer::New(
-      v8::Isolate::GetCurrent(),
-      m_bytesPerFrameIn * frameCount
-    );
-    // Copy input audio data from bridge buffer to ArrayBuffer
-    memmove(
-      input->GetContents().Data(),
-      m_inputBuffer,
-      input->ByteLength()
-    );
 
-    // Setup ArrayBuffer for output audio data
-    output = v8::ArrayBuffer::New(
-      v8::Isolate::GetCurrent(),
-      m_bytesPerFrameOut * frameCount
-    );
-
-    // Create array of arguments and call the javascript callback
-    LocalValue argv[] = {
-      input,
-      output,
-      New<Number>(frameCount),
-      GetFromPersistent(ToLocString("userData"))
-    };
-    callbackReturn = callback->Call(4, argv);
-
-    if(m_outputBuffer != nullptr)
-      free(m_outputBuffer);
-    m_outputBuffer = malloc(output->ByteLength());
-    // Copy output audio data from bridge buffer to ArrayBuffer
-    memmove(
-      m_outputBuffer,
-      output->GetContents().Data(),
-      output->ByteLength()
-    );
-
-    // Store the return result of the javascript callback 
-    // so it be sent to the PaStreamCallback function
-    m_callbackResult = LocalizeInt(callbackReturn);
-
-  uv_mutex_unlock(&async_lock);
+  frameCount = m_frameCount;
+
+  // Setup ArrayBuffer for input audio data
+  input = v8::ArrayBuffer::New(
+    v8::Isolate::GetCurrent(),
+    const_cast<void*>(m_inputBuffer),
+    m_bytesPerFrameIn * frameCount
+  );
+
+  // Setup ArrayBuffer for output audio data
+  output = v8::ArrayBuffer::New(
+    v8::Isolate::GetCurrent(),
+    m_outputBuffer,
+    m_bytesPerFrameOut * frameCount
+  );
+
+  // Create array of arguments and call the javascript callback
+  LocalValue argv[] = {
+    input,
+    output,
+    New<Number>(frameCount),
+    GetFromPersistent(ToLocString("userData"))
+  };
+  m_callbackResult = LocalizeInt(callback->Call(4, argv));
 
+  uv_barrier_wait(&async_barrier);
 }
+
+int JsPaStreamCallbackBridge::Execute(const void* input, void* output, unsigned long frameCount) {
+  m_frameCount = frameCount;
+
+  m_inputBuffer = input;
+  m_outputBuffer = output;
+
+  // Dispatch the asyncronous callback
+  uv_async_send(async);
 
-void JsPaStreamCallbackBridge::consumeAudioData(void* output, unsigned long frameCount) {
+  // Wait for the asyncronous callback
+  uv_barrier_wait(&async_barrier);
 
-  if(m_outputBuffer != nullptr) {
-    memmove(
-      output,
-      m_outputBuffer,
-      m_bytesPerFrameOut * frameCount
-    );
-
-    // Free the output buffer and set it to nullptr to prevent it from sending the same output data twice
-    free(m_outputBuffer);
-    m_outputBuffer = nullptr;
-  }
+  return m_callbackResult;
 }
 
-int JsPaStreamCallbackBridge::getCallbackResult() {
-  int ret;
-  uv_mutex_lock(&async_lock);
-    ret = m_callbackResult;
-  uv_mutex_unlock(&async_lock);
-  return ret;
-}

src/callback.h

@@ -15,11 +15,8 @@ class JsPaStreamCallbackBridge : public AsyncWorker {
 
   ~JsPaStreamCallbackBridge();
 
-  int sendToCallback(const void* input, unsigned long frameCount);
-  void dispatchJSCallback(); 
-  void consumeAudioData(void* output, unsigned long frameCount);
-  int getCallbackResult();
-
+  void dispatchJSCallback();
+  int Execute(const void* input, void* output, unsigned long frameCount);
 
 private:
   NAN_INLINE static NAUV_WORK_CB(UVCallback) {
@@ -31,11 +28,11 @@ class JsPaStreamCallbackBridge : public AsyncWorker {
   void Execute() {}
 
   uv_async_t *async;
-  uv_mutex_t async_lock;
+  uv_barrier_t async_barrier;
   unsigned long m_frameCount;
   size_t m_bytesPerFrameIn;
   size_t m_bytesPerFrameOut;
-  void* m_inputBuffer;
+  const void* m_inputBuffer;
   void* m_outputBuffer;
   int m_callbackResult;
 

src/jsaudio.cc

@@ -181,10 +181,8 @@ static int StreamCallbackDispatcher (
 ) {
   JsPaStreamCallbackBridge* bridge = static_cast<JsPaStreamCallbackBridge*>(userData);
 
-  bridge->sendToCallback(input, frameCount);
-  bridge->consumeAudioData(output, frameCount);
-
-  return bridge->getCallbackResult();
+  // Call Js callback
+  return bridge->Execute(input, output, frameCount);
 }
 
 void StreamFinishedCallback (void* userData) {