shawn/op-pedal
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
84b9469896881385027dae05137af2eea778212b
op-pedal/src/PresetBundle.cpp
T
Robin E. R. Davies 7474c2531d Bunding of media files contained in snapshots.
2025-06-20 15:52:51 -04:00

733 lines
24 KiB
C++
Raw Blame History

// Copyright (c) 2024 Robin Davies
//
// Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in
// the Software without restriction, including without limitation the rights to
// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
// the Software, and to permit persons to whom the Software is furnished to do so,
// subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#include "PresetBundle.hpp"
#include "PiPedalModel.hpp"
#include <vector>
#include "Pedalboard.hpp"
#include "Banks.hpp"
#include "json.hpp"
#include <sstream>
#include "lv2/atom/atom.h"
#include "ZipFile.hpp"
#include <set>
using namespace pipedal;
static std::string ToString(const std::vector<uint8_t> &value)
{
const char *start = (const char *)(&value[0]);
const char *end = start + value.size();
while (end != start && end[-1] == 0)
{
--end;
}
return std::string(start, end);
}
static std::string ToJsonAtomPath(const std::string &path) {
json_variant v = json_variant::make_object();;
auto obj = v.as_object();
(*obj)["otype_"] = json_variant("Path");
(*obj)["value"] = json_variant(path);
std::ostringstream ss;
json_writer writer(ss);
writer.write(v);
return ss.str();
}
static bool TryGetAtomPath(const std::string &atomJson, std::string *outPath)
{
if (atomJson.empty())
return false;
std::stringstream ss(atomJson);
json_reader reader(ss);
json_variant vProperty;
reader.read(&vProperty);
if (vProperty.is_object())
{
auto obj = vProperty.as_object();
if (obj->contains("otype_") &&
(*obj)["otype_"].as_string() == "Path")
{
if (obj->contains("value"))
{
std::string value = (*obj)["value"].as_string();
if (!value.empty())
{
*outPath = value;
return true;
}
}
}
}
return false;
}
static std::vector<uint8_t> ToBinary(const std::string &value)
{
std::vector<uint8_t> result(value.length() + 1);
for (size_t i = 0; i < value.length(); ++i)
{
result[i] = (uint8_t)value[i];
}
result[value.length()] = 0;
return result;
}
class PresetBundleWriterImpl : public PresetBundleWriter
{
public:
using self = PresetBundleWriterImpl;
using super = PresetBundleWriter;
PresetBundleWriterImpl()
{
}
void LoadPresets(PiPedalModel &model, const std::string &presetJson)
{
pluginUploadDirectory = model.GetPluginUploadDirectory();
pluginUploadDirectoryString = pluginUploadDirectory.string();
BankFile bankFile;
std::istringstream s(presetJson);
json_reader reader(s);
reader.read(&bankFile);
GatherMediaPaths(model, bankFile);
configFiles["bankFile.json"] = presetJson;
}
void LoadPluginPresets(PiPedalModel &model, const std::string pluginPresetJson)
{
pluginUploadDirectory = model.GetPluginUploadDirectory();
pluginUploadDirectoryString = pluginUploadDirectory.string();
PluginPresets pluginPresets;
std::istringstream s(pluginPresetJson);
json_reader reader(s);
reader.read(&pluginPresets);
GatherMediaPaths(model, pluginPresets);
configFiles["pluginPresets.json"] = pluginPresetJson;
}
virtual ~PresetBundleWriterImpl() noexcept;
virtual void WriteToFile(const std::filesystem::path &filePath) override;
private:
void AddUsedPlugin(PiPedalModel &model, const std::string &pluginUri, const std::string &name);
std::string UnmapPath(const std::string &path);
std::string MapPath(const std::string &path);
bool IsValidMediaPath(const std::string &path);
void GatherMediaPaths(PiPedalModel &model, BankFile &bankFile);
void GatherMediaPaths(PiPedalModel &model, PluginPresets &pluginPreset);
std::map<std::string, std::string> configFiles;
std::set<std::string> mediaPaths;
std::set<std::string> usedPlugins;
std::vector<std::map<std::string, std::string>> pluginMetadata;
std::filesystem::path pluginUploadDirectory;
std::string pluginUploadDirectoryString;
};
void PresetBundleWriterImpl::WriteToFile(const std::filesystem::path &filePath)
{
ZipFileWriter::ptr zipFile = ZipFileWriter::Create(filePath);
for (const auto &configFile : configFiles)
{
zipFile->WriteFile(configFile.first, configFile.second.data(), configFile.second.size());
}
std::string metadata;
{
std::ostringstream ss;
json_writer writer(ss);
writer.write(this->pluginMetadata);
metadata = ss.str();
zipFile->WriteFile("pluginsUsed.json", metadata.data(), metadata.length());
}
for (const auto &mediaPath : mediaPaths)
{
std::string zipName = (std::filesystem::path("media") / std::filesystem::path(mediaPath)).string();
std::filesystem::path sourcePath = this->pluginUploadDirectory / std::filesystem::path(mediaPath);
if (std::filesystem::exists(sourcePath))
{
if (IsValidMediaPath(sourcePath)) // paranoid guard against exfiltration of non-media files.
{
zipFile->WriteFile(zipName, sourcePath);
}
else
{
Lv2Log::warning(SS("Media file is not valid: " << sourcePath));
}
}
else
{
Lv2Log::warning(SS("Media file not found: " << sourcePath));
}
std::filesystem::path metadataPath = SS(sourcePath.string() << ".mdata");
if (std::filesystem::exists(metadataPath))
{
zipFile->WriteFile(SS(zipName << ".mdata"), metadataPath);
}
}
zipFile->Close();
}
void PresetBundleWriterImpl::GatherMediaPaths(PiPedalModel &model, BankFile &bankFile)
{
for (auto &preset : bankFile.presets())
{
Pedalboard &pedalboard = preset->preset();
auto items = pedalboard.GetAllPlugins();
for (auto plugin : items)
{
AddUsedPlugin(model, plugin->uri(), plugin->pluginName());
const Lv2PluginState &state = plugin->lv2State();
for (const auto &value : state.values_)
{
if (value.second.atomType_ == LV2_ATOM__Path)
{
std::string path = ToString(value.second.value_);
if (!mediaPaths.contains(path))
{
mediaPaths.insert(std::move(path));
}
}
}
for (const auto &property : plugin->pathProperties_)
{
std::string path;
if (TryGetAtomPath(property.second, &path))
{
path = UnmapPath(path);
if (!mediaPaths.contains(path))
{
mediaPaths.insert(std::move(path));
}
}
}
for (const auto &snapshot : pedalboard.snapshots())
{
if (snapshot)
{
for (const auto &value : snapshot->values_)
{
if (value.isEnabled_)
{
const Lv2PluginState &state = value.lv2State_;
for (const auto &v : state.values_)
{
if (v.second.atomType_ == LV2_ATOM__Path)
{
std::string path = ToString(v.second.value_);
if (!mediaPaths.contains(path))
{
mediaPaths.insert(std::move(path));
}
}
}
for (const auto &property : value.pathProperties_)
{
std::string path;
if (TryGetAtomPath(property.second, &path))
{
path = UnmapPath(path);
if (!mediaPaths.contains(path))
{
mediaPaths.insert(std::move(path));
}
}
}
}
}
}
}
}
}
}
void PresetBundleWriterImpl::GatherMediaPaths(PiPedalModel &model, PluginPresets &pluginPresets)
{
AddUsedPlugin(model, pluginPresets.pluginUri_, "");
for (auto &preset : pluginPresets.presets_)
{
const Lv2PluginState &state = preset.state_;
for (const auto &value : state.values_)
{
if (value.second.atomType_ == LV2_ATOM__Path)
{
std::string path = ToString(value.second.value_);
if (!mediaPaths.contains(path))
{
mediaPaths.insert(std::move(path));
}
}
}
}
}
PresetBundleWriter::ptr PresetBundleWriter::CreatePresetsFile(PiPedalModel &model, const std::string &presetJson)
{
auto result = std::make_unique<PresetBundleWriterImpl>();
result->LoadPresets(model, presetJson);
return result;
}
PresetBundleWriter::ptr PresetBundleWriter::CreatePluginPresetsFile(PiPedalModel &model, const std::string &pluginPresetJson)
{
auto result = std::make_unique<PresetBundleWriterImpl>();
result->LoadPluginPresets(model, pluginPresetJson);
return result;
}
class PresetBundleReaderImpl : public PresetBundleReader
{
public:
PresetBundleReaderImpl()
{
}
void LoadPresetsFile(PiPedalModel &model, const std::filesystem::path &path)
{
this->pluginUploadDirectory = model.GetPluginUploadDirectory();
zipFile = ZipFileReader::Create(path);
auto s = zipFile->GetFileInputStream("bankFile.json");
json_reader reader(s);
reader.read(&bankFile);
}
void LoadPluginPresetFile(PiPedalModel &model, const std::filesystem::path &path)
{
this->pluginUploadDirectory = model.GetPluginUploadDirectory();
zipFile = ZipFileReader::Create(path);
auto s = zipFile->GetFileInputStream("pluginPresets.json");
json_reader reader(s);
reader.read(&pluginPresets);
}
virtual ~PresetBundleReaderImpl() noexcept;
virtual void ExtractMediaFiles() override;
virtual std::string GetPresetJson() override;
virtual std::string GetPluginPresetsJson() override;
private:
void ExtractMediaFile(const std::string &zipFileName);
bool IsSameFile(const std::string &zipFileName, const std::filesystem::path &filePath)
{
if (!zipFile->CompareFiles(zipFileName, filePath))
{
return false;
}
std::string metadataZipFilename = SS(zipFileName << ".mdata");
std::filesystem::path metadataFilename = SS(filePath.string() << ".mdata");
if (!std::filesystem::exists(metadataFilename))
{
if (!zipFile->FileExists(metadataZipFilename))
{
return true;
}
return false;
}
else
{
if (!zipFile->FileExists(metadataZipFilename))
{
return false;
}
return zipFile->CompareFiles(metadataZipFilename, metadataFilename);
}
return true;
}
void RenameMediaFileProperty(const std::string oldName, const std::string &newName);
void RenameState(Lv2PluginState &state, const std::string oldName, const std::string &newName);
void RenamePedalboardItem(PedalboardItem *item, const std::string oldName, const std::string &newName);
void RenamePedalboard(Pedalboard &pedalboard, const std::string oldName, const std::string &newName);
void RenamePreset(PluginPreset &pedalboard, const std::string oldName, const std::string &newName);
void RenameSnapshot(Snapshot *snapshot, const std::string oldName, const std::string &newName);
std::filesystem::path pluginUploadDirectory;
// BankFile bankFile;
ZipFileReader::ptr zipFile;
BankFile bankFile;
PluginPresets pluginPresets;
};
void PresetBundleReaderImpl::RenameState(Lv2PluginState &state, const std::string oldName, const std::string &newName)
{
for (auto &value : state.values_)
{
if (value.second.atomType_ == LV2_ATOM__Path)
{
std::string path = ToString(value.second.value_);
if (path == oldName)
{
state.values_.at(value.first).value_ = ToBinary(newName);
}
}
}
}
void PresetBundleReaderImpl::RenamePedalboardItem(PedalboardItem *plugin, const std::string oldName, const std::string &newName)
{
Lv2PluginState &state = plugin->lv2State();
RenameState(state, oldName, newName);
std::vector<std::pair<std::string, std::string>> propertiesToUpdate;
std::string fullOldPath = (pluginUploadDirectory / oldName).string();
for (auto &property : plugin->pathProperties_)
{
std::stringstream ss(property.second);
json_reader reader(ss);
json_variant vProperty;
reader.read(&vProperty);
if (vProperty.is_object())
{
auto obj = vProperty.as_object();
if (obj->contains("otype_") &&
(*obj)["otype_"].as_string() == "Path")
{
if (obj->contains("value"))
{
std::string value = (*obj)["value"].as_string();
if (value == fullOldPath)
{
(*obj)["value"] = (pluginUploadDirectory / newName).string();
std::ostringstream ss;
json_writer writer(ss);
writer.write(vProperty);
propertiesToUpdate.push_back(std::make_pair(property.first, ss.str()));
}
}
}
}
}
for (auto &property : propertiesToUpdate)
{
plugin->pathProperties_[property.first] = property.second;
}
}
void PresetBundleReaderImpl::RenameSnapshot(Snapshot *snapshot, const std::string oldName, const std::string &newName)
{
std::string fullOldPath = (pluginUploadDirectory / oldName).string();
for (auto &value : snapshot->values_)
{
if (value.isEnabled_)
{
Lv2PluginState &state = value.lv2State_;
RenameState(state, oldName, newName);
std::vector<std::pair<std::string, std::string>> propertiesToUpdate;
// Check the path properties in the snapshot value.
for (auto &property : value.pathProperties_)
{
std::string path;
if (TryGetAtomPath(property.second,&path)) {
if (path == fullOldPath) {
propertiesToUpdate.push_back(std::make_pair(property.first,
ToJsonAtomPath((pluginUploadDirectory / newName).string())));
}
}
}
for (auto &property : propertiesToUpdate)
{
value.pathProperties_[property.first] = property.second;
}
}
}
}
void PresetBundleReaderImpl::RenamePedalboard(Pedalboard &pedalboard, const std::string oldName, const std::string &newName)
{
auto items = pedalboard.GetAllPlugins();
for (auto pedalboardItem : items)
{
RenamePedalboardItem(pedalboardItem, oldName, newName);
}
for (std::shared_ptr<Snapshot> &snapshot : pedalboard.snapshots())
{
if (snapshot)
{
RenameSnapshot(snapshot.get(), oldName, newName);
}
}
}
void PresetBundleReaderImpl::RenamePreset(PluginPreset &preset, const std::string oldName, const std::string &newName)
{
Lv2PluginState state = preset.state_;
for (auto &value : state.values_)
{
if (value.second.atomType_ == LV2_ATOM__Path)
{
std::string path = ToString(value.second.value_);
if (path == oldName)
{
state.values_.at(value.first).value_ = ToBinary(newName);
}
}
}
}
void PresetBundleReaderImpl::RenameMediaFileProperty(const std::string oldName, const std::string &newName)
{
// snapshots.
// there should be a dictionary for remapped media files.
// there should be a set for saved media files.
for (auto &preset : bankFile.presets())
{
Pedalboard &pedalboard = preset->preset();
RenamePedalboard(pedalboard, oldName, newName);
}
for (auto &preset : pluginPresets.presets_)
{
RenamePreset(preset, oldName, newName);
}
}
PresetBundleReader::ptr PresetBundleReader::LoadPresetsFile(PiPedalModel &model, const std::filesystem::path &filePath)
{
std::unique_ptr<PresetBundleReaderImpl> result = std::make_unique<PresetBundleReaderImpl>();
result->LoadPresetsFile(model, filePath);
return result;
}
PresetBundleReader::ptr PresetBundleReader::LoadPluginPresetsFile(PiPedalModel &model, const std::filesystem::path &filePath)
{
std::unique_ptr<PresetBundleReaderImpl> result = std::make_unique<PresetBundleReaderImpl>();
result->LoadPluginPresetFile(model, filePath);
return result;
}
void PresetBundleReaderImpl::ExtractMediaFiles()
{
auto zipFiles = zipFile->GetFiles();
for (const auto &zipFile : zipFiles)
{
if (zipFile != "bankFile.json")
{
if (!zipFile.ends_with('/')) // don't process diretories.
{
ExtractMediaFile(zipFile);
}
}
}
}
static void ExtractFileVersion(std::string &baseName, int &n)
{
if (baseName.ends_with(')'))
{
size_t endPos = baseName.length() - 1;
int startPos = baseName.find_last_of('(');
if (startPos != std::string::npos)
{
std::string number = baseName.substr(startPos + 1, endPos - (startPos + 1));
std::istringstream ss(number);
ss >> n;
if (!ss.fail())
{
while (startPos > 0 && baseName[startPos - 1] == ' ')
{
--startPos;
}
baseName = baseName.substr(0, startPos);
return;
}
}
}
n = 0;
}
static std::filesystem::path NextFileName(const std::filesystem::path &fileName)
{
int n = 0;
auto fileNameOnly = fileName.filename().string();
auto extPos = fileNameOnly.find_last_of('.');
if (extPos == std::string::npos)
{
extPos = fileNameOnly.length();
}
std::string baseName = fileNameOnly.substr(0, extPos);
ExtractFileVersion(baseName, n);
if (n >= 1024)
{
// something has gone badly wrong.
throw new std::runtime_error(SS("Can't increase the version number of " << fileName));
}
std::string newFileName = SS(baseName << "(" << (n + 1) << ')' << fileNameOnly.substr(extPos));
return fileName.parent_path() / newFileName;
}
void PresetBundleReaderImpl::ExtractMediaFile(const std::string &zipFileName)
{
namespace fs = std::filesystem;
if (zipFileName.starts_with("media/"))
{
if (zipFileName.ends_with(".mdata"))
{
return;
}
std::string baseName = zipFileName.substr(6);
fs::path targetFileName = this->pluginUploadDirectory / std::filesystem::path(baseName);
bool renamed = false;
while (true)
{
if (fs::exists(targetFileName))
{
if (IsSameFile(zipFileName, targetFileName))
{
break;
}
else
{
renamed = true;
targetFileName = NextFileName(targetFileName);
}
}
else
{
zipFile->ExtractTo(zipFileName, targetFileName);
if (zipFile->FileExists(SS(zipFileName << ".mdata")))
{
zipFile->ExtractTo(SS(zipFileName << ".mdata"), SS(targetFileName.string() << ".mdata"));
}
break;
}
}
if (renamed)
{
std::string newName = fs::path(baseName).parent_path() / targetFileName.filename();
RenameMediaFileProperty(baseName, newName);
}
}
}
std::string PresetBundleReaderImpl::GetPresetJson()
{
std::ostringstream ss;
json_writer writer(ss);
writer.write(this->bankFile);
return ss.str();
}
std::string PresetBundleReaderImpl::GetPluginPresetsJson()
{
std::ostringstream ss;
json_writer writer(ss);
writer.write(this->pluginPresets);
return ss.str();
}
PresetBundleReaderImpl::~PresetBundleReaderImpl() noexcept
{
}
PresetBundleReader::~PresetBundleReader() noexcept
{
}
PresetBundleWriterImpl::~PresetBundleWriterImpl() noexcept
{
}
PresetBundleWriter::~PresetBundleWriter() noexcept
{
}
class PluginMetadata
{
public:
PluginMetadata(std::shared_ptr<Lv2PluginInfo> &pluginInfo)
{
metadata_["uri"] = pluginInfo->uri();
metadata_["name"] = pluginInfo->name();
metadata_["brand"] = pluginInfo->brand();
metadata_["authorName"] = pluginInfo->author_name();
metadata_["authorHomePage"] = pluginInfo->author_homepage();
}
PluginMetadata(const std::string &uri, const std::string &name)
{
metadata_["uri"] = uri;
metadata_["name"] = name.empty() ? uri : name;
}
std::map<std::string, std::string> metadata_;
};
void PresetBundleWriterImpl::AddUsedPlugin(PiPedalModel &model, const std::string &pluginUri, const std::string &name)
{
if (!usedPlugins.contains(pluginUri))
{
usedPlugins.insert(pluginUri);
auto pluginInfo = model.GetPluginInfo(pluginUri);
if (pluginInfo)
{
// use dictionaries because it's more version tolerant.
PluginMetadata metadata(pluginInfo);
this->pluginMetadata.push_back(std::move(metadata.metadata_));
}
else
{
PluginMetadata metadata(pluginUri, name);
this->pluginMetadata.push_back(std::move(metadata.metadata_));
}
}
}
std::string PresetBundleWriterImpl::UnmapPath(const std::string &path)
{
if (path.starts_with(pluginUploadDirectoryString))
{
return path.substr(pluginUploadDirectory.string().length() + 1);
}
return path;
}
bool PresetBundleWriterImpl::IsValidMediaPath(const std::string &path)
{
if (path.starts_with(pluginUploadDirectoryString))
{
if (path.length() >= pluginUploadDirectoryString.length() + 1 &&
path[pluginUploadDirectoryString.length()] == '/')
{
return true;
;
}
}
return false;
}
std::string PresetBundleWriterImpl::MapPath(const std::string &path)
{
if (!path.starts_with("/"))
{
return pluginUploadDirectory / path;
}
return path;
}
Reference in New Issue View Git Blame Copy Permalink