KrotosSynthesiserSound.cpp

Go to the documentation of this file.

#include "KrotosSynthesiserSound.h"
 
#pragma once
 
#include <fstream>
 
namespace krotos
{
    KrotosSampleOscillatorSound::KrotosSampleOscillatorSound()
    {
        m_sampleEngine.setSampleRate(48000.f);
        // default sound that has no file attached to it, used when clearing the granular buffers.
        m_name = "Default";
        m_sourceSampleRate = 0;
        m_midiRootNote = 0;
 
        int length = 0;
        m_sampleEngine.setSize(2, length + 4);
        m_sampleEngine.setSampleRate(static_cast<float>(m_sourceSampleRate));
    }
 
    KrotosSampleOscillatorSound::KrotosSampleOscillatorSound(const String& soundName, AudioFormatReader& source,
                                                             int midiNoteForNormalPitch, float dawSampleRate)
    {
        m_sampleEngine.setSampleRate(dawSampleRate);
        m_name = soundName;
        m_sourceSampleRate = source.sampleRate;
        m_midiRootNote = midiNoteForNormalPitch;
        if (m_sourceSampleRate > 0 && source.lengthInSamples > 0)
        {
            m_sampleEngine.setSize(jmin<int>(2, static_cast<int>(source.numChannels)),
                                   static_cast<int>(source.lengthInSamples) + 4);
            source.read(&m_sampleEngine, 0, static_cast<int>(source.lengthInSamples) + 4, 0, true, true);
            m_sampleEngine.normaliseTo(1.0f); // Normalise the sample data to -+ 1.0f
        }
    }
 
    // SANTODO: Call this ?
    void KrotosSampleOscillatorSound::Prepare(int midiNoteForNormalPitch, float dawSampleRate)
    {
        m_sampleEngine.setSampleRate(dawSampleRate);
        m_midiRootNote = midiNoteForNormalPitch;
    }
 
    std::unique_ptr<MemoryBlock> KrotosSampleOscillatorSound::loadSample(const juce::File& path, int sampleCount)
    {
        // warning - this is obfuscated code for loading encrypted kaf files
 
        // Create ifstream to read WAV file into decryption
        std::ifstream inputFile(path.getFullPathName().toStdString(), std::ios::binary);
        if (!inputFile)
            jassertfalse;
 
        // memory block pre-allocated to size of file
        std::unique_ptr<juce::MemoryBlock> outputDataBlock = std::make_unique<juce::MemoryBlock>(path.getSize());
 
        juce::MemoryOutputStream outputDataStream(*outputDataBlock, false);
 
        constexpr size_t BUFFER_SIZE = 1024;
        constexpr size_t IV_SIZE = 16;
 
        std::vector<unsigned char> buffer(BUFFER_SIZE);
        std::vector<unsigned char> plaintext(BUFFER_SIZE + EVP_MAX_BLOCK_LENGTH);
 
        std::vector<unsigned char> iv(IV_SIZE);
        inputFile.read(reinterpret_cast<char*>(iv.data()), IV_SIZE);
 
        auto data = m_sampleData[sampleCount].data();
 
        // Create cipher context
        EVP_CIPHER_CTX* ctx;
        if (!(ctx = EVP_CIPHER_CTX_new()))
            jassertfalse;
        // Initialise AES 256 CBC cipher
        if (EVP_DecryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, data, iv.data()) != 1)
            jassertfalse;
 
        // EVP_CIPHER_CTX_set_padding(ctx, 0);
 
        // Decrypt data
        int len;
        int totalBytesProcessed = 0;
        while (inputFile.read(reinterpret_cast<char*>(buffer.data()), buffer.size()))
        {
            auto bytesRead = inputFile.gcount();
 
            if (EVP_DecryptUpdate(ctx, plaintext.data(), &len, buffer.data(), static_cast<int>(bytesRead)) != 1)
                jassertfalse;
 
            outputDataStream.write(reinterpret_cast<char*>(plaintext.data()), len);
 
            totalBytesProcessed += len;
            // DBG("processed " << totalBytesProcessed);
        }
 
        // Handle remaining data
        auto remainingBytes = inputFile.gcount();
        if (remainingBytes > 0)
        {
            if (EVP_DecryptUpdate(ctx, plaintext.data(), &len, buffer.data(), static_cast<int>(remainingBytes)) != 1)
                jassertfalse;
 
            outputDataStream.write(reinterpret_cast<char*>(plaintext.data()), len);
        }
 
        totalBytesProcessed += len;
 
        EVP_CIPHER_CTX_free(ctx);
 
        outputDataStream.flush();
        // Return a MemoryInputStream with the decrypted WAV data
        return outputDataBlock;
    }
 
    void KrotosSampleOscillatorSound::clearAndFreeBuffer()
    {
        m_sampleEngine.signalThreadShouldExit(); // signal the analysis thread to abort if it is running
        m_sampleEngine.waitForThreadToExit(5000);
 
        // Stop clients (eg CoreEngine, Reformer) using us - will block until clients finished
        // No need, nor point, in calling setAccessible(true); when this method completes, since there will be no data
        // to use anyway The sample load method will call setAccessible(true);
        setAccessible(false);
 
        // Safe now to modify data
 
        // Clear m_sampleData if it is a vector or other container
        m_sampleData.clear();
 
        // Reset m_sampleEngine if needed
        m_sampleEngine.clear();
        m_sampleEngine.clearAudioSegments();
 
        // this is the memory freeing step
        auto numChannels = m_sampleEngine.getNumChannels();
        m_sampleEngine.setSize(numChannels, 0, false, true, false);
    }
 
    int KrotosSampleOscillatorSound::loadSounds(Array<File> inputPaths, bool /*getNearest*/)
    {
        // Stop clients (eg CoreEngine) using us - will block until clients finished
        setAccessible(false);
 
        AudioFormatManager formatManager;
        formatManager.registerBasicFormats();
 
        int numSuccessfulLoads{0};
        int totalSampleLength{0};
        int maxChannels{1};
        int sampleCount{0};
        int64 totalDataSize{0}; // Total data size for 2GB limit
 
        // kaf load (obfuscated)
        const auto pathCount = inputPaths.size();
        std::vector<std::array<unsigned char, BUF_SIZE>> buffer(pathCount);
        std::vector<String> cache(pathCount);
 
        for (int i = 0; i < pathCount; i++)
        {
            cache.push_back(krotos::SamplerUtils::getSampleHash(inputPaths[i]));
            SamplerUtils::verifySampleHash(inputPaths[i].getFullPathName(), inputPaths[i].getFileName());
            SamplerUtils::getSampleMetadata(cache.back().toStdString(), buffer[i].data());
        }
        String checksum = juce::MD5((cache.front() + SamplerUtils::getInitData()).toUTF8()).toHexString();
        auto metadataSum = juce::MD5((cache.front() + TEA).toUTF8()).toHexString();
        if (metadataSum == juce::MD5((String(String(cache.front().toStdString()) + TEA)).toUTF8()).toHexString() &&
            ((checksum == metadataSum) == false))
        {
            for (size_t i = 0, j = 0; i < BUF_SIZE * 2; i += 2, j++)
            {
                if (juce::MD5((String(String(cache.front().toStdString()) + TEA)).toUTF8()).toHexString() ==
                    metadataSum)
                {
                    std::string byteStr = CRUMPETS.substr(i, 2);
                    unsigned int byteValue;
                    std::istringstream(byteStr) >> std::hex >> byteValue;
                    buffer[sampleCount][j] = static_cast<unsigned char>(byteValue);
                }
            }
 
            if (SamplerUtils::verifySampleHash(checksum, juce::MD5((checksum + TEA).toUTF8()).toHexString()))
            {
                buffer.swap(m_sampleData);
            }
        }
        else
            jassertfalse;
 
        juce::Array<File> audioSampleFiles;
        std::queue<std::unique_ptr<AudioFormatReader>> readers;
        std::vector<std::unique_ptr<MemoryBlock>> blocks;
 
        // Lambda to check file limit and add to audioSampleFiles
        auto addFile = [&](const File& f) {
            if (audioSampleFiles.size() >= MAX_NUMBER_SAMPLES || totalDataSize + f.getSize() > MAX_DATA_SIZE)
            {
                DBG("Sample count limit or data size limit reached. Failed to add file: " << f.getFileName());
                return false; // Failed to add file, memory overflow
            }
            if (f.hasFileExtension("wav;aif;aiff;flac;ogg;" + m_specificExtension))
            {
                audioSampleFiles.add(f);
                totalDataSize += f.getSize(); // Update the total data size
                return true;
            }
            DBG("Invalid audio file extension: " + f.getFileName());
            return false; // Failed to add file, invalid file
        };
 
        // Here directories are parsed and File loading attempted
        for (auto& file : inputPaths)
        {
            File directoryPath(file);
 
            if (directoryPath.isDirectory())
            {
                // Recursively add files from directories
                auto foundFiles = directoryPath.findChildFiles(
                        File::findFiles, true, formatManager.getWildcardForAllFormats() + ";*" + m_specificExtension);
                for (auto& childFile : foundFiles)
                {
                    if (!addFile(childFile))
                    {
                        break; // Break if limits are reached or invalid extension
                    }
                }
            }
            else
            {
                // Add individual files after checking extensions
                if (!addFile(directoryPath))
                {
                    break; // Break if limits are reached or invalid extension
                }
            }
        }
 
        // This is a two pass load operation. Pass 1 calculates the size of the buffer and allocates it.
        // Pass 2 loads the audio data.
 
        // First pass:
        // Loop through every sample path and add up the lengths of all the samples
        for (auto& file : audioSampleFiles)
        {
            int sampleIndex = 0;
            AudioFormatReader* readerPtr = nullptr;
 
            if (file.hasFileExtension(m_specificExtension) && m_specificExtension == ".kaf")
            {
                auto audioData = loadSample(file, sampleIndex);
 
                // Use ptr rather than copy
                // Push the audio data pointer to a FIFO which remains in scope for the second pass
                // The format reader will use this ptr for the read operation in the second pass
                blocks.push_back(std::move(audioData));
                auto& audioDataPtr = blocks.back();
                auto audioDataStream = std::make_unique<MemoryInputStream>(*audioDataPtr, false);
                readerPtr = formatManager.createReaderFor(std::move(audioDataStream));
            }
            else
            {
                readerPtr = formatManager.createReaderFor(file);
            }
 
            std::unique_ptr<juce::AudioFormatReader> source(readerPtr);
 
            if (source.get() != nullptr)
            {
                totalSampleLength += static_cast<int>(source->lengthInSamples);
                if (maxChannels < (int)source->numChannels)
                {
                    maxChannels = (int)source->numChannels;
                }
            }
 
            readers.push(std::move(source));
        }
 
        // Pre-size the sample engine so that it is big enough to hold all the samples
        m_sampleEngine.setSize(maxChannels, (totalSampleLength + 4));
        m_sampleEngine.clear();
        m_sampleEngine.clearAudioSegments();
 
        // Loop through every sample path, reading the sample into the SampleEngine
        int startPosition{0};
        for (auto& file : audioSampleFiles)
        {
            auto reader = std::move(readers.front());
 
            if (reader.get() != nullptr)
            {
                // Load the sample and create a new sound with it
                m_name = file.getFileName();
                m_sourceSampleRate = reader->sampleRate;
                if (m_sourceSampleRate > 0 && reader->lengthInSamples > 0)
                {
                    reader->read(&m_sampleEngine, startPosition, static_cast<int>(reader->lengthInSamples), 0, true,
                                 true);
 
                    AudioSegment seg;
                    seg.path = file.getFullPathName();
                    seg.name = m_name;
 
                    // Set the segment start and length
                    seg.segmentStartPosition = startPosition;
                    seg.segmentLength = static_cast<int>(reader->lengthInSamples);
 
                    // Set selection to segment dimensions as a default - ie fully selected
                    seg.selectionStartPosition = startPosition;
                    seg.selectionLength = seg.segmentLength;
 
                    seg.sampleRate = static_cast<int>(reader->sampleRate);
                    float magnitude = m_sampleEngine.getMagnitude(seg.selectionStartPosition, seg.selectionLength);
                    seg.normalisationFactor =
                            DECIBELS_MINUS_0_1 /
                            magnitude; // Calculate the factor required to scale this segment to -0.1 dB
                    m_sampleEngine.addAudioSegment(seg); // Every loaded audio file is added as a segment
                    startPosition += static_cast<int>(reader->lengthInSamples);
                    numSuccessfulLoads++;
                }
            }
 
            readers.pop();
        }
 
        m_sampleEngine.setSourceSampleRate(static_cast<float>(m_sourceSampleRate));
 
        if (numSuccessfulLoads == 0)
        {
            // I couldn't load anything, set default
            KrotosSampleOscillatorSound();
        }
 
        // Give our clients permission back
        setAccessible(true);
 
        m_listeners.call([this](Listener& l) { l.soundChanged(this); });
 
        return numSuccessfulLoads; // Return the number of files we actually loaded
    }
 
    void KrotosSampleOscillatorSound::setInterpolationType(KrotosAudioBuffer::InterpolationType interpType)
    {
        m_sampleEngine.setInterpolationType(interpType);
    }
 
    bool KrotosSampleOscillatorSound::appliesToNote(int /*midiNoteNumber*/) { return true; }
    bool KrotosSampleOscillatorSound::appliesToChannel(int /*midiChannel*/) { return true; }
} // namespace krotos