react-native-audio-api 0.4.1 → 0.4.2

package/common/cpp/core/AudioBuffer.cpp

@@ -4,7 +4,10 @@
 
 namespace audioapi {
 
-AudioBuffer::AudioBuffer(int numberOfChannels, int length, int sampleRate) {
+AudioBuffer::AudioBuffer(
+    int numberOfChannels,
+    size_t length,
+    float sampleRate) {
   bus_ = std::make_shared<AudioBus>(sampleRate, length, numberOfChannels);
 }
 
@@ -12,7 +15,7 @@ AudioBuffer::AudioBuffer(AudioBus *bus) {
   bus_ = std::shared_ptr<AudioBus>(bus);
 }
 
-int AudioBuffer::getLength() const {
+size_t AudioBuffer::getLength() const {
   return bus_->getSize();
 }
 
@@ -20,12 +23,12 @@ int AudioBuffer::getNumberOfChannels() const {
   return bus_->getNumberOfChannels();
 }
 
-int AudioBuffer::getSampleRate() const {
+float AudioBuffer::getSampleRate() const {
   return bus_->getSampleRate();
 }
 
-double AudioBuffer::getDuration() const {
-  return static_cast<double>(getLength()) / getSampleRate();
+float AudioBuffer::getDuration() const {
+  return static_cast<float>(getLength()) / getSampleRate();
 }
 
 float *AudioBuffer::getChannelData(int channel) const {
@@ -34,9 +37,9 @@ float *AudioBuffer::getChannelData(int channel) const {
 
 void AudioBuffer::copyFromChannel(
     float *destination,
-    int destinationLength,
+    size_t destinationLength,
     int channelNumber,
-    int startInChannel) const {
+    size_t startInChannel) const {
   memcpy(
       destination,
       bus_->getChannel(channelNumber)->getData() + startInChannel,
@@ -46,9 +49,9 @@ void AudioBuffer::copyFromChannel(
 
 void AudioBuffer::copyToChannel(
     const float *source,
-    int sourceLength,
+    size_t sourceLength,
     int channelNumber,
-    int startInChannel) {
+    size_t startInChannel) {
   memcpy(
       bus_->getChannel(channelNumber)->getData() + startInChannel,
       source,

package/common/cpp/core/AudioBuffer.h

@@ -4,6 +4,7 @@
 #include <memory>
 #include <string>
 #include <vector>
+#include <cstddef>
 
 namespace audioapi {
 
@@ -11,26 +12,26 @@ class AudioBus;
 
 class AudioBuffer : public std::enable_shared_from_this<AudioBuffer> {
  public:
-  explicit AudioBuffer(int numberOfChannels, int length, int sampleRate);
+  explicit AudioBuffer(int numberOfChannels, size_t length, float sampleRate);
   explicit AudioBuffer(AudioBus *bus);
 
-  [[nodiscard]] int getLength() const;
-  [[nodiscard]] int getSampleRate() const;
-  [[nodiscard]] double getDuration() const;
+  [[nodiscard]] size_t getLength() const;
+  [[nodiscard]] float getSampleRate() const;
+  [[nodiscard]] float getDuration() const;
 
   [[nodiscard]] int getNumberOfChannels() const;
   [[nodiscard]] float *getChannelData(int channel) const;
 
   void copyFromChannel(
       float *destination,
-      int destinationLength,
+      size_t destinationLength,
       int channelNumber,
-      int startInChannel) const;
+      size_t startInChannel) const;
   void copyToChannel(
       const float *source,
-      int sourceLength,
+      size_t sourceLength,
       int channelNumber,
-      int startInChannel);
+      size_t startInChannel);
 
  private:
   std::shared_ptr<AudioBus> bus_;

package/common/cpp/core/AudioBufferSourceNode.cpp

@@ -16,10 +16,9 @@ AudioBufferSourceNode::AudioBufferSourceNode(BaseAudioContext *context)
       loopStart_(0),
       loopEnd_(0),
       vReadIndex_(0.0) {
-  numberOfInputs_ = 0;
   buffer_ = std::shared_ptr<AudioBuffer>(nullptr);
 
-  detuneParam_ = std::make_shared<AudioParam>(0.0, -MAX_DETUNE, MAX_DETUNE);
+  detuneParam_ = std::make_shared<AudioParam>(0.0, MIN_DETUNE, MAX_DETUNE);
   playbackRateParam_ = std::make_shared<AudioParam>(
       1.0, MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT);
 
@@ -73,7 +72,9 @@ void AudioBufferSourceNode::setBuffer(
 
   buffer_ = buffer;
   alignedBus_ = std::make_shared<AudioBus>(
-      context_->getSampleRate(), buffer_->getLength());
+      context_->getSampleRate(),
+      buffer_->getLength(),
+      buffer_->getNumberOfChannels());
 
   alignedBus_->zero();
   alignedBus_->sum(buffer_->bus_.get());
@@ -90,7 +91,7 @@ void AudioBufferSourceNode::processNode(
 
   // No audio data to fill, zero the output and return.
   if (!isPlaying() || !alignedBus_ || alignedBus_->getSize() == 0 ||
-      !playbackRate) {
+      playbackRate == 0.0f) {
     processingBus->zero();
     return;
   }
@@ -115,7 +116,7 @@ void AudioBufferSourceNode::processWithoutInterpolation(
     size_t startOffset,
     size_t offsetLength,
     float playbackRate) {
-  size_t direction = playbackRate < 0 ? -1 : 1;
+  size_t direction = playbackRate < 0.0f ? -1 : 1;
 
   auto readIndex = static_cast<size_t>(vReadIndex_);
   size_t writeIndex = startOffset;
@@ -165,7 +166,7 @@ void AudioBufferSourceNode::processWithoutInterpolation(
   }
 
   // update reading index for next render quantum
-  vReadIndex_ = readIndex;
+  vReadIndex_ = static_cast<double>(readIndex);
 }
 
 void AudioBufferSourceNode::processWithInterpolation(
@@ -173,13 +174,13 @@ void AudioBufferSourceNode::processWithInterpolation(
     size_t startOffset,
     size_t offsetLength,
     float playbackRate) {
-  size_t direction = playbackRate < 0 ? -1 : 1;
+  size_t direction = playbackRate < 0.0f ? -1 : 1;
 
   size_t writeIndex = startOffset;
 
-  double vFrameStart = getVirtualStartFrame();
-  double vFrameEnd = getVirtualEndFrame();
-  double vFrameDelta = vFrameEnd - vFrameStart;
+  auto vFrameStart = getVirtualStartFrame();
+  auto vFrameEnd = getVirtualEndFrame();
+  auto vFrameDelta = vFrameEnd - vFrameStart;
 
   auto frameStart = static_cast<size_t>(vFrameStart);
   auto frameEnd = static_cast<size_t>(vFrameEnd);
@@ -195,7 +196,8 @@ void AudioBufferSourceNode::processWithInterpolation(
   while (framesLeft > 0) {
     auto readIndex = static_cast<size_t>(vReadIndex_);
     size_t nextReadIndex = readIndex + 1;
-    float factor = vReadIndex_ - readIndex;
+    auto factor =
+        static_cast<float>(vReadIndex_ - static_cast<double>(readIndex));
 
     if (nextReadIndex >= frameEnd) {
       nextReadIndex = loop_ ? frameStart : readIndex;
@@ -210,11 +212,11 @@ void AudioBufferSourceNode::processWithInterpolation(
     }
 
     writeIndex += 1;
-    vReadIndex_ += playbackRate * direction;
+    vReadIndex_ += playbackRate * static_cast<double>(direction);
     framesLeft -= 1;
 
     if (vReadIndex_ < vFrameStart || vReadIndex_ >= vFrameEnd) {
-      vReadIndex_ -= direction * vFrameDelta;
+      vReadIndex_ -= static_cast<double>(direction) * vFrameDelta;
 
       if (!loop_) {
         processingBus->zero(writeIndex, framesLeft);
@@ -227,23 +229,26 @@ void AudioBufferSourceNode::processWithInterpolation(
 }
 
 float AudioBufferSourceNode::getPlaybackRateValue(size_t &startOffset) {
-  double time =
-      context_->getCurrentTime() + startOffset / context_->getSampleRate();
+  auto time = context_->getCurrentTime() +
+      static_cast<double>(startOffset) / context_->getSampleRate();
 
-  return playbackRateParam_->getValueAtTime(time) *
-      std::pow(2.0f, detuneParam_->getValueAtTime(time) / 1200.0f);
+  auto sampleRateFactor = buffer_->getSampleRate() / context_->getSampleRate();
+  auto detune = std::pow(2.0f, detuneParam_->getValueAtTime(time) / 1200.0f);
+  auto playbackRate = playbackRateParam_->getValueAtTime(time);
+
+  return playbackRate * sampleRateFactor * detune;
 }
 
 double AudioBufferSourceNode::getVirtualStartFrame() {
-  double loopStartFrame = loopStart_ * context_->getSampleRate();
+  auto loopStartFrame = loopStart_ * context_->getSampleRate();
 
   return loop_ && loopStartFrame >= 0 && loopStart_ < loopEnd_ ? loopStartFrame
                                                                : 0.0;
 }
 
 double AudioBufferSourceNode::getVirtualEndFrame() {
-  double inputBufferLength = alignedBus_->getSize();
-  double loopEndFrame = loopEnd_ * context_->getSampleRate();
+  auto inputBufferLength = static_cast<double>(alignedBus_->getSize());
+  auto loopEndFrame = loopEnd_ * context_->getSampleRate();
 
   return loop_ && loopEndFrame > 0 && loopStart_ < loopEnd_
       ? std::min(loopEndFrame, inputBufferLength)

package/common/cpp/core/AudioBufferSourceNode.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <memory>
+#include <cstddef>
 
 #include "AudioBuffer.h"
 #include "AudioScheduledSourceNode.h"

package/common/cpp/core/AudioBus.cpp

@@ -17,12 +17,8 @@ namespace audioapi {
 /**
  * Public interfaces - memory management
  */
-AudioBus::AudioBus(int sampleRate, int size)
-    : numberOfChannels_(CHANNEL_COUNT), sampleRate_(sampleRate), size_(size) {
-  createChannels();
-}
 
-AudioBus::AudioBus(int sampleRate, int size, int numberOfChannels)
+AudioBus::AudioBus(float sampleRate, size_t size, int numberOfChannels)
     : numberOfChannels_(numberOfChannels),
       sampleRate_(sampleRate),
       size_(size) {
@@ -41,11 +37,11 @@ int AudioBus::getNumberOfChannels() const {
   return numberOfChannels_;
 }
 
-int AudioBus::getSampleRate() const {
+float AudioBus::getSampleRate() const {
   return sampleRate_;
 }
 
-int AudioBus::getSize() const {
+size_t AudioBus::getSize() const {
   return size_;
 }
 
@@ -56,7 +52,7 @@ AudioArray *AudioBus::getChannel(int index) const {
 AudioArray *AudioBus::getChannelByType(int channelType) const {
   switch (getNumberOfChannels()) {
     case 1: // mono
-      if (channelType == ChannelMono || channelType == ChannelLeft) {
+      if (channelType == ChannelMono) {
         return getChannel(0);
       }
       return nullptr;
@@ -131,7 +127,7 @@ void AudioBus::zero() {
   zero(0, getSize());
 }
 
-void AudioBus::zero(int start, int length) {
+void AudioBus::zero(size_t start, size_t length) {
   for (auto it = channels_.begin(); it != channels_.end(); it += 1) {
     it->get()->zero(start, length);
   }
@@ -169,15 +165,15 @@ void AudioBus::sum(const AudioBus *source) {
   sum(source, 0, 0, getSize());
 }
 
-void AudioBus::sum(const AudioBus *source, int start, int length) {
+void AudioBus::sum(const AudioBus *source, size_t start, size_t length) {
   sum(source, start, start, length);
 }
 
 void AudioBus::sum(
     const AudioBus *source,
-    int sourceStart,
-    int destinationStart,
-    int length) {
+    size_t sourceStart,
+    size_t destinationStart,
+    size_t length) {
   if (source == this) {
     return;
   }
@@ -210,15 +206,15 @@ void AudioBus::copy(const AudioBus *source) {
   copy(source, 0, 0, getSize());
 }
 
-void AudioBus::copy(const AudioBus *source, int start, int length) {
+void AudioBus::copy(const AudioBus *source, size_t start, size_t length) {
   copy(source, start, start, length);
 }
 
 void AudioBus::copy(
     const AudioBus *source,
-    int sourceStart,
-    int destinationStart,
-    int length) {
+    size_t sourceStart,
+    size_t destinationStart,
+    size_t length) {
   if (source == this) {
     return;
   }
@@ -255,9 +251,9 @@ void AudioBus::createChannels() {
 
 void AudioBus::discreteSum(
     const AudioBus *source,
-    int sourceStart,
-    int destinationStart,
-    int length) const {
+    size_t sourceStart,
+    size_t destinationStart,
+    size_t length) const {
   int numberOfChannels =
       std::min(getNumberOfChannels(), source->getNumberOfChannels());
 
@@ -272,9 +268,9 @@ void AudioBus::discreteSum(
 
 void AudioBus::sumByUpMixing(
     const AudioBus *source,
-    int sourceStart,
-    int destinationStart,
-    int length) {
+    size_t sourceStart,
+    size_t destinationStart,
+    size_t length) {
   int numberOfSourceChannels = source->getNumberOfChannels();
   int numberOfChannels = getNumberOfChannels();
 
@@ -351,9 +347,9 @@ void AudioBus::sumByUpMixing(
 
 void AudioBus::sumByDownMixing(
     const AudioBus *source,
-    int sourceStart,
-    int destinationStart,
-    int length) {
+    size_t sourceStart,
+    size_t destinationStart,
+    size_t length) {
   int numberOfSourceChannels = source->getNumberOfChannels();
   int numberOfChannels = getNumberOfChannels();
 

package/common/cpp/core/AudioBus.h

@@ -3,6 +3,7 @@
 #include <algorithm>
 #include <memory>
 #include <vector>
+#include <cstddef>
 
 namespace audioapi {
 
@@ -21,14 +22,13 @@ class AudioBus {
     ChannelSurroundRight = 5,
   };
 
-  explicit AudioBus(int sampleRate, int size);
-  explicit AudioBus(int sampleRate, int size, int numberOfChannels);
+  explicit AudioBus(float sampleRate, size_t size, int numberOfChannels);
 
   ~AudioBus();
 
   [[nodiscard]] int getNumberOfChannels() const;
-  [[nodiscard]] int getSampleRate() const;
-  [[nodiscard]] int getSize() const;
+  [[nodiscard]] float getSampleRate() const;
+  [[nodiscard]] size_t getSize() const;
   [[nodiscard]] AudioArray *getChannel(int index) const;
   [[nodiscard]] AudioArray *getChannelByType(int channelType) const;
 
@@ -37,47 +37,47 @@ class AudioBus {
   [[nodiscard]] float maxAbsValue() const;
 
   void zero();
-  void zero(int start, int length);
+  void zero(size_t start, size_t length);
 
   void sum(const AudioBus *source);
-  void sum(const AudioBus *source, int start, int length);
+  void sum(const AudioBus *source, size_t start, size_t length);
   void sum(
       const AudioBus *source,
-      int sourceStart,
-      int destinationStart,
-      int length);
+      size_t sourceStart,
+      size_t destinationStart,
+      size_t length);
 
   void copy(const AudioBus *source);
-  void copy(const AudioBus *source, int start, int length);
+  void copy(const AudioBus *source, size_t start, size_t length);
   void copy(
       const AudioBus *source,
-      int sourceStart,
-      int destinationStart,
-      int length);
+      size_t sourceStart,
+      size_t destinationStart,
+      size_t length);
 
  private:
   std::vector<std::shared_ptr<AudioArray>> channels_;
 
   int numberOfChannels_;
-  int sampleRate_;
-  int size_;
+  float sampleRate_;
+  size_t size_;
 
   void createChannels();
   void discreteSum(
       const AudioBus *source,
-      int sourceStart,
-      int destinationStart,
-      int length) const;
+      size_t sourceStart,
+      size_t destinationStart,
+      size_t length) const;
   void sumByUpMixing(
       const AudioBus *source,
-      int sourceStart,
-      int destinationStart,
-      int length);
+      size_t sourceStart,
+      size_t destinationStart,
+      size_t length);
   void sumByDownMixing(
       const AudioBus *source,
-      int sourceStart,
-      int destinationStart,
-      int length);
+      size_t sourceStart,
+      size_t destinationStart,
+      size_t length);
 };
 
 } // namespace audioapi

package/common/cpp/core/AudioContext.cpp

@@ -21,7 +21,7 @@ AudioContext::AudioContext() : BaseAudioContext() {
   audioPlayer_->start();
 }
 
-AudioContext::AudioContext(int sampleRate) : BaseAudioContext() {
+AudioContext::AudioContext(float sampleRate) : BaseAudioContext() {
 #ifdef ANDROID
   audioPlayer_ = std::make_shared<AudioPlayer>(this->renderAudio(), sampleRate);
 #else

package/common/cpp/core/AudioContext.h

@@ -15,7 +15,7 @@ class IOSAudioPlayer;
 class AudioContext : public BaseAudioContext {
  public:
   AudioContext();
-  explicit AudioContext(int sampleRate);
+  explicit AudioContext(float sampleRate);
   ~AudioContext() override;
 
   void close();

package/common/cpp/core/AudioDecoder.h

@@ -8,12 +8,12 @@ class AudioBus;
 
 class AudioDecoder {
  public:
-  explicit AudioDecoder(int sampleRate) : sampleRate_(sampleRate) {}
+  explicit AudioDecoder(float sampleRate) : sampleRate_(sampleRate) {}
 
   [[nodiscard]] AudioBus *decodeWithFilePath(const std::string &path) const;
 
  private:
-  int sampleRate_;
+  float sampleRate_;
 };
 
 } // namespace audioapi

package/common/cpp/core/AudioDestinationNode.cpp

@@ -25,7 +25,7 @@ double AudioDestinationNode::getCurrentTime() const {
 
 void AudioDestinationNode::renderAudio(
     AudioBus *destinationBus,
-    int32_t numFrames) {
+    int numFrames) {
   if (!numFrames || !destinationBus || !isInitialized_) {
     return;
   }

package/common/cpp/core/AudioDestinationNode.h

@@ -3,6 +3,7 @@
 #include <algorithm>
 #include <memory>
 #include <vector>
+#include <cstddef>
 
 #include "AudioNode.h"
 
@@ -15,7 +16,7 @@ class AudioDestinationNode : public AudioNode {
  public:
   explicit AudioDestinationNode(BaseAudioContext *context);
 
-  void renderAudio(AudioBus *audioData, int32_t numFrames);
+  void renderAudio(AudioBus *audioData, int numFrames);
 
   std::size_t getCurrentSampleFrame() const;
   double getCurrentTime() const;

package/common/cpp/core/AudioNode.cpp

@@ -75,16 +75,16 @@ bool AudioNode::isEnabled() const {
 void AudioNode::enable() {
   isEnabled_ = true;
 
-  for (auto it = outputNodes_.begin(); it != outputNodes_.end(); ++it) {
-    it->get()->onInputEnabled();
+  for (auto &outputNode : outputNodes_) {
+    outputNode->onInputEnabled();
   }
 }
 
 void AudioNode::disable() {
   isEnabled_ = false;
 
-  for (auto it = outputNodes_.begin(); it != outputNodes_.end(); ++it) {
-    it->get()->onInputDisabled();
+  for (auto &outputNode : outputNodes_) {
+    outputNode->onInputDisabled();
   }
 }
 
@@ -166,12 +166,14 @@ AudioBus *AudioNode::processAudio(AudioBus *outputBus, int framesToProcess) {
       AudioBus *inputBus = (*it)->processAudio(processingBus, framesToProcess);
 
       if (inputBus != processingBus) {
+        // add assert
         processingBus->sum(inputBus);
       }
     } else {
       // Enforce the summing to be done using the internal bus.
-      AudioBus *inputBus = (*it)->processAudio(0, framesToProcess);
+      AudioBus *inputBus = (*it)->processAudio(nullptr, framesToProcess);
       if (inputBus) {
+        // add assert
         processingBus->sum(inputBus);
       }
     }

package/common/cpp/core/AudioNode.h

@@ -3,6 +3,7 @@
 #include <memory>
 #include <string>
 #include <vector>
+#include <cstddef>
 
 #include "ChannelCountMode.h"
 #include "ChannelInterpretation.h"
@@ -37,24 +38,22 @@ class AudioNode : public std::enable_shared_from_this<AudioNode> {
   BaseAudioContext *context_;
   std::shared_ptr<AudioBus> audioBus_;
 
-  int channelCount_ = CHANNEL_COUNT;
-
   int numberOfInputs_ = 1;
   int numberOfOutputs_ = 1;
-  int numberOfEnabledInputNodes_ = 0;
+  int channelCount_ = 2;
+  ChannelCountMode channelCountMode_ = ChannelCountMode::MAX;
+  ChannelInterpretation channelInterpretation_ =
+          ChannelInterpretation::SPEAKERS;
+
+    std::vector<AudioNode *> inputNodes_ = {};
+    std::vector<std::shared_ptr<AudioNode>> outputNodes_ = {};
 
+  int numberOfEnabledInputNodes_ = 0;
   bool isInitialized_ = false;
   bool isEnabled_ = true;
 
   std::size_t lastRenderedFrame_{SIZE_MAX};
 
-  ChannelCountMode channelCountMode_ = ChannelCountMode::MAX;
-  ChannelInterpretation channelInterpretation_ =
-      ChannelInterpretation::SPEAKERS;
-
-  std::vector<AudioNode *> inputNodes_ = {};
-  std::vector<std::shared_ptr<AudioNode>> outputNodes_ = {};
-
  private:
   static std::string toString(ChannelCountMode mode);
   static std::string toString(ChannelInterpretation interpretation);

package/common/cpp/core/AudioNodeManager.cpp

@@ -5,8 +5,6 @@
 
 namespace audioapi {
 
-AudioNodeManager::AudioNodeManager() {}
-
 AudioNodeManager::~AudioNodeManager() {
   audioNodesToConnect_.clear();
   sourceNodes_.clear();
@@ -18,7 +16,7 @@ void AudioNodeManager::addPendingConnection(
     ConnectionType type) {
   Locker lock(getGraphLock());
 
-  audioNodesToConnect_.push_back(std::make_tuple(from, to, type));
+  audioNodesToConnect_.emplace_back(from, to, type);
 }
 
 void AudioNodeManager::addSourceNode(const std::shared_ptr<AudioNode> &node) {

package/common/cpp/core/AudioNodeManager.h

@@ -12,7 +12,7 @@ class AudioNode;
 class AudioNodeManager {
  public:
   enum class ConnectionType { CONNECT, DISCONNECT };
-  AudioNodeManager();
+  AudioNodeManager() = default;
   ~AudioNodeManager();
 
   void preProcessGraph();

package/common/cpp/core/AudioParam.cpp

@@ -181,7 +181,7 @@ void AudioParam::setTargetAtTime(
 
 void AudioParam::setValueCurveAtTime(
     const float *values,
-    int length,
+    size_t length,
     double startTime,
     double duration) {
   if (startTime <= getQueueEndTime()) {
@@ -200,9 +200,12 @@ void AudioParam::setValueCurveAtTime(
 
     if (time < endTime) {
       auto k = static_cast<int>(std::floor(
-          (length - 1) / (endTime - startTime) * (time - startTime)));
+          static_cast<double>(length - 1) / (endTime - startTime) *
+          (time - startTime)));
       auto factor = static_cast<float>(
-          k - (time - startTime) * (length - 1) / (endTime - startTime));
+          k -
+          (time - startTime) * static_cast<double>(length - 1) /
+              (endTime - startTime));
 
       return AudioUtils::linearInterpolate(values, k, k + 1, factor);
     }

package/common/cpp/core/AudioParam.h

@@ -3,6 +3,7 @@
 #include <deque>
 #include <memory>
 #include <vector>
+#include <cstddef>
 
 #include "ParamChangeEvent.h"
 #include "ParamChangeEventType.h"
@@ -27,7 +28,7 @@ class AudioParam {
   void setTargetAtTime(float target, double startTime, double timeConstant);
   void setValueCurveAtTime(
       const float *values,
-      int length,
+      size_t length,
       double startTime,
       double duration);
   void cancelScheduledValues(double cancelTime);

package/common/cpp/core/AudioScheduledSourceNode.cpp

@@ -53,7 +53,7 @@ void AudioScheduledSourceNode::updatePlaybackInfo(
     return;
   }
 
-  int sampleRate = context_->getSampleRate();
+  auto sampleRate = context_->getSampleRate();
 
   size_t firstFrame = context_->getCurrentSampleFrame();
   size_t lastFrame = firstFrame + framesToProcess;