PanasonicV8Decompressor: these aren't Huffman codes, not even Prefix codes

LebedevRI · LebedevRI · commit 71518e85e440 · 2025-05-24T01:57:41.000+03:00
diff --git a/fuzz/librawspeed/decompressors/PanasonicV8Decompressor.cpp b/fuzz/librawspeed/decompressors/PanasonicV8Decompressor.cpp
@@ -77,15 +77,15 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* Data, size_t Size) {
     uint32_t numStripLineOffsets = bs.getU32();
     uint32_t numStripWidths = bs.getU32();
     uint32_t numStripHeights = bs.getU32();
-    uint32_t numHuffmanLUTEntries = bs.getU32();
+    uint32_t numDecoderLUTEntries = bs.getU32();
 
     auto stripSizes = bs.getStream(numStrips, sizeof(uint32_t));
     auto stripLineOffsetsInput =
         bs.getStream(numStripLineOffsets, sizeof(uint32_t));
     auto stripWidthsInput = bs.getStream(numStripWidths, sizeof(uint16_t));
     auto stripHeightsInput = bs.getStream(numStripHeights, sizeof(uint16_t));
-    auto huffmanLUTEntriesInput =
-        bs.getStream(numHuffmanLUTEntries, 2 * sizeof(uint8_t));
+    auto decoderLUTEntriesInput =
+        bs.getStream(numDecoderLUTEntries, 2 * sizeof(uint8_t));
     const auto initialPrediction = bs.getArray<uint16_t, 4>();
 
     // The rest of the bs are the input strips.
@@ -120,19 +120,19 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* Data, size_t Size) {
         getAsArray1DRef(stripLineOffsets), getAsArray1DRef(stripWidths),
         getAsArray1DRef(stripHeights));
 
-    std::vector<PanasonicV8Decompressor::HuffmanLUTEntry> huffmanLUT;
-    huffmanLUT.reserve(std::max(1U, numHuffmanLUTEntries));
-    for (uint32_t entryIdx = 0; entryIdx < numHuffmanLUTEntries; ++entryIdx) {
-      const auto bitcount = huffmanLUTEntriesInput.get<uint8_t>();
-      const auto diffCat = huffmanLUTEntriesInput.get<uint8_t>();
+    std::vector<PanasonicV8Decompressor::DecoderLUTEntry> decoderLUT;
+    decoderLUT.reserve(std::max(1U, numDecoderLUTEntries));
+    for (uint32_t entryIdx = 0; entryIdx < numDecoderLUTEntries; ++entryIdx) {
+      const auto bitcount = decoderLUTEntriesInput.get<uint8_t>();
+      const auto diffCat = decoderLUTEntriesInput.get<uint8_t>();
 
-      huffmanLUT.emplace_back(PanasonicV8Decompressor::HuffmanLUTEntry{
+      decoderLUT.emplace_back(PanasonicV8Decompressor::DecoderLUTEntry{
           .bitcount = bitcount, .diffCat = diffCat});
     }
-    invariant(huffmanLUTEntriesInput.getRemainSize() == 0);
+    invariant(decoderLUTEntriesInput.getRemainSize() == 0);
 
     PanasonicV8Decompressor v8(mRaw, builder.getDecompressorParams(),
-                               getAsArray1DRef(huffmanLUT));
+                               getAsArray1DRef(decoderLUT));
     mRaw->createData();
     v8.decompress();
     MSan::CheckMemIsInitialized(mRaw->getByteDataAsUncroppedArray2DRef());
diff --git a/src/librawspeed/decoders/Rw2Decoder.cpp b/src/librawspeed/decoders/Rw2Decoder.cpp
@@ -99,8 +99,8 @@ struct DecompressorV8Params {
 
   PanasonicV8Decompressor::Bayer2x2 initialPrediction;
 
-  /// Huffman decoding shift down value. Appears to be unused.
-  std::vector<uint16_t> huffShiftDown;
+  /// Decoding shift down value. Appears to be unused.
+  std::vector<uint16_t> shiftDown;
 
   uint16_t gammaClipVal;
 
@@ -131,7 +131,7 @@ void DecompressorV8Params::validate() const {
     ThrowRDE("Strip bit length list does not have enough entries for the "
              "number of strips!");
 
-  if (std::any_of(huffShiftDown.begin(), huffShiftDown.end(),
+  if (std::any_of(shiftDown.begin(), shiftDown.end(),
                   [](uint16_t x) { return x != 0; })) {
     ThrowRDE("Non-zero shift down value encountered! Shift down decoding has "
              "never been tested!");
@@ -174,32 +174,31 @@ DecompressorV8Params::DecompressorV8Params(const TiffIFD& ifd) {
   initialPrediction[3] =
       ifd.getEntry(TiffTag::PANASONIC_V8_INIT_PRED_BLUE)->getU16();
 
-  getPanasonicTiffVector(ifd, TiffTag::PANASONIC_V8_HUF_SHIFT_DOWN,
-                         huffShiftDown);
+  getPanasonicTiffVector(ifd, TiffTag::PANASONIC_V8_HUF_SHIFT_DOWN, shiftDown);
 
   gammaClipVal = ifd.getEntry(TiffTag::PANASONIC_V8_CLIP_VAL)->getU16();
   // NOLINTEND(cppcoreguidelines-prefer-member-initializer)
 
   validate();
 }
 
-std::vector<PanasonicV8Decompressor::HuffmanLUTEntry>
-populateHuffmanLUT(const TiffIFD& ifd) {
-  std::vector<PanasonicV8Decompressor::HuffmanLUTEntry> mHuffmanLUT;
+std::vector<PanasonicV8Decompressor::DecoderLUTEntry>
+populateDecoderLUT(const TiffIFD& ifd) {
+  std::vector<PanasonicV8Decompressor::DecoderLUTEntry> mDecoderLUT;
 
   ByteStream stream = ifd.getEntry(TiffTag::PANASONIC_V8_HUF_TABLE)->getData();
 
   const auto numSymbols = stream.getU16();
   if (numSymbols < 1 || numSymbols > 17)
     ThrowRDE("Unexpected number of symbols: %u", numSymbols);
 
-  struct HuffEntry {
+  struct Entry {
     uint8_t bitcount;
     uint16_t symbol, mask;
     uint8_t codeValue;
   };
-  std::vector<HuffEntry> huffTable;
-  huffTable.reserve(numSymbols);
+  std::vector<Entry> table;
+  table.reserve(numSymbols);
 
   for (unsigned symbolIndex = 0; symbolIndex != numSymbols; ++symbolIndex) {
     const auto len = stream.getU16(); // Number of bits in symbol
@@ -208,28 +207,28 @@ populateHuffmanLUT(const TiffIFD& ifd) {
     const auto code = stream.getU16();
     if (!isIntN<uint32_t>(code, len))
       ThrowRDE("Bad symbol code");
-    HuffEntry entry;
+    Entry entry;
     entry.bitcount = implicit_cast<uint8_t>(len);
     entry.symbol = uint16_t(code << (16U - entry.bitcount));
     entry.codeValue = implicit_cast<uint8_t>(symbolIndex);
     entry.mask = uint16_t(
         0xffffU << (16U -
                     entry.bitcount)); // mask of the bits overlapping symbol
-    if (entry.bitcount == PanasonicV8Decompressor::HuffmanLUTEntry().bitcount &&
-        entry.codeValue == PanasonicV8Decompressor::HuffmanLUTEntry().diffCat)
+    if (entry.bitcount == PanasonicV8Decompressor::DecoderLUTEntry().bitcount &&
+        entry.codeValue == PanasonicV8Decompressor::DecoderLUTEntry().diffCat)
       ThrowRDE("Sentinel symbol encountered");
-    huffTable.emplace_back(entry);
+    table.emplace_back(entry);
   }
   assert(table.size() == numSymbols);
 
-  // Cache of Huffman table results for all possible 16-bit values.
-  mHuffmanLUT.resize(1 + UINT16_MAX);
+  // Cache of decoding results for all possible 16-bit values.
+  mDecoderLUT.resize(1 + UINT16_MAX);
 
   // Populates LUT by checking for a bitwise match between each value and the
-  // prefix codes recorded in the table.
-  for (unsigned li = 0; li < mHuffmanLUT.size(); ++li) {
-    PanasonicV8Decompressor::HuffmanLUTEntry& lutVal = mHuffmanLUT[li];
-    for (const auto& ti : huffTable) {
+  // codes recorded in the table.
+  for (unsigned li = 0; li < mDecoderLUT.size(); ++li) {
+    PanasonicV8Decompressor::DecoderLUTEntry& lutVal = mDecoderLUT[li];
+    for (const auto& ti : table) {
       if ((uint16_t(li) & ti.mask) == ti.symbol) {
         lutVal.bitcount = ti.bitcount;
         lutVal.diffCat = ti.codeValue;
@@ -238,7 +237,7 @@ populateHuffmanLUT(const TiffIFD& ifd) {
     }
   }
 
-  return mHuffmanLUT;
+  return mDecoderLUT;
 }
 
 /// Maybe the most complicated part of the entire file format, and seemingly,
@@ -307,8 +306,8 @@ RawImage Rw2Decoder::decodeRawV8(const TiffIFD& raw) const {
     ThrowRDE("Unexpected CFA, only RGGB is supported");
 
   const DecompressorV8Params mParams(raw);
-  const std::vector<PanasonicV8Decompressor::HuffmanLUTEntry> mHuffmanLUT =
-      populateHuffmanLUT(raw);
+  const std::vector<PanasonicV8Decompressor::DecoderLUTEntry> mDecoderLUT =
+      populateDecoderLUT(raw);
   populateGammaLUT(mParams, raw);
   const std::vector<Array1DRef<const uint8_t>> mStrips =
       getInputStrips(mParams, mFile);
@@ -322,7 +321,7 @@ RawImage Rw2Decoder::decodeRawV8(const TiffIFD& raw) const {
       getAsArray1DRef(mParams.stripHeights));
 
   PanasonicV8Decompressor v8(mRaw, b.getDecompressorParams(),
-                             getAsArray1DRef(mHuffmanLUT));
+                             getAsArray1DRef(mDecoderLUT));
   mRaw->createData();
   v8.decompress();
   return mRaw;
diff --git a/src/librawspeed/decompressors/PanasonicV8Decompressor.cpp b/src/librawspeed/decompressors/PanasonicV8Decompressor.cpp
@@ -130,15 +130,15 @@ class BitStreamerRevMSB final
 };
 
 /// Utility class for Panasonic V8 entropy decoding
-class PanasonicV8Decompressor::InternalHuffDecoder {
+class PanasonicV8Decompressor::InternalDecoder {
 private:
-  const Array1DRef<const HuffmanLUTEntry>
-      mLUT; // Reference to PanasonicV8Decompressor::mHuffmanLUT
+  // Reference to PanasonicV8Decompressor::mDecoderLUT
+  const Array1DRef<const DecoderLUTEntry> mLUT;
   BitStreamerRevMSB mBitPump;
 
 public:
-  InternalHuffDecoder(const Array1DRef<const HuffmanLUTEntry>& LUT,
-                      Array1DRef<const uint8_t> bitStream)
+  InternalDecoder(const Array1DRef<const DecoderLUTEntry>& LUT,
+                  Array1DRef<const uint8_t> bitStream)
       : mLUT(LUT), mBitPump(bitStream) {}
 
   int32_t decodeNextDiffValue();
@@ -238,9 +238,9 @@ PanasonicV8Decompressor::DecompressorParamsBuilder::getOutRects(
 
 PanasonicV8Decompressor::PanasonicV8Decompressor(
     RawImage outputImg, DecompressorParams mParams_,
-    Array1DRef<const HuffmanLUTEntry> mHuffmanLUT_)
+    Array1DRef<const DecoderLUTEntry> mHDecoderLUT_)
     : mRawOutput(std::move(outputImg)), mParams(std::move(mParams_)),
-      mHuffmanLUT(mHuffmanLUT_) {
+      mDecoderLUT(mHDecoderLUT_) {
   if (mRawOutput->getCpp() != 1 ||
       mRawOutput->getDataType() != RawImageType::UINT16 ||
       mRawOutput->getBpp() != sizeof(uint16_t)) {
@@ -272,7 +272,7 @@ void PanasonicV8Decompressor::decompress() const {
                            /*croppedHeight=*/outRect.dim.y)
                            .getAsArray2DRef();
 
-      InternalHuffDecoder decoder(mHuffmanLUT, strip);
+      InternalDecoder decoder(mDecoderLUT, strip);
 
       decompressStrip(out, decoder);
     } catch (const RawspeedException& err) {
@@ -285,8 +285,8 @@ void PanasonicV8Decompressor::decompress() const {
   }
 }
 
-void PanasonicV8Decompressor::decompressStrip(
-    const Array2DRef<uint16_t> out, InternalHuffDecoder decoder) const {
+void PanasonicV8Decompressor::decompressStrip(const Array2DRef<uint16_t> out,
+                                              InternalDecoder decoder) const {
   Bayer2x2 predictedStorage = mParams.initialPrediction;
   const auto pred = Array2DRef(predictedStorage.data(), 2, 2);
 
@@ -337,14 +337,13 @@ void PanasonicV8Decompressor::decompressStrip(
   }
 }
 
-int32_t inline PanasonicV8Decompressor::InternalHuffDecoder::
-    decodeNextDiffValue() {
+int32_t inline PanasonicV8Decompressor::InternalDecoder::decodeNextDiffValue() {
   // Retrieve the difference category, which indicates magnitude of the
   // difference between the predicted and actual value.
   const auto next16 = uint16_t(mBitPump.peekBits(16));
   const auto& [codeLen, codeValue] = mLUT(next16);
   if (codeValue == 0 && codeLen == 7)
-    ThrowRDE("Huffman decoding encountered an invalid value!");
+    ThrowRDE("Decoding encountered an invalid value!");
   mBitPump.skipBits(
       codeLen); // Skip the bits that encoded the difference category
   int diffLen = codeValue;
diff --git a/src/librawspeed/decompressors/PanasonicV8Decompressor.h b/src/librawspeed/decompressors/PanasonicV8Decompressor.h
@@ -41,7 +41,7 @@ namespace rawspeed {
 /// Each raw file is broken up into a number of separate strips, each of which
 /// was separately encoded, and which can be decoded independently. For each
 /// strip, an initial predicted value is provided. The strip's data buffer is
-/// then decoded using the Huffman table provided in metadata. Each value
+/// then decoded using the decoding table provided in metadata. Each value
 /// decoded from the strip is a difference between the predicted value and
 /// actual value, allowing the actual value to be reconstructed.
 class PanasonicV8Decompressor final : public AbstractDecompressor {
@@ -107,27 +107,26 @@ class PanasonicV8Decompressor final : public AbstractDecompressor {
     }
   };
 
-  // Pre-cached Huffman decoded values for rapid lookup.
-  struct HuffmanLUTEntry {
+  // Pre-cached decoded values for rapid lookup.
+  struct DecoderLUTEntry {
     uint8_t bitcount = 7;
     uint8_t diffCat = 0;
   };
 
 private:
   const DecompressorParams mParams;
-  const Array1DRef<const HuffmanLUTEntry> mHuffmanLUT;
+  const Array1DRef<const DecoderLUTEntry> mDecoderLUT;
 
-  /// Huffman decoder helper class. Defined only in the cpp file.
-  class InternalHuffDecoder;
+  /// Decoder helper class. Defined only in the cpp file.
+  class InternalDecoder;
 
   /// Thread safe function for decompressing a single data-stripstrip within a
   /// Rw2V8 raw image.
-  void decompressStrip(Array2DRef<uint16_t> out,
-                       InternalHuffDecoder decoder) const;
+  void decompressStrip(Array2DRef<uint16_t> out, InternalDecoder decoder) const;
 
 public:
   PanasonicV8Decompressor(RawImage outputImg, DecompressorParams mParams_,
-                          Array1DRef<const HuffmanLUTEntry> mHuffmanLUT_);
+                          Array1DRef<const DecoderLUTEntry> mDecoderLUT_);
 
   /// Run the decompressor on the provided raw image
   void decompress() const;
