diff --git a/YUViewLib/src/common/Error.h b/YUViewLib/src/common/Error.h
new file mode 100644
index 000000000..8c884a417
--- /dev/null
+++ b/YUViewLib/src/common/Error.h
@@ -0,0 +1,41 @@
+/*  This file is part of YUView - The YUV player with advanced analytics toolset
+ *   <https://github.com/IENT/YUView>
+ *   Copyright (C) 2015  Institut für Nachrichtentechnik, RWTH Aachen University, GERMANY
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   In addition, as a special exception, the copyright holders give
+ *   permission to link the code of portions of this program with the
+ *   OpenSSL library under certain conditions as described in each
+ *   individual source file, and distribute linked combinations including
+ *   the two.
+ *
+ *   You must obey the GNU General Public License in all respects for all
+ *   of the code used other than OpenSSL. If you modify file(s) with this
+ *   exception, you may extend this exception to your version of the
+ *   file(s), but you are not obligated to do so. If you do not wish to do
+ *   so, delete this exception statement from your version. If you delete
+ *   this exception statement from all source files in the program, then
+ *   also delete it here.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <stdexcept>
+
+class NotImplemented : public std::logic_error
+{
+public:
+  NotImplemented() : std::logic_error("Function not yet implemented"){};
+};
diff --git a/YUViewLib/src/common/Typedef.h b/YUViewLib/src/common/Typedef.h
index 8c3023270..d1b4e5ad7 100644
--- a/YUViewLib/src/common/Typedef.h
+++ b/YUViewLib/src/common/Typedef.h
@@ -274,6 +274,21 @@ template <typename T> struct Range
   }
 };
 
+struct Position
+{
+  Position() = default;
+  Position(int x, int y)
+  {
+    this->x = x;
+    this->y = y;
+  }
+
+  int x{};
+  int y{};
+
+  bool operator!=(const Position &other) const { return this->x != other.x || this->y != other.y; }
+};
+
 struct Ratio
 {
   int num{};
diff --git a/YUViewLib/src/decoder/decoderBase.cpp b/YUViewLib/src/decoder/decoderBase.cpp
index 22688152e..6550b16a8 100644
--- a/YUViewLib/src/decoder/decoderBase.cpp
+++ b/YUViewLib/src/decoder/decoderBase.cpp
@@ -32,9 +32,11 @@
 
 #include "decoderBase.h"
 
+#include <QCoreApplication>
 #include <QDir>
 #include <QSettings>
 
+
 namespace decoder
 {
 
diff --git a/YUViewLib/src/ffmpeg/FFmpegVersionHandler.cpp b/YUViewLib/src/ffmpeg/FFmpegVersionHandler.cpp
index 10df6a6e8..9ca5a6d99 100644
--- a/YUViewLib/src/ffmpeg/FFmpegVersionHandler.cpp
+++ b/YUViewLib/src/ffmpeg/FFmpegVersionHandler.cpp
@@ -31,6 +31,7 @@
  */
 
 #include "FFmpegVersionHandler.h"
+#include <QCoreApplication>
 #include <QDateTime>
 #include <QDir>
 
diff --git a/YUViewLib/src/playlistitem/playlistItemCompressedVideo.cpp b/YUViewLib/src/playlistitem/playlistItemCompressedVideo.cpp
index 796f2e36b..a353a80e9 100644
--- a/YUViewLib/src/playlistitem/playlistItemCompressedVideo.cpp
+++ b/YUViewLib/src/playlistitem/playlistItemCompressedVideo.cpp
@@ -204,9 +204,9 @@ playlistItemCompressedVideo::playlistItemCompressedVideo(const QString &compress
     // Is this file RGB or YUV?
     this->rawFormat = this->inputFileFFmpegLoading->getRawFormat();
     DEBUG_COMPRESSED("playlistItemCompressedVideo::playlistItemCompressedVideo Raw format "
-                     << (this->rawFormat == raw_YUV                 ? "YUV"
-                         : this->rawFormat == video::RawFormat::RGB ? "RGB"
-                                                                    : "Unknown"));
+                     << (this->rawFormat == raw_YUV
+                             ? "YUV"
+                             : this->rawFormat == video::RawFormat::RGB ? "RGB" : "Unknown"));
     if (this->rawFormat == video::RawFormat::YUV)
       formatYuv = this->inputFileFFmpegLoading->getPixelFormatYUV();
     else if (this->rawFormat == video::RawFormat::RGB)
@@ -681,8 +681,8 @@ void playlistItemCompressedVideo::loadRawData(int frameIdx, bool caching)
       {
         // In this scenario, we can read and push AVPackets
         // from the FFmpeg file and pass them to the FFmpeg decoder directly.
-        auto pkt   = caching ? this->inputFileFFmpegCaching->getNextPacket(repushData)
-                             : this->inputFileFFmpegLoading->getNextPacket(repushData);
+        auto pkt = caching ? this->inputFileFFmpegCaching->getNextPacket(repushData)
+                           : this->inputFileFFmpegLoading->getNextPacket(repushData);
         repushData = false;
         if (pkt)
           DEBUG_COMPRESSED("playlistItemCompressedVideo::loadRawData retrived packet PTS "
diff --git a/YUViewLib/src/playlistitem/playlistItemCompressedVideo.h b/YUViewLib/src/playlistitem/playlistItemCompressedVideo.h
index b2bf20b28..cfd7aae7f 100644
--- a/YUViewLib/src/playlistitem/playlistItemCompressedVideo.h
+++ b/YUViewLib/src/playlistitem/playlistItemCompressedVideo.h
@@ -42,8 +42,6 @@
 
 #include "playlistItemWithVideo.h"
 
-class videoHandler;
-
 /* This playlist item encapsulates all compressed video sequences.
  * We can read the data from a plain binary file (we support various raw annexB formats) or we can
  * use ffmpeg to read from a container. For decoding, a range of different decoders is available.
diff --git a/YUViewLib/src/playlistitem/playlistItemDifference.cpp b/YUViewLib/src/playlistitem/playlistItemDifference.cpp
index 18e95d750..c51f9c188 100644
--- a/YUViewLib/src/playlistitem/playlistItemDifference.cpp
+++ b/YUViewLib/src/playlistitem/playlistItemDifference.cpp
@@ -44,15 +44,15 @@
 #define DEBUG_DIFF(fmt, ...) ((void)0)
 #endif
 
-#define DIFFERENCE_INFO_TEXT                                                                       \
-  "Please drop two video item's onto this difference item to calculate the difference."
+constexpr auto DIFFERENCE_INFO_TEXT =
+    "Please drop two video item's onto this difference item to calculate the difference.";
 
 playlistItemDifference::playlistItemDifference() : playlistItemContainer("Difference Item")
 {
-  setIcon(0, functionsGui::convertIcon(":img_difference.png"));
+  this->setIcon(0, functionsGui::convertIcon(":img_difference.png"));
   // Enable dropping for difference objects. The user can drop the two items to calculate the
   // difference from.
-  setFlags(flags() | Qt::ItemIsDropEnabled);
+  this->setFlags(this->flags() | Qt::ItemIsDropEnabled);
 
   this->prop.propertiesWidgetTitle = "Difference Properties";
 
@@ -61,10 +61,10 @@ playlistItemDifference::playlistItemDifference() : playlistItemContainer("Differ
   this->frameLimitsMax = false;
   this->infoText       = DIFFERENCE_INFO_TEXT;
 
-  connect(&difference,
-          &video::videoHandlerDifference::signalHandlerChanged,
-          this,
-          &playlistItemDifference::SignalItemChanged);
+  this->connect(&this->difference,
+                &video::videoHandlerDifference::signalHandlerChanged,
+                this,
+                &playlistItemDifference::SignalItemChanged);
 }
 
 /* For a difference item, the info list is just a list of the names of the
@@ -74,20 +74,18 @@ InfoData playlistItemDifference::getInfo() const
 {
   InfoData info("Difference Info");
 
-  if (childCount() >= 1)
-    info.items.append(InfoItem(QString("File 1"), getChildPlaylistItem(0)->properties().name));
-  if (childCount() >= 2)
-    info.items.append(InfoItem(QString("File 2"), getChildPlaylistItem(1)->properties().name));
+  if (this->childCount() >= 1)
+    info.items.append(
+        InfoItem(QString("File 1"), this->getChildPlaylistItem(0)->properties().name));
+  if (this->childCount() >= 2)
+    info.items.append(
+        InfoItem(QString("File 2"), this->getChildPlaylistItem(1)->properties().name));
 
   // Report the position of the first difference in coding order
-  difference.reportFirstDifferencePosition(info.items);
+  this->difference.reportFirstDifferencePosition(info.items);
 
-  // Report MSE
-  for (int i = 0; i < difference.differenceInfoList.length(); i++)
-  {
-    InfoItem p = difference.differenceInfoList[i];
-    info.items.append(p);
-  }
+  for (const auto &item : this->difference.differenceInfoList)
+    info.items.append(item);
 
   return info;
 }
@@ -99,35 +97,35 @@ void playlistItemDifference::drawItem(QPainter *painter,
 {
   DEBUG_DIFF("playlistItemDifference::drawItem frameIdx %d %s",
              frameIdx,
-             childLlistUpdateRequired ? "childLlistUpdateRequired" : "");
-  if (childLlistUpdateRequired)
+             this->childLlistUpdateRequired ? "childLlistUpdateRequired" : "");
+  if (this->childLlistUpdateRequired)
   {
     // Update the 'childList' and connect the signals/slots
-    updateChildList();
+    this->updateChildList();
 
     // Update the items in the difference item
     video::FrameHandler *childVideo0 = nullptr;
     video::FrameHandler *childVideo1 = nullptr;
     if (childCount() >= 1)
-      childVideo0 = getChildPlaylistItem(0)->getFrameHandler();
+      childVideo0 = this->getChildPlaylistItem(0)->getFrameHandler();
     if (childCount() >= 2)
-      childVideo1 = getChildPlaylistItem(1)->getFrameHandler();
+      childVideo1 = this->getChildPlaylistItem(1)->getFrameHandler();
 
-    difference.setInputVideos(childVideo0, childVideo1);
+    this->difference.setInputVideos(childVideo0, childVideo1);
 
-    if (childCount() > 2)
-      infoText = "More than two items are not supported.\n" DIFFERENCE_INFO_TEXT;
+    if (this->childCount() > 2)
+      infoText = "More than two items are not supported.\n" + QString(DIFFERENCE_INFO_TEXT);
     else
       infoText = DIFFERENCE_INFO_TEXT;
   }
 
-  if (childCount() != 2 || !difference.inputsValid())
+  if (this->childCount() != 2 || !this->difference.inputsValid())
     // Draw the emptyText
     playlistItem::drawItem(painter, -1, zoomFactor, drawRawData);
   else
   {
     // draw the videoHandler
-    difference.drawDifferenceFrame(painter, frameIdx, zoomFactor, drawRawData);
+    this->difference.drawDifferenceFrame(painter, frameIdx, zoomFactor, drawRawData);
   }
 }
 
@@ -138,13 +136,11 @@ ItemLoadingState playlistItemDifference::needsLoading(int frameIdx, bool loadRaw
 
 QSize playlistItemDifference::getSize() const
 {
-  if (!difference.inputsValid())
-  {
+  if (!this->difference.inputsValid())
     // Return the size of the empty text.
     return playlistItemContainer::getSize();
-  }
 
-  auto s = difference.getFrameSize();
+  auto s = this->difference.getFrameSize();
   return QSize(s.width, s.height);
 }
 
@@ -152,12 +148,12 @@ void playlistItemDifference::createPropertiesWidget()
 {
   Q_ASSERT_X(!this->propertiesWidget, "createPropertiesWidget", "Properties widget already exists");
 
-  preparePropertiesWidget(QStringLiteral("playlistItemDifference"));
+  this->preparePropertiesWidget(QStringLiteral("playlistItemDifference"));
 
   // On the top level everything is layout vertically
-  QVBoxLayout *vAllLaout = new QVBoxLayout(propertiesWidget.data());
+  auto vAllLaout = new QVBoxLayout(this->propertiesWidget.data());
 
-  QFrame *line = new QFrame;
+  auto line = new QFrame;
   line->setObjectName(QStringLiteral("line"));
   line->setFrameShape(QFrame::HLine);
   line->setFrameShadow(QFrame::Sunken);
@@ -187,7 +183,7 @@ void playlistItemDifference::savePlaylist(QDomElement &root, const QDir &playlis
 playlistItemDifference *
 playlistItemDifference::newPlaylistItemDifference(const YUViewDomElement &root)
 {
-  playlistItemDifference *newDiff = new playlistItemDifference();
+  auto newDiff = new playlistItemDifference();
 
   // Load properties from the parent classes
   newDiff->difference.loadPlaylist(root);
@@ -211,7 +207,7 @@ ValuePairListSets playlistItemDifference::getPixelValues(const QPoint &pixelPos,
   {
     newSet.append("Item B",
                   getChildPlaylistItem(1)->getFrameHandler()->getPixelValues(pixelPos, frameIdx));
-    newSet.append("Diff (A-B)", difference.getPixelValues(pixelPos, frameIdx, nullptr));
+    newSet.append("Diff (A-B)", this->difference.getPixelValues(pixelPos, frameIdx, nullptr));
   }
 
   return newSet;
@@ -222,18 +218,18 @@ void playlistItemDifference::loadFrame(int  frameIdx,
                                        bool loadRawData,
                                        bool emitSignals)
 {
-  if (childCount() != 2 || !difference.inputsValid())
+  if (this->childCount() != 2 || !this->difference.inputsValid())
     return;
 
-  auto state = difference.needsLoading(frameIdx, loadRawData);
+  const auto state = this->difference.needsLoading(frameIdx, loadRawData);
   if (state == ItemLoadingState::LoadingNeeded)
   {
     // Load the requested current frame
     DEBUG_DIFF("playlistItemDifference::loadFrame loading difference for frame %d", frameIdx);
-    isDifferenceLoading = true;
+    this->isDifferenceLoading = true;
     // Since every playlist item can have it's own relative indexing, we need two frame indices
-    difference.loadFrameDifference(frameIdx);
-    isDifferenceLoading = false;
+    this->difference.loadFrameDifference(frameIdx);
+    this->isDifferenceLoading = false;
     if (emitSignals)
       emit SignalItemChanged(true, RECACHE_NONE);
   }
@@ -248,16 +244,19 @@ void playlistItemDifference::loadFrame(int  frameIdx,
       DEBUG_DIFF("playlistItemDifference::loadFrame loading difference into double buffer %d %s",
                  nextFrameIdx,
                  playing ? "(playing)" : "");
-      isDifferenceLoadingToDoubleBuffer = true;
-      difference.loadFrameDifference(frameIdx, true);
-      isDifferenceLoadingToDoubleBuffer = false;
+      this->isDifferenceLoadingToDoubleBuffer = true;
+      this->difference.loadFrameDifference(frameIdx, true);
+      this->isDifferenceLoadingToDoubleBuffer = false;
       if (emitSignals)
         emit signalItemDoubleBufferLoaded();
     }
   }
 }
 
-bool playlistItemDifference::isLoading() const { return this->isDifferenceLoading; }
+bool playlistItemDifference::isLoading() const
+{
+  return this->isDifferenceLoading;
+}
 
 bool playlistItemDifference::isLoadingDoubleBuffer() const
 {
@@ -268,6 +267,6 @@ void playlistItemDifference::childChanged(bool redraw, recacheIndicator recache)
 {
   // One of the child items changed and needs to redraw. This means that the difference is out of
   // date and has to be recalculated.
-  difference.invalidateAllBuffers();
+  this->difference.invalidateAllBuffers();
   playlistItemContainer::childChanged(redraw, recache);
 }
\ No newline at end of file
diff --git a/YUViewLib/src/playlistitem/playlistItemImageFile.cpp b/YUViewLib/src/playlistitem/playlistItemImageFile.cpp
index 40195fa58..6eb88a7be 100644
--- a/YUViewLib/src/playlistitem/playlistItemImageFile.cpp
+++ b/YUViewLib/src/playlistitem/playlistItemImageFile.cpp
@@ -32,14 +32,15 @@
 
 #include "playlistItemImageFile.h"
 
+#include <common/FunctionsGui.h>
+#include <filesource/FileSource.h>
+#include <video/FrameHandler.h>
+
 #include <QImageReader>
 #include <QPainter>
 #include <QSettings>
 #include <QUrl>
 
-#include <common/FunctionsGui.h>
-#include <filesource/FileSource.h>
-
 #define IMAGEFILE_ERROR_TEXT "The given image file could not be loaded."
 
 playlistItemImageFile::playlistItemImageFile(const QString &filePath)
@@ -122,7 +123,7 @@ playlistItemImageFile::newplaylistItemImageFile(const YUViewDomElement &root,
 
 void playlistItemImageFile::drawItem(QPainter *painter, int, double zoomFactor, bool drawRawData)
 {
-  if (!frame.isFormatValid())
+  if (!this->frame.isFormatValid())
   {
     // The image could not be loaded. Draw a text instead.
     // Get the size of the text and create a QRect of that size which is centered at (0,0)
@@ -137,7 +138,7 @@ void playlistItemImageFile::drawItem(QPainter *painter, int, double zoomFactor,
     painter->drawText(textRect, IMAGEFILE_ERROR_TEXT);
   }
   else if (!this->imageLoading)
-    frame.drawFrame(painter, zoomFactor, drawRawData);
+    this->frame.drawFrame(painter, zoomFactor, drawRawData);
 }
 
 ItemLoadingState playlistItemImageFile::needsLoading(int, bool)
@@ -177,7 +178,7 @@ void playlistItemImageFile::getSupportedFileExtensions(QStringList &allExtension
 ValuePairListSets playlistItemImageFile::getPixelValues(const QPoint &pixelPos, int)
 {
   ValuePairListSets newSet;
-  newSet.append("RGB", frame.getPixelValues(pixelPos, -1));
+  newSet.append("RGB", this->frame.getPixelValues(pixelPos, -1));
   return newSet;
 }
 
@@ -186,14 +187,15 @@ InfoData playlistItemImageFile::getInfo() const
   InfoData info("Image Info");
 
   info.items.append(InfoItem("File", this->properties().name));
-  if (frame.isFormatValid())
+  if (this->frame.isFormatValid())
   {
-    auto frameSize = frame.getFrameSize();
+    const auto frameSize = this->frame.getFrameSize();
     info.items.append(InfoItem("Resolution",
                                QString("%1x%2").arg(frameSize.width).arg(frameSize.height),
                                "The video resolution in pixel (width x height)"));
-    info.items.append(InfoItem(
-        "Bit depth", QString::number(frame.getImageBitDepth()), "The bit depth of the image."));
+    info.items.append(InfoItem("Bit depth",
+                               QString::number(this->frame.getImageBitDepth()),
+                               "The bit depth of the image."));
   }
   else if (isLoading())
     info.items.append(InfoItem("Status", "Loading...", "The image is being loaded. Please wait."));
@@ -205,8 +207,8 @@ InfoData playlistItemImageFile::getInfo() const
 
 QSize playlistItemImageFile::getSize() const
 {
-  auto s = frame.getFrameSize();
-  return QSize(s.width, s.height);
+  const auto size = this->frame.getFrameSize();
+  return QSize(size.width, size.height);
 }
 
 void playlistItemImageFile::updateSettings()
diff --git a/YUViewLib/src/playlistitem/playlistItemImageFile.h b/YUViewLib/src/playlistitem/playlistItemImageFile.h
index 98888a981..aa8c0c6b7 100644
--- a/YUViewLib/src/playlistitem/playlistItemImageFile.h
+++ b/YUViewLib/src/playlistitem/playlistItemImageFile.h
@@ -32,13 +32,17 @@
 
 #pragma once
 
-#include "playlistItem.h"
-
+#include <playlistitem/playlistItem.h>
 #include <video/FrameHandler.h>
 
 #include <QFileSystemWatcher>
 #include <QFuture>
 
+namespace video
+{
+class FrameHandler;
+}
+
 class playlistItemImageFile : public playlistItem
 {
   Q_OBJECT
diff --git a/YUViewLib/src/playlistitem/playlistItemResample.cpp b/YUViewLib/src/playlistitem/playlistItemResample.cpp
index 4ae1d3947..c877a5319 100644
--- a/YUViewLib/src/playlistitem/playlistItemResample.cpp
+++ b/YUViewLib/src/playlistitem/playlistItemResample.cpp
@@ -112,36 +112,36 @@ void playlistItemResample::drawItem(QPainter *painter,
           this->sampling   = 1;
         }
 
-        if (ui.created())
+        if (this->ui.created())
         {
-          QSignalBlocker blockerWidth(ui.spinBoxWidth);
-          QSignalBlocker blockerHeight(ui.spinBoxHeight);
-          ui.spinBoxWidth->setValue(this->scaledSize.width);
-          ui.spinBoxHeight->setValue(this->scaledSize.height);
+          QSignalBlocker blockerWidth(this->ui.spinBoxWidth);
+          QSignalBlocker blockerHeight(this->ui.spinBoxHeight);
+          this->ui.spinBoxWidth->setValue(this->scaledSize.width);
+          this->ui.spinBoxHeight->setValue(this->scaledSize.height);
 
           auto nrFramesInput = this->cutRange.second - this->cutRange.first + 1;
 
-          QSignalBlocker blockerSampling(ui.spinBoxSampling);
-          ui.spinBoxSampling->setMinimum(1);
-          ui.spinBoxSampling->setMaximum(nrFramesInput);
-          ui.spinBoxSampling->setValue(this->sampling);
+          QSignalBlocker blockerSampling(this->ui.spinBoxSampling);
+          this->ui.spinBoxSampling->setMinimum(1);
+          this->ui.spinBoxSampling->setMaximum(nrFramesInput);
+          this->ui.spinBoxSampling->setValue(this->sampling);
 
-          QSignalBlocker blockerStart(ui.spinBoxStart);
-          ui.spinBoxStart->setMinimum(this->cutRange.first);
-          ui.spinBoxStart->setMaximum(this->cutRange.second);
-          ui.spinBoxStart->setValue(this->cutRange.first);
+          QSignalBlocker blockerStart(this->ui.spinBoxStart);
+          this->ui.spinBoxStart->setMinimum(this->cutRange.first);
+          this->ui.spinBoxStart->setMaximum(this->cutRange.second);
+          this->ui.spinBoxStart->setValue(this->cutRange.first);
 
-          QSignalBlocker blockerEnd(ui.spinBoxEnd);
-          ui.spinBoxEnd->setMinimum(this->cutRange.first);
-          ui.spinBoxEnd->setMaximum(this->cutRange.second);
-          ui.spinBoxEnd->setValue(this->cutRange.second);
+          QSignalBlocker blockerEnd(this->ui.spinBoxEnd);
+          this->ui.spinBoxEnd->setMinimum(this->cutRange.first);
+          this->ui.spinBoxEnd->setMaximum(this->cutRange.second);
+          this->ui.spinBoxEnd->setValue(this->cutRange.second);
 
           auto sampleAspectRatio = child->properties().sampleAspectRatio;
           auto sarEnabled        = sampleAspectRatio.num != 0 && sampleAspectRatio.den != 0 &&
                             sampleAspectRatio.num != sampleAspectRatio.den;
-          ui.labelSAR->setEnabled(sarEnabled);
-          ui.pushButtonSARWidth->setEnabled(sarEnabled);
-          ui.pushButtonSARHeight->setEnabled(sarEnabled);
+          this->ui.labelSAR->setEnabled(sarEnabled);
+          this->ui.pushButtonSARWidth->setEnabled(sarEnabled);
+          this->ui.pushButtonSARHeight->setEnabled(sarEnabled);
         }
 
         this->video.setScaledSize(this->scaledSize);
@@ -155,9 +155,9 @@ void playlistItemResample::drawItem(QPainter *painter,
       }
       else
       {
-        ui.labelSAR->setEnabled(false);
-        ui.pushButtonSARWidth->setEnabled(false);
-        ui.pushButtonSARHeight->setEnabled(false);
+        this->ui.labelSAR->setEnabled(false);
+        this->ui.pushButtonSARWidth->setEnabled(false);
+        this->ui.pushButtonSARHeight->setEnabled(false);
       }
     }
   }
@@ -190,50 +190,50 @@ void playlistItemResample::createPropertiesWidget()
   // On the top level everything is layout vertically
   auto vAllLaout = new QVBoxLayout(propertiesWidget.data());
 
-  ui.setupUi();
+  this->ui.setupUi();
 
-  ui.comboBoxInterpolation->addItems(QStringList() << "Bilinear"
-                                                   << "Linear");
-  ui.comboBoxInterpolation->setCurrentIndex(this->interpolationIndex);
+  this->ui.comboBoxInterpolation->addItems(QStringList() << "Bilinear"
+                                                          << "Linear");
+  this->ui.comboBoxInterpolation->setCurrentIndex(this->interpolationIndex);
 
-  ui.labelSAR->setEnabled(false);
-  ui.pushButtonSARWidth->setEnabled(false);
-  ui.pushButtonSARHeight->setEnabled(false);
+  this->ui.labelSAR->setEnabled(false);
+  this->ui.pushButtonSARWidth->setEnabled(false);
+  this->ui.pushButtonSARHeight->setEnabled(false);
 
-  this->connect(ui.spinBoxWidth,
+  this->connect(this->ui.spinBoxWidth,
                 QOverload<int>::of(&QSpinBox::valueChanged),
                 this,
                 &playlistItemResample::slotResampleControlChanged);
-  this->connect(ui.spinBoxHeight,
+  this->connect(this->ui.spinBoxHeight,
                 QOverload<int>::of(&QSpinBox::valueChanged),
                 this,
                 &playlistItemResample::slotResampleControlChanged);
-  this->connect(ui.comboBoxInterpolation,
+  this->connect(this->ui.comboBoxInterpolation,
                 QOverload<int>::of(&QComboBox::currentIndexChanged),
                 this,
                 &playlistItemResample::slotInterpolationModeChanged);
-  this->connect(ui.spinBoxStart,
+  this->connect(this->ui.spinBoxStart,
                 QOverload<int>::of(&QSpinBox::valueChanged),
                 this,
                 &playlistItemResample::slotCutAndSampleControlChanged);
-  this->connect(ui.spinBoxEnd,
+  this->connect(this->ui.spinBoxEnd,
                 QOverload<int>::of(&QSpinBox::valueChanged),
                 this,
                 &playlistItemResample::slotCutAndSampleControlChanged);
-  this->connect(ui.spinBoxSampling,
+  this->connect(this->ui.spinBoxSampling,
                 QOverload<int>::of(&QSpinBox::valueChanged),
                 this,
                 &playlistItemResample::slotCutAndSampleControlChanged);
-  this->connect(ui.pushButtonSARWidth,
+  this->connect(this->ui.pushButtonSARWidth,
                 &QPushButton::clicked,
                 this,
                 &playlistItemResample::slotButtonSARWidth);
-  this->connect(ui.pushButtonSARHeight,
+  this->connect(this->ui.pushButtonSARHeight,
                 &QPushButton::clicked,
                 this,
                 &playlistItemResample::slotButtonSARHeight);
 
-  vAllLaout->addLayout(ui.topVBoxLayout);
+  vAllLaout->addLayout(this->ui.topVBoxLayout);
 }
 
 void playlistItemResample::savePlaylist(QDomElement &root, const QDir &playlistDir) const
@@ -340,13 +340,13 @@ void playlistItemResample::childChanged(bool redraw, recacheIndicator recache)
 
 void playlistItemResample::slotResampleControlChanged(int)
 {
-  this->scaledSize = Size(ui.spinBoxWidth->value(), ui.spinBoxHeight->value());
+  this->scaledSize = Size(this->ui.spinBoxWidth->value(), this->ui.spinBoxHeight->value());
   this->video.setScaledSize(this->scaledSize);
 }
 
 void playlistItemResample::slotInterpolationModeChanged(int)
 {
-  this->interpolationIndex = ui.comboBoxInterpolation->currentIndex();
+  this->interpolationIndex = this->ui.comboBoxInterpolation->currentIndex();
   auto interpolation       = (this->interpolationIndex == 0)
                            ? video::videoHandlerResample::Interpolation::Bilinear
                            : video::videoHandlerResample::Interpolation::Fast;
@@ -355,8 +355,8 @@ void playlistItemResample::slotInterpolationModeChanged(int)
 
 void playlistItemResample::slotCutAndSampleControlChanged(int)
 {
-  this->cutRange = indexRange(ui.spinBoxStart->value(), ui.spinBoxEnd->value());
-  this->sampling = std::max(ui.spinBoxSampling->value(), 1);
+  this->cutRange = indexRange(this->ui.spinBoxStart->value(), this->ui.spinBoxEnd->value());
+  this->sampling = std::max(this->ui.spinBoxSampling->value(), 1);
 
   auto nrFrames            = (this->cutRange.second - this->cutRange.first) / this->sampling;
   this->prop.startEndRange = indexRange(0, nrFrames);
diff --git a/YUViewLib/src/playlistitem/playlistItemResample.h b/YUViewLib/src/playlistitem/playlistItemResample.h
index a2a47e650..fbcd64086 100644
--- a/YUViewLib/src/playlistitem/playlistItemResample.h
+++ b/YUViewLib/src/playlistitem/playlistItemResample.h
@@ -1,34 +1,34 @@
 /*  This file is part of YUView - The YUV player with advanced analytics toolset
-*   <https://github.com/IENT/YUView>
-*   Copyright (C) 2015  Institut für Nachrichtentechnik, RWTH Aachen University, GERMANY
-*
-*   This program is free software; you can redistribute it and/or modify
-*   it under the terms of the GNU General Public License as published by
-*   the Free Software Foundation; either version 3 of the License, or
-*   (at your option) any later version.
-*
-*   In addition, as a special exception, the copyright holders give
-*   permission to link the code of portions of this program with the
-*   OpenSSL library under certain conditions as described in each
-*   individual source file, and distribute linked combinations including
-*   the two.
-*   
-*   You must obey the GNU General Public License in all respects for all
-*   of the code used other than OpenSSL. If you modify file(s) with this
-*   exception, you may extend this exception to your version of the
-*   file(s), but you are not obligated to do so. If you do not wish to do
-*   so, delete this exception statement from your version. If you delete
-*   this exception statement from all source files in the program, then
-*   also delete it here.
-*
-*   This program is distributed in the hope that it will be useful,
-*   but WITHOUT ANY WARRANTY; without even the implied warranty of
-*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-*   GNU General Public License for more details.
-*
-*   You should have received a copy of the GNU General Public License
-*   along with this program. If not, see <http://www.gnu.org/licenses/>.
-*/
+ *   <https://github.com/IENT/YUView>
+ *   Copyright (C) 2015  Institut für Nachrichtentechnik, RWTH Aachen University, GERMANY
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   In addition, as a special exception, the copyright holders give
+ *   permission to link the code of portions of this program with the
+ *   OpenSSL library under certain conditions as described in each
+ *   individual source file, and distribute linked combinations including
+ *   the two.
+ *
+ *   You must obey the GNU General Public License in all respects for all
+ *   of the code used other than OpenSSL. If you modify file(s) with this
+ *   exception, you may extend this exception to your version of the
+ *   file(s), but you are not obligated to do so. If you do not wish to do
+ *   so, delete this exception statement from your version. If you delete
+ *   this exception statement from all source files in the program, then
+ *   also delete it here.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
 
 #pragma once
 
@@ -36,7 +36,6 @@
 #include "video/videoHandlerResample.h"
 
 #include "ui_playlistItemResample.h"
-
 class playlistItemResample : public playlistItemContainer
 {
   Q_OBJECT
@@ -48,22 +47,27 @@ class playlistItemResample : public playlistItemContainer
 
   // Overload from playlistItemVideo.
   virtual QSize getSize() const override;
-  
-  // Overload from playlistItemVideo. We add some specific drawing functionality if the two children are not comparable.
-  virtual void drawItem(QPainter *painter, int frameIdx, double zoomFactor, bool drawRawData) override;
+
+  // Overload from playlistItemVideo. We add some specific drawing functionality if the two children
+  // are not comparable.
+  virtual void
+  drawItem(QPainter *painter, int frameIdx, double zoomFactor, bool drawRawData) override;
 
   virtual void activateDoubleBuffer() override { this->video.activateDoubleBuffer(); }
 
   // Do we need to load the given frame first?
   virtual ItemLoadingState needsLoading(int frameIdx, bool loadRawData) override;
-  // This is part of the caching interface. The loadFrame function is always called from a different thread.
-  virtual void loadFrame(int frameIdx, bool playing, bool loadRawData, bool emitSignals=true) override;
+  // This is part of the caching interface. The loadFrame function is always called from a different
+  // thread.
+  virtual void
+               loadFrame(int frameIdx, bool playing, bool loadRawData, bool emitSignals = true) override;
   virtual bool isLoading() const override { return this->isFrameLoading; }
   virtual bool isLoadingDoubleBuffer() const override { return this->isFrameLoadingDoubleBuffer; }
 
   // Overload from playlistItem. Save the playlist item to playlist.
   virtual void savePlaylist(QDomElement &root, const QDir &playlistDir) const override;
-  // Create a new playlistItemResample from the playlist file entry. Return nullptr if parsing failed.
+  // Create a new playlistItemResample from the playlist file entry. Return nullptr if parsing
+  // failed.
   static playlistItemResample *newPlaylistItemResample(const YUViewDomElement &stringElement);
 
   // Get the pixel values from A, B and the difference.
@@ -83,23 +87,22 @@ private slots:
   void slotButtonSARHeight(bool selected);
 
 private:
-
   // Overload from playlistItem. Create a properties widget custom to the playlistItemResample
   // and set propertiesWidget to point to it.
   virtual void createPropertiesWidget() override;
 
   video::videoHandlerResample video;
 
-  Size scaledSize {0, 0};
-  int interpolationIndex {0};
-  indexRange cutRange {0, 0};
-  int sampling {1};
+  Size       scaledSize{0, 0};
+  int        interpolationIndex{0};
+  indexRange cutRange{0, 0};
+  int        sampling{1};
 
-  bool useLoadedValues {false};
+  bool useLoadedValues{false};
 
   // Is the loadFrame function currently loading?
-  bool isFrameLoading {false};
-  bool isFrameLoadingDoubleBuffer {false};
+  bool isFrameLoading{false};
+  bool isFrameLoadingDoubleBuffer{false};
 
   SafeUi<Ui::playlistItemResample> ui;
 };
diff --git a/YUViewLib/src/playlistitem/playlistItemWithVideo.cpp b/YUViewLib/src/playlistitem/playlistItemWithVideo.cpp
index b88e134ef..25e791b0a 100644
--- a/YUViewLib/src/playlistitem/playlistItemWithVideo.cpp
+++ b/YUViewLib/src/playlistitem/playlistItemWithVideo.cpp
@@ -32,6 +32,9 @@
 
 #include "playlistItemWithVideo.h"
 
+#include <video/rgb/videoHandlerRGB.h>
+#include <video/yuv/videoHandlerYUV.h>
+
 // Activate this if you want to know when which buffer is loaded/converted to image and so on.
 #define PLAYLISTITEMWITHVIDEO_DEBUG_LOADING 0
 #if PLAYLISTITEMWITHVIDEO_DEBUG_LOADING && !NDEBUG
diff --git a/YUViewLib/src/video/FrameHandler.cpp b/YUViewLib/src/video/FrameHandler.cpp
index 40796c8ed..c64e83878 100644
--- a/YUViewLib/src/video/FrameHandler.cpp
+++ b/YUViewLib/src/video/FrameHandler.cpp
@@ -110,44 +110,40 @@ QStringList FrameHandler::frameSizePresetList::getFormattedNames() const
 
 FrameHandler::frameSizePresetList FrameHandler::presetFrameSizes;
 
-FrameHandler::FrameHandler()
-{
-}
-
 QLayout *FrameHandler::createFrameHandlerControls(bool isSizeFixed)
 {
   // Absolutely always only call this function once!
-  assert(!ui.created());
+  assert(!this->ui.created());
 
-  ui.setupUi();
+  this->ui.setupUi();
 
   // Set default values
-  ui.widthSpinBox->setMaximum(100000);
-  ui.widthSpinBox->setValue(frameSize.width);
-  ui.widthSpinBox->setEnabled(!isSizeFixed);
-  ui.heightSpinBox->setMaximum(100000);
-  ui.heightSpinBox->setValue(frameSize.height);
-  ui.heightSpinBox->setEnabled(!isSizeFixed);
-  ui.frameSizeComboBox->addItems(presetFrameSizes.getFormattedNames());
+  this->ui.widthSpinBox->setMaximum(100000);
+  this->ui.widthSpinBox->setValue(frameSize.width);
+  this->ui.widthSpinBox->setEnabled(!isSizeFixed);
+  this->ui.heightSpinBox->setMaximum(100000);
+  this->ui.heightSpinBox->setValue(frameSize.height);
+  this->ui.heightSpinBox->setEnabled(!isSizeFixed);
+  this->ui.frameSizeComboBox->addItems(presetFrameSizes.getFormattedNames());
   int idx = presetFrameSizes.findSize(frameSize);
-  ui.frameSizeComboBox->setCurrentIndex(idx);
-  ui.frameSizeComboBox->setEnabled(!isSizeFixed);
+  this->ui.frameSizeComboBox->setCurrentIndex(idx);
+  this->ui.frameSizeComboBox->setEnabled(!isSizeFixed);
 
   // Connect all the change signals from the controls to "connectWidgetSignals()"
-  connect(ui.widthSpinBox,
+  connect(this->ui.widthSpinBox,
           QOverload<int>::of(&QSpinBox::valueChanged),
           this,
           &FrameHandler::slotVideoControlChanged);
-  connect(ui.heightSpinBox,
+  connect(this->ui.heightSpinBox,
           QOverload<int>::of(&QSpinBox::valueChanged),
           this,
           &FrameHandler::slotVideoControlChanged);
-  connect(ui.frameSizeComboBox,
+  connect(this->ui.frameSizeComboBox,
           QOverload<int>::of(&QComboBox::currentIndexChanged),
           this,
           &FrameHandler::slotVideoControlChanged);
 
-  return ui.frameHandlerLayout;
+  return this->ui.frameHandlerLayout;
 }
 
 void FrameHandler::setFrameSize(Size newSize)
@@ -234,27 +230,27 @@ Size FrameHandler::getNewSizeFromControls()
   // The control that caused the slot to be called
   auto sender = QObject::sender();
 
-  if (sender == ui.widthSpinBox || sender == ui.heightSpinBox)
+  if (sender == this->ui.widthSpinBox || sender == this->ui.heightSpinBox)
   {
-    auto newSize = Size(ui.widthSpinBox->value(), ui.heightSpinBox->value());
+    auto newSize = Size(this->ui.widthSpinBox->value(), this->ui.heightSpinBox->value());
     if (newSize != frameSize)
     {
       // Set the comboBox index without causing another signal to be emitted.
-      const QSignalBlocker blocker(ui.frameSizeComboBox);
+      const QSignalBlocker blocker(this->ui.frameSizeComboBox);
       int                  idx = presetFrameSizes.findSize(newSize);
-      ui.frameSizeComboBox->setCurrentIndex(idx);
+      this->ui.frameSizeComboBox->setCurrentIndex(idx);
     }
     return newSize;
   }
-  else if (sender == ui.frameSizeComboBox)
+  else if (sender == this->ui.frameSizeComboBox)
   {
-    auto newSize = presetFrameSizes.getSize(ui.frameSizeComboBox->currentIndex());
+    auto newSize = presetFrameSizes.getSize(this->ui.frameSizeComboBox->currentIndex());
 
     // Set the width/height spin boxes without emitting another signal.
-    const QSignalBlocker blocker1(ui.widthSpinBox);
-    const QSignalBlocker blocker2(ui.heightSpinBox);
-    ui.widthSpinBox->setValue(int(newSize.width));
-    ui.heightSpinBox->setValue(int(newSize.height));
+    const QSignalBlocker blocker1(this->ui.widthSpinBox);
+    const QSignalBlocker blocker2(this->ui.heightSpinBox);
+    this->ui.widthSpinBox->setValue(int(newSize.width));
+    this->ui.heightSpinBox->setValue(int(newSize.height));
     return newSize;
   }
   return {};
diff --git a/YUViewLib/src/video/FrameHandler.h b/YUViewLib/src/video/FrameHandler.h
index 0b4a0c51d..f58391c7e 100644
--- a/YUViewLib/src/video/FrameHandler.h
+++ b/YUViewLib/src/video/FrameHandler.h
@@ -57,10 +57,6 @@ class FrameHandler : public QObject
   Q_OBJECT
 
 public:
-  // Create a new blank FrameHandler. Don't forget to load an image from file
-  // (loadCurrentImageFromFile).
-  FrameHandler();
-
   // Get the size/bit depth of the (current) frame
   Size getFrameSize() const { return frameSize; }
   int  getImageBitDepth() const { return currentImage.depth(); }
diff --git a/YUViewLib/src/video/rgb/videoHandlerRGB.cpp b/YUViewLib/src/video/rgb/videoHandlerRGB.cpp
index f27fba58e..241a5b97b 100644
--- a/YUViewLib/src/video/rgb/videoHandlerRGB.cpp
+++ b/YUViewLib/src/video/rgb/videoHandlerRGB.cpp
@@ -235,7 +235,7 @@ bool videoHandlerRGB::setFormatFromString(QString format)
 QLayout *videoHandlerRGB::createVideoHandlerControls(bool isSizeFixed)
 {
   // Absolutely always only call this function once!
-  assert(!ui.created());
+  assert(!this->ui.created());
 
   QVBoxLayout *newVBoxLayout = nullptr;
   if (!isSizeFixed)
@@ -252,68 +252,72 @@ QLayout *videoHandlerRGB::createVideoHandlerControls(bool isSizeFixed)
     newVBoxLayout->addWidget(line);
   }
 
-  ui.setupUi();
+  this->ui.setupUi();
 
   // Set all the values of the properties widget to the values of this class
-  ui.rgbFormatComboBox->addItems(functions::toQStringList(rgbPresetList.getFormattedNames()));
-  ui.rgbFormatComboBox->addItem("Custom...");
-  ui.rgbFormatComboBox->setEnabled(!isSizeFixed);
+  this->ui.rgbFormatComboBox->addItems(functions::toQStringList(rgbPresetList.getFormattedNames()));
+  this->ui.rgbFormatComboBox->addItem("Custom...");
+  this->ui.rgbFormatComboBox->setEnabled(!isSizeFixed);
   int idx = rgbPresetList.indexOf(srcPixelFormat);
   if (idx == -1 && srcPixelFormat.isValid())
   {
     // Custom pixel format (but a known pixel format). Add and select it.
     rgbPresetList.append(srcPixelFormat);
-    int nrItems = ui.rgbFormatComboBox->count();
-    ui.rgbFormatComboBox->insertItem(nrItems - 1, QString::fromStdString(srcPixelFormat.getName()));
+    int nrItems = this->ui.rgbFormatComboBox->count();
+    this->ui.rgbFormatComboBox->insertItem(nrItems - 1,
+                                           QString::fromStdString(srcPixelFormat.getName()));
     idx = rgbPresetList.indexOf(srcPixelFormat);
-    ui.rgbFormatComboBox->setCurrentIndex(idx);
+    this->ui.rgbFormatComboBox->setCurrentIndex(idx);
   }
   else if (idx > 0)
-    ui.rgbFormatComboBox->setCurrentIndex(idx);
+    this->ui.rgbFormatComboBox->setCurrentIndex(idx);
 
-  ui.RScaleSpinBox->setValue(componentScale[0]);
-  ui.RScaleSpinBox->setMaximum(1000);
-  ui.GScaleSpinBox->setValue(componentScale[1]);
-  ui.GScaleSpinBox->setMaximum(1000);
-  ui.BScaleSpinBox->setValue(componentScale[2]);
-  ui.BScaleSpinBox->setMaximum(1000);
-  ui.AScaleSpinBox->setValue(componentScale[3]);
-  ui.AScaleSpinBox->setMaximum(1000);
+  this->ui.RScaleSpinBox->setValue(componentScale[0]);
+  this->ui.RScaleSpinBox->setMaximum(1000);
+  this->ui.GScaleSpinBox->setValue(componentScale[1]);
+  this->ui.GScaleSpinBox->setMaximum(1000);
+  this->ui.BScaleSpinBox->setValue(componentScale[2]);
+  this->ui.BScaleSpinBox->setMaximum(1000);
+  this->ui.AScaleSpinBox->setValue(componentScale[3]);
+  this->ui.AScaleSpinBox->setMaximum(1000);
 
-  ui.RInvertCheckBox->setChecked(this->componentInvert[0]);
-  ui.GInvertCheckBox->setChecked(this->componentInvert[1]);
-  ui.BInvertCheckBox->setChecked(this->componentInvert[2]);
-  ui.AInvertCheckBox->setChecked(this->componentInvert[3]);
+  this->ui.RInvertCheckBox->setChecked(this->componentInvert[0]);
+  this->ui.GInvertCheckBox->setChecked(this->componentInvert[1]);
+  this->ui.BInvertCheckBox->setChecked(this->componentInvert[2]);
+  this->ui.AInvertCheckBox->setChecked(this->componentInvert[3]);
 
-  ui.limitedRangeCheckBox->setChecked(this->limitedRange);
+  this->ui.limitedRangeCheckBox->setChecked(this->limitedRange);
 
-  connect(ui.rgbFormatComboBox,
+  connect(this->ui.rgbFormatComboBox,
           QOverload<int>::of(&QComboBox::currentIndexChanged),
           this,
           &videoHandlerRGB::slotRGBFormatControlChanged);
-  connect(ui.colorComponentsComboBox,
+  connect(this->ui.colorComponentsComboBox,
           QOverload<int>::of(&QComboBox::currentIndexChanged),
           this,
           &videoHandlerRGB::slotDisplayOptionsChanged);
-  for (auto spinBox : {ui.RScaleSpinBox, ui.GScaleSpinBox, ui.BScaleSpinBox, ui.AScaleSpinBox})
+  for (auto spinBox : {this->ui.RScaleSpinBox,
+                       this->ui.GScaleSpinBox,
+                       this->ui.BScaleSpinBox,
+                       this->ui.AScaleSpinBox})
     connect(spinBox,
             QOverload<int>::of(&QSpinBox::valueChanged),
             this,
             &videoHandlerRGB::slotDisplayOptionsChanged);
-  for (auto checkBox : {ui.RInvertCheckBox,
-                        ui.GInvertCheckBox,
-                        ui.BInvertCheckBox,
-                        ui.AInvertCheckBox,
-                        ui.limitedRangeCheckBox})
+  for (auto checkBox : {this->ui.RInvertCheckBox,
+                        this->ui.GInvertCheckBox,
+                        this->ui.BInvertCheckBox,
+                        this->ui.AInvertCheckBox,
+                        this->ui.limitedRangeCheckBox})
     connect(checkBox, &QCheckBox::stateChanged, this, &videoHandlerRGB::slotDisplayOptionsChanged);
 
   this->updateControlsForNewPixelFormat();
 
   if (!isSizeFixed && newVBoxLayout)
-    newVBoxLayout->addLayout(ui.topVerticalLayout);
+    newVBoxLayout->addLayout(this->ui.topVerticalLayout);
 
   if (isSizeFixed)
-    return ui.topVerticalLayout;
+    return this->ui.topVerticalLayout;
   else
     return newVBoxLayout;
 }
@@ -321,21 +325,21 @@ QLayout *videoHandlerRGB::createVideoHandlerControls(bool isSizeFixed)
 void videoHandlerRGB::slotDisplayOptionsChanged()
 {
   {
-    auto selection = ui.colorComponentsComboBox->currentText().toStdString();
+    auto selection = this->ui.colorComponentsComboBox->currentText().toStdString();
     if (auto c = componentShowMapper.getValue(selection,
                                               EnumMapper<ComponentDisplayMode>::StringType::Text))
       this->componentDisplayMode = *c;
   }
 
-  componentScale[0]  = ui.RScaleSpinBox->value();
-  componentScale[1]  = ui.GScaleSpinBox->value();
-  componentScale[2]  = ui.BScaleSpinBox->value();
-  componentScale[3]  = ui.AScaleSpinBox->value();
-  componentInvert[0] = ui.RInvertCheckBox->isChecked();
-  componentInvert[1] = ui.GInvertCheckBox->isChecked();
-  componentInvert[2] = ui.BInvertCheckBox->isChecked();
-  componentInvert[3] = ui.AInvertCheckBox->isChecked();
-  limitedRange       = ui.limitedRangeCheckBox->isChecked();
+  componentScale[0]  = this->ui.RScaleSpinBox->value();
+  componentScale[1]  = this->ui.GScaleSpinBox->value();
+  componentScale[2]  = this->ui.BScaleSpinBox->value();
+  componentScale[3]  = this->ui.AScaleSpinBox->value();
+  componentInvert[0] = this->ui.RInvertCheckBox->isChecked();
+  componentInvert[1] = this->ui.GInvertCheckBox->isChecked();
+  componentInvert[2] = this->ui.BInvertCheckBox->isChecked();
+  componentInvert[3] = this->ui.AInvertCheckBox->isChecked();
+  limitedRange       = this->ui.limitedRangeCheckBox->isChecked();
 
   // Set the current frame in the buffer to be invalid and clear the cache.
   // Emit that this item needs redraw and the cache needs updating.
@@ -346,25 +350,25 @@ void videoHandlerRGB::slotDisplayOptionsChanged()
 
 void videoHandlerRGB::updateControlsForNewPixelFormat()
 {
-  if (!ui.created())
+  if (!this->ui.created())
     return;
 
   auto valid         = this->srcPixelFormat.isValid();
   auto hasAlpha      = this->srcPixelFormat.hasAlpha();
   auto validAndAlpha = valid & hasAlpha;
 
-  ui.RScaleSpinBox->setEnabled(valid);
-  ui.GScaleSpinBox->setEnabled(valid);
-  ui.BScaleSpinBox->setEnabled(valid);
-  ui.AScaleSpinBox->setEnabled(validAndAlpha);
-  ui.RInvertCheckBox->setEnabled(valid);
-  ui.GInvertCheckBox->setEnabled(valid);
-  ui.BInvertCheckBox->setEnabled(valid);
-  ui.AInvertCheckBox->setEnabled(validAndAlpha);
-
-  QSignalBlocker block(ui.colorComponentsComboBox);
-  ui.colorComponentsComboBox->setEnabled(valid);
-  ui.colorComponentsComboBox->clear();
+  this->ui.RScaleSpinBox->setEnabled(valid);
+  this->ui.GScaleSpinBox->setEnabled(valid);
+  this->ui.BScaleSpinBox->setEnabled(valid);
+  this->ui.AScaleSpinBox->setEnabled(validAndAlpha);
+  this->ui.RInvertCheckBox->setEnabled(valid);
+  this->ui.GInvertCheckBox->setEnabled(valid);
+  this->ui.BInvertCheckBox->setEnabled(valid);
+  this->ui.AInvertCheckBox->setEnabled(validAndAlpha);
+
+  QSignalBlocker block(this->ui.colorComponentsComboBox);
+  this->ui.colorComponentsComboBox->setEnabled(valid);
+  this->ui.colorComponentsComboBox->clear();
   if (valid)
   {
     std::vector<ComponentDisplayMode> listItems;
@@ -388,16 +392,16 @@ void videoHandlerRGB::updateControlsForNewPixelFormat()
       this->componentDisplayMode = ComponentDisplayMode::RGBA;
 
     for (const auto &item : listItems)
-      ui.colorComponentsComboBox->addItem(
+      this->ui.colorComponentsComboBox->addItem(
           QString::fromStdString(componentShowMapper.getText(item)));
-    ui.colorComponentsComboBox->setCurrentText(
+    this->ui.colorComponentsComboBox->setCurrentText(
         QString::fromStdString(componentShowMapper.getText(this->componentDisplayMode)));
   }
 }
 
 void videoHandlerRGB::slotRGBFormatControlChanged()
 {
-  auto selectionIdx     = ui.rgbFormatComboBox->currentIndex();
+  auto selectionIdx     = this->ui.rgbFormatComboBox->currentIndex();
   auto nrBytesOldFormat = getBytesPerFrame();
 
   if (selectionIdx == this->rgbPresetList.count())
@@ -415,18 +419,18 @@ void videoHandlerRGB::slotRGBFormatControlChanged()
     {
       // Valid pixel format which is not in the list. Add it...
       this->rgbPresetList.append(this->srcPixelFormat);
-      int                  nrItems = ui.rgbFormatComboBox->count();
-      const QSignalBlocker blocker(ui.rgbFormatComboBox);
-      ui.rgbFormatComboBox->insertItem(nrItems - 1,
-                                       QString::fromStdString(this->srcPixelFormat.getName()));
+      int                  nrItems = this->ui.rgbFormatComboBox->count();
+      const QSignalBlocker blocker(this->ui.rgbFormatComboBox);
+      this->ui.rgbFormatComboBox->insertItem(
+          nrItems - 1, QString::fromStdString(this->srcPixelFormat.getName()));
       idx = this->rgbPresetList.indexOf(this->srcPixelFormat);
     }
 
     if (idx > 0)
     {
       // Format found. Set it without another call to this function.
-      const QSignalBlocker blocker(ui.rgbFormatComboBox);
-      ui.rgbFormatComboBox->setCurrentIndex(idx);
+      const QSignalBlocker blocker(this->ui.rgbFormatComboBox);
+      this->ui.rgbFormatComboBox->setCurrentIndex(idx);
     }
 
     selectionIdx = idx;
diff --git a/YUViewLib/src/video/videoHandler.cpp b/YUViewLib/src/video/videoHandler.cpp
index 796a61a6b..1a06c836b 100644
--- a/YUViewLib/src/video/videoHandler.cpp
+++ b/YUViewLib/src/video/videoHandler.cpp
@@ -178,31 +178,32 @@ ItemLoadingState videoHandler::needsLoading(int frameIdx, bool loadRawValues)
 void videoHandler::drawFrame(QPainter *painter, int frameIdx, double zoomFactor, bool drawRawValues)
 {
   // Check if the frameIdx changed and if we have to load a new frame
-  if (frameIdx != currentImageIndex)
+  if (frameIdx != this->currentImageIndex)
   {
     // The current buffer is out of date. Update it.
 
     // Check the double buffer
     if (frameIdx == doubleBufferImageFrameIndex)
     {
-      currentImage      = doubleBufferImage;
-      currentImageIndex = frameIdx;
+      this->currentImage      = this->doubleBufferImage;
+      this->currentImageIndex = frameIdx;
       DEBUG_VIDEO("videoHandler::drawFrame %d loaded from double buffer", frameIdx);
     }
     else
     {
       QMutexLocker lock(&imageCacheAccess);
-      if (cacheValid && imageCache.contains(frameIdx))
+      if (this->cacheValid && this->imageCache.contains(frameIdx))
       {
-        currentImage      = imageCache[frameIdx];
-        currentImageIndex = frameIdx;
+        this->currentImage      = this->imageCache[frameIdx];
+        this->currentImageIndex = frameIdx;
         DEBUG_VIDEO("videoHandler::drawFrame %d loaded from cache", frameIdx);
       }
     }
   }
 
-  DEBUG_VIDEO(
-      "videoHandler::drawFrame frameIdx %d currentImageIndex %d", frameIdx, currentImageIndex);
+  DEBUG_VIDEO("videoHandler::drawFrame frameIdx %d currentImageIndex %d",
+              frameIdx,
+              this->currentImageIndex);
 
   // Create the video QRect with the size of the sequence and center it.
   QRect videoRect;
@@ -210,9 +211,10 @@ void videoHandler::drawFrame(QPainter *painter, int frameIdx, double zoomFactor,
   videoRect.moveCenter(QPoint(0, 0));
 
   // Draw the current image (currentImage)
-  currentImageSetMutex.lock();
-  painter->drawImage(videoRect, currentImage);
-  currentImageSetMutex.unlock();
+  {
+    QMutexLocker lock(&this->currentImageSetMutex);
+    painter->drawImage(videoRect, currentImage);
+  }
 
   if (drawRawValues && zoomFactor >= SPLITVIEW_DRAW_VALUES_ZOOMFACTOR)
   {
diff --git a/YUViewLib/src/video/videoHandlerDifference.cpp b/YUViewLib/src/video/videoHandlerDifference.cpp
index 9d3ad8651..ba685856d 100644
--- a/YUViewLib/src/video/videoHandlerDifference.cpp
+++ b/YUViewLib/src/video/videoHandlerDifference.cpp
@@ -49,6 +49,198 @@ namespace video
 #define DEBUG_VIDEO(fmt, ...) ((void)0)
 #endif
 
+namespace
+{
+
+struct PositionAndPartIndex
+{
+  PositionAndPartIndex(Position position, int partIndex)
+  {
+    this->position  = position;
+    this->partIndex = partIndex;
+  };
+  Position position{};
+  int      partIndex;
+};
+
+std::optional<PositionAndPartIndex> findFirstDifferenceInHEVCBlock(Position      pos,
+                                                                   int           blockSize,
+                                                                   const QImage &diffImg,
+                                                                   bool          markDifference)
+{
+  const auto frameSize = diffImg.size();
+  if (pos.x >= int(frameSize.width()) || pos.y >= int(frameSize.height()))
+    return {};
+
+  if (blockSize == 4)
+  {
+    // Check for a difference
+    for (auto subX = pos.x; subX < pos.x + 4; subX++)
+    {
+      for (auto subY = pos.y; subY < pos.y + 4; subY++)
+      {
+        auto rgb = diffImg.pixel(QPoint(subX, subY));
+
+        if (markDifference)
+        {
+          // Black means no difference
+          if (qRed(rgb) != 0 || qGreen(rgb) != 0 || qBlue(rgb) != 0)
+            return PositionAndPartIndex(pos, 0);
+        }
+        else
+        {
+          // TODO: Double check if this is always true
+          // Do other values also convert to RGB(130,130,130) ?
+          // What about 10 bit input material
+          auto red   = qRed(rgb);
+          auto green = qGreen(rgb);
+          auto blue  = qBlue(rgb);
+
+          if (red != 130 || green != 130 || blue != 130)
+            return PositionAndPartIndex(pos, 0);
+        }
+      }
+    }
+  }
+  else
+  {
+    // Walk further into the hierarchy
+    const int bs                 = blockSize / 2;
+    const int nr4x4BlocksPerPart = (bs / 4) * (bs / 4);
+    if (auto diff = findFirstDifferenceInHEVCBlock(pos, bs, diffImg, markDifference))
+      return diff;
+    if (auto diff = findFirstDifferenceInHEVCBlock(
+            Position(pos.x + bs, pos.y), bs, diffImg, markDifference))
+      return PositionAndPartIndex(diff->position, diff->partIndex + nr4x4BlocksPerPart);
+    if (auto diff = findFirstDifferenceInHEVCBlock(
+            Position(pos.x, pos.y + bs), bs, diffImg, markDifference))
+      return PositionAndPartIndex(diff->position, diff->partIndex + nr4x4BlocksPerPart * 2);
+    if (auto diff = findFirstDifferenceInHEVCBlock(
+            Position(pos.x + bs, pos.y + bs), bs, diffImg, markDifference))
+      return PositionAndPartIndex(diff->position, diff->partIndex + nr4x4BlocksPerPart * 3);
+  }
+  return {};
+}
+
+inline int
+getValueFromSource(const unsigned char *src, const int idx, const int bps, const bool bigEndian)
+{
+  if (bps > 8)
+    // Read two bytes in the right order
+    return (bigEndian) ? src[idx * 2] << 8 | src[idx * 2 + 1]
+                       : src[idx * 2] | src[idx * 2 + 1] << 8;
+  else
+    // Just read one byte
+    return src[idx];
+}
+
+std::optional<PositionAndPartIndex>
+findFirstDifferenceInHEVCBlockYUV(Position                   pos,
+                                  int                        blockSize,
+                                  const QByteArray &         diffYUV,
+                                  const Size &               frameSize,
+                                  const yuv::PixelFormatYUV &diffYUVFormat)
+{
+  if (pos.x >= int(frameSize.width) || pos.y >= int(frameSize.height))
+    return {};
+
+  // The items can be of different size (we then calculate the difference of the top left aligned
+  // part)
+  const auto w_in = frameSize.width;
+  const auto h_in = frameSize.height;
+
+  // Get subsampling modes (they are identical for both inputs and the output)
+  const auto subH = diffYUVFormat.getSubsamplingHor();
+  const auto subV = diffYUVFormat.getSubsamplingVer();
+
+  const bool bigEndian = diffYUVFormat.isBigEndian();
+  const auto bps_in    = diffYUVFormat.getBitsPerSample();
+  const auto diffZero  = 128 << (bps_in - 8);
+
+  // Get pointers to the inputs
+  const auto componentSizeLuma_In   = w_in * h_in;
+  const auto componentSizeChroma_In = (w_in / subH) * (h_in / subV);
+  const auto nrBytesLumaPlane_In    = bps_in > 8 ? 2 * componentSizeLuma_In : componentSizeLuma_In;
+  const auto nrBytesChromaPlane_In =
+      bps_in > 8 ? 2 * componentSizeChroma_In : componentSizeChroma_In;
+
+  // Calculate Luma sample difference
+  const int stride_in = bps_in > 8 ? w_in * 2 : w_in; // How many bytes to the next y line?
+  const int strideC_in =
+      w_in / subH * (bps_in > 8 ? 2 : 1); // How many bytes to the next U/V y line
+
+  if (blockSize == 4)
+  {
+    auto srcY1 = (unsigned char *)diffYUV.data();
+    auto srcU1 = (diffYUVFormat.getPlaneOrder() == yuv::PlaneOrder::YUV ||
+                  diffYUVFormat.getPlaneOrder() == yuv::PlaneOrder::YUVA)
+                     ? srcY1 + nrBytesLumaPlane_In
+                     : srcY1 + nrBytesLumaPlane_In + nrBytesChromaPlane_In;
+    auto srcV1 = (diffYUVFormat.getPlaneOrder() == yuv::PlaneOrder::YUV ||
+                  diffYUVFormat.getPlaneOrder() == yuv::PlaneOrder::YUVA)
+                     ? srcY1 + nrBytesLumaPlane_In + nrBytesChromaPlane_In
+                     : srcY1 + nrBytesLumaPlane_In;
+
+    // adjust source pointer according to block position
+    srcY1 += pos.y * stride_in;
+    srcU1 += pos.y / subV * strideC_in;
+    srcV1 += pos.y / subV * strideC_in;
+
+    // Check for a difference
+    for (int subY = pos.y; subY < pos.y + 4; subY++)
+    {
+
+      for (int subX = pos.x; subX < pos.x + 4; subX++)
+      {
+
+        auto val1 = getValueFromSource(srcY1, subX, bps_in, bigEndian);
+        if (val1 != diffZero)
+          return PositionAndPartIndex(pos, 0);
+
+        // is this a position at which we have a chroma sample?
+        if (subX % subH == 0 && subY % subV == 0 && subX * subV < int(w_in))
+        {
+          auto valU1 = getValueFromSource(srcU1, subX, bps_in, bigEndian);
+          auto valV1 = getValueFromSource(srcV1, subX, bps_in, bigEndian);
+          if (valU1 != diffZero || valV1 != diffZero)
+            return PositionAndPartIndex(pos, 0);
+        }
+      }
+
+      // Goto the next y line
+      srcY1 += stride_in;
+
+      // is this a position at which we have a chroma line?
+      if (subY % subV == 0)
+      {
+        // Goto the next y line
+        srcU1 += strideC_in;
+        srcV1 += strideC_in;
+      }
+    }
+  }
+  else
+  {
+    // Walk further into the hierarchy
+    const int bs                 = blockSize / 2;
+    const int nr4x4BlocksPerPart = (bs / 4) * (bs / 4);
+    if (auto diff = findFirstDifferenceInHEVCBlockYUV(pos, bs, diffYUV, frameSize, diffYUVFormat))
+      return diff;
+    if (auto diff = findFirstDifferenceInHEVCBlockYUV(
+            Position(pos.x + bs, pos.y), bs, diffYUV, frameSize, diffYUVFormat))
+      PositionAndPartIndex(diff->position, diff->partIndex + nr4x4BlocksPerPart);
+    if (auto diff = findFirstDifferenceInHEVCBlockYUV(
+            Position(pos.x, pos.y + bs), bs, diffYUV, frameSize, diffYUVFormat))
+      PositionAndPartIndex(diff->position, diff->partIndex + nr4x4BlocksPerPart * 2);
+    if (auto diff = findFirstDifferenceInHEVCBlockYUV(
+            Position(pos.x + bs, pos.y + bs), bs, diffYUV, frameSize, diffYUVFormat))
+      PositionAndPartIndex(diff->position, diff->partIndex + nr4x4BlocksPerPart * 3);
+  }
+  return {};
+}
+
+} // namespace
+
 videoHandlerDifference::videoHandlerDifference() : videoHandler()
 {
 }
@@ -58,28 +250,28 @@ void videoHandlerDifference::drawDifferenceFrame(QPainter *painter,
                                                  double    zoomFactor,
                                                  bool      drawRawValues)
 {
-  if (!inputsValid())
+  if (!this->inputsValid())
     return;
 
   // Check if the frameIdx changed and if we have to load a new frame
-  if (frameIdx != currentImageIndex)
+  if (frameIdx != this->currentImageIndex)
   {
     // The current buffer is out of date. Update it.
 
     // Check the double buffer
-    if (frameIdx == doubleBufferImageFrameIndex)
+    if (frameIdx == this->doubleBufferImageFrameIndex)
     {
-      currentImage      = doubleBufferImage;
-      currentImageIndex = frameIdx;
+      this->currentImage      = this->doubleBufferImage;
+      this->currentImageIndex = frameIdx;
       DEBUG_VIDEO("videoHandler::drawFrame %d loaded from double buffer", frameIdx);
     }
     else
     {
-      QMutexLocker lock(&imageCacheAccess);
-      if (cacheValid && imageCache.contains(frameIdx))
+      QMutexLocker lock(&this->imageCacheAccess);
+      if (this->cacheValid && this->imageCache.contains(frameIdx))
       {
-        currentImage      = imageCache[frameIdx];
-        currentImageIndex = frameIdx;
+        this->currentImage      = this->imageCache[frameIdx];
+        this->currentImageIndex = frameIdx;
         DEBUG_VIDEO("videoHandler::drawFrame %d loaded from cache", frameIdx);
       }
     }
@@ -91,57 +283,57 @@ void videoHandlerDifference::drawDifferenceFrame(QPainter *painter,
   videoRect.moveCenter(QPoint(0, 0));
 
   // Draw the current image (currentImage)
-  currentImageSetMutex.lock();
-  painter->drawImage(videoRect, currentImage);
-  currentImageSetMutex.unlock();
+  {
+    QMutexLocker lock(&this->currentImageSetMutex);
+    painter->drawImage(videoRect, currentImage);
+  }
 
   if (drawRawValues && zoomFactor >= SPLITVIEW_DRAW_VALUES_ZOOMFACTOR)
   {
     // Draw the pixel values onto the pixels
-    inputVideo[0]->drawPixelValues(
-        painter, frameIdx, videoRect, zoomFactor, inputVideo[1], this->markDifference);
+    this->inputVideo[0]->drawPixelValues(
+        painter, frameIdx, videoRect, zoomFactor, inputVideo[1], this->markDifference, frameIdx);
   }
 }
 
 void videoHandlerDifference::loadFrameDifference(int frameIndex, bool)
 {
   // Calculate the difference between the inputVideos
-  if (!inputsValid())
+  if (!this->inputsValid())
     return;
 
-  differenceInfoList.clear();
+  this->differenceInfoList.clear();
 
   // Check if the second item is a video and the first one is not. In that case,
   // make sure that the right frame is loaded for the video item.
-  videoHandler *video0 = dynamic_cast<videoHandler *>(inputVideo[0].data());
-  videoHandler *video1 = dynamic_cast<videoHandler *>(inputVideo[1].data());
+  auto video0 = dynamic_cast<videoHandler *>(this->inputVideo[0].data());
+  auto video1 = dynamic_cast<videoHandler *>(this->inputVideo[1].data());
   if (video0 == nullptr && video1 != nullptr && video1->getCurrentImageIndex() != frameIndex)
     video1->loadFrame(frameIndex);
 
   // Calculate the difference
-  QImage newFrame = inputVideo[0]->calculateDifference(inputVideo[1],
-                                                       frameIndex,
-                                                       frameIndex,
-                                                       differenceInfoList,
-                                                       amplificationFactor,
-                                                       markDifference);
+  auto newFrame = this->inputVideo[0]->calculateDifference(this->inputVideo[1],
+                                                           frameIndex,
+                                                           frameIndex,
+                                                           this->differenceInfoList,
+                                                           this->amplificationFactor,
+                                                           this->markDifference);
 
   if (!newFrame.isNull())
   {
     // The new difference frame is ready
-    currentImageIndex = frameIndex;
-    currentImageSetMutex.lock();
-    currentImage = newFrame;
-    currentImageSetMutex.unlock();
+    this->currentImageIndex = frameIndex;
+    QMutexLocker lock(&this->currentImageSetMutex);
+    this->currentImage = newFrame;
   }
 }
 
 bool videoHandlerDifference::inputsValid() const
 {
-  if (inputVideo[0].isNull() || inputVideo[1].isNull())
+  if (this->inputVideo[0].isNull() || this->inputVideo[1].isNull())
     return false;
 
-  if (!inputVideo[0]->isFormatValid() || !inputVideo[1]->isFormatValid())
+  if (!this->inputVideo[0]->isFormatValid() || !this->inputVideo[1]->isFormatValid())
     return false;
 
   return true;
@@ -149,22 +341,22 @@ bool videoHandlerDifference::inputsValid() const
 
 void videoHandlerDifference::setInputVideos(FrameHandler *childVideo0, FrameHandler *childVideo1)
 {
-  if (inputVideo[0] != childVideo0 || inputVideo[1] != childVideo1)
+  if (this->inputVideo[0] != childVideo0 || inputVideo[1] != childVideo1)
   {
     // Something changed
-    inputVideo[0] = childVideo0;
-    inputVideo[1] = childVideo1;
+    this->inputVideo[0] = childVideo0;
+    this->inputVideo[1] = childVideo1;
 
     if (inputsValid())
     {
       // We have two valid video "children"
 
       // Get the frame size of the difference (min in x and y direction), and set it.
-      auto size0 = inputVideo[0]->getFrameSize();
-      auto size1 = inputVideo[1]->getFrameSize();
+      auto size0 = this->inputVideo[0]->getFrameSize();
+      auto size1 = this->inputVideo[1]->getFrameSize();
       auto diffSize =
           Size(std::min(size0.width, size1.width), std::min(size0.height, size1.height));
-      setFrameSize(diffSize);
+      this->setFrameSize(diffSize);
     }
 
     // If something changed, we might need a redraw
@@ -177,10 +369,10 @@ QStringPairList videoHandlerDifference::getPixelValues(const QPoint &pixelPos,
                                                        FrameHandler *,
                                                        const int frameIdx1)
 {
-  if (!inputsValid())
-    return QStringPairList();
+  if (!this->inputsValid())
+    return {};
 
-  return inputVideo[0]->getPixelValues(pixelPos, frameIdx, inputVideo[1], frameIdx1);
+  return this->inputVideo[0]->getPixelValues(pixelPos, frameIdx, this->inputVideo[1], frameIdx1);
 }
 
 void videoHandlerDifference::setFormatFromSizeAndName(
@@ -191,120 +383,122 @@ void videoHandlerDifference::setFormatFromSizeAndName(
 
 QLayout *videoHandlerDifference::createDifferenceHandlerControls()
 {
-  Q_ASSERT_X(!ui.created(), "createResampleHandlerControls", "Controls must only be created once");
+  Q_ASSERT_X(
+      !this->ui.created(), "createResampleHandlerControls", "Controls must only be created once");
 
-  ui.setupUi();
+  this->ui.setupUi();
 
   // Set all the values of the properties widget to the values of this class
-  ui.markDifferenceCheckBox->setChecked(markDifference);
-  ui.amplificationFactorSpinBox->setValue(amplificationFactor);
-  ui.codingOrderComboBox->addItems(QStringList() << "HEVC");
-  ui.codingOrderComboBox->setCurrentIndex((int)codingOrder);
+  this->ui.markDifferenceCheckBox->setChecked(markDifference);
+  this->ui.amplificationFactorSpinBox->setValue(amplificationFactor);
+  this->ui.codingOrderComboBox->addItems(QStringList() << "HEVC");
+  this->ui.codingOrderComboBox->setCurrentIndex((int)codingOrder);
 
   // Connect all the change signals from the controls to "connectWidgetSignals()"
-  connect(ui.markDifferenceCheckBox,
+  connect(this->ui.markDifferenceCheckBox,
           &QCheckBox::stateChanged,
           this,
           &videoHandlerDifference::slotDifferenceControlChanged);
-  connect(ui.codingOrderComboBox,
+  connect(this->ui.codingOrderComboBox,
           QOverload<int>::of(&QComboBox::currentIndexChanged),
           this,
           &videoHandlerDifference::slotDifferenceControlChanged);
-  connect(ui.amplificationFactorSpinBox,
+  connect(this->ui.amplificationFactorSpinBox,
           QOverload<int>::of(&QSpinBox::valueChanged),
           this,
           &videoHandlerDifference::slotDifferenceControlChanged);
 
-  return ui.topVBoxLayout;
+  return this->ui.topVBoxLayout;
 }
 
 void videoHandlerDifference::slotDifferenceControlChanged()
 {
   // The control that caused the slot to be called
-  QObject *sender = QObject::sender();
+  auto sender = QObject::sender();
 
-  if (sender == ui.markDifferenceCheckBox)
+  if (sender == this->ui.markDifferenceCheckBox)
   {
-    markDifference = ui.markDifferenceCheckBox->isChecked();
+    this->markDifference = this->ui.markDifferenceCheckBox->isChecked();
 
     // Set the current frame in the buffer to be invalid and emit the signal that something has
     // changed
-    currentImageIndex = -1;
+    this->currentImageIndex = -1;
     emit signalHandlerChanged(true, RECACHE_NONE);
   }
-  else if (sender == ui.codingOrderComboBox)
+  else if (sender == this->ui.codingOrderComboBox)
   {
-    codingOrder = (CodingOrder)ui.codingOrderComboBox->currentIndex();
+    this->codingOrder = (CodingOrder)this->ui.codingOrderComboBox->currentIndex();
 
     // The calculation of the first difference in coding order changed but no redraw is necessary
     emit signalHandlerChanged(false, RECACHE_NONE);
   }
-  else if (sender == ui.amplificationFactorSpinBox)
+  else if (sender == this->ui.amplificationFactorSpinBox)
   {
-    amplificationFactor = ui.amplificationFactorSpinBox->value();
+    this->amplificationFactor = this->ui.amplificationFactorSpinBox->value();
 
     // Set the current frame in the buffer to be invalid and emit the signal that something has
     // changed
-    currentImageIndex = -1;
+    this->currentImageIndex = -1;
     emit signalHandlerChanged(true, RECACHE_NONE);
   }
 }
 
 void videoHandlerDifference::reportFirstDifferencePosition(QList<InfoItem> &infoList) const
 {
-  if (!inputsValid())
+  if (!this->inputsValid())
     return;
 
-  if (functions::clipToUnsigned(currentImage.width()) != frameSize.width ||
-      functions::clipToUnsigned(currentImage.height()) != frameSize.height)
+  if (functions::clipToUnsigned(this->currentImage.width()) != this->frameSize.width ||
+      functions::clipToUnsigned(this->currentImage.height()) != this->frameSize.height)
     return;
 
-  if (codingOrder == CodingOrder::HEVC)
+  if (this->codingOrder == CodingOrder::HEVC)
   {
     // Assume the following:
     // - The picture is split into LCUs of 64x64 pixels which are scanned in raster scan
     // - Each LCU is scanned in a hierarchical tree until the smallest unit size (4x4 pixels) is
     // reached This is exactly what we are going to do here now
 
-    int widthLCU  = (frameSize.width + 63) / 64; // Round up
-    int heightLCU = (frameSize.height + 63) / 64;
+    int widthLCU  = (this->frameSize.width + 63) / 64; // Round up
+    int heightLCU = (this->frameSize.height + 63) / 64;
 
     for (int y = 0; y < heightLCU; y++)
     {
       for (int x = 0; x < widthLCU; x++)
       {
-        // Now take the tree approach
-        int firstX, firstY, partIndex = 0;
+        // Go into LCUs in a tree fashion
 
-        auto videoYUV0 = dynamic_cast<yuv::videoHandlerYUV *>(inputVideo[0].data());
-        if (videoYUV0 != NULL && videoYUV0->isDiffReady())
+        auto videoYUV0 = dynamic_cast<yuv::videoHandlerYUV *>(this->inputVideo[0].data());
+        if (videoYUV0 != nullptr && videoYUV0->isDiffReady())
         {
           // find first difference using YUV instead of QImage. The latter does not work for 10bit
           // videos and very small differences, since it only supports 8bit
-          if (hierarchicalPositionYUV(x * 64,
-                                      y * 64,
-                                      64,
-                                      firstX,
-                                      firstY,
-                                      partIndex,
-                                      videoYUV0->getDiffYUV(),
-                                      videoYUV0->getDiffYUVFormat()))
+          if (auto posAndIndex = findFirstDifferenceInHEVCBlockYUV(Position(x * 64, y * 64),
+                                                                   64,
+                                                                   videoYUV0->getDiffYUV(),
+                                                                   this->frameSize,
+                                                                   videoYUV0->getDiffYUVFormat()))
           {
-            // We found a difference in this block
             infoList.append(InfoItem("First diff LCU", QString::number(y * widthLCU + x)));
-            infoList.append(InfoItem("First diff X,Y", QString("%1,%2").arg(firstX).arg(firstY)));
-            infoList.append(InfoItem("First diff partIndex", QString::number(partIndex)));
+            infoList.append(InfoItem(
+                "First diff X,Y",
+                QString("%1,%2").arg(posAndIndex->position.x).arg(posAndIndex->position.y)));
+            infoList.append(
+                InfoItem("First diff partIndex", QString::number(posAndIndex->partIndex)));
             return;
           }
         }
         else
         {
-          if (hierarchicalPosition(x * 64, y * 64, 64, firstX, firstY, partIndex, currentImage))
+          if (auto posAndIndex = findFirstDifferenceInHEVCBlock(
+                  Position(x * 64, y * 64), 64, currentImage, this->markDifference))
           {
-            // We found a difference in this block
             infoList.append(InfoItem("First diff LCU", QString::number(y * widthLCU + x)));
-            infoList.append(InfoItem("First diff X,Y", QString("%1,%2").arg(firstX).arg(firstY)));
-            infoList.append(InfoItem("First diff partIndex", QString::number(partIndex)));
+            infoList.append(InfoItem(
+                "First diff X,Y",
+                QString("%1,%2").arg(posAndIndex->position.x).arg(posAndIndex->position.y)));
+            infoList.append(
+                InfoItem("First diff partIndex", QString::number(posAndIndex->partIndex)));
             return;
           }
         }
@@ -340,220 +534,15 @@ void videoHandlerDifference::loadPlaylist(const YUViewDomElement &element)
 
 ItemLoadingState videoHandlerDifference::needsLoadingRawValues(int frameIndex)
 {
-  if (auto video = dynamic_cast<videoHandler *>(inputVideo[0].data()))
+  if (auto video = dynamic_cast<videoHandler *>(this->inputVideo[0].data()))
     if (video->needsLoadingRawValues(frameIndex) == ItemLoadingState::LoadingNeeded)
       return ItemLoadingState::LoadingNeeded;
 
-  if (auto video = dynamic_cast<videoHandler *>(inputVideo[1].data()))
+  if (auto video = dynamic_cast<videoHandler *>(this->inputVideo[1].data()))
     if (video->needsLoadingRawValues(frameIndex) == ItemLoadingState::LoadingNeeded)
       return ItemLoadingState::LoadingNeeded;
 
   return ItemLoadingState::LoadingNotNeeded;
 }
 
-bool videoHandlerDifference::hierarchicalPosition(int           x,
-                                                  int           y,
-                                                  int           blockSize,
-                                                  int &         firstX,
-                                                  int &         firstY,
-                                                  int &         partIndex,
-                                                  const QImage &diffImg) const
-{
-  if (x >= int(frameSize.width) || y >= int(frameSize.height))
-    // This block is entirely outside of the picture
-    return false;
-
-  if (blockSize == 4)
-  {
-    // Check for a difference
-    for (int subX = x; subX < x + 4; subX++)
-    {
-      for (int subY = y; subY < y + 4; subY++)
-      {
-        QRgb rgb = diffImg.pixel(QPoint(subX, subY));
-
-        if (markDifference)
-        {
-          // Black means no difference
-          if (qRed(rgb) != 0 || qGreen(rgb) != 0 || qBlue(rgb) != 0)
-          {
-            // First difference found
-            firstX = x;
-            firstY = y;
-            return true;
-          }
-        }
-        else
-        {
-          // TODO: Double check if this is always true
-          // Do other values also convert to RGB(130,130,130) ?
-          // What about ten bit input material
-          int red   = qRed(rgb);
-          int green = qGreen(rgb);
-          int blue  = qBlue(rgb);
-
-          if (red != 130 || green != 130 || blue != 130)
-          {
-            // First difference found
-            firstX = x;
-            firstY = y;
-            return true;
-          }
-        }
-      }
-    }
-
-    // No difference found in this block. Count the number of 4x4 blocks scanned (that is the
-    // partIndex)
-    partIndex++;
-  }
-  else
-  {
-    // Walk further into the hierarchy
-    const int b2 = blockSize / 2;
-    if (hierarchicalPosition(x, y, b2, firstX, firstY, partIndex, diffImg))
-      return true;
-    if (hierarchicalPosition(x + b2, y, b2, firstX, firstY, partIndex, diffImg))
-      return true;
-    if (hierarchicalPosition(x, y + b2, b2, firstX, firstY, partIndex, diffImg))
-      return true;
-    if (hierarchicalPosition(x + b2, y + b2, b2, firstX, firstY, partIndex, diffImg))
-      return true;
-  }
-  return false;
-}
-
-inline int
-getValueFromSource(const unsigned char *src, const int idx, const int bps, const bool bigEndian)
-{
-  if (bps > 8)
-    // Read two bytes in the right order
-    return (bigEndian) ? src[idx * 2] << 8 | src[idx * 2 + 1]
-                       : src[idx * 2] | src[idx * 2 + 1] << 8;
-  else
-    // Just read one byte
-    return src[idx];
-}
-
-bool videoHandlerDifference::hierarchicalPositionYUV(int                        x,
-                                                     int                        y,
-                                                     int                        blockSize,
-                                                     int &                      firstX,
-                                                     int &                      firstY,
-                                                     int &                      partIndex,
-                                                     const QByteArray &         diffYUV,
-                                                     const yuv::PixelFormatYUV &diffYUVFormat) const
-{
-  if (x >= int(frameSize.width) || y >= int(frameSize.height))
-    // This block is entirely outside of the picture
-    return false;
-
-  // The items can be of different size (we then calculate the difference of the top left aligned
-  // part)
-  const int w_in = frameSize.width;
-  const int h_in = frameSize.height;
-
-  // Get subsampling modes (they are identical for both inputs and the output)
-  const int subH = diffYUVFormat.getSubsamplingHor();
-  const int subV = diffYUVFormat.getSubsamplingVer();
-
-  // Get the endianness of the inputs
-  const bool bigEndian = diffYUVFormat.isBigEndian();
-
-  // Get/Set the bit depth of the input
-  const int bps_in   = diffYUVFormat.getBitsPerSample();
-  const int diffZero = 128 << (bps_in - 8);
-
-  // Get pointers to the inputs
-  const int componentSizeLuma_In   = w_in * h_in;
-  const int componentSizeChroma_In = (w_in / subH) * (h_in / subV);
-  const int nrBytesLumaPlane_In    = bps_in > 8 ? 2 * componentSizeLuma_In : componentSizeLuma_In;
-  const int nrBytesChromaPlane_In =
-      bps_in > 8 ? 2 * componentSizeChroma_In : componentSizeChroma_In;
-  // Current item
-
-  // Calculate Luma sample difference
-  const int stride_in = bps_in > 8 ? w_in * 2 : w_in; // How many bytes to the next y line?
-  const int strideC_in =
-      w_in / subH * (bps_in > 8 ? 2 : 1); // How many bytes to the next U/V y line
-
-  if (blockSize == 4)
-  {
-    const unsigned char *srcY1 = (unsigned char *)diffYUV.data();
-    const unsigned char *srcU1 = (diffYUVFormat.getPlaneOrder() == yuv::PlaneOrder::YUV ||
-                                  diffYUVFormat.getPlaneOrder() == yuv::PlaneOrder::YUVA)
-                                     ? srcY1 + nrBytesLumaPlane_In
-                                     : srcY1 + nrBytesLumaPlane_In + nrBytesChromaPlane_In;
-    const unsigned char *srcV1 = (diffYUVFormat.getPlaneOrder() == yuv::PlaneOrder::YUV ||
-                                  diffYUVFormat.getPlaneOrder() == yuv::PlaneOrder::YUVA)
-                                     ? srcY1 + nrBytesLumaPlane_In + nrBytesChromaPlane_In
-                                     : srcY1 + nrBytesLumaPlane_In;
-
-    // adjust source pointer according to block position
-    srcY1 += y * stride_in;
-    srcU1 += y / subV * strideC_in;
-    srcV1 += y / subV * strideC_in;
-
-    // Check for a difference
-    for (int subY = y; subY < y + 4; subY++)
-    {
-
-      for (int subX = x; subX < x + 4; subX++)
-      {
-
-        int val1 = getValueFromSource(srcY1, subX, bps_in, bigEndian);
-        if (val1 != diffZero)
-        {
-          firstX = x;
-          firstY = y;
-          return true;
-        }
-
-        // is this a position at which we have a chroma sample?
-        if (subX % subH == 0 && subY % subV == 0 && subX * subV < w_in)
-        {
-          int valU1 = getValueFromSource(srcU1, subX, bps_in, bigEndian);
-          int valV1 = getValueFromSource(srcV1, subX, bps_in, bigEndian);
-          if (valU1 != diffZero || valV1 != diffZero)
-          {
-            firstX = x * subV;
-            firstY = y;
-            return true;
-          }
-        }
-      }
-
-      // Goto the next y line
-      srcY1 += stride_in;
-
-      // is this a position at which we have a chroma line?
-      if (subY % subV == 0)
-      {
-        // Goto the next y line
-        srcU1 += strideC_in;
-        srcV1 += strideC_in;
-      }
-    }
-
-    // No difference found in this block. Count the number of 4x4 blocks scanned (that is the
-    // partIndex)
-    partIndex++;
-  }
-  else
-  {
-    // Walk further into the hierarchy
-    const int b2 = blockSize / 2;
-    if (hierarchicalPositionYUV(x, y, b2, firstX, firstY, partIndex, diffYUV, diffYUVFormat))
-      return true;
-    if (hierarchicalPositionYUV(x + b2, y, b2, firstX, firstY, partIndex, diffYUV, diffYUVFormat))
-      return true;
-    if (hierarchicalPositionYUV(x, y + b2, b2, firstX, firstY, partIndex, diffYUV, diffYUVFormat))
-      return true;
-    if (hierarchicalPositionYUV(
-            x + b2, y + b2, b2, firstX, firstY, partIndex, diffYUV, diffYUVFormat))
-      return true;
-  }
-  return false;
-}
-
 } // namespace video
diff --git a/YUViewLib/src/video/videoHandlerDifference.h b/YUViewLib/src/video/videoHandlerDifference.h
index 0918e5481..346d05215 100644
--- a/YUViewLib/src/video/videoHandlerDifference.h
+++ b/YUViewLib/src/video/videoHandlerDifference.h
@@ -105,23 +105,6 @@ private slots:
   // The two videos that the difference will be calculated from
   QPointer<FrameHandler> inputVideo[2];
 
-  // Recursively scan the LCU
-  bool hierarchicalPosition(int           x,
-                            int           y,
-                            int           blockSize,
-                            int &         firstX,
-                            int &         firstY,
-                            int &         partIndex,
-                            const QImage &diffImg) const;
-  bool hierarchicalPositionYUV(int                        x,
-                               int                        y,
-                               int                        blockSize,
-                               int &                      firstX,
-                               int &                      firstY,
-                               int &                      partIndex,
-                               const QByteArray &         diffYUV,
-                               const yuv::PixelFormatYUV &diffYUVFormat) const;
-
   SafeUi<Ui::videoHandlerDifference> ui;
 };
 
diff --git a/YUViewLib/src/video/yuv/videoHandlerYUV.cpp b/YUViewLib/src/video/yuv/videoHandlerYUV.cpp
index 2f1c8c35d..ed80a2253 100644
--- a/YUViewLib/src/video/yuv/videoHandlerYUV.cpp
+++ b/YUViewLib/src/video/yuv/videoHandlerYUV.cpp
@@ -143,14 +143,14 @@ std::pair<bool, PixelFormatYUV> convertYUVPackedToPlanar(const QByteArray &    s
 
     // What are the offsets withing the 4 samples for the components?
     const int oY = (packing == PackingOrder::YUYV || packing == PackingOrder::YVYU) ? 0 : 1;
-    const int oU = (packing == PackingOrder::UYVY)   ? 0
-                   : (packing == PackingOrder::YUYV) ? 1
-                   : (packing == PackingOrder::VYUY) ? 2
-                                                     : 3;
-    const int oV = (packing == PackingOrder::VYUY)   ? 0
-                   : (packing == PackingOrder::YVYU) ? 1
-                   : (packing == PackingOrder::UYVY) ? 2
-                                                     : 3;
+    const int oU =
+        (packing == PackingOrder::UYVY)
+            ? 0
+            : (packing == PackingOrder::YUYV) ? 1 : (packing == PackingOrder::VYUY) ? 2 : 3;
+    const int oV =
+        (packing == PackingOrder::VYUY)
+            ? 0
+            : (packing == PackingOrder::YVYU) ? 1 : (packing == PackingOrder::UYVY) ? 2 : 3;
 
     if (format.getBitsPerSample() == 10 && format.isBytePacking())
     {
@@ -230,10 +230,10 @@ std::pair<bool, PixelFormatYUV> convertYUVPackedToPlanar(const QByteArray &    s
                     packing == PackingOrder::VUYA)
                        ? 1
                        : 2;
-    const int oV = (packing == PackingOrder::YVU)    ? 1
-                   : (packing == PackingOrder::AYUV) ? 3
-                   : (packing == PackingOrder::VUYA) ? 0
-                                                     : 2;
+    const int oV =
+        (packing == PackingOrder::YVU)
+            ? 1
+            : (packing == PackingOrder::AYUV) ? 3 : (packing == PackingOrder::VUYA) ? 0 : 2;
 
     // How many samples to the next sample?
     const int offsetNext = (packing == PackingOrder::YUV || packing == PackingOrder::YVU ? 3 : 4);
@@ -1086,12 +1086,12 @@ inline void UVPlaneResamplingChromaOffset(const PixelFormatYUV          format,
   // Which of these position is needed depends on the chromaOffset and the subsampling.
   const int possibleValsX = getMaxPossibleChromaOffsetValues(true, format.getSubsampling());
   const int possibleValsY = getMaxPossibleChromaOffsetValues(false, format.getSubsampling());
-  const int offsetX8      = (possibleValsX == 1)   ? format.getChromaOffset().x * 4
-                            : (possibleValsX == 3) ? format.getChromaOffset().x * 2
-                                                   : format.getChromaOffset().x;
-  const int offsetY8      = (possibleValsY == 1)   ? format.getChromaOffset().y * 4
-                            : (possibleValsY == 3) ? format.getChromaOffset().y * 2
-                                                   : format.getChromaOffset().y;
+  const int offsetX8      = (possibleValsX == 1) ? format.getChromaOffset().x * 4
+                                            : (possibleValsX == 3) ? format.getChromaOffset().x * 2
+                                                                   : format.getChromaOffset().x;
+  const int offsetY8 = (possibleValsY == 1) ? format.getChromaOffset().y * 4
+                                            : (possibleValsY == 3) ? format.getChromaOffset().y * 2
+                                                                   : format.getChromaOffset().y;
 
   // The format to use for input/output
   const bool bigEndian = format.isBigEndian();
@@ -2512,7 +2512,7 @@ void videoHandlerYUV::drawFrame(QPainter *painter,
                                 bool      drawRawData)
 {
   std::string msg;
-  if (!srcPixelFormat.canConvertToRGB(frameSize, &msg))
+  if (!this->srcPixelFormat.canConvertToRGB(frameSize, &msg))
   {
     // The conversion to RGB can not be performed. Draw a text about this
     msg = "With the given settings, the YUV data can not be converted to RGB:\n" + msg;
@@ -2520,7 +2520,7 @@ void videoHandlerYUV::drawFrame(QPainter *painter,
     QFont displayFont = painter->font();
     displayFont.setPointSizeF(painter->font().pointSizeF() * zoomFactor);
     painter->setFont(displayFont);
-    QSize textSize = painter->fontMetrics().size(0, QString::fromStdString(msg));
+    auto  textSize = painter->fontMetrics().size(0, QString::fromStdString(msg));
     QRect textRect;
     textRect.setSize(textSize);
     textRect.moveCenter(QPoint(0, 0));
@@ -2687,7 +2687,7 @@ void videoHandlerYUV::yuv420_to_argb8888(quint8 *yp,
 QLayout *videoHandlerYUV::createVideoHandlerControls(bool isSizeFixed)
 {
   // Absolutely always only call this function once!
-  assert(!ui.created());
+  assert(!this->ui.created());
 
   QVBoxLayout *newVBoxLayout = nullptr;
   if (!isSizeFixed)
@@ -2705,96 +2705,100 @@ QLayout *videoHandlerYUV::createVideoHandlerControls(bool isSizeFixed)
   }
 
   // Create the UI and setup all the controls
-  ui.setupUi();
+  this->ui.setupUi();
 
   // Add the preset YUV formats. If the current format is in the list, add it and select it.
   for (auto format : presetList)
-    ui.yuvFormatComboBox->addItem(QString::fromStdString(format.getName()));
+    this->ui.yuvFormatComboBox->addItem(QString::fromStdString(format.getName()));
 
   int idx = presetList.indexOf(srcPixelFormat);
   if (idx == -1 && srcPixelFormat.isValid())
   {
     // The currently set pixel format is not in the presets list. Add and select it.
-    ui.yuvFormatComboBox->addItem(QString::fromStdString(srcPixelFormat.getName()));
+    this->ui.yuvFormatComboBox->addItem(QString::fromStdString(srcPixelFormat.getName()));
     presetList.append(srcPixelFormat);
     idx = presetList.indexOf(srcPixelFormat);
   }
-  ui.yuvFormatComboBox->setCurrentIndex(idx);
+  this->ui.yuvFormatComboBox->setCurrentIndex(idx);
   // Add the custom... entry that allows the user to add custom formats
-  ui.yuvFormatComboBox->addItem("Custom...");
-  ui.yuvFormatComboBox->setEnabled(!isSizeFixed);
+  this->ui.yuvFormatComboBox->addItem("Custom...");
+  this->ui.yuvFormatComboBox->setEnabled(!isSizeFixed);
 
   // Set all the values of the properties widget to the values of this class
-  ui.colorComponentsComboBox->addItems(
+  this->ui.colorComponentsComboBox->addItems(
       functions::toQStringList(ComponentDisplayModeMapper.getNames()));
-  ui.colorComponentsComboBox->setCurrentIndex(
+  this->ui.colorComponentsComboBox->setCurrentIndex(
       int(ComponentDisplayModeMapper.indexOf(this->conversionSettings.componentDisplayMode)));
-  ui.chromaInterpolationComboBox->addItems(
+  this->ui.chromaInterpolationComboBox->addItems(
       functions::toQStringList(ChromaInterpolationMapper.getNames()));
-  ui.chromaInterpolationComboBox->setCurrentIndex(
+  this->ui.chromaInterpolationComboBox->setCurrentIndex(
       int(ChromaInterpolationMapper.indexOf(this->conversionSettings.chromaInterpolation)));
-  ui.chromaInterpolationComboBox->setEnabled(srcPixelFormat.isChromaSubsampled());
-  ui.colorConversionComboBox->addItems(functions::toQStringList(ColorConversionMapper.getNames()));
-  ui.colorConversionComboBox->setCurrentIndex(
+  this->ui.chromaInterpolationComboBox->setEnabled(srcPixelFormat.isChromaSubsampled());
+  this->ui.colorConversionComboBox->addItems(
+      functions::toQStringList(ColorConversionMapper.getNames()));
+  this->ui.colorConversionComboBox->setCurrentIndex(
       int(ColorConversionMapper.indexOf(this->conversionSettings.colorConversion)));
-  ui.lumaScaleSpinBox->setValue(this->conversionSettings.mathParameters[Component::Luma].scale);
-  ui.lumaOffsetSpinBox->setMaximum(1000);
-  ui.lumaOffsetSpinBox->setValue(this->conversionSettings.mathParameters[Component::Luma].offset);
-  ui.lumaInvertCheckBox->setChecked(
+  this->ui.lumaScaleSpinBox->setValue(
+      this->conversionSettings.mathParameters[Component::Luma].scale);
+  this->ui.lumaOffsetSpinBox->setMaximum(1000);
+  this->ui.lumaOffsetSpinBox->setValue(
+      this->conversionSettings.mathParameters[Component::Luma].offset);
+  this->ui.lumaInvertCheckBox->setChecked(
       this->conversionSettings.mathParameters[Component::Luma].invert);
-  ui.chromaScaleSpinBox->setValue(this->conversionSettings.mathParameters[Component::Chroma].scale);
-  ui.chromaOffsetSpinBox->setMaximum(1000);
-  ui.chromaOffsetSpinBox->setValue(
+  this->ui.chromaScaleSpinBox->setValue(
+      this->conversionSettings.mathParameters[Component::Chroma].scale);
+  this->ui.chromaOffsetSpinBox->setMaximum(1000);
+  this->ui.chromaOffsetSpinBox->setValue(
       this->conversionSettings.mathParameters[Component::Chroma].offset);
-  ui.chromaInvertCheckBox->setChecked(
+  this->ui.chromaInvertCheckBox->setChecked(
       this->conversionSettings.mathParameters[Component::Chroma].invert);
 
   // Connect all the change signals from the controls to "connectWidgetSignals()"
-  connect(ui.yuvFormatComboBox,
+  connect(this->ui.yuvFormatComboBox,
           QOverload<int>::of(&QComboBox::currentIndexChanged),
           this,
           &videoHandlerYUV::slotYUVFormatControlChanged);
-  connect(ui.colorComponentsComboBox,
+  connect(this->ui.colorComponentsComboBox,
           QOverload<int>::of(&QComboBox::currentIndexChanged),
           this,
           &videoHandlerYUV::slotYUVControlChanged);
-  connect(ui.chromaInterpolationComboBox,
+  connect(this->ui.chromaInterpolationComboBox,
           QOverload<int>::of(&QComboBox::currentIndexChanged),
           this,
           &videoHandlerYUV::slotYUVControlChanged);
-  connect(ui.colorConversionComboBox,
+  connect(this->ui.colorConversionComboBox,
           QOverload<int>::of(&QComboBox::currentIndexChanged),
           this,
           &videoHandlerYUV::slotYUVControlChanged);
-  connect(ui.lumaScaleSpinBox,
+  connect(this->ui.lumaScaleSpinBox,
           QOverload<int>::of(&QSpinBox::valueChanged),
           this,
           &videoHandlerYUV::slotYUVControlChanged);
-  connect(ui.lumaOffsetSpinBox,
+  connect(this->ui.lumaOffsetSpinBox,
           QOverload<int>::of(&QSpinBox::valueChanged),
           this,
           &videoHandlerYUV::slotYUVControlChanged);
-  connect(ui.lumaInvertCheckBox,
+  connect(this->ui.lumaInvertCheckBox,
           &QCheckBox::stateChanged,
           this,
           &videoHandlerYUV::slotYUVControlChanged);
-  connect(ui.chromaScaleSpinBox,
+  connect(this->ui.chromaScaleSpinBox,
           QOverload<int>::of(&QSpinBox::valueChanged),
           this,
           &videoHandlerYUV::slotYUVControlChanged);
-  connect(ui.chromaOffsetSpinBox,
+  connect(this->ui.chromaOffsetSpinBox,
           QOverload<int>::of(&QSpinBox::valueChanged),
           this,
           &videoHandlerYUV::slotYUVControlChanged);
-  connect(ui.chromaInvertCheckBox,
+  connect(this->ui.chromaInvertCheckBox,
           &QCheckBox::stateChanged,
           this,
           &videoHandlerYUV::slotYUVControlChanged);
 
   if (!isSizeFixed && newVBoxLayout)
-    newVBoxLayout->addLayout(ui.topVBoxLayout);
+    newVBoxLayout->addLayout(this->ui.topVBoxLayout);
 
-  return (isSizeFixed) ? ui.topVBoxLayout : newVBoxLayout;
+  return (isSizeFixed) ? this->ui.topVBoxLayout : newVBoxLayout;
 }
 
 void videoHandlerYUV::slotYUVFormatControlChanged(int idx)
@@ -2817,18 +2821,19 @@ void videoHandlerYUV::slotYUVFormatControlChanged(int idx)
       {
         // Valid pixel format with is not in the list. Add it...
         presetList.append(newFormat);
-        int                  nrItems = ui.yuvFormatComboBox->count();
-        const QSignalBlocker blocker(ui.yuvFormatComboBox);
-        ui.yuvFormatComboBox->insertItem(nrItems - 1, QString::fromStdString(newFormat.getName()));
+        int                  nrItems = this->ui.yuvFormatComboBox->count();
+        const QSignalBlocker blocker(this->ui.yuvFormatComboBox);
+        this->ui.yuvFormatComboBox->insertItem(nrItems - 1,
+                                               QString::fromStdString(newFormat.getName()));
         // Select the added format
         idx = presetList.indexOf(newFormat);
-        ui.yuvFormatComboBox->setCurrentIndex(idx);
+        this->ui.yuvFormatComboBox->setCurrentIndex(idx);
       }
       else
       {
         // The format is already in the list. Select it without invoking another signal.
-        const QSignalBlocker blocker(ui.yuvFormatComboBox);
-        ui.yuvFormatComboBox->setCurrentIndex(idx);
+        const QSignalBlocker blocker(this->ui.yuvFormatComboBox);
+        this->ui.yuvFormatComboBox->setCurrentIndex(idx);
       }
     }
     else
@@ -2836,8 +2841,8 @@ void videoHandlerYUV::slotYUVFormatControlChanged(int idx)
       // The user pressed cancel. Go back to the old format
       int idx = presetList.indexOf(srcPixelFormat);
       Q_ASSERT(idx != -1); // The previously selected format should always be in the list
-      const QSignalBlocker blocker(ui.yuvFormatComboBox);
-      ui.yuvFormatComboBox->setCurrentIndex(idx);
+      const QSignalBlocker blocker(this->ui.yuvFormatComboBox);
+      this->ui.yuvFormatComboBox->setCurrentIndex(idx);
     }
   }
   else
@@ -2865,15 +2870,16 @@ void videoHandlerYUV::setSrcPixelFormat(PixelFormatYUV format, bool emitSignal)
                                                                     << shift;
   this->conversionSettings.mathParameters[Component::Chroma].offset = 128 << shift;
 
-  if (ui.created())
+  if (this->ui.created())
   {
     // Every time the pixel format changed, see if the interpolation combo box is enabled/disabled
-    QSignalBlocker blocker1(ui.chromaInterpolationComboBox);
-    QSignalBlocker blocker2(ui.lumaOffsetSpinBox);
-    QSignalBlocker blocker3(ui.chromaOffsetSpinBox);
-    ui.chromaInterpolationComboBox->setEnabled(format.isChromaSubsampled());
-    ui.lumaOffsetSpinBox->setValue(this->conversionSettings.mathParameters[Component::Luma].offset);
-    ui.chromaOffsetSpinBox->setValue(
+    QSignalBlocker blocker1(this->ui.chromaInterpolationComboBox);
+    QSignalBlocker blocker2(this->ui.lumaOffsetSpinBox);
+    QSignalBlocker blocker3(this->ui.chromaOffsetSpinBox);
+    this->ui.chromaInterpolationComboBox->setEnabled(format.isChromaSubsampled());
+    this->ui.lumaOffsetSpinBox->setValue(
+        this->conversionSettings.mathParameters[Component::Luma].offset);
+    this->ui.chromaOffsetSpinBox->setValue(
         this->conversionSettings.mathParameters[Component::Chroma].offset);
   }
 
@@ -2899,29 +2905,32 @@ void videoHandlerYUV::slotYUVControlChanged()
   // The control that caused the slot to be called
   auto sender = QObject::sender();
 
-  if (sender == ui.colorComponentsComboBox || sender == ui.chromaInterpolationComboBox ||
-      sender == ui.colorConversionComboBox || sender == ui.lumaScaleSpinBox ||
-      sender == ui.lumaOffsetSpinBox || sender == ui.lumaInvertCheckBox ||
-      sender == ui.chromaScaleSpinBox || sender == ui.chromaOffsetSpinBox ||
-      sender == ui.chromaInvertCheckBox)
+  if (sender == this->ui.colorComponentsComboBox ||
+      sender == this->ui.chromaInterpolationComboBox ||
+      sender == this->ui.colorConversionComboBox || sender == this->ui.lumaScaleSpinBox ||
+      sender == this->ui.lumaOffsetSpinBox || sender == this->ui.lumaInvertCheckBox ||
+      sender == this->ui.chromaScaleSpinBox || sender == this->ui.chromaOffsetSpinBox ||
+      sender == this->ui.chromaInvertCheckBox)
   {
     this->conversionSettings.chromaInterpolation =
-        *ChromaInterpolationMapper.at(ui.chromaInterpolationComboBox->currentIndex());
+        *ChromaInterpolationMapper.at(this->ui.chromaInterpolationComboBox->currentIndex());
     this->conversionSettings.componentDisplayMode =
-        *ComponentDisplayModeMapper.at(ui.colorComponentsComboBox->currentIndex());
+        *ComponentDisplayModeMapper.at(this->ui.colorComponentsComboBox->currentIndex());
     this->conversionSettings.colorConversion =
-        *ColorConversionMapper.at(ui.colorConversionComboBox->currentIndex());
+        *ColorConversionMapper.at(this->ui.colorConversionComboBox->currentIndex());
 
-    this->conversionSettings.mathParameters[Component::Luma].scale  = ui.lumaScaleSpinBox->value();
-    this->conversionSettings.mathParameters[Component::Luma].offset = ui.lumaOffsetSpinBox->value();
+    this->conversionSettings.mathParameters[Component::Luma].scale =
+        this->ui.lumaScaleSpinBox->value();
+    this->conversionSettings.mathParameters[Component::Luma].offset =
+        this->ui.lumaOffsetSpinBox->value();
     this->conversionSettings.mathParameters[Component::Luma].invert =
-        ui.lumaInvertCheckBox->isChecked();
+        this->ui.lumaInvertCheckBox->isChecked();
     this->conversionSettings.mathParameters[Component::Chroma].scale =
-        ui.chromaScaleSpinBox->value();
+        this->ui.chromaScaleSpinBox->value();
     this->conversionSettings.mathParameters[Component::Chroma].offset =
-        ui.chromaOffsetSpinBox->value();
+        this->ui.chromaOffsetSpinBox->value();
     this->conversionSettings.mathParameters[Component::Chroma].invert =
-        ui.chromaInvertCheckBox->isChecked();
+        this->ui.chromaInvertCheckBox->isChecked();
 
     // Set the current frame in the buffer to be invalid and clear the cache.
     // Emit that this item needs redraw and the cache needs updating.
@@ -2930,12 +2939,12 @@ void videoHandlerYUV::slotYUVControlChanged()
     this->setCacheInvalid();
     emit signalHandlerChanged(true, RECACHE_CLEAR);
   }
-  else if (sender == ui.yuvFormatComboBox)
+  else if (sender == this->ui.yuvFormatComboBox)
   {
     auto oldFormatBytesPerFrame = this->srcPixelFormat.bytesPerFrame(frameSize);
 
     // Set the new YUV format
-    // setSrcPixelFormat(yuvFormatList.getFromName(ui.yuvFormatComboBox->currentText()));
+    // setSrcPixelFormat(yuvFormatList.getFromName(this->ui.yuvFormatComboBox->currentText()));
 
     // Set the current frame in the buffer to be invalid and clear the cache.
     // Emit that this item needs redraw and the cache needs updating.
@@ -3440,12 +3449,12 @@ void videoHandlerYUV::loadFrame(int frameIndex, bool loadToDoubleBuffer)
 {
   DEBUG_YUV("videoHandlerYUV::loadFrame " << frameIndex);
 
-  if (!isFormatValid())
+  if (!this->isFormatValid())
     // We cannot load a frame if the format is not known
     return;
 
   // Does the data in currentFrameRawData need to be updated?
-  if (!loadRawYUVData(frameIndex))
+  if (!this->loadRawYUVData(frameIndex))
     // Loading failed or it is still being performed in the background
     return;
 
@@ -3459,8 +3468,8 @@ void videoHandlerYUV::loadFrame(int frameIndex, bool loadToDoubleBuffer)
                       this->srcPixelFormat,
                       this->frameSize,
                       this->conversionSettings);
-    doubleBufferImage           = newImage;
-    doubleBufferImageFrameIndex = frameIndex;
+    this->doubleBufferImage           = newImage;
+    this->doubleBufferImageFrameIndex = frameIndex;
   }
   else if (currentImageIndex != frameIndex)
   {
@@ -3471,8 +3480,8 @@ void videoHandlerYUV::loadFrame(int frameIndex, bool loadToDoubleBuffer)
                       this->frameSize,
                       this->conversionSettings);
     QMutexLocker setLock(&currentImageSetMutex);
-    currentImage      = newImage;
-    currentImageIndex = frameIndex;
+    this->currentImage      = newImage;
+    this->currentImageIndex = frameIndex;
   }
 }
 
@@ -3506,7 +3515,7 @@ void videoHandlerYUV::loadFrameForCaching(int frameIndex, QImage &frameToCache)
 // Load the raw YUV data for the given frame index into currentFrameRawData.
 bool videoHandlerYUV::loadRawYUVData(int frameIndex)
 {
-  if (currentFrameRawData_frameIndex == frameIndex && cacheValid)
+  if (this->currentFrameRawData_frameIndex == frameIndex && this->cacheValid)
     // Buffer already up to date
     return true;
 
@@ -3514,20 +3523,18 @@ bool videoHandlerYUV::loadRawYUVData(int frameIndex)
 
   // The function loadFrameForCaching also uses the signalRequesRawYUVData to request raw data.
   // However, only one thread can use this at a time.
-  requestDataMutex.lock();
-  emit signalRequestRawData(frameIndex, false);
+  QMutexLocker lock(&this->requestDataMutex);
+  emit         signalRequestRawData(frameIndex, false);
 
   if (frameIndex != rawData_frameIndex || rawData.isEmpty())
   {
     // Loading failed
     DEBUG_YUV("videoHandlerYUV::loadRawYUVData Loading failed");
-    requestDataMutex.unlock();
     return false;
   }
 
-  currentFrameRawData            = rawData;
-  currentFrameRawData_frameIndex = frameIndex;
-  requestDataMutex.unlock();
+  this->currentFrameRawData            = rawData;
+  this->currentFrameRawData_frameIndex = frameIndex;
 
   DEBUG_YUV("videoHandlerYUV::loadRawYUVData " << frameIndex << " Done");
   return true;
@@ -3619,14 +3626,14 @@ yuv_t videoHandlerYUV::getPixelValue(const QPoint &pixelPos) const
       // The data is arranged in blocks of 4 samples. How many of these are there?
       // What are the offsets withing the 4 samples for the components?
       const int oY = (packing == PackingOrder::YUYV || packing == PackingOrder::YVYU) ? 0 : 1;
-      const int oU = (packing == PackingOrder::UYVY)   ? 0
-                     : (packing == PackingOrder::YUYV) ? 1
-                     : (packing == PackingOrder::VYUY) ? 2
-                                                       : 3;
-      const int oV = (packing == PackingOrder::VYUY)   ? 0
-                     : (packing == PackingOrder::YVYU) ? 1
-                     : (packing == PackingOrder::UYVY) ? 2
-                                                       : 3;
+      const int oU =
+          (packing == PackingOrder::UYVY)
+              ? 0
+              : (packing == PackingOrder::YUYV) ? 1 : (packing == PackingOrder::VYUY) ? 2 : 3;
+      const int oV =
+          (packing == PackingOrder::VYUY)
+              ? 0
+              : (packing == PackingOrder::YVYU) ? 1 : (packing == PackingOrder::UYVY) ? 2 : 3;
 
       if (format.isBytePacking() && format.getBitsPerSample() == 10)
       {
@@ -3673,10 +3680,10 @@ yuv_t videoHandlerYUV::getPixelValue(const QPoint &pixelPos) const
                       packing == PackingOrder::VUYA)
                          ? 1
                          : 2;
-      const int oV = (packing == PackingOrder::YVU)    ? 1
-                     : (packing == PackingOrder::AYUV) ? 3
-                     : (packing == PackingOrder::VUYA) ? 0
-                                                       : 2;
+      const int oV =
+          (packing == PackingOrder::YVU)
+              ? 1
+              : (packing == PackingOrder::AYUV) ? 3 : (packing == PackingOrder::VUYA) ? 0 : 2;
 
       // How many bytes to the next sample?
       const int offsetNext =
@@ -4110,7 +4117,7 @@ void videoHandlerYUV::setPixelFormatYUV(const PixelFormatYUV &newFormat, bool em
 
   if (newFormat != srcPixelFormat)
   {
-    if (ui.created())
+    if (this->ui.created())
     {
       // Check if the custom format is in the presets list. If not, add it.
       int idx = presetList.indexOf(newFormat);
@@ -4118,18 +4125,19 @@ void videoHandlerYUV::setPixelFormatYUV(const PixelFormatYUV &newFormat, bool em
       {
         // Valid pixel format with is not in the list. Add it...
         presetList.append(newFormat);
-        int                  nrItems = ui.yuvFormatComboBox->count();
-        const QSignalBlocker blocker(ui.yuvFormatComboBox);
-        ui.yuvFormatComboBox->insertItem(nrItems - 1, QString::fromStdString(newFormat.getName()));
+        int                  nrItems = this->ui.yuvFormatComboBox->count();
+        const QSignalBlocker blocker(this->ui.yuvFormatComboBox);
+        this->ui.yuvFormatComboBox->insertItem(nrItems - 1,
+                                               QString::fromStdString(newFormat.getName()));
         // Select the added format
         idx = presetList.indexOf(newFormat);
-        ui.yuvFormatComboBox->setCurrentIndex(idx);
+        this->ui.yuvFormatComboBox->setCurrentIndex(idx);
       }
       else
       {
         // Just select the format in the combo box
-        const QSignalBlocker blocker(ui.yuvFormatComboBox);
-        ui.yuvFormatComboBox->setCurrentIndex(idx);
+        const QSignalBlocker blocker(this->ui.yuvFormatComboBox);
+        this->ui.yuvFormatComboBox->setCurrentIndex(idx);
       }
     }
 
@@ -4143,8 +4151,8 @@ void videoHandlerYUV::setYUVColorConversion(ColorConversion conversion)
   {
     this->conversionSettings.colorConversion = conversion;
 
-    if (ui.created())
-      ui.colorConversionComboBox->setCurrentIndex(
+    if (this->ui.created())
+      this->ui.colorConversionComboBox->setCurrentIndex(
           int(ColorConversionMapper.indexOf(this->conversionSettings.colorConversion)));
   }
 }
diff --git a/YUViewLib/src/video/yuv/videoHandlerYUV.h b/YUViewLib/src/video/yuv/videoHandlerYUV.h
index 4a12ae3e9..1b1b20373 100644
--- a/YUViewLib/src/video/yuv/videoHandlerYUV.h
+++ b/YUViewLib/src/video/yuv/videoHandlerYUV.h
@@ -39,6 +39,11 @@
 
 #include <map>
 
+namespace Ui
+{
+class videoHandlerYUV;
+}
+
 namespace video::yuv
 {
 
diff --git a/YUViewUnitTest/YUViewUnitTest.pro b/YUViewUnitTest/YUViewUnitTest.pro
index c812c2af5..870180e14 100644
--- a/YUViewUnitTest/YUViewUnitTest.pro
+++ b/YUViewUnitTest/YUViewUnitTest.pro
@@ -2,6 +2,7 @@ TEMPLATE = subdirs
 
 requires(qtHaveModule(testlib))
 
-SUBDIRS = filesource \
+SUBDIRS = helper \
+          filesource \
           statistics \
           video
diff --git a/YUViewUnitTest/helper/YUVFramesProvider.cpp b/YUViewUnitTest/helper/YUVFramesProvider.cpp
new file mode 100644
index 000000000..58e26d2c0
--- /dev/null
+++ b/YUViewUnitTest/helper/YUVFramesProvider.cpp
@@ -0,0 +1,140 @@
+/*  This file is part of YUView - The YUV player with advanced analytics toolset
+ *   <https://github.com/IENT/YUView>
+ *   Copyright (C) 2015  Institut für Nachrichtentechnik, RWTH Aachen University, GERMANY
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   In addition, as a special exception, the copyright holders give
+ *   permission to link the code of portions of this program with the
+ *   OpenSSL library under certain conditions as described in each
+ *   individual source file, and distribute linked combinations including
+ *   the two.
+ *
+ *   You must obey the GNU General Public License in all respects for all
+ *   of the code used other than OpenSSL. If you modify file(s) with this
+ *   exception, you may extend this exception to your version of the
+ *   file(s), but you are not obligated to do so. If you do not wish to do
+ *   so, delete this exception statement from your version. If you delete
+ *   this exception statement from all source files in the program, then
+ *   also delete it here.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "YUVFramesProvider.h"
+
+#include <common/Error.h>
+
+namespace helper
+{
+
+namespace
+{
+
+QByteArray generatePlane(Size planeSize, int bitDepth)
+{
+  assert(bitDepth > 0 && bitDepth <= 16);
+  auto nrBytesPerSample = (bitDepth + 7) / 8;
+  auto maxValue         = (1 << bitDepth) - 1;
+
+  const auto nrSamples = planeSize.width * planeSize.height * nrBytesPerSample;
+  const auto xPlusYMax = planeSize.width + planeSize.height;
+
+  QByteArray data;
+  data.resize(nrSamples);
+
+  if (nrBytesPerSample == 1)
+  {
+    auto rawPtr = (uint8_t *)(data.data());
+    for (unsigned y = 0; y < planeSize.height; y++)
+    {
+      for (unsigned x = 0; x < planeSize.width; x++)
+      {
+        const auto val = (x + y) * maxValue / xPlusYMax;
+        rawPtr[x]      = uint8_t(val);
+      }
+      rawPtr += planeSize.width;
+    }
+  }
+  else if (nrBytesPerSample == 2)
+  {
+    auto rawPtr = (uint16_t *)(data.data());
+    for (unsigned y = 0; y < planeSize.height; y++)
+    {
+      for (unsigned x = 0; x < planeSize.width; x++)
+      {
+        const auto val = (x + y) * maxValue / xPlusYMax;
+        rawPtr[x]      = uint16_t(val);
+      }
+      rawPtr += planeSize.width;
+    }
+  }
+  else
+    assert(false);
+
+  return data;
+}
+
+} // namespace
+
+YUVFramesProvider::YUVFramesProvider(video::videoHandler *videoHandler)
+{
+  this->videoHandler = videoHandler;
+  connect(videoHandler,
+          &video::videoHandler::signalRequestFrame,
+          this,
+          &YUVFramesProvider::onSignalRequestFrame);
+  connect(videoHandler,
+          &video::videoHandler::signalRequestRawData,
+          this,
+          &YUVFramesProvider::onSignalRequestRawData);
+}
+
+void YUVFramesProvider::onSignalRequestFrame(int frameIndex, bool caching)
+{
+  // Provide a frame ...
+  int debugStop = 234;
+}
+
+void YUVFramesProvider::onSignalRequestRawData(int frameIndex, bool caching)
+{
+  // Provide raw data ...
+  int debugStop = 234;
+}
+
+QByteArray generateYUVPlane(const Size &planeSize, const video::yuv::PixelFormatYUV &pixelFormat)
+{
+  QByteArray data;
+  data += generatePlane(planeSize, pixelFormat.getBitsPerSample());
+
+  auto chromaSize = Size(planeSize.width / pixelFormat.getSubsamplingHor(),
+                         planeSize.height / pixelFormat.getSubsamplingVer());
+  for (unsigned planeIdx = 1; planeIdx < pixelFormat.getNrPlanes(); planeIdx++)
+    data += generatePlane(chromaSize, pixelFormat.getBitsPerSample());
+  return data;
+}
+
+QByteArray
+generateYUVVideo(const Size &frameSize, const video::yuv::PixelFormatYUV &pixelFormat, int nrFrames)
+{
+  if (pixelFormat.isValid())
+    return {};
+  if (!pixelFormat.isPlanar() || pixelFormat.isUVInterleaved())
+    throw NotImplemented();
+
+  QByteArray data;
+  for (int frameNr = 0; frameNr < nrFrames; frameNr++)
+    data += generateYUVPlane(frameSize, pixelFormat);
+  return data;
+}
+
+} // namespace helper
diff --git a/YUViewUnitTest/helper/YUVFramesProvider.h b/YUViewUnitTest/helper/YUVFramesProvider.h
new file mode 100644
index 000000000..387d313fb
--- /dev/null
+++ b/YUViewUnitTest/helper/YUVFramesProvider.h
@@ -0,0 +1,59 @@
+/*  This file is part of YUView - The YUV player with advanced analytics toolset
+ *   <https://github.com/IENT/YUView>
+ *   Copyright (C) 2015  Institut für Nachrichtentechnik, RWTH Aachen University, GERMANY
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   In addition, as a special exception, the copyright holders give
+ *   permission to link the code of portions of this program with the
+ *   OpenSSL library under certain conditions as described in each
+ *   individual source file, and distribute linked combinations including
+ *   the two.
+ *
+ *   You must obey the GNU General Public License in all respects for all
+ *   of the code used other than OpenSSL. If you modify file(s) with this
+ *   exception, you may extend this exception to your version of the
+ *   file(s), but you are not obligated to do so. If you do not wish to do
+ *   so, delete this exception statement from your version. If you delete
+ *   this exception statement from all source files in the program, then
+ *   also delete it here.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <video/yuv/videoHandlerYUV.h>
+
+#include <QByteArray>
+#include <QObject>
+
+namespace helper
+{
+
+class YUVFramesProvider : public QObject
+{
+  Q_OBJECT
+
+public:
+  YUVFramesProvider() = delete;
+  YUVFramesProvider(video::videoHandler *videoHandler);
+
+public slots:
+  void onSignalRequestFrame(int frameIndex, bool caching);
+  void onSignalRequestRawData(int frameIndex, bool caching);
+
+private:
+  video::videoHandler *videoHandler{};
+};
+
+} // namespace helper
diff --git a/YUViewUnitTest/helper/helper.pro b/YUViewUnitTest/helper/helper.pro
new file mode 100644
index 000000000..e36b457b4
--- /dev/null
+++ b/YUViewUnitTest/helper/helper.pro
@@ -0,0 +1,17 @@
+QT += core gui widgets opengl xml concurrent network
+
+TEMPLATE = lib
+CONFIG += staticlib
+CONFIG += c++1z
+CONFIG -= debug_and_release
+CONFIG += object_parallel_to_source
+
+INCLUDEPATH += $$top_srcdir/YUViewLib/src
+
+# For the generated ui_ files
+INCLUDEPATH += $$top_builddir/YUViewLib/
+
+TARGET = YUViewUnitTestHelperLib
+
+SOURCES += $$files(*.cpp, true)
+HEADERS += $$files(*.h, true)
diff --git a/YUViewUnitTest/video/videoHandler/videoHandler.pro b/YUViewUnitTest/video/videoHandler/videoHandler.pro
new file mode 100644
index 000000000..dc3aacc2b
--- /dev/null
+++ b/YUViewUnitTest/video/videoHandler/videoHandler.pro
@@ -0,0 +1,6 @@
+TEMPLATE = subdirs
+
+requires(qtHaveModule(testlib))
+
+SUBDIRS = videoHandlerDifference \
+          videoHandlerYUV
diff --git a/YUViewUnitTest/video/videoHandler/videoHandlerDifference/VideoHandlerDifferenceTest.cpp b/YUViewUnitTest/video/videoHandler/videoHandlerDifference/VideoHandlerDifferenceTest.cpp
new file mode 100644
index 000000000..cf2a3ed83
--- /dev/null
+++ b/YUViewUnitTest/video/videoHandler/videoHandlerDifference/VideoHandlerDifferenceTest.cpp
@@ -0,0 +1,29 @@
+#include <QtTest>
+
+#include <helper2/YUVFramesProvider.h>
+
+using namespace video::yuv;
+
+class VideoHandlerDifferenceTest : public QObject
+{
+  Q_OBJECT
+
+public:
+  VideoHandlerDifferenceTest(){};
+  ~VideoHandlerDifferenceTest(){};
+
+private slots:
+  void testDifferenceDrawing();
+};
+
+void VideoHandlerDifferenceTest::testDifferenceDrawing()
+{
+  auto frameSize = Size(16, 16);
+  auto pixelFormat =
+      video::yuv::PixelFormatYUV(video::yuv::Subsampling::YUV_420, 8, video::yuv::PlaneOrder::YUV);
+  auto rawVideoBytes = helper::generateYUVVideo(frameSize, pixelFormat, 3);
+}
+
+QTEST_MAIN(VideoHandlerDifferenceTest)
+
+#include "VideoHandlerDifferenceTest.moc"
diff --git a/YUViewUnitTest/video/videoHandler/videoHandlerDifference/VideoHandlerDifferenceTest.pro b/YUViewUnitTest/video/videoHandler/videoHandlerDifference/VideoHandlerDifferenceTest.pro
new file mode 100644
index 000000000..94593cb9e
--- /dev/null
+++ b/YUViewUnitTest/video/videoHandler/videoHandlerDifference/VideoHandlerDifferenceTest.pro
@@ -0,0 +1,17 @@
+TEMPLATE = app
+
+CONFIG += qt console warn_on no_testcase_installs depend_includepath testcase
+CONFIG += c++1z
+CONFIG -= debug_and_release
+CONFIG -= app_bundled
+
+TARGET = VideoHandlerDifferenceTest
+
+QT += testlib
+QT += gui widgets xml
+
+INCLUDEPATH += $$top_srcdir/YUViewLib/src \
+               $$top_srcdir/YUViewUnitTest
+LIBS += -L$$top_builddir/YUViewLib -lYUViewLib -L$$top_builddir/YUViewUnitTest/helper -lhelperLib
+
+SOURCES += VideoHandlerDifferenceTest.cpp
diff --git a/YUViewUnitTest/video/videoHandler/videoHandlerYUV/VideoHandlerYUVTest.cpp b/YUViewUnitTest/video/videoHandler/videoHandlerYUV/VideoHandlerYUVTest.cpp
new file mode 100644
index 000000000..799deef39
--- /dev/null
+++ b/YUViewUnitTest/video/videoHandler/videoHandlerYUV/VideoHandlerYUVTest.cpp
@@ -0,0 +1,37 @@
+#include <QtTest>
+
+#include <video/videoHandlerYUV.h>
+
+using namespace video::yuv;
+
+class VideoHandlerYUVTest : public QObject
+{
+  Q_OBJECT
+
+public:
+  VideoHandlerYUVTest(){};
+  ~VideoHandlerYUVTest(){};
+
+private slots:
+  void testBasicDrawing();
+};
+
+void VideoHandlerYUVTest::testBasicDrawing()
+{
+  auto frameSize = Size(128, 128);
+  auto pixelFormat =
+      video::yuv::PixelFormatYUV(video::yuv::Subsampling::YUV_420, 8, video::yuv::PlaneOrder::YUV);
+  // auto rawYUVData = helper::generateYUVPlane(frameSize, pixelFormat);
+
+  // video::yuv::videoHandlerYUV video;
+  // video.setFrameSize(frameSize);
+  // video.setPixelFormatYUV(pixelFormat);
+
+  // helper::YUVFramesProvider yuvFramesProvider(&video);
+
+  // video.loadFrame(0);
+}
+
+QTEST_MAIN(VideoHandlerYUVTest)
+
+#include "VideoHandlerYUVTest.moc"
diff --git a/YUViewUnitTest/video/videoHandler/videoHandlerYUV/VideoHandlerYUVTest.pro b/YUViewUnitTest/video/videoHandler/videoHandlerYUV/VideoHandlerYUVTest.pro
new file mode 100644
index 000000000..7c6ee80c9
--- /dev/null
+++ b/YUViewUnitTest/video/videoHandler/videoHandlerYUV/VideoHandlerYUVTest.pro
@@ -0,0 +1,17 @@
+TEMPLATE = app
+
+CONFIG += qt console warn_on no_testcase_installs depend_includepath testcase
+CONFIG += c++1z
+CONFIG -= debug_and_release
+CONFIG -= app_bundled
+
+TARGET = VideoHandlerYUVTest
+
+QT += testlib
+QT += gui widgets xml
+
+INCLUDEPATH += $$top_srcdir/YUViewLib/src \
+               $$top_srcdir/YUViewUnitTest
+LIBS += -L$$top_builddir/YUViewLib -lYUViewLib -L$$top_builddir/YUViewUnitTest/helper -lYUViewUnitTestHelperLib
+
+SOURCES += VideoHandlerYUVTest.cpp