TileProcessor.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 <mutex>
#include <memory>
 
#include "PacketTracker.h"
#include "ITileProcessor.h"
 
namespace grk
{
 
class SchedulerFreebyrd;

struct TileProcessor : virtual public ITileProcessor
{
  TileProcessor(uint16_t index, TileCodingParams* tcp, CodeStream* codeStream, IStream* stream,
                bool isCompressor, uint32_t tileCacheStrategy);

  virtual ~TileProcessor() override;
 
  void setProcessors(MarkerParser* parser) override;

  virtual bool init(void) override;
 
  void setStream(IStream* stream, bool ownsStream) override;
 
  bool decompressWithTLM(const std::shared_ptr<TPFetchSeq>& tilePartFetchSeq, CoderPool* streamPool,
                         Rect32 unreducedImageBounds, std::function<void()> post,
                         TileFutureManager& futures) override;
 
  bool decompressPrepareWithTLM(const std::shared_ptr<TPFetchSeq>& tilePartFetchSeq) override;

  bool doPostT1(void) override;

  void prepareForDecompression(void) override;

  bool parseTilePart(std::vector<std::unique_ptr<MarkerParser>>* parsers, IStream* bifurcatedStream,
                     uint16_t mainMarkerId, TilePartInfo tilePartInfo) override;

  bool decompressFromCachedTileParts() override;

  bool readSOT(IStream* stream, uint8_t* headerData, uint16_t headerSize,
               TilePartInfo& tilePartInfo, bool needToReadIndexAndLength) override;

  void scheduleAndRunDecompress(CoderPool* coderPool, Rect32 unreducedImageBounds,
                                std::function<void()> post, TileFutureManager& futures) override;
  void post_decompressT2T1(GrkImage* scratch) override;

  bool differentialUpdate(Rect32 unreducedImageBounds) override;

  GrkImage* getImage(void) override;

  void setImage(GrkImage* img) override;

  Rect32 getUnreducedTileWindow(void) override;

  TileCodingParams* getTCP(void) override;

  uint8_t getMaxNumDecompressResolutions(void) override;

  IStream* getStream(void) override;

  uint16_t getIndex(void) const override;

  void incrementIndex(void) override;

  Tile* getTile(void) override;
 
  grk_progression_state getProgressionState() override;

  CodecScheduler* getScheduler(void) override;

  bool isCompressor(void) override;

  uint64_t getNumProcessedPackets(void) override;

  void incNumProcessedPackets(void) override;

  void incNumProcessedPackets(uint64_t numPackets) override;

  void incNumReadDataPackets(void) override;

  uint32_t getTileCacheStrategy(void) override;

  grk_plugin_tile* getCurrentPluginTile(void) const override;

  void setCurrentPluginTile(grk_plugin_tile* tile) override;

  CodingParams* getCodingParams(void) override;

  GrkImage* getHeaderImage(void) override;

  std::shared_ptr<PacketLengthCache<uint32_t>> getPacketLengthCache(void) override;

  bool needsMctDecompress(uint16_t compno) override;

  bool needsMctDecompress(void) override;
 
  bool shouldDecodeComponent(uint16_t compno) override;

  Mct* getMCT(void) override;

  void release(void) override;

  void release(uint32_t strategy) override;
  void releaseForSwath() override;

  bool readPLT(uint8_t* headerData, uint16_t headerSize) override;

  bool allSOTMarkersParsed() override;
  bool hasUnparsedTileParts() override;

  void setTruncated(void) override;
 
  bool hasError(void) override;
 
  bool isInitialized(void) override;
 
  bool isBestEffortDecompressed(void) override;
  void setBestEffortDecompressed(void) override;
  bool scheduledForDecompression(void) override;
  void resetSOTParsing() override;
  bool reinitForReDecompress(void) override;
  bool isStripOutputWritten() const override
  {
    return stripOutputWritten_;
  }
 
protected:
  GrkImage* headerImage_ = nullptr;

  grk_plugin_tile* current_plugin_tile_ = nullptr;

  CodingParams* cp_ = nullptr;

  std::shared_ptr<PacketLengthCache<uint32_t>> packetLengthCache_;

  Tile* tile_ = nullptr;

  uint16_t tileIndex_ = 0;

  TileCodingParams* tcp_ = nullptr;

  IStream* stream_ = nullptr;

  Mct* mct_ = nullptr;

  CodecScheduler* scheduler_ = nullptr;

  SchedulerFreebyrd* schedulerFreebyrd_ = nullptr;
 
private:
  std::vector<tf::Task> blockTasks_;
 
  bool initialized_ = false;
 
  void prepareConcurrentParsing(void);
 
  std::atomic<bool> success_ = true;
  bool concurrentFlowsStale_ = false;
 
  // Flow components for task graph scheduling.
  // rootFlow_ owns the composed DAG submitted to the executor.
  // tileHeaderParseFlow_/prepareFlow_ are populated during parsing and may
  // outlive a single submission cycle, so stale copies are kept alive until
  // the previous executor run completes (via staleParsing_).
  std::unique_ptr<FlowComponent> rootFlow_;
  std::unique_ptr<FlowComponent> tileHeaderParseFlow_;
  std::unique_ptr<FlowComponent> prepareFlow_;
  std::vector<std::unique_ptr<FlowComponent>> staleParsing_;
  std::unique_ptr<FlowComponent> t2ParseFlow_;
  std::unique_ptr<FlowComponent> allocAndScheduleFlow_;
  std::unique_ptr<FlowComponent> postDecompressFlow_;

  void deallocBuffers();

  bool createDecompressTileComponentWindows(void);

  MarkerParser* markerParser_ = nullptr;

  uint64_t numProcessedPackets_ = 0;

  std::atomic<uint64_t> numReadDataPackets_ = 0;
 
  TilePartInfo tilePartInfo_;
  uint64_t startPos_ = 0;

  uint8_t numSOTsParsed_ = 0;

  bool truncated_ = false;

  bool bestEffortDecompressed_ = false;
  bool scheduledForDecompression_ = false;

  GrkImage* image_ = nullptr;

  bool isCompressor_;

  Rect32 unreducedImageWindow_;

  uint32_t tileCacheStrategy_ = 0;
 
  void decompress_synch_plugin_with_host(void);
 
  std::shared_ptr<TPFetchSeq> tilePartFetchSeq_;
  TPSeq tilePartSeq_;
 
  std::vector<uint8_t> threadTilePart_;
  std::mutex pltMutex_;
 
  // band callback for strip-mode ImageFormat output
  grk_io_band_callback ioBandCallback_ = nullptr;
  void* ioBandUserData_ = nullptr;
  bool stripOutputWritten_ = false;
};
 
} // namespace grk