Basic rendering of RGB565 values works.

Christian Feldmann · Christian Feldmann · commit f9bc50c4e0dc · 2025-06-12T10:51:03.000+03:00
diff --git a/YUViewLib/src/playlistitem/playlistItemRawFile.cpp b/YUViewLib/src/playlistitem/playlistItemRawFile.cpp
@@ -55,17 +55,17 @@ namespace
 {
 
 constexpr auto YUV_EXTENSIONS  = {"yuv", "nv12", "y4m"};
-constexpr auto RGB_EXTENSIONS  = {"rgb", "gbr", "bgr", "brg"};
+constexpr auto RGB_EXTENSIONS  = {"rgb", "gbr", "bgr", "brg", "rgb565", "rgb565be"};
 constexpr auto RGBA_EXTENSIONS = {"rgba", "gbra", "bgra", "brga", "argb", "agbr", "abgr", "abrg"};
 constexpr auto RAW_BAYER_EXTENSIONS = {"raw"};
 constexpr auto CMYK_EXTENSIONS      = {"cmyk"};
 
 bool isInExtensions(const QString &testValue, const std::initializer_list<const char *> &extensions)
 {
   const auto it =
-      std::find_if(extensions.begin(),
-                   extensions.end(),
-                   [testValue](const char *extension) { return QString(extension) == testValue; });
+    std::find_if(extensions.begin(),
+                 extensions.end(),
+                 [testValue](const char *extension) { return QString(extension) == testValue; });
   return it != extensions.end();
 }
 
@@ -206,7 +206,7 @@ InfoData playlistItemRawFile::getInfo() const
     info.items.append(infoItem);
 
   const auto nrFrames =
-      (this->properties().startEndRange.second - this->properties().startEndRange.first + 1);
+    (this->properties().startEndRange.second - this->properties().startEndRange.first + 1);
   info.items.append(InfoItem("Num Frames", std::to_string(nrFrames)));
   info.items.append(InfoItem("Bytes per Frame", std::to_string(this->video->getBytesPerFrame())));
 
@@ -221,7 +221,7 @@ InfoData playlistItemRawFile::getInfo() const
     {
       if ((*fileSize % bpf) != 0)
         info.items.append(InfoItem(
-            "Warning"sv, "The file size and the given video size and/or raw format do not match."));
+          "Warning"sv, "The file size and the given video size and/or raw format do not match."));
     }
     else
       info.items.append(InfoItem("Warning"sv, "Could not obtain file size from input."));
@@ -251,7 +251,7 @@ bool playlistItemRawFile::parseY4MFile()
   unsigned width  = 0;
   unsigned height = 0;
   auto     format =
-      video::yuv::PixelFormatYUV(video::yuv::Subsampling::YUV_420, 8, video::yuv::PlaneOrder::YUV);
+    video::yuv::PixelFormatYUV(video::yuv::Subsampling::YUV_420, 8, video::yuv::PlaneOrder::YUV);
 
   while (rawData.at(offset++) == ' ')
   {
@@ -389,7 +389,7 @@ bool playlistItemRawFile::parseY4MFile()
 
   if (width == 0 || height == 0)
     return setError(
-        "Error parsing the Y4M header: The size could not be obtained from the header.");
+      "Error parsing the Y4M header: The size could not be obtained from the header.");
 
   // Next, all frames should follow. Each frame starts with the sequence 'FRAME', followed by a set
   // of paramters for the frame. The 'FRAME' indicator is terminated by a 0x0A. The list of
@@ -452,7 +452,7 @@ bool playlistItemRawFile::parseY4MFile()
 void playlistItemRawFile::setFormatFromFileName()
 {
   const auto fileInfoForGuess = filesource::frameFormatGuess::getFileInfoForGuessFromPath(
-      this->dataSource.getAbsoluteFilePath());
+    this->dataSource.getAbsoluteFilePath());
 
   const auto frameFormat = filesource::frameFormatGuess::guessFrameFormat(fileInfoForGuess);
 
@@ -496,7 +496,7 @@ void playlistItemRawFile::savePlaylist(QDomElement &root, const QDir &playlistDi
   QUrl fileURL(QString::fromStdString(dataSource.getAbsoluteFilePath()));
   fileURL.setScheme("file");
   auto relativePath =
-      playlistDir.relativeFilePath(QString::fromStdString(dataSource.getAbsoluteFilePath()));
+    playlistDir.relativeFilePath(QString::fromStdString(dataSource.getAbsoluteFilePath()));
 
   auto d = YUViewDomElement(root.ownerDocument().createElement("playlistItemRawFile"));
 
@@ -523,7 +523,7 @@ playlistItemRawFile *playlistItemRawFile::newplaylistItemRawFile(const YUViewDom
 
   // check if file with absolute path exists, otherwise check relative path
   const auto filePath =
-      functions::getAbsPathFromAbsAndRel(playlistFilePath, absolutePath, relativePath);
+    functions::getAbsPathFromAbsAndRel(playlistFilePath, absolutePath, relativePath);
   if (filePath.isEmpty())
     return nullptr;
 
@@ -583,7 +583,7 @@ void playlistItemRawFile::getSupportedFileExtensions(QStringList &allExtensions,
       allExtensions.append(QString(extension));
 
   filters.append("Raw YUV File (*.yuv *.nv21)");
-  filters.append("Raw RGB File (*.rgb *.rbg *.grb *.gbr *.brg *.bgr)");
+  filters.append("Raw RGB File (*.rgb *.rbg *.grb *.gbr *.brg *.bgr, *.rgb565, *.rgb565be)");
   filters.append("Raw RGBA File (*.rgba *.rbga *.grba *.gbra *.brga *.bgra *.argb *.arbg *.agrb "
                  "*.agbr *.abrg *.abgr)");
   filters.append("YUV4MPEG2 File (*.y4m)");
diff --git a/YUViewLib/src/video/PixelFormat.h b/YUViewLib/src/video/PixelFormat.h
@@ -63,6 +63,12 @@ enum class DataLayout
 constexpr EnumMapper<DataLayout, 2> DataLayoutMapper = {
     std::make_pair(DataLayout::Packed, "Packed"), std::make_pair(DataLayout::Planar, "Planar")};
 
+enum class TextRendering
+{
+  White,
+  Black
+};
+
 } // namespace video
 
 Q_DECLARE_METATYPE(video::DataLayout);
diff --git a/YUViewLib/src/video/rgb/ConversionRGB.cpp b/YUViewLib/src/video/rgb/ConversionRGB.cpp
@@ -67,6 +67,77 @@ int getOffsetToFirstByteOfComponent(const Channel         channel,
   return offset;
 }
 
+using RGBTuple = std::tuple<int, int, int>;
+RGBTuple extractRGB565Value(const unsigned char *data, const Endianness endianess)
+{
+  int byte1 = *data;
+  int byte2 = *(data + 1);
+
+  if (endianess == Endianness::Big)
+    std::swap(byte1, byte2);
+
+  const auto value = byte1 + (byte2 << 8);
+
+  int r = ((value & 0b00000000'00011111) << 3);
+  int g = ((value & 0b00000111'11100000) >> 3);
+  int b = ((value & 0b11111000'00000000) >> 8);
+
+  return {r, g, b};
+}
+
+void convertRGB565ToARGB(const QByteArray     &sourceBuffer,
+                         const PixelFormatRGB &srcPixelFormat,
+                         unsigned char        *targetBuffer,
+                         const Size            frameSize,
+                         const bool            componentInvert[4],
+                         const int             componentScale[4],
+                         const bool            limitedRange)
+{
+  auto rawData = reinterpret_cast<const unsigned char *>(sourceBuffer.data());
+
+  const auto endianness = srcPixelFormat.getEndianess();
+  for (unsigned i = 0; i < frameSize.width * frameSize.height; i++)
+  {
+    int byte1 = *rawData;
+    int byte2 = *(rawData + 1);
+
+    if (endianness == Endianness::Big)
+      std::swap(byte1, byte2);
+
+    const auto value = byte1 + (byte2 << 8);
+
+    int r = ((value & 0b00000000'00011111) << 3);
+    int g = ((value & 0b00000111'11100000) >> 3);
+    int b = ((value & 0b11111000'00000000) >> 8);
+
+    r = functions::clip(r * componentScale[0], 0, 255);
+    g = functions::clip(g * componentScale[1], 0, 255);
+    b = functions::clip(b * componentScale[2], 0, 255);
+
+    if (componentInvert[0])
+      r = (255 - r);
+    if (componentInvert[1])
+      g = (255 - g);
+    if (componentInvert[2])
+      b = (255 - b);
+
+    if (limitedRange)
+    {
+      r = LimitedRangeToFullRange.at(r);
+      g = LimitedRangeToFullRange.at(g);
+      b = LimitedRangeToFullRange.at(b);
+    }
+
+    targetBuffer[0] = r;
+    targetBuffer[1] = g;
+    targetBuffer[2] = b;
+    targetBuffer[3] = 255;
+
+    rawData += 2;
+    targetBuffer += 4;
+  }
+}
+
 // Convert the input format to the output RGBA format. Apply inversion, scaling,
 // limited range conversion and alpha multiplication. The input can be any supported
 // format. The output is always 8 bit ARGB little endian.
@@ -103,10 +174,10 @@ void convertRGBToARGB(const QByteArray     &sourceBuffer,
     srcA = ((InValueType)sourceBuffer.data()) + offsetA;
   }
 
+  const auto isBigEndian = bitDepth > 8 && srcPixelFormat.getEndianess() == Endianness::Big;
   for (unsigned i = 0; i < frameSize.width * frameSize.height; i++)
   {
-    const auto isBigEndian = bitDepth > 8 && srcPixelFormat.getEndianess() == Endianness::Big;
-    auto       convertValue =
+    auto convertValue =
       [&isBigEndian, &rightShift](const InValueType sourceData, const int scale, const bool invert)
     {
       auto value = static_cast<int64_t>(sourceData[0]);
@@ -205,6 +276,30 @@ void convertRGBPlaneToARGB(const QByteArray     &sourceBuffer,
   }
 }
 
+rgba_t getPixelValueForPredefiendFormat(const QByteArray     &sourceBuffer,
+                                        const PixelFormatRGB &srcPixelFormat,
+                                        const Size            frameSize,
+                                        const QPoint         &pixelPos)
+{
+  const auto offsetPixelPos = frameSize.width * pixelPos.y() + pixelPos.x();
+  const auto rawData =
+    reinterpret_cast<const unsigned char *>(sourceBuffer.data() + offsetPixelPos * 2);
+
+  int byte1 = *rawData;
+  int byte2 = *(rawData + 1);
+
+  if (srcPixelFormat.getEndianess() == Endianness::Big)
+    std::swap(byte1, byte2);
+
+  const auto value = byte1 + (byte2 << 8);
+
+  int r = ((value & 0b00000000'00011111));
+  int g = ((value & 0b00000111'11100000) >> 5);
+  int b = ((value & 0b11111000'00000000) >> 11);
+
+  return {static_cast<unsigned>(r), static_cast<unsigned>(g), static_cast<unsigned>(b), 255};
+}
+
 template <int bitDepth>
 rgba_t getPixelValue(const QByteArray     &sourceBuffer,
                      const PixelFormatRGB &srcPixelFormat,
@@ -251,10 +346,16 @@ void convertInputRGBToARGB(const QByteArray     &sourceBuffer,
                            const bool            premultiplyAlpha)
 {
   const auto bitsPerComponent = srcPixelFormat.getBitsPerComponent();
-  if (bitsPerComponent < 8 || bitsPerComponent > 32)
-    throw std::invalid_argument("Invalid bit depth in pixel format for conversion");
 
-  if (bitsPerComponent == 8)
+  if (srcPixelFormat.getPredefinedPixelFormat())
+    convertRGB565ToARGB(sourceBuffer,
+                        srcPixelFormat,
+                        targetBuffer,
+                        frameSize,
+                        componentInvert,
+                        componentScale,
+                        limitedRange);
+  else if (bitsPerComponent == 8)
     convertRGBToARGB<8>(sourceBuffer,
                         srcPixelFormat,
                         targetBuffer,
@@ -274,7 +375,7 @@ void convertInputRGBToARGB(const QByteArray     &sourceBuffer,
                          limitedRange,
                          outputHasAlpha,
                          premultiplyAlpha);
-  else
+  else if (bitsPerComponent <= 32)
     convertRGBToARGB<32>(sourceBuffer,
                          srcPixelFormat,
                          targetBuffer,
@@ -284,6 +385,8 @@ void convertInputRGBToARGB(const QByteArray     &sourceBuffer,
                          limitedRange,
                          outputHasAlpha,
                          premultiplyAlpha);
+  else
+    throw std::invalid_argument("Unable to perform conversion");
 }
 
 void convertSinglePlaneOfRGBToGreyscaleARGB(const QByteArray     &sourceBuffer,
@@ -334,15 +437,17 @@ rgba_t getPixelValueFromBuffer(const QByteArray     &sourceBuffer,
                                const QPoint         &pixelPos)
 {
   const auto bitsPerComponent = srcPixelFormat.getBitsPerComponent();
-  if (bitsPerComponent < 8 || bitsPerComponent > 32)
-    throw std::invalid_argument("Invalid bit depth in pixel format for conversion");
 
-  if (bitsPerComponent == 8)
+  if (srcPixelFormat.getPredefinedPixelFormat())
+    return getPixelValueForPredefiendFormat(sourceBuffer, srcPixelFormat, frameSize, pixelPos);
+  else if (bitsPerComponent == 8)
     return getPixelValue<8>(sourceBuffer, srcPixelFormat, frameSize, pixelPos);
   else if (bitsPerComponent <= 16)
     return getPixelValue<16>(sourceBuffer, srcPixelFormat, frameSize, pixelPos);
-  else
+  else if (bitsPerComponent <= 32)
     return getPixelValue<32>(sourceBuffer, srcPixelFormat, frameSize, pixelPos);
+
+  throw std::invalid_argument("Unable to perform conversion");
 }
 
 } // namespace video::rgb
diff --git a/YUViewLib/src/video/rgb/PixelFormatRGB.cpp b/YUViewLib/src/video/rgb/PixelFormatRGB.cpp
@@ -61,16 +61,12 @@ PixelFormatRGB::PixelFormatRGB(const std::string &name)
   if (name == UNKNOWN_FORMAT_NAME)
     return;
 
-  if (name.substr(0, 8) == "RGB565BE")
-  {
-    this->predefinedPixelFormat = PredefinedPixelFormat::RGB565BE;
-    return;
-  }
-  if (name.substr(0, 6) == "RGB565")
-  {
-    this->predefinedPixelFormat = PredefinedPixelFormat::RGB565;
-    return;
-  }
+  for (const auto predefinedFormat : PredefinedPixelFormatMapper)
+    if (name == predefinedFormat.second)
+    {
+      this->predefinedPixelFormat = predefinedFormat.first;
+      return;
+    }
 
   auto channelOrderString = name.substr(0, 3);
   if (name[0] == 'a' || name[0] == 'A')
@@ -122,10 +118,8 @@ std::string PixelFormatRGB::getName() const
   if (!this->isValid())
     return UNKNOWN_FORMAT_NAME;
 
-  if (this->predefinedPixelFormat == PredefinedPixelFormat::RGB565)
-    return "RGB565";
-  if (this->predefinedPixelFormat == PredefinedPixelFormat::RGB565BE)
-    return "RGB565BE";
+  if (this->predefinedPixelFormat)
+    return std::string(PredefinedPixelFormatMapper.getName(*this->predefinedPixelFormat));
 
   std::string name;
   if (this->alphaMode == AlphaMode::First)
@@ -303,6 +297,28 @@ Channel PixelFormatRGB::getChannelAtPosition(int position) const
   throw std::invalid_argument("Invalid argument for channel position");
 }
 
+TextRendering PixelFormatRGB::getPixelValueTextRendering(rgba_t value) const
+{
+  // Shift the values to 8 bit
+  if (this->predefinedPixelFormat)
+  {
+    value.R = (value.R << 3);
+    value.G = (value.G << 2);
+    value.B = (value.B << 3);
+  }
+  else if (this->bitsPerComponent > 8)
+  {
+    const auto shift = (this->bitsPerComponent - 8);
+    value.R          = (value.R >> shift);
+    value.G          = (value.G >> shift);
+    value.B          = (value.B >> shift);
+  }
+
+  // Approximation of Y = 0.375 R + 0.5 G + 0.125 B to be closer to the percieved brightness.
+  const auto luminance = (3 * value.R + 4 * value.B + value.B) >> 3;
+  return luminance < 128 ? TextRendering::White : TextRendering::Black;
+}
+
 bool PixelFormatRGB::operator==(const PixelFormatRGB &a) const
 {
   if (!this->isValid() || !a.isValid())
diff --git a/YUViewLib/src/video/rgb/PixelFormatRGB.h b/YUViewLib/src/video/rgb/PixelFormatRGB.h
@@ -119,6 +119,10 @@ enum class PredefinedPixelFormat
   RGB565BE, // 16 bits packed as R:5, G:6, B:5 Big Endian
 };
 
+constexpr EnumMapper<PredefinedPixelFormat, 2> PredefinedPixelFormatMapper = {
+  std::make_pair(PredefinedPixelFormat::RGB565, "RGB565"),
+  std::make_pair(PredefinedPixelFormat::RGB565BE, "RGB565BE")};
+
 enum class ChannelOrder
 {
   RGB,
@@ -172,10 +176,11 @@ class PixelFormatRGB
   [[nodiscard]] Endianness                           getEndianess() const;
   [[nodiscard]] std::optional<PredefinedPixelFormat> getPredefinedPixelFormat() const;
 
-  [[nodiscard]] int     getNrChannels() const;
-  [[nodiscard]] int     getBytesPerFrame(const Size frameSize) const;
-  [[nodiscard]] int     getChannelPosition(const Channel channel) const;
-  [[nodiscard]] Channel getChannelAtPosition(const int position) const;
+  [[nodiscard]] int           getNrChannels() const;
+  [[nodiscard]] int           getBytesPerFrame(const Size frameSize) const;
+  [[nodiscard]] int           getChannelPosition(const Channel channel) const;
+  [[nodiscard]] Channel       getChannelAtPosition(const int position) const;
+  [[nodiscard]] TextRendering getPixelValueTextRendering(rgba_t value) const;
 
   bool operator==(const PixelFormatRGB &a) const;
   bool operator!=(const PixelFormatRGB &a) const;
diff --git a/YUViewLib/src/video/rgb/videoHandlerRGB.cpp b/YUViewLib/src/video/rgb/videoHandlerRGB.cpp
diff --git a/YUViewLib/src/video/yuv/PixelFormatYUV.cpp b/YUViewLib/src/video/yuv/PixelFormatYUV.cpp
