Class ZstdCompressCtx

java.lang.Object
com.github.luben.zstd.AutoCloseBase
com.github.luben.zstd.ZstdCompressCtx
All Implemented Interfaces:
Closeable, AutoCloseable

public class ZstdCompressCtx extends AutoCloseBase
  • Field Details

    • nativePtr

      private long nativePtr
    • compression_dict

      private ZstdDictCompress compression_dict
  • Constructor Details

    • ZstdCompressCtx

      public ZstdCompressCtx()
      Create a context for faster compress operations One such context is required for each thread - put this in a ThreadLocal.
  • Method Details

    • init

      private void init()
    • free

      private void free()
    • doClose

      void doClose()
      Specified by:
      doClose in class AutoCloseBase
    • setLevel

      public ZstdCompressCtx setLevel(int level)
      Set compression level
      Parameters:
      level - compression level, default: Zstd.defaultCompressionLevel()
    • setLevel0

      private void setLevel0(int level)
    • setChecksum

      public ZstdCompressCtx setChecksum(boolean checksumFlag)
      Enable or disable compression checksums
      Parameters:
      checksumFlag - A 32-bits checksum of content is written at end of frame, default: false
    • setChecksum0

      private void setChecksum0(boolean checksumFlag)
    • setWorkers

      public ZstdCompressCtx setWorkers(int workers)
    • setContentSize

      public ZstdCompressCtx setContentSize(boolean contentSizeFlag)
      Enable or disable content size
      Parameters:
      contentSizeFlag - Content size will be written into frame header _whenever known_, default: true
    • setContentSize0

      private void setContentSize0(boolean contentSizeFlag)
    • setDictID

      public ZstdCompressCtx setDictID(boolean dictIDFlag)
      Enable or disable dictID
      Parameters:
      dictIDFlag - When applicable, dictionary's ID is written into frame header, default: true
    • setDictID0

      private void setDictID0(boolean dictIDFlag)
    • setLong

      public ZstdCompressCtx setLong(int windowLog)
      Enable or disable LongDistanceMatching and set the window size
      Parameters:
      windowLog - Maximum allowed back-reference distance, expressed as power of 2. This will set a memory budget for streaming decompression, with larger values requiring more memory and typically compressing more. Must be clamped between 10 and 32/64 but values greater then 27 may not be decompressable in all context as they require more memory. 0 disables LDM.
    • loadDict

      public ZstdCompressCtx loadDict(ZstdDictCompress dict)
      Load compression dictionary to be used for subsequently compressed frames.
      Parameters:
      dict - the dictionary or `null` to remove loaded dictionary
    • loadCDictFast0

      private long loadCDictFast0(ZstdDictCompress dict)
    • loadDict

      public ZstdCompressCtx loadDict(byte[] dict)
      Load compression dictionary to be used for subsequently compressed frames.
      Parameters:
      dict - the dictionary or `null` to remove loaded dictionary
    • loadCDict0

      private long loadCDict0(byte[] dict)
    • ensureOpen

      private void ensureOpen()
    • reset

      public void reset()
      Clear all state and parameters from the compression context. This leaves the object in a state identical to a newly created compression context.
    • reset0

      private long reset0()
    • setPledgedSrcSize

      public void setPledgedSrcSize(long srcSize)
      Promise to compress a certain number of source bytes. Knowing the number of bytes to compress up front helps to choose proper compression settings and size internal buffers. Additionally, the pledged size is stored in the header of the output stream, allowing decompressors to know how much uncompressed data to expect. Attempting to compress more or less than than the pledged size will result in an error.
    • setPledgedSrcSize0

      private long setPledgedSrcSize0(long srcSize)
    • compressDirectByteBufferStream

      public boolean compressDirectByteBufferStream(ByteBuffer dst, ByteBuffer src, EndDirective endOp)
      Compress as much of the src ByteBuffer into the dst ByteBuffer as possible.
      Parameters:
      dst - destination of compressed data
      src - buffer to compress
      endOp - directive for handling the end of the stream
      Returns:
      true if all state has been flushed from internal buffers
    • compressDirectByteBufferStream0

      private long compressDirectByteBufferStream0(ByteBuffer dst, int dstOffset, int dstSize, ByteBuffer src, int srcSize, int srcOffset, int endOp)
      4 pieces of information are packed into the return value of this method, which must be treated as an unsigned long. The highest bit is set if all data has been flushed from internal buffers. The next 31 bits are the new position of the destination buffer. The next bit is set if an error occurred. If an error occurred, the lowest 31 bits encode a zstd error code. Otherwise, the lowest 31 bits are the new position of the source buffer.
    • compressDirectByteBuffer

      public int compressDirectByteBuffer(ByteBuffer dstBuff, int dstOffset, int dstSize, ByteBuffer srcBuff, int srcOffset, int srcSize)
      Compresses buffer 'srcBuff' into buffer 'dstBuff' reusing this ZstdCompressCtx. Destination buffer should be sized to handle worst cases situations (input data not compressible). Worst case size evaluation is provided by function ZSTD_compressBound(). This is a low-level function that does not take into account or affect the `limit` or `position` of source or destination buffers.
      Parameters:
      dstBuff - the destination buffer - must be direct
      dstOffset - the start offset of 'dstBuff'
      dstSize - the size of 'dstBuff' (after 'dstOffset')
      srcBuff - the source buffer - must be direct
      srcOffset - the start offset of 'srcBuff'
      srcSize - the length of 'srcBuff' (after 'srcOffset')
      Returns:
      the number of bytes written into buffer 'dstBuff'.
    • compressDirectByteBuffer0

      private long compressDirectByteBuffer0(ByteBuffer dst, int dstOffset, int dstSize, ByteBuffer src, int srcOffset, int srcSize)
    • compressByteArray

      public int compressByteArray(byte[] dstBuff, int dstOffset, int dstSize, byte[] srcBuff, int srcOffset, int srcSize)
      Compresses byte array 'srcBuff' into byte array 'dstBuff' reusing this ZstdCompressCtx. Destination buffer should be sized to handle worst cases situations (input data not compressible). Worst case size evaluation is provided by function ZSTD_compressBound().
      Parameters:
      dstBuff - the destination buffer (byte array)
      dstOffset - the start offset of 'dstBuff'
      dstSize - the size of 'dstBuff' (after 'dstOffset')
      srcBuff - the source buffer (byte array)
      srcOffset - the start offset of 'srcBuff'
      srcSize - the length of 'srcBuff' (after 'srcOffset')
      Returns:
      the number of bytes written into buffer 'dstBuff'.
    • compressByteArray0

      private long compressByteArray0(byte[] dst, int dstOffset, int dstSize, byte[] src, int srcOffset, int srcSize)
    • compress

      public int compress(ByteBuffer dstBuf, ByteBuffer srcBuf)
      Compresses the data in buffer 'srcBuf'
      Parameters:
      dstBuf - the destination buffer - must be direct. It is assumed that the `position()` of this buffer marks the offset at which the compressed data are to be written, and that the `limit()` of this buffer is the maximum compressed data size to allow.

      When this method returns successfully, its `position()` will be set to its current `position()` plus the compressed size of the data.

      srcBuf - the source buffer - must be direct. It is assumed that the `position()` of this buffer marks the beginning of the uncompressed data to be compressed, and that the `limit()` of this buffer marks its end.

      When this method returns successfully, its `position()` will be set to the initial `limit()`.

      Returns:
      the size of the compressed data
    • compress

      public ByteBuffer compress(ByteBuffer srcBuf) throws ZstdException
      Compresses the data in buffer 'srcBuf'
      Parameters:
      srcBuf - the source buffer - must be direct. It is assumed that the `position()` of the buffer marks the beginning of the uncompressed data to be compressed, and that the `limit()` of this buffer marks its end.

      When this method returns successfully, its `position()` will be set to its initial `limit()`.

      Returns:
      A newly allocated direct ByteBuffer containing the compressed data.
      Throws:
      ZstdException
    • compress

      public int compress(byte[] dst, byte[] src)
    • compress

      public byte[] compress(byte[] src)