ITileProcessor.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
{
 
struct TilePartInfo
{
  uint32_t tilePartLength_ = 0;
  uint8_t tilePart_ = 0;
  uint64_t remainingTilePartBytes_ = 0;
};
 
class Mct;

struct ITileProcessor
{
  virtual ~ITileProcessor() = default;

  virtual void setProcessors(MarkerParser* parser) = 0;

  virtual bool init(void) = 0;

  virtual void setStream(IStream* stream, bool ownsStream) = 0;

  virtual bool decompressWithTLM(const std::shared_ptr<TPFetchSeq>& tilePartFetchSeq,
                                 CoderPool* streamPool, Rect32 unreducedImageBounds,
                                 std::function<void()> post, TileFutureManager& futures) = 0;

  virtual bool decompressPrepareWithTLM(const std::shared_ptr<TPFetchSeq>& tilePartFetchSeq) = 0;

  virtual bool doPostT1(void) = 0;

  virtual void prepareForDecompression(void) = 0;

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

  virtual bool decompressFromCachedTileParts() = 0;

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

  virtual void scheduleAndRunDecompress(CoderPool* coderPool, Rect32 unreducedImageBounds,
                                        std::function<void()> post, TileFutureManager& futures) = 0;

  virtual void post_decompressT2T1(GrkImage* scratch) = 0;

  virtual bool differentialUpdate(Rect32 unreducedImageBounds) = 0;

  virtual GrkImage* getImage(void) = 0;

  virtual void setImage(GrkImage* img) = 0;

  virtual Rect32 getUnreducedTileWindow(void) = 0;

  virtual TileCodingParams* getTCP(void) = 0;

  virtual uint8_t getMaxNumDecompressResolutions(void) = 0;

  virtual IStream* getStream(void) = 0;

  virtual uint16_t getIndex(void) const = 0;

  virtual void incrementIndex(void) = 0;

  virtual Tile* getTile(void) = 0;

  virtual grk_progression_state getProgressionState() = 0;

  virtual CodecScheduler* getScheduler(void) = 0;

  virtual bool isCompressor(void) = 0;

  virtual uint64_t getNumProcessedPackets(void) = 0;

  virtual void incNumProcessedPackets(void) = 0;

  virtual void incNumProcessedPackets(uint64_t numPackets) = 0;

  virtual void incNumReadDataPackets(void) = 0;

  virtual uint32_t getTileCacheStrategy(void) = 0;

  virtual grk_plugin_tile* getCurrentPluginTile(void) const = 0;

  virtual void setCurrentPluginTile(grk_plugin_tile* tile) = 0;

  virtual CodingParams* getCodingParams(void) = 0;

  virtual GrkImage* getHeaderImage(void) = 0;

  virtual std::shared_ptr<PacketLengthCache<uint32_t>> getPacketLengthCache(void) = 0;

  virtual bool needsMctDecompress(uint16_t compno) = 0;

  virtual bool needsMctDecompress(void) = 0;

  virtual bool shouldDecodeComponent(uint16_t compno) = 0;

  virtual Mct* getMCT(void) = 0;

  virtual void release(void) = 0;

  virtual void release(uint32_t strategy) = 0;

  virtual void releaseForSwath() = 0;

  virtual bool readPLT(uint8_t* headerData, uint16_t headerSize) = 0;

  virtual bool allSOTMarkersParsed() = 0;

  virtual bool hasUnparsedTileParts() = 0;

  virtual void resetSOTParsing() = 0;

  virtual void setTruncated(void) = 0;

  virtual bool hasError(void) = 0;

  virtual bool isInitialized(void) = 0;

  virtual bool isBestEffortDecompressed(void) = 0;
  virtual void setBestEffortDecompressed(void) = 0;
 
  virtual bool scheduledForDecompression(void) = 0;

  virtual bool reinitForReDecompress(void) = 0;

  virtual bool isStripOutputWritten() const = 0;
};
 
} // namespace grk