PacketManager.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
 
namespace grk
{
constexpr size_t GRK_INCLUDE_TRACKER_CHUNK_SIZE = 1024;

struct LayerIncludeBuffers
{
  LayerIncludeBuffers()
  {
    for(uint8_t i = 0; i < GRK_MAXRLVLS; ++i)
      chunkMap[i] = nullptr; // Buffers start as nullptr
  }

  ~LayerIncludeBuffers()
  {
    clear();
  }

  bool update(uint8_t resno, uint64_t bitIndex)
  {
    if(resno >= GRK_MAXRLVLS)
      throw std::out_of_range("Resolution index out of range");
 
    if(!chunkMap[resno])
      chunkMap[resno] = new std::unordered_map<size_t, uint8_t*>(); // Lazily allocate the map
 
    auto& chunks = *chunkMap[resno];
    uint64_t byteIndex = bitIndex >> 3; // Byte index within the resolution's buffer
    uint64_t chunkIndex =
        byteIndex / GRK_INCLUDE_TRACKER_CHUNK_SIZE; // Determine which chunk to access
    uint64_t chunkOffset = byteIndex % GRK_INCLUDE_TRACKER_CHUNK_SIZE; // Offset within the chunk
 
    // Lazily allocate the chunk
    if(!chunks.contains(chunkIndex))
      chunks[chunkIndex] = new uint8_t[GRK_INCLUDE_TRACKER_CHUNK_SIZE](); // Allocate chunk lazily
 
    auto include = chunks[chunkIndex] + chunkOffset;
    uint8_t bit = (bitIndex & 7);
    uint8_t val = *include;
    if(((val >> bit) & 1) == 0)
    {
      *include = (uint8_t)(val | (1 << bit));
      return true;
    }
 
    return false;
  }

  void clear()
  {
    for(uint8_t i = 0; i < GRK_MAXRLVLS; ++i)
    {
      if(chunkMap[i])
      {
        for(auto& chunk : *chunkMap[i])
          delete[] chunk.second; // Delete each chunk
        delete chunkMap[i]; // Delete the map
        chunkMap[i] = nullptr;
      }
    }
  }
 
private:
  std::unordered_map<size_t, uint8_t*>* chunkMap[GRK_MAXRLVLS];
};
 
struct IncludeTracker
{
  IncludeTracker(void)
      : currentLayer(0), currentLayerIncludeBuf(nullptr),
        include(new std::unordered_map<uint16_t, LayerIncludeBuffers*>())
  {
    resetNumPrecinctsPerRes();
  }
 
  ~IncludeTracker()
  {
    clear();
    delete include;
  }
 
  bool update(uint16_t layno, uint8_t resno, uint16_t compno, uint64_t precno)
  {
    LayerIncludeBuffers* layerBuf = nullptr;
 
    // Retrieve or create the ResIncludeBuffers for the current layer
    if(layno == currentLayer && currentLayerIncludeBuf)
    {
      layerBuf = currentLayerIncludeBuf;
    }
    else
    {
      if(include->find(layno) == include->end())
        include->operator[](layno) = layerBuf = new LayerIncludeBuffers;
      else
        layerBuf = include->operator[](layno);
      currentLayerIncludeBuf = layerBuf;
      currentLayer = layno;
    }
 
    // Calculate the index in bits
    auto numprecs = numPrecinctsPerRes[resno];
    uint64_t bitIndex = compno * numprecs + precno;
 
    return layerBuf->update(resno, bitIndex);
  }
 
  void clear()
  {
    for(auto it = include->begin(); it != include->end(); ++it)
      delete it->second;
    include->clear();
  }
 
  void resetNumPrecinctsPerRes(void)
  {
    for(uint8_t i = 0; i < GRK_MAXRLVLS; ++i)
      numPrecinctsPerRes[i] = 0;
  }
 
  void updateNumPrecinctsPerRes(uint8_t resno, uint64_t numPrecincts)
  {
    if(numPrecincts > numPrecinctsPerRes[resno])
      numPrecinctsPerRes[resno] = numPrecincts;
  }
 
private:
  uint64_t numPrecinctsPerRes[GRK_MAXRLVLS];
  uint16_t currentLayer;
  LayerIncludeBuffers* currentLayerIncludeBuf;
  std::unordered_map<uint16_t, LayerIncludeBuffers*>* include;
};
 
class PacketManager
{
public:
  PacketManager(bool compression, GrkImage* img, CodingParams* cparams, uint16_t tilenumber,
                T2_MODE t2_mode, ITileProcessor* tileProc);
  virtual ~PacketManager();
  PacketIter* getPacketIter(uint32_t poc) const;
  void enable_tile_part_generation(uint32_t prog_iter_num, bool first_poc_tile_part,
                                   uint8_t newTilePartProgressionPosition);
  static void updateCompressParams(const GrkImage* image, CodingParams* p_cp, TileCodingParams* tcp,
                                   uint16_t tile_no);
 
  IncludeTracker* getIncludeTracker(void);
  uint32_t getNumProgressions(void);
  ITileProcessor* getTileProcessor(void);
  GrkImage* getImage();
  Rect32 getTileBounds(void);
  CodingParams* getCodingParams(void);
  T2_MODE getT2Mode(void);
 
private:
  static void updateCompressTcpProgressions(TileCodingParams* tcp, uint16_t num_comps,
                                            Rect32 tileBounds, uint64_t max_precincts,
                                            uint8_t max_res, uint32_t dx_min, uint32_t dy_min,
                                            bool poc);
  static void getParams(const GrkImage* image, CodingParams* p_cp, TileCodingParams* tcp,
                        uint16_t tileno, Rect32* tileBounds, uint32_t* dx_min, uint32_t* dy_min,
                        IncludeTracker* includeTracker, uint64_t* max_precincts, uint8_t* max_res,
                        uint32_t** componentPrecinctInfo);
  GrkImage* image_;
  CodingParams* cp_;
  uint16_t tileIndex_;
  IncludeTracker* includeTracker_;
  PacketIter* pi_;
  T2_MODE t2Mode_;
  ITileProcessor* tileProcessor_;
  Rect32 tileBounds_;
};
 
} // namespace grk