PresetBundler.cpp

Go to the documentation of this file.

namespace krotos
{
    const String PresetBundler::PresetSubdirectory{"Presets"};
    const String PresetBundler::AudioAssetsSubdirectory{"Audio Assets"};
    const String PresetBundler::BundleFileExtension{".kspb"};
 
    String PresetBundler::m_presetFileExtension{".ksp"};
 
    PresetBundler::PresetBundler(File preset)
    {
        String presetString = preset.loadFileAsString();
        ValueTree presetData = ValueTree::fromXml(presetString);
        initialise(presetData);
    }
 
    PresetBundler::PresetBundler(ValueTree presetData) { initialise(presetData); }
 
    void PresetBundler::initialise(ValueTree presetData)
    {
        if (presetData.isValid() == false)
        {
            throw PresetException("Invalid preset value tree", "initialisation");
        }
        m_factoryAssetsDirectory = AssetManager::getAssetDirectory().getFullPathName();
        m_presetFile = presetData;
        m_assetFilepaths = getAssetsListFromPreset();
        clenseExportIDs(); // ensures filenames are compatible with windows OS
        // set a unique root ID for the bundle build folder in case multiple instances are exporting
        m_bundleRootId = "presetbundler" + Uuid().toString();
    }
 
    bool PresetBundler::createBundle(File outputLocation, String& errors)
    {
        bool bundleCreated(false);
 
        const bool fileStructureExists(createBundleFileStructure());
        if (fileStructureExists == false)
        {
            errors = "Failed to create bundle. Unable to make temp file " + getExportBundleRoot().getFullPathName();
            return bundleCreated; // No need to continue from here
        }
        const bool bundleAssetsTooBig(getEstimatedAssetsSizeMB() > m_maxSizeMegaBytes);
        if (bundleAssetsTooBig)
        {
            int bundleSize = getEstimatedAssetsSizeMB();
            errors = "Audio files are too large - preset size over the size limit by " +
                     String(m_maxSizeMegaBytes - bundleSize) + "MB";
        }
        else
        {
            String anyMissingFiles = listMissingFiles();
            if (anyMissingFiles.isNotEmpty())
            {
                errors = "Files used in this preset could not be found:\n" + anyMissingFiles;
                // annoying but won't necessary break a preset
            }
 
            copyAudioAssetsForExport();
            String exportedPresetFileName = outputLocation.getFileNameWithoutExtension() + m_presetFileExtension;
            File exportPreset = copyPresetForExport(exportedPresetFileName);
            processExportedPresetFile(exportPreset);
 
            File bundleFile = buildBundleArchive(outputLocation.getFullPathName());
            if (bundleFile.getFullPathName().isNotEmpty() && bundleFile.exists())
            {
                bundleCreated = true;
            }
            else
            {
                errors = "\nThe export bundle could not be created, "
                         "this might be caused by the chosen output folder becoming inaccessible or by lack of "
                         "available memory";
            }
        }
        cleanUpFileStructure();
 
        return bundleCreated;
    }
 
    File PresetBundler::openBundle(File bundleFile)
    {
        jassert(bundleFile.hasFileExtension(BundleFileExtension));
        jassert(bundleFile.existsAsFile());
 
        ZipFile bundleZip(bundleFile);
        File bundleRoot = getSandboxDirectoryForBundle(bundleFile);
        bundleRoot.deleteRecursively();
        auto uncompressResult = bundleZip.uncompressTo(bundleRoot);
        if (uncompressResult.failed())
        {
            throw PresetException("Krotos Studio was unable to open the bundle file.",
                                  uncompressResult.getErrorMessage());
        }
        auto validBundle = validateBundleDirectory(bundleRoot);
        if (!validBundle)
        {
            throw PresetException("The file does not appear to be a valid Krotos Studio preset bundle.", "openBundle");
        }
        return bundleRoot;
    }
 
    bool PresetBundler::validateBundleDirectory(File bundleDirectory)
    {
        bool validBundle(false);
        if (bundleDirectory.isDirectory())
        {
            File presetFile = getPresetFromBundleDirectory(bundleDirectory);
            validBundle |= presetFile.hasFileExtension(m_presetFileExtension);
 
            File presetDir = bundleDirectory.getChildFile(PresetSubdirectory);
            validBundle |= presetDir.isDirectory();
 
            File audioAssetsDir = bundleDirectory.getChildFile(AudioAssetsSubdirectory);
            validBundle |= audioAssetsDir.isDirectory();
        }
        return validBundle;
    }
 
    File PresetBundler::getPresetFromBundleDirectory(File bundleRoot)
    {
        File presetFile = bundleRoot.getChildFile(PresetSubdirectory).findChildFiles(File::findFiles, true)[0];
        jassert(presetFile.hasFileExtension(m_presetFileExtension));
        return presetFile;
    }
 
    File PresetBundler::copyPresetForExport(String nameForPresetFile)
    {
        File presetDirectory(getExportBundleRoot().getChildFile(PresetSubdirectory));
        File presetFileDestination(
                getExportBundleRoot().getChildFile(PresetSubdirectory).getChildFile(nameForPresetFile));
        if (presetDirectory.isDirectory())
        {
            m_presetFile.createXml()->writeTo(presetFileDestination);
        }
        return presetFileDestination;
    }
 
    void PresetBundler::copyAudioAssetsForExport()
    {
        const File audioAssetDirectory(getExportBundleRoot().getChildFile(AudioAssetsSubdirectory));
        if (audioAssetDirectory.isDirectory())
        {
            for (auto asset : m_assetFilepaths)
            {
                const File fileSource(asset.assetPath);
                const File fileDestination(audioAssetDirectory.getFullPathName() + File::getSeparatorChar() +
                                           asset.assetID);
                if (fileSource.existsAsFile())
                {
                    if (fileDestination.getParentDirectory().createDirectory().wasOk())
                    {
                        fileSource.copyFileTo(fileDestination);
                    }
                }
            }
        }
    }
 
    File PresetBundler::getExportBundleRoot()
    {
        const File root(File::getSpecialLocation(File::SpecialLocationType::tempDirectory));
        const File bundleRoot = root.getChildFile(m_bundleRootId);
        return bundleRoot;
    }
 
    bool PresetBundler::createBundleFileStructure()
    {
        const File bundleRoot = getExportBundleRoot();
        const File presetDir(bundleRoot.getChildFile(PresetSubdirectory));
        const File audioAssetsDir(bundleRoot.getChildFile(AudioAssetsSubdirectory));
        const bool structureOkay(presetDir.createDirectory().wasOk() && audioAssetsDir.createDirectory().wasOk());
        return structureOkay;
    }
 
    void PresetBundler::cleanUpFileStructure()
    {
        const File bundleRoot(getExportBundleRoot());
        if (bundleRoot.exists())
        {
            bundleRoot.deleteRecursively();
        }
    }
 
    bool PresetBundler::isValueAudioFile(String value)
    {
        bool isAudioFile(false);
        StringArray audioFileTypes;
        audioFileTypes.addTokens(AssetManager::SupportedAudioTypes, ";", "\"");
        for (auto type : audioFileTypes)
        {
            if (value.toLowerCase().endsWith(type))
            {
                isAudioFile = true;
                break;
            }
        }
        return isAudioFile;
    }
 
    int PresetBundler::getEstimatedAssetsSizeMB()
    {
        int64 cumulativeSizeBytes(0);
        for (auto asset : m_assetFilepaths)
        {
            File file(asset.assetPath);
            cumulativeSizeBytes += file.getSize();
        }
        const int sizeInMB(cumulativeSizeBytes / (1024 * 1024));
        return sizeInMB;
    }
 
    void PresetBundler::getPresetFilepaths(StringArray& listOfFiles, XmlElement kwidgetElement)
    {
        for (auto* kwidget : kwidgetElement.getChildIterator())
        {
            // KST-2636: hotfix to remove IRs from inclusion in exported preset bundles
            if (kwidget->getStringAttribute(XmlType::Property::id).containsIgnoreCase(KwidgetFactory::KwidgetType::ConvolutionReverb))
            {
                continue;
            }
            
            // Some kwidgets will have child kwidgets
            auto anotherKwidgetsElem = kwidget->getChildByName(XmlType::Tag::kwidgets);
            if (anotherKwidgetsElem != nullptr)
            {
                getPresetFilepaths(listOfFiles, *anotherKwidgetsElem);
            }
            auto customParamsElem = kwidget->getChildByName(XmlType::Tag::customParams);
            if (customParamsElem != nullptr)
            {
                findPathAttributesRecursive(listOfFiles, *customParamsElem);
            }
        }
    }
 
    void PresetBundler::findPathAttributesRecursive(StringArray& listOfFiles, XmlElement customParamsElement)
    {
        const int attributes = customParamsElement.getNumAttributes();
        for (int i = 0; i < attributes; i++)
        {
            String value = customParamsElement.getAttributeValue(i);
            if (isValueAudioFile(value))
            {
                // sometimes a value is multiple paths separated by newlines
                if (isValueMultipleFiles(value))
                {
                    StringArray values = StringArray::fromLines(value);
                    for (auto singleValue : values)
                    {
                        singleValue = convertFilepath(singleValue);
                        listOfFiles.addIfNotAlreadyThere(singleValue);
                    }
                }
                else
                {
                    value = convertFilepath(value);
                    listOfFiles.addIfNotAlreadyThere(value);
                }
            }
        }
        // some custom parameters will have child tags i.e. SAMPLES
        for (auto* customParamElem : customParamsElement.getChildIterator())
        {
            findPathAttributesRecursive(listOfFiles, *customParamElem);
        }
    }
 
    std::vector<PresetBundler::AudioAsset> PresetBundler::getAssetsListFromPreset()
    {
        std::vector<AudioAsset> assetsFound;
        StringArray audioAssetsPaths;
        auto presetDataElem = m_presetFile.createXml();
        if (presetDataElem != nullptr)
        {
            auto kwidgetsElem = presetDataElem->getChildByName(XmlType::Tag::kwidgets);
            if (kwidgetsElem != nullptr)
            {
                getPresetFilepaths(audioAssetsPaths, *kwidgetsElem);
            }
 
            // assign asset IDs
            int assetId(0);
            for (String path : audioAssetsPaths)
            {
                AudioAsset newAsset;
                newAsset.assetPath = path;
                String slash = File::getSeparatorString();
                newAsset.assetID = "Asset" + String(++assetId) + slash + File(path).getFileName();
                assetsFound.push_back(newAsset);
            }
        }
        return assetsFound;
    }
 
    void PresetBundler::processExportedPresetFile(File exportPreset)
    {
        if (exportPreset.existsAsFile())
        {
            auto presetDataElem = XmlDocument::parse(exportPreset);
            auto kwidgetsElem = presetDataElem->getChildByName(XmlType::Tag::kwidgets);
            if (kwidgetsElem != nullptr)
            {
                replacePaths(*kwidgetsElem);
                presetDataElem->writeTo(exportPreset);
            }
        }
    }
 
    void PresetBundler::replacePaths(XmlElement& kwidgetElement)
    {
        for (auto* kwidgetIterator : kwidgetElement.getChildIterator())
        {
            // Some kwidgets will have child kwidgets
            auto anotherKwidgetsElem = kwidgetIterator->getChildByName(XmlType::Tag::kwidgets);
            if (anotherKwidgetsElem != nullptr)
            {
                replacePaths(*anotherKwidgetsElem);
            }
            auto customParamsElem = kwidgetIterator->getChildByName(XmlType::Tag::customParams);
            if (customParamsElem != nullptr)
            {
                replacePathRecursive(*customParamsElem);
            }
        }
    }
    void PresetBundler::replacePathRecursive(XmlElement& customParamsElement)
    {
        const int attributes = customParamsElement.getNumAttributes();
        for (int i = 0; i < attributes; i++)
        {
            String value = customParamsElement.getAttributeValue(i);
            if (isValueAudioFile(value) == false)
            {
                continue;
            }
            for (auto asset : m_assetFilepaths)
            {
                const String attributeName = customParamsElement.getAttributeName(i);
 
                if (AssetManager::convertFilePathString(value) == AssetManager::convertFilePathString(asset.assetPath))
                {
                    customParamsElement.setAttribute(attributeName, asset.assetID);
                    break;
                }
            }
        }
        // some custom parameters will have child tags i.e. SAMPLES
        for (auto* customParamChild : customParamsElement.getChildIterator())
        {
            replacePathRecursive(*customParamChild);
        }
    }
 
    File PresetBundler::buildBundleArchive(String outputFilePath)
    {
        File archiveFile(outputFilePath);
        if (archiveFile.exists())
        {
            archiveFile.deleteFile();
        }
        const int compressionLevel(0);
        ZipFile::Builder zipBuilder;
 
        auto files = File(getExportBundleRoot()).findChildFiles(File::findFiles, /*recurs*/ true);
        for (auto file : files)
        {
            zipBuilder.addFile(file, compressionLevel, file.getRelativePathFrom(getExportBundleRoot()));
        }
 
        FileOutputStream archiveStream(archiveFile);
        bool success = zipBuilder.writeToStream(archiveStream, nullptr);
        return success ? archiveFile : File();
    }
 
    String PresetBundler::listMissingFiles()
    {
        String missingAssets;
        for (auto asset : m_assetFilepaths)
        {
            String filePath = AssetManager::convertFilePathString(asset.assetPath);
            File file(filePath);
            if (file.existsAsFile() == false)
            {
                missingAssets += filePath + "\n";
            }
        }
        return missingAssets;
    }
 
    void PresetBundler::clenseExportIDs()
    {
        for (auto& asset : m_assetFilepaths)
        {
            String subfolder = asset.assetID.upToFirstOccurrenceOf(File::getSeparatorString(),
                                                                   /*include slash*/ true, /*ignoreCase*/ false);
            String filename = asset.assetID.fromLastOccurrenceOf(File::getSeparatorString(),
                                                                 /*include slash*/ false, /*ignoreCase*/ false);
            // https://learn.microsoft.com/en-us/windows/win32/fileio/naming-a-file
            asset.assetID = subfolder + File::createLegalFileName(filename);
        }
    }
 
    void PresetBundler::setPresetFileExtension(String fileExtension) { m_presetFileExtension = fileExtension; }
 
    File PresetBundler::getSandboxDirectory()
    {
        return AssetManager::getUserDataDirectory().getFullPathName() + File::getSeparatorString() + "BundleImport";
    }
 
    File PresetBundler::getSandboxDirectoryForBundle(const File& bundleFile)
    {
        return getSandboxDirectory().getChildFile(File::createLegalFileName(bundleFile.getFileNameWithoutExtension()));
    }
 
    File PresetBundler::getAudioAssetDirectoryForBundle(const File& bundleFile)
    {
        return getSandboxDirectoryForBundle(bundleFile).getChildFile(AudioAssetsSubdirectory);
    }
 
    File PresetBundler::getPresetDirectoryForBundle(const File& bundleFile)
    {
        return getSandboxDirectoryForBundle(bundleFile).getChildFile(PresetSubdirectory);
    }
 
    bool PresetBundler::isABundlePreset(const File& preset)
    {
        return preset.isAChildOf(PresetBundler::getSandboxDirectory());
    }
 
    bool PresetBundler::isValueMultipleFiles(String value) { return value.containsChar('\n'); }
 
    String PresetBundler::convertFilepath(String filepathFromPreset)
    {
        filepathFromPreset = AssetManager::convertFilePathString(filepathFromPreset);
        if (File file(filepathFromPreset); file.existsAsFile() == false)
        {
            // If file does not exist, then check if user has a custom factory assets path
            String subPath(filepathFromPreset.fromFirstOccurrenceOf("Factory Assets" + File::getSeparatorString(),
                                                                    /*includeSubString*/ false, /*ignoreCase*/ false));
            String customAssetFilepath(utils::StringsIntoPath(m_factoryAssetsDirectory, subPath));
            File customFile(customAssetFilepath);
            const String kafFile{".kaf"};
            if (customFile.existsAsFile())
            {
                filepathFromPreset = customAssetFilepath;
            }
            // .kaf interoperability support
            else if (customFile.withFileExtension(kafFile).existsAsFile())
            {
                filepathFromPreset = customFile.withFileExtension(kafFile).getFullPathName();
            }
        }
        return filepathFromPreset;
    }
} // namespace krotos