PanasonicV8Decompressor: sink getDecoderLUT() back into decompressor

Author: LebedevRI

fuzz/librawspeed/decompressors/PanasonicV8Decompressor.cpp

@@ -77,15 +77,14 @@ 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 numDecoderLUTEntries = bs.getU32();
+    uint32_t numDefineCodesSize = 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 decoderLUTEntriesInput =
-        bs.getStream(numDecoderLUTEntries, 2 * sizeof(uint8_t));
+    auto defineCodes = bs.getStream(numDefineCodesSize);
     const auto initialPrediction = bs.getArray<uint16_t, 4>();
 
     // The rest of the bs are the input strips.
@@ -118,21 +117,9 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* Data, size_t Size) {
     PanasonicV8Decompressor::DecompressorParamsBuilder builder(
         imgDim, initialPrediction, getAsArray1DRef(strips),
         getAsArray1DRef(stripLineOffsets), getAsArray1DRef(stripWidths),
-        getAsArray1DRef(stripHeights));
+        getAsArray1DRef(stripHeights), defineCodes);
 
-    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>();
-
-      decoderLUT.emplace_back(PanasonicV8Decompressor::DecoderLUTEntry{
-          .bitcount = bitcount, .diffCat = diffCat});
-    }
-    invariant(decoderLUTEntriesInput.getRemainSize() == 0);
-
-    PanasonicV8Decompressor v8(mRaw, builder.getDecompressorParams(),
-                               getAsArray1DRef(decoderLUT));
+    PanasonicV8Decompressor v8(mRaw, builder.getDecompressorParams());
     mRaw->createData();
     v8.decompress();
     MSan::CheckMemIsInitialized(mRaw->getByteDataAsUncroppedArray2DRef());

src/librawspeed/decoders/Rw2Decoder.cpp

@@ -23,8 +23,6 @@
 #include "adt/Array1DRef.h"
 #include "adt/Array1DRefExtras.h"
 #include "adt/Array2DRef.h"
-#include "adt/Bit.h"
-#include "adt/Casts.h"
 #include "adt/Point.h"
 #include "bitstreams/BitStreams.h"
 #include "common/BayerPhase.h"
@@ -182,64 +180,6 @@ DecompressorV8Params::DecompressorV8Params(const TiffIFD& ifd) {
   validate();
 }
 
-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 Entry {
-    uint8_t bitcount;
-    uint16_t symbol, mask;
-    uint8_t codeValue;
-  };
-  std::vector<Entry> table;
-  table.reserve(numSymbols);
-
-  for (unsigned symbolIndex = 0; symbolIndex != numSymbols; ++symbolIndex) {
-    const auto len = stream.getU16(); // Number of bits in symbol
-    if (len < 1 || len > 16)
-      ThrowRDE("Unexpected symbol length");
-    const auto code = stream.getU16();
-    if (!isIntN<uint32_t>(code, len))
-      ThrowRDE("Bad symbol code");
-    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::DecoderLUTEntry().bitcount &&
-        entry.codeValue == PanasonicV8Decompressor::DecoderLUTEntry().diffCat)
-      ThrowRDE("Sentinel symbol encountered");
-    table.emplace_back(entry);
-  }
-  assert(table.size() == numSymbols);
-
-  // 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
-  // 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;
-        break; // NOTE: not a prefix code!
-      }
-    }
-  }
-
-  return mDecoderLUT;
-}
-
 /// Maybe the most complicated part of the entire file format, and seemingly,
 /// completely unused.
 void populateGammaLUT(const DecompressorV8Params& mParams, const TiffIFD& ifd) {
@@ -306,8 +246,6 @@ RawImage Rw2Decoder::decodeRawV8(const TiffIFD& raw) const {
     ThrowRDE("Unexpected CFA, only RGGB is supported");
 
   const DecompressorV8Params mParams(raw);
-  const std::vector<PanasonicV8Decompressor::DecoderLUTEntry> mDecoderLUT =
-      populateDecoderLUT(raw);
   populateGammaLUT(mParams, raw);
   const std::vector<Array1DRef<const uint8_t>> mStrips =
       getInputStrips(mParams, mFile);
@@ -318,10 +256,10 @@ RawImage Rw2Decoder::decodeRawV8(const TiffIFD& raw) const {
       imgDim, mParams.initialPrediction, getAsArray1DRef(mStrips),
       getAsArray1DRef(mParams.stripLineOffsets),
       getAsArray1DRef(mParams.stripWidths),
-      getAsArray1DRef(mParams.stripHeights));
+      getAsArray1DRef(mParams.stripHeights),
+      raw.getEntry(TiffTag::PANASONIC_V8_HUF_TABLE)->getData());
 
-  PanasonicV8Decompressor v8(mRaw, b.getDecompressorParams(),
-                             getAsArray1DRef(mDecoderLUT));
+  PanasonicV8Decompressor v8(mRaw, b.getDecompressorParams());
   mRaw->createData();
   v8.decompress();
   return mRaw;

src/librawspeed/decompressors/PanasonicV8Decompressor.cpp

@@ -25,6 +25,8 @@
 #include "adt/Array1DRef.h"
 #include "adt/Array1DRefExtras.h"
 #include "adt/Array2DRef.h"
+#include "adt/Bit.h"
+#include "adt/Casts.h"
 #include "adt/CroppedArray2DRef.h"
 #include "adt/Invariant.h"
 #include "adt/Point.h"
@@ -39,9 +41,11 @@
 #include "common/RawImage.h"
 #include "common/RawspeedException.h"
 #include "decoders/RawDecoderException.h"
+#include "io/ByteStream.h"
 #include "io/IOException.h"
 #include <algorithm>
 #include <array>
+#include <cassert>
 #include <climits>
 #include <cstddef>
 #include <cstdint>
@@ -218,6 +222,63 @@ int minBitsPerPixelNeeded(
 
 } // namespace
 
+std::vector<PanasonicV8Decompressor::DecoderLUTEntry>
+PanasonicV8Decompressor::DecompressorParamsBuilder::getDecoderLUT(
+    ByteStream stream) {
+  std::vector<PanasonicV8Decompressor::DecoderLUTEntry> mDecoderLUT;
+
+  const auto numSymbols = stream.getU16();
+  if (numSymbols < 1 || numSymbols > 17)
+    ThrowRDE("Unexpected number of symbols: %u", numSymbols);
+
+  struct Entry {
+    uint8_t bitcount;
+    uint16_t symbol, mask;
+    uint8_t codeValue;
+  };
+  std::vector<Entry> table;
+  table.reserve(numSymbols);
+
+  for (unsigned symbolIndex = 0; symbolIndex != numSymbols; ++symbolIndex) {
+    const auto len = stream.getU16(); // Number of bits in symbol
+    if (len < 1 || len > 16)
+      ThrowRDE("Unexpected symbol length");
+    const auto code = stream.getU16();
+    if (!isIntN<uint32_t>(code, len))
+      ThrowRDE("Bad symbol code");
+    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::DecoderLUTEntry().bitcount &&
+        entry.codeValue == PanasonicV8Decompressor::DecoderLUTEntry().diffCat)
+      ThrowRDE("Sentinel symbol encountered");
+    table.emplace_back(entry);
+  }
+  assert(table.size() == numSymbols);
+
+  // 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
+  // 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;
+        break; // NOTE: not a prefix code!
+      }
+    }
+  }
+
+  return mDecoderLUT;
+}
+
 std::vector<iRectangle2D>
 PanasonicV8Decompressor::DecompressorParamsBuilder::getOutRects(
     iRectangle2D imgDim, Array1DRef<const uint32_t> stripLineOffsets,
@@ -256,19 +317,17 @@ PanasonicV8Decompressor::DecompressorParamsBuilder::getOutRects(
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-PanasonicV8Decompressor::PanasonicV8Decompressor(
-    RawImage outputImg, DecompressorParams mParams_,
-    Array1DRef<const DecoderLUTEntry> mHDecoderLUT_)
-    : mRawOutput(std::move(outputImg)), mParams(std::move(mParams_)),
-      mDecoderLUT(mHDecoderLUT_) {
+PanasonicV8Decompressor::PanasonicV8Decompressor(RawImage outputImg,
+                                                 DecompressorParams mParams_)
+    : mRawOutput(std::move(outputImg)), mParams(std::move(mParams_)) {
   if (mRawOutput->getCpp() != 1 ||
       mRawOutput->getDataType() != RawImageType::UINT16 ||
       mRawOutput->getBpp() != sizeof(uint16_t)) {
     ThrowRDE("Unexpected component count / data type");
   }
   if (!mRawOutput->dim.hasPositiveArea())
     ThrowRDE("Unexpected image dimensions");
-  const auto minBpp = minBitsPerPixelNeeded(mDecoderLUT);
+  const auto minBpp = minBitsPerPixelNeeded(mParams.mDecoderLUT);
   for (int stripIdx = 0; stripIdx < mParams.mStrips.size(); ++stripIdx) {
     const auto strip = mParams.mStrips(stripIdx);
     const auto maxPixelsInStrip = (uint64_t{CHAR_BIT} * strip.size()) / minBpp;
@@ -300,7 +359,7 @@ void PanasonicV8Decompressor::decompress() const {
                            /*croppedHeight=*/outRect.dim.y)
                            .getAsArray2DRef();
 
-      InternalDecoder decoder(mDecoderLUT, strip);
+      InternalDecoder decoder(mParams.mDecoderLUT, strip);
 
       decompressStrip(out, decoder);
     } catch (const RawspeedException& err) {

src/librawspeed/decompressors/PanasonicV8Decompressor.h

@@ -29,6 +29,7 @@
 #include "common/RawImage.h"
 #include "decoders/RawDecoderException.h"
 #include "decompressors/AbstractDecompressor.h"
+#include "io/ByteStream.h"
 #include <array>
 #include <cstdint>
 #include <vector>
@@ -52,14 +53,25 @@ class PanasonicV8Decompressor final : public AbstractDecompressor {
   /// Four values, one for each component of the sensor's color filter array.
   using Bayer2x2 = std::array<uint16_t, 4>;
 
+  // Pre-cached decoded values for rapid lookup.
+  struct DecoderLUTEntry {
+    uint8_t bitcount = 7;
+    uint8_t diffCat = 0;
+
+    [[nodiscard]] bool isSentinel() const {
+      constexpr auto sentinel = DecoderLUTEntry();
+      return bitcount == sentinel.bitcount && diffCat == sentinel.diffCat;
+    }
+  };
+
   /// Decompressor parameters populated from tags. They remain constant after
   /// construction.
   struct DecompressorParamsBuilder;
 
   struct DecompressorParams {
     const Array1DRef<const Array1DRef<const uint8_t>> mStrips;
     const Array1DRef<const iRectangle2D> mOutRect;
-
+    const Array1DRef<const DecoderLUTEntry> mDecoderLUT;
     const Bayer2x2 initialPrediction;
 
     DecompressorParams() = delete;
@@ -69,29 +81,36 @@ class PanasonicV8Decompressor final : public AbstractDecompressor {
 
     DecompressorParams(Array1DRef<const Array1DRef<const uint8_t>> mStrips_,
                        Array1DRef<const iRectangle2D> mOutRect_,
+                       Array1DRef<const DecoderLUTEntry> mDecoderLUT_,
                        Bayer2x2 initialPrediction_)
-        : mStrips(mStrips_), mOutRect(mOutRect_),
+        : mStrips(mStrips_), mOutRect(mOutRect_), mDecoderLUT(mDecoderLUT_),
           initialPrediction(initialPrediction_) {}
   };
 
   struct DecompressorParamsBuilder {
+    const std::vector<PanasonicV8Decompressor::DecoderLUTEntry> mDecoderLUT;
     const Array1DRef<const Array1DRef<const uint8_t>> mStrips;
     const Bayer2x2 initialPrediction;
 
     const std::vector<iRectangle2D> mOutRects;
 
+    std::vector<PanasonicV8Decompressor::DecoderLUTEntry> static getDecoderLUT(
+        ByteStream bs);
+
     std::vector<iRectangle2D> static getOutRects(
         iRectangle2D imgDim, Array1DRef<const uint32_t> stripLineOffsets,
         Array1DRef<const uint16_t> stripWidths,
         Array1DRef<const uint16_t> stripHeights);
 
+    // NOLINTNEXTLINE(readability-function-size)
     DecompressorParamsBuilder(
         iRectangle2D imgDim, Bayer2x2 initialPrediction_,
         Array1DRef<const Array1DRef<const uint8_t>> mStrips_,
         Array1DRef<const uint32_t> stripLineOffsets,
         Array1DRef<const uint16_t> stripWidths,
-        Array1DRef<const uint16_t> stripHeights)
-        : mStrips(mStrips_), initialPrediction(initialPrediction_),
+        Array1DRef<const uint16_t> stripHeights, ByteStream defineCodes)
+        : mDecoderLUT(getDecoderLUT(defineCodes)), mStrips(mStrips_),
+          initialPrediction(initialPrediction_),
           mOutRects(getOutRects(imgDim, stripLineOffsets, stripWidths,
                                 stripHeights)) {
       if (mStrips.size() != implicit_cast<int>(mOutRects.size()))
@@ -103,24 +122,13 @@ class PanasonicV8Decompressor final : public AbstractDecompressor {
     }
 
     [[nodiscard]] DecompressorParams getDecompressorParams() const {
-      return {mStrips, getAsArray1DRef(mOutRects), initialPrediction};
-    }
-  };
-
-  // Pre-cached decoded values for rapid lookup.
-  struct DecoderLUTEntry {
-    uint8_t bitcount = 7;
-    uint8_t diffCat = 0;
-
-    [[nodiscard]] bool isSentinel() const {
-      constexpr auto sentinel = DecoderLUTEntry();
-      return bitcount == sentinel.bitcount && diffCat == sentinel.diffCat;
+      return {mStrips, getAsArray1DRef(mOutRects), getAsArray1DRef(mDecoderLUT),
+              initialPrediction};
     }
   };
 
 private:
   const DecompressorParams mParams;
-  const Array1DRef<const DecoderLUTEntry> mDecoderLUT;
 
   /// Decoder helper class. Defined only in the cpp file.
   class InternalDecoder;
@@ -130,8 +138,7 @@ class PanasonicV8Decompressor final : public AbstractDecompressor {
   void decompressStrip(Array2DRef<uint16_t> out, InternalDecoder decoder) const;
 
 public:
-  PanasonicV8Decompressor(RawImage outputImg, DecompressorParams mParams_,
-                          Array1DRef<const DecoderLUTEntry> mDecoderLUT_);
+  PanasonicV8Decompressor(RawImage outputImg, DecompressorParams mParams_);
 
   /// Run the decompressor on the provided raw image
   void decompress() const;