TLMMarker.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 <vector>
#include <span> // C++20
 
namespace grk
{

template<typename T>
struct TilePartLength
{
  TilePartLength(uint16_t tileIndex, T len) : tileIndex_(tileIndex), length_(len) {}
 
  uint16_t tileIndex_;
 
  T length_;
};

class TLMMarkerManager
{
  using TL_VEC = std::vector<TilePartLength<uint32_t>>;
 
public:
  TLMMarkerManager()
      : tilePartLengthsIter_(), // Default-initialized iterator (invalid until tilePartLengths_
                                // exists)
        lastMarkerId_(-1), valid_(true)
  {}

  void push_back(TilePartLength<uint32_t> tilePartLength)
  {
    if(!valid_)
      return;
 
    // push tile part length
    if(!tilePartLengths_)
    {
      tilePartLengths_ = std::make_unique<TL_VEC>();
      tilePartLengthsIter_ =
          tilePartLengths_->begin(); // Set to begin (empty vector’s begin == end)
    }
    tilePartLengths_->push_back(tilePartLength);
  }

  void reset() noexcept
  {
    if(tilePartLengths_)
      tilePartLengthsIter_ = tilePartLengths_->begin();
  }

  TilePartLength<uint32_t>* next(bool peek = false) noexcept
  {
    if(!valid_ || !tilePartLengths_ || tilePartLengthsIter_ == tilePartLengths_->end())
      return nullptr;
 
    auto result = &(*tilePartLengthsIter_);
    if(!peek)
      ++tilePartLengthsIter_;
 
    return result;
  }

  [[nodiscard]] bool empty() const noexcept
  {
    return !tilePartLengths_ || tilePartLengths_->empty();
  }

  [[nodiscard]] bool validateMarkerId(uint8_t markerId) noexcept
  {
    if(!valid_)
      return false;
    if(markerId <= lastMarkerId_)
    {
      grklog.warn("TLM: marker id %d is greater than last marker id %d. Disabling TLM.", markerId,
                  lastMarkerId_);
      valid_ = false;
      return false;
    }
    lastMarkerId_ = (int32_t)markerId;
    return true;
  }
 
private:
  std::unique_ptr<TL_VEC> tilePartLengths_;

  TL_VEC::iterator tilePartLengthsIter_;

  int32_t lastMarkerId_;

  bool valid_;
};

struct TLMMarker
{
  explicit TLMMarker(uint16_t numSignalledTiles);

  TLMMarker(const std::string& filePath, uint16_t numSignalledTiles, uint64_t tileStreamStart);

  explicit TLMMarker(IStream* stream);

  ~TLMMarker() = default;

  bool read(std::span<uint8_t> headerData, uint16_t headerSize);

  void rewind() noexcept;

  uint8_t getNumTileParts(uint16_t tileIndex) const noexcept;

  TilePartLength<uint32_t>* next(bool peek);

  void invalidate() noexcept;

  [[nodiscard]] bool valid() const noexcept;

  void seekNextSlated(TileWindow* tilesToDecompress, TileCache* tileCache, IStream* stream);

  bool writeBegin(uint32_t numTilePartsTotal);

  void add(TilePartLength<uint32_t> info);

  void add(uint16_t tile_index, uint32_t tile_part_size) noexcept;

  bool writeEnd();

  void readComplete(uint64_t tileStreamStart) noexcept;
 
  const TPSEQ_VEC& getTileParts(void) const;
 
private:
  std::unique_ptr<TLMMarkerManager> markerManager_;

  TPSEQ_VEC tilePartsPerTile_;

  IStream* stream_ = nullptr;

  uint64_t streamStart = 0;

  bool valid_ = true;

  bool hasTileIndices_ = false;

  uint16_t tileCount_ = 0;

  uint16_t numSignalledTiles_ = 0;

  uint64_t tilePartStart_ = 0;
 
  std::string filePath_;
};
 
} // namespace grk