CodingParams.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 <memory>
#include <mutex>
 
#include "PacketCache.h"
 
namespace grk
{
 
typedef void (*mct_function)(const void* p_src_data, void* p_dest_data, uint64_t nb_elem);
enum MCT_ELEMENT_TYPE
{
  MCT_TYPE_INT16 = 0, 
  MCT_TYPE_INT32 = 1, 
  MCT_TYPE_FLOAT = 2, 
  MCT_TYPE_DOUBLE = 3 
};

enum MCT_ARRAY_TYPE
{
  MCT_TYPE_DEPENDENCY = 0,
  MCT_TYPE_DECORRELATION = 1,
  MCT_TYPE_OFFSET = 2
};

struct TileComponentCodingParams
{
  TileComponentCodingParams();
  uint8_t csty_;
  uint8_t numresolutions_;
  uint8_t cblkw_expn_;
  uint8_t cblkh_expn_;
  uint8_t cblkStyle_;
  uint8_t qmfbid_;
  // true if quantization marker has been read for this component,
  // false otherwise
  bool quantizationMarkerSet_;
  // true if quantization marker was read from QCC otherwise false
  bool fromQCC_;
  // true if quantization marker was read from tile header
  bool fromTileHeader_;
  uint8_t qntsty_;
  grk_stepsize stepsizes_[GRK_MAXBANDS];
  // number of step sizes read from QCC marker
  uint8_t numStepSizes_;
  uint8_t numgbits_;
  uint8_t roishift_;
  uint8_t precWidthExp_[GRK_MAXRLVLS];
  uint8_t precHeightExp_[GRK_MAXRLVLS];
  int32_t dcLevelShift_;
};

struct grk_mct_data
{
  MCT_ELEMENT_TYPE element_type_;
  MCT_ARRAY_TYPE array_type_;
  uint32_t index_;
  uint8_t* data_;
  uint32_t data_size_;
};

struct grk_simple_mcc_decorrelation_data
{
  uint32_t index_;
  uint32_t nb_comps_;
  grk_mct_data* decorrelation_array_;
  grk_mct_data* offset_array_;
  uint32_t is_irreversible_ : 1;
};

struct TileCodingParams
{
  explicit TileCodingParams(CodingParams* cp);
  TileCodingParams(const TileCodingParams& rhs);
  TileCodingParams& operator=(const TileCodingParams&) = delete;
  ~TileCodingParams();
 
  bool advanceTilePartCounter(uint16_t tileIndex, uint8_t tilePartIndex);
  bool initDefault(GrkImage* headerImage);

  bool readPpt(uint8_t* headerData, uint16_t headerSize);

  bool mergePpt(void);

  bool readSPCodSPCoc(uint16_t compno, uint8_t* headerData, uint16_t* headerSize);

  bool readSQcdSQcc(bool fromTileHeader, bool fromQCC, uint16_t compno, uint8_t* headerData,
                    uint16_t* headerSize);

  bool readCod(uint8_t* headerData, uint16_t headerSize);

  bool readCoc(uint8_t* headerData, uint16_t headerSize);

  bool readQcd(bool fromTileHeader, uint8_t* headerData, uint16_t headerSize);

  bool readQcc(bool fromTileHeader, uint8_t* headerData, uint16_t headerSize);

  bool readRgn(uint8_t* headerData, uint16_t headerSize);

  bool readPoc(uint8_t* headerData, uint16_t headerSize, int tilePartIndex);

  bool readMct(uint8_t* headerData, uint16_t headerSize);

  bool readMco(uint8_t* headerData, uint16_t headerSize);

  bool readMcc(uint8_t* headerData, uint16_t headerSize);
 
  bool addMct(uint32_t index);
 
  void updateLayersToDecompress(void);
 
  bool validateQuantization(void);
 
  void setIsHT(bool ht, bool reversible, uint8_t guardBits);
  bool isHT(void);
  uint32_t getNumProgressions(void);
  bool hasPoc(void);
  void finalizePocs(void);
 
  CodingParams* cp_ = nullptr;
 
  bool wholeTileDecompress_ = true;

  uint8_t csty_ = 0;
  GRK_PROG_ORDER prg_ = GRK_PROG_UNKNOWN;
  uint16_t numLayers_ = 0;
  /* layers slated for decompression */
  uint16_t layersToDecompress_ = 0;
  uint8_t mct_ = 0;
  double rates_[maxCompressLayersGRK];
  uint32_t numpocs_ = 0;
  grk_progression progressionOrderChange_[GRK_MAXRLVLS];
  uint32_t pptMarkersCount_ = 0;
  grk_ppx* pptMarkers_ = nullptr;
  uint8_t* pptData_ = nullptr;
  uint8_t* pptBuffer_ = nullptr;
  size_t pptLength_ = 0;
  double distortion_[maxCompressLayersGRK];
  // quantization style as read from main QCD marker
  uint32_t mainQcdQntsty = 0;
  // number of step sizes as read from main QCD marker
  uint32_t mainQcdNumStepSizes = 0;
  TileComponentCodingParams* tccps_ = nullptr;
  // tile part counter
  // NOTES: tile parts must appear in code stream in strictly increasing
  // order
  uint8_t tilePartCounter_ = 0;
  uint8_t signalledNumTileParts_ = 0;
  // packets
  PacketCache* packets_ = nullptr;
  double* mct_norms_ = nullptr;
  float* mctDecodingMatrix_ = nullptr;
  float* mctCodingMatrix_ = nullptr;
  grk_mct_data* mctRecords_ = nullptr;
  uint32_t numMctRecords_ = 0;
  uint32_t numMaxMctRecords_ = 0;
  grk_simple_mcc_decorrelation_data* mccRecords_ = nullptr;
  uint32_t numMccRecords_ = 0;
  uint32_t numMaxMccRecords_ = 0;
  uint32_t cod_ = 0;
  bool ppt_ = false;
  Quantizer* qcd_ = nullptr;
  uint16_t numComps_ = 0;
 
private:
  bool ht_ = false;
  std::mutex pocMutex_;
  std::vector<std::vector<grk_progression>> pocLists_;
};
 
struct EncodingParams
{
  size_t maxComponentRate_;
  uint8_t newTilePartProgressionPosition_;
  uint8_t newTilePartProgressionDivider_;
  bool allocationByRateDistortion_;
  bool allocationByFixedQuality_;
  bool enableTilePartGeneration_;
  /* write plt marker */
  bool writePlt_;
  /* write TLM marker */
  bool writeTlm_;
  /* rate control algorithm */
  uint32_t rateControlAlgorithm_;
};
 
struct DecodingParams
{
  uint8_t reduce_;
  uint16_t layersToDecompress_;
  uint32_t disableRandomAccessFlags_;
  bool skipAllocateComposite_;
  bool fast16BitMct_;
};
 
struct TLMMarker;
 
class TileCodingParamsPool
{
public:
  TileCodingParamsPool() = default;
 
  TileCodingParams* get(uint16_t tileIndex)
  {
    std::unique_lock<std::mutex> lock(mutex_);
    auto it = tileMap_.find(tileIndex);
 
    if(it == tileMap_.end()) // Check if tile exists
    {
      auto tcp = std::make_unique<TileCodingParams>(nullptr);
      it = tileMap_.emplace(tileIndex, std::move(tcp)).first;
    }
    return it->second.get(); // Return raw pointer
  }
 
private:
  std::unordered_map<uint16_t, std::unique_ptr<TileCodingParams>> tileMap_;
  mutable std::mutex mutex_; // Mutex for thread safety
};
 
class TileCache;

struct CodingParams
{
  CodingParams();
  ~CodingParams();
  Rect32 getTileBounds(Rect32 imageBounds, uint16_t tile_x, uint16_t tile_y) const;

  bool readCom(uint8_t* headerData, uint16_t headerSize);

  uint8_t getNumTilePartsFromTLM(uint16_t tileIndex) const noexcept;
 
  bool hasTLM(void) const noexcept;
 
  void init(grk_decompress_parameters* parameters, std::unique_ptr<TileCache>& tileCache);
 
  uint16_t rsiz_; 
  uint32_t pcap_; /* Pcap */
  uint16_t ccap_[32]; /* Ccap */
  uint32_t tx0_; 
  uint32_t ty0_; 
  uint32_t t_width_; 
  uint32_t t_height_; 
  std::mutex commentMutex;
  size_t numComments_; 
  char* comment_[GRK_NUM_COMMENTS_SUPPORTED];
  uint16_t commentLength_[GRK_NUM_COMMENTS_SUPPORTED];
  bool isBinaryComment_[GRK_NUM_COMMENTS_SUPPORTED];
  uint16_t t_grid_width_; 
  uint16_t t_grid_height_; 
 
  double dw_x0 = 0; /* decompress window left boundary*/
  double dw_x1 = 0; /* decompress window right boundary*/
  double dw_y0 = 0; /* decompress window top boundary*/
  double dw_y1 = 0; /* decompress window bottom boundary*/
  std::unique_ptr<PPMMarker> ppmMarkers_;
  TileCodingParamsPool tcps_; 
  union
  {
    DecodingParams dec_;
    EncodingParams enc_;
  } codingParams_;
  std::vector<uint16_t> compsToDecompress_;
  std::unique_ptr<TLMMarker> tlmMarkers_;
  std::unique_ptr<PLMarker> plmMarkers_;
  bool asynchronous_;
  bool simulate_synchronous_;
  grk_decompress_callback decompressCallback_;
  void* decompressCallbackUserData_;
  /* packet info recording for transcode (PLT, SOP/EPH, filtering, reorder) */
  struct RecordedPacketInfo
  {
    uint16_t compno;
    uint8_t resno;
    uint16_t layno;
    uint64_t precinctIndex;
    uint32_t totalLength; /* header + data */
    uint32_t headerLength; /* header only (for EPH injection) */
  };
  bool recordPacketLengths_ = false;
  std::vector<std::vector<RecordedPacketInfo>> recordedPacketInfo_; /* [tileIndex] → packets */
};
 
} // namespace grk