diff --git a/YUViewLib/src/common/Functions.cpp b/YUViewLib/src/common/Functions.cpp
index 07a7b7b0f..ce6d6ebdf 100644
--- a/YUViewLib/src/common/Functions.cpp
+++ b/YUViewLib/src/common/Functions.cpp
@@ -168,6 +168,16 @@ std::string toLower(std::string str)
   return str;
 }
 
+ByteVector readData(std::istream &istream, const size_t nrBytes)
+{
+  ByteVector data;
+  data.resize(nrBytes);
+  istream.read(reinterpret_cast<char *>(data.data()), nrBytes);
+  const auto nrBytesActuallyRead = istream.gcount();
+  data.resize(nrBytesActuallyRead);
+  return data;
+}
+
 std::optional<unsigned long> toUnsigned(const std::string &text)
 {
   try
diff --git a/YUViewLib/src/common/Functions.h b/YUViewLib/src/common/Functions.h
index 667c7fe41..a06553ea6 100644
--- a/YUViewLib/src/common/Functions.h
+++ b/YUViewLib/src/common/Functions.h
@@ -34,6 +34,7 @@
 
 #include <common/Typedef.h>
 
+#include <istream>
 #include <optional>
 
 namespace functions
@@ -64,6 +65,7 @@ QString formatDataSize(double size, bool isBits = false);
 
 QStringList toQStringList(const std::vector<std::string> &stringVec);
 std::string toLower(std::string str);
+ByteVector  readData(std::istream &istream, const size_t nrBytes);
 
 inline std::string boolToString(bool b)
 {
diff --git a/YUViewLib/src/ffmpeg/AVInputFormatWrapper.cpp b/YUViewLib/src/ffmpeg/AVInputFormatWrapper.cpp
index 7362e3372..0193e9145 100644
--- a/YUViewLib/src/ffmpeg/AVInputFormatWrapper.cpp
+++ b/YUViewLib/src/ffmpeg/AVInputFormatWrapper.cpp
@@ -65,6 +65,31 @@ AVInputFormatWrapper::AVInputFormatWrapper(AVInputFormat *f, LibraryVersion v)
   this->update();
 }
 
+QString AVInputFormatWrapper::getName() const
+{
+  return this->name;
+}
+
+QString AVInputFormatWrapper::getLongName() const
+{
+  return this->long_name;
+}
+
+int AVInputFormatWrapper::getFlags() const
+{
+  return this->flags;
+}
+
+QString AVInputFormatWrapper::getExtensions() const
+{
+  return this->extensions;
+}
+
+QString AVInputFormatWrapper::getMimeType() const
+{
+  return this->mime_type;
+}
+
 void AVInputFormatWrapper::update()
 {
   if (this->fmt == nullptr)
diff --git a/YUViewLib/src/ffmpeg/AVInputFormatWrapper.h b/YUViewLib/src/ffmpeg/AVInputFormatWrapper.h
index ec1ebdf2c..c9fdda8d6 100644
--- a/YUViewLib/src/ffmpeg/AVInputFormatWrapper.h
+++ b/YUViewLib/src/ffmpeg/AVInputFormatWrapper.h
@@ -43,6 +43,12 @@ class AVInputFormatWrapper
   AVInputFormatWrapper();
   AVInputFormatWrapper(AVInputFormat *f, LibraryVersion v);
 
+  QString getName() const;
+  QString getLongName() const;
+  int     getFlags() const;
+  QString getExtensions() const;
+  QString getMimeType() const;
+
   explicit operator bool() const { return fmt != nullptr; };
 
 private:
diff --git a/YUViewLib/src/filesource/FileSourceFFmpegFile.cpp b/YUViewLib/src/filesource/FileSourceFFmpegFile.cpp
index 4e34b631b..6776e8d92 100644
--- a/YUViewLib/src/filesource/FileSourceFFmpegFile.cpp
+++ b/YUViewLib/src/filesource/FileSourceFFmpegFile.cpp
@@ -34,6 +34,7 @@
 
 #include <QProgressDialog>
 #include <QSettings>
+#include <fstream>
 
 #include <common/Formatting.h>
 #include <ffmpeg/AVCodecContextWrapper.h>
@@ -56,8 +57,18 @@ namespace
 
 auto startCode = QByteArrayLiteral("\x00\x00\x01");
 
+uint64_t getBoxSize(ByteVector::const_iterator iterator)
+{
+  uint64_t size = 0;
+  size += static_cast<uint64_t>(*(iterator++)) << (8 * 3);
+  size += static_cast<uint64_t>(*(iterator++)) << (8 * 2);
+  size += static_cast<uint64_t>(*(iterator++)) << (8 * 1);
+  size += static_cast<uint64_t>(*iterator);
+  return size;
 }
 
+} // namespace
+
 FileSourceFFmpegFile::FileSourceFFmpegFile()
 {
   connect(&this->fileWatcher,
@@ -217,6 +228,55 @@ StringPairVec FileSourceFFmpegFile::getMetadata()
   return ff.getDictionaryEntries(this->formatCtx.getMetadata(), "", 0);
 }
 
+ByteVector FileSourceFFmpegFile::getLhvCData()
+{
+  const auto inputFormat = this->formatCtx.getInputFormat();
+  const auto isMp4       = inputFormat.getName().contains("mp4");
+  if (!this->getVideoStreamCodecID().isHEVC() || !isMp4)
+    return {};
+
+  // This is a bit of a hack. The problem is that FFmpeg can currently not extract this for us.
+  // Maybe this will be added in the future. So the only option we have here is to manually extract
+  // the lhvC data from the mp4 file. In mp4, the boxes can be at the beginning or at the end of the
+  // file.
+  enum class SearchPosition
+  {
+    Beginning,
+    End
+  };
+
+  std::ifstream inputFile(this->fileName.toStdString(), std::ios::binary);
+  for (const auto searchPosition : {SearchPosition::Beginning, SearchPosition::End})
+  {
+    constexpr auto NR_SEARCH_BYTES = 5120;
+
+    if (searchPosition == SearchPosition::End)
+      inputFile.seekg(-NR_SEARCH_BYTES, std::ios_base::end);
+
+    const auto rawFileData = functions::readData(inputFile, NR_SEARCH_BYTES);
+    if (rawFileData.empty())
+      continue;
+
+    const std::string searchString = "lhvC";
+    auto              lhvcPos      = std::search(
+        rawFileData.begin(), rawFileData.end(), searchString.begin(), searchString.end());
+    if (lhvcPos == rawFileData.end())
+      continue;
+
+    if (std::distance(rawFileData.begin(), lhvcPos) < 4)
+      continue;
+
+    const auto boxSize = getBoxSize(lhvcPos - 4);
+    if (boxSize == 0 || boxSize > std::distance(lhvcPos, rawFileData.end()))
+      continue;
+
+    // We just return the payload without the box size or the "lhvC" tag
+    return ByteVector(lhvcPos + 4, lhvcPos + boxSize - 4);
+  }
+
+  return {};
+}
+
 QList<QByteArray> FileSourceFFmpegFile::getParameterSets()
 {
   if (!this->isFileOpened)
@@ -484,6 +544,7 @@ void FileSourceFFmpegFile::openFileAndFindVideoStream(QString fileName)
   if (!this->ff.openInput(this->formatCtx, fileName))
     return;
 
+  this->fileName = fileName;
   this->formatCtx.getInputFormat();
 
   for (unsigned idx = 0; idx < this->formatCtx.getNbStreams(); idx++)
diff --git a/YUViewLib/src/filesource/FileSourceFFmpegFile.h b/YUViewLib/src/filesource/FileSourceFFmpegFile.h
index 0505def37..acc51d4cd 100644
--- a/YUViewLib/src/filesource/FileSourceFFmpegFile.h
+++ b/YUViewLib/src/filesource/FileSourceFFmpegFile.h
@@ -35,6 +35,7 @@
 #include "FileSource.h"
 #include <ffmpeg/AVCodecIDWrapper.h>
 #include <ffmpeg/AVCodecParametersWrapper.h>
+#include <ffmpeg/AVInputFormatWrapper.h>
 #include <ffmpeg/AVPacketWrapper.h>
 #include <ffmpeg/FFmpegVersionHandler.h>
 #include <video/rgb/videoHandlerRGB.h>
@@ -85,6 +86,7 @@ class FileSourceFFmpegFile : public QObject
 
   QByteArray    getExtradata();
   StringPairVec getMetadata();
+  ByteVector    getLhvCData();
   // Return a list containing the raw data of all parameter set NAL units
   QList<QByteArray> getParameterSets();
 
@@ -135,6 +137,8 @@ private slots:
   FFmpeg::AVPacketWrapper        currentPacket;    //< A place for the curren (frame) input buffer
   bool                           endOfFile{false}; //< Are we at the end of file (draining mode)?
 
+  QString fileName;
+
   // Seek the stream to the given pts value, flush the decoder and load the first packet so
   // that we are ready to start decoding from this pts.
   int64_t                 duration{-1}; //< duration / AV_TIME_BASE is the duration in seconds
diff --git a/YUViewLib/src/parser/AVFormat/HVCC.cpp b/YUViewLib/src/parser/AVFormat/DecoderConfigurationHvcC.cpp
similarity index 67%
rename from YUViewLib/src/parser/AVFormat/HVCC.cpp
rename to YUViewLib/src/parser/AVFormat/DecoderConfigurationHvcC.cpp
index 555464932..c0678ca43 100644
--- a/YUViewLib/src/parser/AVFormat/HVCC.cpp
+++ b/YUViewLib/src/parser/AVFormat/DecoderConfigurationHvcC.cpp
@@ -30,57 +30,17 @@
  *   along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "HVCC.h"
+#include "DecoderConfigurationHvcC.h"
 
 namespace parser::avformat
 {
 
 using namespace reader;
 
-void HVCCNalUnit::parse(unsigned              unitID,
-                        SubByteReaderLogging &reader,
-                        ParserAnnexBHEVC *    hevcParser,
-                        BitratePlotModel *    bitrateModel)
-{
-  SubByteReaderLoggingSubLevel subLevel(reader, "nal unit " + std::to_string(unitID));
-
-  this->nalUnitLength = reader.readBits("nalUnitLength", 16);
-
-  // Get the bytes of the raw nal unit to pass to the "real" hevc parser
-  auto nalData = reader.readBytes("", nalUnitLength, Options().withLoggingDisabled());
-
-  // Let the hevc annexB parser parse this
-  auto parseResult =
-      hevcParser->parseAndAddNALUnit(unitID, nalData, {}, {}, reader.getCurrentItemTree());
-  if (parseResult.success && bitrateModel != nullptr && parseResult.bitrateEntry)
-    bitrateModel->addBitratePoint(0, *parseResult.bitrateEntry);
-}
-
-void HVCCNalArray::parse(unsigned              arrayID,
-                         SubByteReaderLogging &reader,
-                         ParserAnnexBHEVC *    hevcParser,
-                         BitratePlotModel *    bitrateModel)
-{
-  SubByteReaderLoggingSubLevel subLevel(reader, "nal unit array " + std::to_string(arrayID));
-
-  // The next 3 bytes contain info about the array
-  this->array_completeness = reader.readFlag("array_completeness");
-  reader.readFlag("reserved_flag_false", Options().withCheckEqualTo(0, CheckLevel::Warning));
-  this->nal_unit_type = reader.readBits("nal_unit_type", 6);
-  this->numNalus      = reader.readBits("numNalus", 16);
-
-  for (unsigned i = 0; i < numNalus; i++)
-  {
-    HVCCNalUnit nal;
-    nal.parse(i, reader, hevcParser, bitrateModel);
-    nalList.push_back(nal);
-  }
-}
-
-void HVCC::parse(ByteVector &              data,
-                 std::shared_ptr<TreeItem> root,
-                 ParserAnnexBHEVC *        hevcParser,
-                 BitratePlotModel *        bitrateModel)
+void DecoderConfigurationHvcC::parse(const ByteVector &        data,
+                                     std::shared_ptr<TreeItem> root,
+                                     ParserAnnexBHEVC *        hevcParser,
+                                     BitratePlotModel *        bitrateModel)
 {
   SubByteReaderLogging reader(data, root, "Extradata (HEVC hvcC format)");
   reader.disableEmulationPrevention();
@@ -123,10 +83,10 @@ void HVCC::parse(ByteVector &              data,
   // Now parse the contained raw NAL unit arrays
   for (unsigned i = 0; i < this->numOfArrays; i++)
   {
-    HVCCNalArray a;
-    a.parse(i, reader, hevcParser, bitrateModel);
-    this->naluArrays.push_back(a);
+    DecoderConfigurationNALArray array;
+    array.parse(i, reader, hevcParser, bitrateModel);
+    this->naluArrays.push_back(array);
   }
 }
 
-} // namespace parser::avformat
\ No newline at end of file
+} // namespace parser::avformat
diff --git a/YUViewLib/src/parser/AVFormat/HVCC.h b/YUViewLib/src/parser/AVFormat/DecoderConfigurationHvcC.h
similarity index 73%
rename from YUViewLib/src/parser/AVFormat/HVCC.h
rename to YUViewLib/src/parser/AVFormat/DecoderConfigurationHvcC.h
index 81e51f2fb..67f64b203 100644
--- a/YUViewLib/src/parser/AVFormat/HVCC.h
+++ b/YUViewLib/src/parser/AVFormat/DecoderConfigurationHvcC.h
@@ -32,50 +32,21 @@
 
 #pragma once
 
-#include <common/Typedef.h>
 #include <parser/HEVC/ParserAnnexBHEVC.h>
 #include <parser/common/BitratePlotModel.h>
-#include <parser/common/SubByteReaderLogging.h>
 #include <parser/common/TreeItem.h>
 
-namespace parser::avformat
-{
+#include "DecoderConfigurationNalArray.h"
 
-class HVCCNalUnit
-{
-public:
-  HVCCNalUnit() = default;
-
-  void parse(unsigned                      unitID,
-             reader::SubByteReaderLogging &reader,
-             ParserAnnexBHEVC *            hevcParser,
-             BitratePlotModel *            bitrateModel);
-
-  unsigned nalUnitLength{};
-};
-
-class HVCCNalArray
+namespace parser::avformat
 {
-public:
-  HVCCNalArray() = default;
-
-  void parse(unsigned                      arrayID,
-             reader::SubByteReaderLogging &reader,
-             ParserAnnexBHEVC *            hevcParser,
-             BitratePlotModel *            bitrateModel);
-
-  bool                array_completeness{};
-  unsigned            nal_unit_type{};
-  unsigned            numNalus{};
-  vector<HVCCNalUnit> nalList;
-};
 
-class HVCC
+class DecoderConfigurationHvcC
 {
 public:
-  HVCC() = default;
+  DecoderConfigurationHvcC() = default;
 
-  void parse(ByteVector &              data,
+  void parse(const ByteVector &        data,
              std::shared_ptr<TreeItem> root,
              ParserAnnexBHEVC *        hevcParser,
              BitratePlotModel *        bitrateModel);
@@ -99,7 +70,7 @@ class HVCC
   unsigned lengthSizeMinusOne{};
   unsigned numOfArrays{};
 
-  vector<HVCCNalArray> naluArrays;
+  std::vector<DecoderConfigurationNALArray> naluArrays;
 };
 
-} // namespace parser::avformat
\ No newline at end of file
+} // namespace parser::avformat
diff --git a/YUViewLib/src/parser/AVFormat/DecoderConfigurationLhvC.cpp b/YUViewLib/src/parser/AVFormat/DecoderConfigurationLhvC.cpp
new file mode 100644
index 000000000..0e7c904a7
--- /dev/null
+++ b/YUViewLib/src/parser/AVFormat/DecoderConfigurationLhvC.cpp
@@ -0,0 +1,76 @@
+/*  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 "DecoderConfigurationLhvC.h"
+
+namespace parser::avformat
+{
+
+using namespace reader;
+
+void DecoderConfigurationLhvC::parse(const ByteVector &        data,
+                                     std::shared_ptr<TreeItem> root,
+                                     ParserAnnexBHEVC *        hevcParser,
+                                     BitratePlotModel *        bitrateModel)
+{
+  SubByteReaderLogging reader(data, root, "Extradata (HEVC lhvC format)");
+  reader.disableEmulationPrevention();
+
+  // ISO/IEC 14496-15, 9.6.3
+  this->configurationVersion =
+      reader.readBits("configurationVersion", 8, Options().withCheckEqualTo(1));
+  reader.readBits("reserved_4onebits", 4, Options().withCheckEqualTo(15));
+  this->min_spatial_segmentation_idc = reader.readBits("min_spatial_segmentation_idc", 12);
+  reader.readBits("reserver_6onebits", 6, Options().withCheckEqualTo(63));
+  this->parallelismType =
+      reader.readBits("parallelismType",
+                      2,
+                      Options().withMeaningVector({"mixed-type parallel decoding",
+                                                   "slice-based parallel decoding",
+                                                   "tile-based parallel decoding",
+                                                   "wavefront-based parallel decoding"}));
+  reader.readBits("reserver_2onebits", 2, Options().withCheckEqualTo(3));
+  this->numTemporalLayers  = reader.readBits("numTemporalLayers", 3);
+  this->temporalIdNested   = reader.readFlag("temporalIdNested");
+  this->lengthSizeMinusOne = reader.readBits("lengthSizeMinusOne", 2);
+  this->numOfArrays        = reader.readBits("numOfArrays", 8);
+
+  // Now parse the contained raw NAL unit arrays
+  for (unsigned i = 0; i < this->numOfArrays; i++)
+  {
+    DecoderConfigurationNALArray array;
+    array.parse(i, reader, hevcParser, bitrateModel);
+    this->naluArrays.push_back(array);
+  }
+}
+
+} // namespace parser::avformat
diff --git a/YUViewLib/src/parser/AVFormat/DecoderConfigurationLhvC.h b/YUViewLib/src/parser/AVFormat/DecoderConfigurationLhvC.h
new file mode 100644
index 000000000..4b604118c
--- /dev/null
+++ b/YUViewLib/src/parser/AVFormat/DecoderConfigurationLhvC.h
@@ -0,0 +1,66 @@
+/*  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 <parser/HEVC/ParserAnnexBHEVC.h>
+#include <parser/common/BitratePlotModel.h>
+#include <parser/common/SubByteReaderLogging.h>
+#include <parser/common/TreeItem.h>
+
+#include "DecoderConfigurationNalArray.h"
+
+namespace parser::avformat
+{
+
+class DecoderConfigurationLhvC
+{
+public:
+  DecoderConfigurationLhvC() = default;
+
+  void parse(const ByteVector &        data,
+             std::shared_ptr<TreeItem> root,
+             ParserAnnexBHEVC *        hevcParser,
+             BitratePlotModel *        bitrateModel);
+
+  unsigned configurationVersion{};
+  unsigned min_spatial_segmentation_idc{};
+  unsigned parallelismType{};
+  unsigned numTemporalLayers{};
+  bool     temporalIdNested{};
+  unsigned lengthSizeMinusOne{};
+  unsigned numOfArrays{};
+
+  std::vector<DecoderConfigurationNALArray> naluArrays;
+};
+
+} // namespace parser::avformat
diff --git a/YUViewLib/src/parser/AVFormat/DecoderConfigurationNalArray.cpp b/YUViewLib/src/parser/AVFormat/DecoderConfigurationNalArray.cpp
new file mode 100644
index 000000000..2a19cdab7
--- /dev/null
+++ b/YUViewLib/src/parser/AVFormat/DecoderConfigurationNalArray.cpp
@@ -0,0 +1,80 @@
+/*  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 "DecoderConfigurationNalArray.h"
+
+namespace parser::avformat
+{
+
+using namespace reader;
+
+void DecoderConfigurationNALUnit::parse(const unsigned        unitID,
+                                        SubByteReaderLogging &reader,
+                                        ParserAnnexBHEVC *    hevcParser,
+                                        BitratePlotModel *    bitrateModel)
+{
+  SubByteReaderLoggingSubLevel subLevel(reader, "nal unit " + std::to_string(unitID));
+
+  this->nalUnitLength = reader.readBits("nalUnitLength", 16);
+
+  // Get the bytes of the raw nal unit to pass to the "real" hevc parser
+  auto nalData = reader.readBytes("", nalUnitLength, Options().withLoggingDisabled());
+
+  // Let the hevc annexB parser parse this
+  auto parseResult =
+      hevcParser->parseAndAddNALUnit(unitID, nalData, {}, {}, reader.getCurrentItemTree());
+  if (parseResult.success && bitrateModel != nullptr && parseResult.bitrateEntry)
+    bitrateModel->addBitratePoint(0, *parseResult.bitrateEntry);
+}
+
+void DecoderConfigurationNALArray::parse(const unsigned        arrayID,
+                                         SubByteReaderLogging &reader,
+                                         ParserAnnexBHEVC *    hevcParser,
+                                         BitratePlotModel *    bitrateModel)
+{
+  SubByteReaderLoggingSubLevel subLevel(reader, "nal unit array " + std::to_string(arrayID));
+
+  // The next 3 bytes contain info about the array
+  this->array_completeness = reader.readFlag("array_completeness");
+  reader.readFlag("reserved_flag_false", Options().withCheckEqualTo(0, CheckLevel::Warning));
+  this->nal_unit_type = reader.readBits("nal_unit_type", 6);
+  this->numNalus      = reader.readBits("numNalus", 16);
+
+  for (unsigned i = 0; i < numNalus; i++)
+  {
+    DecoderConfigurationNALUnit nal;
+    nal.parse(i, reader, hevcParser, bitrateModel);
+    nalList.push_back(nal);
+  }
+}
+
+} // namespace parser::avformat
diff --git a/YUViewLib/src/parser/AVFormat/DecoderConfigurationNalArray.h b/YUViewLib/src/parser/AVFormat/DecoderConfigurationNalArray.h
new file mode 100644
index 000000000..2deadbcac
--- /dev/null
+++ b/YUViewLib/src/parser/AVFormat/DecoderConfigurationNalArray.h
@@ -0,0 +1,71 @@
+/*  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 <parser/HEVC/ParserAnnexBHEVC.h>
+#include <parser/common/BitratePlotModel.h>
+#include <parser/common/SubByteReaderLogging.h>
+
+namespace parser::avformat
+{
+
+class DecoderConfigurationNALUnit
+{
+public:
+  DecoderConfigurationNALUnit() = default;
+
+  void parse(const unsigned                unitID,
+             reader::SubByteReaderLogging &reader,
+             ParserAnnexBHEVC *            hevcParser,
+             BitratePlotModel *            bitrateModel);
+
+  unsigned nalUnitLength{};
+};
+
+class DecoderConfigurationNALArray
+{
+public:
+  DecoderConfigurationNALArray() = default;
+
+  void parse(const unsigned                arrayID,
+             reader::SubByteReaderLogging &reader,
+             ParserAnnexBHEVC *            hevcParser,
+             BitratePlotModel *            bitrateModel);
+
+  bool                                     array_completeness{};
+  unsigned                                 nal_unit_type{};
+  unsigned                                 numNalus{};
+  std::vector<DecoderConfigurationNALUnit> nalList;
+};
+
+} // namespace parser::avformat
diff --git a/YUViewLib/src/parser/AVFormat/ParserAVFormat.cpp b/YUViewLib/src/parser/AVFormat/ParserAVFormat.cpp
index ae28d99b4..dfcc0d9d7 100644
--- a/YUViewLib/src/parser/AVFormat/ParserAVFormat.cpp
+++ b/YUViewLib/src/parser/AVFormat/ParserAVFormat.cpp
@@ -41,7 +41,8 @@
 #include "../Mpeg2/ParserAnnexBMpeg2.h"
 #include "../Subtitles/Subtitle608.h"
 #include "../Subtitles/SubtitleDVB.h"
-#include "HVCC.h"
+#include "DecoderConfigurationHvcC.h"
+#include "DecoderConfigurationLhvC.h"
 #include "parser/common/SubByteReaderLogging.h"
 #include <parser/common/Functions.h>
 
@@ -104,13 +105,13 @@ bool ParserAVFormat::parseExtradata(ByteVector &extradata)
     return true;
 
   if (this->codecID.isAVC())
-    return this->parseExtradata_AVC(extradata);
+    return this->parseExtradataAVC(extradata);
   else if (this->codecID.isHEVC())
-    return this->parseExtradata_hevc(extradata);
+    return this->parseExtradataHEVC(extradata, HEVCExtradataType::hvcC);
   else if (this->codecID.isMpeg2())
-    return this->parseExtradata_mpeg2(extradata);
+    return this->parseExtradataMPEG2(extradata);
   else
-    return this->parseExtradata_generic(extradata);
+    return this->parseExtradataGeneric(extradata);
 }
 
 void ParserAVFormat::parseMetadata(const StringPairVec &metadata)
@@ -124,7 +125,7 @@ void ParserAVFormat::parseMetadata(const StringPairVec &metadata)
     metadataRoot->createChildItem(p.first, p.second);
 }
 
-bool ParserAVFormat::parseExtradata_generic(ByteVector &extradata)
+bool ParserAVFormat::parseExtradataGeneric(const ByteVector &extradata)
 {
   if (extradata.empty() || !packetModel->rootItem)
     return true;
@@ -138,7 +139,7 @@ bool ParserAVFormat::parseExtradata_generic(ByteVector &extradata)
   return true;
 }
 
-bool ParserAVFormat::parseExtradata_AVC(ByteVector &extradata)
+bool ParserAVFormat::parseExtradataAVC(const ByteVector &extradata)
 {
   if (extradata.empty() || !packetModel->rootItem)
     return true;
@@ -187,7 +188,7 @@ bool ParserAVFormat::parseExtradata_AVC(ByteVector &extradata)
   return true;
 }
 
-bool ParserAVFormat::parseExtradata_hevc(ByteVector &extradata)
+bool ParserAVFormat::parseExtradataHEVC(const ByteVector &extradata, const HEVCExtradataType type)
 {
   if (extradata.empty() || !packetModel->rootItem)
     return true;
@@ -200,8 +201,16 @@ bool ParserAVFormat::parseExtradata_hevc(ByteVector &extradata)
 
     try
     {
-      avformat::HVCC hvcc;
-      hvcc.parse(extradata, packetModel->rootItem, hevcParser, this->bitratePlotModel.get());
+      if (type == HEVCExtradataType::hvcC)
+      {
+        avformat::DecoderConfigurationHvcC hvcC;
+        hvcC.parse(extradata, packetModel->rootItem, hevcParser, this->bitratePlotModel.get());
+      }
+      else if (type == HEVCExtradataType::lhvC)
+      {
+        avformat::DecoderConfigurationLhvC lhvC;
+        lhvC.parse(extradata, packetModel->rootItem, hevcParser, this->bitratePlotModel.get());
+      }
     }
     catch (...)
     {
@@ -224,7 +233,7 @@ bool ParserAVFormat::parseExtradata_hevc(ByteVector &extradata)
   return true;
 }
 
-bool ParserAVFormat::parseExtradata_mpeg2(ByteVector &extradata)
+bool ParserAVFormat::parseExtradataMPEG2(const ByteVector &extradata)
 {
   if (extradata.empty() || !packetModel->rootItem)
     return true;
@@ -244,11 +253,11 @@ bool ParserAVFormat::parseExtradata_mpeg2(ByteVector &extradata)
   return true;
 }
 
-std::map<std::string, unsigned>
-ParserAVFormat::parseByteVectorAnnexBStartCodes(ByteVector &                   data,
-                                                PacketDataFormat               dataFormat,
-                                                BitratePlotModel::BitrateEntry packetBitrateEntry,
-                                                std::shared_ptr<TreeItem>      item)
+std::map<std::string, unsigned> ParserAVFormat::parseByteVectorAnnexBStartCodes(
+    const ByteVector &                   data,
+    const PacketDataFormat               dataFormat,
+    const BitratePlotModel::BitrateEntry packetBitrateEntry,
+    std::shared_ptr<TreeItem>            item)
 {
   if (dataFormat != PacketDataFormat::RawNAL && dataFormat != PacketDataFormat::MP4)
   {
@@ -256,7 +265,7 @@ ParserAVFormat::parseByteVectorAnnexBStartCodes(ByteVector &                   d
     return {};
   }
 
-  auto getNextNalStart = [&data, &dataFormat](ByteVector::iterator searchStart) {
+  auto getNextNalStart = [&data, &dataFormat](ByteVector::const_iterator searchStart) {
     if (dataFormat == PacketDataFormat::RawNAL)
     {
       if (std::distance(searchStart, data.end()) <= 3)
@@ -620,6 +629,10 @@ bool ParserAVFormat::runParsingOfFile(QString compressedFilePath)
     return false;
   }
 
+  const auto lhvCData = ffmpegFile.getLhvCData();
+  if (!lhvCData.empty())
+    this->parseExtradataHEVC(lhvCData, HEVCExtradataType::lhvC);
+
   int max_ts                      = ffmpegFile.getMaxTS();
   this->videoStreamIndex          = ffmpegFile.getVideoStreamIndex();
   this->framerate                 = ffmpegFile.getFramerate();
diff --git a/YUViewLib/src/parser/AVFormat/ParserAVFormat.h b/YUViewLib/src/parser/AVFormat/ParserAVFormat.h
index 985e2ffc9..1a3265621 100644
--- a/YUViewLib/src/parser/AVFormat/ParserAVFormat.h
+++ b/YUViewLib/src/parser/AVFormat/ParserAVFormat.h
@@ -79,17 +79,23 @@ class ParserAVFormat : public Parser
   // Used for parsing if the packets contain an obu file that we can parse.
   std::unique_ptr<ParserAV1OBU> obuParser;
 
-  bool parseExtradata_generic(ByteVector &extradata);
-  bool parseExtradata_AVC(ByteVector &extradata);
-  bool parseExtradata_hevc(ByteVector &extradata);
-  bool parseExtradata_mpeg2(ByteVector &extradata);
+  enum class HEVCExtradataType
+  {
+    hvcC,
+    lhvC
+  };
+
+  bool parseExtradataGeneric(const ByteVector &extradata);
+  bool parseExtradataAVC(const ByteVector &extradata);
+  bool parseExtradataHEVC(const ByteVector &extradata, const HEVCExtradataType type);
+  bool parseExtradataMPEG2(const ByteVector &extradata);
 
   // Parse all NAL units in data using the AnnexB parser
   std::map<std::string, unsigned>
-  parseByteVectorAnnexBStartCodes(ByteVector &                   data,
-                                  FFmpeg::PacketDataFormat       dataFormat,
-                                  BitratePlotModel::BitrateEntry packetBitrateEntry,
-                                  std::shared_ptr<TreeItem>      item);
+  parseByteVectorAnnexBStartCodes(const ByteVector &                   data,
+                                  const FFmpeg::PacketDataFormat       dataFormat,
+                                  const BitratePlotModel::BitrateEntry packetBitrateEntry,
+                                  std::shared_ptr<TreeItem>            item);
 
   // When the parser is used in the bitstream analysis window, the runParsingOfFile is used and
   // we update this list while parsing the file.
diff --git a/YUViewLib/src/playlistitem/playlistItems.cpp b/YUViewLib/src/playlistitem/playlistItems.cpp
index 12b219471..5c609a1c9 100644
--- a/YUViewLib/src/playlistitem/playlistItems.cpp
+++ b/YUViewLib/src/playlistitem/playlistItems.cpp
@@ -142,6 +142,8 @@ playlistItem *askUserForFileTypeAndCreatePlalistItem(QWidget *  parent,
       return new playlistItemStatisticsFile(fileName, openMode);
     }
   }
+
+  return nullptr;
 }
 
 } // namespace