Как получить доступ к аудиоданным с хоста JUCE Demo Audio Plugin?

Question

Я работаю над проектом, который требует, чтобы я записывал аудиоданные в виде файлов.wav (по 1 секунде каждый) из плагина MIDI Synth, загруженного на хост JUCE Demo Audio Plugin. По сути, мне нужно автоматически создать набор данных (соответствующий различным настройкам параметров) из MIDI Synth.

Должен ли я отправлять сообщения MIDI Note On/Off для создания аудиоданных? Или есть лучший способ получить аудио данные?

AudioBuffer<FloatType> getBusBuffer (AudioBuffer<FloatType>& processBlockBuffer) const

Это функция, которая решит мои потребности? Если да, как я буду хранить данные? Если нет, то может ли кто-нибудь подсказать мне правильную функцию / решение? Спасибо.

Answer 1

Я не совсем уверен, что вы спрашиваете, поэтому я буду догадываться:

Вам нужно программно запустить некоторые ноты MIDI в вашем синтезаторе, а затем записать все аудио в файл.wav, верно?

Предполагая, что вы уже знаете JUCE, было бы довольно тривиально создать приложение, которое открывает ваш плагин, отправляет MIDI и записывает аудио, но, вероятно, просто настроить AudioPluginHost проект.

Давайте разбить его на несколько простых шагов (сначала откройте AudioPluginHost проект):

1. Программно отправить MIDI

смотреть на GraphEditorPanel.hконкретно класс GraphDocumentComponent, У него есть закрытая переменная-член: MidiKeyboardState keyState;, Это собирает входящие MIDI-сообщения и затем вставляет их во входящий аудио и MIDI-буфер, который отправляется плагину.

Вы можете просто позвонить keyState.noteOn (midiChannel, midiNoteNumber, velocity) а также keyState.noteOff (midiChannel, midiNoteNumber, velocity) чтобы вызвать заметку.

2. Запись аудио выхода

Это довольно простая вещь в JUCE - вы должны начать с демонстрации JUCE. В следующем примере записывается вывод звука в фоновом режиме, но существует множество других способов сделать это:

class AudioRecorder  : public AudioIODeviceCallback
{
public:
    AudioRecorder (AudioThumbnail& thumbnailToUpdate)
        : thumbnail (thumbnailToUpdate)
    {
        backgroundThread.startThread();
    }

    ~AudioRecorder()
    {
        stop();
    }

    //==============================================================================
    void startRecording (const File& file)
    {
        stop();

        if (sampleRate > 0)
        {
            // Create an OutputStream to write to our destination file...
            file.deleteFile();
            ScopedPointer<FileOutputStream> fileStream (file.createOutputStream());

            if (fileStream.get() != nullptr)
            {
                // Now create a WAV writer object that writes to our output stream...
                WavAudioFormat wavFormat;
                auto* writer = wavFormat.createWriterFor (fileStream.get(), sampleRate, 1, 16, {}, 0);

                if (writer != nullptr)
                {
                    fileStream.release(); // (passes responsibility for deleting the stream to the writer object that is now using it)

                    // Now we'll create one of these helper objects which will act as a FIFO buffer, and will
                    // write the data to disk on our background thread.
                    threadedWriter.reset (new AudioFormatWriter::ThreadedWriter (writer, backgroundThread, 32768));

                    // Reset our recording thumbnail
                    thumbnail.reset (writer->getNumChannels(), writer->getSampleRate());
                    nextSampleNum = 0;

                    // And now, swap over our active writer pointer so that the audio callback will start using it..
                    const ScopedLock sl (writerLock);
                    activeWriter = threadedWriter.get();
                }
            }
        }
    }

    void stop()
    {
        // First, clear this pointer to stop the audio callback from using our writer object..
        {
            const ScopedLock sl (writerLock);
            activeWriter = nullptr;
        }

        // Now we can delete the writer object. It's done in this order because the deletion could
        // take a little time while remaining data gets flushed to disk, so it's best to avoid blocking
        // the audio callback while this happens.
        threadedWriter.reset();
    }

    bool isRecording() const
    {
        return activeWriter != nullptr;
    }

    //==============================================================================
    void audioDeviceAboutToStart (AudioIODevice* device) override
    {
        sampleRate = device->getCurrentSampleRate();
    }

    void audioDeviceStopped() override
    {
        sampleRate = 0;
    }

    void audioDeviceIOCallback (const float** inputChannelData, int numInputChannels,
                                float** outputChannelData, int numOutputChannels,
                                int numSamples) override
    {
        const ScopedLock sl (writerLock);

        if (activeWriter != nullptr && numInputChannels >= thumbnail.getNumChannels())
        {
            activeWriter->write (inputChannelData, numSamples);

            // Create an AudioBuffer to wrap our incoming data, note that this does no allocations or copies, it simply references our input data
            AudioBuffer<float> buffer (const_cast<float**> (inputChannelData), thumbnail.getNumChannels(), numSamples);
            thumbnail.addBlock (nextSampleNum, buffer, 0, numSamples);
            nextSampleNum += numSamples;
        }

        // We need to clear the output buffers, in case they're full of junk..
        for (int i = 0; i < numOutputChannels; ++i)
            if (outputChannelData[i] != nullptr)
                FloatVectorOperations::clear (outputChannelData[i], numSamples);
    }

private:
    AudioThumbnail& thumbnail;
    TimeSliceThread backgroundThread  { "Audio Recorder Thread" }; // the thread that will write our audio data to disk
    ScopedPointer<AudioFormatWriter::ThreadedWriter> threadedWriter; // the FIFO used to buffer the incoming data
    double sampleRate   = 0.0;
    int64 nextSampleNum = 0;

    CriticalSection writerLock;
    AudioFormatWriter::ThreadedWriter* volatile activeWriter = nullptr;
};

Обратите внимание, что фактические звуковые обратные вызовы, которые содержат аудиоданные из вашего плагина, происходят внутри AudioProcessorGraph внутри FilterGraph, Во время передачи необработанных аудиоданных много раз в секунду происходит звуковой обратный вызов. Вероятно, было бы очень грязно изменить это внутри AudioPluginHost если вы не знаете, что делаете - вероятно, было бы проще использовать что-то вроде приведенного выше примера или создать собственное приложение, которое имеет свой собственный аудиопоток.

Функция, о которой вы спрашивали:

AudioBuffer<FloatType> getBusBuffer (AudioBuffer<FloatType>& processBlockBuffer) const

не имеет значения. Если вы уже находитесь в режиме обратного вызова аудио, это даст вам звук, отправляемый на шину вашего плагина (иначе, если у вашего синтезатора есть боковая цепь). Вместо этого вы хотите взять звук, исходящий из обратного вызова, и передать его AudioFormatWriterили предпочтительно AudioFormatWriter::ThreadedWriter так что фактическая запись происходит в другом потоке.

Если вы совсем не знакомы с C++ или JUCE, Max/MSP или Pure Data может быть проще, если вы что-то быстро наберете.