コード例 #1
0
ファイル: ExportTest.cs プロジェクト: terminar/PresetMagician
        private void TestExportInternal(Plugin.PluginTypes pluginType, string expectedExtension)
        {
            var outputDir = Path.Combine(Directory.GetCurrentDirectory(), @"TestData\PresetExport");

            Directory.CreateDirectory(outputDir);

            foreach (var file in Directory.EnumerateFiles(outputDir, "*", SearchOption.AllDirectories))
            {
                File.Delete(file);
            }

            var plugin = GetTestPlugin(pluginType);

            TestBankPath1Levels(outputDir, pluginType, expectedExtension);
            TestBankPath2Levels(outputDir, pluginType, expectedExtension);
            TestBankPath3Levels(outputDir, pluginType, expectedExtension);
            TestBankPath4Levels(outputDir, pluginType, expectedExtension);

            var existingDefaultPreset = new Preset();

            existingDefaultPreset.Plugin              = plugin;
            existingDefaultPreset.PresetId            = "a6d4d311-6856-ffff-863b-d90b3240b085";
            existingDefaultPreset.Metadata.PresetName = "Default";
            existingDefaultPreset.Metadata.BankPath   = "Factory/Default/Crazy";

            var exporter = new NKSExport(null);
            var existingPresetExportInfo = new PresetExportInfo(existingDefaultPreset);

            existingPresetExportInfo.UserContentDirectory = outputDir;
            existingPresetExportInfo.FolderMode           = PresetExportInfo.FolderExportMode.ONE_LEVEL_LAST_BANK;

            exporter.ExportNKSPreset(existingPresetExportInfo, new byte[] { 0xFF });

            existingDefaultPreset.PresetId = "ffffff11-6856-ffff-863b-d90b3240b085";

            existingPresetExportInfo = new PresetExportInfo(existingDefaultPreset);
            existingPresetExportInfo.UserContentDirectory = outputDir;
            existingPresetExportInfo.FolderMode           = PresetExportInfo.FolderExportMode.ONE_LEVEL_LAST_BANK;

            existingPresetExportInfo.CanExport().Should().BeFalse();

            existingPresetExportInfo = new PresetExportInfo(existingDefaultPreset);
            existingPresetExportInfo.UserContentDirectory = outputDir;
            existingPresetExportInfo.FolderMode           = PresetExportInfo.FolderExportMode.ONE_LEVEL_LAST_BANK;
            existingPresetExportInfo.OverwriteMode        = PresetExportInfo.FileOverwriteMode.APPEND_GUID;

            MakeRelative(existingPresetExportInfo).Should()
            .Be(@"SuperDuperPlugin\Crazy\Default.ffffff11-6856-ffff-863b-d90b3240b085" + expectedExtension);

            existingPresetExportInfo = new PresetExportInfo(existingDefaultPreset);
            existingPresetExportInfo.UserContentDirectory = outputDir;
            existingPresetExportInfo.FolderMode           = PresetExportInfo.FolderExportMode.ONE_LEVEL_LAST_BANK;
            existingPresetExportInfo.OverwriteMode        = PresetExportInfo.FileOverwriteMode.FORCE_OVERWRITE;

            MakeRelative(existingPresetExportInfo).Should()
            .Be(@"SuperDuperPlugin\Crazy\Default" + expectedExtension);
        }
コード例 #2
0
        protected override async Task ExecuteAsync(object parameter)
        {
            var pluginPresets = from item in _globalFrontendService.PresetExportList
                                group item by item.Plugin
                                into pluginGroup
                                let first = pluginGroup.First()
                                            select new
            {
                first.Plugin,
                Presets = pluginGroup.Select(gi => new { Preset = gi })
            };

            int totalPresets  = _globalFrontendService.PresetExportList.Count;
            int currentPreset = 0;

            _applicationService.StartApplicationOperation(this, "Exporting Presets",
                                                          totalPresets);
            var progress = _applicationService.GetApplicationProgress();

            await TaskHelper.Run(async() =>
            {
                var exportDirectory = _globalService.RuntimeConfiguration
                                      .NativeInstrumentsUserContentDirectory;

                if (!Directory.Exists(exportDirectory))
                {
                    LogTo.Warning($"Directory {exportDirectory} does not exist, using the default");
                }

                foreach (var pluginPreset in pluginPresets)
                {
                    Preset lastPreset = null;
                    try
                    {
                        await _presetDataPersisterService.OpenDatabase();

                        if (pluginPreset.Plugin.PresetParser == null)
                        {
                            _applicationService.AddApplicationOperationError(
                                $"Unable to update export presets for {pluginPreset.Plugin.PluginName} because it has no Preset Parser. Try to force-reload metadata for this plugin.");
                            continue;
                        }


                        using (var remotePluginInstance =
                                   _remoteVstService.GetRemotePluginInstance(pluginPreset.Plugin, false))
                        {
                            foreach (var preset in pluginPreset.Presets)
                            {
                                lastPreset = preset.Preset;
                                currentPreset++;
                                _applicationService.UpdateApplicationOperationStatus(
                                    currentPreset,
                                    $"Exporting {pluginPreset.Plugin.PluginName} - {preset.Preset.Metadata.PresetName}");

                                if (progress.CancellationToken.IsCancellationRequested)
                                {
                                    return;
                                }

                                var presetData = await _presetDataPersisterService.GetPresetData(preset.Preset);

                                if (preset.Preset.PresetBank == null)
                                {
                                    preset.Preset.PresetBank = preset.Preset.Plugin.RootBank;
                                    LogTo.Warning(
                                        $"Preset {preset.Preset.Metadata.PresetName} has no preset bank, using none.");
                                }

                                var presetExportInfo = new PresetExportInfo(preset.Preset)
                                {
                                    FolderMode           = _globalService.RuntimeConfiguration.FolderExportMode,
                                    OverwriteMode        = _globalService.RuntimeConfiguration.FileOverwriteMode,
                                    UserContentDirectory = exportDirectory
                                };

                                if (!presetExportInfo.CanExport())
                                {
                                    _applicationService.AddApplicationOperationError(
                                        $"Cannot export {preset.Preset.Plugin} -{preset.Preset.Metadata.PresetName}. " +
                                        $"Reason: {presetExportInfo.CannotExportReason}");
                                    continue;
                                }

                                pluginPreset.Plugin.PresetParser.PluginInstance = remotePluginInstance;

                                if (_globalService.RuntimeConfiguration.ExportWithAudioPreviews &&
                                    pluginPreset.Plugin.PluginType == Plugin.PluginTypes.Instrument)
                                {
                                    await remotePluginInstance.LoadPlugin().ConfigureAwait(false);
                                    pluginPreset.Plugin.PresetParser.OnPluginLoad();
                                    remotePluginInstance.SetChunk(presetData, false);

                                    remotePluginInstance.ExportNksAudioPreview(presetExportInfo, presetData,
                                                                               preset.Preset.Plugin.GetAudioPreviewDelay());
                                }

                                remotePluginInstance.ExportNks(presetExportInfo, presetData);


                                pluginPreset.Plugin.PresetParser.OnAfterPresetExport();
                                preset.Preset.LastExported = DateTime.Now;
                                preset.Preset.UpdateLastExportedMetadata();
                            }

                            if (remotePluginInstance.IsLoaded)
                            {
                                pluginPreset.Plugin.PresetParser.OnPluginUnload();
                            }

                            remotePluginInstance.UnloadPlugin();
                        }
                    }
                    catch (Exception e)
                    {
                        var errorMessage =
                            $"Unable to export presets for {pluginPreset.Plugin.PluginName} because of {e.GetType().FullName}: {e.Message}. ";

                        if (lastPreset != null)
                        {
                            errorMessage +=
                                $"The preset causing the error was: {lastPreset.Metadata.PresetName} in bank path {lastPreset.Metadata.BankPath}";
                        }

                        _applicationService.AddApplicationOperationError(
                            errorMessage
                            );
                        LogTo.Debug(e.StackTrace);
                    }

                    await _presetDataPersisterService.CloseDatabase();

                    _dataPersisterService.SavePresetsForPlugin(pluginPreset.Plugin);
                }
            });

            _applicationService.StopApplicationOperation("Export completed");
        }