tracktion_WaveNode.h

Go to the documentation of this file.

 /*
    ,--.                     ,--.     ,--.  ,--.
  ,-'  '-.,--.--.,--,--.,---.|  |,-.,-'  '-.`--' ,---. ,--,--,      Copyright 2024
  '-.  .-'|  .--' ,-.  | .--'|     /'-.  .-',--.| .-. ||      \   Tracktion Software
    |  |  |  |  \ '-'  \ `--.|  \  \  |  |  |  |' '-' '|  ||  |       Corporation
    `---' `--'   `--`--'`---'`--'`--' `---' `--' `---' `--''--'    www.tracktion.com
 
    Tracktion Engine uses a GPL/commercial licence - see LICENCE.md for details.
*/
 
#pragma once
 
#include "tracktion_SpeedRampWaveNode.h"
 
namespace tracktion { inline namespace engine
{
 
class TimeRangeRemappingReader;
class EditToClipBeatReader;
class EditToClipTimeReader;
class ResamplerReader;
class PitchAdjustReader;
class SpeedFadeEditReader;
 
struct WarpPoint
{
    TimePosition sourceTime, warpTime;
};
 
using WarpMap = std::vector<WarpPoint>;
 
//==============================================================================
//==============================================================================
class WaveNode final    : public tracktion::graph::Node,
                          public TracktionEngineNode
{
public:
    WaveNode (const AudioFile&,
              TimeRange editTime,
              TimeDuration offset,
              TimeRange loopSection,
              LiveClipLevel,
              double speedRatio,
              const juce::AudioChannelSet& sourceChannelsToUse,
              const juce::AudioChannelSet& destChannelsToFill,
              ProcessState&,
              EditItemID,
              bool isOfflineRender);
 
    //==============================================================================
    tracktion::graph::NodeProperties getNodeProperties() override;
    void prepareToPlay (const tracktion::graph::PlaybackInitialisationInfo&) override;
    bool isReadyToProcess() override;
    void process (ProcessContext&) override;
 
private:
    //==============================================================================
    TimeRange editPosition, loopSection;
    TimeDuration offset;
    double originalSpeedRatio = 0, outputSampleRate = 44100.0;
    const EditItemID editItemID;
    bool isOfflineRender = false;
 
    AudioFile audioFile;
    LiveClipLevel clipLevel;
    juce::Range<int64_t> editPositionInSamples;
    double audioFileSampleRate = 0;
    const juce::AudioChannelSet channelsToUse, destChannels;
    AudioFileCache::Reader::Ptr reader;
 
    struct PerChannelState;
    std::shared_ptr<juce::OwnedArray<PerChannelState>> channelState;
 
    int64_t editPositionToFileSample (int64_t) const noexcept;
    int64_t editTimeToFileSample (TimePosition) const noexcept;
    bool updateFileSampleRate();
    void replaceChannelStateIfPossible (NodeGraph*, int numChannelsToUse);
    void replaceChannelStateIfPossible (WaveNode&, int numChannelsToUse);
    void processSection (ProcessContext&, juce::Range<int64_t> timelineRange);
 
    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (WaveNode)
};
 
 
//==============================================================================
//==============================================================================
class WaveNodeRealTime final    : public graph::Node,
                                  public TracktionEngineNode,
                                  public DynamicallyOffsettableNodeBase
{
public:
    //==============================================================================
    enum class ReadAhead : bool { no, yes };
 
    //==============================================================================
    WaveNodeRealTime (const AudioFile&,
                      TimeRange editTime,
                      TimeDuration offset,
                      TimeRange loopSection,
                      LiveClipLevel,
                      double speedRatio,
                      const juce::AudioChannelSet& sourceChannelsToUse,
                      const juce::AudioChannelSet& destChannelsToFill,
                      ProcessState&,
                      EditItemID,
                      bool isOfflineRender,
                      ResamplingQuality = ResamplingQuality::lagrange,
                      SpeedFadeDescription = {},
                      std::optional<tempo::Sequence::Position> editTempoSequence = {},
                      TimeStretcher::Mode = TimeStretcher::Mode::defaultMode,
                      TimeStretcher::ElastiqueProOptions = {},
                      float pitchChangeSemitones = 0.0f,
                      ReadAhead = ReadAhead::no);
 
    //==============================================================================
    enum class SyncTempo : bool { no, yes };
 
    enum class SyncPitch : bool { no, yes };
 
    WaveNodeRealTime (const AudioFile&,
                      TimeStretcher::Mode,
                      TimeStretcher::ElastiqueProOptions,
                      BeatRange editTime,
                      BeatDuration offset,
                      BeatRange loopSection,
                      LiveClipLevel,
                      const juce::AudioChannelSet& sourceChannelsToUse,
                      const juce::AudioChannelSet& destChannelsToFill,
                      ProcessState&,
                      EditItemID,
                      bool isOfflineRender,
                      ResamplingQuality,
                      SpeedFadeDescription,
                      std::optional<tempo::Sequence::Position> editTempoSequence,
                      std::optional<WarpMap>,
                      tempo::Sequence sourceFileTempoMap,
                      SyncTempo, SyncPitch,
                      std::optional<tempo::Sequence> chordPitchSequence,
                      float pitchChangeSemitones = 1.0f,
                      ReadAhead = ReadAhead::no);
 
    //==============================================================================
    void setDynamicOffsetBeats (BeatDuration) override;
 
    //==============================================================================
    graph::NodeProperties getNodeProperties() override;
    void prepareToPlay (const graph::PlaybackInitialisationInfo&) override;
    bool isReadyToProcess() override;
    void process (ProcessContext&) override;
 
private:
    //==============================================================================
    BeatRange editPositionBeats, loopSectionBeats;
    BeatDuration offsetBeats;
    TimeRange editPositionTime, loopSectionTime;
    TimeDuration offsetTime;
    const double speedRatio = 1.0;
    const EditItemID editItemID;
    const bool isOfflineRender = false;
    const ResamplingQuality resamplingQuality;
 
    const AudioFile audioFile;
    const SpeedFadeDescription speedFadeDescription;
    const std::optional<tempo::Sequence::Position> editTempoSequence;
    std::optional<WarpMap> warpMap;
    TimeStretcher::Mode timeStretcherMode;
    TimeStretcher::ElastiqueProOptions elastiqueProOptions;
    LiveClipLevel clipLevel;
    const juce::AudioChannelSet channelsToUse, destChannels;
    float pitchChangeSemitones = 0.0;
    double outputSampleRate = 44100.0;
    int outputBlockSize = 0;
    bool isFirstBlock = false;
    const ReadAhead readAhead;
 
    size_t stateHash = 0;
    ResamplerReader* resamplerReader = nullptr;
    PitchAdjustReader* pitchAdjustReader = nullptr;
    std::shared_ptr<SpeedFadeEditReader> editReader;
    std::shared_ptr<std::vector<float>> channelState;
    std::shared_ptr<BeatDuration> dynamicOffsetBeats = std::make_shared<BeatDuration>();
 
    std::shared_ptr<tempo::Sequence> fileTempoSequence;
    std::shared_ptr<tempo::Sequence::Position> fileTempoPosition;
    SyncTempo syncTempo = SyncTempo::no;
    SyncPitch syncPitch = SyncPitch::no;
    std::shared_ptr<tempo::Sequence> chordPitchSequence;
    std::shared_ptr<tempo::Sequence::Position> chordPitchPosition;
 
    bool buildAudioReaderGraph();
    void replaceStateIfPossible (NodeGraph*);
    void replaceStateIfPossible (WaveNodeRealTime&);
    void processSection (ProcessContext&);
    tempo::Key getKeyToSyncTo (TimePosition) const;
 
    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (WaveNodeRealTime)
};
 
}} // namespace tracktion { inline namespace engine
 
#ifndef DOXYGEN
template<>
struct std::hash<tracktion::engine::WarpMap>
{
    size_t operator() (const tracktion::engine::WarpMap& w) const noexcept
    {
        size_t seed = 0;
 
        for (const auto& p : w)
        {
            tracktion::hash_combine (seed, p.sourceTime.inSeconds());
            tracktion::hash_combine (seed, p.warpTime.inSeconds());
        }
 
        return seed;
    }
};
#endif