PacketIter.h

Go to the documentation of this file.

/*
 *    Copyright (C) 2016-2026 Grok Image Compression Inc.
 *
 *    This source code is free software: you can redistribute it and/or  modify
 *    it under the terms of the GNU Affero General Public License, version 3,
 *    as published by the Free Software Foundation.
 *
 *    This source code is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU Affero General Public License for more details.
 *
 *    You should have received a copy of the GNU Affero General Public License
 *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
 
#pragma once
 
#include <limits>
 
namespace grk
{
 
enum T2_MODE
{
  THRESH_CALC = 0, 
  FINAL_PASS = 1 
};

struct ResPrecinctInfo
{
  ResPrecinctInfo();

  bool init(uint8_t resno, uint8_t decompLevel, Rect32 tileBounds, uint32_t dx, uint32_t dy,
            bool windowed, Rect32 tileWindow);

  void print(void);

  uint8_t precWidthExp;
  uint8_t precHeightExp;
  uint8_t precWidthExpPRJ;
  uint8_t precHeightExpPRJ;

  uint32_t resOffsetX0PRJ;
  uint32_t resOffsetY0PRJ;

  uint64_t precWidthPRJ;
  uint64_t precWidthPRJMinusOne;
  uint64_t precHeightPRJ;
  uint64_t precHeightPRJMinusOne;

  uint64_t numPrecincts_;

  uint64_t dxPRJ;
  uint64_t dyPRJ;

  uint32_t resInPrecGridX0;
  uint32_t resInPrecGridY0;

  uint8_t resno_;
  uint8_t decompLevel_;

  Rect<uint64_t> tileBoundsPrecPRJ;
  Rect32 tileBoundsPrecGrid;

  Rect<uint64_t> winPrecPRJ;
  Rect32 winPrecGrid;

  uint64_t innerPrecincts_;
  uint64_t winPrecinctsLeft_;
  uint64_t winPrecinctsRight_;
  uint64_t winPrecinctsTop_;
  uint64_t winPrecinctsBottom_;

  bool valid;
};

struct PacketIterInfoResolution
{
  PacketIterInfoResolution();
  ~PacketIterInfoResolution();

  uint8_t precWidthExp;
  uint8_t precHeightExp;
  uint32_t precinctGridWidth;
  uint32_t precinctGridHeight;
  ResPrecinctInfo* precinctInfo;
};

struct PacketIterInfoComponent
{
  PacketIterInfoComponent();
  ~PacketIterInfoComponent();

  uint32_t dx;
  uint32_t dy;
  uint8_t numresolutions;
  PacketIterInfoResolution* resolutions;
};
 
class PacketManager;

struct PacketIter
{
  PacketIter();
  ~PacketIter();

  void init(PacketManager* packetMan, uint32_t pocIndex, TileCodingParams* tcp, Rect32 tileBounds,
            bool compression, uint8_t max_res, uint64_t max_precincts,
            uint32_t** componentPrecinctInfo);

  void printStaticState(void);

  void printDynamicState(void);

  void enable_tile_part_generation(uint32_t prog_iter_num, bool first_poc_tile_part,
                                   uint8_t newTilePartProgressionPosition);

  bool genPrecinctInfoOPT();

  void genPrecinctInfo();

  void genPrecinctInfo(PacketIterInfoComponent* comp, PacketIterInfoResolution* res,
                       uint8_t resNumber);

  uint8_t* get_include(uint16_t layerIndex);

  bool update_include(void);

  void destroy_include(void);

  bool next(SparseBuffer* compressedPackets);

  GRK_PROG_ORDER getProgression(void) const;

  uint16_t getCompno(void) const;

  uint8_t getResno(void) const;

  uint64_t getPrecinctIndex(void) const;

  uint16_t getLayno(void) const;
 
private:
  uint16_t compno = 0;
  uint8_t resno = 0;
  uint64_t precinctIndex = 0;
  uint16_t layno = 0;
  grk_progression prog;
  uint16_t numcomps = 0;
  PacketIterInfoComponent* comps = nullptr;

  uint64_t x = 0;
  uint64_t y = 0;
  uint32_t dx = 0;
  uint32_t dy = 0;
  uint32_t dxActive = 0;
  uint32_t dyActive = 0;

  void update_dxy(void);

  bool checkForRemainingValidProgression(int32_t prog, uint32_t prog_iter_num,
                                         const char* progString);
  // This packet iterator is designed so that the innermost progression
  // is only incremented before the **next** packet is processed.
  // i.e. it is not incremented before the very first packet is processed,
  // but rather before all subsequent packets are processed.
  // This flag keeps track of this state.
  bool incrementInner = false;

  PacketManager* packetManager = nullptr;
  uint8_t maxNumDecompositionResolutions = 0;
  bool singleProgression_ = false;
  bool compression_ = false;
  ResPrecinctInfo* precinctInfoOPT_ = nullptr;

  uint32_t px0grid_ = 0;
  uint32_t py0grid_ = 0;

  bool skippedLeft_ = false;

  bool genPrecinctY0Grid(ResPrecinctInfo* rpInfo);
  bool genPrecinctX0Grid(ResPrecinctInfo* rpInfo);
  void genPrecinctY0GridRPCL_OPT(ResPrecinctInfo* rpInfo);
  void genPrecinctX0GridRPCL_OPT(ResPrecinctInfo* rpInfo);
  bool genPrecinctX0GridPCRL_OPT(ResPrecinctInfo* rpInfo);
  bool genPrecinctY0GridPCRL_OPT(ResPrecinctInfo* rpInfo);
  bool precInfoCheck(ResPrecinctInfo* rpInfo);
  void generatePrecinctIndex(void);
  bool validatePrecinct(void);
  void update_dxy_for_comp(PacketIterInfoComponent* comp, bool updateActive);
  bool isWholeTile(void);

  bool next_cprl(SparseBuffer*);
  bool next_cprlOPT(SparseBuffer* compressedPackets);

  bool next_pcrl();
  bool next_pcrlOPT();

  bool next_lrcp();
  bool next_lrcpOPT();
  bool next_rlcp();
  bool next_rlcpOPT();
  bool next_rpcl(SparseBuffer*);
  bool next_rpclOPT(SparseBuffer* compressedPackets);
 
  bool skipPackets(SparseBuffer* compressedPackets, uint64_t numPackets);
};
 
} // namespace grk