IStream.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 "IMemAdvisor.h"
#include "IStreamWriter.h"
#include "ChunkBuffer.h"
 
namespace grk
{
 
/*src/lib/core/t1
 * Callback function prototype for zero copy read function
 */
typedef size_t (*readZeroCopyCallback)(uint8_t** buffer, size_t numBytes, void* user_data);

struct StreamCallbacks
{
  explicit StreamCallbacks(grk_stream_params* streamParams)
      : StreamCallbacks(streamParams->read_fn, nullptr, streamParams->seek_fn,
                        streamParams->write_fn)
  {}
  StreamCallbacks(grk_stream_read_fn rcb, readZeroCopyCallback zcrcb, grk_stream_seek_fn scb,
                  grk_stream_write_fn wcb)
      : readCallback_(rcb), readZeroCopyCallback_(zcrcb), seekCallback_(scb), writeCallback_(wcb)
  {}
  StreamCallbacks() : StreamCallbacks(nullptr, nullptr, nullptr, nullptr) {}
 
  grk_stream_read_fn readCallback_;
  readZeroCopyCallback readZeroCopyCallback_;
  grk_stream_seek_fn seekCallback_;
  grk_stream_write_fn writeCallback_;
};
 
class IFetcher;
 
struct IStream : public t1_t2::IStreamWriter
{
  virtual ~IStream() = default;

  virtual void setUserData(void* data, grk_stream_free_user_data_fn freeUserDataFun,
                           uint64_t len) = 0;

  virtual void setCallbacks(StreamCallbacks& callbacks) = 0;

  virtual size_t read(uint8_t* buffer, uint8_t** zero_copy_buffer, size_t len) = 0;

  virtual bool write24u(uint32_t value) = 0;

  virtual size_t writeBytes(const uint8_t* buffer, size_t len) = 0;

  virtual bool flush() = 0;

  virtual bool skip(int64_t len) = 0;
  virtual uint64_t tell(void) = 0;
  virtual uint64_t numBytesLeft(void) = 0;
  virtual bool seek(uint64_t offset) = 0;

  virtual bool hasSeek() = 0;

  virtual bool supportsZeroCopy() = 0;

  virtual void setFormat(GRK_CODEC_FORMAT format) = 0;

  virtual GRK_CODEC_FORMAT getFormat(void) = 0;

  virtual uint8_t* currPtr(void) = 0;

  virtual bool isMemStream() = 0;

  virtual IFetcher* getFetcher(void) = 0;
 
  virtual IStream* bifurcate(void) = 0;
 
  virtual void setChunkBuffer(std::shared_ptr<ChunkBuffer<>> chunkBuffer) = 0;
 
  virtual void memAdvise(size_t virtual_offset, size_t length, GrkAccessPattern pattern) = 0;
};
 
} // namespace grk