PacketParser.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 <cstdint>
#include <unordered_map>
#include <queue>
#include <optional>
 
#include "SparseBuffer.h"
 
namespace grk
{

class PacketParser
{
public:
  PacketParser(ITileProcessor* tileProcessor, uint16_t packetSequenceNumber, uint16_t compno,
               uint8_t resno, uint64_t precinctIndex, uint16_t layno, uint32_t cachedLength,
               SparseBuffer* compressedPackets);

  virtual ~PacketParser(void) = default;

  uint32_t readHeader(void);

  uint32_t getHeaderLength(void) const;
 
  void parsePacketData(void);

  void print(void);
 
private:
  void readData(void);

  void readDataFinalize(void);

  ITileProcessor* tileProcessor_;
 
  uint16_t tileIndex_ = 0;

  uint16_t packetSequenceNumber_ = 0;

  uint16_t compno_ = 0;

  uint8_t resno_ = 0;

  uint64_t precinctIndex_ = 0;

  uint16_t layno_ = 0;

  SparseBuffer* packets_ = nullptr;

  uint8_t* layerData_ = nullptr;

  size_t layerBytesAvailable_ = 0;

  bool tagBitsPresent_ = false;

  uint32_t headerLength_ = 0;

  uint32_t signalledLayerDataBytes_ = 0;

  uint32_t plLength_ = 0;

  bool parsedHeader_ = false;

  bool headerError_ = false;
};

template<typename T>
class LimitedQueue
{
public:
  LimitedQueue(std::size_t maxSize)
      : elements(std::make_unique<T*[]>(maxSize)), currentSize(0), maxSize(maxSize), popIndex(-1)
  {}

  ~LimitedQueue() = default;

  bool push(T* ptr)
  {
    if(currentSize >= maxSize)
    {
      return false; // Queue full
    }
    elements[currentSize++] = ptr; // Store pointer
    return true; // Successfully pushed
  }

  std::optional<T*> pop()
  {
    auto currentPopIndex = ++popIndex;
    if((size_t)currentPopIndex >= currentSize)
      return std::nullopt; // Queue empty
    return elements[(size_t)currentPopIndex];
  }
 
private:
  std::unique_ptr<T*[]> elements;

  size_t currentSize;

  std::size_t maxSize;

  std::atomic<int32_t> popIndex;
};

struct AllLayersPrecinctPacketParser
{
  AllLayersPrecinctPacketParser(ITileProcessor* tileProcessor);
  ~AllLayersPrecinctPacketParser(void) = default;

  void enqueue(PacketParser* parser);
  ITileProcessor* tileProcessor_;

  LimitedQueue<PacketParser> parserQueue_;
};

struct ResolutionPacketParser
{
  ResolutionPacketParser(ITileProcessor* tileProcessor);
  ~ResolutionPacketParser();

  void clearPrecinctParsers(void);

  void enqueue(uint64_t precinctIndex, PacketParser* parser);
  ITileProcessor* tileProcessor_;

  std::unordered_map<uint64_t, std::unique_ptr<AllLayersPrecinctPacketParser>>
      allLayerPrecinctParsers_;
};
 
} // namespace grk