Plugin.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Reflection;
using System.Threading.Tasks;
using System.Windows;

using NAudio.Wave;

using NWaves.Transforms;

using QuickLook.Common.Helpers;
using QuickLook.Common.Plugin;

using ScottPlot;
using ScottPlot.Interactivity.UserActionResponses;
using ScottPlot.TickGenerators;
using ScottPlot.WPF;

namespace QuickLook.Plugin.WavLabelViewer
{
    public class Plugin : IViewer
    {
        public int Priority => 0;

        private string DllLocation;

        public bool IsSettingsUpdated = false;

        public void Init()
        {
            this.DllLocation = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);

            AppDomain.CurrentDomain.ReflectionOnlyAssemblyResolve += AssemblyResolve;
            AppDomain.CurrentDomain.AssemblyResolve += AssemblyResolve;
        }

        public bool CanHandle(string path)
        {
            if (!Directory.Exists(path))
            {
                var ext = Path.GetExtension(path).ToLower();
                return ext == ".lab";
            }
            return false;
        }

        public void Prepare(string path, ContextObject context)
        {
            var max = WindowHelper.GetCurrentDesktopSize();
            context.PreferredSize = new Size(max.Width * 0.75, max.Height * 0.75);
        }

        public void View(string path, ContextObject context)
        {
            if (!this.IsSettingsUpdated)
            {
                Settings.Update();
                this.IsSettingsUpdated = true;
            }

            var settings = Settings.Load();

            var wavpath = Path.ChangeExtension(path, ".wav");
            var labpath = Path.ChangeExtension(path, ".lab");

            bool isWavExists = File.Exists(wavpath);

            var labels = LabelLine.LoadFrom(labpath);

            var viewer = new WpfPlot();
            var plot = viewer.Plot;

            double duration = labels[labels.Length - 1].End;

            viewer.Menu.AddSeparator();

            viewer.UserInputProcessor.RemoveAll<DoubleClickBenchmark>();
            //viewer.UserInputProcessor.RemoveAll<MouseDragPan>();
            //viewer.UserInputProcessor.RemoveAll<MouseDragZoom>();
            //viewer.UserInputProcessor.UserActionResponses.Add(new MouseDragPan(StandardMouseButtons.Right));
            viewer.UserInputProcessor.Enable();

            static string SampleCountToTimeTickFormatter(double position)
            {
                if (position == 0)
                    return "0s";
                else
                    return $"{position:f2}s";
            }

            plot.Axes.Left.RemoveTickGenerator();
            plot.Axes.Bottom.TickGenerator = new NumericAutomatic() { LabelFormatter = SampleCountToTimeTickFormatter };

            //plot.Add.Palette = new ScottPlot.Palettes.Penumbra();

            if (OSThemeHelper.AppsUseDarkTheme())
            {
                // change figure colors
                plot.FigureBackground.Color = Color.FromHex("#181818");
                plot.DataBackground.Color = Color.FromHex("#1f1f1f");

                // change axis and grid colors
                plot.Axes.Color(Color.FromHex("#d7d7d7"));
                plot.Grid.MajorLineColor = Color.FromHex("#404040");

                // change legend colors
                plot.Legend.BackgroundColor = Color.FromHex("#404040");
                plot.Legend.FontColor = Color.FromHex("#d7d7d7");
                plot.Legend.OutlineColor = Color.FromHex("#d7d7d7");

                plot.Grid.YAxisStyle.MajorLineStyle.IsVisible = false;
                plot.Grid.XAxisStyle.MajorLineStyle.Color = Color.FromHex("#545a6a");
            }

            if (isWavExists)
            {
                using var audio = new WaveFileReader(wavpath);
                var reader = audio.ToSampleProvider().ToMono();
                var sampleCount = audio.Length / audio.WaveFormat.BlockAlign;
                float[] samples = new float[sampleCount];
                var wf = audio.WaveFormat;
                var wavDuration = sampleCount / (double)wf.SampleRate;

                if (duration < wavDuration)
                    duration = wavDuration;

                float[] buffer = new float[4096];
                int samplesIndex = 0;
                int samplesRead = 0;
                do
                {
                    samplesRead = reader.Read(buffer, 0, buffer.Length);
                    unsafe
                    {
                        fixed (float* floatPtr = buffer)
                        fixed (float* shortPtr = samples)
                        {
                            for (int i = 0; i < samplesRead; i++)
                            {
                                *(shortPtr + samplesIndex + i) = *(floatPtr + i);
                            }
                        }
                    }
                    samplesIndex += samplesRead;
                } while (samplesRead > 0);

                var fftSize = settings.FFTSize;
                var hopSize = settings.HopSize;
                var windowType = settings.WindowType;

                int frameSize = fftSize;
                int fftBins = fftSize / 2 + 1;
                int frameCount = (samples.Length - frameSize) / hopSize + 1;

                var spectrogram = new double[fftBins, frameCount];

                var window = NWaves.Windows.Window.OfType(windowType, frameSize);

                Parallel.For(0, frameCount, frameIndex => {
                    var fft = new Fft(fftSize);

                    var re = new float[fftSize];
                    var im = new float[fftSize];

                    int pos = frameIndex * hopSize;

                    for (int n = 0; n < frameSize; n++)
                        re[n] = samples[pos + n] * window[n];

                    fft.Direct(re, im);

                    for (int k = 0; k < fftBins; k++)
                    {
                        var mag = Math.Sqrt(re[k] * re[k] + im[k] * im[k]);
                        spectrogram[(fftBins - 1) - k, frameIndex] = 20 * Math.Log10(mag + 1e-10f);
                    }
                });

                double freq = (fftBins - 1) * ((wf.SampleRate / 2) / (fftBins - 1));
                var logYMax = Math.Log10(freq + 1);

                var heatmapAxis = plot.Axes.AddLeftAxis();
                heatmapAxis.RemoveTickGenerator();

                LogMinorTickGenerator minorTickGen = new();
                NumericAutomatic tickGen = new() {
                    MinorTickGenerator = minorTickGen
                };
                heatmapAxis.TickGenerator = tickGen;
                heatmapAxis.IsVisible = false;

                var heatmapPlot = plot.Add.Heatmap(spectrogram);
                heatmapPlot.IsVisible = settings.ShowSpectrogram;
                heatmapPlot.Axes.YAxis = heatmapAxis;
                heatmapPlot.Extent = new CoordinateRect(0, duration, 0, logYMax);
                heatmapPlot.Colormap = new ScottPlot.Colormaps.Inferno();
                heatmapPlot.Update();

                if (settings.UseAxesLock)
                {
                    plot.Axes.Rules.Add(new PlotAxisLimitRule(new AxisLimits(0.0, duration, 0, logYMax), heatmapAxis));
                    plot.Axes.Rules.Add(new PlotAxisFixedLimitRule(new CoordinateRange(0, logYMax), heatmapAxis));
                }

                var signalPlot = plot.Add.SignalConst(samples, 1.0 / wf.SampleRate);
                signalPlot.IsVisible = settings.ShowWaveform;
                signalPlot.Color = Colors.Blue.WithAlpha(0.5);

                viewer.Menu.Add("Toggle Waveform", (p) => {
                    settings.ShowWaveform = !settings.ShowWaveform;
                    signalPlot.IsVisible = settings.ShowWaveform;
                    viewer.Refresh();
                    settings.Save();
                });
                viewer.Menu.Add("Toggle Spectrogram", (p) => {
                    settings.ShowSpectrogram = !settings.ShowSpectrogram;
                    heatmapPlot.IsVisible = settings.ShowSpectrogram;
                    viewer.Refresh();
                    settings.Save();
                });
            }

            if (settings.UseAxesLock)
            {
                plot.Axes.Rules.Add(new PlotAxisLimitRule(new AxisLimits(0.0, duration, -1f, 1f), plot.Axes.Left));
                plot.Axes.Rules.Add(new PlotAxisFixedLimitRule(new CoordinateRange(-1f, 1f), plot.Axes.Left));
            }

            var labelSpans = new List<LabelSpan>();
            var labelSpanLineStyleColor = Colors.Red;
            var labelSpanFillStyleColor = Colors.Transparent;
            //var labelSpanFillStyleColor = labelSpanLineStyleColor.WithAlpha(0.15);
            foreach (var label in labels)
            {
                LabelSpan labelSpan = new(label) {
                    IsVisible = settings.ShowLabels
                };
                labelSpan.LineStyle.Color = labelSpanLineStyleColor;
                labelSpan.FillStyle.Color = labelSpanFillStyleColor;
                plot.PlottableList.Add(labelSpan);
                labelSpans.Add(labelSpan);
            }

            viewer.Menu.Add("Toggle Label", (p) => {
                settings.ShowLabels = !settings.ShowLabels;
                foreach (var labelSpan in labelSpans)
                    labelSpan.IsVisible = settings.ShowLabels;
                viewer.Refresh();
                settings.Save();
            });

            viewer.Refresh();

            context.ViewerContent = viewer;
            context.Title = Path.GetFileName(path);

            context.IsBusy = false;
        }

        public void Cleanup()
        {
            AppDomain.CurrentDomain.ReflectionOnlyAssemblyResolve -= AssemblyResolve;
            AppDomain.CurrentDomain.AssemblyResolve -= AssemblyResolve;
        }

        private Assembly AssemblyResolve(object sender, ResolveEventArgs e)
        {
            var assemblyPath = Path.Combine(this.DllLocation, new AssemblyName(e.Name).Name + ".dll");
            if (File.Exists(assemblyPath))
                return Assembly.LoadFrom(assemblyPath);
            else if (Environment.Is64BitProcess)
            {
                assemblyPath = Path.Combine(this.DllLocation, "x64", new AssemblyName(e.Name).Name + ".dll");
                if (File.Exists(assemblyPath))
                    return Assembly.LoadFrom(assemblyPath);
            }
            else
            {
                assemblyPath = Path.Combine(this.DllLocation, "x86", new AssemblyName(e.Name).Name + ".dll");
                if (File.Exists(assemblyPath))
                    return Assembly.LoadFrom(assemblyPath);
            }

            return null;
        }
    }
}