tracktion_RenderOptions.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.
*/
 
namespace tracktion { inline namespace engine
{
 
//==============================================================================
class RenderOptions  : private juce::ValueTree::Listener
{
public:
    enum TargetFileFormat
    {
        wav = 0,
        aiff,
        flac,
        ogg,
        mp3,
        midi,
        numFormats
    };
 
    enum AddRenderOptions
    {
        addTrack        = 0,
        replaceTrack    = 1,
        nextTrack       = 2,
        thisTrack       = 3,
        replaceClips    = 4,
        none            = 5,
    };
 
    //==============================================================================
    RenderOptions (Engine&);
    RenderOptions (const RenderOptions&, juce::UndoManager*);
    RenderOptions (Engine&, const juce::ValueTree&, juce::UndoManager*);
    ~RenderOptions() override;
 
    RenderOptions() = delete;
    RenderOptions (const RenderOptions&) = delete;
    RenderOptions (RenderOptions&&) = delete;
    RenderOptions operator= (const RenderOptions&) = delete;
    RenderOptions operator= (RenderOptions&&) = delete;
 
    void loadFromUserSettings();
    void saveToUserSettings();
    void setToDefault();
 
    //==============================================================================
    RenderManager::Job::Ptr performBackgroundRender (Edit&, SelectionManager*, TimeRange timeRangeToRender);
 
    //==============================================================================
    HashCode getHash() const noexcept                        { return hash; }
 
    Renderer::Parameters getRenderParameters (Edit&, SelectionManager*, TimeRange markedRegion);
    Renderer::Parameters getRenderParameters (Edit&);
    Renderer::Parameters getRenderParameters (EditClip&);
    Renderer::Parameters getRenderParameters (MidiClip&);
 
    juce::AudioFormat* getAudioFormat();
 
    Clip::Ptr applyRenderToEdit (Edit&, ProjectItem::Ptr, TimeRange time, SelectionManager*) const;
 
    //==============================================================================
    static std::unique_ptr<RenderOptions> forGeneralExporter (Edit&);
    static std::unique_ptr<RenderOptions> forTrackRender (juce::Array<Track*> tracks, AddRenderOptions addOption);
    static std::unique_ptr<RenderOptions> forClipRender (juce::Array<Clip*> clips, bool midiNotes);
    static std::unique_ptr<RenderOptions> forEditClip (Clip& editClip);
 
    //==============================================================================
    bool getUINeedsRefresh();
    void setUINeedsRefresh();
 
    //==============================================================================
    enum class RenderType
    {
        editClip = 0,
        clip,
        track,
        midi,
        allExport
    };
 
    bool isEditClipRender() const                               { return type == RenderType::editClip; }
    bool isClipRender() const                                   { return type == RenderType::clip; }
    bool isTrackRender() const                                  { return type == RenderType::track; }
    bool isMidiRender() const                                   { return type == RenderType::midi; }
    bool isExportAll() const                                    { return type == RenderType::allExport; }
    bool isRender() const                                       { return isTrackRender() || isClipRender() || isMidiRender(); }
 
    //==============================================================================
    TargetFileFormat setFormat (TargetFileFormat);
    void setFormatType (const juce::String& typeString);
    juce::String getFormatTypeName (TargetFileFormat);
 
    juce::Array<EditItemID> getTrackIDs() const                 { return tracks; }
    void setTrackIDs (const juce::Array<EditItemID>&);
    HashCode getTracksHash() const;
 
    void setSampleRate (int);
    void setBitDepth (int depth)                                { bitDepth = depth; }
 
    juce::StringArray getQualitiesList() const;
    int getQualityIndex() const                                 { return qualityIndex; }
    void setQualityIndex (int q)                                { qualityIndex = q; }
 
    juce::File getDestFile() const noexcept                     { return destFile; }
    juce::String getFileExtension() const;
 
    TargetFileFormat getFormat() const noexcept                 { return format; }
    int getBitDepth() const                                     { return bitDepth; }
    bool getStereo() const                                      { return stereo; }
    double getSampleRate() const                                { return sampleRate; }
    bool shouldAddMetadata() const                              { return addMetadata; }
 
    bool shouldAddAcidMetadata() const                          { return addAcidMetadata; }
 
    juce::BigInteger getTrackIndexes (const Edit&) const;
    bool getRemoveSilence() const noexcept                      { return removeSilence; }
    bool getMarkedRegion() const noexcept                       { return markedRegion; }
    int getNumTracks() const noexcept                           { return tracks.size(); }
 
    void setSelected (bool onlySelectedTrackAndClips);
    void setMarkedRegion (bool onlyMarked)                      { markedRegion = onlyMarked; }
    void setIncludePlugins (bool includePlugins)                { usePlugins = includePlugins; }
    void setAddRenderOption (AddRenderOptions options)          { addRenderOptions = options; }
    void setEndAllowance (TimeDuration time)                    { endAllowance = time; }
    void setFilename (juce::String, bool canPromptToOverwriteExisting);
    void updateHash();
 
    //==============================================================================
    juce::StringArray getFormatTypes();
    juce::StringArray getAddRenderOptionText();
 
    static TimeDuration findEndAllowance (Edit&, juce::Array<EditItemID>* tracks, juce::Array<Clip*>*);
    static bool isMarkedRegionBigEnough (TimeRange);
 
    Engine& engine;
 
    juce::CachedValue<RenderType> type;
    juce::CachedValue<juce::String> tracksProperty;
 
    juce::CachedValue<bool> createMidiFile;
    juce::CachedValue<TargetFileFormat> format;
    juce::CachedValue<bool> stereo;
    juce::CachedValue<double> sampleRate;
    juce::CachedValue<int> bitDepth, qualityIndex;
    juce::CachedValue<double> rmsLevelDb, peakLevelDb;
 
    juce::CachedValue<bool> removeSilence, normalise, dither, adjustBasedOnRMS,
                            markedRegion, selectedTracks, selectedClips,
                            tracksToSeparateFiles, realTime, usePlugins;
 
    juce::CachedValue<AddRenderOptions> addRenderOptions;
    juce::CachedValue<bool> addRenderToLibrary, reverseRender, addMetadata, addAcidMetadata;
 
    // These optional lambdas will be called when the addRenderToLibrary flag
    // is set, and can be used to do something with the finished item
    std::function<void(AudioClipBase&)> offerToAddClipToLibrary;
    std::function<void(const juce::File&)> offerToAddFileToLibrary;
 
private:
    //==============================================================================
    juce::ValueTree state;
 
    void relinkCachedValues (juce::UndoManager*);
 
    void valueTreePropertyChanged (juce::ValueTree&, const juce::Identifier&) override;
    void valueTreeChildAdded (juce::ValueTree&, juce::ValueTree&) override {}
    void valueTreeChildRemoved (juce::ValueTree&, juce::ValueTree&, int) override {}
    void valueTreeChildOrderChanged (juce::ValueTree&, int, int) override {}
    void valueTreeParentChanged (juce::ValueTree&) override {}
 
    //==============================================================================
    juce::Array<EditItemID> tracks;
    juce::File destFile;
    juce::Array<Clip*> allowedClips;
    TimeDuration endAllowance;
    HashCode hash = 0;
    bool uiNeedsRefresh = true;
 
    static void updateLastUsedRenderPath (RenderOptions&, const juce::String& itemID);
 
    //==============================================================================
    void updateFileName();
    void updateOptionsForFormat();
    void updateDefaultFilename (Edit*);
    juce::String getCurrentFileExtension();
};
 
}} // namespace tracktion { inline namespace engine
 
namespace juce
{
    template <>
    struct VariantConverter<tracktion::engine::RenderOptions::RenderType>
    {
        static tracktion::engine::RenderOptions::RenderType fromVar (const var& v)   { return (tracktion::engine::RenderOptions::RenderType) static_cast<int> (v); }
        static var toVar (tracktion::engine::RenderOptions::RenderType v)            { return static_cast<int> (v); }
    };
 
    template <>
    struct VariantConverter<tracktion::engine::RenderOptions::TargetFileFormat>
    {
        static tracktion::engine::RenderOptions::TargetFileFormat fromVar (const var& v)   { return (tracktion::engine::RenderOptions::TargetFileFormat) static_cast<int> (v); }
        static var toVar (tracktion::engine::RenderOptions::TargetFileFormat v)            { return static_cast<int> (v); }
    };
 
    template <>
    struct VariantConverter<tracktion::engine::RenderOptions::AddRenderOptions>
    {
        static tracktion::engine::RenderOptions::AddRenderOptions fromVar (const var& v)   { return (tracktion::engine::RenderOptions::AddRenderOptions) static_cast<int> (v); }
        static var toVar (tracktion::engine::RenderOptions::AddRenderOptions v)            { return static_cast<int> (v); }
    };
}