diff --git a/UVtools.GUI/Forms/FrmBenchmark.cs b/UVtools.GUI/Forms/FrmBenchmark.cs
index bba8f82..c3ddc94 100644
--- a/UVtools.GUI/Forms/FrmBenchmark.cs
+++ b/UVtools.GUI/Forms/FrmBenchmark.cs
@@ -182,6 +182,18 @@ namespace UVtools.GUI.Forms
             progressBar.Style = ProgressBarStyle.Blocks;
         }
 
+        private void UpdateResults(bool isSingleThread, long milliseconds)
+        {
+            decimal seconds = Math.Round(milliseconds / 1000m, 2);
+            //var text = (isSingleThread ? "Single" : "Multi") + $" Thread: {Math.Round(SingleThreadTests / seconds, 2)} OPS ({seconds}s)";
+
+            if(isSingleThread)
+                lbSingleThreadResults.Text = $"Single Thread: {Math.Round(SingleThreadTests / seconds, 2)} {RunsAbbreviation} ({SingleThreadTests} tests / {seconds}s)";
+            else
+                lbMultiThreadResults.Text = $"Multi Thread: {Math.Round(MultiThreadTests / seconds, 2)} {RunsAbbreviation} ({MultiThreadTests} tests / {seconds}s)"; ;
+        }
+
+        #region Tests
         public byte[] EncodeCbddlpImage(Mat image, byte bit = 0)
         {
             List<byte> rawData = new List<byte>();
@@ -238,7 +250,7 @@ namespace UVtools.GUI.Forms
             // Collect stragglers
             AddRep();
 
-            
+
             return rawData.ToArray();
         }
 
@@ -385,19 +397,6 @@ namespace UVtools.GUI.Forms
             return rawData.ToArray();
         }
 
-        private void UpdateResults(bool isSingleThread, long milliseconds)
-        {
-            decimal seconds = Math.Round(milliseconds / 1000m, 2);
-            //var text = (isSingleThread ? "Single" : "Multi") + $" Thread: {Math.Round(SingleThreadTests / seconds, 2)} OPS ({seconds}s)";
-
-            if(isSingleThread)
-                lbSingleThreadResults.Text = $"Single Thread: {Math.Round(SingleThreadTests / seconds, 2)} {RunsAbbreviation} ({SingleThreadTests} tests / {seconds}s)";
-            else
-                lbMultiThreadResults.Text = $"Multi Thread: {Math.Round(MultiThreadTests / seconds, 2)} {RunsAbbreviation} ({MultiThreadTests} tests / {seconds}s)"; ;
-        }
-
-        #region Tests
-
         public Mat RandomMat(int width, int height)
         {
             var bytes = new byte[width * height];
diff --git a/UVtools.WPF/MainWindow.axaml.cs b/UVtools.WPF/MainWindow.axaml.cs
index 4183b40..8d7b901 100644
--- a/UVtools.WPF/MainWindow.axaml.cs
+++ b/UVtools.WPF/MainWindow.axaml.cs
@@ -618,6 +618,11 @@ namespace UVtools.WPF
             await new AboutWindow().ShowDialog(this);
         }
 
+        public async void MenuHelpBenchmarkClicked()
+        {
+            await new BenchmarkWindow().ShowDialog(this);
+        }
+
         public async void MenuHelpInstallProfilesClicked()
         {
             var PEFolder = App.GetPrusaSlicerDirectory();
diff --git a/UVtools.WPF/Structures/BenchmarkTest.cs b/UVtools.WPF/Structures/BenchmarkTest.cs
new file mode 100644
index 0000000..b349bbb
--- /dev/null
+++ b/UVtools.WPF/Structures/BenchmarkTest.cs
@@ -0,0 +1,34 @@
+/*
+ *                     GNU AFFERO GENERAL PUBLIC LICENSE
+ *                       Version 3, 19 November 2007
+ *  Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ *  Everyone is permitted to copy and distribute verbatim copies
+ *  of this license document, but changing it is not allowed.
+ */
+namespace UVtools.WPF.Structures
+{
+    public sealed class BenchmarkTest
+    {
+        public const string DEVCPU = "Intel® Core™ i9-9900K @ 3.60 GHz";
+        public const string DEVRAM = "G.SKILL Trident Z 32GB DDR4-3200MHz CL14";
+
+        public BenchmarkTest(string name, string functionName, float devSingleThreadResult = 0, float devMultiThreadResult = 0)
+        {
+            Name = name;
+            FunctionName = functionName;
+            DevSingleThreadResult = devSingleThreadResult;
+            DevMultiThreadResult = devMultiThreadResult;
+        }
+
+        public string Name { get; }
+        public string FunctionName { get; }
+
+        public float DevSingleThreadResult { get; }
+        public float DevMultiThreadResult { get; }
+
+        public override string ToString()
+        {
+            return $"{Name}";
+        }
+    }
+}
diff --git a/UVtools.WPF/UVtools.WPF.csproj b/UVtools.WPF/UVtools.WPF.csproj
index 2575258..249e72b 100644
--- a/UVtools.WPF/UVtools.WPF.csproj
+++ b/UVtools.WPF/UVtools.WPF.csproj
@@ -24,10 +24,10 @@
     <NoWarn>1701;1702;</NoWarn>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="Avalonia" Version="0.10.999-cibuild0010986-beta" />
+    <PackageReference Include="Avalonia" Version="0.10.999-cibuild0011267-beta" />
     <PackageReference Include="Avalonia.Angle.Windows.Natives" Version="2.1.0.2020091801" />
-    <PackageReference Include="Avalonia.Controls.DataGrid" Version="0.10.999-cibuild0010986-beta" />
-    <PackageReference Include="Avalonia.Desktop" Version="0.10.999-cibuild0010986-beta" />
+    <PackageReference Include="Avalonia.Controls.DataGrid" Version="0.10.999-cibuild0011267-beta" />
+    <PackageReference Include="Avalonia.Desktop" Version="0.10.999-cibuild0011267-beta" />
     <PackageReference Include="Avalonia.ThemeManager" Version="0.10.0-preview3" />
     <PackageReference Include="Dock.Avalonia" Version="0.10.0-preview5" />
     <PackageReference Include="Emgu.CV.runtime.raspbian" Version="4.4.0.4099" />
diff --git a/UVtools.WPF/Windows/BenchmarkWindow.axaml b/UVtools.WPF/Windows/BenchmarkWindow.axaml
new file mode 100644
index 0000000..57b86ac
--- /dev/null
+++ b/UVtools.WPF/Windows/BenchmarkWindow.axaml
@@ -0,0 +1,128 @@
+<Window xmlns="https://github.com/avaloniaui"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+        mc:Ignorable="d" d:DesignWidth="800" d:DesignHeight="450"
+        x:Class="UVtools.WPF.Windows.BenchmarkWindow"
+        Title="Benchmark"
+        Icon="/Assets/Icons/UVtools.ico"
+        SizeToContent="WidthAndHeight"
+        WindowStartupLocation="CenterOwner"
+        CanResize="False"
+        >
+
+  <Grid
+    RowDefinitions="Auto,10,
+    Auto,10,
+    Auto,10,
+    Auto,20,
+    Auto,10,
+    Auto,20,
+    Auto"
+    >
+  <Border
+    Background="WhiteSmoke"
+    Padding="10"
+    BorderBrush="Black"
+    BorderThickness="1"
+    >
+    <TextBlock Text="{Binding Description}"/>
+    
+  </Border>
+
+    <Grid
+      ColumnDefinitions="Auto,10,*"
+      Grid.Row="2"
+      Margin="10"
+      >
+
+      <TextBlock
+        VerticalAlignment="Center"
+        Text="Test:"/>
+      <ComboBox
+        Grid.Column="2"
+        HorizontalAlignment="Stretch"
+        SelectedIndex="{Binding TestSelectedIndex}"
+        Items="{Binding Tests}"
+        IsEnabled="{Binding !IsRunning}"
+        />
+    </Grid>
+
+    <TextBlock
+      Margin="10,0"
+      Grid.Row="4"
+      FontWeight="Bold" Text="Your results:" />
+
+    <Grid
+    Grid.Row="6"  
+    ColumnDefinitions="Auto,5,Auto"
+    RowDefinitions="Auto,5,Auto"
+    Margin="10,0"
+    >
+      <TextBlock 
+        HorizontalAlignment="Right"
+        Text="Single Thread:" />
+      <TextBlock
+        Grid.Column="2"
+        Text="{Binding SingleThreadTDPS}" />
+
+      <TextBlock
+        Grid.Row="2"
+        HorizontalAlignment="Right"
+        Text="Multi Thread:" />
+      <TextBlock
+        Grid.Row="2"
+        Grid.Column="2"
+        Text="{Binding MultiThreadTDPS}" />
+    </Grid>
+
+    <TextBlock
+      Margin="10,0"
+      Grid.Row="8"
+      FontWeight="Bold" Text="Developer results:" />
+
+    <Grid
+    Grid.Row="10"
+    ColumnDefinitions="Auto,5,Auto"
+    RowDefinitions="Auto,5,Auto"
+    Margin="10,0"
+    >
+      <TextBlock
+        HorizontalAlignment="Right"
+        Text="Single Thread:" />
+      <TextBlock
+        Grid.Column="2"
+        Text="{Binding DevSingleThreadTDPS}" />
+
+      <TextBlock
+        Grid.Row="2"
+        HorizontalAlignment="Right"
+        Text="Multi Thread:" />
+      <TextBlock
+        Grid.Row="2"
+        Grid.Column="2"
+        Text="{Binding DevMultiThreadTDPS}" />
+    </Grid>
+
+    <Grid
+    Grid.Row="12"
+    ColumnDefinitions="*,Auto"
+    >
+      <ProgressBar
+         IsIndeterminate="{Binding IsRunning}"
+         IsEnabled="{Binding IsRunning}"
+        />
+
+      <Button 
+        Name="StartStopButton"
+        Grid.Column="1"
+        Padding="40,10"
+        IsDefault="True"
+        Content="{Binding StartStopButtonText}"
+        Command="{Binding StartStop}"
+        />
+      
+    </Grid>
+
+  </Grid>
+</Window>
diff --git a/UVtools.WPF/Windows/BenchmarkWindow.axaml.cs b/UVtools.WPF/Windows/BenchmarkWindow.axaml.cs
new file mode 100644
index 0000000..ec9418c
--- /dev/null
+++ b/UVtools.WPF/Windows/BenchmarkWindow.axaml.cs
@@ -0,0 +1,470 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Drawing;
+using System.Reflection;
+using System.Security.Cryptography;
+using System.Threading;
+using System.Threading.Tasks;
+using Avalonia.Markup.Xaml;
+using Avalonia.Threading;
+using Emgu.CV;
+using Emgu.CV.CvEnum;
+using UVtools.Core.Extensions;
+using UVtools.WPF.Controls;
+using UVtools.WPF.Extensions;
+using UVtools.WPF.Structures;
+
+namespace UVtools.WPF.Windows
+{
+    public class BenchmarkWindow : WindowEx
+    {
+        private int _testSelectedIndex;
+        private string _singleThreadTdps = $"0 {RunsAbbreviation}";
+        private string _multiThreadTdps = $"0 {RunsAbbreviation}";
+        private string _devSingleThreadTdps = $"{Tests[0].DevSingleThreadResult} {RunsAbbreviation}";
+        private string _devMultiThreadTdps = $"{Tests[0].DevMultiThreadResult} {RunsAbbreviation}";
+        private bool _isRunning;
+        private string _startStopButtonText = "Start";
+        private const ushort SingleThreadTests = 100;
+        private const ushort MultiThreadTests = 1000;
+
+        public const string RunsAbbreviation = "TDPS";
+        public const string StressCPUTestName = "Stress CPU (Run until stop)";
+
+        private RNGCryptoServiceProvider _randomProvider = new RNGCryptoServiceProvider();
+
+        private CancellationTokenSource _tokenSource;
+        private CancellationToken _token => _tokenSource.Token;
+
+        public static BenchmarkTest[] Tests =>
+            new[]
+            {
+                new BenchmarkTest("4K Random CBBDLP Enconde", "Test4KRandomCBBDLPEncode", 40.30f, 246.30f),
+                new BenchmarkTest("8K Random CBBDLP Enconde", "Test8KRandomCBBDLPEncode", 9.70f, 64.10f),
+                new BenchmarkTest("4K Random CBT Enconde", "Test4KRandomCBTEncode", 13.50f, 113.30f),
+                new BenchmarkTest("8K Random CBT Enconde", "Test8KRandomCBTEncode", 3.40f, 28.20f),
+                new BenchmarkTest("4K Random PW0 Enconde", "Test4KRandomPW0Encode", 14.10f, 89.00f),
+                new BenchmarkTest("8K Random PW0 Enconde", "Test8KRandomPW0Encode", 3.50f, 22.40f),
+                new BenchmarkTest(StressCPUTestName, "Test4KRandomCBTEncode", 0, 0),
+            };
+
+        public string Description  => "Benchmark your machine against pre-defined tests.\n" +
+                                      "This will use all compution power avaliable, CPU will be exhausted\n." +
+                                      "Run the test while your PC is idle or not in heavy load.\n" +
+                                      "Results are in 'tests done per second' (TDPS)\n" +
+                                      "\n" +
+                                      "To your reference you are competing against developer system:\n"+
+                                      $"CPU: {BenchmarkTest.DEVCPU}\n" +
+                                      $"RAM: {BenchmarkTest.DEVRAM}";
+
+        public int TestSelectedIndex
+        {
+            get => _testSelectedIndex;
+            set
+            {
+                if(!RaiseAndSetIfChanged(ref _testSelectedIndex, value)) return;
+                DevSingleThreadTDPS = $"{Tests[_testSelectedIndex].DevSingleThreadResult} {RunsAbbreviation}";
+                DevMultiThreadTDPS = $"{Tests[_testSelectedIndex].DevMultiThreadResult} {RunsAbbreviation}";
+            }
+        }
+
+        public string SingleThreadTDPS
+        {
+            get => _singleThreadTdps;
+            set => RaiseAndSetIfChanged(ref _singleThreadTdps, value);
+        }
+
+        public string MultiThreadTDPS
+        {
+            get => _multiThreadTdps;
+            set => RaiseAndSetIfChanged(ref _multiThreadTdps, value);
+        }
+
+        public string DevSingleThreadTDPS
+        {
+            get => _devSingleThreadTdps;
+            set => RaiseAndSetIfChanged(ref _devSingleThreadTdps, value);
+        }
+
+        public string DevMultiThreadTDPS
+        {
+            get => _devMultiThreadTdps;
+            set => RaiseAndSetIfChanged(ref _devMultiThreadTdps, value);
+        }
+
+        public string StartStopButtonText
+        {
+            get => _startStopButtonText;
+            set => RaiseAndSetIfChanged(ref _startStopButtonText, value);
+        }
+
+        public bool IsRunning
+        {
+            get => _isRunning;
+            set
+            {
+                if(!RaiseAndSetIfChanged(ref _isRunning, value)) return;
+                StartStopButtonText = _isRunning ? "Stop" : "Start";
+            }
+        }
+
+        public BenchmarkWindow()
+        {
+            InitializeComponent();
+
+            DataContext = this;
+        }
+
+        private void InitializeComponent()
+        {
+            AvaloniaXamlLoader.Load(this);
+        }
+
+        protected override bool HandleClosing() => IsRunning;
+
+        public void StartStop()
+        {
+            if (IsRunning)
+            {
+                if (!_token.CanBeCanceled || _token.IsCancellationRequested) return;
+                _tokenSource.Cancel();
+            }
+            else
+            {
+                BenchmarkTest benchmark = Tests[_testSelectedIndex];
+                SingleThreadTDPS = $"Running {SingleThreadTests} tests";
+                MultiThreadTDPS = $"Running {MultiThreadTests} tests";
+                return;
+                _tokenSource = new CancellationTokenSource();
+                MethodInfo theMethod = GetType().GetMethod(benchmark.FunctionName);
+
+                Task.Factory.StartNew(() =>
+                {
+                    Stopwatch sw = Stopwatch.StartNew();
+                    try
+                    {
+                        if (benchmark.Name.Equals(StressCPUTestName))
+                        {
+                            while (true)
+                            {
+                                if (_token.IsCancellationRequested) break;
+                                Parallel.For(0, MultiThreadTests, i =>
+                                {
+                                    if (_token.IsCancellationRequested) return;
+                                    theMethod.Invoke(this, null);
+                                });
+                            }
+
+                            return;
+                        }
+
+                        
+                        for (int i = 0; i < SingleThreadTests; i++)
+                        {
+                            if (_token.IsCancellationRequested) _token.ThrowIfCancellationRequested();
+                            theMethod.Invoke(this, null);
+                        }
+
+                        sw.Stop();
+                        var singleMiliseconds = sw.ElapsedMilliseconds;
+                        Dispatcher.UIThread.InvokeAsync(() => UpdateResults(true, singleMiliseconds));
+
+                        if (_token.IsCancellationRequested) _token.ThrowIfCancellationRequested();
+
+                        sw.Restart();
+                        Parallel.For(0, MultiThreadTests, i =>
+                        {
+                            if (_token.IsCancellationRequested) return;
+                            theMethod.Invoke(this, null);
+                        });
+
+                        sw.Stop();
+
+                        if (_token.IsCancellationRequested) _token.ThrowIfCancellationRequested();
+                        var multiMiliseconds = sw.ElapsedMilliseconds;
+                        Dispatcher.UIThread.InvokeAsync(() => UpdateResults(false, multiMiliseconds));
+                    }
+                    catch (OperationCanceledException)
+                    {
+
+                    }
+                    catch (Exception ex)
+                    {
+                        Dispatcher.UIThread.InvokeAsync(() => this.MessageBoxError(ex.ToString(), "Error"));
+                        
+                    }
+                    finally
+                    {
+                        Dispatcher.UIThread.InvokeAsync(() => IsRunning = !IsRunning);
+                    }
+                }, _token);
+
+                IsRunning = !IsRunning;
+            }
+        }
+
+        private void UpdateResults(bool isSingleThread, long milliseconds)
+        {
+            decimal seconds = Math.Round(milliseconds / 1000m, 2);
+            //var text = (isSingleThread ? "Single" : "Multi") + $" Thread: {Math.Round(SingleThreadTests / seconds, 2)} OPS ({seconds}s)";
+
+            if (isSingleThread)
+                SingleThreadTDPS = $"{Math.Round(SingleThreadTests / seconds, 2)} {RunsAbbreviation} ({SingleThreadTests} tests / {seconds}s)";
+            else
+                MultiThreadTDPS = $"{Math.Round(MultiThreadTests / seconds, 2)} {RunsAbbreviation} ({MultiThreadTests} tests / {seconds}s)";
+        }
+
+        #region Tests
+        public byte[] EncodeCbddlpImage(Mat image, byte bit = 0)
+        {
+            List<byte> rawData = new List<byte>();
+            var span = image.GetPixelSpan<byte>();
+
+            bool obit = false;
+            int rep = 0;
+
+            //ngrey:= uint16(r | g | b)
+            // thresholds:
+            // aa 1:  127
+            // aa 2:  255 127
+            // aa 4:  255 191 127 63
+            // aa 8:  255 223 191 159 127 95 63 31
+            byte threshold = (byte)(256 / 1 * bit - 1);
+
+            void AddRep()
+            {
+                if (rep <= 0) return;
+
+                byte by = (byte)rep;
+
+                if (obit)
+                {
+                    by |= 0x80;
+                    //bitsOn += uint(rep)
+                }
+
+                rawData.Add(by);
+            }
+
+            for (int pixel = 0; pixel < span.Length; pixel++)
+            {
+                var nbit = span[pixel] >= threshold;
+
+                if (nbit == obit)
+                {
+                    rep++;
+
+                    if (rep == 0x7d)
+                    {
+                        AddRep();
+                        rep = 0;
+                    }
+                }
+                else
+                {
+                    AddRep();
+                    obit = nbit;
+                    rep = 1;
+                }
+            }
+
+            // Collect stragglers
+            AddRep();
+
+
+            return rawData.ToArray();
+        }
+
+        private byte[] EncodeCbtImage(Mat image)
+        {
+            List<byte> rawData = new List<byte>();
+            byte color = byte.MaxValue >> 1;
+            uint stride = 0;
+            var span = image.GetPixelSpan<byte>();
+
+            void AddRep()
+            {
+                if (stride == 0)
+                {
+                    return;
+                }
+
+                if (stride > 1)
+                {
+                    color |= 0x80;
+                }
+                rawData.Add(color);
+
+                if (stride <= 1)
+                {
+                    // no run needed
+                    return;
+                }
+
+                if (stride <= 0x7f)
+                {
+                    rawData.Add((byte)stride);
+                    return;
+                }
+
+                if (stride <= 0x3fff)
+                {
+                    rawData.Add((byte)((stride >> 8) | 0x80));
+                    rawData.Add((byte)stride);
+                    return;
+                }
+
+                if (stride <= 0x1fffff)
+                {
+                    rawData.Add((byte)((stride >> 16) | 0xc0));
+                    rawData.Add((byte)(stride >> 8));
+                    rawData.Add((byte)stride);
+                    return;
+                }
+
+                if (stride <= 0xfffffff)
+                {
+                    rawData.Add((byte)((stride >> 24) | 0xe0));
+                    rawData.Add((byte)(stride >> 16));
+                    rawData.Add((byte)(stride >> 8));
+                    rawData.Add((byte)stride);
+                }
+
+            }
+
+
+            for (int pixel = 0; pixel < span.Length; pixel++)
+            {
+                var grey7 = (byte)(span[pixel] >> 1);
+
+                if (grey7 == color)
+                {
+                    stride++;
+                }
+                else
+                {
+                    AddRep();
+                    color = grey7;
+                    stride = 1;
+                }
+            }
+
+            AddRep();
+
+
+            return rawData.ToArray();
+        }
+
+        public byte[] EncodePW0Image(Mat image)
+        {
+            List<byte> rawData = new List<byte>();
+            var span = image.GetPixelSpan<byte>();
+
+            int lastColor = -1;
+            int reps = 0;
+
+            void PutReps()
+            {
+                while (reps > 0)
+                {
+                    int done = reps;
+
+                    if (lastColor == 0 || lastColor == 0xf)
+                    {
+                        if (done > 0xfff)
+                        {
+                            done = 0xfff;
+                        }
+                        //more:= []byte{ 0, 0}
+                        //binary.BigEndian.PutUint16(more, uint16(done | (color << 12)))
+
+                        //rle = append(rle, more...)
+
+                        ushort more = (ushort)(done | (lastColor << 12));
+                        rawData.Add((byte)(more >> 8));
+                        rawData.Add((byte)more);
+                    }
+                    else
+                    {
+                        if (done > 0xf)
+                        {
+                            done = 0xf;
+                        }
+                        rawData.Add((byte)(done | lastColor << 4));
+                    }
+
+                    reps -= done;
+                }
+            }
+
+            for (int i = 0; i < span.Length; i++)
+            {
+                int color = span[i] >> 4;
+
+                if (color == lastColor)
+                {
+                    reps++;
+                }
+                else
+                {
+                    PutReps();
+                    lastColor = color;
+                    reps = 1;
+                }
+            }
+
+            PutReps();
+
+            return rawData.ToArray();
+        }
+
+        public Mat RandomMat(int width, int height)
+        {
+            var bytes = new byte[width * height];
+            _randomProvider.GetBytes(bytes);
+            Mat mat = new Mat(new Size(width, height), DepthType.Cv8U, 1);
+            mat.SetBytes(bytes);
+            return mat;
+        }
+
+        public void Test4KRandomCBBDLPEncode()
+        {
+            using (var mat = RandomMat(3840, 2160))
+                EncodeCbddlpImage(mat);
+        }
+
+        public void Test8KRandomCBBDLPEncode()
+        {
+            using (var mat = RandomMat(7680, 4320))
+                EncodeCbddlpImage(mat);
+        }
+
+        public void Test4KRandomCBTEncode()
+        {
+            using (var mat = RandomMat(3840, 2160))
+                EncodeCbtImage(mat);
+        }
+
+        public void Test8KRandomCBTEncode()
+        {
+            using (var mat = RandomMat(7680, 4320))
+                EncodeCbtImage(mat);
+        }
+
+        public void Test4KRandomPW0Encode()
+        {
+            using (var mat = RandomMat(3840, 2160))
+                EncodePW0Image(mat);
+        }
+
+        public void Test8KRandomPW0Encode()
+        {
+            using (var mat = RandomMat(7680, 4320))
+                EncodePW0Image(mat);
+        }
+
+        #endregion
+    }
+}