Add support for 16+ bits YUV files (up to 32-bit)

- Extend BitDepthList to support 8-32 bit depth
- Add get_min_standard_bytes() for correct bytes-per-sample calculation
- Fix type overflows by upgrading to int64_t
- Fix setFormatFromCorrelation loop to test 24/32-bit formats
- Use bytesPerSample consistently instead of hardcoded (bps > 8) checks

Author: for13to1

YUViewLib/src/video/yuv/PixelFormatYUV.cpp

@@ -174,7 +174,7 @@ PixelFormatYUV::PixelFormatYUV(const std::string &name)
       auto   bitdepthStr = sm.str(3);
       size_t sz;
       int    bitDepth = std::stoi(bitdepthStr, &sz);
-      if (sz > 0 && bitDepth >= 8 && bitDepth <= 16)
+      if (sz > 0 && bitDepth >= 8 && bitDepth <= 32)
         newFormat.bitsPerSample = bitDepth;
     }
 
@@ -317,7 +317,7 @@ bool PixelFormatYUV::canConvertToRGB(Size imageSize, std::string *whyNot) const
   // Check the bit depth
   const int bps        = this->bitsPerSample;
   bool      canConvert = true;
-  if (bps < 8 || bps > 16)
+  if (bps < 8 || bps > 32)
   {
     if (whyNot)
     {
@@ -382,28 +382,28 @@ int64_t PixelFormatYUV::bytesPerFrame(const Size &frameSize) const
   }
 
   int64_t bytes = 0;
+  const auto bytesPerSample = get_min_standard_bytes(this->bitsPerSample); // Round to bytes
 
   if (this->planar || !this->bytePacking)
   {
     // Add the bytes of the 3 (or 4) planes.
     // This also works for packed formats without byte packing. For these formats the number of
     // bytes are identical to the not packed formats, the bytes are just sorted in another way.
 
-    const auto bytesPerSample = (this->bitsPerSample + 7) / 8;    // Round to bytes
-    bytes += frameSize.width * frameSize.height * bytesPerSample; // Luma plane
+    bytes += (int64_t)frameSize.width * frameSize.height * bytesPerSample; // Luma plane
     if (this->subsampling == Subsampling::YUV_444)
-      bytes += frameSize.width * frameSize.height * bytesPerSample * 2; // U/V planes
+      bytes += (int64_t)frameSize.width * frameSize.height * bytesPerSample * 2; // U/V planes
     else if (this->subsampling == Subsampling::YUV_422 || this->subsampling == Subsampling::YUV_440)
-      bytes += (frameSize.width / 2) * frameSize.height * bytesPerSample *
+      bytes += (int64_t)(frameSize.width / 2) * frameSize.height * bytesPerSample *
                2; // U/V planes, half the width
     else if (this->subsampling == Subsampling::YUV_420)
-      bytes += (frameSize.width / 2) * (frameSize.height / 2) * bytesPerSample *
+      bytes += (int64_t)(frameSize.width / 2) * (frameSize.height / 2) * bytesPerSample *
                2; // U/V planes, half the width and height
     else if (this->subsampling == Subsampling::YUV_410)
-      bytes += (frameSize.width / 4) * (frameSize.height / 4) * bytesPerSample *
+      bytes += (int64_t)(frameSize.width / 4) * (frameSize.height / 4) * bytesPerSample *
                2; // U/V planes, half the width and height
     else if (this->subsampling == Subsampling::YUV_411)
-      bytes += (frameSize.width / 4) * frameSize.height * bytesPerSample *
+      bytes += (int64_t)(frameSize.width / 4) * frameSize.height * bytesPerSample *
                2; // U/V planes, quarter the width
     else if (this->subsampling == Subsampling::YUV_400)
       bytes += 0; // No chroma components
@@ -413,30 +413,29 @@ int64_t PixelFormatYUV::bytesPerFrame(const Size &frameSize) const
     if (this->planar &&
         (this->planeOrder == PlaneOrder::YUVA || this->planeOrder == PlaneOrder::YVUA))
       // There is an additional alpha plane. The alpha plane is not subsampled
-      bytes += frameSize.width * frameSize.height * bytesPerSample; // Alpha plane
+      bytes += (int64_t)frameSize.width * frameSize.height * bytesPerSample; // Alpha plane
     if (!this->planar && this->subsampling == Subsampling::YUV_444 &&
         (this->packingOrder == PackingOrder::AYUV || this->packingOrder == PackingOrder::YUVA ||
          this->packingOrder == PackingOrder::VUYA))
       // There is an additional alpha plane. The alpha plane is not subsampled
-      bytes += frameSize.width * frameSize.height * bytesPerSample; // Alpha plane
+      bytes += (int64_t)frameSize.width * frameSize.height * bytesPerSample; // Alpha plane
   }
   else
   {
     // This is a packed format with byte packing
     if (this->subsampling == Subsampling::YUV_422)
     {
       // All packing orders have 4 values per packed value (which has 2 Y samples)
-      const auto bitsPerPixel = this->bitsPerSample * 4;
-      return ((bitsPerPixel + 7) / 8) * (frameSize.width / 2) * frameSize.height;
+      return 4 * bytesPerSample * (frameSize.width / 2) * frameSize.height;
     }
     // This is a packed format. The added number of bytes might be lower because of the packing.
     if (this->subsampling == Subsampling::YUV_444)
     {
-      auto bitsPerPixel = this->bitsPerSample * 3;
+      auto channels = 3;
       if (this->packingOrder == PackingOrder::AYUV || this->packingOrder == PackingOrder::YUVA ||
           this->packingOrder == PackingOrder::VUYA)
-        bitsPerPixel += this->bitsPerSample;
-      return ((bitsPerPixel + 7) / 8) * frameSize.width * frameSize.height;
+        channels += 1;
+      return channels * bytesPerSample * frameSize.width * frameSize.height;
     }
     // else if (subsampling == Subsampling::YUV_422 || subsampling == Subsampling::YUV_440)
     //{

YUViewLib/src/video/yuv/PixelFormatYUV.h

@@ -95,15 +95,15 @@ class MathParameters
 {
 public:
   MathParameters() = default;
-  MathParameters(int scale, int offset, bool invert) : scale(scale), offset(offset), invert(invert)
+  MathParameters(int scale, int64_t offset, bool invert) : scale(scale), offset(offset), invert(invert)
   {
   }
   // Do we need to apply any transform to the raw YUV data before conversion to RGB?
   bool mathRequired() const { return scale != 1 || invert; }
 
-  int  scale{1};
-  int  offset{128};
-  bool invert{};
+  int     scale{1};
+  int64_t offset{128};
+  bool    invert{};
 };
 
 enum class PredefinedPixelFormat
@@ -184,7 +184,7 @@ constexpr EnumMapper<PlaneOrder, 4> PlaneOrderMapper = {std::make_pair(PlaneOrde
                                                         std::make_pair(PlaneOrder::YUVA, "YUVA"),
                                                         std::make_pair(PlaneOrder::YVUA, "YVUA")};
 
-const auto BitDepthList = std::vector<unsigned>({8, 9, 10, 12, 14, 16});
+const auto BitDepthList = std::vector<unsigned>({8, 9, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32});
 
 // This class defines a specific YUV format with all properties like pixels per sample, subsampling
 // of chroma components and so on.
@@ -264,4 +264,21 @@ class PixelFormatYUV
   bool         bytePacking{};
 };
 
+inline uint64_t get_min_standard_bytes(uint64_t x) {
+  if (x == 0)
+    return 0;
+
+  if (x >= UINT64_MAX / 8) {
+    return UINT64_MAX;
+  }
+
+  x--;
+
+  for (int current_shift = 1; current_shift < 64; current_shift <<= 1) {
+    x |= x >> current_shift;
+  }
+
+  return (x + 8) >> 3;
+}
+
 } // namespace video::yuv

YUViewLib/src/video/yuv/PixelFormatYUVGuess.cpp

@@ -66,7 +66,7 @@ std::vector<unsigned> getDetectionBitDepthList(const std::optional<unsigned> &de
 {
   if (detectedBitrate)
     return {*detectedBitrate};
-  return {10u, 12u, 14u, 16u, 8u};
+  return BitDepthList;
 }
 
 std::vector<Subsampling> getDetectionSubsamplingList(Subsampling subsamplingToForceAsFirst,