react-native-audio-api 0.2.0 → 0.3.0-rc1

package/common/cpp/utils/JsiPromise.cpp

@@ -0,0 +1,59 @@
+#include "JsiPromise.h"
+
+#include <jsi/jsi.h>
+#include <ReactCommon/CallInvoker.h>
+#include <functional>
+
+namespace JsiPromise {
+
+using namespace facebook;
+
+jsi::Value PromiseVendor::createPromise(std::function<void(std::shared_ptr<Promise>)> func) {
+  if (_runtime == nullptr) {
+    throw new std::runtime_error("Runtime was null!");
+  }
+  auto& runtime = *_runtime;
+  auto callInvoker = _callInvoker;
+
+  // get Promise constructor
+  auto promiseCtor = runtime.global().getPropertyAsFunction(runtime, "Promise");
+
+  // create a "run" function (first Promise arg)
+  auto runPromise = jsi::Function::createFromHostFunction(runtime,
+                                                          jsi::PropNameID::forUtf8(runtime, "runPromise"),
+                                                          2,
+                                                          [callInvoker, func](jsi::Runtime& runtime,
+                                                                              const jsi::Value& thisValue,
+                                                                              const jsi::Value* arguments,
+                                                                              size_t count) -> jsi::Value {
+    auto resolveLocal = arguments[0].asObject(runtime).asFunction(runtime);
+    auto resolve = std::make_shared<jsi::Function>(std::move(resolveLocal));
+    auto rejectLocal = arguments[1].asObject(runtime).asFunction(runtime);
+    auto reject = std::make_shared<jsi::Function>(std::move(rejectLocal));
+
+    auto resolveWrapper = [resolve, &runtime, callInvoker](jsi::Value value) -> void {
+      auto valueShared = std::make_shared<jsi::Value>(std::move(value));
+      callInvoker->invokeAsync([resolve, &runtime, valueShared]() -> void {
+        resolve->call(runtime, *valueShared);
+      });
+    };
+
+    auto rejectWrapper = [reject, &runtime, callInvoker](const std::string& errorMessage) -> void {
+      auto error = jsi::JSError(runtime, errorMessage);
+      auto errorShared = std::make_shared<jsi::JSError>(error);
+      callInvoker->invokeAsync([reject, &runtime, errorShared]() -> void {
+        reject->call(runtime, errorShared->value());
+      });
+    };
+
+    auto promise = std::make_shared<Promise>(resolveWrapper, rejectWrapper);
+    func(promise);
+
+    return jsi::Value::undefined();
+  });
+
+  // return new Promise((resolve, reject) => ...)
+  return promiseCtor.callAsConstructor(runtime, runPromise);
+}
+
+} // namespace JsiPromise

package/common/cpp/utils/JsiPromise.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#include <ReactCommon/CallInvoker.h>
+#include <jsi/jsi.h>
+#include <utility>
+#include <memory>
+#include <string>
+
+namespace JsiPromise {
+
+using namespace facebook;
+
+class Promise {
+ public:
+  Promise(std::function<void(jsi::Value)> resolve, std::function<void(const std::string&)> reject): _resolve(std::move(resolve)), _reject(std::move(reject)) {}
+
+  bool isResolved;
+  void resolve(jsi::Value&& value) {
+    _resolve(std::forward<jsi::Value>(value));
+  }
+  void reject(const std::string& errorMessage) {
+    _reject(errorMessage);
+  }
+
+ private:
+  std::function<void(jsi::Value)> _resolve;
+  std::function<void(const std::string&)> _reject;
+};
+
+class PromiseVendor {
+ public:
+  PromiseVendor(jsi::Runtime* runtime, std::shared_ptr<react::CallInvoker> callInvoker): _runtime(runtime), _callInvoker(callInvoker) {}
+
+ public:
+  jsi::Value createPromise(std::function<void(std::shared_ptr<Promise>)> func);
+
+ private:
+  jsi::Runtime* _runtime;
+  std::shared_ptr<react::CallInvoker> _callInvoker;
+};
+
+} // namespace JsiPromise

package/common/cpp/utils/Locker.h

@@ -7,8 +7,8 @@ namespace audioapi {
 // Small easy interface to manage locking
 class Locker {
  public:
-  Locker(): lockPtr_(0) {}
-  explicit Locker(std::mutex& lockPtr): lockPtr_(&lockPtr) {
+  Locker() : lockPtr_(0) {}
+  explicit Locker(std::mutex &lockPtr) : lockPtr_(&lockPtr) {
     lock();
   }
 
@@ -16,7 +16,9 @@ class Locker {
     unlock();
   }
 
-  explicit operator bool() const { return !!lockPtr_; }
+  explicit operator bool() const {
+    return !!lockPtr_;
+  }
 
   void lock() {
     if (lockPtr_) {
@@ -26,11 +28,11 @@ class Locker {
 
   void unlock() {
     if (lockPtr_) {
-    lockPtr_->unlock();
+      lockPtr_->unlock();
     }
   }
 
-  static Locker tryLock(std::mutex& lock) {
+  static Locker tryLock(std::mutex &lock) {
     Locker result = Locker();
 
     if (lock.try_lock()) {
@@ -41,7 +43,7 @@ class Locker {
   }
 
  private:
-  std::mutex* lockPtr_;
+  std::mutex *lockPtr_;
 };
 
 } // namespace audioapi

package/common/cpp/utils/VectorMath.cpp

@@ -115,8 +115,20 @@ float maximumMagnitude(
   return maximumValue;
 }
 
-void multiplyByScalarThenAddToOutput(const float* inputVector, float scalar, float* outputVector, size_t numberOfElementsToProcess) {
-    vDSP_vsma(inputVector, 1, &scalar, outputVector, 1, outputVector, 1, numberOfElementsToProcess);
+void multiplyByScalarThenAddToOutput(
+    const float *inputVector,
+    float scalar,
+    float *outputVector,
+    size_t numberOfElementsToProcess) {
+  vDSP_vsma(
+      inputVector,
+      1,
+      &scalar,
+      outputVector,
+      1,
+      outputVector,
+      1,
+      numberOfElementsToProcess);
 }
 
 #else
@@ -609,69 +621,73 @@ float maximumMagnitude(
   return max;
 }
 
-void multiplyByScalarThenAddToOutput(const float* inputVector, float scalar, float* outputVector, size_t numberOfElementsToProcess) {
-    size_t n = numberOfElementsToProcess;
+void multiplyByScalarThenAddToOutput(
+    const float *inputVector,
+    float scalar,
+    float *outputVector,
+    size_t numberOfElementsToProcess) {
+  size_t n = numberOfElementsToProcess;
 
 #if HAVE_X86_SSE2
-    // If the inputVector address is not 16-byte aligned, the first several frames (at most three) should be processed separately.
-    while (!is16ByteAligned(inputVector) && n) {
-        *outputVector += scalar * *inputVector;
-        inputVector++;
-        outputVector++;
-        n--;
-    }
+  // If the inputVector address is not 16-byte aligned, the first several frames
+  // (at most three) should be processed separately.
+  while (!is16ByteAligned(inputVector) && n) {
+    *outputVector += scalar * *inputVector;
+    inputVector++;
+    outputVector++;
+    n--;
+  }
 
-    // Now the inputVector is aligned, use SSE.
-    size_t tailFrames = n % 4;
-    const float* endP = outputVector + n - tailFrames;
-
-    __m128 pSource;
-    __m128 dest;
-    __m128 temp;
-    __m128 mScale = _mm_set_ps1(scalar);
-
-    bool destAligned = is16ByteAligned(outputVector);
-
-#define SSE2_MULT_ADD(loadInstr, storeInstr)       \
-    while (outputVector < endP)                    \
-    {                                              \
-        pSource = _mm_load_ps(inputVector);        \
-        temp = _mm_mul_ps(pSource, mScale);        \
-        dest = _mm_##loadInstr##_ps(outputVector); \
-        dest = _mm_add_ps(dest, temp);             \
-        _mm_##storeInstr##_ps(outputVector, dest); \
-        inputVector += 4;                          \
-        outputVector += 4;                         \
-    }
+  // Now the inputVector is aligned, use SSE.
+  size_t tailFrames = n % 4;
+  const float *endP = outputVector + n - tailFrames;
+
+  __m128 pSource;
+  __m128 dest;
+  __m128 temp;
+  __m128 mScale = _mm_set_ps1(scalar);
+
+  bool destAligned = is16ByteAligned(outputVector);
+
+#define SSE2_MULT_ADD(loadInstr, storeInstr)   \
+  while (outputVector < endP) {                \
+    pSource = _mm_load_ps(inputVector);        \
+    temp = _mm_mul_ps(pSource, mScale);        \
+    dest = _mm_##loadInstr##_ps(outputVector); \
+    dest = _mm_add_ps(dest, temp);             \
+    _mm_##storeInstr##_ps(outputVector, dest); \
+    inputVector += 4;                          \
+    outputVector += 4;                         \
+  }
 
-    if (destAligned)
-        SSE2_MULT_ADD(load, store)
-    else
-        SSE2_MULT_ADD(loadu, storeu)
+  if (destAligned)
+    SSE2_MULT_ADD(load, store)
+  else
+    SSE2_MULT_ADD(loadu, storeu)
 
-    n = tailFrames;
+  n = tailFrames;
 #elif HAVE_ARM_NEON_INTRINSICS
-    size_t tailFrames = n % 4;
-    const float* endP = outputVector + n - tailFrames;
+  size_t tailFrames = n % 4;
+  const float *endP = outputVector + n - tailFrames;
 
-    float32x4_t k = vdupq_n_f32(scalar);
-    while (outputVector < endP) {
-        float32x4_t source = vld1q_f32(inputVector);
-        float32x4_t dest = vld1q_f32(outputVector);
+  float32x4_t k = vdupq_n_f32(scalar);
+  while (outputVector < endP) {
+    float32x4_t source = vld1q_f32(inputVector);
+    float32x4_t dest = vld1q_f32(outputVector);
 
-        dest = vmlaq_f32(dest, source, k);
-        vst1q_f32(outputVector, dest);
+    dest = vmlaq_f32(dest, source, k);
+    vst1q_f32(outputVector, dest);
 
-        inputVector += 4;
-        outputVector += 4;
-    }
-    n = tailFrames;
+    inputVector += 4;
+    outputVector += 4;
+  }
+  n = tailFrames;
 #endif
-    while (n--) {
-        *outputVector += *inputVector * scalar;
-        ++inputVector;
-        ++outputVector;
-    }
+  while (n--) {
+    *outputVector += *inputVector * scalar;
+    ++inputVector;
+    ++outputVector;
+  }
 }
 
 #endif

package/common/cpp/utils/android/FFTFrame.cpp

@@ -4,19 +4,20 @@
 
 namespace audioapi {
 void FFTFrame::inverse(float *timeDomainData) {
-    fftwf_complex *freqDomainData = fftwf_alloc_complex(size_ / 2);
-    for(int i = 0; i < size_ / 2; i++) {
-        freqDomainData[i][0] = realData_[i];
-        freqDomainData[i][1] = imaginaryData_[i];
-    }
+  fftwf_complex *freqDomainData = fftwf_alloc_complex(size_ / 2);
+  for (int i = 0; i < size_ / 2; i++) {
+    freqDomainData[i][0] = realData_[i];
+    freqDomainData[i][1] = imaginaryData_[i];
+  }
 
-    auto plan = fftwf_plan_dft_c2r_1d(size_, freqDomainData, timeDomainData, FFTW_ESTIMATE);
-    fftwf_execute(plan);
-    fftwf_destroy_plan(plan);
-    fftwf_free(freqDomainData);
+  auto plan = fftwf_plan_dft_c2r_1d(
+      size_, freqDomainData, timeDomainData, FFTW_ESTIMATE);
+  fftwf_execute(plan);
+  fftwf_destroy_plan(plan);
+  fftwf_free(freqDomainData);
 
-    VectorMath::multiplyByScalar(
-            timeDomainData, 1.0f / static_cast<float>(size_), timeDomainData, size_);
+  VectorMath::multiplyByScalar(
+      timeDomainData, 1.0f / static_cast<float>(size_), timeDomainData, size_);
 }
 } // namespace audioapi
 #endif

package/common/cpp/utils/ios/FFTFrame.cpp

@@ -11,7 +11,12 @@ void FFTFrame::inverse(float *timeDomainData) {
   freqDomainData.imagp = imaginaryData_;
 
   vDSP_fft_zrip(fftSetup_, &freqDomainData, 1, log2Size_, FFT_INVERSE);
-  vDSP_ztoc(&freqDomainData, 1, reinterpret_cast<DSPComplex *>(timeDomainData), 2, size_ / 2);
+  vDSP_ztoc(
+      &freqDomainData,
+      1,
+      reinterpret_cast<DSPComplex *>(timeDomainData),
+      2,
+      size_ / 2);
 
   // Scale the FFT data, beacuse of
   // https://developer.apple.com/library/archive/documentation/Performance/Conceptual/vDSP_Programming_Guide/UsingFourierTransforms/UsingFourierTransforms.html#//apple_ref/doc/uid/TP40005147-CH3-15892

package/common/cpp/wrappers/BaseAudioContextWrapper.cpp

@@ -73,4 +73,11 @@ BaseAudioContextWrapper::createPeriodicWave(
       context_->createPeriodicWave(real, imag, disableNormalization, length);
   return std::make_shared<PeriodicWaveWrapper>(periodicWave);
 }
+
+std::shared_ptr<AudioBufferWrapper>
+BaseAudioContextWrapper::decodeAudioDataSource(const std::string &source) {
+  return std::make_shared<AudioBufferWrapper>(
+      context_->decodeAudioDataSource(source));
+}
+
 } // namespace audioapi

package/common/cpp/wrappers/BaseAudioContextWrapper.h

@@ -41,6 +41,7 @@ class BaseAudioContextWrapper {
       float *imag,
       bool disableNormalization,
       int length);
+  std::shared_ptr<AudioBufferWrapper> decodeAudioDataSource(const std::string &source);
 
  protected:
   std::shared_ptr<AudioDestinationNodeWrapper> destination_;

package/ios/AudioAPIModule.mm

@@ -1,6 +1,8 @@
 #import "AudioAPIModule.h"
 
+#import <ReactCommon/RCTTurboModule.h>
 #import <React/RCTBridge+Private.h>
+#import <React/RCTBridge.h>
 #import <React/RCTUtils.h>
 #import <jsi/jsi.h>
 
@@ -33,7 +35,7 @@ RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install)
   auto &runtime = *jsRuntime;
 
   auto wrapper = std::make_shared<audioapi::AudioAPIInstallerWrapper>();
-  auto hostObject = std::make_shared<audioapi::AudioAPIInstallerHostObject>(wrapper);
+  auto hostObject = std::make_shared<audioapi::AudioAPIInstallerHostObject>(wrapper, jsRuntime, cxxBridge.jsCallInvoker);
   auto object = jsi::Object::createFromHostObject(runtime, hostObject);
   runtime.global().setProperty(runtime, "__AudioAPIInstaller", std::move(object));
 

package/ios/AudioDecoder/AudioDecoder.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#import <AVFoundation/AVFoundation.h>
+#import <Foundation/Foundation.h>
+
+@interface AudioDecoder : NSObject
+
+@property (nonatomic, strong) AVAudioPCMBuffer *buffer;
+@property (nonatomic, assign) int sampleRate;
+
+- (instancetype)initWithSampleRate:(int)sampleRate;
+
+- (const AudioBufferList *)decode:(NSString *)pathOrURL;
+
+- (void)cleanup;
+
+@end

package/ios/AudioDecoder/AudioDecoder.m

@@ -0,0 +1,167 @@
+#import <AudioDecoder.h>
+
+@implementation AudioDecoder
+
+- (instancetype)initWithSampleRate:(int)sampleRate
+{
+  if (self = [super init]) {
+    self.sampleRate = sampleRate;
+  }
+  return self;
+}
+
+- (const AudioBufferList *)decode:(NSString *)pathOrURL
+{
+  // check if the input is a URL or a local file path
+  NSURL *url = [NSURL URLWithString:pathOrURL];
+
+  if (url && url.scheme) {
+    self.buffer = [self decodeWithURL:url];
+  } else {
+    self.buffer = [self decodeWithFilePath:pathOrURL];
+  }
+
+  return self.buffer.audioBufferList;
+}
+
+- (AVAudioPCMBuffer *)decodeWithFilePath:(NSString *)path
+{
+  NSError *error = nil;
+  NSURL *fileURL = [NSURL fileURLWithPath:path];
+  AVAudioFile *audioFile = [[AVAudioFile alloc] initForReading:fileURL error:&error];
+
+  if (error) {
+    NSLog(@"Error occurred while opening the audio file: %@", [error localizedDescription]);
+    return nil;
+  }
+  AVAudioPCMBuffer *buffer = [[AVAudioPCMBuffer alloc] initWithPCMFormat:[audioFile processingFormat]
+                                                           frameCapacity:[audioFile length]];
+
+  AVAudioFormat *format = [[AVAudioFormat alloc] initWithCommonFormat:AVAudioPCMFormatFloat32
+                                                           sampleRate:self.sampleRate
+                                                             channels:buffer.audioBufferList->mNumberBuffers
+                                                          interleaved:NO];
+
+  [audioFile readIntoBuffer:buffer error:&error];
+  if (error) {
+    NSLog(@"Error occurred while reading the audio file: %@", [error localizedDescription]);
+    return nil;
+  }
+
+  if (self.sampleRate != audioFile.processingFormat.sampleRate) {
+    return [self convertBuffer:buffer ToFormat:format];
+  }
+
+  return buffer;
+}
+
+- (AVAudioPCMBuffer *)decodeWithURL:(NSURL *)url
+{
+  __block NSURL *tempFileURL = nil;
+
+  dispatch_group_t group = dispatch_group_create();
+
+  dispatch_group_enter(group);
+
+  [self downloadFileFromURL:url
+                 completion:^(NSURL *downloadedFileURL, NSError *downloadError) {
+                   if (downloadError) {
+                     NSLog(@"Error downloading file: %@", downloadError.localizedDescription);
+                     tempFileURL = nil;
+                   } else {
+                     tempFileURL = downloadedFileURL;
+                   }
+
+                   dispatch_group_leave(group);
+                 }];
+
+  dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
+
+  if (!tempFileURL) {
+    NSLog(@"Cannot process given url");
+    return nil;
+  }
+
+  return [self decodeWithFilePath:tempFileURL.path];
+}
+
+- (void)downloadFileFromURL:(NSURL *)url completion:(void (^)(NSURL *tempFileURL, NSError *error))completion
+{
+  // get unique file path in temporary dir
+  NSString *tempDirectory = NSTemporaryDirectory();
+  NSString *timestamp = [NSString stringWithFormat:@"_%@", @((long long)[[NSDate date] timeIntervalSince1970])];
+  NSString *fileNameWithTimestamp = [url.lastPathComponent stringByDeletingPathExtension];
+  fileNameWithTimestamp = [fileNameWithTimestamp stringByAppendingString:timestamp];
+  NSString *fileExtension =
+      [url.pathExtension length] > 0 ? [NSString stringWithFormat:@".%@", url.pathExtension] : @"";
+  NSString *tempFilePath =
+      [tempDirectory stringByAppendingPathComponent:[fileNameWithTimestamp stringByAppendingString:fileExtension]];
+  NSURL *tempFileURL = [NSURL fileURLWithPath:tempFilePath];
+
+  // download file
+  NSURLSession *session = [NSURLSession sharedSession];
+  NSURLSessionDownloadTask *downloadTask = [session
+      downloadTaskWithURL:url
+        completionHandler:^(NSURL *location, NSURLResponse *response, NSError *error) {
+          if (error) {
+            NSLog(@"Error downloading file: %@", error.localizedDescription);
+            if (completion) {
+              completion(nil, error);
+            }
+            return;
+          }
+
+          // move to generated file path in temporary dir
+          NSError *fileError = nil;
+          BOOL success = [[NSFileManager defaultManager] moveItemAtURL:location toURL:tempFileURL error:&fileError];
+          if (success) {
+            NSLog(@"File downloaded successfully to %@", tempFileURL.path);
+            if (completion) {
+              completion(tempFileURL, nil);
+            }
+          } else {
+            NSLog(@"Error moving downloaded file: %@", fileError.localizedDescription);
+            if (completion) {
+              completion(nil, fileError);
+            }
+          }
+        }];
+
+  [downloadTask resume];
+}
+
+- (AVAudioPCMBuffer *)convertBuffer:(AVAudioPCMBuffer *)buffer ToFormat:(AVAudioFormat *)format
+{
+  NSError *error = nil;
+  AVAudioConverter *converter = [[AVAudioConverter alloc] initFromFormat:buffer.format toFormat:format];
+  AVAudioPCMBuffer *convertedBuffer =
+      [[AVAudioPCMBuffer alloc] initWithPCMFormat:format frameCapacity:(AVAudioFrameCount)buffer.frameCapacity];
+
+  AVAudioConverterInputBlock inputBlock =
+      ^AVAudioBuffer *(AVAudioPacketCount inNumberOfPackets, AVAudioConverterInputStatus *outStatus)
+  {
+    if (buffer.frameLength > 0) {
+      *outStatus = AVAudioConverterInputStatus_HaveData;
+      return buffer;
+    } else {
+      *outStatus = AVAudioConverterInputStatus_NoDataNow;
+      return nil;
+    }
+  };
+
+  [converter convertToBuffer:convertedBuffer error:&error withInputFromBlock:inputBlock];
+
+  if (error) {
+    NSLog(@"Error occurred while converting the audio file: %@", [error localizedDescription]);
+    return nil;
+  }
+
+  return convertedBuffer;
+}
+
+- (void)cleanup
+{
+  self.buffer = nil;
+}
+
+@end

package/ios/AudioDecoder/IOSAudioDecoder.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <string>
+
+#ifdef __OBJC__ // when compiled as Objective-C++
+#import <AudioDecoder.h>
+#else // when compiled as C++
+typedef struct objc_object AudioDecoder;
+#endif // __OBJC__
+
+namespace audioapi {
+
+class AudioBus;
+
+class IOSAudioDecoder {
+ protected:
+  AudioDecoder *audioDecoder_;
+  int sampleRate_;
+
+ public:
+  IOSAudioDecoder(int sampleRate);
+  ~IOSAudioDecoder();
+
+  AudioBus *decodeWithFilePath(const std::string &path);
+};
+} // namespace audioapi

package/ios/AudioDecoder/IOSAudioDecoder.mm

@@ -0,0 +1,40 @@
+#import <AVFoundation/AVFoundation.h>
+
+#include <AudioArray.h>
+#include <AudioBus.h>
+#include <IOSAudioDecoder.h>
+
+namespace audioapi {
+
+IOSAudioDecoder::IOSAudioDecoder(int sampleRate) : sampleRate_(sampleRate)
+{
+  audioDecoder_ = [[AudioDecoder alloc] initWithSampleRate:sampleRate_];
+}
+
+IOSAudioDecoder::~IOSAudioDecoder()
+{
+  [audioDecoder_ cleanup];
+  audioDecoder_ = nullptr;
+}
+
+AudioBus *IOSAudioDecoder::decodeWithFilePath(const std::string &path)
+{
+  auto bufferList = [audioDecoder_ decode:[NSString stringWithUTF8String:path.c_str()]];
+  AudioBus *audioBus;
+  if (bufferList) {
+    auto numberOfChannels = bufferList->mNumberBuffers;
+    auto size = bufferList->mBuffers[0].mDataByteSize / sizeof(float);
+
+    audioBus = new AudioBus(sampleRate_, size, numberOfChannels);
+
+    for (int i = 0; i < numberOfChannels; i++) {
+      float *data = (float *)bufferList->mBuffers[i].mData;
+      memcpy(audioBus->getChannel(i)->getData(), data, sizeof(float) * size);
+    }
+  } else {
+    audioBus = new AudioBus(sampleRate_, 1, 1);
+  }
+
+  return audioBus;
+}
+} // namespace audioapi

package/ios/AudioPlayer/AudioPlayer.h

@@ -3,7 +3,7 @@
 #import <AVFoundation/AVFoundation.h>
 #import <Foundation/Foundation.h>
 
-typedef void (^RenderAudioBlock)(AudioBufferList* outputBuffer, int numFrames);
+typedef void (^RenderAudioBlock)(AudioBufferList *outputBuffer, int numFrames);
 
 @interface AudioPlayer : NSObject
 

package/ios/AudioPlayer/AudioPlayer.m

@@ -70,7 +70,6 @@
   [self.audioEngine attachNode:self.sourceNode];
   [self.audioEngine connect:self.sourceNode to:self.audioEngine.mainMixerNode format:self.format];
 
-
   if (!self.audioEngine.isRunning) {
     NSError *error = nil;
     if (![self.audioEngine startAndReturnError:&error]) {