Spry/vapi/libzstd.vapi

/* libzstd.vapi - Vala bindings for Zstandard compression library
 * 
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 * Vala bindings generated for use with the spry framework.
 * 
 * Based on zstd.h from libzstd 1.5.7
 */

[CCode (cprefix = "ZSTD_", lower_case_cprefix = "ZSTD_", cheader_filename = "zstd.h,zstd_errors.h")]
namespace Zstd {
    
    /* Version */
    [CCode (cname = "ZSTD_VERSION_MAJOR")]
    public const int VERSION_MAJOR;
    [CCode (cname = "ZSTD_VERSION_MINOR")]
    public const int VERSION_MINOR;
    [CCode (cname = "ZSTD_VERSION_RELEASE")]
    public const int VERSION_RELEASE;
    [CCode (cname = "ZSTD_VERSION_NUMBER")]
    public const int VERSION_NUMBER;
    
    [CCode (cname = "ZSTD_versionNumber")]
    public uint version_number();
    [CCode (cname = "ZSTD_versionString")]
    public unowned string version_string();
    
    /* Default compression level */
    [CCode (cname = "ZSTD_CLEVEL_DEFAULT")]
    public const int CLEVEL_DEFAULT;
    
    /* Block size constants */
    [CCode (cname = "ZSTD_BLOCKSIZELOG_MAX")]
    public const int BLOCKSIZELOG_MAX;
    [CCode (cname = "ZSTD_BLOCKSIZE_MAX")]
    public const int BLOCKSIZE_MAX;
    
    /* Content size constants */
    [CCode (cname = "ZSTD_CONTENTSIZE_UNKNOWN")]
    public const uint64 CONTENTSIZE_UNKNOWN;
    [CCode (cname = "ZSTD_CONTENTSIZE_ERROR")]
    public const uint64 CONTENTSIZE_ERROR;
    
    /* Compression strategies */
    [CCode (cname = "ZSTD_strategy", cprefix = "ZSTD_", has_type_id = false)]
    public enum Strategy {
        fast = 1,
        dfast = 2,
        greedy = 3,
        lazy = 4,
        lazy2 = 5,
        btlazy2 = 6,
        btopt = 7,
        btultra = 8,
        btultra2 = 9
    }
    
    /* End directive for streaming */
    [CCode (cname = "ZSTD_EndDirective", cprefix = "ZSTD_e_", has_type_id = false)]
    public enum EndDirective {
        continue = 0,
        flush = 1,
        end = 2
    }
    
    /* Reset directive */
    [CCode (cname = "ZSTD_ResetDirective", cprefix = "ZSTD_reset_", has_type_id = false)]
    public enum ResetDirective {
        session_only = 1,
        parameters = 2,
        session_and_parameters = 3
    }
    
    /* Error codes */
    [CCode (cname = "ZSTD_ErrorCode", cprefix = "ZSTD_error_", has_type_id = false)]
    public enum ErrorCode {
        no_error = 0,
        GENERIC = 1,
        prefix_unknown = 10,
        version_unsupported = 12,
        frameParameter_unsupported = 14,
        frameParameter_windowTooLarge = 16,
        corruption_detected = 20,
        checksum_wrong = 22,
        literals_headerWrong = 24,
        dictionary_corrupted = 30,
        dictionary_wrong = 32,
        dictionaryCreation_failed = 34,
        parameter_unsupported = 40,
        parameter_combination_unsupported = 41,
        parameter_outOfBound = 42,
        tableLog_tooLarge = 44,
        maxSymbolValue_tooLarge = 46,
        maxSymbolValue_tooSmall = 48,
        cannotProduce_uncompressedBlock = 49,
        stabilityCondition_notRespected = 50,
        stage_wrong = 60,
        init_missing = 62,
        memory_allocation = 64,
        workSpace_tooSmall = 66,
        dstSize_tooSmall = 70,
        srcSize_wrong = 72,
        dstBuffer_null = 74,
        noForwardProgress_destFull = 80,
        noForwardProgress_inputEmpty = 82,
        frameIndex_tooLarge = 100,
        seekableIO = 102,
        dstBuffer_wrong = 104,
        srcBuffer_wrong = 105,
        sequenceProducer_failed = 106,
        externalSequences_invalid = 107,
        maxCode = 120
    }
    
    /* Bounds structure */
    [CCode (cname = "ZSTD_bounds", has_type_id = false)]
    public struct Bounds {
        public size_t error;
        public int lowerBound;
        public int upperBound;
    }
    
    /* Input buffer for streaming */
    [CCode (cname = "ZSTD_inBuffer", has_type_id = false)]
    public struct InBuffer {
        public uint8* src;
        public size_t size;
        public size_t pos;
    }
    
    /* Output buffer for streaming */
    [CCode (cname = "ZSTD_outBuffer", has_type_id = false)]
    public struct OutBuffer {
        public uint8* dst;
        public size_t size;
        public size_t pos;
    }
    
    /* Compression context */
    [CCode (cname = "ZSTD_CCtx", free_function = "ZSTD_freeCCtx", has_type_id = false)]
    [Compact]
    public class CCtx {
        [CCode (cname = "ZSTD_createCCtx")]
        public CCtx();
        
        [CCode (cname = "ZSTD_compressCCtx")]
        public size_t compress(uint8* dst, size_t dstCapacity, uint8* src, size_t srcSize, int compressionLevel);
        
        [CCode (cname = "ZSTD_compress2")]
        public size_t compress2(uint8* dst, size_t dstCapacity, uint8* src, size_t srcSize);
        
        [CCode (cname = "ZSTD_CCtx_setParameter")]
        public size_t set_parameter(CParameter param, int value);
        
        [CCode (cname = "ZSTD_CCtx_setPledgedSrcSize")]
        public size_t set_pledged_src_size(uint64 pledgedSrcSize);
        
        [CCode (cname = "ZSTD_CCtx_reset")]
        public size_t reset(ResetDirective reset);
        
        [CCode (cname = "ZSTD_compressStream2")]
        public size_t compress_stream2(OutBuffer* output, InBuffer* input, EndDirective endOp);
        
        [CCode (cname = "ZSTD_initCStream")]
        public size_t init_stream(int compressionLevel);
        
        [CCode (cname = "ZSTD_compressStream")]
        public size_t compress_stream(OutBuffer* output, InBuffer* input);
        
        [CCode (cname = "ZSTD_flushStream")]
        public size_t flush_stream(OutBuffer* output);
        
        [CCode (cname = "ZSTD_endStream")]
        public size_t end_stream(OutBuffer* output);
    }
    
    /* Decompression context */
    [CCode (cname = "ZSTD_DCtx", free_function = "ZSTD_freeDCtx", has_type_id = false)]
    [Compact]
    public class DCtx {
        [CCode (cname = "ZSTD_createDCtx")]
        public DCtx();
        
        [CCode (cname = "ZSTD_decompressDCtx")]
        public size_t decompress(uint8* dst, size_t dstCapacity, uint8* src, size_t srcSize);
        
        [CCode (cname = "ZSTD_DCtx_setParameter")]
        public size_t set_parameter(DParameter param, int value);
        
        [CCode (cname = "ZSTD_DCtx_reset")]
        public size_t reset(ResetDirective reset);
    }
    
    /* Compression stream (alias for CCtx) */
    [CCode (cname = "ZSTD_CStream", free_function = "ZSTD_freeCStream", has_type_id = false)]
    [Compact]
    public class CStream {
        [CCode (cname = "ZSTD_createCStream")]
        public CStream();
    }
    
    /* Compression parameters */
    [CCode (cname = "ZSTD_cParameter", cprefix = "ZSTD_c_", has_type_id = false)]
    public enum CParameter {
        compressionLevel = 100,
        windowLog = 101,
        hashLog = 102,
        chainLog = 103,
        searchLog = 104,
        minMatch = 105,
        targetLength = 106,
        strategy = 107,
        targetCBlockSize = 130,
        enableLongDistanceMatching = 160,
        ldmHashLog = 161,
        ldmMinMatch = 162,
        ldmBucketSizeLog = 163,
        ldmHashRateLog = 164,
        contentSizeFlag = 200,
        checksumFlag = 201,
        dictIDFlag = 202,
        nbWorkers = 400,
        jobSize = 401,
        overlapLog = 402
    }
    
    /* Decompression parameters */
    [CCode (cname = "ZSTD_dParameter", cprefix = "ZSTD_d_", has_type_id = false)]
    public enum DParameter {
        windowLogMax = 100
    }
    
    /* Simple API - One-shot compression */
    [CCode (cname = "ZSTD_compress")]
    public size_t compress(uint8* dst, size_t dstCapacity, uint8* src, size_t srcSize, int compressionLevel);
    
    /* Simple API - One-shot decompression */
    [CCode (cname = "ZSTD_decompress")]
    public size_t decompress(uint8* dst, size_t dstCapacity, uint8* src, size_t compressedSize);
    
    /* Helper functions */
    [CCode (cname = "ZSTD_compressBound")]
    public size_t compress_bound(size_t srcSize);
    
    [CCode (cname = "ZSTD_isError")]
    public uint is_error(size_t result);
    
    [CCode (cname = "ZSTD_getErrorCode")]
    public ErrorCode get_error_code(size_t functionResult);
    
    [CCode (cname = "ZSTD_getErrorName")]
    public unowned string get_error_name(size_t result);
    
    [CCode (cname = "ZSTD_minCLevel")]
    public int min_c_level();
    
    [CCode (cname = "ZSTD_maxCLevel")]
    public int max_c_level();
    
    [CCode (cname = "ZSTD_defaultCLevel")]
    public int default_c_level();
    
    /* Content size functions */
    [CCode (cname = "ZSTD_getFrameContentSize")]
    public uint64 get_frame_content_size(uint8* src, size_t srcSize);
    
    [CCode (cname = "ZSTD_findFrameCompressedSize")]
    public size_t find_frame_compressed_size(uint8* src, size_t srcSize);
    
    /* Streaming buffer size recommendations */
    [CCode (cname = "ZSTD_CStreamInSize")]
    public size_t cstream_in_size();
    
    [CCode (cname = "ZSTD_CStreamOutSize")]
    public size_t cstream_out_size();
    
    /* Error string from error code */
    [CCode (cname = "ZSTD_getErrorString")]
    public unowned string get_error_string(ErrorCode code);
    
    /* Parameter bounds */
    [CCode (cname = "ZSTD_cParam_getBounds")]
    public Bounds cparam_get_bounds(CParameter cParam);
    
    [CCode (cname = "ZSTD_dParam_getBounds")]
    public Bounds dparam_get_bounds(DParameter dParam);
}