JUCE Framework Einführung

Adrachin:

Bist Du vertraut mit dem Juice Framework für audio plugin development?

LiquidGPT:

Das Juice Framework (JUCE) ist ein sehr populäres Framework zur Entwicklung von Audio-Plugins und -Anwendungen. Es wird häufig in der Audio-Software-Entwicklung eingesetzt, da es umfangreiche Funktionen und eine plattformübergreifende Unterstützung bietet.

JUCE bietet die Möglichkeit, VST-, AU- und AAX-Plugins sowie Standalone-Anwendungen zu erstellen. Es beinhaltet Module für Audioverarbeitung, GUI-Erstellung, MIDI-Handling und vieles mehr.

Hier ist ein einfacher Leitfaden, um mit JUCE zu beginnen:

Installation von JUCE

1. JUCE herunterladen:

   • Lade JUCE von der offiziellen Website herunter: JUCE Download.

2. Projucer einrichten:

   • Nach dem Herunterladen und Entpacken von JUCE, öffne den Projucer (eine Anwendung, die Projektdateien für verschiedene Plattformen generiert).

Ein einfaches Audio-Plugin-Projekt erstellen

1. Neues Projekt erstellen:

   • Öffne den Projucer und wähle „New Project“.
   • Wähle „Audio Plug-In“ als Projekttyp.

2. Projekt konfigurieren:

   • Gib dem Projekt einen Namen und wähle einen Speicherort.
   • Konfiguriere die gewünschten Plattformen (Windows, MacOS, Linux).

3. Projekt öffnen:

   • Nach dem Erstellen des Projekts kannst du es in deinem bevorzugten IDE (Visual Studio für dich) öffnen.

Code für ein einfaches Audio-Plugin

Hier ist ein Beispielcode für ein einfaches Gain-Plugin:

PluginProcessor.h:

#pragma once

#include <JuceHeader.h>

class SimpleGainAudioProcessor : public juce::AudioProcessor
{
public:
    SimpleGainAudioProcessor();
    ~SimpleGainAudioProcessor() override;

    void prepareToPlay (double sampleRate, int samplesPerBlock) override;
    void releaseResources() override;

    void processBlock (juce::AudioBuffer<float>&, juce::MidiBuffer&) override;

    juce::AudioProcessorEditor* createEditor() override;
    bool hasEditor() const override;

    const juce::String getName() const override;

    bool acceptsMidi() const override;
    bool producesMidi() const override;
    bool isMidiEffect() const override;
    double getTailLengthSeconds() const override;

    int getNumPrograms() override;
    int getCurrentProgram() override;
    void setCurrentProgram (int index) override;
    const juce::String getProgramName (int index) override;
    void changeProgramName (int index, const juce::String& newName) override;

    void getStateInformation (juce::MemoryBlock& destData) override;
    void setStateInformation (const void* data, int sizeInBytes) override;

private:
    float gain;
    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (SimpleGainAudioProcessor)
};

PluginProcessor.cpp:

#include "PluginProcessor.h"
#include "PluginEditor.h"

SimpleGainAudioProcessor::SimpleGainAudioProcessor()
#ifndef JucePlugin_PreferredChannelConfigurations
     : AudioProcessor (BusesProperties()
#if ! JucePlugin_IsMidiEffect
#if ! JucePlugin_IsSynth
                      .withInput ("Input", juce::AudioChannelSet::stereo(), true)
#endif
                      .withOutput ("Output", juce::AudioChannelSet::stereo(), true)
#endif
                      )
#endif
{
    gain = 1.0f;
}

SimpleGainAudioProcessor::~SimpleGainAudioProcessor() {}

void SimpleGainAudioProcessor::prepareToPlay (double sampleRate, int samplesPerBlock) {}

void SimpleGainAudioProcessor::releaseResources() {}

void SimpleGainAudioProcessor::processBlock (juce::AudioBuffer<float>& buffer, juce::MidiBuffer& midiMessages)
{
    juce::ScopedNoDenormals noDenormals;
    auto totalNumInputChannels  = getTotalNumInputChannels();
    auto totalNumOutputChannels = getTotalNumOutputChannels();

    for (auto i = totalNumInputChannels; i < totalNumOutputChannels; ++i)
        buffer.clear (i, 0, buffer.getNumSamples());

    for (int channel = 0; channel < totalNumInputChannels; ++channel)
    {
        auto* channelData = buffer.getWritePointer (channel);

        for (int sample = 0; sample < buffer.getNumSamples(); ++sample)
            channelData[sample] *= gain;
    }
}

bool SimpleGainAudioProcessor::hasEditor() const { return true; }
juce::AudioProcessorEditor* SimpleGainAudioProcessor::createEditor() { return new juce::GenericAudioProcessorEditor (*this); }

const juce::String SimpleGainAudioProcessor::getName() const { return JucePlugin_Name; }

bool SimpleGainAudioProcessor::acceptsMidi() const { return false; }
bool SimpleGainAudioProcessor::producesMidi() const { return false; }
bool SimpleGainAudioProcessor::isMidiEffect() const { return false; }
double SimpleGainAudioProcessor::getTailLengthSeconds() const { return 0.0; }

int SimpleGainAudioProcessor::getNumPrograms() { return 1; }
int SimpleGainAudioProcessor::getCurrentProgram() { return 0; }
void SimpleGainAudioProcessor::setCurrentProgram (int index) {}
const juce::String SimpleGainAudioProcessor::getProgramName (int index) { return {}; }
void SimpleGainAudioProcessor::changeProgramName (int index, const juce::String& newName) {}

void SimpleGainAudioProcessor::getStateInformation (juce::MemoryBlock& destData) {}
void SimpleGainAudioProcessor::setStateInformation (const void* data, int sizeInBytes) {}

Dieses Beispiel zeigt ein einfaches Gain-Plugin, das den Eingangs-Audiopegel multipliziert. Der gain-Wert kann später durch einen Parameter oder eine GUI-Komponente steuerbar gemacht werden.

Nächste Schritte

• GUI hinzufügen: Erstelle eine benutzerdefinierte GUI, um Parameter zu steuern.
• Parameter hinzufügen: Füge Parameter hinzu, um den Gain-Wert von der Benutzeroberfläche aus zu ändern.
• Testen: Baue und teste das Plugin in deiner bevorzugten DAW.

Falls du spezifische Fragen oder weitere Hilfe benötigst, lass es mich wissen!