public override async Task DoScan()
{
InitializeInternal();
var parser = new KoaBankFileParser(ExportConfig.KoaFileHeader, ExportConfig.KoaPresetNameLength,
ExportConfig.KoaPresetLength,
ExportConfig.KoaNumPresets);
var converter = new RolandConverter(ExportConfig);
converter.LoadDefinitionFromCsvString(Encoding.UTF8.GetString(GetDefinitionData()));
foreach (var presetFile in PresetFiles)
{
var presets = parser.Parse(presetFile);
var presetBankName = Path.GetFileNameWithoutExtension(presetFile);
foreach (var parsedPreset in presets)
{
converter.SetFileMemory(parsedPreset.PresetData);
var preset = new PresetParserMetadata
{
PresetName = parsedPreset.PresetName.Trim(), Plugin = PluginInstance.Plugin,
BankPath = presetBankName,
SourceFile = presetFile + ":" + parsedPreset.Index
};
PostProcessPreset(preset, converter);
await DataPersistence.PersistPreset(preset, converter.Export());
}
}
await base.DoScan();
}
private void TestOriginalMetadata(PresetParserMetadata originalPreset, PresetParserMetadata savedPreset)
{
var testedProperties = new HashSet <string>();
foreach (var x in OriginalPresetMetadataPropertiesWhichShouldBePersisted)
{
var loadedValue = PropertyHelper.GetPropertyValue(savedPreset, x.Key);
var originalValue = PropertyHelper.GetPropertyValue(originalPreset, x.Key);
loadedValue.Should().BeEquivalentTo(originalValue,
$"Loading the property {x.Key} should be the same as the saved one");
testedProperties.Add(x.Key);
}
savedPreset.Characteristics.IsEqualTo(originalPreset.Characteristics).Should().BeTrue();
testedProperties.Add(nameof(PresetParserMetadata.Characteristics));
savedPreset.Types.IsEqualTo(originalPreset.Types).Should().BeTrue();
testedProperties.Add(nameof(PresetParserMetadata.Types));
testedProperties.Add(nameof(PresetParserMetadata.SerializedCharacteristics));
testedProperties.Add(nameof(PresetParserMetadata.SerializedTypes));
var allProperties =
(from prop in typeof(PresetMetadata).GetProperties() select prop.Name).ToList();
allProperties.Except(testedProperties).Should().BeEmpty("We want to test ALL TEH PROPERTIEZ");
}
protected override byte[] ProcessFile(string fileName, PresetParserMetadata preset)
{
var data = File.ReadAllBytes(fileName);
var ms = new MemoryStream();
ms.Write(data, 0, data.Length);
var relativeFile = BinaryFile.StringToByteArray(fileName.Replace(GetParseDirectory(), ""));
var tuningFile = BinaryFile.StringToByteArray(@"Tunings\Basic\Default.tun");
ms.Seek(0, SeekOrigin.End);
ms.WriteByte(0x01);
ms.WriteByte((byte)relativeFile.Length);
ms.Write(relativeFile, 0, relativeFile.Length);
ms.WriteByte(0x01);
ms.WriteByte((byte)tuningFile.Length);
ms.Write(tuningFile, 0, tuningFile.Length);
ms.Seek(0, SeekOrigin.Begin);
var ms2 = new MemoryStream();
ms2.Write(LittleEndian.GetBytes(ms.Length), 0, 4);
ms.WriteTo(ms2);
ms2.Seek(0, SeekOrigin.Begin);
return(ms2.ToArray());
}
private void RetrievePresetData(XNode node, PresetParserMetadata preset)
{
preset.Comment = GetNodeValue(node,
$"string(/package/archives/archive[@client_id='{PresetSectionName}-preset']/section/entry[@id='Preset notes']/@value)");
preset.Author = GetNodeValue(node,
$"string(/package/archives/archive[@client_id='{PresetSectionName}-preset']/section/entry[@id='Preset author']/@value)");
}
private void MigrateData(XNode source, XNode dest, PresetParserMetadata preset)
{
var dataNode =
$"/package/archives/archive[@client_id='{PresetSectionName}-preset']/section[@id='ParameterValues']/entry";
var nodes = source.XPathSelectElements(dataNode);
var dataNode2 =
$"/package/archives/archive[@client_id='{PresetSectionName}-state']/section[@id='Slot0']";
var insertNode = dest.XPathSelectElement(dataNode2);
insertNode.Elements().Remove();
insertNode.Add(nodes);
var presetNameNode = new XElement("entry");
presetNameNode.SetAttributeValue("id", "Preset name");
presetNameNode.SetAttributeValue("type", "string");
var bank = RootBank.CreateRecursive(preset.BankPath);
presetNameNode.SetAttributeValue("value", bank.BankName + "/" + preset.PresetName);
insertNode.Add(presetNameNode);
}
protected async Task GetPresetsUsingFullBank(PresetBank bank, int start, int numPresets, string sourceFile)
{
if (start < 0)
{
Logger.Error("GetPresets start index is less than 0, ignoring. This is probably a bug or a " +
"misconfiguration. Please report this including the full log file.");
return;
}
var endIndex = start + numPresets;
if (endIndex > PluginInstance.Plugin.PluginInfo.ProgramCount)
{
Logger.Error(
$"Tried to retrieve presets between the index {start} and {endIndex}, but this would exceed maximum " +
$"program count of {PluginInstance.Plugin.PluginInfo.ProgramCount}, ignoring. You might wish to " +
"report this as a bug.");
return;
}
for (var index = start; index < endIndex; index++)
{
PluginInstance.SetProgram(index);
var preset = new PresetParserMetadata
{
PresetName = PluginInstance.GetCurrentProgramName(),
BankPath = bank.BankPath,
SourceFile = sourceFile + ":" + index,
Plugin = PluginInstance.Plugin
};
await DataPersistence.PersistPreset(preset, PluginInstance.GetChunk(false));
}
}
private static Preset GetFreshPresetTestSubject()
{
var characteristic = new Characteristic();
var type = new Type();
var preset = new Preset();
var originalMetadata = new PresetParserMetadata();
originalMetadata.BankPath = "foo/bar";
originalMetadata.Author = "horst";
originalMetadata.Comment = "kein kommentar";
originalMetadata.Types.Add(type);
originalMetadata.Characteristics.Add(characteristic);
originalMetadata.PresetName = "my preset";
var plugin = new Plugin();
preset.Plugin = plugin;
preset.SetFromPresetParser(originalMetadata);
plugin.Presets.Add(preset);
preset.PresetHash = "foobar";
preset.PresetSize = 1234;
preset.PresetCompressedSize = 4567;
preset.IsMetadataModified = false;
preset.UpdateLastExportedMetadata();
return(preset);
}
protected override (PresetParserMetadata preset, byte[] presetData) GetPreset(string name, string presetData,
PresetBank presetBank)
{
var pluginState = new XElement("PluginState");
pluginState.SetAttributeValue("application", XmlPluginName);
var midiControlMap = new XElement("MidiControlMap");
midiControlMap.SetAttributeValue("name", XmlPluginName);
var xmlPreset = XDocument.Parse(presetData);
var presetElement = xmlPreset.Element("Preset");
var presetName = name.Replace(Extension, "");
presetElement.SetAttributeValue("name", "ParametersState");
var preset = new PresetParserMetadata
{
PresetName = name.Replace(Extension, ""), Plugin = PluginInstance.Plugin, BankPath = presetBank.BankPath
};
var tagsAttribute = presetElement.Attribute("tags");
if (!(tagsAttribute is null))
{
var modes = GetModes(tagsAttribute.Value);
foreach (var modeName in modes)
{
preset.Characteristics.Add(new Characteristic {
CharacteristicName = modeName
});
}
}
presetElement.SetAttributeValue("tags", null);
presetElement.SetAttributeValue("version", null);
pluginState.Add(presetElement);
var presetElement2 = new XElement("Preset");
presetElement2.SetAttributeValue("name", "OtherParameters");
var param = new XElement("param");
param.SetAttributeValue("name", "Preset Name");
param.SetAttributeValue("value", presetName);
presetElement2.Add(param);
pluginState.Add(presetElement2);
var ms = RecursiveVC2Parser.WriteVC2(pluginState.ToString());
return(preset, ms.ToArray());
}
protected override byte[] ProcessFile(string fileName, PresetParserMetadata preset)
{
var fxp = new FXP();
fxp.ReadFile(fileName);
return(fxp.ChunkDataByteArray);
}
protected override byte[] ProcessFile(string fileName, PresetParserMetadata preset)
{
var inflater = new Inflater(false);
inflater.SetInput(File.ReadAllBytes(fileName));
var size = inflater.Inflate(_decodeBuffer);
return(_decodeBuffer.GetRange(0, size).ToArray());
}
protected override byte[] ProcessFile(string fileName, PresetParserMetadata preset)
{
var tfx = GetTfxParser();
var(directory, filename) = GetSplittedParseFile(fileName);
tfx.Parse(directory, filename);
return(tfx.GetDataToWrite());
}
protected override byte[] ProcessFile(string fileName, PresetParserMetadata preset)
{
var data = File.ReadAllText(fileName);
if (PreProcessXmlFunc != null)
{
data = PreProcessXmlFunc.Invoke(data);
}
var xmlWithoutHeader = XmlHeaderReplacerRegex.Replace(data, "");
return(WriteVC2(xmlWithoutHeader).ToArray());
}
private async Task ProcessPreset(FileSystemInfo file, PresetBank bank)
{
var presetData = File.ReadAllBytes(file.FullName);
var sourceFile = file.FullName;
var preset = new PresetParserMetadata
{
PresetName = file.Name.Replace(".h2p", ""), Plugin = PluginInstance.Plugin, BankPath = bank.BankPath,
SourceFile = sourceFile
};
var metadata = ExtractMetadata(Encoding.UTF8.GetString(presetData));
if (metadata.ContainsKey("Author"))
{
preset.Author = metadata["Author"];
}
var comments = new List <string>();
if (metadata.ContainsKey("Description") && metadata["Description"].Length > 0)
{
comments.Add(metadata["Description"]);
}
if (metadata.ContainsKey("Usage") && metadata["Usage"].Length > 0)
{
comments.Add(metadata["Usage"]);
}
preset.Comment = string.Join(Environment.NewLine, comments);
if (metadata.ContainsKey("Categories") && metadata["Categories"].Length > 0)
{
preset.Types.AddRange(ExtractTypes(metadata["Categories"]));
}
if (metadata.ContainsKey("Features") && metadata["Features"].Length > 0)
{
preset.Characteristics.AddRange(ExtractModes(metadata["Features"]));
}
if (metadata.ContainsKey("Character") && metadata["Character"].Length > 0)
{
preset.Characteristics.AddRange(ExtractModes(metadata["Character"]));
}
await DataPersistence.PersistPreset(preset, presetData);
}
public async Task DoLibraryScan(OmnisphereLibrary library)
{
library.BuildMetadata();
foreach (var multi in library.GetMultis())
{
var presetData = library.GetFileContent(multi);
var sourceFile = library.Path + "/" + multi.Directory.DirectoryPath + multi.Filename;
var preset = new PresetParserMetadata
{
PresetName = multi.FilenameWithoutExtension, Plugin = PluginInstance.Plugin,
BankPath = library.Name + "/" + multi.Directory.DirectoryPath,
SourceFile = sourceFile
};
ApplyMetadata(multi, preset);
await DataPersistence.PersistPreset(preset, presetData);
}
foreach (var patch in library.GetPatches())
{
var presetData = Encoding.ASCII.GetString(library.GetFileContent(patch));
var template = VendorResources.OmnispherePatchTemplate;
presetData = presetData.Replace("<AmberPart >", "");
presetData = presetData.Replace("<AmberPart>", "");
presetData = presetData.Replace("</AmberPart>", "");
template = template.Replace("{{PATCHNAME}}", patch.FilenameWithoutExtension);
template = template.Replace("{{LIBRARYNAME}}", library.Name);
template = template.Replace("{{PATCHGOESHERE}}", presetData);
var sourceFile = library.Path + "/" + patch.Directory.DirectoryPath + patch.Filename;
var preset = new PresetParserMetadata
{
PresetName = patch.FilenameWithoutExtension, Plugin = PluginInstance.Plugin,
BankPath = library.Name + "/" + patch.Directory.DirectoryPath,
SourceFile = sourceFile
};
ApplyMetadata(patch, preset);
await DataPersistence.PersistPreset(preset, Encoding.ASCII.GetBytes(template + "\0"));
}
}
protected override byte[] ProcessFile(string fileName, PresetParserMetadata preset)
{
var xmlPreset = XDocument.Load(fileName);
var chunk = PluginInstance.GetChunk(false);
var chunkXml = Encoding.UTF8.GetString(chunk);
var actualPresetDocument = XDocument.Parse(chunkXml);
RetrievePresetData(xmlPreset, preset);
MigrateData(xmlPreset, actualPresetDocument, preset);
var builder = new StringBuilder();
using (TextWriter writer = new StringWriter(builder))
{
actualPresetDocument.Save(writer);
return(Encoding.UTF8.GetBytes(builder.ToString()));
}
}
public void TestSetFromPresetParser()
{
var plugin = InitializePluginToBeSaved();
var presetData = new PresetParserMetadata();
presetData.Plugin = plugin;
presetData.SourceFile = "foobar";
presetData.BankPath = "foo/bar";
var ps = Fixture.GetServiceLocator().ResolveType <PresetDataPersisterService>();
ps.OpenDatabase().Wait();
ps.PersistPreset(presetData, new byte[1]).Wait();
var lastPreset = plugin.Presets.Last();
lastPreset.OriginalMetadata.SourceFile.Should().Be("foobar");
lastPreset.Plugin.Should().Be(plugin);
}
public override async Task DoScan()
{
foreach (var bankFile in GetBankFiles())
{
Logger.Debug($"Parsing {bankFile}");
try
{
var cfg = new SpireJsonConfig {
SelectedBank = bankFile
};
var bf = new SpireBank();
bf.ParseDiskFile(File.ReadAllBytes(bankFile));
foreach (var p in bf.Presets)
{
var bankPath = Path.GetFileNameWithoutExtension(bankFile);
var preset = new PresetParserMetadata
{
PresetName = p.ProgramName.Trim(), Plugin = PluginInstance.Plugin,
BankPath = bankPath,
SourceFile = bankFile + ":" + bf.Presets.IndexOf(p)
};
await DataPersistence.PersistPreset(preset, bf.GenerateMemoryBank(p, cfg));
}
}
catch (SpireException e)
{
Logger.Error($"Error parsing {bankFile}");
Logger.LogException(e);
}
}
await base.DoScan();
}
#pragma warning disable 1998
public async Task PersistPreset(PresetParserMetadata presetMetadata, byte[] data, bool force = false)
#pragma warning restore 1998
{
var preset = new Preset();
preset.Plugin = presetMetadata.Plugin;
preset.Plugin.Presets.Add(preset);
preset.SetFromPresetParser(presetMetadata);
preset.PresetHash = HashUtils.getIxxHash(data);
preset.PresetSize = data.Length;
preset.PresetCompressedSize = data.Length;
try
{
PresetData.Add(preset.OriginalMetadata.SourceFile, LZ4Pickler.Pickle(data));
}
catch (Exception e)
{
Console.WriteLine($"Error while trying to add {preset.OriginalMetadata.SourceFile}");
throw e;
}
}
public async Task PersistPreset(PresetParserMetadata presetMetadata, byte[] data, bool force = false)
{
var plugin = presetMetadata.Plugin;
var preset = (from p in plugin.Presets
where p.OriginalMetadata.SourceFile == presetMetadata.SourceFile
select p)
.FirstOrDefault();
if (preset == null)
{
preset = new Preset();
preset.Plugin = plugin;
plugin.Presets.Add(preset);
}
preset.SetFromPresetParser(presetMetadata);
PresetUpdated?.Invoke(this, new PresetUpdatedEventArgs(preset));
var hash = HashUtils.getIxxHash(data);
if (hash == preset.PresetHash && preset.PresetSize == data.Length && !force)
{
return;
}
preset.PresetHash = hash;
preset.PresetSize = data.Length;
var presetData = new PresetDataStorage {
PresetData = data, PluginId = preset.Plugin.PluginId, PresetDataId = preset.PresetId
};
await _db.InsertOrReplaceAsync(presetData);
preset.PresetCompressedSize = presetData.PresetCompressedSize;
}
public async Task <int> ScanPresetXml(XElement rootElement, string fileName, PresetBank presetBank,
bool persist = true)
{
var count = 0;
var directories = rootElement.Elements("Directory");
foreach (var directory in directories)
{
var bankNameElement = directory.Attribute("Name");
if (bankNameElement == null)
{
bankNameElement = directory.Attribute("name");
if (bankNameElement == null)
{
Logger.Warning($"A directory within {fileName} contains no name attribute. Maybe the file is corrupt?");
continue;
}
}
var subBank = presetBank.CreateRecursive(bankNameElement.Value);
count += await ScanPresetXml(directory, fileName, subBank, persist);
}
var presets = rootElement.Elements("preset");
foreach (var presetElement in presets)
{
var nameAttribute = presetElement.Attribute("name");
if (nameAttribute == null)
{
nameAttribute = presetElement.Attribute("Name");
if (nameAttribute == null)
{
Logger.Error($"A preset in the file {fileName} has no name attribute. Ignoring the preset, " +
"as PresetMagician does not know how to identify the name of the preset.");
continue;
}
}
count++;
if (persist)
{
var sourceFile = fileName + ":" + presetBank.BankPath + "/" + nameAttribute.Value;
var presetName = nameAttribute.Value;
if (SourceFileDuplicates.ContainsKey(sourceFile))
{
SourceFileDuplicates[sourceFile]++;
sourceFile += ":" + (SourceFileDuplicates[sourceFile] + 1);
presetName += "-1";
Logger.Warning(
$"The preset file {fileName} contains a duplicate preset name in {presetBank.BankPath}/" +
$"{nameAttribute.Value}. " + Environment.NewLine + Environment.NewLine +
"PresetMagician has no reliable way to check which preset is which " +
"(think of it as two files with exactly the same name in the same directory). " +
Environment.NewLine + Environment.NewLine +
$"PresetMagician will use {presetName} for it; however, it could happen that the preset " +
"data gets mixed up between these duplicate presets." +
Environment.NewLine + Environment.NewLine +
"To avoid this, please rename the duplicates to an unique name.");
}
else
{
SourceFileDuplicates.Add(sourceFile, 0);
}
var preset = new PresetParserMetadata
{
PresetName = presetName, Plugin = PluginInstance.Plugin,
BankPath = presetBank.BankPath,
SourceFile = sourceFile
};
var base64 = presetElement.Value.Trim().Replace("-", "/").Replace("$", "");
await DataPersistence.PersistPreset(preset, Convert.FromBase64String(base64));
}
}
return(count);
}
private void ApplyType(int id, PresetParserMetadata preset)
{
switch (id)
{
case 1: break;
case 2: // Arpeggiated
preset.Characteristics.Add(new Characteristic {
CharacteristicName = "Arpeggiated"
});
break;
case 3: //Bass
preset.Types.Add(new Type {
TypeName = "Bass"
});
break;
case 4: // Chord
preset.Characteristics.Add(new Characteristic {
CharacteristicName = "Chord"
});
break;
case 5: // Effect
preset.Types.Add(new Type {
TypeName = "Sound Effects"
});
break;
case 6: // Drumkit
preset.Types.Add(new Type {
TypeName = "Drums", SubTypeName = "Kit"
});
break;
case 7: // Drumloop
preset.Types.Add(new Type {
TypeName = "Drums"
});
preset.Characteristics.Add(new Characteristic {
CharacteristicName = "Sequence / Loop"
});
break;
case 8: // Gated
preset.Types.Add(new Type {
TypeName = "Arp / Sequence", SubTypeName = "Gated"
});
break;
case 9: // Lead
preset.Characteristics.Add(new Characteristic {
CharacteristicName = "Lead"
});
break;
case 10: // Melody
preset.Characteristics.Add(new Characteristic {
CharacteristicName = "Melodic"
});
break;
case 11: // Pad
preset.Types.Add(new Type {
TypeName = "Synth Pad"
});
break;
case 12: // Pluck
preset.Types.Add(new Type {
TypeName = "Synth Pluck"
});
break;
case 13: // Sequence
preset.Types.Add(new Type {
TypeName = "Arp / Sequence"
});
break;
case 14: // Splitted
preset.Types.Add(new Type {
TypeName = "Combination"
});
break;
case 15: // Synth
preset.Types.Add(new Type {
TypeName = "Synth Misc"
});
break;
case 16: // Texture
preset.Characteristics.Add(new Characteristic {
CharacteristicName = "Textural"
});
break;
case 17: // Track
preset.Types.Add(new Type {
TypeName = "Arp / Sequence"
});
break;
case 18: // Bell
preset.Types.Add(new Type {
TypeName = "Percussion", SubTypeName = "Bell"
});
break;
case 19: // Brass
preset.Types.Add(new Type {
TypeName = "Brass"
});
break;
case 20: // Drum
preset.Types.Add(new Type {
TypeName = "Drums"
});
break;
case 21: // Guitar
preset.Types.Add(new Type {
TypeName = "Guitar"
});
break;
case 22: // Mallet
preset.Types.Add(new Type {
TypeName = "Mallet Instruments"
});
break;
case 23: // Organ
preset.Types.Add(new Type {
TypeName = "Organ"
});
break;
case 24: // Piano
preset.Types.Add(new Type {
TypeName = "Piano / Keys"
});
break;
case 25: // String
preset.Types.Add(new Type {
TypeName = "Bowed Instruments", SubTypeName = "Synth"
});
break;
case 26: // Vocal
preset.Types.Add(new Type {
TypeName = "Vocal"
});
break;
case 27: // Woodwind
preset.Types.Add(new Type {
TypeName = "Mallet Instruments", SubTypeName = "Wood"
});
break;
case 28: // Keys
preset.Types.Add(new Type {
TypeName = "Piano / Keys"
});
break;
case 29: // Solo
preset.Types.Add(new Type {
TypeName = "Solo"
});
break;
default:
Logger.Error(
$"Unknown type id {id} for preset {preset.PresetName}. Seems like there were additional " +
"types introduced to Rapid since this preset parser was developed. " +
"Please report this as a bug.");
break;
}
}
protected override byte[] ProcessFile(string fileName, PresetParserMetadata preset)
{
var chunkData = base.ProcessFile(fileName, preset);
var ms = new MemoryStream(chunkData);
var parameterSize = ms.ReadInt32();
ms.Seek(parameterSize, SeekOrigin.Current);
var metadataSize = ms.ReadInt32();
var metadataBuf = new byte[metadataSize];
ms.Read(metadataBuf, 0, metadataSize);
var inflater = new Inflater(false);
inflater.SetInput(metadataBuf);
var size = inflater.Inflate(_decodeBuffer);
var metadata = _decodeBuffer.GetRange(0, size).ToArray();
var metadataString = Encoding.UTF8.GetString(metadata);
var tokens = metadataString.Split(',');
var metadataDictionary = new Dictionary <string, string>();
var isKey = true;
var key = "";
foreach (var token in tokens)
{
if (isKey)
{
key = token;
}
else
{
try
{
metadataDictionary.Add(key, token);
}
catch (ArgumentException)
{
// Do nothing
}
}
isKey = !isKey;
}
if (metadataDictionary.ContainsKey("Comment"))
{
preset.Comment = metadataDictionary["Comment"];
}
if (metadataDictionary.ContainsKey("Author"))
{
preset.Author = metadataDictionary["Author"];
}
ApplyType(int.Parse(metadataDictionary["Type"]), preset);
return(chunkData);
}
public override async Task DoScan()
{
InitDb();
var instruments = GetInstrumentNames();
var instrumentList = GetInstruments(instruments);
var allPresets = GetPresets(instrumentList);
var presetsByPacks = (from p in allPresets
group p by p.Pack.name
into g
select new { Pack = g, Presets = g.ToList() }).ToList();
foreach (var pack in presetsByPacks)
{
var presetBank = RootBank.CreateRecursive(pack.Pack.Key);
foreach (var presetData in pack.Presets)
{
var preset = new PresetParserMetadata
{
BankPath = presetBank.BankPath,
PresetName = presetData.Preset.name,
Author = presetData.SoundDesigner.name,
Comment = presetData.Preset.comment,
Plugin = PluginInstance.Plugin
};
preset.Types.Add(new Type {
TypeName = presetData.Type.name
});
var characteristics = GetPresetCharacteristics(presetData.Preset);
var characteristicsNames = (from c in characteristics select c.name).ToList();
foreach (var name in characteristicsNames)
{
preset.Characteristics.Add(new Characteristic {
CharacteristicName = name
});
}
var fileName = presetData.Preset.file_path.Replace('/', '\\');
var content = File.ReadAllBytes(fileName);
var ms = new MemoryStream();
ms.Write(LittleEndian.GetBytes(content.Length), 0, 4);
ms.WriteByte(0);
ms.WriteByte(0);
ms.WriteByte(0);
ms.WriteByte(0);
ms.Write(LittleEndian.GetBytes(content.Length), 0, 4);
ms.WriteByte(0);
ms.WriteByte(0);
ms.WriteByte(0);
ms.WriteByte(0);
ms.Write(content, 0, content.Length);
ms.Write(content, 0, content.Length);
preset.SourceFile = fileName;
await DataPersistence.PersistPreset(preset, ms.ToArray());
}
}
_db.Close();
_db = null;
await base.DoScan();
}
protected async Task GetPresetsUsingBankTrickery(PresetBank bank, int start, int numPresets, string sourceFile)
{
if (start < 0)
{
Logger.Error("GetPresets start index is less than 0, ignoring. This is probably a bug or a " +
"misconfiguration. Please report this including the full log file.");
return;
}
var endIndex = start + numPresets;
if (endIndex > PluginInstance.Plugin.PluginInfo.ProgramCount)
{
Logger.Error(
$"Tried to retrieve presets between the index {start} and {endIndex}, but this would exceed maximum " +
$"program count of {PluginInstance.Plugin.PluginInfo.ProgramCount}, ignoring. You might wish to " +
"report this as a bug.");
return;
}
for (var index = start; index < endIndex; index++)
{
PluginInstance.SetProgram(0);
PluginInstance.PerformIdleLoop(10);
var programBackup = PluginInstance.GetChunk(true);
PluginInstance.SetProgram(index);
PluginInstance.PerformIdleLoop(10);
var programName = PluginInstance.GetCurrentProgramName();
var fullSourceFile = sourceFile + ":" + index;
var vstPreset = new PresetParserMetadata
{
SourceFile = fullSourceFile,
BankPath = bank.BankPath,
PresetName = programName,
Plugin = PluginInstance.Plugin
};
var realProgram = PluginInstance.GetChunk(true);
PluginInstance.SetProgram(0);
PluginInstance.PerformIdleLoop(10);
PluginInstance.SetChunk(realProgram, true);
PluginInstance.PerformIdleLoop(10);
var presetData = PluginInstance.GetChunk(false);
// Restore original program 0
PluginInstance.SetChunk(programBackup, true);
PluginInstance.PerformIdleLoop(10);
var hash = HashUtils.getIxxHash(presetData);
if (PresetHashes.ContainsKey(hash))
{
Logger.Warning(
$"Skipping program {index} with name {programName} because a program with the same data " +
$"was already added ({PresetHashes[hash]}. Please report this if you think if it's a bug.");
}
else
{
PresetHashes.Add(hash, fullSourceFile + " " + programName);
await DataPersistence.PersistPreset(vstPreset, presetData);
}
}
}
protected virtual void PostProcessPreset(PresetParserMetadata metadata, RolandConverter converter)
{
}
protected override void PostProcessPreset(PresetParserMetadata metadata, RolandConverter converter)
{
string typeName = null;
string subTypeName = null;
string characteristicName = null;
switch (converter.GetMemoryValue("fm.pat.com.patCategory"))
{
case 1: // AC.PIANO
typeName = "Piano / Keys";
characteristicName = "Acoustic";
break;
case 2: // EL.PIANO
typeName = "Piano / Keys";
subTypeName = "Electric Piano";
break;
case 3: // KEYBOARDS
typeName = "Piano / Keys";
break;
case 4: // BELL
typeName = "Mallet Instruments";
subTypeName = "Bell";
break;
case 5: // MALLET
typeName = "Mallet Instruments";
break;
case 6: // ORGAN
typeName = "Organ";
break;
case 7: // ACCORDION
typeName = "Organ";
subTypeName = "Accordion";
break;
case 8: // HARMONICA
typeName = "Reed Instruments";
subTypeName = "Harmonica";
break;
case 9: // AC.GUITAR
typeName = "Guitar";
subTypeName = "Acoustic";
characteristicName = "Acoustic";
break;
case 10: // EL.GUITAR
typeName = "Guitar";
subTypeName = "Electric";
characteristicName = "Electric";
break;
case 11: // DIST.GUITAR
typeName = "Guitar";
subTypeName = "Electric";
characteristicName = "Distorted";
break;
case 12: // BASS
typeName = "Bass";
break;
case 13: // SYNTH BASS
typeName = "Synth Bass";
break;
case 14: // STRINGS
typeName = "Bowed Strings";
break;
case 15: // ORCHESTRA
typeName = "Gerne";
subTypeName = "Orchestral";
break;
case 16: // HIT&STAB
characteristicName = "Stabs & Hits";
break;
case 17: // WIND
typeName = "Ethnic World";
subTypeName = "Flutes & Wind";
break;
case 18: // FLUTE
typeName = "Flute";
break;
case 19: // AC.BRASS
typeName = "Brass";
break;
case 20: // SYNTH BRASS
typeName = "Brass";
subTypeName = "Synth";
characteristicName = "Synthetic";
break;
case 21: // SAX
typeName = "Reed Instruments";
subTypeName = "Saxophone";
break;
case 22: // HARD LEAD
typeName = "Synth Lead";
characteristicName = "Hard";
break;
case 23: // SOFT LEAD
typeName = "Synth Lead";
characteristicName = "Soft / Warm";
break;
case 24: // TECHNO SYNTH
typeName = "Genre";
subTypeName = "Techno";
break;
case 25: // PULSATING
typeName = "Arp/Sequence";
subTypeName = "Pulsing";
break;
case 26: // SYNTH FX
typeName = "Synth Misc";
subTypeName = "FX";
break;
case 27: // OTHER SYNTH
typeName = "Synth Misc";
break;
case 28: // BRIGHT PAD
typeName = "Synth Pad";
characteristicName = "Bright";
break;
case 29: // SOFT PAD
typeName = "Synth Pad";
characteristicName = "Soft / Warm";
break;
case 30: // VOX
characteristicName = "Vox";
break;
case 31: // PLUCKED
characteristicName = "Pluck";
break;
case 32: // ETHNIC
typeName = "Ethnic World";
break;
case 33: // FRETTED
break;
case 34: // PERCUSSION
typeName = "Percussion";
break;
case 35: // SOUND FX
typeName = "Sound Effects";
break;
case 36: // BEAT&GROOVE
break;
case 37: // DRUMS
typeName = "Drums";
break;
case 38: // COMBINATION
typeName = "Combination";
break;
}
if (typeName != null)
{
metadata.Types.Add(new Type()
{
TypeName = typeName, SubTypeName = subTypeName
});
}
if (characteristicName != null)
{
metadata.Characteristics.Add(new Characteristic()
{
CharacteristicName = characteristicName
});
}
}
static void Main(string[] args)
{
var file =
//@"C:\Program Files\Applied Acoustics Systems\String Studio VS-3\Factory Library\Factory Library.VS-3 Pack";
@"C:\Users\Drachenkatze\AppData\Roaming\Applied Acoustics Systems\Lounge Lizard Session 4\Banks\Lounge Lizard Session.LLS4 Bank";
var fileData = File.ReadAllText(file);
//fileData = fileData.Replace("\n", "");
//fileData = fileData.Replace("\r", "");
Script script = new Script();
script.DebuggerEnabled = false;
script.Options.ScriptLoader = new MyCustomScriptLoader()
{
ModulePaths = new string[] { "?_module.lua" }
};
script.DoString(VendorResources.AppliedAcousticSystems_LibraryParser);
var func = script.Globals.Get("loadLibrary");
var sw = new Stopwatch();
sw.Start();
var result = script.Call(func, fileData, "Factory", "Factory Library", file);
var p = new PresetParserMetadata();
foreach (var table in result.Table.Values)
{
File.WriteAllText(@"C:\Users\Drachenkatze\Documents\PresetMagician\test.dat",
(string)table.Table["presetData"]);
Console.WriteLine(table.Table["presetName"]);
Console.WriteLine(table.Table["rawMetaData"]);
var metadata = (Table)table.Table["metaData"];
if (metadata != null)
{
Console.WriteLine(metadata["modes"].GetType().FullName);
if (metadata["creator"] != null)
{
p.Author = (string)metadata["creator"];
}
if (metadata["comment"] != null)
{
p.Comment = (string)metadata["comment"];
}
var modes = (Table)metadata["modes"];
if (modes != null)
{
foreach (var mode in modes.Values)
{
p.Characteristics.Add(new Characteristic()
{
CharacteristicName = mode.String
});
Console.WriteLine(mode.String);
}
}
var categories = (Table)metadata["categories"];
if (categories != null)
{
foreach (var category in categories.Values)
{
var splittedString = category.String.Split('.');
if (splittedString.Length == 2)
{
p.Types.Add(new Type()
{
TypeName = splittedString[0], SubTypeName = splittedString[1]
});
}
if (splittedString.Length == 1)
{
p.Types.Add(new Type()
{
TypeName = splittedString[0]
});
}
}
}
}
}
}
private void ApplyMetadata(FileSystemFile file, PresetParserMetadata metadata)
{
if (file.Attributes.ContainsKey("Author") && file.Attributes["Author"].Count > 0)
{
metadata.Author = string.Join(", ", file.Attributes["Author"]);
}
if (file.Attributes.ContainsKey("Description") && file.Attributes["Description"].Count > 0)
{
metadata.Comment = string.Join(Environment.NewLine, file.Attributes["Description"]);
}
if (file.Attributes.ContainsKey("Category"))
{
foreach (var category in file.Attributes["Category"])
{
metadata.Types.Add(new Type {
TypeName = category
});
}
}
if (file.Attributes.ContainsKey("Complexity"))
{
foreach (var category in file.Attributes["Complexity"])
{
metadata.Characteristics.Add(new Characteristic {
CharacteristicName = category
});
}
}
if (file.Attributes.ContainsKey("Gender"))
{
foreach (var category in file.Attributes["Gender"])
{
metadata.Characteristics.Add(new Characteristic {
CharacteristicName = category
});
}
}
if (file.Attributes.ContainsKey("Technique"))
{
foreach (var category in file.Attributes["Technique"])
{
metadata.Characteristics.Add(new Characteristic {
CharacteristicName = category
});
}
}
if (file.Attributes.ContainsKey("Type"))
{
foreach (var category in file.Attributes["Type"])
{
metadata.Types.Add(new Type {
TypeName = category
});
}
}
}
