PacketParser: simplify

Author: Grok Compression

src/lib/core/t2/PacketParser.cpp

@@ -23,12 +23,11 @@ namespace grk
 PacketParser::PacketParser(TileProcessor* tileProcessor, uint16_t packetSequenceNumber,
                            uint16_t compno, uint8_t resno, uint64_t precinctIndex, uint16_t layno,
                            uint32_t plLength, SparseBuffer* compressedPackets)
-    : tileProcessor_(tileProcessor), packetSequenceNumber_(packetSequenceNumber), compno_(compno),
-      resno_(resno), precinctIndex_(precinctIndex), layno_(layno), packets_(compressedPackets),
+    : tileProcessor_(tileProcessor), tileIndex_(tileProcessor->getIndex()),
+      packetSequenceNumber_(packetSequenceNumber), compno_(compno), resno_(resno),
+      precinctIndex_(precinctIndex), layno_(layno), packets_(compressedPackets),
       layerData_(compressedPackets->chunkPtr()),
-      layerBytesAvailable_(compressedPackets->chunkLength()), tagBitsPresent_(false),
-      headerLength_(0), signalledLayerDataBytes_(0), plLength_(plLength), parsedHeader_(false),
-      headerError_(false)
+      layerBytesAvailable_(compressedPackets->chunkLength()), plLength_(plLength)
 {}
 void PacketParser::print(void)
 {
@@ -98,14 +97,13 @@ uint32_t PacketParser::readHeader(void)
   auto cp = tileProcessor_->getCodingParams();
   if(cp->ppmMarkers_)
   {
-    if(tileProcessor_->getIndex() >= cp->ppmMarkers_->packetHeaders.size())
+    if(tileIndex_ >= cp->ppmMarkers_->packetHeaders.size())
     {
-      grklog.error("PPM marker has no packed packet header data for tile %u",
-                   tileProcessor_->getIndex() + 1);
+      grklog.error("PPM marker has no packed packet header data for tile %u", tileIndex_ + 1);
       headerError_ = true;
       throw t1::CorruptPacketHeaderException();
     }
-    auto header = &cp->ppmMarkers_->packetHeaders[tileProcessor_->getIndex()];
+    auto header = &cp->ppmMarkers_->packetHeaders[tileIndex_];
     headerStart = header->ptr_to_buf();
     remainingBytes = header->num_elts_ptr();
   }
@@ -152,7 +150,7 @@ uint32_t PacketParser::readHeader(void)
             incl->decode(bio.get(), cblkno, layno_ + 1, &value);
             if(value != incl->getUninitializedValue() && value != layno_)
             {
-              grklog.warn("Tile number: %u", tileProcessor_->getIndex() + 1);
+              grklog.warn("Tile number: %u", tileIndex_ + 1);
               std::string msg = "Corrupt inclusion tag tree found when decoding packet header.";
               grklog.warn("%s", msg.c_str());
               throw t1::CorruptPacketHeaderException();

src/lib/core/t2/PacketParser.h

@@ -86,78 +86,80 @@ class PacketParser
    */
   TileProcessor* tileProcessor_;
 
+  uint16_t tileIndex_ = 0;
+
   /**
    * @brief packet sequence number
    *
    * This is the generated packet sequence number. We compare to the signalled
    * sequence number to detect pack stream corruption
    */
-  uint16_t packetSequenceNumber_;
+  uint16_t packetSequenceNumber_ = 0;
 
   /**
    * @brief component number
    */
-  uint16_t compno_;
+  uint16_t compno_ = 0;
 
   /**
    * @brief resolution number
    */
-  uint8_t resno_;
+  uint8_t resno_ = 0;
 
   /**
    * @brief precinct index
    */
-  uint64_t precinctIndex_;
+  uint64_t precinctIndex_ = 0;
 
   /**
    * @brief layer number
    */
-  uint16_t layno_;
+  uint16_t layno_ = 0;
 
   /**
    * @brief @ref SparseBuffer of all packets
    */
-  SparseBuffer* packets_;
+  SparseBuffer* packets_ = nullptr;
 
   /**
    * @brief packets_ current chunk pointer aka layer data
    */
-  uint8_t* layerData_;
+  uint8_t* layerData_ = nullptr;
 
   /**
    * @brief all available bytes in layer (includes packet header and data)
    */
-  size_t layerBytesAvailable_;
+  size_t layerBytesAvailable_ = 0;
 
   /**
    * @brief true if tag bits present in packet header
    */
-  bool tagBitsPresent_;
+  bool tagBitsPresent_ = false;
 
   /**
    * @brief packet header length - does not include packed header bytes
    */
-  uint32_t headerLength_;
+  uint32_t headerLength_ = 0;
 
   /**
    * @brief length of packet data as signalled in packet header
    */
-  uint32_t signalledLayerDataBytes_;
+  uint32_t signalledLayerDataBytes_ = 0;
 
   /**
    * @brief total packet length as signalled in marker (PLT/PLM)
    */
-  uint32_t plLength_;
+  uint32_t plLength_ = 0;
 
   /**
    * @brief true if header has been parsed
    */
-  bool parsedHeader_;
+  bool parsedHeader_ = false;
 
   /**
    * @brief true of there was an error reading the header
    */
-  bool headerError_;
+  bool headerError_ = false;
 };
 
 /**
@@ -259,6 +261,7 @@ struct AllLayersPrecinctPacketParser
    * @brief @ref TileProcessor
    */
   TileProcessor* tileProcessor_;
+
   /**
    * @brief Queue of @ref PacketParser
    */