react-native-executorch 0.4.9 → 0.5.0-nightly-6f4dd53-20251211

package/ios/RnExecutorch/models/stt/Whisper.mm

@@ -1,68 +0,0 @@
-#import "Whisper.hpp"
-#import "WhisperEncoder.hpp"
-#import "Whisperdecoder.hpp"
-
-@implementation Whisper {
-  WhisperEncoder *encoder;
-  WhisperDecoder *decoder;
-  NSNumber *START_TOKEN;
-  NSNumber *EOS_TOKEN;
-  NSArray *encoderLastHiddenState;
-  int maxSeqLen;
-}
-
-- (instancetype)init {
-  self = [super init];
-  if (self) {
-    START_TOKEN = @50257;
-    EOS_TOKEN = @50256;
-    maxSeqLen = 512;
-  }
-  return self;
-}
-
-- (NSArray *)encode:(NSArray *)waveform {
-  self->encoderLastHiddenState = [self->encoder encode:waveform];
-
-  if (!self->encoderLastHiddenState) {
-    [NSException raise:@"forward_error" format:nil];
-  }
-  return self->encoderLastHiddenState;
-}
-
-- (NSArray *)decode:(NSArray *)prevTokens
-    encoderLastHiddenState:(NSArray *)encoderLastHiddenState {
-  if ([encoderLastHiddenState count] > 0) {
-    return [self->decoder decode:prevTokens
-          encoderLastHiddenState:encoderLastHiddenState];
-  }
-  return [self->decoder
-                      decode:prevTokens
-      encoderLastHiddenState:[NSMutableArray
-                                 arrayWithObject:self->encoderLastHiddenState]];
-}
-
-- (void)loadModules:(NSArray *)modelSources {
-
-  self->encoder = [[WhisperEncoder alloc] init];
-  self->decoder = [[WhisperDecoder alloc] init];
-
-  // Load encoder after preprocessor
-  [self loadModuleHelper:self->encoder
-      withSource:[modelSources objectAtIndex:0]
-      onSuccess:^{
-        // Load decoder after encoder
-        [self loadModuleHelper:self->decoder
-            withSource:[modelSources objectAtIndex:1]
-            onSuccess:^{
-            }
-            onFailure:^(NSString *errorCode) {
-              [NSException raise:@"init_decoder_error" format:@"%d", errorCode];
-            }];
-      }
-      onFailure:^(NSString *errorCode) {
-        [NSException raise:@"init_encoder_error" format:@"%d", errorCode];
-      }];
-}
-
-@end

package/ios/RnExecutorch/models/stt/WhisperDecoder.hpp

@@ -1,16 +0,0 @@
-#ifndef WhisperDecoder_hpp
-#define WhisperDecoder_hpp
-
-#import "../BaseModel.h"
-#import "ExecutorchLib/ETModel.h"
-#import <Foundation/Foundation.h>
-#import <UIKit/UIKit.h>
-
-@interface WhisperDecoder : BaseModel
-
-- (NSArray *)decode:(NSArray *)prevTokens
-    encoderLastHiddenState:(NSArray *)encoderLastHiddenState;
-
-@end
-
-#endif /* WhisperDecoder_hpp */

package/ios/RnExecutorch/models/stt/WhisperDecoder.mm

@@ -1,22 +0,0 @@
-#import "WhisperDecoder.hpp"
-#import "../../utils/ScalarType.h"
-
-NSNumber *encoderLastHiddenStateType = ScalarType.Float;
-NSNumber *prevTokensType = ScalarType.Int32;
-NSArray *decoderInputTypes = @[ prevTokensType, encoderLastHiddenStateType ];
-NSArray *encoderLastHiddenStateShape = @[ @1, @1500, @384 ];
-
-@implementation WhisperDecoder
-
-- (NSArray *)decode:(NSArray *)prevTokens
-    encoderLastHiddenState:(NSArray *)encoderLastHiddenState {
-  NSNumber *tokensCount = @([prevTokens count]);
-  NSArray *prevTokensShape = @[ @1, tokensCount ];
-  NSArray *predictedToken =
-      [self forward:@[ prevTokens, encoderLastHiddenState ]
-              shapes:@[ prevTokensShape, encoderLastHiddenStateShape ]
-          inputTypes:decoderInputTypes];
-  return [[predictedToken objectAtIndex:0] lastObject];
-}
-
-@end

package/ios/RnExecutorch/models/stt/WhisperEncoder.hpp

@@ -1,15 +0,0 @@
-#ifndef WhisperEncoder_hpp
-#define WhisperEncoder_hpp
-
-#import "../BaseModel.h"
-#import "ExecutorchLib/ETModel.h"
-#import <Foundation/Foundation.h>
-#import <UIKit/UIKit.h>
-
-@interface WhisperEncoder : BaseModel
-
-- (NSArray *)encode:(NSArray *)waveform;
-
-@end
-
-#endif /* WhisperEncoder_hpp */

package/ios/RnExecutorch/models/stt/WhisperEncoder.mm

@@ -1,21 +0,0 @@
-#import "WhisperEncoder.hpp"
-#import "../../utils/SFFT.hpp"
-#import "../../utils/ScalarType.h"
-
-NSArray *spectrogramInputType = [NSArray arrayWithObject:ScalarType.Float];
-NSNumber *fftFrameSize = @256;
-
-@implementation WhisperEncoder
-
-- (NSArray *)encode:(NSArray *)waveform {
-  NSArray *stft = [SFFT sfftFromWaveform:waveform fftSize:512 fftHopLength:160];
-  NSNumber *numFrames = [NSNumber numberWithDouble:([stft count] / 256)];
-  NSArray *inputShape = @[ @[ numFrames, fftFrameSize ] ];
-  NSArray *result = [self forward:@[ stft ]
-                           shapes:inputShape
-                       inputTypes:spectrogramInputType];
-  // unsquezing before the return, since forward returns an array of results;
-  return [result objectAtIndex:0];
-}
-
-@end

package/ios/RnExecutorch/models/style_transfer/StyleTransferModel.h

@@ -1,11 +0,0 @@
-#import "../BaseModel.h"
-#import "opencv2/opencv.hpp"
-
-@interface StyleTransferModel : BaseModel
-
-- (cv::Size)getModelImageSize;
-- (NSArray *)preprocess:(cv::Mat &)input;
-- (cv::Mat)postprocess:(NSArray *)output;
-- (cv::Mat)runModel:(cv::Mat &)input;
-
-@end

package/ios/RnExecutorch/models/style_transfer/StyleTransferModel.mm

@@ -1,50 +0,0 @@
-#import "StyleTransferModel.h"
-#import "../../utils/ImageProcessor.h"
-
-@implementation StyleTransferModel {
-  cv::Size originalSize;
-}
-
-- (cv::Size)getModelImageSize {
-  NSArray *inputShape = [module getInputShape:@0];
-  NSNumber *widthNumber = inputShape.lastObject;
-  NSNumber *heightNumber = inputShape[inputShape.count - 2];
-
-  int height = [heightNumber intValue];
-  int width = [widthNumber intValue];
-
-  return cv::Size(height, width);
-}
-
-- (NSArray *)preprocess:(cv::Mat &)input {
-  self->originalSize = cv::Size(input.cols, input.rows);
-
-  cv::Size modelImageSize = [self getModelImageSize];
-  cv::Mat output;
-  cv::resize(input, output, modelImageSize);
-
-  NSArray *modelInput = [ImageProcessor matToNSArray:output];
-  return modelInput;
-}
-
-- (cv::Mat)postprocess:(NSArray *)output {
-  cv::Size modelImageSize = [self getModelImageSize];
-  cv::Mat processedImage = [ImageProcessor arrayToMat:output
-                                                width:modelImageSize.width
-                                               height:modelImageSize.height];
-
-  cv::Mat processedOutput;
-  cv::resize(processedImage, processedOutput, originalSize);
-
-  return processedOutput;
-}
-
-- (cv::Mat)runModel:(cv::Mat &)input {
-  NSArray *modelInput = [self preprocess:input];
-  NSArray *result = [self forward:@[ modelInput ]];
-  input = [self postprocess:result[0]];
-
-  return input;
-}
-
-@end

package/ios/RnExecutorch/models/text_embeddings/TextEmbeddingsModel.h

@@ -1,15 +0,0 @@
-#import "BaseModel.h"
-#import "ExecutorchLib/HuggingFaceTokenizer.h"
-
-@interface TextEmbeddingsModel : BaseModel {
-@protected
-  HuggingFaceTokenizer *tokenizer;
-}
-
-- (void)loadTokenizer:(NSString *)tokenizerSource;
-- (NSArray *)preprocess:(NSString *)input;
-- (NSArray *)runModel:(NSString *)input;
-- (NSArray *)postprocess:(NSArray *)input
-           attentionMask:(NSArray *)attentionMask;
-
-@end

package/ios/RnExecutorch/models/text_embeddings/TextEmbeddingsModel.mm

@@ -1,45 +0,0 @@
-#import "TextEmbeddingsModel.h"
-#import "TextEmbeddingsUtils.h"
-
-@implementation TextEmbeddingsModel
-
-- (NSArray *)preprocess:(NSString *)input {
-  NSArray *input_ids = [self->tokenizer encode:input];
-  NSMutableArray *attention_mask = [NSMutableArray new];
-  for (int i = 0; i < [input_ids count]; i++) {
-    [attention_mask addObject:@((int)([input_ids[i] intValue] != 0))];
-  }
-  return @[ input_ids, attention_mask ]; // [2, tokens]
-}
-
-- (NSArray *)postprocess:(NSArray *)modelOutput   // [tokens * embedding_dim]
-           attentionMask:(NSArray *)attentionMask // [tokens]
-{
-  NSArray *embeddings = [TextEmbeddingsUtils meanPooling:modelOutput
-                                           attentionMask:attentionMask];
-  return [TextEmbeddingsUtils normalize:embeddings];
-}
-
-- (NSArray *)runModel:(NSString *)input {
-  NSArray *modelInput = [self preprocess:input];
-
-  NSMutableArray *inputTypes = [NSMutableArray arrayWithObjects:@4, @4, nil];
-  NSMutableArray *shapes = [NSMutableArray new];
-
-  NSNumber *tokenCount = @([modelInput[0] count]);
-  for (__unused id _ in modelInput) {
-    [shapes addObject:[NSMutableArray arrayWithObjects:@1, tokenCount, nil]];
-  }
-
-  NSArray *modelOutput = [self forward:modelInput
-                                shapes:shapes
-                            inputTypes:inputTypes];
-  return [self postprocess:modelOutput[0] attentionMask:modelInput[1]];
-}
-
-- (void)loadTokenizer:(NSString *)tokenizerSource {
-  tokenizer =
-      [[HuggingFaceTokenizer alloc] initWithTokenizerPath:tokenizerSource];
-}
-
-@end

package/ios/RnExecutorch/models/text_embeddings/TextEmbeddingsUtils.h

@@ -1,8 +0,0 @@
-@interface TextEmbeddingsUtils : NSObject
-
-+ (NSArray *)meanPooling:(NSArray *)modelOutput
-           attentionMask:(NSArray *)attentionMask;
-
-+ (NSArray *)normalize:(NSArray *)embeddings;
-
-@end

package/ios/RnExecutorch/models/text_embeddings/TextEmbeddingsUtils.mm

@@ -1,49 +0,0 @@
-#import "TextEmbeddingsUtils.h"
-
-@implementation TextEmbeddingsUtils
-
-+ (NSArray *)meanPooling:(NSArray *)modelOutput
-           attentionMask:(NSArray *)attentionMask {
-  NSInteger modelOutputLength = [modelOutput count];
-  NSInteger attentionMaskLength = [attentionMask count];
-  NSInteger embeddingDim = modelOutputLength / attentionMaskLength;
-
-  NSMutableArray *result = [NSMutableArray arrayWithCapacity:embeddingDim];
-
-  double sumMask = 0.0;
-  for (NSNumber *maskValue in attentionMask) {
-    sumMask += [maskValue intValue];
-  }
-  sumMask = fmax(sumMask, 1e-9);
-
-  for (NSInteger i = 0; i < embeddingDim; i++) {
-    double sum = 0;
-    for (NSInteger j = 0; j < attentionMaskLength; j++) {
-      sum += [modelOutput[j * embeddingDim + i] doubleValue] *
-             [attentionMask[j] intValue];
-    }
-    [result addObject:@(sum / sumMask)];
-  }
-
-  return result;
-}
-
-+ (NSArray *)normalize:(NSArray *)embeddings {
-  NSInteger embeddingDim = [embeddings count];
-  double sum = 0.0;
-
-  for (NSNumber *value in embeddings) {
-    sum += [value doubleValue] * [value doubleValue];
-  }
-  sum = fmax(sqrt(sum), 1e-9);
-
-  NSMutableArray *normalizedResult =
-      [NSMutableArray arrayWithCapacity:embeddingDim];
-  for (NSNumber *value in embeddings) {
-    [normalizedResult addObject:@([value doubleValue] / sum)];
-  }
-
-  return normalizedResult;
-}
-
-@end

package/ios/RnExecutorch/utils/Constants.h

@@ -1,8 +0,0 @@
-#ifndef Constants_h
-#define Constants_h
-
-#include <map>
-
-extern const std::unordered_map<int, std::string> cocoLabelsMap;
-
-#endif /* Constants_h */

package/ios/RnExecutorch/utils/Conversions.h

@@ -1,15 +0,0 @@
-#import "opencv2/opencv.hpp"
-
-// Convert a matrix containing a single value per cell to a NSArray
-template <typename T>
-NSArray* simpleMatToNSArray(const cv::Mat& mat) {
-    std::size_t numPixels = mat.rows * mat.cols;
-    NSMutableArray *arr = [[NSMutableArray alloc] initWithCapacity:numPixels];
-
-    for (std::size_t x = 0; x < mat.rows; ++x) {
-        for (std::size_t y = 0; y < mat.cols; ++y) {
-            arr[x * mat.cols + y] = @(mat.at<T>(x, y));
-        }
-    }
-    return arr;
-}

package/ios/RnExecutorch/utils/ETError.h

@@ -1,26 +0,0 @@
-typedef NS_ENUM(NSUInteger, ETError) {
-  UndefinedError = 0x65,
-  ModuleNotLoaded = 0x66,
-  FileWriteFailed = 0x67,
-  InvalidModelSource = 0xff,
-
-  Ok = 0x00,
-  Internal = 0x01,
-  InvalidState = 0x02,
-  EndOfMethod = 0x03,
-
-  NotSupported = 0x10,
-  NotImplemented = 0x11,
-  InvalidArgument = 0x12,
-  InvalidType = 0x13,
-  OperatorMissing = 0x14,
-
-  NotFound = 0x20,
-  MemoryAllocationFailed = 0x21,
-  AccessFailed = 0x22,
-  InvalidProgram = 0x23,
-
-  DelegateInvalidCompatibility = 0x30,
-  DelegateMemoryAllocationFailed = 0x31,
-  DelegateInvalidHandle = 0x32
-};

package/ios/RnExecutorch/utils/ImageProcessor.h

@@ -1,15 +0,0 @@
-#import <opencv2/opencv.hpp>
-
-@interface ImageProcessor : NSObject
-
-+ (NSArray *)matToNSArray:(const cv::Mat &)mat
-                     mean:(cv::Scalar)mean
-                 variance:(cv::Scalar)variance;
-+ (NSArray *)matToNSArray:(const cv::Mat &)mat;
-+ (cv::Mat)arrayToMat:(NSArray *)array width:(int)width height:(int)height;
-+ (cv::Mat)arrayToMatGray:(NSArray *)array width:(int)width height:(int)height;
-+ (NSArray *)matToNSArrayGray:(const cv::Mat &)mat;
-+ (NSString *)saveToTempFile:(const cv::Mat &)image;
-+ (cv::Mat)readImage:(NSString *)source;
-
-@end

package/ios/RnExecutorch/utils/ImageProcessor.mm

@@ -1,147 +0,0 @@
-#import "ImageProcessor.h"
-#import "ETError.h"
-
-@implementation ImageProcessor
-
-+ (NSArray *)matToNSArray:(const cv::Mat &)mat {
-  return [ImageProcessor matToNSArray:mat
-                                 mean:cv::Scalar(0.0, 0.0, 0.0)
-                             variance:cv::Scalar(1.0, 1.0, 1.0)];
-}
-
-+ (NSArray *)matToNSArray:(const cv::Mat &)mat
-                     mean:(cv::Scalar)mean
-                 variance:(cv::Scalar)variance {
-  int pixelCount = mat.cols * mat.rows;
-  NSMutableArray *floatArray =
-      [[NSMutableArray alloc] initWithCapacity:pixelCount * 3];
-  for (NSUInteger k = 0; k < pixelCount * 3; k++) {
-    [floatArray addObject:@0.0];
-  }
-
-  for (int i = 0; i < pixelCount; i++) {
-    int row = i / mat.cols;
-    int col = i % mat.cols;
-    cv::Vec3b pixel = mat.at<cv::Vec3b>(row, col);
-    floatArray[0 * pixelCount + i] =
-        @((pixel[0] - mean[0] * 255.0) / (variance[0] * 255.0));
-    floatArray[1 * pixelCount + i] =
-        @((pixel[1] - mean[1] * 255.0) / (variance[1] * 255.0));
-    floatArray[2 * pixelCount + i] =
-        @((pixel[2] - mean[2] * 255.0) / (variance[2] * 255.0));
-  }
-
-  return floatArray;
-}
-
-+ (NSArray *)matToNSArrayGray:(const cv::Mat &)mat {
-  NSMutableArray *pixelArray =
-      [[NSMutableArray alloc] initWithCapacity:mat.cols * mat.rows];
-
-  for (int row = 0; row < mat.rows; row++) {
-    for (int col = 0; col < mat.cols; col++) {
-      float pixelValue = mat.at<float>(row, col);
-      [pixelArray addObject:@(pixelValue)];
-    }
-  }
-
-  return pixelArray;
-}
-
-+ (cv::Mat)arrayToMat:(NSArray *)array width:(int)width height:(int)height {
-  cv::Mat mat(height, width, CV_8UC3);
-
-  int pixelCount = width * height;
-  for (int i = 0; i < pixelCount; i++) {
-    int row = i / width;
-    int col = i % width;
-    float r = 0, g = 0, b = 0;
-
-    r = [[array objectAtIndex:0 * pixelCount + i] floatValue];
-    g = [[array objectAtIndex:1 * pixelCount + i] floatValue];
-    b = [[array objectAtIndex:2 * pixelCount + i] floatValue];
-
-    cv::Vec3b color((uchar)(b * 255), (uchar)(g * 255), (uchar)(r * 255));
-    mat.at<cv::Vec3b>(row, col) = color;
-  }
-
-  return mat;
-}
-
-+ (cv::Mat)arrayToMatGray:(NSArray *)array width:(int)width height:(int)height {
-  cv::Mat mat(height, width, CV_32F);
-
-  int pixelCount = width * height;
-  for (int i = 0; i < pixelCount; i++) {
-    int row = i / width;
-    int col = i % width;
-    float value = [array[i] floatValue];
-    mat.at<float>(row, col) = value;
-  }
-
-  return mat;
-}
-
-+ (NSString *)saveToTempFile:(const cv::Mat &)image {
-  NSString *uniqueID = [[NSUUID UUID] UUIDString];
-  NSString *filename =
-      [NSString stringWithFormat:@"rn_executorch_%@.png", uniqueID];
-  NSString *outputPath =
-      [NSTemporaryDirectory() stringByAppendingPathComponent:filename];
-
-  std::string filePath = [outputPath UTF8String];
-  if (!cv::imwrite(filePath, image)) {
-    @throw [NSException
-        exceptionWithName:@"ImageSaveException"
-                   reason:[NSString
-                              stringWithFormat:@"%ld", (long)FileWriteFailed]
-                 userInfo:nil];
-  }
-
-  return [NSString stringWithFormat:@"file://%@", outputPath];
-}
-
-+ (cv::Mat)readImage:(NSString *)source {
-  NSURL *url = [NSURL URLWithString:source];
-
-  cv::Mat inputImage;
-  if ([[url scheme] isEqualToString:@"data"]) {
-    // base64
-    NSArray *parts = [source componentsSeparatedByString:@","];
-    if ([parts count] < 2) {
-      @throw [NSException
-          exceptionWithName:@"readImage_error"
-                     reason:[NSString
-                                stringWithFormat:@"%ld", (long)InvalidArgument]
-                   userInfo:nil];
-    }
-    NSString *encodedString = parts[1];
-    NSData *data = [[NSData alloc]
-        initWithBase64EncodedString:encodedString
-                            options:
-                                NSDataBase64DecodingIgnoreUnknownCharacters];
-    cv::Mat encodedData(1, [data length], CV_8UC1, (void *)data.bytes);
-    inputImage = cv::imdecode(encodedData, cv::IMREAD_COLOR);
-  } else if ([[url scheme] isEqualToString:@"file"]) {
-    // local file
-    inputImage = cv::imread([[url path] UTF8String], cv::IMREAD_COLOR);
-  } else {
-    // external file
-    NSData *data = [NSData dataWithContentsOfURL:url];
-    inputImage =
-        cv::imdecode(cv::Mat(1, [data length], CV_8UC1, (void *)data.bytes),
-                     cv::IMREAD_COLOR);
-  }
-
-  if (inputImage.empty()) {
-    @throw [NSException
-        exceptionWithName:@"readImage_error"
-                   reason:[NSString
-                              stringWithFormat:@"%ld", (long)InvalidArgument]
-                 userInfo:nil];
-  }
-
-  return inputImage;
-}
-
-@end

package/ios/RnExecutorch/utils/Numerical.h

@@ -1 +0,0 @@
-std::vector<double> softmax(const std::vector<double> &v);

package/ios/RnExecutorch/utils/Numerical.mm

@@ -1,18 +0,0 @@
-#include "Utils.h"
-
-std::vector<double> softmax(const std::vector<double> &v) {
-  std::vector<double> result(v.size());
-  double maxVal = *std::max_element(v.begin(), v.end());
-
-  double sumExp = 0.0;
-  for (size_t i = 0; i < v.size(); ++i) {
-    result[i] = std::exp(v[i] - maxVal);
-    sumExp += result[i];
-  }
-
-  for (size_t i = 0; i < v.size(); ++i) {
-    result[i] /= sumExp;
-  }
-
-  return result;
-}

package/ios/RnExecutorch/utils/ObjectDetectionUtils.hpp

@@ -1,23 +0,0 @@
-#ifndef ObjectDetectionUtils_hpp
-#define ObjectDetectionUtils_hpp
-
-#import <Foundation/Foundation.h>
-#include <stdio.h>
-#include <vector>
-
-struct Detection {
-  float x1;
-  float y1;
-  float x2;
-  float y2;
-  float label;
-  float score;
-};
-
-NSString *floatLabelToNSString(float label);
-NSDictionary *detectionToNSDictionary(const Detection &detection);
-float iou(const Detection &a, const Detection &b);
-std::vector<Detection> nms(std::vector<Detection> detections,
-                           float iouThreshold);
-
-#endif /* ObjectDetectionUtils_hpp */

package/ios/RnExecutorch/utils/SFFT.hpp

@@ -1,13 +0,0 @@
-#import <Accelerate/Accelerate.h>
-#import <UIKit/UIKit.h>
-
-@interface SFFT : NSObject
-
-+ (NSArray *)sfftFromWaveform:(NSArray *)waveform
-                      fftSize:(int)fftSize
-                 fftHopLength:(int)fftHopLength;
-+ (void)fft:(float *)signal
-      fftSetup:(FFTSetup)fftSetup
-       fftSize:(int)fftSize
-    magnitudes:(NSMutableArray *)magnitudes;
-@end

package/ios/RnExecutorch/utils/SFFT.mm

@@ -1,71 +0,0 @@
-#import "SFFT.hpp"
-
-@implementation SFFT
-
-+ (NSArray *)sfftFromWaveform:(NSArray *)waveform
-                      fftSize:(int)fftSize
-                 fftHopLength:(int)fftHopLength {
-  FFTSetup fftSetup = vDSP_create_fftsetup(log2(fftSize), kFFTRadix2);
-  if (!fftSetup) {
-    NSLog(@"Error creating FFT setup.");
-  }
-
-  // Generate Hann Window coefficients.
-  // https://www.mathworks.com/help/signal/ref/hann.html
-  float hann[fftSize];
-  for (int i = 0; i < fftSize; i++) {
-    hann[i] = 0.5 * (1 - cos(2 * M_PI * i / (fftSize - 1)));
-  }
-
-  NSMutableArray *stftResult = [NSMutableArray new];
-  int currentIndex = 0;
-  while (currentIndex + fftSize <= waveform.count) {
-    float signal[fftSize];
-
-    // Extract signal and apply the Hann window
-    for (int i = 0; i < fftSize; i++) {
-      signal[i] = [waveform[currentIndex + i] floatValue] * hann[i];
-    }
-
-    [SFFT fft:signal fftSetup:fftSetup magnitudes:stftResult fftSize:fftSize];
-
-    currentIndex += fftHopLength;
-  }
-
-  vDSP_destroy_fftsetup(fftSetup);
-  return stftResult;
-}
-
-+ (void)fft:(float *)signal
-      fftSetup:(FFTSetup)fftSetup
-    magnitudes:(NSMutableArray *)magnitudes
-       fftSize:(int)fftSize {
-  const int log2n = log2(fftSize);
-  DSPSplitComplex a;
-  a.realp = (float *)malloc(fftSize / 2 * sizeof(float));
-  a.imagp = (float *)malloc(fftSize / 2 * sizeof(float));
-
-  // Perform the FFT
-  vDSP_ctoz((DSPComplex *)signal, 2, &a, 1, fftSize / 2);
-  vDSP_fft_zrip(fftSetup, &a, 1, log2n, FFT_FORWARD);
-
-  // Zero out Nyquist component
-  a.imagp[0] = 0.0f;
-
-  const float magnitudeScale = 1.0f / fftSize;
-  for (int i = 0; i < fftSize / 2; ++i) {
-    double magnitude = sqrt(a.realp[i] * a.realp[i] + a.imagp[i] * a.imagp[i]) *
-                       magnitudeScale;
-    // FIXME: we don't need that, but if we remove this we have to get rid of
-    // reversing this operation in the preprocessing part
-    double magnitudeDb = 20 * log10f(magnitude);
-    // Push to the result array
-    [magnitudes addObject:@(magnitudeDb)];
-  }
-
-  // Cleanup
-  free(a.realp);
-  free(a.imagp);
-}
-
-@end