MixerSource.h

Go to the documentation of this file.

/**********************************************************************
 
  Audacity: A Digital Audio Editor
 
  @file MixerSource.h
  @brief Fetches from tracks, applies envelopes, warps time, and resamples
 
  Dominic Mazzoni
  Markus Meyer
 
  Paul Licameli split from Mix.h
 
***********************************************************************/
#ifndef __AUDACITY_MIXER_SOURCE__
#define __AUDACITY_MIXER_SOURCE__
 
#include "AudioGraphSource.h"
#include "MixerOptions.h"
#include "SampleCount.h"
#include <memory>
 
class Resample;
class SampleTrack;
class WideSampleSequence;
 
 
class MixerSource final : public AudioGraph::Source {
public:
   using TimesAndSpeed = MixerOptions::TimesAndSpeed;
   using ResampleParameters = MixerOptions::ResampleParameters;
 
   MixerSource(const std::shared_ptr<const WideSampleSequence> &seq,
      size_t bufferSize,
      double rate, const MixerOptions::Warp &options, bool highQuality,
      bool mayThrow, std::shared_ptr<TimesAndSpeed> pTimesAndSpeed,
      const ArrayOf<bool> *pMap
   );
   MixerSource(MixerSource&&) = default;
   MixerSource &operator=(MixerSource&&) = delete;
   ~MixerSource();
 
   unsigned Channels() const { return mnChannels; }
   const WideSampleSequence &GetSequence() const;
   const bool *MixerSpec(unsigned iChannel) const;
 
   bool AcceptsBuffers(const Buffers &buffers) const override;
   bool AcceptsBlockSize(size_t blockSize) const override;
   std::optional<size_t> Acquire(Buffers &data, size_t bound) override;
   sampleCount Remaining() const override;
   bool Release() override;
   bool Terminates() const override;
   void Reposition(double time, bool skipping);
 
   bool VariableRates() const { return mResampleParameters.mVariableRates; }
 
private:
   void MakeResamplers();
 
   static constexpr size_t sProcessLen = 1024;
 
 
   static constexpr size_t sQueueMaxLen = 65536;
 
   size_t MixSameRate(unsigned nChannels, size_t maxOut, float *floatBuffers[]);
 
   size_t MixVariableRates(
      unsigned nChannels, size_t maxOut, float *floatBuffers[]);
 
   void ZeroFill(size_t produced, size_t max, float &floatBuffer);
 
   const std::shared_ptr<const WideSampleSequence> mpSeq;
   size_t i;
 
   const size_t mnChannels;
   const double mRate; // may require resampling
 
   const BoundedEnvelope *const mEnvelope; // for time warp which also resamples
   const bool mMayThrow;
 
   const std::shared_ptr<TimesAndSpeed> mTimesAndSpeed;
 
 
   sampleCount mSamplePos;
 
   std::vector<std::vector<float>> mSampleQueue;
 
   int mQueueStart;
 
   int mQueueLen;
 
   const ResampleParameters mResampleParameters;
   std::vector<std::unique_ptr<Resample>> mResample;
 
   std::vector<double> mEnvValues;
 
   const ArrayOf<bool> *const mpMap;
 
   unsigned mMaxChannels{};
   size_t mLastProduced{};
};
#endif