From 1776039bf62bd516e7c8ff2dfe8b9e64df3d7c0d Mon Sep 17 00:00:00 2001
From: Alkl58 <34812414+Alkl58@users.noreply.github.com>
Date: Sun, 26 Mar 2023 19:25:03 +0200
Subject: [PATCH] Add Target VMAF (#140)

* Target VMAF Base (POC - unfinished)

* Fix Input Seeeking Frane Inaccuracy (Scene Based Splitting)

* Fix Target VMAF
Make Target VMAF more reliable

* Add Target VMAF Front-end options

* Target VMAF UI Translations
---
 NotEnoughAV1Encodes/MainWindow.xaml           |  31 +-
 NotEnoughAV1Encodes/MainWindow.xaml.cs        | 104 +++++-
 .../NotEnoughAV1Encodes.csproj                |   1 +
 NotEnoughAV1Encodes/Queue/ChunkVMAF.cs        |  13 +
 NotEnoughAV1Encodes/Queue/QueueElement.cs     |   2 +
 NotEnoughAV1Encodes/Video/VMAF.cs             | 270 ++++++++++++++++
 NotEnoughAV1Encodes/Video/VideoEncode.cs      |  20 +-
 NotEnoughAV1Encodes/Video/VideoSettings.cs    |  17 +
 NotEnoughAV1Encodes/Video/VideoSplitter.cs    | 302 +++++++++++++-----
 .../resources/lang/Strings.Designer.cs        |  81 +++++
 .../resources/lang/Strings.de.resx            |  27 ++
 .../resources/lang/Strings.fr-FR.resx         |  27 ++
 .../resources/lang/Strings.it-IT.resx         |  27 ++
 .../resources/lang/Strings.ja-JP.resx         |  27 ++
 .../resources/lang/Strings.resx               |  27 ++
 .../resources/lang/Strings.ru-RU.resx         |  27 ++
 .../resources/lang/Strings.zh-CN.resx         |  27 ++
 17 files changed, 915 insertions(+), 115 deletions(-)
 create mode 100644 NotEnoughAV1Encodes/Queue/ChunkVMAF.cs
 create mode 100644 NotEnoughAV1Encodes/Video/VMAF.cs

diff --git a/NotEnoughAV1Encodes/MainWindow.xaml b/NotEnoughAV1Encodes/MainWindow.xaml
index 902c2fe..aac86b1 100644
--- a/NotEnoughAV1Encodes/MainWindow.xaml
+++ b/NotEnoughAV1Encodes/MainWindow.xaml
@@ -367,21 +367,38 @@
                                     </Style>
                                 </Canvas.Style>
                                 <Slider x:Name="SliderQualityAOMFFMPEG" Value="{Binding AOMFFMPEGQuantizer}" VerticalAlignment="Top" SmallChange="1" Maximum="63" TickPlacement="BottomRight" Height="34" IsSnapToTickEnabled="True" Canvas.Left="131" Canvas.Top="69" Width="520"/>
-                                <Label Content="{Binding ElementName=SliderQualityAOMFFMPEG, Path=Value, UpdateSourceTrigger=PropertyChanged}" VerticalAlignment="Top" HorizontalAlignment="Right" Width="78" Canvas.Left="664" Canvas.Top="75"/>
+                                <Label x:Name="LabelQuantizerPreview" Content="{Binding ElementName=SliderQualityAOMFFMPEG, Path=Value, UpdateSourceTrigger=PropertyChanged}" VerticalAlignment="Top" HorizontalAlignment="Right" Width="78" Canvas.Left="664" Canvas.Top="75"/>
                                 <Label x:Name="LabelQualityMode" Content="{lex:Loc}" HorizontalAlignment="Left" Margin="18,12,0,0" VerticalAlignment="Top" Width="108"/>
                                 <ComboBox x:Name="ComboBoxQualityMode" SelectedIndex="{Binding AOMFFMPEGQualityMode}" HorizontalAlignment="Left" Margin="131,10,0,0" VerticalAlignment="Top" Width="140" Height="30" SelectionChanged="ComboBoxQualityMode_SelectionChanged">
                                     <ComboBoxItem Content="Constant Quality"/>
                                     <ComboBoxItem Content="Constrained Quality"/>
                                     <ComboBoxItem Content="Average Bitrate"/>
                                     <ComboBoxItem Content="Constrained Bitrate"/>
+                                    <ComboBoxItem Content="Target VMAF"/>
                                 </ComboBox>
                                 <Label x:Name="LabelQuantizer" Content="{lex:Loc}" HorizontalAlignment="Left" Margin="20,73,0,0" VerticalAlignment="Top" Width="106" Height="30"/>
-                                <Label x:Name="LabelBitrateMin" Content="{lex:Loc}" Visibility="{Binding ElementName=TextBoxMinBitrateAOMFFMPEG, Path=Visibility, UpdateSourceTrigger=PropertyChanged}" IsEnabled="{Binding ElementName=TextBoxMinBitrateAOMFFMPEG, Path=IsEnabled, UpdateSourceTrigger=PropertyChanged}" HorizontalAlignment="Left" Margin="21,140,0,0" VerticalAlignment="Top" Width="106" Height="30"/>
-                                <Label x:Name="LabelBitrateAvg" Content="{lex:Loc}" IsEnabled="{Binding ElementName=TextBoxAVGBitrateAOMFFMPEG, Path=IsEnabled, UpdateSourceTrigger=PropertyChanged}" HorizontalAlignment="Left" Margin="21,173,0,0" VerticalAlignment="Top" Width="105" Height="30"/>
-                                <Label x:Name="LabelBitrateMax" Content="{lex:Loc}" Visibility="{Binding ElementName=TextBoxMaxBitrateAOMFFMPEG, Path=Visibility, UpdateSourceTrigger=PropertyChanged}" IsEnabled="{Binding ElementName=TextBoxMaxBitrateAOMFFMPEG, Path=IsEnabled, UpdateSourceTrigger=PropertyChanged}" HorizontalAlignment="Left" Margin="21,206,0,0" VerticalAlignment="Top" Width="105" Height="30"/>
-                                <TextBox x:Name="TextBoxMinBitrateAOMFFMPEG" PreviewTextInput="NumberValidationTextBox" Margin="131,142,0,0" Text="{Binding AOMFFMPEGMinBitrate}" TextWrapping="Wrap" VerticalAlignment="Top" HorizontalContentAlignment="Center" VerticalContentAlignment="Center" IsEnabled="False" HorizontalAlignment="Left" Width="120"/>
-                                <TextBox x:Name="TextBoxAVGBitrateAOMFFMPEG" PreviewTextInput="NumberValidationTextBox" Margin="131,175,0,0" Text="{Binding AOMFFMPEGAvgBitrate}" TextWrapping="Wrap" VerticalAlignment="Top" HorizontalContentAlignment="Center" VerticalContentAlignment="Center" IsEnabled="False" HorizontalAlignment="Left" Width="120"/>
-                                <TextBox x:Name="TextBoxMaxBitrateAOMFFMPEG" PreviewTextInput="NumberValidationTextBox" Margin="131,208,0,0" Text="{Binding AOMFFMPEGMaxBitrate}" TextWrapping="Wrap" VerticalAlignment="Top" HorizontalContentAlignment="Center" VerticalContentAlignment="Center" IsEnabled="False" HorizontalAlignment="Left" Width="120"/>
+                                <Label x:Name="LabelBitrateMin" Content="{lex:Loc}" HorizontalAlignment="Left" VerticalAlignment="Top" Width="106" Height="30" Canvas.Left="21" Canvas.Top="46"/>
+                                <Label x:Name="LabelBitrateAvg" Content="{lex:Loc}" HorizontalAlignment="Left" VerticalAlignment="Top" Width="105" Height="30" Canvas.Left="21" Canvas.Top="79"/>
+                                <Label x:Name="LabelBitrateMax" Content="{lex:Loc}" HorizontalAlignment="Left" VerticalAlignment="Top" Width="105" Height="30" Canvas.Left="21" Canvas.Top="112"/>
+                                <TextBox x:Name="TextBoxMinBitrateAOMFFMPEG" PreviewTextInput="NumberValidationTextBox" Text="{Binding AOMFFMPEGMinBitrate}" TextWrapping="Wrap" VerticalAlignment="Top" HorizontalContentAlignment="Center" VerticalContentAlignment="Center" HorizontalAlignment="Left" Width="120" Canvas.Left="131" Canvas.Top="48"/>
+                                <TextBox x:Name="TextBoxAVGBitrateAOMFFMPEG" PreviewTextInput="NumberValidationTextBox" Text="{Binding AOMFFMPEGAvgBitrate}" TextWrapping="Wrap" VerticalAlignment="Top" HorizontalContentAlignment="Center" VerticalContentAlignment="Center" HorizontalAlignment="Left" Width="120" Canvas.Left="131" Canvas.Top="81"/>
+                                <TextBox x:Name="TextBoxMaxBitrateAOMFFMPEG" PreviewTextInput="NumberValidationTextBox" Text="{Binding AOMFFMPEGMaxBitrate}" TextWrapping="Wrap" VerticalAlignment="Top" HorizontalContentAlignment="Center" VerticalContentAlignment="Center" HorizontalAlignment="Left" Width="120" Canvas.Left="131" Canvas.Top="114"/>
+                                <!-- Target VMAF -->
+                                <Label x:Name="LabelTargetVMAF" Content="{lex:Loc}" HorizontalAlignment="Left" VerticalAlignment="Center" Width="106" Height="30" Canvas.Left="18" Canvas.Top="46"/>
+                                <Slider x:Name="SliderTargetVMAF" Value="{Binding TargetVMAFScore}" VerticalAlignment="Top" SmallChange="0.5" Maximum="100" TickPlacement="BottomRight" Height="34" IsSnapToTickEnabled="True" Canvas.Left="132" Canvas.Top="42" Width="520" Minimum="70" TickFrequency="0.5"/>
+                                <Label x:Name="LabelTargetVMAFPreview" Content="{Binding ElementName=SliderTargetVMAF, Path=Value, UpdateSourceTrigger=PropertyChanged}" VerticalAlignment="Top" HorizontalAlignment="Center" Width="78" Canvas.Left="664" Canvas.Top="46"/>
+                                <Label x:Name="LabelTargetVMAFProbes" Content="{lex:Loc}" HorizontalAlignment="Center" VerticalAlignment="Top" Width="106" Height="30" Canvas.Left="18" Canvas.Top="79"/>
+                                <Slider x:Name="SliderTargetVMAFProbes" Value="{Binding TargetVMAFProbes}" VerticalAlignment="Center" SmallChange="1" Maximum="6" TickPlacement="BottomRight" Height="34" IsSnapToTickEnabled="True" Canvas.Left="132" Canvas.Top="73" Width="520" Minimum="2" TickFrequency="1" HorizontalAlignment="Center" ToolTip="{lex:Loc SliderTargetVMAFProbesToolTip}"/>
+                                <Label x:Name="LabelTargetVMAFProbesPreview" Content="{Binding ElementName=SliderTargetVMAFProbes, Path=Value, UpdateSourceTrigger=PropertyChanged}" VerticalAlignment="Center" HorizontalAlignment="Left" Width="78" Canvas.Left="664" Canvas.Top="77"/>
+                                <Label x:Name="LabelTargetVMAFMinQ" Content="{lex:Loc}" HorizontalAlignment="Center" VerticalAlignment="Top" Width="106" Height="30" Canvas.Left="18" Canvas.Top="109"/>
+                                <Slider x:Name="SliderTargetVMAFMinQ" Value="{Binding TargetVMAFMinQ}" VerticalAlignment="Top" SmallChange="1" Maximum="63" TickPlacement="BottomRight" Height="34" IsSnapToTickEnabled="True" Canvas.Left="132" Canvas.Top="103" Width="520" ValueChanged="SliderTargetVMAFMinQ_ValueChanged" ToolTip="{lex:Loc SliderTargetVMAFMinQToolTip}"/>
+                                <Label x:Name="LabelTargetVMAFMinQPreview" Content="{Binding ElementName=SliderTargetVMAFMinQ, Path=Value, UpdateSourceTrigger=PropertyChanged}" VerticalAlignment="Top" HorizontalAlignment="Center" Width="78" Canvas.Left="664" Canvas.Top="107"/>
+                                <Label x:Name="LabelTargetVMAFMaxQ" Content="{lex:Loc}" HorizontalAlignment="Center" VerticalAlignment="Top" Width="106" Height="30" Canvas.Left="18" Canvas.Top="137"/>
+                                <Slider x:Name="SliderTargetVMAFMaxQ" Value="{Binding TargetVMAFMaxQ}" VerticalAlignment="Top" SmallChange="1" Maximum="63" TickPlacement="BottomRight" Height="34" IsSnapToTickEnabled="True" Canvas.Left="132" Canvas.Top="133" Width="520" HorizontalAlignment="Center" ValueChanged="SliderTargetVMAFMaxQ_ValueChanged" ToolTip="{lex:Loc SliderTargetVMAFMaxQToolTip}"/>
+                                <Label x:Name="LabelTargetVMAFMaxQPreview" Content="{Binding ElementName=SliderTargetVMAFMaxQ, Path=Value, UpdateSourceTrigger=PropertyChanged}" VerticalAlignment="Top" HorizontalAlignment="Center" Width="78" Canvas.Left="664" Canvas.Top="138"/>
+                                <Label x:Name="LabelTargetVMAFMaxProbeLength" Content="{lex:Loc}" HorizontalAlignment="Left" VerticalAlignment="Top" Width="106" Height="30" Canvas.Left="19" Canvas.Top="167"/>
+                                <Slider x:Name="SliderTargetVMAFMaxProbeLength" Value="{Binding TargetVMAFProbeLength}" VerticalAlignment="Top" SmallChange="1" Maximum="60" TickPlacement="BottomRight" Height="34" IsSnapToTickEnabled="True" Canvas.Left="132" Canvas.Top="165" Width="520" HorizontalAlignment="Center" ToolTip="{lex:Loc SliderTargetVMAFMaxProbeLengthToolTip}" Minimum="1"/>
+                                <Label x:Name="LabelTargetVMAFMaxProbeLengthPreview" Content="{Binding ElementName=SliderTargetVMAFMaxProbeLength, Path=Value, UpdateSourceTrigger=PropertyChanged}" VerticalAlignment="Top" HorizontalAlignment="Center" Width="78" Canvas.Left="664" Canvas.Top="169"/>
                             </Canvas>
                             <!-- RAV1E FFmpeg -->
                             <Canvas HorizontalAlignment="Left" Width="1055">
diff --git a/NotEnoughAV1Encodes/MainWindow.xaml.cs b/NotEnoughAV1Encodes/MainWindow.xaml.cs
index 2d8657c..02708ce 100644
--- a/NotEnoughAV1Encodes/MainWindow.xaml.cs
+++ b/NotEnoughAV1Encodes/MainWindow.xaml.cs
@@ -996,33 +996,102 @@ private void ComboBoxVideoEncoder_SelectionChanged(object sender, System.Windows
 
         private void ComboBoxQualityMode_SelectionChanged(object sender, System.Windows.Controls.SelectionChangedEventArgs e)
         {
+            // Hide all
+            LabelQuantizer.Visibility = Visibility.Collapsed;
+            SliderQualityAOMFFMPEG.Visibility = Visibility.Collapsed;
+            LabelQuantizerPreview.Visibility = Visibility.Collapsed;
+            LabelBitrateMin.Visibility = Visibility.Collapsed;
+            TextBoxMinBitrateAOMFFMPEG.Visibility = Visibility.Collapsed;
+            LabelBitrateAvg.Visibility = Visibility.Collapsed;
+            TextBoxAVGBitrateAOMFFMPEG.Visibility = Visibility.Collapsed;
+            LabelBitrateMax.Visibility = Visibility.Collapsed;
+            TextBoxMaxBitrateAOMFFMPEG.Visibility = Visibility.Collapsed;
+            LabelTargetVMAF.Visibility = Visibility.Collapsed;
+            LabelTargetVMAFPreview.Visibility = Visibility.Collapsed;
+            SliderTargetVMAF.Visibility = Visibility.Collapsed;
+            LabelTargetVMAFProbes.Visibility = Visibility.Collapsed;
+            SliderTargetVMAFProbes.Visibility = Visibility.Collapsed;
+            LabelTargetVMAFProbesPreview.Visibility = Visibility.Collapsed;
+            LabelTargetVMAFMinQ.Visibility = Visibility.Collapsed;
+            SliderTargetVMAFMinQ.Visibility= Visibility.Collapsed;
+            LabelTargetVMAFMinQPreview.Visibility = Visibility.Collapsed;
+            LabelTargetVMAFMaxQ.Visibility = Visibility.Collapsed;
+            SliderTargetVMAFMaxQ.Visibility = Visibility.Collapsed;
+            LabelTargetVMAFMaxQPreview.Visibility = Visibility.Collapsed;
+            LabelTargetVMAFMaxProbeLength.Visibility = Visibility.Collapsed;
+            SliderTargetVMAFMaxProbeLength.Visibility = Visibility.Collapsed;
+            LabelTargetVMAFMaxProbeLengthPreview.Visibility = Visibility.Collapsed;
+            PresetSettings.TargetVMAF = false;
+
             if (ComboBoxQualityMode.SelectedIndex == 0)
             {
-                SliderQualityAOMFFMPEG.IsEnabled = true;
-                TextBoxAVGBitrateAOMFFMPEG.IsEnabled = false;
-                TextBoxMaxBitrateAOMFFMPEG.IsEnabled = false;
-                TextBoxMinBitrateAOMFFMPEG.IsEnabled = false;
+                // Constant Quality
+                LabelQuantizer.Visibility = Visibility.Visible;
+                SliderQualityAOMFFMPEG.Visibility = Visibility.Visible;
+                LabelQuantizerPreview.Visibility = Visibility.Visible;
             }
             else if (ComboBoxQualityMode.SelectedIndex == 1)
             {
-                SliderQualityAOMFFMPEG.IsEnabled = true;
-                TextBoxAVGBitrateAOMFFMPEG.IsEnabled = false;
-                TextBoxMaxBitrateAOMFFMPEG.IsEnabled = true;
-                TextBoxMinBitrateAOMFFMPEG.IsEnabled = false;
+                // Constrained Quality
+                TextBoxMaxBitrateAOMFFMPEG.Visibility = Visibility.Visible;
+                LabelBitrateMax.Visibility = Visibility.Visible;
+                LabelQuantizer.Visibility = Visibility.Visible;
+                SliderQualityAOMFFMPEG.Visibility = Visibility.Visible;
+                LabelQuantizerPreview.Visibility = Visibility.Visible;
             }
             else if (ComboBoxQualityMode.SelectedIndex == 2)
             {
-                SliderQualityAOMFFMPEG.IsEnabled = false;
-                TextBoxAVGBitrateAOMFFMPEG.IsEnabled = true;
-                TextBoxMaxBitrateAOMFFMPEG.IsEnabled = false;
-                TextBoxMinBitrateAOMFFMPEG.IsEnabled = false;
+                // Average Bitrate
+                LabelBitrateAvg.Visibility = Visibility.Visible;
+                TextBoxAVGBitrateAOMFFMPEG.Visibility = Visibility.Visible;
             }
             else if (ComboBoxQualityMode.SelectedIndex == 3)
             {
-                SliderQualityAOMFFMPEG.IsEnabled = false;
-                TextBoxAVGBitrateAOMFFMPEG.IsEnabled = true;
-                TextBoxMaxBitrateAOMFFMPEG.IsEnabled = true;
-                TextBoxMinBitrateAOMFFMPEG.IsEnabled = true;
+                // Constrained Bitrate
+                LabelBitrateMin.Visibility = Visibility.Visible;
+                TextBoxMinBitrateAOMFFMPEG.Visibility = Visibility.Visible;
+                LabelBitrateAvg.Visibility = Visibility.Visible;
+                TextBoxAVGBitrateAOMFFMPEG.Visibility = Visibility.Visible;
+                LabelBitrateMax.Visibility = Visibility.Visible;
+                TextBoxMaxBitrateAOMFFMPEG.Visibility = Visibility.Visible;
+            }
+            else if (ComboBoxQualityMode.SelectedIndex == 4) 
+            {
+                // Target VMAF
+                PresetSettings.TargetVMAF = true;
+                LabelTargetVMAF.Visibility = Visibility.Visible;
+                LabelTargetVMAFPreview.Visibility = Visibility.Visible;
+                SliderTargetVMAF.Visibility = Visibility.Visible;
+                LabelTargetVMAFProbes.Visibility = Visibility.Visible;
+                SliderTargetVMAFProbes.Visibility = Visibility.Visible;
+                LabelTargetVMAFProbesPreview.Visibility = Visibility.Visible;
+                LabelTargetVMAFMinQ.Visibility = Visibility.Visible;
+                SliderTargetVMAFMinQ.Visibility = Visibility.Visible;
+                LabelTargetVMAFMinQPreview.Visibility = Visibility.Visible;
+                LabelTargetVMAFMaxQ.Visibility = Visibility.Visible;
+                SliderTargetVMAFMaxQ.Visibility = Visibility.Visible;
+                LabelTargetVMAFMaxQPreview.Visibility = Visibility.Visible;
+                LabelTargetVMAFMaxProbeLength.Visibility = Visibility.Visible;
+                SliderTargetVMAFMaxProbeLength.Visibility = Visibility.Visible;
+                LabelTargetVMAFMaxProbeLengthPreview.Visibility = Visibility.Visible;
+            }
+        }
+
+        private void SliderTargetVMAFMinQ_ValueChanged(object sender, RoutedPropertyChangedEventArgs<double> e)
+        {
+            if (SliderTargetVMAF == null) return;
+            if (SliderTargetVMAFMinQ.Value > SliderTargetVMAFMaxQ.Value)
+            {
+                SliderTargetVMAFMaxQ.Value = SliderTargetVMAFMinQ.Value;
+            }
+        }
+
+        private void SliderTargetVMAFMaxQ_ValueChanged(object sender, RoutedPropertyChangedEventArgs<double> e)
+        {
+            if (SliderTargetVMAF == null) return;
+            if (SliderTargetVMAFMinQ.Value > SliderTargetVMAFMaxQ.Value)
+            {
+                SliderTargetVMAFMinQ.Value = SliderTargetVMAFMaxQ.Value;
             }
         }
 
@@ -2027,6 +2096,7 @@ private string GenerateAomFFmpegCommand()
                 1 => " -crf " + SliderQualityAOMFFMPEG.Value + " -b:v " + TextBoxMaxBitrateAOMFFMPEG.Text + "k",
                 2 => " -b:v " + TextBoxMinBitrateAOMFFMPEG.Text + "k",
                 3 => " -minrate " + TextBoxMinBitrateAOMFFMPEG.Text + "k -b:v " + TextBoxAVGBitrateAOMFFMPEG.Text + "k -maxrate " + TextBoxMaxBitrateAOMFFMPEG.Text + "k",
+                4 => " -crf {q_vmaf} -b:v 0",
                 _ => ""
             };
 
@@ -2732,7 +2802,7 @@ private async Task MainStartAsync(CancellationToken _cancelToken)
                         {
                             await Task.Run(() => videoSplitter.Split(queueElement, _cancelToken), _cancelToken);
 
-                            if (queueElement.ChunkingMethod == 0)
+                            if (queueElement.ChunkingMethod == 0 || queueElement.Preset.TargetVMAF)
                             {
                                 // Equal Chunking
                                 IOrderedEnumerable<string> sortedChunks = Directory.GetFiles(Path.Combine(Global.Temp, "NEAV1E", queueElement.UniqueIdentifier, "Chunks"), "*.mkv", SearchOption.TopDirectoryOnly).OrderBy(f => f);
diff --git a/NotEnoughAV1Encodes/NotEnoughAV1Encodes.csproj b/NotEnoughAV1Encodes/NotEnoughAV1Encodes.csproj
index 08bc8ab..f4fd733 100644
--- a/NotEnoughAV1Encodes/NotEnoughAV1Encodes.csproj
+++ b/NotEnoughAV1Encodes/NotEnoughAV1Encodes.csproj
@@ -34,6 +34,7 @@
 
   <ItemGroup>
     <PackageReference Include="MahApps.Metro" Version="2.4.9" />
+    <PackageReference Include="MathNet.Numerics" Version="5.0.0" />
     <PackageReference Include="Newtonsoft.Json" Version="13.0.2" />
     <PackageReference Include="Octokit" Version="5.0.0" />
     <PackageReference Include="System.Management" Version="7.0.0" />
diff --git a/NotEnoughAV1Encodes/Queue/ChunkVMAF.cs b/NotEnoughAV1Encodes/Queue/ChunkVMAF.cs
new file mode 100644
index 0000000..6095c63
--- /dev/null
+++ b/NotEnoughAV1Encodes/Queue/ChunkVMAF.cs
@@ -0,0 +1,13 @@
+using System.Collections.Generic;
+using System.Windows.Documents;
+
+namespace NotEnoughAV1Encodes.Queue
+{
+    public class ChunkVMAF
+    {
+        public string ChunkName { get; set; }
+        public string CalculatedQuantizer { get; set; }
+        public List<double> QValues { get; set; }
+        public List<double> VMAFValues { get; set; }
+    }
+}
diff --git a/NotEnoughAV1Encodes/Queue/QueueElement.cs b/NotEnoughAV1Encodes/Queue/QueueElement.cs
index e0a7f8e..ddf968f 100644
--- a/NotEnoughAV1Encodes/Queue/QueueElement.cs
+++ b/NotEnoughAV1Encodes/Queue/QueueElement.cs
@@ -27,6 +27,8 @@ public string Status
         public string VideoCommand { get; set; }
         /// <summary>Video HDR Muxing parameters.</summary>
         public string VideoHDRMuxCommand { get; set; }
+        /// <summary>Target VMAF Chunk List.</summary>
+        public List<ChunkVMAF> ChunkVMAF { get; set; } = new();
         /// <summary>Audio Encoding parameters.</summary>
         public string AudioCommand { get; set; }
         /// <summary>Softsub Command</summary>
diff --git a/NotEnoughAV1Encodes/Video/VMAF.cs b/NotEnoughAV1Encodes/Video/VMAF.cs
new file mode 100644
index 0000000..24d8935
--- /dev/null
+++ b/NotEnoughAV1Encodes/Video/VMAF.cs
@@ -0,0 +1,270 @@
+using MathNet.Numerics;
+using NotEnoughAV1Encodes.Queue;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Threading;
+
+namespace NotEnoughAV1Encodes.Video
+{
+    public class VMAF
+    {
+        private double CalculateVMAFScore(string source, string distorted, string chunk, QueueElement queueElement, CancellationToken token)
+        {
+            string vmafModel = "../vmaf/vmaf_v0.6.1.json";
+            string logPath = distorted.Replace("\\", "/").Replace(":", "\\\\:") + ".xml";
+
+            string ffmpegCommand = "/C ffmpeg.exe";
+
+            // Input
+            ffmpegCommand += source;
+            ffmpegCommand += " -i \"" + distorted + "\"";
+
+            // VMAF Filter
+            ffmpegCommand += " -lavfi \"[0:v]setpts=PTS-STARTPTS[reference];" +
+                                       "[1:v]scale=1920:1080:flags=bicubic,setpts=PTS-STARTPTS[distorted];" +
+                                       "[distorted][reference]libvmaf=log_fmt=xml:log_path=" + logPath + ":model_path=" + vmafModel + ":n_threads=4\"" +
+                                       " -f null -";
+
+            Process processVideo = new();
+            ProcessStartInfo startInfo = new()
+            {
+                WindowStyle = ProcessWindowStyle.Hidden,
+                FileName = "cmd.exe",
+                WorkingDirectory = Path.Combine(Directory.GetCurrentDirectory(), "Apps", "FFmpeg"),
+                Arguments = ffmpegCommand,
+                RedirectStandardError = true,
+                RedirectStandardInput = true,
+                CreateNoWindow = true
+            };
+
+            processVideo.StartInfo = startInfo;
+
+            token.Register(() => { try { processVideo.StandardInput.Write("q"); } catch { } });
+
+            processVideo.Start();
+
+            // Get launched Process ID
+            int _pid = processVideo.Id;
+
+            // Add Process ID to Array, inorder to keep track / kill the instances
+            Global.LaunchedPIDs.Add(_pid);
+
+            //StreamReader sr = processVideo.StandardError;
+
+            double vmafScore = 0.0;
+
+            string lastLine = null;
+            while (!processVideo.StandardError.EndOfStream)
+            {
+                lastLine = processVideo.StandardError.ReadLine();
+                //Global.Logger(lastLine, queueElement.Output + ".log");
+                if (lastLine.Contains("VMAF score:"))
+                {
+                    string split = "VMAF score:";
+                    vmafScore = double.Parse(lastLine[(lastLine.IndexOf(split) + split.Length)..], System.Globalization.CultureInfo.InvariantCulture);
+                }
+            }
+
+
+            processVideo.WaitForExit();
+
+            // Remove PID from Array after Exit
+            Global.LaunchedPIDs.RemoveAll(i => i == _pid);
+
+            if (processVideo.ExitCode == 0 && token.IsCancellationRequested == false)
+            {
+                Global.Logger("INFO  - VMAF.CalculateVMAFScore() => Exit Code: 0  Chunk: " + chunk, queueElement.Output + ".log");
+            }
+            else
+            {
+                queueElement.Error = true;
+                queueElement.ErrorCount += 1;
+                Global.Logger("FATAL - VMAF.CalculateVMAFScore() => Exit Code: " + processVideo.ExitCode + "  Chunk: " + chunk, queueElement.Output + ".log");
+            }
+
+            return vmafScore;
+        }
+
+        private double EncodeAndCalculate(QueueElement queueElement, string chunk, int index, string ffmpegFilter, string quality, Settings settings, CancellationToken token)
+        {
+            // Create Folder where VMAF Probe Encodes are saved
+            Directory.CreateDirectory(Path.Combine(Global.Temp, "NEAV1E", queueElement.UniqueIdentifier, "VMAF"));
+
+            string ChunkOutput = "\"" + Path.Combine(Global.Temp, "NEAV1E", queueElement.UniqueIdentifier, "VMAF", index.ToString("D6") + "_vmaf_probe_q" + quality + ".mp4") + "\"";
+            string videoCommand = " -c:v libaom-av1 -crf " + quality + " -b:v 0 -cpu-used 6 -threads 4 -tile-columns 2 -tile-rows 1 ";
+
+            string ChunkInput = " -i \"" + chunk + "_vmaf_reference.mp4\"";
+
+            if (queueElement.Preset.TargetVMAFUserEncoderSettings)
+            {
+                videoCommand = queueElement.VideoCommand;
+                videoCommand = videoCommand.Replace("{q_vmaf}", quality);
+            }
+
+            Global.Logger("INFO  - VMAF.EncodeAndCalculate() => Chunk: " + chunk + " -  Q: " + quality + " - Command: " + "/C ffmpeg.exe -y " + ChunkInput + " " + ffmpegFilter + " -an -sn -map_metadata -1 " + videoCommand + " " + ChunkOutput, queueElement.Output + ".log");
+
+            Process processVideo = new();
+            ProcessStartInfo startInfo = new()
+            {
+                WindowStyle = ProcessWindowStyle.Hidden,
+                FileName = "cmd.exe",
+                WorkingDirectory = Path.Combine(Directory.GetCurrentDirectory(), "Apps", "FFmpeg"),
+                Arguments = "/C ffmpeg.exe -y " + ChunkInput + " " + ffmpegFilter + " -an -sn -map_metadata -1 " + videoCommand + " " + ChunkOutput,
+                RedirectStandardError = true,
+                RedirectStandardInput = true,
+                CreateNoWindow = true
+            };
+
+            processVideo.StartInfo = startInfo;
+
+            token.Register(() => { try { processVideo.StandardInput.Write("q"); } catch { } });
+
+            processVideo.Start();
+
+            // Get launched Process ID
+            int _pid = processVideo.Id;
+
+            // Add Process ID to Array, inorder to keep track / kill the instances
+            Global.LaunchedPIDs.Add(_pid);
+
+            string lastLine = null;
+            while (! processVideo.StandardError.EndOfStream)
+            {
+                lastLine = processVideo.StandardError.ReadLine();
+            }
+
+            processVideo.WaitForExit();
+
+            // Remove PID from Array after Exit
+            Global.LaunchedPIDs.RemoveAll(i => i == _pid);
+
+            if (processVideo.ExitCode == 0 && token.IsCancellationRequested == false)
+            {
+                Global.Logger("INFO  - VMAF.EncodeAndCalculate() => Exit Code: 0  Chunk: " + chunk, queueElement.Output + ".log");
+            }
+            else
+            {
+                queueElement.Error = true;
+                queueElement.ErrorCount += 1;
+                Global.Logger("FATAL - VMAF.EncodeAndCalculate() => Exit Code: " + processVideo.ExitCode + "  Chunk: " + chunk, queueElement.Output + ".log");
+            }
+
+            // Calculate VMAF Score
+            double vmafScore = CalculateVMAFScore(ChunkInput, ChunkOutput, chunk, queueElement, token);
+            Global.Logger("INFO  - VMAF.EncodeAndCalculate() => Chunk: " + chunk + " -  Q: " + quality + " => VAMF Score: " + vmafScore, queueElement.Output + ".log");
+            return vmafScore;
+        }
+
+        private static double InterpolateVMAF(double[] qValues, double[] vmafValues, double targetVmaf)
+        {
+            return Interpolate.Linear(vmafValues, qValues).Interpolate(targetVmaf);
+        }
+
+        public string Probe(QueueElement queueElement, string chunk, int index, string ffmpegFilter, Settings settings, CancellationToken token)
+        {
+            Global.Logger("INFO  - VMAF.Probe() => Chunk: " + chunk, queueElement.Output + ".log");
+            // Check if already Probed
+            List<ChunkVMAF> tempList = queueElement.ChunkVMAF.ToList();
+            ChunkVMAF result = tempList.FirstOrDefault(n => n.ChunkName == chunk);
+            if (result != null)
+            {
+                Global.Logger("INFO  - VMAF.Probe() => Chunk: " + chunk + " - Already Probed - Return Q: " + result.CalculatedQuantizer, queueElement.Output + ".log");
+                return result.CalculatedQuantizer;
+            }
+
+            // Create VMAF Object
+            ChunkVMAF chunkVMAF = new();
+            chunkVMAF.ChunkName = chunk;
+
+            // Base Encodes
+            List<double> qValues = new();
+            List<double> vmafValues = new();
+
+            // Floor / Ceiling
+            qValues.Add(0);
+            vmafValues.Add(100);
+
+            qValues.Add(queueElement.Preset.TargetVMAFMinQ);
+            double vmaf = EncodeAndCalculate(queueElement, chunk, index, ffmpegFilter, queueElement.Preset.TargetVMAFMinQ.ToString(), settings, token);
+            vmafValues.Add(vmaf);
+            Global.Logger("INFO  - VMAF.Probe() => Chunk: " + chunk + " - Probe Q: " + queueElement.Preset.TargetVMAFMinQ.ToString() + " => VMAF: " + vmaf.ToString(), queueElement.Output + ".log");
+
+            double diff = Math.Abs(queueElement.Preset.TargetVMAFScore - vmaf);
+            if (vmaf < queueElement.Preset.TargetVMAFScore || diff < 1.0)
+            {
+                // Skip everything, the calculated vmaf score is less than the target vmaf score, can't go below the TargetVMAFMinQ (Highest Quality)
+                // or diff is already less than 1
+                chunkVMAF.CalculatedQuantizer = queueElement.Preset.TargetVMAFMinQ.ToString();
+                chunkVMAF.VMAFValues = vmafValues;
+                chunkVMAF.QValues = qValues;
+
+                queueElement.ChunkVMAF.Add(chunkVMAF);
+
+                return chunkVMAF.CalculatedQuantizer;
+            }
+
+            qValues.Add(queueElement.Preset.TargetVMAFMaxQ);
+            vmaf = EncodeAndCalculate(queueElement, chunk, index, ffmpegFilter, queueElement.Preset.TargetVMAFMaxQ.ToString(), settings, token);
+            vmafValues.Add(vmaf);
+            Global.Logger("INFO  - VMAF.Probe() => Chunk: " + chunk + " - Probe Q: " + queueElement.Preset.TargetVMAFMaxQ.ToString() + " => VMAF: " + vmaf.ToString(), queueElement.Output + ".log");
+
+
+            // First Calculation
+            double interpolatedQ = InterpolateVMAF(qValues.ToArray(), vmafValues.ToArray(), queueElement.Preset.TargetVMAFScore);
+            Global.Logger("INFO  - VMAF.Probe() => Chunk: " + chunk + " - Interpolated Q: " + interpolatedQ.ToString() + " for VMAF: " + queueElement.Preset.TargetVMAFScore.ToString(), queueElement.Output + ".log");
+
+            // already outside of the given min max q values
+            if (interpolatedQ < queueElement.Preset.TargetVMAFMinQ)
+            {
+                chunkVMAF.CalculatedQuantizer = queueElement.Preset.TargetVMAFMinQ.ToString();
+                chunkVMAF.VMAFValues = vmafValues;
+                chunkVMAF.QValues = qValues;
+
+                queueElement.ChunkVMAF.Add(chunkVMAF);
+
+                return chunkVMAF.CalculatedQuantizer;
+            }
+
+            if (interpolatedQ > queueElement.Preset.TargetVMAFMaxQ)
+            {
+                chunkVMAF.CalculatedQuantizer = queueElement.Preset.TargetVMAFMaxQ.ToString();
+                chunkVMAF.VMAFValues = vmafValues;
+                chunkVMAF.QValues = qValues;
+
+                queueElement.ChunkVMAF.Add(chunkVMAF);
+
+                return chunkVMAF.CalculatedQuantizer;
+            }
+
+            // Do the encodes / calculations as often as specified in the settings
+            for (int i = 2; i < queueElement.Preset.TargetVMAFProbes; i++)
+            {
+                qValues.Add(interpolatedQ);
+                double vmafTmp = EncodeAndCalculate(queueElement, chunk, index, ffmpegFilter, Convert.ToInt32(Math.Round(interpolatedQ)).ToString(), settings, token);
+                vmafValues.Add(vmafTmp);
+
+                interpolatedQ = InterpolateVMAF(qValues.ToArray(), vmafValues.ToArray(), queueElement.Preset.TargetVMAFScore);
+                Global.Logger("INFO  - VMAF.Probe() => Chunk: " + chunk + " - Interpolated Q: " + interpolatedQ.ToString() + " for VMAF: " + queueElement.Preset.TargetVMAFScore.ToString(), queueElement.Output + ".log");
+
+                // Skip remaining probes if the target vmaf value is less than 1 apart from current vmaf value
+                diff = Math.Abs(queueElement.Preset.TargetVMAFScore - vmafTmp);
+                if (diff < 1.0 || interpolatedQ < queueElement.Preset.TargetVMAFMinQ)
+                {
+                    Global.Logger("INFO  - VMAF.Probe() => Chunk: " + chunk + " - SKIP - Interpolated Q: " + interpolatedQ.ToString() + " VMAF Diff: " + diff.ToString(), queueElement.Output + ".log");
+                    break;
+                }
+            }
+
+            chunkVMAF.CalculatedQuantizer = Convert.ToInt32(Math.Round(interpolatedQ)).ToString();
+            chunkVMAF.VMAFValues = vmafValues;
+            chunkVMAF.QValues = qValues;
+
+            queueElement.ChunkVMAF.Add(chunkVMAF);
+
+            return chunkVMAF.CalculatedQuantizer;
+        }
+    }
+}
diff --git a/NotEnoughAV1Encodes/Video/VideoEncode.cs b/NotEnoughAV1Encodes/Video/VideoEncode.cs
index cd66eec..00f9600 100644
--- a/NotEnoughAV1Encodes/Video/VideoEncode.cs
+++ b/NotEnoughAV1Encodes/Video/VideoEncode.cs
@@ -109,7 +109,7 @@ public void Encode(int _workerCount, List<string> VideoChunks, Queue.QueueElemen
                             }
 
                             // Set Chunk Input
-                            if (queueElement.ChunkingMethod == 0 || queueParallel)
+                            if (queueElement.ChunkingMethod == 0 || queueParallel || queueElement.Preset.TargetVMAF)
                             {
                                 // Input for Chunked Encoding or Parallel Queue Processing
                                 ChunkInput = "-i \"" + chunk + "\"";
@@ -170,19 +170,29 @@ public void Encode(int _workerCount, List<string> VideoChunks, Queue.QueueElemen
                                 ChunkOutput = passesSettings + "\"" +  Path.Combine(Global.Temp, "NEAV1E", queueElement.UniqueIdentifier, "Video", index.ToString("D6") + "_stats.log") + "\"" + _NULoutput;
                             }
 
+                            string videoCommand = queueElement.VideoCommand;
+
+                            // Target VMAF
+                            if (queueElement.Preset.TargetVMAF && queueElement.EncodingMethod is (int) Encoder.AOMFFMPEG)
+                            {
+                                VMAF vmaf = new();
+                                string calculatedQ = vmaf.Probe(queueElement, chunk, index, ffmpegFilter, settings, token);
+                                videoCommand = videoCommand.Replace("{q_vmaf}", calculatedQ);
+                            }
+
                             Process processVideo = new();
                             ProcessStartInfo startInfo = new()
                             {
                                 WindowStyle = ProcessWindowStyle.Hidden,
                                 FileName = "cmd.exe",
                                 WorkingDirectory = Path.Combine(Directory.GetCurrentDirectory(), "Apps", "FFmpeg"),
-                                Arguments = "/C ffmpeg.exe -y " + ChunkInput + " " + ffmpegFilter + " -an -sn -map_metadata -1 " + queueElement.VideoCommand + " " + ChunkOutput,
+                                Arguments = "/C ffmpeg.exe -y " + ChunkInput + " " + ffmpegFilter + " -an -sn -map_metadata -1 " + videoCommand + " " + ChunkOutput,
                                 RedirectStandardError = true,
                                 RedirectStandardInput = true,
                                 CreateNoWindow = true
                             };
 
-                            string debugCommand = "/C ffmpeg.exe -y " + ChunkInput + " " + ffmpegFilter + " -an -sn -map_metadata -1 " + queueElement.VideoCommand + " " + ChunkOutput;
+                            string debugCommand = "/C ffmpeg.exe -y " + ChunkInput + " " + ffmpegFilter + " -an -sn -map_metadata -1 " + videoCommand + " " + ChunkOutput;
                             Global.Logger("INFO  - VideoEncode.Encode() => Command: " + debugCommand, queueElement.Output + ".log");
 
                             processVideo.StartInfo = startInfo;
@@ -262,13 +272,13 @@ public void Encode(int _workerCount, List<string> VideoChunks, Queue.QueueElemen
                                     WindowStyle = ProcessWindowStyle.Hidden,
                                     FileName = "cmd.exe",
                                     WorkingDirectory = Path.Combine(Directory.GetCurrentDirectory(), "Apps", "FFmpeg"),
-                                    Arguments = "/C ffmpeg.exe -y " + ChunkInput + " " + ffmpegFilter + " -an -sn -map_metadata -1 " + queueElement.VideoCommand + " " + ChunkOutput,
+                                    Arguments = "/C ffmpeg.exe -y " + ChunkInput + " " + ffmpegFilter + " -an -sn -map_metadata -1 " + videoCommand + " " + ChunkOutput,
                                     RedirectStandardError = true,
                                     RedirectStandardInput = true,
                                     CreateNoWindow = true
                                 };
 
-                                string DebugCommand = "/C ffmpeg.exe -y " + ChunkInput + " " + ffmpegFilter + " -an -sn -map_metadata -1 " + queueElement.VideoCommand + " " + ChunkOutput;
+                                string DebugCommand = "/C ffmpeg.exe -y " + ChunkInput + " " + ffmpegFilter + " -an -sn -map_metadata -1 " + videoCommand + " " + ChunkOutput;
                                 Global.Logger("INFO  - VideoEncode.Encode() 2nd Pass => Command: " + DebugCommand, queueElement.Output + ".log");
 
                                 processVideo2ndPass.StartInfo = startInfo;
diff --git a/NotEnoughAV1Encodes/Video/VideoSettings.cs b/NotEnoughAV1Encodes/Video/VideoSettings.cs
index 679814f..4f12fcb 100644
--- a/NotEnoughAV1Encodes/Video/VideoSettings.cs
+++ b/NotEnoughAV1Encodes/Video/VideoSettings.cs
@@ -181,5 +181,22 @@ public class VideoSettings
         public int Vp9TuneContent { get; set; }
         public int Vp9Tune { get; set; }
         public string Vp9MaxKf { get; set; } = "240";
+
+        // Target VMAF
+
+        /// <summary>Target VMAF Active.</summary>
+        public bool TargetVMAF { get; set; }
+        /// <summary>Target VMAF Use user Encoder Settings (false uses hardcoded settings)</summary>
+        public bool TargetVMAFUserEncoderSettings { get; set; }
+        /// <summary>Target VMAF Score.</summary>
+        public double TargetVMAFScore { get; set; } = 95.0;
+        /// <summary>Target VMAF Tries.</summary>
+        public int TargetVMAFProbes { get; set; } = 4;
+        /// <summary>Target VMAF Minimum Q (Highest Quality).</summary>
+        public int TargetVMAFMinQ { get; set; } = 15;
+        /// <summary>Target VMAF Maximum Q (Lowest Quality).</summary>
+        public int TargetVMAFMaxQ { get; set; } = 40;
+        /// <summary>Target VMAF Proble Video Length (in seconds).</summary>
+        public int TargetVMAFProbeLength { get; set; } = 1;
     }
 }
diff --git a/NotEnoughAV1Encodes/Video/VideoSplitter.cs b/NotEnoughAV1Encodes/Video/VideoSplitter.cs
index 39c95a4..58827b1 100644
--- a/NotEnoughAV1Encodes/Video/VideoSplitter.cs
+++ b/NotEnoughAV1Encodes/Video/VideoSplitter.cs
@@ -1,4 +1,5 @@
-using Microsoft.VisualBasic.FileIO;
+using Microsoft.VisualBasic.FileIO;
+using Newtonsoft.Json.Linq;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -70,7 +71,7 @@ private void PySceneDetect(CancellationToken _token)
 
                 if (!_token.IsCancellationRequested)
                 {
-                    PySceneDetectParse();
+                    PySceneDetectParse(_token);
                 }
                 else
                 {
@@ -83,7 +84,7 @@ private void PySceneDetect(CancellationToken _token)
             }
         }
 
-        private void PySceneDetectParse()
+        private void PySceneDetectParse(CancellationToken token)
         {
             List<string> FFmpegArgs = new();
 
@@ -145,76 +146,95 @@ private void PySceneDetectParse()
                     sw.Close();
                 }
             }
+
+            PySceneTargetVMAFChunking(FFmpegArgs, token);
         }
 
-        private void FFmpegChunking(CancellationToken _token)
+        private void PySceneTargetVMAFChunking(List<string> ffmpegArgs, CancellationToken token)
         {
-            Global.Logger("DEBUG - VideoSplitter.Split() => FFmpegChunking()", queueElement.Output + ".log");
-            // Skips Splitting of already existent
-            if (!File.Exists(Path.Combine(Global.Temp, "NEAV1E", queueElement.UniqueIdentifier, "splitted.log")))
+            // To avoid getting incorrect vmaf values due to ffmpeg seeking issue,
+            // we have to split the video into chunks
+
+            if (!queueElement.Preset.TargetVMAF) return;
+
+            if (File.Exists(Path.Combine(Global.Temp, "NEAV1E", queueElement.UniqueIdentifier, "splitted.log")))
             {
-                // Create Chunks Folder
-                Directory.CreateDirectory(Path.Combine(Global.Temp, "NEAV1E", queueElement.UniqueIdentifier, "Chunks"));
-                Global.Logger("DEBUG - VideoSplitter.Split() => FFmpegChunking() => Path: " + Path.Combine(Global.Temp, "NEAV1E", queueElement.UniqueIdentifier, "Chunks"), queueElement.Output + ".log");
+                Global.Logger("WARN - VideoSplitter.Split() => PySceneTargetVMAFChunking() => Skipped Splitting - Resuming?", queueElement.Output + ".log");
+                return;
+            }
 
-                // Generate Command
-                string ffmpegCommand = "/C ffmpeg.exe -y -i \"" + queueElement.VideoDB.InputPath + "\"";
+            // Create Chunks Folder
+            Directory.CreateDirectory(Path.Combine(Global.Temp, "NEAV1E", queueElement.UniqueIdentifier, "Chunks"));
+            Global.Logger("DEBUG - VideoSplitter.Split() => PySceneTargetVMAFChunking() => Path: " + Path.Combine(Global.Temp, "NEAV1E", queueElement.UniqueIdentifier, "Chunks"), queueElement.Output + ".log");
 
-                // Subtitle Input for Hardcoding
-                if(!string.IsNullOrEmpty(queueElement.SubtitleBurnCommand))
-                {
-                    // Filter not compatible with filter_complex
-                    if (string.IsNullOrEmpty(queueElement.FilterCommand))
-                    {
-                        if (queueElement.SubtitleBurnCommand.Contains("-filter_complex"))
-                        {
-                            ffmpegCommand += " -i \"" + Path.Combine(Global.Temp, "NEAV1E", queueElement.UniqueIdentifier, "Subtitles", "subs.mkv") + "\"";
-                        }
-                    }
-                }
+            int counter = 0;
+            int amount = ffmpegArgs.Count() * 2;
+            foreach (string seek in ffmpegArgs)
+            {
+                string ss = seek.Split("-t")[0];
+                string to = seek.Split(ss)[1];
+                // Generate Command
+                string ffmpegCommand = "/C ffmpeg.exe -y " + ss + " -i \"" + queueElement.VideoDB.InputPath + "\" " + to + " -c:v libx264 -preset ultrafast -crf 0" +
+                                       " -reset_timestamps 1 -map_metadata -1 -sn -an \"" + 
+                                       Path.Combine(Global.Temp, "NEAV1E", queueElement.UniqueIdentifier, "Chunks", "split" + counter.ToString("D6") + ".mkv") + "\"";
 
-                // Set Encoder
-                string encoder = queueElement.ReencodeMethod switch
+                // Start Splitting
+                Process chunkingProcess = new();
+                ProcessStartInfo startInfo = new()
                 {
-                    0 => " -c:v libx264 -preset ultrafast -crf 0",
-                    1 => " -c:v ffv1 -level 3 -threads 4 -coder 1 -context 1 -slicecrc 0 -slices 4",
-                    2 => " -c:v utvideo",
-                    3 => " -c:v copy",
-                    _ => " -c:v copy"
+                    WindowStyle = ProcessWindowStyle.Hidden,
+                    FileName = "cmd.exe",
+                    RedirectStandardInput = false,
+                    RedirectStandardError = false,
+                    CreateNoWindow = true,
+                    WorkingDirectory = Path.Combine(Directory.GetCurrentDirectory(), "Apps", "FFmpeg"),
+                    Arguments = ffmpegCommand
                 };
+                chunkingProcess.StartInfo = startInfo;
 
-                ffmpegCommand += " -reset_timestamps 1 -map_metadata -1 -sn -an" + encoder;
+                token.Register(() => { try { chunkingProcess.StandardInput.Write("q"); } catch { } });
 
+                // Start Process
+                chunkingProcess.Start();
 
-                if (queueElement.ReencodeMethod != 3)
-                {
-                    ffmpegCommand += " -sc_threshold 0 -g " + queueElement.ChunkLength.ToString();
-                    ffmpegCommand += " -force_key_frames " + '\u0022' + "expr:gte(t, n_forced * " + queueElement.ChunkLength.ToString() + ")" + '\u0022';
-                    ffmpegCommand += queueElement.FilterCommand;
-                    if (queueElement.SubtitleBurnCommand != null)
-                    {
-                        if (string.IsNullOrEmpty(queueElement.FilterCommand))
-                        {
-                            ffmpegCommand += queueElement.SubtitleBurnCommand;
-                        }
-                        else
-                        {
-                            // Don't want to mix filter_complex with vf
-                            if (!queueElement.SubtitleBurnCommand.Contains("-filter_complex"))
-                            {
-                                // Prevents using "-vf" two times
-                                ffmpegCommand += queueElement.SubtitleBurnCommand.Remove(0, 5);
-                            }
-                        }
+                // Get launched Process ID
+                int tempPID = chunkingProcess.Id;
 
-                    }
+                // Add Process ID to Array, inorder to keep track / kill the instances
+                Global.LaunchedPIDs.Add(tempPID);
 
-                }
+                queueElement.Status = "Splitting - Chunk " + counter.ToString() + "/" + amount.ToString();
 
-                ffmpegCommand += " -segment_time " + queueElement.ChunkLength.ToString() + " -f segment \"";
-                ffmpegCommand += Path.Combine(Global.Temp, "NEAV1E", queueElement.UniqueIdentifier, "Chunks", "split%6d.mkv") + "\"";
+                // Wait for Exit
+                chunkingProcess.WaitForExit();
 
-                Global.Logger("INFO  - VideoSplitter.Split() => FFmpegChunking() => FFmpeg Command: " + ffmpegCommand, queueElement.Output + ".log");
+                // Get Exit Code
+                int exit_code = chunkingProcess.ExitCode;
+
+                // Remove PID from Array after Exit
+                Global.LaunchedPIDs.RemoveAll(i => i == tempPID);
+
+                counter++;
+            }
+
+            // We repeat the process for max 1s long chunks for later VMAF calculation
+            int counter_temp = 0;
+            foreach (string seek in ffmpegArgs)
+            {
+                string ss = seek.Split("-t")[0];
+                double to = Convert.ToDouble(seek.Split("-t")[1]);
+                string seekto = to.ToString();
+
+                // Only use TargetVMAFProbeLength when the chunk is longer than that value
+                if (to > queueElement.Preset.TargetVMAFProbeLength)
+                {
+                    seekto = queueElement.Preset.TargetVMAFProbeLength.ToString();
+                }
+                
+                // Generate Command
+                string ffmpegCommand = "/C ffmpeg.exe -y " + ss + " -i \"" + queueElement.VideoDB.InputPath + "\" -t " + seekto +
+                                       " -c:v libx264 -preset ultrafast -crf 0 -reset_timestamps 1 -map_metadata -1 -sn -an \"" +
+                                       Path.Combine(Global.Temp, "NEAV1E", queueElement.UniqueIdentifier, "Chunks", "split" + counter_temp.ToString("D6") + ".mkv_vmaf_reference.mp4") + "\"";
 
                 // Start Splitting
                 Process chunkingProcess = new();
@@ -222,15 +242,15 @@ private void FFmpegChunking(CancellationToken _token)
                 {
                     WindowStyle = ProcessWindowStyle.Hidden,
                     FileName = "cmd.exe",
-                    RedirectStandardInput = true,
-                    RedirectStandardError = true,
+                    RedirectStandardInput = false,
+                    RedirectStandardError = false,
                     CreateNoWindow = true,
                     WorkingDirectory = Path.Combine(Directory.GetCurrentDirectory(), "Apps", "FFmpeg"),
                     Arguments = ffmpegCommand
                 };
                 chunkingProcess.StartInfo = startInfo;
 
-                _token.Register(() => { try { chunkingProcess.StandardInput.Write("q"); } catch { } });
+                token.Register(() => { try { chunkingProcess.StandardInput.Write("q"); } catch { } });
 
                 // Start Process
                 chunkingProcess.Start();
@@ -241,20 +261,7 @@ private void FFmpegChunking(CancellationToken _token)
                 // Add Process ID to Array, inorder to keep track / kill the instances
                 Global.LaunchedPIDs.Add(tempPID);
 
-                StreamReader sr = chunkingProcess.StandardError;
-                string stderr = "\n";
-                while (!sr.EndOfStream)
-                {
-                    string line = sr.ReadLine();
-                    if (! line.Contains("frame=") && !line.Contains("[segment"))
-                        stderr += line + "\n";
-                    int processedFrames = Global.GetTotalFramesProcessed(line);
-                    if (processedFrames != 0)
-                    {
-                        queueElement.Progress = Convert.ToDouble(processedFrames);
-                        queueElement.Status = "Splitting - " + ((decimal)queueElement.Progress / queueElement.FrameCount).ToString("0.00%");
-                    }
-                }
+                queueElement.Status = "Splitting - Chunk " + counter.ToString() + "/" + amount.ToString();
 
                 // Wait for Exit
                 chunkingProcess.WaitForExit();
@@ -265,25 +272,148 @@ private void FFmpegChunking(CancellationToken _token)
                 // Remove PID from Array after Exit
                 Global.LaunchedPIDs.RemoveAll(i => i == tempPID);
 
-                // Write Save Point
-                if (chunkingProcess.ExitCode == 0 && _token.IsCancellationRequested == false)
+                counter++;
+                counter_temp++;
+            }
+
+        }
+
+        private void FFmpegChunking(CancellationToken _token)
+        {
+            Global.Logger("DEBUG - VideoSplitter.Split() => FFmpegChunking()", queueElement.Output + ".log");
+            // Skips Splitting of already existent
+            if (File.Exists(Path.Combine(Global.Temp, "NEAV1E", queueElement.UniqueIdentifier, "splitted.log")))
+            {
+                Global.Logger("WARN - VideoSplitter.Split() => FFmpegChunking() => Skipped Splitting - Resuming?", queueElement.Output + ".log");
+                return;
+            }
+
+            // Create Chunks Folder
+            Directory.CreateDirectory(Path.Combine(Global.Temp, "NEAV1E", queueElement.UniqueIdentifier, "Chunks"));
+            Global.Logger("DEBUG - VideoSplitter.Split() => FFmpegChunking() => Path: " + Path.Combine(Global.Temp, "NEAV1E", queueElement.UniqueIdentifier, "Chunks"), queueElement.Output + ".log");
+
+            // Generate Command
+            string ffmpegCommand = "/C ffmpeg.exe -y -i \"" + queueElement.VideoDB.InputPath + "\"";
+
+            // Subtitle Input for Hardcoding
+            if (!string.IsNullOrEmpty(queueElement.SubtitleBurnCommand))
+            {
+                // Filter not compatible with filter_complex
+                if (string.IsNullOrEmpty(queueElement.FilterCommand))
                 {
-                    FileStream _finishedLog = File.Create(Path.Combine(Global.Temp, "NEAV1E", queueElement.UniqueIdentifier, "splitted.log"));
-                    _finishedLog.Close();
-                    Global.Logger("DEBUG - VideoSplitter.Split() => FFmpegChunking() => FFmpeg Exit Code: " + exit_code, queueElement.Output + ".log");
+                    if (queueElement.SubtitleBurnCommand.Contains("-filter_complex"))
+                    {
+                        ffmpegCommand += " -i \"" + Path.Combine(Global.Temp, "NEAV1E", queueElement.UniqueIdentifier, "Subtitles", "subs.mkv") + "\"";
+                    }
                 }
-                else
+            }
+
+            // Set Encoder
+            string encoder = queueElement.ReencodeMethod switch
+            {
+                0 => " -c:v libx264 -preset ultrafast -crf 0",
+                1 => " -c:v ffv1 -level 3 -threads 4 -coder 1 -context 1 -slicecrc 0 -slices 4",
+                2 => " -c:v utvideo",
+                3 => " -c:v copy",
+                _ => " -c:v copy"
+            };
+
+            ffmpegCommand += " -reset_timestamps 1 -map_metadata -1 -sn -an" + encoder;
+
+
+            if (queueElement.ReencodeMethod != 3)
+            {
+                ffmpegCommand += " -sc_threshold 0 -g " + queueElement.ChunkLength.ToString();
+                ffmpegCommand += " -force_key_frames " + '\u0022' + "expr:gte(t, n_forced * " + queueElement.ChunkLength.ToString() + ")" + '\u0022';
+                ffmpegCommand += queueElement.FilterCommand;
+                if (queueElement.SubtitleBurnCommand != null)
                 {
-                    queueElement.Error = true;
-                    queueElement.ErrorCount += 1;
-                    Global.Logger("FATAL - VideoSplitter.Split() => FFmpegChunking() => FFmpeg Exit Code: " + exit_code, queueElement.Output + ".log");
-                    Global.Logger("==========================================================" + stderr, queueElement.Output + ".log");
-                    Global.Logger("==========================================================", queueElement.Output + ".log");
+                    if (string.IsNullOrEmpty(queueElement.FilterCommand))
+                    {
+                        ffmpegCommand += queueElement.SubtitleBurnCommand;
+                    }
+                    else
+                    {
+                        // Don't want to mix filter_complex with vf
+                        if (!queueElement.SubtitleBurnCommand.Contains("-filter_complex"))
+                        {
+                            // Prevents using "-vf" two times
+                            ffmpegCommand += queueElement.SubtitleBurnCommand.Remove(0, 5);
+                        }
+                    }
+
                 }
+
+            }
+
+            ffmpegCommand += " -segment_time " + queueElement.ChunkLength.ToString() + " -f segment \"";
+            ffmpegCommand += Path.Combine(Global.Temp, "NEAV1E", queueElement.UniqueIdentifier, "Chunks", "split%6d.mkv") + "\"";
+
+            Global.Logger("INFO  - VideoSplitter.Split() => FFmpegChunking() => FFmpeg Command: " + ffmpegCommand, queueElement.Output + ".log");
+
+            // Start Splitting
+            Process chunkingProcess = new();
+            ProcessStartInfo startInfo = new()
+            {
+                WindowStyle = ProcessWindowStyle.Hidden,
+                FileName = "cmd.exe",
+                RedirectStandardInput = true,
+                RedirectStandardError = true,
+                CreateNoWindow = true,
+                WorkingDirectory = Path.Combine(Directory.GetCurrentDirectory(), "Apps", "FFmpeg"),
+                Arguments = ffmpegCommand
+            };
+            chunkingProcess.StartInfo = startInfo;
+
+            _token.Register(() => { try { chunkingProcess.StandardInput.Write("q"); } catch { } });
+
+            // Start Process
+            chunkingProcess.Start();
+
+            // Get launched Process ID
+            int tempPID = chunkingProcess.Id;
+
+            // Add Process ID to Array, inorder to keep track / kill the instances
+            Global.LaunchedPIDs.Add(tempPID);
+
+            StreamReader sr = chunkingProcess.StandardError;
+            string stderr = "\n";
+            while (!sr.EndOfStream)
+            {
+                string line = sr.ReadLine();
+                if (!line.Contains("frame=") && !line.Contains("[segment"))
+                    stderr += line + "\n";
+                int processedFrames = Global.GetTotalFramesProcessed(line);
+                if (processedFrames != 0)
+                {
+                    queueElement.Progress = Convert.ToDouble(processedFrames);
+                    queueElement.Status = "Splitting - " + ((decimal)queueElement.Progress / queueElement.FrameCount).ToString("0.00%");
+                }
+            }
+
+            // Wait for Exit
+            chunkingProcess.WaitForExit();
+
+            // Get Exit Code
+            int exit_code = chunkingProcess.ExitCode;
+
+            // Remove PID from Array after Exit
+            Global.LaunchedPIDs.RemoveAll(i => i == tempPID);
+
+            // Write Save Point
+            if (chunkingProcess.ExitCode == 0 && _token.IsCancellationRequested == false)
+            {
+                FileStream _finishedLog = File.Create(Path.Combine(Global.Temp, "NEAV1E", queueElement.UniqueIdentifier, "splitted.log"));
+                _finishedLog.Close();
+                Global.Logger("DEBUG - VideoSplitter.Split() => FFmpegChunking() => FFmpeg Exit Code: " + exit_code, queueElement.Output + ".log");
             }
             else
             {
-                Global.Logger("WARN - VideoSplitter.Split() => FFmpegChunking() => Skipped Splitting - Resuming?", queueElement.Output + ".log");
+                queueElement.Error = true;
+                queueElement.ErrorCount += 1;
+                Global.Logger("FATAL - VideoSplitter.Split() => FFmpegChunking() => FFmpeg Exit Code: " + exit_code, queueElement.Output + ".log");
+                Global.Logger("==========================================================" + stderr, queueElement.Output + ".log");
+                Global.Logger("==========================================================", queueElement.Output + ".log");
             }
         }
 
diff --git a/NotEnoughAV1Encodes/resources/lang/Strings.Designer.cs b/NotEnoughAV1Encodes/resources/lang/Strings.Designer.cs
index ba3f9a2..5ac1474 100644
--- a/NotEnoughAV1Encodes/resources/lang/Strings.Designer.cs
+++ b/NotEnoughAV1Encodes/resources/lang/Strings.Designer.cs
@@ -928,6 +928,51 @@ public class Strings {
             }
         }
         
+        /// <summary>
+        ///   Sucht eine lokalisierte Zeichenfolge, die VMAF: ähnelt.
+        /// </summary>
+        public static string LabelTargetVMAF {
+            get {
+                return ResourceManager.GetString("LabelTargetVMAF", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Sucht eine lokalisierte Zeichenfolge, die Probe Length (s): ähnelt.
+        /// </summary>
+        public static string LabelTargetVMAFMaxProbeLength {
+            get {
+                return ResourceManager.GetString("LabelTargetVMAFMaxProbeLength", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Sucht eine lokalisierte Zeichenfolge, die Max Q: ähnelt.
+        /// </summary>
+        public static string LabelTargetVMAFMaxQ {
+            get {
+                return ResourceManager.GetString("LabelTargetVMAFMaxQ", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Sucht eine lokalisierte Zeichenfolge, die Min Q: ähnelt.
+        /// </summary>
+        public static string LabelTargetVMAFMinQ {
+            get {
+                return ResourceManager.GetString("LabelTargetVMAFMinQ", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Sucht eine lokalisierte Zeichenfolge, die Probes: ähnelt.
+        /// </summary>
+        public static string LabelTargetVMAFProbes {
+            get {
+                return ResourceManager.GetString("LabelTargetVMAFProbes", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Sucht eine lokalisierte Zeichenfolge, die Temp Path ähnelt.
         /// </summary>
@@ -1207,6 +1252,42 @@ public class Strings {
             }
         }
         
+        /// <summary>
+        ///   Sucht eine lokalisierte Zeichenfolge, die Max probe length in seconds. Will be ignored if the chunk itself is shorter. ähnelt.
+        /// </summary>
+        public static string SliderTargetVMAFMaxProbeLengthToolTip {
+            get {
+                return ResourceManager.GetString("SliderTargetVMAFMaxProbeLengthToolTip", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Sucht eine lokalisierte Zeichenfolge, die Sets the lowest possible quality. ähnelt.
+        /// </summary>
+        public static string SliderTargetVMAFMaxQToolTip {
+            get {
+                return ResourceManager.GetString("SliderTargetVMAFMaxQToolTip", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Sucht eine lokalisierte Zeichenfolge, die Sets the best possible quality. ähnelt.
+        /// </summary>
+        public static string SliderTargetVMAFMinQToolTip {
+            get {
+                return ResourceManager.GetString("SliderTargetVMAFMinQToolTip", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Sucht eine lokalisierte Zeichenfolge, die Max amount of tries to approximate the target quality. The logic will try to avoid using more tries than necessary. A minimum of 2 is required, those 2 tries are using Max Q and Min Q from below. ähnelt.
+        /// </summary>
+        public static string SliderTargetVMAFProbesToolTip {
+            get {
+                return ResourceManager.GetString("SliderTargetVMAFProbesToolTip", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Sucht eine lokalisierte Zeichenfolge, die Sort by Framecount (asc) ähnelt.
         /// </summary>
diff --git a/NotEnoughAV1Encodes/resources/lang/Strings.de.resx b/NotEnoughAV1Encodes/resources/lang/Strings.de.resx
index fd5961a..eba6d42 100644
--- a/NotEnoughAV1Encodes/resources/lang/Strings.de.resx
+++ b/NotEnoughAV1Encodes/resources/lang/Strings.de.resx
@@ -575,6 +575,33 @@ Please download and extract 7-zip to the following path:
   <data name="Paths" xml:space="preserve">
     <value>Pfade</value>
   </data>
+  <data name="LabelTargetVMAF" xml:space="preserve">
+    <value>VMAF:</value>
+  </data>
+  <data name="LabelTargetVMAFMaxProbeLength" xml:space="preserve">
+    <value>Probe Länge (s):</value>
+  </data>
+  <data name="LabelTargetVMAFMaxQ" xml:space="preserve">
+    <value>Max Q:</value>
+  </data>
+  <data name="LabelTargetVMAFMinQ" xml:space="preserve">
+    <value>Min Q:</value>
+  </data>
+  <data name="LabelTargetVMAFProbes" xml:space="preserve">
+    <value>Proben:</value>
+  </data>
+  <data name="SliderTargetVMAFMaxProbeLengthToolTip" xml:space="preserve">
+    <value>Maximale Sondenlänge in Sekunden. Wird ignoriert, wenn der Chunk selbst kürzer ist.</value>
+  </data>
+  <data name="SliderTargetVMAFMaxQToolTip" xml:space="preserve">
+    <value>Legt die niedrigstmögliche Qualität fest.</value>
+  </data>
+  <data name="SliderTargetVMAFMinQToolTip" xml:space="preserve">
+    <value>Stellt die bestmögliche Qualität ein.</value>
+  </data>
+  <data name="SliderTargetVMAFProbesToolTip" xml:space="preserve">
+    <value>Maximale Anzahl von Versuchen zur Annäherung an die Zielqualität. Die Logik versucht, mehr Versuche als nötig zu vermeiden. Ein Minimum von 2 Versuchen ist erforderlich, diese 2 Versuche verwenden Max Q und Min Q von unten.</value>
+  </data>
   <data name="ButtonCropAutoDetect" xml:space="preserve">
     <value>Autom. Erkennung</value>
   </data>
diff --git a/NotEnoughAV1Encodes/resources/lang/Strings.fr-FR.resx b/NotEnoughAV1Encodes/resources/lang/Strings.fr-FR.resx
index 1f33652..e888f0a 100644
--- a/NotEnoughAV1Encodes/resources/lang/Strings.fr-FR.resx
+++ b/NotEnoughAV1Encodes/resources/lang/Strings.fr-FR.resx
@@ -575,6 +575,33 @@ Please download and extract 7-zip to the following path:
   <data name="Paths" xml:space="preserve">
     <value>Dossier</value>
   </data>
+  <data name="LabelTargetVMAF" xml:space="preserve">
+    <value>VMAF:</value>
+  </data>
+  <data name="LabelTargetVMAFMaxProbeLength" xml:space="preserve">
+    <value>Sonde longueur (s):</value>
+  </data>
+  <data name="LabelTargetVMAFMaxQ" xml:space="preserve">
+    <value>Max Q:</value>
+  </data>
+  <data name="LabelTargetVMAFMinQ" xml:space="preserve">
+    <value>Min Q:</value>
+  </data>
+  <data name="LabelTargetVMAFProbes" xml:space="preserve">
+    <value>Sondes:</value>
+  </data>
+  <data name="SliderTargetVMAFMaxProbeLengthToolTip" xml:space="preserve">
+    <value>Longueur maximale de la probe en secondes. Ce paramètre sera ignoré si le chunk lui-même est plus court.</value>
+  </data>
+  <data name="SliderTargetVMAFMaxQToolTip" xml:space="preserve">
+    <value>Définit la qualité la plus basse possible.</value>
+  </data>
+  <data name="SliderTargetVMAFMinQToolTip" xml:space="preserve">
+    <value>Définit la meilleure qualité possible.</value>
+  </data>
+  <data name="SliderTargetVMAFProbesToolTip" xml:space="preserve">
+    <value>Nombre maximal d'essais pour approcher la qualité cible. La logique essaiera d'éviter d'utiliser plus d'essais que nécessaire. Un minimum de 2 essais est requis, ces 2 essais utilisent Max Q et Min Q à partir du bas.</value>
+  </data>
   <data name="ButtonCropAutoDetect" xml:space="preserve">
     <value>Détection automatique</value>
   </data>
diff --git a/NotEnoughAV1Encodes/resources/lang/Strings.it-IT.resx b/NotEnoughAV1Encodes/resources/lang/Strings.it-IT.resx
index bd186fa..f33f919 100644
--- a/NotEnoughAV1Encodes/resources/lang/Strings.it-IT.resx
+++ b/NotEnoughAV1Encodes/resources/lang/Strings.it-IT.resx
@@ -530,6 +530,33 @@ Please download and extract 7-zip to the following path:
   <data name="Paths" xml:space="preserve">
     <value>Percorsi</value>
   </data>
+  <data name="LabelTargetVMAF" xml:space="preserve">
+    <value>VMAF:</value>
+  </data>
+  <data name="LabelTargetVMAFMaxProbeLength" xml:space="preserve">
+    <value>Probe Lunghezza (s):</value>
+  </data>
+  <data name="LabelTargetVMAFMaxQ" xml:space="preserve">
+    <value>Max Q:</value>
+  </data>
+  <data name="LabelTargetVMAFMinQ" xml:space="preserve">
+    <value>Min Q:</value>
+  </data>
+  <data name="LabelTargetVMAFProbes" xml:space="preserve">
+    <value>Sonde:</value>
+  </data>
+  <data name="SliderTargetVMAFMaxProbeLengthToolTip" xml:space="preserve">
+    <value>Lunghezza massima della sonda in secondi. Verrà ignorata se il chunk stesso è più breve.</value>
+  </data>
+  <data name="SliderTargetVMAFMaxQToolTip" xml:space="preserve">
+    <value>Imposta la qualità più bassa possibile.</value>
+  </data>
+  <data name="SliderTargetVMAFMinQToolTip" xml:space="preserve">
+    <value>Imposta la migliore qualità possibile.</value>
+  </data>
+  <data name="SliderTargetVMAFProbesToolTip" xml:space="preserve">
+    <value>Numero massimo di tentativi per approssimare la qualità target. La logica cercherà di evitare di utilizzare più tentativi del necessario. È necessario un minimo di 2 tentativi; questi 2 tentativi utilizzano Q max e Q min dal basso.</value>
+  </data>
   <data name="ButtonCropAutoDetect" xml:space="preserve">
     <value>Rilevamento automatico</value>
   </data>
diff --git a/NotEnoughAV1Encodes/resources/lang/Strings.ja-JP.resx b/NotEnoughAV1Encodes/resources/lang/Strings.ja-JP.resx
index 1375561..8f5b6f4 100644
--- a/NotEnoughAV1Encodes/resources/lang/Strings.ja-JP.resx
+++ b/NotEnoughAV1Encodes/resources/lang/Strings.ja-JP.resx
@@ -539,6 +539,33 @@ Please download and extract 7-zip to the following path:
   <data name="Paths" xml:space="preserve">
     <value>パス</value>
   </data>
+  <data name="LabelTargetVMAF" xml:space="preserve">
+    <value>VMAF:</value>
+  </data>
+  <data name="LabelTargetVMAFMaxProbeLength" xml:space="preserve">
+    <value>プローブの長さ（s）:</value>
+  </data>
+  <data name="LabelTargetVMAFMaxQ" xml:space="preserve">
+    <value>マックスQ:</value>
+  </data>
+  <data name="LabelTargetVMAFMinQ" xml:space="preserve">
+    <value>ミンQ:</value>
+  </data>
+  <data name="LabelTargetVMAFProbes" xml:space="preserve">
+    <value>プローブを使用します：</value>
+  </data>
+  <data name="SliderTargetVMAFMaxProbeLengthToolTip" xml:space="preserve">
+    <value>プローブの最大長を秒単位で指定します。チャンク自体の長さが短い場合は無視されます。</value>
+  </data>
+  <data name="SliderTargetVMAFMaxQToolTip" xml:space="preserve">
+    <value>可能な限り低い品質を設定します。</value>
+  </data>
+  <data name="SliderTargetVMAFMinQToolTip" xml:space="preserve">
+    <value>最高の画質を設定します。</value>
+  </data>
+  <data name="SliderTargetVMAFProbesToolTip" xml:space="preserve">
+    <value>目標品質に近づけるための試行回数の最大値。ロジックは、必要以上の試行回数を使用しないようにします。最低2回の試行が必要で、この2回の試行には、以下から最大Qと最小Qが使用されます。</value>
+  </data>
   <data name="ButtonCropAutoDetect" xml:space="preserve">
     <value>オートディテクト</value>
   </data>
diff --git a/NotEnoughAV1Encodes/resources/lang/Strings.resx b/NotEnoughAV1Encodes/resources/lang/Strings.resx
index 7ba9700..e347e91 100644
--- a/NotEnoughAV1Encodes/resources/lang/Strings.resx
+++ b/NotEnoughAV1Encodes/resources/lang/Strings.resx
@@ -581,6 +581,33 @@ Please download and extract 7-zip to the following path:
   <data name="Paths" xml:space="preserve">
     <value>Paths</value>
   </data>
+  <data name="LabelTargetVMAF" xml:space="preserve">
+    <value>VMAF:</value>
+  </data>
+  <data name="LabelTargetVMAFProbes" xml:space="preserve">
+    <value>Probes:</value>
+  </data>
+  <data name="LabelTargetVMAFMaxProbeLength" xml:space="preserve">
+    <value>Probe Length (s):</value>
+  </data>
+  <data name="LabelTargetVMAFMaxQ" xml:space="preserve">
+    <value>Max Q:</value>
+  </data>
+  <data name="LabelTargetVMAFMinQ" xml:space="preserve">
+    <value>Min Q:</value>
+  </data>
+  <data name="SliderTargetVMAFMaxProbeLengthToolTip" xml:space="preserve">
+    <value>Max probe length in seconds. Will be ignored if the chunk itself is shorter.</value>
+  </data>
+  <data name="SliderTargetVMAFMaxQToolTip" xml:space="preserve">
+    <value>Sets the lowest possible quality.</value>
+  </data>
+  <data name="SliderTargetVMAFMinQToolTip" xml:space="preserve">
+    <value>Sets the best possible quality.</value>
+  </data>
+  <data name="SliderTargetVMAFProbesToolTip" xml:space="preserve">
+    <value>Max amount of tries to approximate the target quality. The logic will try to avoid using more tries than necessary. A minimum of 2 is required, those 2 tries are using Max Q and Min Q from below.</value>
+  </data>
   <data name="ButtonCropAutoDetect" xml:space="preserve">
     <value>Auto Detect</value>
   </data>
diff --git a/NotEnoughAV1Encodes/resources/lang/Strings.ru-RU.resx b/NotEnoughAV1Encodes/resources/lang/Strings.ru-RU.resx
index 4725512..0fe1f78 100644
--- a/NotEnoughAV1Encodes/resources/lang/Strings.ru-RU.resx
+++ b/NotEnoughAV1Encodes/resources/lang/Strings.ru-RU.resx
@@ -523,6 +523,33 @@ Please download and extract 7-zip to the following path:
   <data name="Paths" xml:space="preserve">
     <value>Пути</value>
   </data>
+  <data name="LabelTargetVMAF" xml:space="preserve">
+    <value>VMAF:</value>
+  </data>
+  <data name="LabelTargetVMAFMaxProbeLength" xml:space="preserve">
+    <value>Длина зонда (s):</value>
+  </data>
+  <data name="LabelTargetVMAFMaxQ" xml:space="preserve">
+    <value>Макс Q:</value>
+  </data>
+  <data name="LabelTargetVMAFMinQ" xml:space="preserve">
+    <value>Минь Q:</value>
+  </data>
+  <data name="LabelTargetVMAFProbes" xml:space="preserve">
+    <value>Зонды:</value>
+  </data>
+  <data name="SliderTargetVMAFMaxProbeLengthToolTip" xml:space="preserve">
+    <value>Максимальная длина зонда в секундах. Будет игнорироваться, если сам чанк короче.</value>
+  </data>
+  <data name="SliderTargetVMAFMaxQToolTip" xml:space="preserve">
+    <value>Устанавливает минимально возможное качество.</value>
+  </data>
+  <data name="SliderTargetVMAFMinQToolTip" xml:space="preserve">
+    <value>Устанавливает наилучшее возможное качество.</value>
+  </data>
+  <data name="SliderTargetVMAFProbesToolTip" xml:space="preserve">
+    <value>Максимальное количество попыток для приближения к целевому качеству. Логика будет стараться избегать использования большего количества попыток, чем необходимо. Требуется минимум 2, эти 2 попытки используют Max Q и Min Q снизу.</value>
+  </data>
   <data name="ButtonCropAutoDetect" xml:space="preserve">
     <value>автоматическое обнаружение</value>
   </data>
diff --git a/NotEnoughAV1Encodes/resources/lang/Strings.zh-CN.resx b/NotEnoughAV1Encodes/resources/lang/Strings.zh-CN.resx
index 2c5c47a..107065e 100644
--- a/NotEnoughAV1Encodes/resources/lang/Strings.zh-CN.resx
+++ b/NotEnoughAV1Encodes/resources/lang/Strings.zh-CN.resx
@@ -572,6 +572,33 @@
   <data name="Paths" xml:space="preserve">
     <value>路径</value>
   </data>
+  <data name="LabelTargetVMAF" xml:space="preserve">
+    <value>VMAF:</value>
+  </data>
+  <data name="LabelTargetVMAFMaxProbeLength" xml:space="preserve">
+    <value>探头长度（s）:</value>
+  </data>
+  <data name="LabelTargetVMAFMaxQ" xml:space="preserve">
+    <value>马克斯-Q:</value>
+  </data>
+  <data name="LabelTargetVMAFMinQ" xml:space="preserve">
+    <value>敏Q:</value>
+  </data>
+  <data name="LabelTargetVMAFProbes" xml:space="preserve">
+    <value>探头:</value>
+  </data>
+  <data name="SliderTargetVMAFMaxProbeLengthToolTip" xml:space="preserve">
+    <value>最大探测长度（秒）。如果数据块本身更短，则会被忽略。</value>
+  </data>
+  <data name="SliderTargetVMAFMaxQToolTip" xml:space="preserve">
+    <value>设置尽可能低的质量。</value>
+  </data>
+  <data name="SliderTargetVMAFMinQToolTip" xml:space="preserve">
+    <value>设置尽可能好的质量。</value>
+  </data>
+  <data name="SliderTargetVMAFProbesToolTip" xml:space="preserve">
+    <value>接近目标质量的最大尝试量。该逻辑将尽量避免使用超过必要的尝试。至少需要2次，这2次尝试是使用下面的最大Q和最小Q。</value>
+  </data>
   <data name="ButtonCropAutoDetect" xml:space="preserve">
     <value>自动检测</value>
   </data>