public override async Task DoScan()
        {
            await PluginInstance.LoadPlugin();

            DeterminateVstPresetSaveMode();
            await GetFactoryPresets();

            await base.DoScan();
        }
        private async Task ParseAdditionalBanks()
        {
            await PluginInstance.LoadPlugin();

            DeterminateVstPresetSaveMode();

            foreach (var bank in AdditionalBankFiles)
            {
                var result = LoadFxp(bank.Path);

                if (result == VstUtils.LoadFxpResult.Error)
                {
                    continue;
                }

                var presetBank = RootBank.CreateRecursive(bank.BankName);

                // ReSharper disable once SwitchStatementMissingSomeCases
                switch (result)
                {
                case VstUtils.LoadFxpResult.Program:
                    await GetPresets(presetBank, 0, 1, bank.Path);

                    break;

                case VstUtils.LoadFxpResult.Bank:
                {
                    var ranges = bank.GetProgramRanges();

                    if (ranges.Count == 0)
                    {
                        await GetPresets(presetBank, 0, PluginInstance.Plugin.PluginInfo.ProgramCount, bank.Path);
                    }
                    else
                    {
                        foreach (var(start, length) in ranges)
                        {
                            await GetPresets(presetBank, start - 1, length, bank.Path);
                        }
                    }

                    break;
                }
                }
            }
        }
Example #3
0
        public override async Task DoScan()
        {
            await PluginInstance.LoadPlugin();

            await base.DoScan();
        }
        public void DeterminateVstPresetSaveMode()
        {
            if (PresetSaveMode != PresetSaveModes.NotYetDetermined)
            {
                return;
            }

            if (PluginInstance.Plugin.PluginType == Plugin.PluginTypes.Unknown)
            {
                PresetSaveMode = PresetSaveModes.None;
                Logger.Info(
                    "Unknown plugin type, setting preset save mode to none");
                return;
            }

            if ((PluginInstance.Plugin.PluginInfo.Flags & VstPluginFlags.ProgramChunks) == 0)
            {
                PresetSaveMode = PresetSaveModes.None;
                Logger.Info(
                    "Plugin does not support program chunks, setting preset save mode to none");
                return;
            }

            if (PluginInstance.Plugin.PluginInfo.ProgramCount > 1)
            {
                PluginInstance.LoadPlugin().Wait();
                Logger.Debug(PluginInstance.Plugin.PluginName +
                             ": Program count is greater than 1, checking for preset save mode");

                if (AreChunksNull(false))
                {
                    // Bank chunks are null, can't use for NKS
                    PresetSaveMode = PresetSaveModes.None;
                    Logger.Debug(PluginInstance.Plugin.PluginName +
                                 ": Bank chunks are null, unable to use this plugin with NKS");
                    return;
                }

                if (!AreChunksConsistent(false))
                {
                    PresetSaveMode = PresetSaveModes.Fallback;
                    Logger.Info(
                        "Using preset save mode fallback");
                    return;
                }

                Logger.Debug(PluginInstance.Plugin.PluginName + ": bank chunks are consistent");

                if (IsCurrentProgramStoredInBankChunk())
                {
                    Logger.Debug(PluginInstance.Plugin.PluginName +
                                 ": current program is stored in the bank chunk");
                    PresetSaveMode = PresetSaveModes.FullBank;
                    Logger.Info(
                        "Using preset save mode full bank");
                    return;

                    // Perfect, just put out the full bank chunk. Nothing to do here.
                }

                // Trick Maschine by getting the program chunk, save it to program 0, get the bank chunk,
                // save the preset and restore the original program 0
                if (!AreChunksNull(true))
                {
                    if (AreChunksConsistent(true))
                    {
                        Logger.Debug(PluginInstance.Plugin.PluginName +
                                     ": program chunks are consistent");
                        PresetSaveMode = PresetSaveModes.BankTrickery;
                        Logger.Info(
                            "Using preset save mode bank trickery");
                        return;
                    }

                    PresetSaveMode = PresetSaveModes.Fallback;
                    Logger.Info(
                        "Using preset save mode fallback");
                    return;
                }

                PresetSaveMode = PresetSaveModes.None;
                Logger.Info(
                    "Using preset save mode none");
                return;
            }

            Logger.Info(
                "Plugin reported a program count of 0 or 1, using preset save mode none");
            PresetSaveMode = PresetSaveModes.None;
        }
 public override int GetNumPresets()
 {
     PluginInstance.LoadPlugin().Wait();
     return(base.GetNumPresets() + PluginInstance.Plugin.PluginInfo.ProgramCount);
 }