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 }); } } }