lz4/

sys.rs

#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(clippy::missing_safety_doc)]
#![allow(clippy::too_many_arguments)]
#![allow(clippy::needless_range_loop)]

pub use libc::{c_char, c_int, c_uint, c_ulonglong, c_void, size_t};
use std::cmp;
use std::ptr;
use std::slice;

#[derive(Clone, Copy, Debug)]
#[repr(C)]
pub struct LZ4FCompressionContext(pub *mut c_void);
unsafe impl Send for LZ4FCompressionContext {}

#[derive(Clone, Copy, Debug)]
#[repr(C)]
pub struct LZ4FDecompressionContext(pub *mut c_void);
unsafe impl Send for LZ4FDecompressionContext {}

pub type LZ4FErrorCode = size_t;

#[derive(Clone, Debug)]
#[repr(u32)]
pub enum BlockSize {
    Default = 0,
    Max64KB = 4,
    Max256KB = 5,
    Max1MB = 6,
    Max4MB = 7,
}

impl BlockSize {
    pub fn get_size(&self) -> usize {
        match self {
            BlockSize::Default | BlockSize::Max64KB => 64 * 1024,
            BlockSize::Max256KB => 256 * 1024,
            BlockSize::Max1MB => 1024 * 1024,
            BlockSize::Max4MB => 4 * 1024 * 1024,
        }
    }
}

#[derive(Clone, Debug)]
#[repr(u32)]
pub enum BlockMode {
    Linked = 0,
    Independent,
}

#[derive(Clone, Debug)]
#[repr(u32)]
pub enum ContentChecksum {
    NoChecksum = 0,
    ChecksumEnabled,
}

#[derive(Clone, Debug)]
#[repr(u32)]
pub enum FrameType {
    Frame = 0,
    SkippableFrame,
}

#[derive(Clone, Debug)]
#[repr(u32)]
pub enum BlockChecksum {
    NoBlockChecksum = 0,
    BlockChecksumEnabled,
}

#[derive(Clone, Debug)]
#[repr(C)]
pub struct LZ4FFrameInfo {
    pub block_size_id: BlockSize,
    pub block_mode: BlockMode,
    pub content_checksum_flag: ContentChecksum,
    pub frame_type: FrameType,
    pub content_size: c_ulonglong,
    pub dict_id: c_uint,
    pub block_checksum_flag: BlockChecksum,
}

#[derive(Clone, Debug)]
#[repr(C)]
pub struct LZ4FPreferences {
    pub frame_info: LZ4FFrameInfo,
    pub compression_level: c_uint,
    pub auto_flush: c_uint,
    pub favor_dec_speed: c_uint,
    pub reserved: [c_uint; 3],
}

#[derive(Debug)]
#[repr(C)]
pub struct LZ4FCompressOptions {
    pub stable_src: c_uint,
    pub reserved: [c_uint; 3],
}

#[derive(Debug)]
#[repr(C)]
pub struct LZ4FDecompressOptions {
    /// Matches the lz4-rs binding shape. Upstream uses this as a performance
    /// pledge for linked-block history; this pure implementation keeps history
    /// in owned context storage, so the flag is accepted but has no behavioral
    /// effect.
    pub stable_dst: c_uint,
    /// When non-zero, block and content checksum fields are consumed but not
    /// validated, matching upstream `LZ4F_decompressOptions_t`.
    pub skipChecksums: c_uint,
    pub reserved: [c_uint; 2],
}

#[derive(Debug)]
#[repr(C)]
pub struct LZ4StreamEncode {
    _private: [u8; 0],
}

#[derive(Debug)]
#[repr(C)]
pub struct LZ4StreamDecode {
    _private: [u8; 0],
}

#[derive(Debug)]
#[repr(C)]
pub struct LZ4StreamHC {
    _private: [u8; 0],
}

#[derive(Debug)]
#[repr(C)]
pub struct LZ4FCDict {
    _private: [u8; 0],
}

pub const LZ4F_VERSION: c_uint = 100;

const LZ4_VERSION_NUMBER: c_int = 11000;
const MINMATCH: usize = 4;
const LZ4_HASH_BITS: usize = 12;
const LZ4_HASH_BITS_U16: usize = LZ4_HASH_BITS + 1;
const LZ4_64K_LIMIT: usize = 64 * 1024 + MFLIMIT - 1;
const HASH_UNIT: usize = std::mem::size_of::<usize>();
const LZ4HC_HASH_BITS: usize = 15;
const LZ4HC_HASH_SIZE: usize = 1 << LZ4HC_HASH_BITS;
const LZ4MID_HASH_BITS: usize = LZ4HC_HASH_BITS - 1;
const LZ4MID_HASH_SIZE: usize = 1 << LZ4MID_HASH_BITS;
const LZ4MID_HASHSIZE: usize = 8;
const LZ4_OPT_NUM: usize = 1 << 12;
const LZ4_DISTANCE_MAX: usize = 64 * 1024 - 1;
const LAST_LITERALS: usize = 5;
const MFLIMIT: usize = 12;
const OPTIMAL_ML: usize = 18;
const LZ4_MAX_INPUT_SIZE: c_int = 0x7E00_0000;
const LZ4HC_CLEVEL_MIN: c_int = 3;
const LZ4HC_CLEVEL_DEFAULT: c_int = 9;
const LZ4HC_CLEVEL_MAX: c_int = 12;
const LZ4F_MAGIC: [u8; 4] = [0x04, 0x22, 0x4D, 0x18];
const LZ4F_SKIPPABLE_MAGIC_MIN: u32 = 0x184D_2A50;
const LZ4F_SKIPPABLE_MAGIC_MAX: u32 = 0x184D_2A5F;
const LZ4F_ERROR_MAX_CODE: usize = 24;
const LZ4F_ERROR_GENERIC_CODE: usize = 1;
const LZ4F_ERROR_MAX_BLOCK_SIZE_INVALID_CODE: usize = 2;
const LZ4F_ERROR_BLOCK_MODE_INVALID_CODE: usize = 3;
const LZ4F_ERROR_PARAMETER_INVALID_CODE: usize = 4;
const LZ4F_ERROR_COMPRESSION_LEVEL_INVALID_CODE: usize = 5;
const LZ4F_ERROR_HEADER_VERSION_WRONG_CODE: usize = 6;
const LZ4F_ERROR_BLOCK_CHECKSUM_INVALID_CODE: usize = 7;
const LZ4F_ERROR_RESERVED_FLAG_SET_CODE: usize = 8;
const LZ4F_ERROR_ALLOCATION_FAILED_CODE: usize = 9;
const LZ4F_ERROR_SRC_SIZE_TOO_LARGE_CODE: usize = 10;
const LZ4F_ERROR_FRAME_SIZE_WRONG_CODE: usize = 14;
const LZ4F_ERROR_FRAME_TYPE_UNKNOWN_CODE: usize = 13;
const LZ4F_ERROR_SRC_PTR_WRONG_CODE: usize = 15;
const LZ4F_ERROR_DECOMPRESSION_FAILED_CODE: usize = 16;
const LZ4F_ERROR_HEADER_CHECKSUM_INVALID_CODE: usize = 17;
const LZ4F_ERROR_DST_MAX_SIZE_TOO_SMALL_CODE: usize = 11;
const LZ4F_ERROR_FRAME_HEADER_INCOMPLETE_CODE: usize = 12;
const LZ4F_ERROR_CONTENT_CHECKSUM_INVALID_CODE: usize = 18;
const LZ4F_ERROR_FRAME_DECODING_ALREADY_STARTED_CODE: usize = 19;
const LZ4F_ERROR_COMPRESSION_STATE_UNINITIALIZED_CODE: usize = 20;
const LZ4F_ERROR_PARAMETER_NULL_CODE: usize = 21;
const LZ4F_ERROR_IO_WRITE_CODE: usize = 22;
const LZ4F_ERROR_IO_READ_CODE: usize = 23;
const ERROR_GENERIC: usize = lz4f_error(LZ4F_ERROR_GENERIC_CODE);
const ERROR_MAX_BLOCK_SIZE_INVALID: usize = lz4f_error(LZ4F_ERROR_MAX_BLOCK_SIZE_INVALID_CODE);
const ERROR_BLOCK_MODE_INVALID: usize = lz4f_error(LZ4F_ERROR_BLOCK_MODE_INVALID_CODE);
const ERROR_PARAMETER_INVALID: usize = lz4f_error(LZ4F_ERROR_PARAMETER_INVALID_CODE);
const ERROR_COMPRESSION_LEVEL_INVALID: usize =
    lz4f_error(LZ4F_ERROR_COMPRESSION_LEVEL_INVALID_CODE);
const ERROR_HEADER_VERSION_WRONG: usize = lz4f_error(LZ4F_ERROR_HEADER_VERSION_WRONG_CODE);
const ERROR_BLOCK_CHECKSUM_INVALID: usize = lz4f_error(LZ4F_ERROR_BLOCK_CHECKSUM_INVALID_CODE);
const ERROR_RESERVED_FLAG_SET: usize = lz4f_error(LZ4F_ERROR_RESERVED_FLAG_SET_CODE);
const ERROR_ALLOCATION_FAILED: usize = lz4f_error(LZ4F_ERROR_ALLOCATION_FAILED_CODE);
const ERROR_SRC_SIZE_TOO_LARGE: usize = lz4f_error(LZ4F_ERROR_SRC_SIZE_TOO_LARGE_CODE);
const ERROR_FRAME_SIZE_WRONG: usize = lz4f_error(LZ4F_ERROR_FRAME_SIZE_WRONG_CODE);
const ERROR_FRAME_TYPE_UNKNOWN: usize = lz4f_error(LZ4F_ERROR_FRAME_TYPE_UNKNOWN_CODE);
const ERROR_SRC_PTR_WRONG: usize = lz4f_error(LZ4F_ERROR_SRC_PTR_WRONG_CODE);
const ERROR_DECOMPRESSION_FAILED: usize = lz4f_error(LZ4F_ERROR_DECOMPRESSION_FAILED_CODE);
const ERROR_HEADER_CHECKSUM_INVALID: usize = lz4f_error(LZ4F_ERROR_HEADER_CHECKSUM_INVALID_CODE);
const ERROR_DST_TOO_SMALL: usize = lz4f_error(LZ4F_ERROR_DST_MAX_SIZE_TOO_SMALL_CODE);
const ERROR_BAD_HEADER: usize = lz4f_error(LZ4F_ERROR_FRAME_HEADER_INCOMPLETE_CODE);
const ERROR_CHECKSUM_INVALID: usize = lz4f_error(LZ4F_ERROR_CONTENT_CHECKSUM_INVALID_CODE);
const ERROR_FRAME_DECODING_ALREADY_STARTED: usize =
    lz4f_error(LZ4F_ERROR_FRAME_DECODING_ALREADY_STARTED_CODE);
const ERROR_COMPRESSION_STATE_UNINITIALIZED: usize =
    lz4f_error(LZ4F_ERROR_COMPRESSION_STATE_UNINITIALIZED_CODE);
const ERROR_PARAMETER_NULL: usize = lz4f_error(LZ4F_ERROR_PARAMETER_NULL_CODE);
const ERROR_IO_WRITE: usize = lz4f_error(LZ4F_ERROR_IO_WRITE_CODE);
const ERROR_IO_READ: usize = lz4f_error(LZ4F_ERROR_IO_READ_CODE);

static ERROR_GENERIC_NAME: &[u8] = b"ERROR_GENERIC\0";
static ERROR_MAX_BLOCK_SIZE_NAME: &[u8] = b"ERROR_maxBlockSize_invalid\0";
static ERROR_BLOCK_MODE_NAME: &[u8] = b"ERROR_blockMode_invalid\0";
static ERROR_PARAMETER_INVALID_NAME: &[u8] = b"ERROR_parameter_invalid\0";
static ERROR_COMPRESSION_LEVEL_NAME: &[u8] = b"ERROR_compressionLevel_invalid\0";
static ERROR_HEADER_VERSION_NAME: &[u8] = b"ERROR_headerVersion_wrong\0";
static ERROR_BLOCK_CHECKSUM_NAME: &[u8] = b"ERROR_blockChecksum_invalid\0";
static ERROR_RESERVED_FLAG_NAME: &[u8] = b"ERROR_reservedFlag_set\0";
static ERROR_ALLOCATION_FAILED_NAME: &[u8] = b"ERROR_allocation_failed\0";
static ERROR_SRC_SIZE_TOO_LARGE_NAME: &[u8] = b"ERROR_srcSize_tooLarge\0";
static ERROR_FRAME_SIZE_NAME: &[u8] = b"ERROR_frameSize_wrong\0";
static ERROR_FRAME_TYPE_NAME: &[u8] = b"ERROR_frameType_unknown\0";
static ERROR_SRC_PTR_NAME: &[u8] = b"ERROR_srcPtr_wrong\0";
static ERROR_DECOMPRESSION_FAILED_NAME: &[u8] = b"ERROR_decompressionFailed\0";
static ERROR_HEADER_CHECKSUM_NAME: &[u8] = b"ERROR_headerChecksum_invalid\0";
static ERROR_DST_NAME: &[u8] = b"ERROR_dstMaxSize_tooSmall\0";
static ERROR_BAD_HEADER_NAME: &[u8] = b"ERROR_frameHeader_incomplete\0";
static ERROR_CHECKSUM_NAME: &[u8] = b"ERROR_contentChecksum_invalid\0";
static ERROR_FRAME_DECODING_ALREADY_STARTED_NAME: &[u8] = b"ERROR_frameDecoding_alreadyStarted\0";
static ERROR_COMPRESSION_STATE_UNINITIALIZED_NAME: &[u8] =
    b"ERROR_compressionState_uninitialized\0";
static ERROR_PARAMETER_NULL_NAME: &[u8] = b"ERROR_parameter_null\0";
static ERROR_IO_WRITE_NAME: &[u8] = b"ERROR_io_write\0";
static ERROR_IO_READ_NAME: &[u8] = b"ERROR_io_read\0";
static ERROR_UNSPECIFIED_NAME: &[u8] = b"Unspecified error code\0";
static LZ4_VERSION_STRING_BYTES: &[u8] = b"1.10.0\0";

const fn lz4f_error(code: usize) -> usize {
    usize::MAX - (code - 1)
}

#[derive(Debug)]
struct CompressionCtx {
    prefs: FramePrefs,
    content_hasher: XxHash32,
    dictionary: Vec<u8>,
    pending: Vec<u8>,
    total_input: u64,
    external_dictionary: bool,
    started: bool,
}

#[derive(Clone, Copy, Debug)]
struct FramePrefs {
    block_size_id: u8,
    block_independent: bool,
    block_checksum: bool,
    content_checksum: bool,
    content_size: u64,
    dict_id: c_uint,
    compression_level: c_int,
    auto_flush: bool,
    favor_dec_speed: bool,
}

impl Default for FramePrefs {
    fn default() -> Self {
        // Matches upstream `LZ4F_INIT_FRAMEINFO` (lz4frame.h:186): a NULL
        // `LZ4F_preferences_t*` and a zero-initialised one both decode to
        // `LZ4F_blockLinked = 0`, not Independent.
        Self {
            block_size_id: 4,
            block_independent: false,
            block_checksum: false,
            content_checksum: false,
            content_size: 0,
            dict_id: 0,
            compression_level: 0,
            auto_flush: false,
            favor_dec_speed: false,
        }
    }
}

#[derive(Debug)]
struct DecompressionCtx {
    input: Vec<u8>,
    pending: Vec<u8>,
    pending_pos: usize,
    pos: usize,
    parsed_header: bool,
    done: bool,
    block_checksum: bool,
    content_checksum: bool,
    content_size: u64,
    content_read: u64,
    dict_id: c_uint,
    block_independent: bool,
    block_max: usize,
    dictionary: Vec<u8>,
    external_dictionary: bool,
    content_hasher: XxHash32,
    raw_block_remaining: usize,
    raw_block_checksum: XxHash32,
    skip_checksums: bool,
}

#[derive(Debug)]
struct HcStreamCtx {
    compression_level: c_int,
    dictionary: Vec<u8>,
    attached_dictionary: bool,
    favor_dec_speed: bool,
}

#[derive(Debug, Default)]
struct EncodeStreamCtx {
    dictionary: Vec<u8>,
    attached_dictionary: bool,
}

#[derive(Debug, Default)]
struct DecodeStreamCtx {
    dictionary: Vec<u8>,
}

#[derive(Debug, Default)]
struct CDictCtx {
    dictionary: Vec<u8>,
}

impl Default for HcStreamCtx {
    fn default() -> Self {
        Self {
            compression_level: LZ4HC_CLEVEL_DEFAULT,
            dictionary: Vec::new(),
            attached_dictionary: false,
            favor_dec_speed: false,
        }
    }
}

impl Default for DecompressionCtx {
    fn default() -> Self {
        Self {
            input: Vec::new(),
            pending: Vec::new(),
            pending_pos: 0,
            pos: 0,
            parsed_header: false,
            done: false,
            block_checksum: false,
            content_checksum: false,
            content_size: 0,
            content_read: 0,
            dict_id: 0,
            block_independent: true,
            block_max: 64 * 1024,
            dictionary: Vec::new(),
            external_dictionary: false,
            content_hasher: XxHash32::new(0),
            raw_block_remaining: 0,
            raw_block_checksum: XxHash32::new(0),
            skip_checksums: false,
        }
    }
}

/// Library version number; useful to check dll version. Requires v1.3.0+.
#[no_mangle]
pub unsafe extern "C" fn LZ4_versionNumber() -> c_int {
    LZ4_VERSION_NUMBER
}

/// Library version string; useful to check dll version. Requires v1.7.5+.
#[no_mangle]
pub extern "C" fn LZ4_versionString() -> *const c_char {
    LZ4_VERSION_STRING_BYTES.as_ptr() as *const c_char
}

/// `LZ4_compressBound()` :
/// Provides the maximum size that LZ4 compression may output in a "worst case" scenario
/// (input data not compressible). This function is primarily useful for memory allocation
/// purposes (destination buffer size). Note that `LZ4_compress_default()` compresses faster
/// when `dstCapacity` is `>= LZ4_compressBound(srcSize)`.
///
/// - `inputSize` : max supported value is `LZ4_MAX_INPUT_SIZE`
/// - return : maximum output size in a "worst case" scenario,
///   or 0 if input size is incorrect (too large or negative)
#[no_mangle]
pub unsafe extern "C" fn LZ4_compressBound(size: c_int) -> c_int {
    if !(0..=LZ4_MAX_INPUT_SIZE).contains(&size) {
        0
    } else {
        size + (size / 255) + 16
    }
}

/// `LZ4_compress_default()` :
/// Compresses `srcSize` bytes from buffer `src` into already-allocated `dst` buffer of size
/// `dstCapacity`. Compression is guaranteed to succeed if `dstCapacity >= LZ4_compressBound(srcSize)`.
/// It also runs faster, so it's a recommended setting.
/// If the function cannot compress `src` into a more limited `dst` budget, compression stops
/// *immediately*, and the function result is zero. In which case, `dst` content is undefined (invalid).
///
/// - `srcSize` : max supported value is `LZ4_MAX_INPUT_SIZE`.
/// - `dstCapacity` : size of buffer `dst` (which must be already allocated).
/// - return : the number of bytes written into buffer `dst` (necessarily `<= dstCapacity`)
///   or 0 if compression fails.
///
/// Note : This function is protected against buffer overflow scenarios
/// (never writes outside `dst` buffer, nor reads outside `source` buffer).
#[no_mangle]
pub unsafe extern "C" fn LZ4_compress_default(
    source: *const c_char,
    dest: *mut c_char,
    sourceSize: c_int,
    maxDestSize: c_int,
) -> c_int {
    LZ4_compress_fast(source, dest, sourceSize, maxDestSize, 1)
}

/// Obsolete compression function (since v1.7.3). Use `LZ4_compress_default()` instead.
#[no_mangle]
pub unsafe extern "C" fn LZ4_compress(
    source: *const c_char,
    dest: *mut c_char,
    sourceSize: c_int,
) -> c_int {
    LZ4_compress_default(source, dest, sourceSize, LZ4_compressBound(sourceSize))
}

/// Obsolete compression function (since v1.7.3). Use `LZ4_compress_default()` instead.
#[no_mangle]
pub unsafe extern "C" fn LZ4_compress_limitedOutput(
    source: *const c_char,
    dest: *mut c_char,
    sourceSize: c_int,
    maxOutputSize: c_int,
) -> c_int {
    LZ4_compress_default(source, dest, sourceSize, maxOutputSize)
}

/// Obsolete compression function (since v1.7.3). Use `LZ4_compress_fast_extState()` instead.
#[no_mangle]
pub unsafe extern "C" fn LZ4_compress_withState(
    state: *mut c_void,
    source: *const c_char,
    dest: *mut c_char,
    inputSize: c_int,
) -> c_int {
    LZ4_compress_fast_extState(
        state,
        source,
        dest,
        inputSize,
        LZ4_compressBound(inputSize),
        1,
    )
}

/// Obsolete compression function (since v1.7.3). Use `LZ4_compress_fast_extState()` instead.
#[no_mangle]
pub unsafe extern "C" fn LZ4_compress_limitedOutput_withState(
    state: *mut c_void,
    source: *const c_char,
    dest: *mut c_char,
    inputSize: c_int,
    maxOutputSize: c_int,
) -> c_int {
    LZ4_compress_fast_extState(state, source, dest, inputSize, maxOutputSize, 1)
}

/// `LZ4_compress_fast()` :
/// Same as `LZ4_compress_default()`, but allows selection of "acceleration" factor.
/// The larger the acceleration value, the faster the algorithm, but also the lesser the
/// compression. It's a trade-off. It can be fine tuned, with each successive value providing
/// roughly +~3% to speed. An acceleration value of "1" is the same as regular
/// `LZ4_compress_default()`. Values `<= 0` will be replaced by `LZ4_ACCELERATION_DEFAULT`
/// (currently == 1). Values `> LZ4_ACCELERATION_MAX` will be replaced by `LZ4_ACCELERATION_MAX`
/// (currently == 65537).
#[no_mangle]
pub unsafe extern "C" fn LZ4_compress_fast(
    source: *const c_char,
    dest: *mut c_char,
    sourceSize: c_int,
    maxDestSize: c_int,
    acceleration: c_int,
) -> c_int {
    if !(0..=LZ4_MAX_INPUT_SIZE).contains(&sourceSize)
        || maxDestSize <= 0
        || (sourceSize > 0 && source.is_null())
        || dest.is_null()
    {
        return 0;
    }
    let src = if sourceSize == 0 {
        &[]
    } else {
        slice::from_raw_parts(source as *const u8, sourceSize as usize)
    };
    let dst = slice::from_raw_parts_mut(dest as *mut u8, maxDestSize as usize);
    compress_block(src, dst, normalize_acceleration(acceleration)).map_or(0, |n| n as c_int)
}

/// Returns the size in bytes required for an `LZ4_compress_fast_extState()` state buffer.
/// Allocate on 8-byte boundaries (a normal `malloc()` is sufficient).
#[no_mangle]
pub extern "C" fn LZ4_sizeofState() -> c_int {
    ((1usize << (LZ4_HASH_BITS + 2)) + 32) as c_int
}

/// `LZ4_compress_fast_extState()` :
/// Same as `LZ4_compress_fast()`, using an externally allocated memory space for its state.
/// Use `LZ4_sizeofState()` to know how much memory must be allocated, and allocate it on
/// 8-byte boundaries (using `malloc()` typically). Then, provide this buffer as `state` to
/// the compression function.
#[no_mangle]
pub unsafe extern "C" fn LZ4_compress_fast_extState(
    state: *mut c_void,
    source: *const c_char,
    dest: *mut c_char,
    sourceSize: c_int,
    maxDestSize: c_int,
    acceleration: c_int,
) -> c_int {
    if !(0..=LZ4_MAX_INPUT_SIZE).contains(&sourceSize)
        || maxDestSize <= 0
        || (sourceSize > 0 && source.is_null())
        || dest.is_null()
        || state.is_null()
    {
        return 0;
    }
    let src = if sourceSize == 0 {
        &[]
    } else {
        slice::from_raw_parts(source as *const u8, sourceSize as usize)
    };
    let dst = slice::from_raw_parts_mut(dest as *mut u8, maxDestSize as usize);
    compress_block_ext_state(state, src, dst, normalize_acceleration(acceleration))
        .map_or(0, |n| n as c_int)
}

/// `LZ4_compress_fast_extState_fastReset()` :
/// A variant of `LZ4_compress_fast_extState()`.
///
/// Using this variant avoids an expensive initialization step. It is only safe to call if
/// the state buffer is known to be correctly initialized already (see `LZ4_resetStream_fast()`
/// for a definition of "correctly initialized"). From a high level, the difference is that
/// this function initializes the provided state with a call to something like
/// `LZ4_resetStream_fast()` while `LZ4_compress_fast_extState()` starts with a call to
/// `LZ4_resetStream()`.
#[no_mangle]
pub unsafe extern "C" fn LZ4_compress_fast_extState_fastReset(
    state: *mut c_void,
    source: *const c_char,
    dest: *mut c_char,
    sourceSize: c_int,
    maxDestSize: c_int,
    acceleration: c_int,
) -> c_int {
    LZ4_compress_fast_extState(state, source, dest, sourceSize, maxDestSize, acceleration)
}

/// `LZ4_compress_destSize()` :
/// Reverse the logic: compresses as much data as possible from `src` buffer into already
/// allocated buffer `dst`, of size `>= dstCapacity`. This function either compresses the
/// entire `src` content into `dst` if it's large enough, or fills `dst` buffer completely
/// with as much data as possible from `src`. Note: acceleration parameter is fixed to "default".
///
/// - `*srcSizePtr` : in+out parameter. Initially contains size of input. Will be modified to
///   indicate how many bytes were read from `src` to fill `dst`. New value is
///   necessarily `<=` input value.
/// - return : Nb bytes written into `dst` (necessarily `<= dstCapacity`) or 0 if compression
///   fails.
///
/// Note : `targetDstSize` must be `>= 1`, because it's the smallest valid lz4 payload.
///
/// Note 2 : from v1.8.2 to v1.9.1, this function had a bug (fixed in v1.9.2+): the produced
///          compressed content could, in rare circumstances, require to be decompressed into
///          a destination buffer larger by at least 1 byte than `decompressedSize`.
#[no_mangle]
pub unsafe extern "C" fn LZ4_compress_destSize(
    src: *const c_char,
    dst: *mut c_char,
    srcSizePtr: *mut c_int,
    targetDstSize: c_int,
) -> c_int {
    if src.is_null()
        || dst.is_null()
        || srcSizePtr.is_null()
        || *srcSizePtr < 0
        || targetDstSize <= 0
    {
        return 0;
    }
    let src_slice = slice::from_raw_parts(src as *const u8, *srcSizePtr as usize);
    let dst_slice = slice::from_raw_parts_mut(dst as *mut u8, targetDstSize as usize);
    let Some((consumed, written)) = compress_dest_size(src_slice, dst_slice, 1) else {
        return 0;
    };
    *srcSizePtr = consumed as c_int;
    written as c_int
}

/// `LZ4_compress_destSize_extState()` : introduced in v1.10.0.
/// Same as `LZ4_compress_destSize()`, but using an externally allocated state. Also exposes
/// `acceleration`.
#[no_mangle]
pub unsafe extern "C" fn LZ4_compress_destSize_extState(
    state: *mut c_void,
    src: *const c_char,
    dst: *mut c_char,
    srcSizePtr: *mut c_int,
    targetDstSize: c_int,
    acceleration: c_int,
) -> c_int {
    if state.is_null()
        || src.is_null()
        || dst.is_null()
        || srcSizePtr.is_null()
        || *srcSizePtr < 0
        || targetDstSize <= 0
    {
        return 0;
    }
    if targetDstSize >= LZ4_compressBound(*srcSizePtr) {
        return LZ4_compress_fast_extState(
            state,
            src,
            dst,
            *srcSizePtr,
            targetDstSize,
            acceleration,
        );
    }

    let src_slice = slice::from_raw_parts(src as *const u8, *srcSizePtr as usize);
    let dst_slice = slice::from_raw_parts_mut(dst as *mut u8, targetDstSize as usize);
    let Some((consumed, written)) =
        compress_dest_size(src_slice, dst_slice, normalize_acceleration(acceleration))
    else {
        return 0;
    };
    *srcSizePtr = consumed as c_int;
    written as c_int
}

/// `LZ4_compress_HC()` :
/// Compress data from `src` into `dst`, using the powerful but slower "HC" algorithm.
/// `dst` must be already allocated. Compression is guaranteed to succeed if
/// `dstCapacity >= LZ4_compressBound(srcSize)`. Max supported `srcSize` value is
/// `LZ4_MAX_INPUT_SIZE`. `compressionLevel` : any value between 1 and `LZ4HC_CLEVEL_MAX`
/// will work. Values `> LZ4HC_CLEVEL_MAX` behave the same as `LZ4HC_CLEVEL_MAX`.
///
/// - return : the number of bytes written into `dst` or 0 if compression fails.
#[no_mangle]
pub unsafe extern "C" fn LZ4_compress_HC(
    src: *const c_char,
    dst: *mut c_char,
    srcSize: c_int,
    dstCapacity: c_int,
    compressionLevel: c_int,
) -> c_int {
    if srcSize < 0 || dstCapacity <= 0 || src.is_null() || dst.is_null() {
        return 0;
    }
    let src = slice::from_raw_parts(src as *const u8, srcSize as usize);
    let dst = slice::from_raw_parts_mut(dst as *mut u8, dstCapacity as usize);
    compress_block_hc(src, dst, compressionLevel, false).map_or(0, |n| n as c_int)
}

/// Returns the size in bytes required for an `LZ4_compress_HC_extStateHC()` state buffer.
/// Memory segment must be aligned on 8-byte boundaries.
#[no_mangle]
pub extern "C" fn LZ4_sizeofStateHC() -> c_int {
    cmp::max(
        std::mem::size_of::<HcStreamCtx>(),
        std::mem::align_of::<HcStreamCtx>(),
    ) as c_int
}

/// `LZ4_compress_HC_extStateHC()` :
/// Same as `LZ4_compress_HC()`, but using an externally allocated memory segment for `state`.
/// `state` size is provided by `LZ4_sizeofStateHC()`. Memory segment must be aligned on
/// 8-byte boundaries (which a normal `malloc()` should do properly).
#[no_mangle]
pub unsafe extern "C" fn LZ4_compress_HC_extStateHC(
    stateHC: *mut c_void,
    src: *const c_char,
    dst: *mut c_char,
    srcSize: c_int,
    maxDstSize: c_int,
    compressionLevel: c_int,
) -> c_int {
    if stateHC.is_null() || srcSize < 0 || maxDstSize <= 0 || src.is_null() || dst.is_null() {
        return 0;
    }
    let ctx = stateHC as *mut HcStreamCtx;
    ptr::write(ctx, HcStreamCtx::default());
    (*ctx).compression_level = normalize_hc_level(compressionLevel);
    let src_slice = slice::from_raw_parts(src as *const u8, srcSize as usize);
    let dst_slice = slice::from_raw_parts_mut(dst as *mut u8, maxDstSize as usize);
    compress_hc_stream_block(
        &mut *ctx,
        src_slice,
        dst_slice,
        normalize_hc_level(compressionLevel),
        false,
    )
}

/// `LZ4_compress_HC_extStateHC_fastReset()` :
/// A variant of `LZ4_compress_HC_extStateHC()`.
///
/// Using this variant avoids an expensive initialization step. It is only safe to call if
/// the state buffer is known to be correctly initialized already. The difference is that
/// this function initializes the provided state with a call to `LZ4_resetStreamHC_fast()`
/// while `LZ4_compress_HC_extStateHC()` starts with a call to `LZ4_resetStreamHC()`.
#[no_mangle]
pub unsafe extern "C" fn LZ4_compress_HC_extStateHC_fastReset(
    state: *mut c_void,
    src: *const c_char,
    dst: *mut c_char,
    srcSize: c_int,
    dstCapacity: c_int,
    compressionLevel: c_int,
) -> c_int {
    if state.is_null() || srcSize < 0 || dstCapacity <= 0 || src.is_null() || dst.is_null() {
        return 0;
    }
    let ctx = &mut *(state as *mut HcStreamCtx);
    ctx.compression_level = normalize_hc_level(compressionLevel);
    let src_slice = slice::from_raw_parts(src as *const u8, srcSize as usize);
    let dst_slice = slice::from_raw_parts_mut(dst as *mut u8, dstCapacity as usize);
    compress_hc_stream_block(
        ctx,
        src_slice,
        dst_slice,
        normalize_hc_level(compressionLevel),
        ctx.favor_dec_speed,
    )
}

/// `LZ4_compress_HC_destSize()` : v1.9.0+
/// Will compress as much data as possible from `src` to fit into `targetDstSize` budget.
/// Result is provided in 2 parts :
/// - return : the number of bytes written into `dst` (necessarily `<= targetDstSize`) or 0
///   if compression fails.
/// - `*srcSizePtr` : on success, updated to indicate how many bytes were read from `src`.
#[no_mangle]
pub unsafe extern "C" fn LZ4_compress_HC_destSize(
    stateHC: *mut c_void,
    src: *const c_char,
    dst: *mut c_char,
    srcSizePtr: *mut c_int,
    targetDstSize: c_int,
    compressionLevel: c_int,
) -> c_int {
    if stateHC.is_null()
        || src.is_null()
        || dst.is_null()
        || srcSizePtr.is_null()
        || *srcSizePtr < 0
        || targetDstSize <= 0
    {
        return 0;
    }

    let src_len = *srcSizePtr as usize;
    let src_slice = slice::from_raw_parts(src as *const u8, src_len);
    let dst_slice = slice::from_raw_parts_mut(dst as *mut u8, targetDstSize as usize);
    let Some((consumed, written)) =
        compress_hc_dest_size(src_slice, dst_slice, compressionLevel, false)
    else {
        return 0;
    };
    *srcSizePtr = consumed as c_int;
    written as c_int
}

/// Deprecated HC compression function. Use `LZ4_compress_HC()` instead.
#[no_mangle]
pub unsafe extern "C" fn LZ4_compressHC(
    src: *const c_char,
    dst: *mut c_char,
    srcSize: c_int,
) -> c_int {
    LZ4_compress_HC(src, dst, srcSize, LZ4_compressBound(srcSize), 0)
}

/// Deprecated HC compression function. Use `LZ4_compress_HC()` instead.
#[no_mangle]
pub unsafe extern "C" fn LZ4_compressHC_limitedOutput(
    src: *const c_char,
    dst: *mut c_char,
    srcSize: c_int,
    maxDstSize: c_int,
) -> c_int {
    LZ4_compress_HC(src, dst, srcSize, maxDstSize, 0)
}

/// Deprecated HC compression function. Use `LZ4_compress_HC()` instead.
#[no_mangle]
pub unsafe extern "C" fn LZ4_compressHC2(
    src: *const c_char,
    dst: *mut c_char,
    srcSize: c_int,
    cLevel: c_int,
) -> c_int {
    LZ4_compress_HC(src, dst, srcSize, LZ4_compressBound(srcSize), cLevel)
}

/// Deprecated HC compression function. Use `LZ4_compress_HC()` instead.
#[no_mangle]
pub unsafe extern "C" fn LZ4_compressHC2_limitedOutput(
    src: *const c_char,
    dst: *mut c_char,
    srcSize: c_int,
    maxDstSize: c_int,
    cLevel: c_int,
) -> c_int {
    LZ4_compress_HC(src, dst, srcSize, maxDstSize, cLevel)
}

/// Deprecated HC compression function. Use `LZ4_compress_HC_extStateHC()` instead.
#[no_mangle]
pub unsafe extern "C" fn LZ4_compressHC_withStateHC(
    state: *mut c_void,
    src: *const c_char,
    dst: *mut c_char,
    srcSize: c_int,
) -> c_int {
    LZ4_compress_HC_extStateHC(state, src, dst, srcSize, LZ4_compressBound(srcSize), 0)
}

/// Deprecated HC compression function. Use `LZ4_compress_HC_extStateHC()` instead.
#[no_mangle]
pub unsafe extern "C" fn LZ4_compressHC_limitedOutput_withStateHC(
    state: *mut c_void,
    src: *const c_char,
    dst: *mut c_char,
    srcSize: c_int,
    maxDstSize: c_int,
) -> c_int {
    LZ4_compress_HC_extStateHC(state, src, dst, srcSize, maxDstSize, 0)
}

/// Deprecated HC compression function. Use `LZ4_compress_HC_extStateHC()` instead.
#[no_mangle]
pub unsafe extern "C" fn LZ4_compressHC2_withStateHC(
    state: *mut c_void,
    src: *const c_char,
    dst: *mut c_char,
    srcSize: c_int,
    cLevel: c_int,
) -> c_int {
    LZ4_compress_HC_extStateHC(state, src, dst, srcSize, LZ4_compressBound(srcSize), cLevel)
}

/// Deprecated HC compression function. Use `LZ4_compress_HC_extStateHC()` instead.
#[no_mangle]
pub unsafe extern "C" fn LZ4_compressHC2_limitedOutput_withStateHC(
    state: *mut c_void,
    src: *const c_char,
    dst: *mut c_char,
    srcSize: c_int,
    maxDstSize: c_int,
    cLevel: c_int,
) -> c_int {
    LZ4_compress_HC_extStateHC(state, src, dst, srcSize, maxDstSize, cLevel)
}

/// `LZ4_decompress_safe()` :
/// - `compressedSize` : is the exact complete size of the compressed block.
/// - `dstCapacity` : is the size of destination buffer (which must be already allocated),
///   presumed an upper bound of decompressed size.
/// - return : the number of bytes decompressed into destination buffer (necessarily
///   `<= dstCapacity`). If destination buffer is not large enough, decoding will
///   stop and output an error code (negative value). If the source stream is
///   detected malformed, the function will stop decoding and return a negative result.
///
/// Note 1 : This function is protected against malicious data packets: it will never write
/// outside `dst` buffer, nor read outside `source` buffer, even if the compressed block is
/// maliciously modified to order the decoder to do these actions. In such case, the decoder
/// stops immediately, and considers the compressed block malformed.
///
/// Note 2 : `compressedSize` and `dstCapacity` must be provided to the function, the
/// compressed block does not contain them.
#[no_mangle]
pub unsafe extern "C" fn LZ4_decompress_safe(
    source: *const c_char,
    dest: *mut c_char,
    compressedSize: c_int,
    maxDecompressedSize: c_int,
) -> c_int {
    if compressedSize < 0 || maxDecompressedSize < 0 || source.is_null() || dest.is_null() {
        return -1;
    }
    let src = slice::from_raw_parts(source as *const u8, compressedSize as usize);
    let dst = slice::from_raw_parts_mut(dest as *mut u8, maxDecompressedSize as usize);
    decompress_block(src, dst).map_or(-1, |n| n as c_int)
}

/// `LZ4_decompress_safe_usingDict()` :
/// Works the same as a combination of `LZ4_setStreamDecode()` followed by
/// `LZ4_decompress_safe_continue()`. However, it's stateless: it doesn't need any
/// `LZ4_streamDecode_t` state. Dictionary is presumed stable: it must remain accessible
/// and unmodified during decompression.
///
/// Performance tip : Decompression speed can be substantially increased when
/// `dst == dictStart + dictSize`.
#[no_mangle]
pub unsafe extern "C" fn LZ4_decompress_safe_usingDict(
    source: *const c_char,
    dest: *mut c_char,
    compressedSize: c_int,
    maxDecompressedSize: c_int,
    dictStart: *const c_char,
    dictSize: c_int,
) -> c_int {
    if compressedSize < 0
        || maxDecompressedSize < 0
        || dictSize < 0
        || source.is_null()
        || dest.is_null()
        || (dictSize > 0 && dictStart.is_null())
    {
        return -1;
    }

    // Mirrors upstream `LZ4_decompress_safe_usingDict` (lz4.c:2715-2727):
    // dispatch by dict layout to the corresponding specialised decoder.
    if dictSize == 0 {
        return LZ4_decompress_safe(source, dest, compressedSize, maxDecompressedSize);
    }
    let src = slice::from_raw_parts(source as *const u8, compressedSize as usize);
    let dst = slice::from_raw_parts_mut(dest as *mut u8, maxDecompressedSize as usize);
    let dict = slice::from_raw_parts(dictStart as *const u8, dictSize as usize);

    let dict_end = (dictStart as *const u8).add(dictSize as usize);
    if dict_end == dest as *const u8 {
        // Contiguous prefix (`dictStart + dictSize == dest`). Upstream
        // routes to `LZ4_decompress_safe_withPrefix64k` when
        // `dictSize >= 64 KB - 1` and to `LZ4_decompress_safe_withSmallPrefix`
        // otherwise; both rely on the prefix bytes lying immediately before
        // `dest` in memory and read them via implicit pointer arithmetic.
        // The Rust ext-dict decoder reads the same bytes through an explicit
        // dict slice, producing byte-equivalent output, so both branches map
        // to the same call here. (A future pass could specialise these with
        // unsafe pointer reads from `dst.as_ptr().sub(prefix_size)` if the
        // benchmark ever shows a measurable gap.)
        let _is_prefix_64k = dictSize as usize >= 64 * 1024 - 1;
        return decompress_block_with_dict(src, dst, dict).map_or(-1, |n| n as c_int);
    }

    // forceExtDict path: dictionary lives in a separate buffer.
    decompress_block_with_dict(src, dst, dict).map_or(-1, |n| n as c_int)
}

/// `LZ4_decompress_safe_partial()` :
/// Decompress an LZ4 compressed block, of size `srcSize` at position `src`, into destination
/// buffer `dst` of size `dstCapacity`. Up to `targetOutputSize` bytes will be decoded. The
/// function stops decoding on reaching this objective. This can be useful to boost performance
/// whenever only the beginning of a block is required.
///
/// - return : the number of bytes decoded in `dst` (necessarily `<= targetOutputSize`). If
///   source stream is detected malformed, function returns a negative result.
///
/// Note 1 : return can be `< targetOutputSize`, if compressed block contains less data.
/// Note 2 : `targetOutputSize` must be `<= dstCapacity`.
/// Note 3 : If `srcSize` is the exact size of the block, then `targetOutputSize` can be any
///          value, including larger than the block's decompressed size. The function will,
///          at most, generate block's decompressed size.
/// Note 4 : If `srcSize` is _larger_ than block's compressed size, then `targetOutputSize`
///          **MUST** be `<=` block's decompressed size. Otherwise, *silent corruption will occur*.
#[no_mangle]
pub unsafe extern "C" fn LZ4_decompress_safe_partial(
    source: *const c_char,
    dest: *mut c_char,
    compressedSize: c_int,
    targetOutputSize: c_int,
    dstCapacity: c_int,
) -> c_int {
    if compressedSize < 0
        || targetOutputSize < 0
        || dstCapacity < 0
        || source.is_null()
        || dest.is_null()
    {
        return -1;
    }
    let src = slice::from_raw_parts(source as *const u8, compressedSize as usize);
    let dst = slice::from_raw_parts_mut(dest as *mut u8, dstCapacity as usize);
    let target = cmp::min(targetOutputSize as usize, dst.len());
    decompress_block_partial(src, dst, target).map_or(-1, |n| n as c_int)
}

/// `LZ4_decompress_safe_partial_usingDict()` :
/// Behaves the same as `LZ4_decompress_safe_partial()` with the added ability to specify a
/// memory segment for past data.
///
/// Performance tip : Decompression speed can be substantially increased when
/// `dst == dictStart + dictSize`.
#[no_mangle]
pub unsafe extern "C" fn LZ4_decompress_safe_partial_usingDict(
    source: *const c_char,
    dest: *mut c_char,
    compressedSize: c_int,
    targetOutputSize: c_int,
    dstCapacity: c_int,
    dictStart: *const c_char,
    dictSize: c_int,
) -> c_int {
    if compressedSize < 0
        || targetOutputSize < 0
        || dstCapacity < 0
        || dictSize < 0
        || source.is_null()
        || dest.is_null()
        || (dictSize > 0 && dictStart.is_null())
    {
        return -1;
    }

    // Mirrors upstream `LZ4_decompress_safe_partial_usingDict` (lz4.c:2730-2743).
    if dictSize == 0 {
        return LZ4_decompress_safe_partial(
            source,
            dest,
            compressedSize,
            targetOutputSize,
            dstCapacity,
        );
    }
    let src = slice::from_raw_parts(source as *const u8, compressedSize as usize);
    let dst = slice::from_raw_parts_mut(dest as *mut u8, dstCapacity as usize);
    let dict = slice::from_raw_parts(dictStart as *const u8, dictSize as usize);

    let dict_end = (dictStart as *const u8).add(dictSize as usize);
    if dict_end == dest as *const u8 {
        // Contiguous prefix — see `LZ4_decompress_safe_usingDict` for the
        // rationale on why both upstream prefix specialisations collapse to
        // the same Rust call.
        let _is_prefix_64k = dictSize as usize >= 64 * 1024 - 1;
        return decompress_block_partial_with_dict(
            src,
            dst,
            cmp::min(targetOutputSize as usize, dst.len()),
            dict,
        )
        .map_or(-1, |n| n as c_int);
    }

    // forceExtDict path.
    decompress_block_partial_with_dict(
        src,
        dst,
        cmp::min(targetOutputSize as usize, dst.len()),
        dict,
    )
    .map_or(-1, |n| n as c_int)
}

/// `LZ4_decoderRingBufferSize()` : v1.8.2+
/// Note : in a ring buffer scenario (optional), blocks are presumed decompressed next to each
/// other up to the moment there is not enough remaining space for next block
/// (`remainingSize < maxBlockSize`), at which stage it resumes from beginning of ring buffer.
/// When setting such a ring buffer for streaming decompression, provides the minimum size of
/// this ring buffer to be compatible with any source respecting `maxBlockSize` condition.
///
/// - return : minimum ring buffer size, or 0 if there is an error (invalid `maxBlockSize`).
#[no_mangle]
pub extern "C" fn LZ4_decoderRingBufferSize(maxBlockSize: c_int) -> c_int {
    if !(0..=LZ4_MAX_INPUT_SIZE).contains(&maxBlockSize) {
        return 0;
    }
    let max_block_size = cmp::max(maxBlockSize, 16);
    max_block_size.saturating_add((LZ4_DISTANCE_MAX + 1 + 14) as c_int)
}

/// Deprecated since v1.9.0; use `LZ4_decompress_safe_partial()` instead.
///
/// `LZ4_decompress_fast()` decompresses a block knowing only the uncompressed size. It is
/// no longer faster than `LZ4_decompress_safe()` and is not protected against malformed or
/// malicious inputs.
///
/// - `originalSize` : the uncompressed size to regenerate. `dst` must be already allocated,
///   its size must be `>= originalSize` bytes.
/// - return : number of bytes read from source buffer (== compressed size). The function
///   expects to finish at block's end exactly. If the source stream is detected
///   malformed, the function stops decoding and returns a negative result.
///
/// Note : since `LZ4_decompress_fast*()` doesn't know its `src` size, it may read an unknown
/// amount of input, past input buffer bounds. Match offsets are not validated, so match reads
/// from `src` may underflow too. Use these functions in trusted environments with trusted
/// data **only**.
#[no_mangle]
pub unsafe extern "C" fn LZ4_decompress_fast(
    source: *const c_char,
    dest: *mut c_char,
    originalSize: c_int,
) -> c_int {
    if originalSize < 0 || source.is_null() || dest.is_null() {
        return -1;
    }
    let dst = slice::from_raw_parts_mut(dest as *mut u8, originalSize as usize);
    decompress_block_exact_ptr(source as *const u8, dst, &[]).map_or(-1, |n| n as c_int)
}

/// Deprecated; use `LZ4_decompress_safe_partial_usingDict()` instead.
/// Variant of `LZ4_decompress_fast()` accepting an external dictionary. Same security
/// caveats apply: only use with trusted data.
#[no_mangle]
pub unsafe extern "C" fn LZ4_decompress_fast_usingDict(
    source: *const c_char,
    dest: *mut c_char,
    originalSize: c_int,
    dictStart: *const c_char,
    dictSize: c_int,
) -> c_int {
    if originalSize < 0
        || dictSize < 0
        || source.is_null()
        || dest.is_null()
        || (dictSize > 0 && dictStart.is_null())
    {
        return -1;
    }
    let dst = slice::from_raw_parts_mut(dest as *mut u8, originalSize as usize);
    let dict = if dictSize > 0 {
        slice::from_raw_parts(dictStart as *const u8, dictSize as usize)
    } else {
        &[]
    };
    decompress_block_exact_ptr(source as *const u8, dst, dict).map_or(-1, |n| n as c_int)
}

/// Obsolete decompression function (since v1.8.0). Use `LZ4_decompress_fast()` instead.
#[no_mangle]
pub unsafe extern "C" fn LZ4_uncompress(
    source: *const c_char,
    dest: *mut c_char,
    outputSize: c_int,
) -> c_int {
    LZ4_decompress_fast(source, dest, outputSize)
}

/// Obsolete decompression function (since v1.8.0). Use `LZ4_decompress_safe()` instead.
#[no_mangle]
pub unsafe extern "C" fn LZ4_uncompress_unknownOutputSize(
    source: *const c_char,
    dest: *mut c_char,
    isize: c_int,
    maxOutputSize: c_int,
) -> c_int {
    LZ4_decompress_safe(source, dest, isize, maxOutputSize)
}

/// Obsolete streaming decoding function (since v1.7.0). Use `LZ4_decompress_safe_usingDict()`
/// instead.
#[no_mangle]
pub unsafe extern "C" fn LZ4_decompress_safe_withPrefix64k(
    source: *const c_char,
    dest: *mut c_char,
    compressedSize: c_int,
    maxDstSize: c_int,
) -> c_int {
    LZ4_decompress_safe_usingDict(
        source,
        dest,
        compressedSize,
        maxDstSize,
        if maxDstSize > 0 {
            dest.sub(cmp::min(maxDstSize as usize, LZ4_DISTANCE_MAX))
        } else {
            dest
        },
        cmp::min(maxDstSize.max(0) as usize, LZ4_DISTANCE_MAX) as c_int,
    )
}

/// Obsolete streaming decoding function (since v1.7.0). Use `LZ4_decompress_fast_usingDict()`
/// instead.
#[no_mangle]
pub unsafe extern "C" fn LZ4_decompress_fast_withPrefix64k(
    source: *const c_char,
    dest: *mut c_char,
    originalSize: c_int,
) -> c_int {
    LZ4_decompress_fast_usingDict(
        source,
        dest,
        originalSize,
        if originalSize > 0 {
            dest.sub(cmp::min(originalSize as usize, LZ4_DISTANCE_MAX))
        } else {
            dest
        },
        cmp::min(originalSize.max(0) as usize, LZ4_DISTANCE_MAX) as c_int,
    )
}

/// Deprecated; consider migrating towards `LZ4_decompress_safe_continue()` instead.
/// (Note that the contract differs: that variant requires the block's compressed size,
/// instead of decompressed size.)
///
/// Streaming variant of `LZ4_decompress_fast()` that uses the previously decoded data as a
/// dictionary. Same security caveats apply as `LZ4_decompress_fast()`: use only with trusted
/// data.
#[no_mangle]
pub unsafe extern "C" fn LZ4_decompress_fast_continue(
    stream: *mut LZ4StreamDecode,
    source: *const c_char,
    dest: *mut c_char,
    originalSize: c_int,
) -> c_int {
    if stream.is_null() || originalSize < 0 || source.is_null() || dest.is_null() {
        return -1;
    }
    let ctx = &mut *(stream as *mut DecodeStreamCtx);
    let dst = slice::from_raw_parts_mut(dest as *mut u8, originalSize as usize);
    match decompress_block_exact_ptr(source as *const u8, dst, &ctx.dictionary) {
        Some(n) => {
            append_hc_dictionary(&mut ctx.dictionary, dst);
            n as c_int
        }
        None => -1,
    }
}

/// Tells when an `LZ4F_*` function result is an error code.
#[no_mangle]
pub extern "C" fn LZ4F_isError(code: size_t) -> c_uint {
    (code > lz4f_error(LZ4F_ERROR_MAX_CODE)) as c_uint
}

/// Returns the error code string corresponding to `code`; for debugging.
#[no_mangle]
pub extern "C" fn LZ4F_getErrorName(code: size_t) -> *const c_char {
    match code {
        ERROR_MAX_BLOCK_SIZE_INVALID => ERROR_MAX_BLOCK_SIZE_NAME.as_ptr() as *const c_char,
        ERROR_BLOCK_MODE_INVALID => ERROR_BLOCK_MODE_NAME.as_ptr() as *const c_char,
        ERROR_PARAMETER_INVALID => ERROR_PARAMETER_INVALID_NAME.as_ptr() as *const c_char,
        ERROR_COMPRESSION_LEVEL_INVALID => ERROR_COMPRESSION_LEVEL_NAME.as_ptr() as *const c_char,
        ERROR_HEADER_VERSION_WRONG => ERROR_HEADER_VERSION_NAME.as_ptr() as *const c_char,
        ERROR_BLOCK_CHECKSUM_INVALID => ERROR_BLOCK_CHECKSUM_NAME.as_ptr() as *const c_char,
        ERROR_RESERVED_FLAG_SET => ERROR_RESERVED_FLAG_NAME.as_ptr() as *const c_char,
        ERROR_ALLOCATION_FAILED => ERROR_ALLOCATION_FAILED_NAME.as_ptr() as *const c_char,
        ERROR_SRC_SIZE_TOO_LARGE => ERROR_SRC_SIZE_TOO_LARGE_NAME.as_ptr() as *const c_char,
        ERROR_FRAME_SIZE_WRONG => ERROR_FRAME_SIZE_NAME.as_ptr() as *const c_char,
        ERROR_FRAME_TYPE_UNKNOWN => ERROR_FRAME_TYPE_NAME.as_ptr() as *const c_char,
        ERROR_SRC_PTR_WRONG => ERROR_SRC_PTR_NAME.as_ptr() as *const c_char,
        ERROR_DECOMPRESSION_FAILED => ERROR_DECOMPRESSION_FAILED_NAME.as_ptr() as *const c_char,
        ERROR_HEADER_CHECKSUM_INVALID => ERROR_HEADER_CHECKSUM_NAME.as_ptr() as *const c_char,
        ERROR_DST_TOO_SMALL => ERROR_DST_NAME.as_ptr() as *const c_char,
        ERROR_BAD_HEADER => ERROR_BAD_HEADER_NAME.as_ptr() as *const c_char,
        ERROR_CHECKSUM_INVALID => ERROR_CHECKSUM_NAME.as_ptr() as *const c_char,
        ERROR_FRAME_DECODING_ALREADY_STARTED => {
            ERROR_FRAME_DECODING_ALREADY_STARTED_NAME.as_ptr() as *const c_char
        }
        ERROR_COMPRESSION_STATE_UNINITIALIZED => {
            ERROR_COMPRESSION_STATE_UNINITIALIZED_NAME.as_ptr() as *const c_char
        }
        ERROR_PARAMETER_NULL => ERROR_PARAMETER_NULL_NAME.as_ptr() as *const c_char,
        ERROR_IO_WRITE => ERROR_IO_WRITE_NAME.as_ptr() as *const c_char,
        ERROR_IO_READ => ERROR_IO_READ_NAME.as_ptr() as *const c_char,
        ERROR_GENERIC => ERROR_GENERIC_NAME.as_ptr() as *const c_char,
        _ => ERROR_UNSPECIFIED_NAME.as_ptr() as *const c_char,
    }
}

/// Returns the `LZ4F_errorCodes` enum value corresponding to a function result.
/// Returns 0 (`LZ4F_OK_NoError`) when the result is not an error.
#[no_mangle]
pub extern "C" fn LZ4F_getErrorCode(code: size_t) -> c_uint {
    if LZ4F_isError(code) == 0 {
        0
    } else {
        (usize::MAX - code + 1) as c_uint
    }
}

/// Returns the value of `LZ4F_VERSION` the library was compiled with.
#[no_mangle]
pub extern "C" fn LZ4F_getVersion() -> c_uint {
    LZ4F_VERSION
}

/// Returns the maximum allowed compression level (currently 12). Available since v1.8.0.
#[no_mangle]
pub extern "C" fn LZ4F_compressionLevel_max() -> c_int {
    LZ4HC_CLEVEL_MAX
}

/// `LZ4F_getBlockSize()` :
/// - return : in scalar format (`size_t`), the maximum block size associated with
///   `blockSizeID`, or an error code (can be tested using `LZ4F_isError()`) if
///   `blockSizeID` is invalid.
#[no_mangle]
pub extern "C" fn LZ4F_getBlockSize(blockSizeID: c_uint) -> size_t {
    let blockSizeID = if blockSizeID == 0 { 4 } else { blockSizeID };
    if !(4..=7).contains(&blockSizeID) {
        return ERROR_MAX_BLOCK_SIZE_INVALID;
    }
    block_max_size(blockSizeID as u8)
}

/// `LZ4F_createCompressionContext()` :
/// The first thing to do is to create a compressionContext object, which will keep track of
/// operation state during streaming compression. `version` provided MUST be `LZ4F_VERSION`.
/// It is intended to track potential version mismatch, notably when using DLL. The function
/// provides a pointer to a fully allocated `LZ4F_cctx` object. `cctxPtr` MUST be `!= NULL`.
/// If return `!= zero`, context creation failed. A created compression context can be employed
/// multiple times for consecutive streaming operations. Once all streaming compression jobs
/// are completed, the state object can be released using `LZ4F_freeCompressionContext()`.
#[no_mangle]
pub unsafe extern "C" fn LZ4F_createCompressionContext(
    ctx: &mut LZ4FCompressionContext,
    version: c_uint,
) -> LZ4FErrorCode {
    if version != LZ4F_VERSION {
        return ERROR_PARAMETER_INVALID;
    }
    let inner = Box::new(CompressionCtx {
        prefs: FramePrefs::default(),
        content_hasher: XxHash32::new(0),
        dictionary: Vec::new(),
        pending: Vec::new(),
        total_input: 0,
        external_dictionary: false,
        started: false,
    });
    ctx.0 = Box::into_raw(inner) as *mut c_void;
    0
}

/// Releases an `LZ4F_cctx` previously created by `LZ4F_createCompressionContext()`.
/// Always successful: the return value can be ignored. Works fine with `NULL` input pointers
/// (does nothing).
#[no_mangle]
pub unsafe extern "C" fn LZ4F_freeCompressionContext(ctx: LZ4FCompressionContext) -> LZ4FErrorCode {
    if !ctx.0.is_null() {
        drop(Box::from_raw(ctx.0 as *mut CompressionCtx));
    }
    0
}

/// Context size inspection (v1.10.1+). Returns the total memory footprint of the provided
/// compression context, or 0 if `ctx` is null.
#[no_mangle]
pub unsafe extern "C" fn LZ4F_cctx_size(ctx: LZ4FCompressionContext) -> size_t {
    if ctx.0.is_null() {
        0
    } else {
        std::mem::size_of::<CompressionCtx>()
    }
}

/// `LZ4F_compressBegin()` :
/// Will write the frame header into `dstBuffer`. `dstCapacity` must be
/// `>= LZ4F_HEADER_SIZE_MAX` bytes. `prefsPtr` is optional: NULL can be provided to set all
/// preferences to default.
///
/// - return : number of bytes written into `dstBuffer` for the header, or an error code
///   (which can be tested using `LZ4F_isError()`).
#[no_mangle]
pub unsafe extern "C" fn LZ4F_compressBegin(
    ctx: LZ4FCompressionContext,
    dstBuffer: *mut u8,
    dstMaxSize: size_t,
    preferencesPtr: *const LZ4FPreferences,
) -> LZ4FErrorCode {
    if ctx.0.is_null() || dstBuffer.is_null() {
        return ERROR_PARAMETER_NULL;
    }
    let inner = &mut *(ctx.0 as *mut CompressionCtx);
    inner.prefs = preferences_from_ptr(preferencesPtr);
    inner.content_hasher = XxHash32::new(0);
    inner.dictionary.clear();
    inner.pending.clear();
    inner.total_input = 0;
    inner.external_dictionary = false;
    inner.started = true;
    let header = frame_header(inner.prefs);
    if dstMaxSize < header.len() {
        return ERROR_DST_TOO_SMALL;
    }
    ptr::copy_nonoverlapping(header.as_ptr(), dstBuffer, header.len());
    header.len()
}

/// `LZ4F_compressBegin_usingDict()` : stable since v1.10
/// Initialises dictionary compression streaming, and writes the frame header into `dstBuffer`.
/// `dstCapacity` must be `>= LZ4F_HEADER_SIZE_MAX` bytes. `prefsPtr` is optional: one may
/// provide NULL as argument, however it's the only way to provide `dictID` in the frame
/// header. `dictBuffer` must outlive the compression session.
///
/// - return : number of bytes written into `dstBuffer` for the header, or an error code
///   (which can be tested using `LZ4F_isError()`).
///
/// NOTE: The LZ4Frame spec allows each independent block to be compressed with the dictionary,
/// but this entry supports a more limited scenario, where only the first block uses the
/// dictionary. For larger inputs, consider `LZ4F_compressFrame_usingCDict()`.
#[no_mangle]
pub unsafe extern "C" fn LZ4F_compressBegin_usingDict(
    ctx: LZ4FCompressionContext,
    dstBuffer: *mut c_void,
    dstCapacity: size_t,
    dictBuffer: *const c_void,
    dictSize: size_t,
    preferencesPtr: *const LZ4FPreferences,
) -> LZ4FErrorCode {
    if dictSize > 0 && dictBuffer.is_null() {
        return ERROR_SRC_PTR_WRONG;
    }
    let written = LZ4F_compressBegin(ctx, dstBuffer as *mut u8, dstCapacity, preferencesPtr);
    if LZ4F_isError(written) != 0 {
        return written;
    }
    if dictSize > 0 {
        let inner = &mut *(ctx.0 as *mut CompressionCtx);
        let dict = slice::from_raw_parts(dictBuffer as *const u8, dictSize);
        let keep = cmp::min(dict.len(), LZ4_DISTANCE_MAX);
        inner.dictionary.clear();
        inner
            .dictionary
            .extend_from_slice(&dict[dict.len() - keep..]);
        inner.external_dictionary = true;
    }
    written
}

/// `LZ4F_createCDict()` : stable since v1.10
/// When compressing multiple messages / blocks using the same dictionary, it's recommended
/// to initialise it just once. `LZ4F_createCDict()` will create a digested dictionary,
/// ready to start future compression operations without startup delay. An `LZ4F_CDict` can
/// be created once and shared by multiple threads concurrently, since its usage is read-only.
/// `dictBuffer` can be released after `LZ4F_CDict` creation, since its content is copied
/// within the CDict.
#[no_mangle]
pub unsafe extern "C" fn LZ4F_createCDict(
    dictBuffer: *const c_void,
    dictSize: size_t,
) -> *mut LZ4FCDict {
    if dictSize > 0 && dictBuffer.is_null() {
        return ptr::null_mut();
    }
    let mut ctx = CDictCtx::default();
    if dictSize > 0 {
        let dict = slice::from_raw_parts(dictBuffer as *const u8, dictSize);
        let keep = cmp::min(dict.len(), LZ4_DISTANCE_MAX);
        ctx.dictionary.extend_from_slice(&dict[dict.len() - keep..]);
    }
    Box::into_raw(Box::new(ctx)) as *mut LZ4FCDict
}

/// Releases an `LZ4F_CDict` created by `LZ4F_createCDict()`. Does nothing if `cdict` is null.
#[no_mangle]
pub unsafe extern "C" fn LZ4F_freeCDict(cdict: *mut LZ4FCDict) {
    if !cdict.is_null() {
        drop(Box::from_raw(cdict as *mut CDictCtx));
    }
}

/// `LZ4F_compressBegin_usingCDict()` : stable since v1.10
/// Initialises streaming dictionary compression, and writes the frame header into `dstBuffer`.
/// `dstCapacity` must be `>= LZ4F_HEADER_SIZE_MAX` bytes. `prefsPtr` is optional: one may
/// provide NULL as argument, but note that it's the only way to insert a `dictID` in the
/// frame header. `cdict` must outlive the compression session.
///
/// - return : number of bytes written into `dstBuffer` for the header, or an error code,
///   which can be tested using `LZ4F_isError()`.
#[no_mangle]
pub unsafe extern "C" fn LZ4F_compressBegin_usingCDict(
    ctx: LZ4FCompressionContext,
    dstBuffer: *mut c_void,
    dstCapacity: size_t,
    cdict: *const LZ4FCDict,
    preferencesPtr: *const LZ4FPreferences,
) -> size_t {
    if cdict.is_null() {
        return LZ4F_compressBegin(ctx, dstBuffer as *mut u8, dstCapacity, preferencesPtr);
    }
    let dict = &*(cdict as *const CDictCtx);
    LZ4F_compressBegin_usingDict(
        ctx,
        dstBuffer,
        dstCapacity,
        dict.dictionary.as_ptr() as *const c_void,
        dict.dictionary.len(),
        preferencesPtr,
    )
}

/// `LZ4F_compressBound()` :
/// Provides minimum `dstCapacity` required to guarantee success of `LZ4F_compressUpdate()`,
/// given a `srcSize` and preferences, for a worst case scenario. When `srcSize == 0`,
/// `LZ4F_compressBound()` provides an upper bound for `LZ4F_flush()` and `LZ4F_compressEnd()`
/// instead. Note that the result is only valid for a single invocation of
/// `LZ4F_compressUpdate()`. When invoking `LZ4F_compressUpdate()` multiple times, if the
/// output buffer is gradually filled up instead of emptied and re-used from its start, one
/// must check if there is enough remaining capacity before each invocation, using
/// `LZ4F_compressBound()`.
///
/// `prefsPtr` is optional: when NULL is provided, preferences will be set to cover the
/// worst case scenario.
///
/// tech details: if automatic flushing is not enabled, the return value includes the
/// possibility that internal buffer might already be filled by up to `(blockSize-1)` bytes.
/// It also includes frame footer (ending + checksum), since it might be generated by
/// `LZ4F_compressEnd()`. It does not include the frame header, as it was already generated
/// by `LZ4F_compressBegin()`.
#[no_mangle]
pub unsafe extern "C" fn LZ4F_compressBound(
    srcSize: size_t,
    preferencesPtr: *const LZ4FPreferences,
) -> size_t {
    let prefs = preferences_from_ptr(preferencesPtr);
    let checksums = if prefs.block_checksum { 4 } else { 0 };
    let block_max = block_max_size(prefs.block_size_id);
    let buffered = if prefs.auto_flush { 0 } else { block_max };
    let total = srcSize.saturating_add(buffered);
    let blocks = if total == 0 {
        1
    } else {
        total.div_ceil(block_max)
    };
    total + blocks * (4 + checksums) + 16
}

/// `LZ4F_compressFrameBound()` :
/// Returns the maximum possible compressed size with `LZ4F_compressFrame()` given `srcSize`
/// and preferences. `preferencesPtr` is optional: it can be replaced by NULL, in which case
/// the function will assume default preferences.
///
/// Note : this result is only usable with `LZ4F_compressFrame()`. It may also be relevant to
/// `LZ4F_compressUpdate()` _only if_ no `flush()` operation is ever performed.
#[no_mangle]
pub unsafe extern "C" fn LZ4F_compressFrameBound(
    srcSize: size_t,
    preferencesPtr: *const LZ4FPreferences,
) -> size_t {
    LZ4F_compressBound(srcSize, preferencesPtr) + 19 + 4
}

/// `LZ4F_compressFrame()` :
/// Compress `srcBuffer` content into an LZ4-compressed frame. It's a one shot operation,
/// all input content is consumed, and all output is generated.
///
/// Note : it's a stateless operation (no `LZ4F_cctx` state needed).
///
/// - `dstCapacity` MUST be `>= LZ4F_compressFrameBound(srcSize, preferencesPtr)`.
/// - `preferencesPtr` is optional: one can provide NULL, in which case all preferences are
///   set to default.
/// - return : number of bytes written into `dstBuffer`, or an error code if it fails (can
///   be tested using `LZ4F_isError()`).
#[no_mangle]
pub unsafe extern "C" fn LZ4F_compressFrame(
    dstBuffer: *mut c_void,
    dstCapacity: size_t,
    srcBuffer: *const c_void,
    srcSize: size_t,
    preferencesPtr: *const LZ4FPreferences,
) -> size_t {
    if dstBuffer.is_null() || (srcSize > 0 && srcBuffer.is_null()) {
        return ERROR_PARAMETER_NULL;
    }
    let mut preferences;
    let begin_preferences = if preferencesPtr.is_null() {
        ptr::null()
    } else {
        preferences = (*preferencesPtr).clone();
        if preferences.frame_info.content_size != 0 {
            preferences.frame_info.content_size = srcSize as u64;
        }
        &preferences
    };
    let mut ctx = LZ4FCompressionContext(ptr::null_mut());
    let code = LZ4F_createCompressionContext(&mut ctx, LZ4F_VERSION);
    if LZ4F_isError(code) != 0 {
        return code;
    }

    let dst = dstBuffer as *mut u8;
    let mut pos = LZ4F_compressBegin(ctx, dst, dstCapacity, begin_preferences);
    if LZ4F_isError(pos) != 0 {
        LZ4F_freeCompressionContext(ctx);
        return pos;
    }
    let update = LZ4F_compressUpdate(
        ctx,
        dst.add(pos),
        dstCapacity.saturating_sub(pos),
        srcBuffer as *const u8,
        srcSize,
        ptr::null(),
    );
    if LZ4F_isError(update) != 0 {
        LZ4F_freeCompressionContext(ctx);
        return update;
    }
    pos += update;
    let end = LZ4F_compressEnd(
        ctx,
        dst.add(pos),
        dstCapacity.saturating_sub(pos),
        ptr::null(),
    );
    LZ4F_freeCompressionContext(ctx);
    if LZ4F_isError(end) != 0 {
        return end;
    }
    pos + end
}

/// `LZ4F_compressFrame_usingCDict()` : stable since v1.10
/// Compress an entire `srcBuffer` into a valid LZ4 frame using a digested Dictionary.
/// `cctx` must point to a context created by `LZ4F_createCompressionContext()`. If
/// `cdict == NULL`, compress without a dictionary. `dstBuffer` MUST be
/// `>= LZ4F_compressFrameBound(srcSize, preferencesPtr)`. If this condition is not
/// respected, function will fail (return an errorCode). The `LZ4F_preferences_t` structure
/// is optional: one may provide NULL as argument, but it's not recommended, as it's the
/// only way to provide `dictID` in the frame header.
///
/// - return : number of bytes written into `dstBuffer`, or an error code if it fails (can
///   be tested using `LZ4F_isError()`).
///
/// Note: for larger inputs generating multiple independent blocks, this entry point uses
/// the dictionary for each block.
#[no_mangle]
pub unsafe extern "C" fn LZ4F_compressFrame_usingCDict(
    ctx: LZ4FCompressionContext,
    dstBuffer: *mut c_void,
    dstCapacity: size_t,
    srcBuffer: *const c_void,
    srcSize: size_t,
    cdict: *const LZ4FCDict,
    preferencesPtr: *const LZ4FPreferences,
) -> size_t {
    if ctx.0.is_null() || dstBuffer.is_null() || (srcSize > 0 && srcBuffer.is_null()) {
        return ERROR_PARAMETER_NULL;
    }
    let dst = dstBuffer as *mut u8;
    let mut pos = LZ4F_compressBegin_usingCDict(ctx, dstBuffer, dstCapacity, cdict, preferencesPtr);
    if LZ4F_isError(pos) != 0 {
        return pos;
    }
    let update = LZ4F_compressUpdate(
        ctx,
        dst.add(pos),
        dstCapacity.saturating_sub(pos),
        srcBuffer as *const u8,
        srcSize,
        ptr::null(),
    );
    if LZ4F_isError(update) != 0 {
        return update;
    }
    pos += update;
    let end = LZ4F_compressEnd(
        ctx,
        dst.add(pos),
        dstCapacity.saturating_sub(pos),
        ptr::null(),
    );
    if LZ4F_isError(end) != 0 {
        return end;
    }
    pos + end
}

/// `LZ4F_compressUpdate()` :
/// Can be called repetitively to compress as much data as necessary.
///
/// Important rule: `dstCapacity` MUST be large enough to ensure operation success even in
/// worst case situations. This value is provided by `LZ4F_compressBound()`. If this
/// condition is not respected, `LZ4F_compressUpdate()` will fail (result is an errorCode).
/// After an error, the state is left in a UB state, and must be re-initialised or freed.
///
/// If previously an uncompressed block was written, buffered data is flushed before
/// appending compressed data is continued.
///
/// `cOptPtr` is optional: NULL can be provided, in which case all options are set to default.
///
/// - return : number of bytes written into `dstBuffer` (it can be zero, meaning input data
///   was just buffered), or an error code if it fails (which can be tested using
///   `LZ4F_isError()`).
#[no_mangle]
pub unsafe extern "C" fn LZ4F_compressUpdate(
    ctx: LZ4FCompressionContext,
    dstBuffer: *mut u8,
    dstCapacity: size_t,
    srcBuffer: *const u8,
    srcSize: size_t,
    _cOptPtr: *const LZ4FCompressOptions,
) -> size_t {
    if ctx.0.is_null() || dstBuffer.is_null() || (srcSize > 0 && srcBuffer.is_null()) {
        return ERROR_PARAMETER_NULL;
    }
    let inner = &mut *(ctx.0 as *mut CompressionCtx);
    if !inner.started {
        return ERROR_COMPRESSION_STATE_UNINITIALIZED;
    }
    let src = if srcSize > 0 {
        slice::from_raw_parts(srcBuffer, srcSize)
    } else {
        &[]
    };
    let block_max = block_max_size(inner.prefs.block_size_id);
    let dst = slice::from_raw_parts_mut(dstBuffer, dstCapacity);
    if inner.prefs.auto_flush {
        return compress_frame_update_blocks(inner, src, dst, true);
    }

    let mut written = 0usize;
    if !inner.pending.is_empty() {
        let fill = cmp::min(block_max - inner.pending.len(), src.len());
        inner.pending.extend_from_slice(&src[..fill]);
        if inner.pending.len() < block_max {
            return 0;
        }

        let pending = std::mem::take(&mut inner.pending);
        let n = compress_frame_update_block(inner, &pending, dst);
        inner.pending = pending;
        inner.pending.clear();
        if LZ4F_isError(n) != 0 {
            return n;
        }
        written += n;
        let rest = &src[fill..];
        let full_len = rest.len() / block_max * block_max;
        if full_len > 0 {
            let Some(remaining_dst) = dst.get_mut(written..) else {
                return ERROR_DST_TOO_SMALL;
            };
            let n = compress_frame_update_blocks(inner, &rest[..full_len], remaining_dst, false);
            if LZ4F_isError(n) != 0 {
                return n;
            }
            written += n;
        }
        if full_len < rest.len() {
            inner.pending.extend_from_slice(&rest[full_len..]);
        }
        return written;
    }

    let full_len = src.len() / block_max * block_max;
    if full_len > 0 {
        let n = compress_frame_update_blocks(inner, &src[..full_len], dst, false);
        if LZ4F_isError(n) != 0 {
            return n;
        }
        written += n;
    }
    if full_len < src.len() {
        inner.pending.extend_from_slice(&src[full_len..]);
    }
    written
}

fn compress_frame_update_block(inner: &mut CompressionCtx, src: &[u8], dst: &mut [u8]) -> size_t {
    match (
        inner.prefs.block_checksum,
        inner.prefs.content_checksum,
        inner.prefs.block_independent,
    ) {
        (false, false, false) => {
            compress_frame_update_block_flags::<false, false, false>(inner, src, dst)
        }
        (false, false, true) => {
            compress_frame_update_block_flags::<false, false, true>(inner, src, dst)
        }
        (false, true, false) => {
            compress_frame_update_block_flags::<false, true, false>(inner, src, dst)
        }
        (false, true, true) => {
            compress_frame_update_block_flags::<false, true, true>(inner, src, dst)
        }
        (true, false, false) => {
            compress_frame_update_block_flags::<true, false, false>(inner, src, dst)
        }
        (true, false, true) => {
            compress_frame_update_block_flags::<true, false, true>(inner, src, dst)
        }
        (true, true, false) => {
            compress_frame_update_block_flags::<true, true, false>(inner, src, dst)
        }
        (true, true, true) => {
            compress_frame_update_block_flags::<true, true, true>(inner, src, dst)
        }
    }
}

fn compress_frame_update_block_flags<
    const BLOCK_CHECKSUM: bool,
    const CONTENT_CHECKSUM: bool,
    const BLOCK_INDEPENDENT: bool,
>(
    inner: &mut CompressionCtx,
    src: &[u8],
    dst: &mut [u8],
) -> size_t {
    let checksum_len = if BLOCK_CHECKSUM { 4 } else { 0 };
    let raw_needed = 4 + src.len() + checksum_len;
    if dst.len() < raw_needed {
        return ERROR_DST_TOO_SMALL;
    }

    let compressed_len = compress_frame_block(src, &mut dst[4..], &inner.prefs, &inner.dictionary);
    let (block_len, raw) = match compressed_len {
        Some(len) if len < src.len() => (len, false),
        _ => {
            dst[4..4 + src.len()].copy_from_slice(src);
            (src.len(), true)
        }
    };

    let block_size = (block_len as u32) | if raw { 0x8000_0000 } else { 0 };
    dst[..4].copy_from_slice(&block_size.to_le_bytes());
    if CONTENT_CHECKSUM {
        inner.content_hasher.update(src);
    }
    inner.total_input = inner.total_input.saturating_add(src.len() as u64);
    if !BLOCK_INDEPENDENT {
        append_hc_dictionary(&mut inner.dictionary, src);
        inner.external_dictionary = false;
    } else if inner.external_dictionary {
        inner.dictionary.clear();
        inner.external_dictionary = false;
    }
    let needed = 4 + block_len + checksum_len;
    if BLOCK_CHECKSUM {
        let checksum = xxhash32(&dst[4..4 + block_len], 0);
        dst[4 + block_len..needed].copy_from_slice(&checksum.to_le_bytes());
    }
    needed
}

fn compress_frame_update_blocks(
    inner: &mut CompressionCtx,
    src: &[u8],
    dst: &mut [u8],
    emit_partial: bool,
) -> size_t {
    match (
        inner.prefs.block_checksum,
        inner.prefs.content_checksum,
        inner.prefs.block_independent,
    ) {
        (false, false, false) => {
            compress_frame_update_blocks_flags::<false, false, false>(inner, src, dst, emit_partial)
        }
        (false, false, true) => {
            compress_frame_update_blocks_flags::<false, false, true>(inner, src, dst, emit_partial)
        }
        (false, true, false) => {
            compress_frame_update_blocks_flags::<false, true, false>(inner, src, dst, emit_partial)
        }
        (false, true, true) => {
            compress_frame_update_blocks_flags::<false, true, true>(inner, src, dst, emit_partial)
        }
        (true, false, false) => {
            compress_frame_update_blocks_flags::<true, false, false>(inner, src, dst, emit_partial)
        }
        (true, false, true) => {
            compress_frame_update_blocks_flags::<true, false, true>(inner, src, dst, emit_partial)
        }
        (true, true, false) => {
            compress_frame_update_blocks_flags::<true, true, false>(inner, src, dst, emit_partial)
        }
        (true, true, true) => {
            compress_frame_update_blocks_flags::<true, true, true>(inner, src, dst, emit_partial)
        }
    }
}

fn compress_frame_update_blocks_flags<
    const BLOCK_CHECKSUM: bool,
    const CONTENT_CHECKSUM: bool,
    const BLOCK_INDEPENDENT: bool,
>(
    inner: &mut CompressionCtx,
    src: &[u8],
    dst: &mut [u8],
    emit_partial: bool,
) -> size_t {
    let block_max = block_max_size(inner.prefs.block_size_id);
    let mut written = 0usize;
    let mut chunks = src.chunks_exact(block_max);
    for chunk in &mut chunks {
        let Some(remaining_dst) = dst.get_mut(written..) else {
            return ERROR_DST_TOO_SMALL;
        };
        let n = compress_frame_update_block_flags::<
            BLOCK_CHECKSUM,
            CONTENT_CHECKSUM,
            BLOCK_INDEPENDENT,
        >(inner, chunk, remaining_dst);
        if LZ4F_isError(n) != 0 {
            return n;
        }
        written += n;
    }
    let remainder = chunks.remainder();
    if emit_partial && !remainder.is_empty() {
        let Some(remaining_dst) = dst.get_mut(written..) else {
            return ERROR_DST_TOO_SMALL;
        };
        let n = compress_frame_update_block_flags::<
            BLOCK_CHECKSUM,
            CONTENT_CHECKSUM,
            BLOCK_INDEPENDENT,
        >(inner, remainder, remaining_dst);
        if LZ4F_isError(n) != 0 {
            return n;
        }
        written += n;
    }
    written
}

/// `LZ4F_uncompressedUpdate()` :
/// Can be called repetitively to add data stored as uncompressed blocks.
///
/// Important rule: `dstCapacity` MUST be large enough to store the entire source buffer as
/// no compression is done for this operation. If this condition is not respected,
/// `LZ4F_uncompressedUpdate()` will fail (result is an errorCode). After an error, the
/// state is left in a UB state, and must be re-initialised or freed.
///
/// If previously a compressed block was written, buffered data is flushed first, before
/// appending uncompressed data is continued. This operation is only supported when
/// `LZ4F_blockIndependent` is used.
///
/// `cOptPtr` is optional: NULL can be provided, in which case all options are set to default.
///
/// - return : number of bytes written into `dstBuffer` (it can be zero, meaning input data
///   was just buffered), or an error code if it fails (which can be tested using
///   `LZ4F_isError()`).
#[no_mangle]
pub unsafe extern "C" fn LZ4F_uncompressedUpdate(
    ctx: LZ4FCompressionContext,
    dstBuffer: *mut c_void,
    dstCapacity: size_t,
    srcBuffer: *const c_void,
    srcSize: size_t,
    _cOptPtr: *const LZ4FCompressOptions,
) -> size_t {
    if ctx.0.is_null() || dstBuffer.is_null() || (srcSize > 0 && srcBuffer.is_null()) {
        return ERROR_PARAMETER_NULL;
    }
    let inner = &mut *(ctx.0 as *mut CompressionCtx);
    if !inner.started {
        return ERROR_COMPRESSION_STATE_UNINITIALIZED;
    }
    let src = if srcSize > 0 {
        slice::from_raw_parts(srcBuffer as *const u8, srcSize)
    } else {
        &[]
    };
    let dst = slice::from_raw_parts_mut(dstBuffer as *mut u8, dstCapacity);
    compress_frame_raw_blocks(inner, src, dst)
}

fn compress_frame_raw_block_flags<
    const BLOCK_CHECKSUM: bool,
    const CONTENT_CHECKSUM: bool,
    const BLOCK_INDEPENDENT: bool,
>(
    inner: &mut CompressionCtx,
    src: &[u8],
    dst: &mut [u8],
) -> size_t {
    let checksum_len = if BLOCK_CHECKSUM { 4 } else { 0 };
    let needed = 4 + src.len() + checksum_len;
    if dst.len() < needed {
        return ERROR_DST_TOO_SMALL;
    }
    let block_size = (src.len() as u32) | 0x8000_0000;
    dst[..4].copy_from_slice(&block_size.to_le_bytes());
    dst[4..4 + src.len()].copy_from_slice(src);
    if BLOCK_CHECKSUM {
        let checksum = xxhash32(&dst[4..4 + src.len()], 0);
        dst[4 + src.len()..needed].copy_from_slice(&checksum.to_le_bytes());
    }
    if CONTENT_CHECKSUM {
        inner.content_hasher.update(src);
    }
    inner.total_input = inner.total_input.saturating_add(src.len() as u64);
    if !BLOCK_INDEPENDENT {
        append_hc_dictionary(&mut inner.dictionary, src);
    } else if inner.external_dictionary {
        inner.dictionary.clear();
        inner.external_dictionary = false;
    }
    needed
}

fn compress_frame_raw_blocks(inner: &mut CompressionCtx, src: &[u8], dst: &mut [u8]) -> size_t {
    match (
        inner.prefs.block_checksum,
        inner.prefs.content_checksum,
        inner.prefs.block_independent,
    ) {
        (false, false, false) => {
            compress_frame_raw_blocks_flags::<false, false, false>(inner, src, dst)
        }
        (false, false, true) => {
            compress_frame_raw_blocks_flags::<false, false, true>(inner, src, dst)
        }
        (false, true, false) => {
            compress_frame_raw_blocks_flags::<false, true, false>(inner, src, dst)
        }
        (false, true, true) => {
            compress_frame_raw_blocks_flags::<false, true, true>(inner, src, dst)
        }
        (true, false, false) => {
            compress_frame_raw_blocks_flags::<true, false, false>(inner, src, dst)
        }
        (true, false, true) => {
            compress_frame_raw_blocks_flags::<true, false, true>(inner, src, dst)
        }
        (true, true, false) => {
            compress_frame_raw_blocks_flags::<true, true, false>(inner, src, dst)
        }
        (true, true, true) => compress_frame_raw_blocks_flags::<true, true, true>(inner, src, dst),
    }
}

fn compress_frame_raw_blocks_flags<
    const BLOCK_CHECKSUM: bool,
    const CONTENT_CHECKSUM: bool,
    const BLOCK_INDEPENDENT: bool,
>(
    inner: &mut CompressionCtx,
    src: &[u8],
    dst: &mut [u8],
) -> size_t {
    let block_max = block_max_size(inner.prefs.block_size_id);
    let mut written = 0usize;
    for chunk in src.chunks(block_max) {
        let Some(remaining_dst) = dst.get_mut(written..) else {
            return ERROR_DST_TOO_SMALL;
        };
        let n = compress_frame_raw_block_flags::<BLOCK_CHECKSUM, CONTENT_CHECKSUM, BLOCK_INDEPENDENT>(
            inner,
            chunk,
            remaining_dst,
        );
        if LZ4F_isError(n) != 0 {
            return n;
        }
        written += n;
    }
    written
}

/// `LZ4F_flush()` :
/// When data must be generated and sent immediately, without waiting for a block to be
/// completely filled, it's possible to call `LZ4F_flush()`. It will immediately compress
/// any data buffered within `cctx`.
///
/// `dstCapacity` must be large enough to ensure the operation will be successful. `cOptPtr`
/// is optional: it's possible to provide NULL, all options will be set to default.
///
/// - return : nb of bytes written into `dstBuffer` (can be zero, when there is no data
///   stored within `cctx`), or an error code if it fails (which can be tested using
///   `LZ4F_isError()`).
///
/// Note : `LZ4F_flush()` is guaranteed to be successful when
/// `dstCapacity >= LZ4F_compressBound(0, prefsPtr)`.
#[no_mangle]
pub unsafe extern "C" fn LZ4F_flush(
    ctx: LZ4FCompressionContext,
    dstBuffer: *mut u8,
    dstCapacity: size_t,
    _cOptPtr: *const LZ4FCompressOptions,
) -> size_t {
    if ctx.0.is_null() || dstBuffer.is_null() {
        return ERROR_PARAMETER_NULL;
    }
    let inner = &mut *(ctx.0 as *mut CompressionCtx);
    if !inner.started {
        return ERROR_COMPRESSION_STATE_UNINITIALIZED;
    }
    if inner.pending.is_empty() {
        return 0;
    }
    let dst = slice::from_raw_parts_mut(dstBuffer, dstCapacity);
    let pending = std::mem::take(&mut inner.pending);
    let n = compress_frame_update_block(inner, &pending, dst);
    if LZ4F_isError(n) == 0 {
        inner.pending.clear();
    } else {
        inner.pending = pending;
    }
    n
}

/// `LZ4F_compressEnd()` :
/// To properly finish an LZ4 frame, invoke `LZ4F_compressEnd()`. It will flush whatever
/// data remained within `cctx` (like `LZ4F_flush()`) and properly finalise the frame, with
/// an endMark and a checksum. `cOptPtr` is optional: NULL can be provided, in which case
/// all options will be set to default.
///
/// - return : nb of bytes written into `dstBuffer`, necessarily `>= 4` (endMark), or an
///   error code if it fails (which can be tested using `LZ4F_isError()`).
///
/// Note : `LZ4F_compressEnd()` is guaranteed to be successful when
/// `dstCapacity >= LZ4F_compressBound(0, prefsPtr)`. A successful call makes `cctx` available
/// again for another compression task.
#[no_mangle]
pub unsafe extern "C" fn LZ4F_compressEnd(
    ctx: LZ4FCompressionContext,
    dstBuffer: *mut u8,
    dstCapacity: size_t,
    _cOptPtr: *const LZ4FCompressOptions,
) -> size_t {
    if ctx.0.is_null() || dstBuffer.is_null() {
        return ERROR_PARAMETER_NULL;
    }
    let inner = &mut *(ctx.0 as *mut CompressionCtx);
    if !inner.started {
        return ERROR_COMPRESSION_STATE_UNINITIALIZED;
    }
    let footer_len = 4 + if inner.prefs.content_checksum { 4 } else { 0 };
    if dstCapacity < footer_len {
        return ERROR_DST_TOO_SMALL;
    }
    let dst = slice::from_raw_parts_mut(dstBuffer, dstCapacity);
    let mut pos = 0usize;
    if !inner.pending.is_empty() {
        let checksum_len = if inner.prefs.block_checksum { 4 } else { 0 };
        let max_pending_len = 4 + inner.pending.len() + checksum_len + footer_len;
        if dstCapacity < max_pending_len {
            return ERROR_DST_TOO_SMALL;
        }
        let pending = std::mem::take(&mut inner.pending);
        let n = compress_frame_update_block(inner, &pending, dst);
        if LZ4F_isError(n) != 0 {
            inner.pending = pending;
            return n;
        }
        pos += n;
    }
    if inner.prefs.content_size != 0 && inner.total_input != inner.prefs.content_size {
        return ERROR_FRAME_SIZE_WRONG;
    }
    if dstCapacity - pos < footer_len {
        return ERROR_DST_TOO_SMALL;
    }
    dst[pos..pos + 4].copy_from_slice(&0u32.to_le_bytes());
    if inner.prefs.content_checksum {
        dst[pos + 4..pos + 8].copy_from_slice(&inner.content_hasher.digest().to_le_bytes());
    }
    inner.started = false;
    pos + footer_len
}

/// `LZ4F_createDecompressionContext()` :
/// Create an `LZ4F_dctx` object, to track all decompression operations. `version` provided
/// MUST be `LZ4F_VERSION`. `dctxPtr` MUST be valid. The function fills `dctxPtr` with the
/// value of a pointer to an allocated and initialised `LZ4F_dctx` object. The return is an
/// errorCode, which can be tested using `LZ4F_isError()`. dctx memory can be released using
/// `LZ4F_freeDecompressionContext()`; its result indicates current state of decompression
/// context when being released. That is, it should be `== 0` if decompression has been
/// completed fully and correctly.
#[no_mangle]
pub unsafe extern "C" fn LZ4F_createDecompressionContext(
    ctx: &mut LZ4FDecompressionContext,
    version: c_uint,
) -> LZ4FErrorCode {
    if version != LZ4F_VERSION {
        return ERROR_PARAMETER_INVALID;
    }
    ctx.0 = Box::into_raw(Box::<DecompressionCtx>::default()) as *mut c_void;
    0
}

/// Releases an `LZ4F_dctx` previously created by `LZ4F_createDecompressionContext()`.
#[no_mangle]
pub unsafe extern "C" fn LZ4F_freeDecompressionContext(
    ctx: LZ4FDecompressionContext,
) -> LZ4FErrorCode {
    if !ctx.0.is_null() {
        let boxed = Box::from_raw(ctx.0 as *mut DecompressionCtx);
        let status = decompression_free_status(&boxed);
        drop(boxed);
        return status;
    }
    0
}

/// Context size inspection (v1.10.1+). Returns the total memory footprint of the provided
/// decompression context, or 0 if `ctx` is null.
#[no_mangle]
pub unsafe extern "C" fn LZ4F_dctx_size(ctx: LZ4FDecompressionContext) -> size_t {
    if ctx.0.is_null() {
        0
    } else {
        std::mem::size_of::<DecompressionCtx>()
    }
}

/// `LZ4F_getFrameInfo()` :
/// This function extracts frame parameters (max blockSize, dictID, etc.). Its usage is
/// optional: user can also invoke `LZ4F_decompress()` directly.
///
/// Extracted information will fill an existing `LZ4F_frameInfo_t` structure. This can be
/// useful for allocation and dictionary identification purposes.
///
/// `LZ4F_getFrameInfo()` can work in the following situations:
///
/// 1) At the beginning of a new frame, before any invocation of `LZ4F_decompress()`. It will
///    decode the header from `srcBuffer`, consuming the header and starting the decoding
///    process. Input size must be large enough to contain the full frame header. Frame
///    header size can be known beforehand by `LZ4F_headerSize()`. Frame header size is
///    variable but is guaranteed to be `>= LZ4F_HEADER_SIZE_MIN` bytes and
///    `<= LZ4F_HEADER_SIZE_MAX` bytes. Hence blindly providing `LZ4F_HEADER_SIZE_MAX` bytes
///    or more will always work. If input size is not large enough, function will fail and
///    return an error code.
///
/// 2) After decoding has been started, it's possible to invoke `LZ4F_getFrameInfo()` anytime
///    to extract already-decoded frame parameters stored within `dctx`. If decoding has
///    barely started and not yet read enough information to decode the header, this fails.
///
/// The number of bytes consumed from `srcBuffer` will be updated in `*srcSizePtr`. The
/// function only consumes bytes when decoding has not yet started, and when decoding the
/// header has been successful. Decompression must then resume from `(srcBuffer + *srcSizePtr)`.
///
/// - return : a hint about how many `srcSize` bytes `LZ4F_decompress()` expects for next
///   call, or an error code which can be tested using `LZ4F_isError()`.
///
/// note 1 : in case of error, `dctx` is not modified. Decoding operation can resume from
///          beginning safely.
/// note 2 : frame parameters are *copied into* an already-allocated `LZ4F_frameInfo_t`
///          structure.
#[no_mangle]
pub unsafe extern "C" fn LZ4F_getFrameInfo(
    ctx: LZ4FDecompressionContext,
    frameInfoPtr: *mut LZ4FFrameInfo,
    srcBuffer: *const u8,
    srcSizePtr: *mut size_t,
) -> size_t {
    if ctx.0.is_null() || frameInfoPtr.is_null() || srcSizePtr.is_null() {
        return ERROR_PARAMETER_NULL;
    }
    let inner = &mut *(ctx.0 as *mut DecompressionCtx);
    if inner.parsed_header {
        *srcSizePtr = 0;
        *frameInfoPtr = frame_info_from_decompression_ctx(inner);
        return frame_hint(inner);
    }
    if !inner.input.is_empty() {
        *srcSizePtr = 0;
        return ERROR_FRAME_DECODING_ALREADY_STARTED;
    }
    let src_size = *srcSizePtr;
    if srcBuffer.is_null() {
        *srcSizePtr = 0;
        return ERROR_SRC_PTR_WRONG;
    }
    if src_size < 7 {
        *srcSizePtr = 0;
        return ERROR_BAD_HEADER;
    }
    let src = slice::from_raw_parts(srcBuffer, src_size);
    if is_skippable_magic_prefix(src) {
        let Some(skip_len) = parse_skippable_frame_len(src) else {
            return ERROR_BAD_HEADER;
        };
        *srcSizePtr = cmp::min(skip_len, src_size);
        *frameInfoPtr = LZ4FFrameInfo {
            block_size_id: BlockSize::Default,
            block_mode: BlockMode::Independent,
            content_checksum_flag: ContentChecksum::NoChecksum,
            frame_type: FrameType::SkippableFrame,
            content_size: 0,
            dict_id: 0,
            block_checksum_flag: BlockChecksum::NoBlockChecksum,
        };
        return 0;
    }
    let (prefs, header_len) = match parse_frame_header(src) {
        Ok(parsed) => parsed,
        Err(code) => {
            *srcSizePtr = 0;
            return code;
        }
    };
    if !inner.parsed_header && !inner.done {
        apply_frame_prefs(inner, prefs);
    }
    *srcSizePtr = header_len;
    *frameInfoPtr = LZ4FFrameInfo {
        block_size_id: block_size_enum(prefs.block_size_id),
        block_mode: if prefs.block_independent {
            BlockMode::Independent
        } else {
            BlockMode::Linked
        },
        content_checksum_flag: if prefs.content_checksum {
            ContentChecksum::ChecksumEnabled
        } else {
            ContentChecksum::NoChecksum
        },
        frame_type: FrameType::Frame,
        content_size: prefs.content_size,
        dict_id: prefs.dict_id,
        block_checksum_flag: if prefs.block_checksum {
            BlockChecksum::BlockChecksumEnabled
        } else {
            BlockChecksum::NoBlockChecksum
        },
    };
    0
}

/// `LZ4F_headerSize()` : v1.9.0+
/// Provide the header size of a frame starting at `src`. `srcSize` must be
/// `>= LZ4F_MIN_SIZE_TO_KNOW_HEADER_LENGTH`, which is enough to decode the header length.
///
/// - return : size of frame header, or an error code, which can be tested using
///   `LZ4F_isError()`.
///
/// note : Frame header size is variable, but is guaranteed to be `>= LZ4F_HEADER_SIZE_MIN`
/// bytes, and `<= LZ4F_HEADER_SIZE_MAX` bytes.
#[no_mangle]
pub unsafe extern "C" fn LZ4F_headerSize(src: *const c_void, srcSize: size_t) -> size_t {
    if src.is_null() {
        return ERROR_SRC_PTR_WRONG;
    }
    if srcSize < 5 {
        return ERROR_BAD_HEADER;
    }
    let src = slice::from_raw_parts(src as *const u8, srcSize);
    if is_skippable_magic_prefix(src) {
        return 8;
    }
    if src[..4] != LZ4F_MAGIC {
        return ERROR_FRAME_TYPE_UNKNOWN;
    }
    expected_frame_header_len(src).unwrap_or(ERROR_BAD_HEADER)
}

/// Incrementally decompresses an LZ4 frame into user-provided buffers.
///
/// Call repeatedly until the return value is 0 (frame fully decoded) or an error is reported.
/// On each call, the function consumes up to `*srcSizePtr` bytes from `srcBuffer` and
/// produces up to `*dstSizePtr` bytes into `dstBuffer`. It updates both size pointers with
/// the actual number of bytes consumed/produced. There is no separate flush step.
///
/// Typical loop:
/// - Provide whatever input you have and an available output buffer.
/// - Read how much input was consumed and how much output was produced.
/// - Use the returned value as a hint for how many source bytes are ideal next time.
///
/// Returns:
/// - `> 0` : Hint (in bytes) for how many source bytes are ideal to provide on the next
///   call. The current frame is not yet complete.
/// - `0` : The current frame is fully decoded. If `*srcSizePtr` is less than the provided
///   value, the unconsumed tail is the start of another frame (if any).
/// - error : An error code; test with `LZ4F_isError(ret)`. After an error, `dctx` is not
///   resumable: call `LZ4F_resetDecompressionContext()` before reusing it.
///
/// Notes:
/// - The function may not consume all provided input on each call. Always check `*srcSizePtr`.
///   Present any unconsumed source bytes again on the next call.
/// - `dstBuffer` content is overwritten; it does not need to be stable across calls.
/// - After finishing a frame (return == 0), you may immediately start feeding the next frame
///   into the same `dctx`.
///
/// Warning: If you called `LZ4F_getFrameInfo()` beforehand, you must advance `srcBuffer`
/// and decrease `*srcSizePtr` by the number of bytes it consumed (the frame header).
/// Failing to do so can cause decompression failure or, worse, silent corruption.
#[no_mangle]
pub unsafe extern "C" fn LZ4F_decompress(
    ctx: LZ4FDecompressionContext,
    dstBuffer: *mut u8,
    dstSizePtr: *mut size_t,
    srcBuffer: *const u8,
    srcSizePtr: *mut size_t,
    dOptPtr: *const LZ4FDecompressOptions,
) -> size_t {
    if ctx.0.is_null() || dstSizePtr.is_null() || srcSizePtr.is_null() {
        return ERROR_PARAMETER_NULL;
    }
    // `stable_dst` is an upstream storage optimization. This implementation
    // keeps linked-block history in `DecompressionCtx::dictionary`, so both
    // stable and unstable destination modes share the same behavior.
    let _stable_dst = !dOptPtr.is_null() && (*dOptPtr).stable_dst != 0;
    let inner = &mut *(ctx.0 as *mut DecompressionCtx);
    if !dOptPtr.is_null() && (*dOptPtr).skipChecksums != 0 {
        inner.skip_checksums = true;
    }
    let skip_checksums = inner.skip_checksums;
    let src_size = *srcSizePtr;
    let dst_capacity = *dstSizePtr;
    if dst_capacity > 0 && dstBuffer.is_null() {
        return ERROR_PARAMETER_NULL;
    }

    if src_size > 0
        && dst_capacity > 0
        && !srcBuffer.is_null()
        && inner.input.is_empty()
        && pending_is_empty(inner)
        && inner.parsed_header
        && !inner.done
    {
        let src = slice::from_raw_parts(srcBuffer, src_size);
        if let Some(result) = try_copy_raw_block_slice_to_dst(
            inner,
            src,
            slice::from_raw_parts_mut(dstBuffer, dst_capacity),
            skip_checksums,
        ) {
            match result {
                Ok((consumed, written)) => {
                    *srcSizePtr = consumed;
                    *dstSizePtr = written;
                    if inner.done && pending_is_empty(inner) {
                        *inner = DecompressionCtx::default();
                        return 0;
                    }
                    return frame_hint(inner);
                }
                Err(code) => return code,
            }
        }
        if let Some(result) = try_decompress_frame_block_slice_to_dst(
            inner,
            src,
            slice::from_raw_parts_mut(dstBuffer, dst_capacity),
            skip_checksums,
        ) {
            match result {
                Ok((consumed, written)) => {
                    *srcSizePtr = consumed;
                    *dstSizePtr = written;
                    if inner.done && pending_is_empty(inner) {
                        *inner = DecompressionCtx::default();
                        return 0;
                    }
                    return frame_hint(inner);
                }
                Err(code) => return code,
            }
        }
    }

    if src_size > 0 {
        if srcBuffer.is_null() {
            return ERROR_SRC_PTR_WRONG;
        }
        inner
            .input
            .extend_from_slice(slice::from_raw_parts(srcBuffer, src_size));
    }

    if pending_is_empty(inner) && dst_capacity > 0 {
        if let Err(code) = parse_frame_header_if_available(inner) {
            return code;
        }
        // Drain as many complete blocks from `inner.input` as fit in `dst`
        // within this single LZ4F_decompress call. Without this loop, each
        // call processed exactly one block while accumulating leftover input
        // — so once the slow path ran for any reason (e.g. the first call,
        // before the header is parsed), `inner.input` was never drained and
        // the fast slice-to-dst path could not fire on subsequent calls.
        let dst_slice = slice::from_raw_parts_mut(dstBuffer, dst_capacity);
        let mut total_written = 0usize;
        loop {
            let remaining = &mut dst_slice[total_written..];
            if remaining.is_empty() {
                break;
            }
            if inner.raw_block_remaining > 0 {
                match copy_raw_block_from_input_to_dst(inner, remaining, skip_checksums) {
                    Some(Ok(written)) => {
                        total_written += written;
                        if inner.done {
                            break;
                        }
                        if written == 0 {
                            break;
                        }
                        continue;
                    }
                    Some(Err(code)) => return code,
                    None => break,
                }
            }
            match try_decompress_frame_block_to_dst(inner, remaining, skip_checksums) {
                Some(Ok(written)) => {
                    total_written += written;
                    if inner.done {
                        break;
                    }
                    // If the most recent call wrote 0 bytes (e.g. final
                    // block-zero marker followed by trailer) we still made
                    // progress on inner state — try once more and let the
                    // function return None on the next call when truly out
                    // of complete blocks.
                    continue;
                }
                Some(Err(code)) => return code,
                None => break,
            }
        }
        if total_written > 0 || inner.done {
            let consumed = consumed_from_call(inner.done, src_size, inner.input.len());
            *srcSizePtr = consumed;
            *dstSizePtr = total_written;
            if inner.done && pending_is_empty(inner) {
                *inner = DecompressionCtx::default();
                return 0;
            }
            return frame_hint(inner);
        }
    }

    if let Err(code) = parse_available_frame(inner, skip_checksums) {
        return code;
    }
    let pending_len = pending_len(inner);
    let to_copy = cmp::min(dst_capacity, pending_len);
    if to_copy > 0 {
        ptr::copy_nonoverlapping(
            inner.pending.as_ptr().add(inner.pending_pos),
            dstBuffer,
            to_copy,
        );
        inner.pending_pos += to_copy;
        if inner.pending_pos == inner.pending.len() {
            inner.pending.clear();
            inner.pending_pos = 0;
        }
    }
    *dstSizePtr = to_copy;
    if pending_is_empty(inner) && !inner.done {
        if let Err(code) = parse_available_frame(inner, skip_checksums) {
            return code;
        }
    }
    *srcSizePtr = consumed_from_call(inner.done, src_size, inner.input.len());
    if inner.done && pending_is_empty(inner) {
        *inner = DecompressionCtx::default();
        return 0;
    }
    frame_hint(inner)
}

/// `LZ4F_decompress_usingDict()` : stable since v1.10
/// Same as `LZ4F_decompress()`, using a predefined dictionary. Dictionary is used "in place",
/// without any preprocessing. It must remain accessible throughout the entire frame decoding.
#[no_mangle]
pub unsafe extern "C" fn LZ4F_decompress_usingDict(
    ctx: LZ4FDecompressionContext,
    dstBuffer: *mut c_void,
    dstSizePtr: *mut size_t,
    srcBuffer: *const c_void,
    srcSizePtr: *mut size_t,
    dict: *const c_void,
    dictSize: size_t,
    decompressOptionsPtr: *const LZ4FDecompressOptions,
) -> size_t {
    if ctx.0.is_null() {
        return ERROR_PARAMETER_NULL;
    }
    if dictSize > 0 && dict.is_null() {
        return ERROR_SRC_PTR_WRONG;
    }
    let inner = &mut *(ctx.0 as *mut DecompressionCtx);
    if !inner.parsed_header && dictSize > 0 {
        let dict = slice::from_raw_parts(dict as *const u8, dictSize);
        let keep = cmp::min(dict.len(), LZ4_DISTANCE_MAX);
        inner.dictionary.clear();
        inner
            .dictionary
            .extend_from_slice(&dict[dict.len() - keep..]);
        inner.external_dictionary = true;
    }
    LZ4F_decompress(
        ctx,
        dstBuffer as *mut u8,
        dstSizePtr,
        srcBuffer as *const u8,
        srcSizePtr,
        decompressOptionsPtr,
    )
}

/// `LZ4F_resetDecompressionContext()` : added in v1.8.0
/// In case of an error, the context is left in "undefined" state. In which case, it's
/// necessary to reset it, before re-using it. This method can also be used to abruptly stop
/// any unfinished decompression, and start a new one using same context resources. Always
/// successful.
#[no_mangle]
pub unsafe extern "C" fn LZ4F_resetDecompressionContext(ctx: LZ4FDecompressionContext) {
    if !ctx.0.is_null() {
        *(ctx.0 as *mut DecompressionCtx) = DecompressionCtx::default();
    }
}

/// Allocate and initialize an `LZ4_stream_t` streaming compression state.
///
/// A newly created state is automatically initialized. The same state can be
/// re-used multiple times consecutively, starting each new stream of blocks
/// with `LZ4_resetStream_fast()`. Release with `LZ4_freeStream()`.
#[no_mangle]
pub unsafe extern "C" fn LZ4_createStream() -> *mut LZ4StreamEncode {
    Box::into_raw(Box::<EncodeStreamCtx>::default()) as *mut LZ4StreamEncode
}

/// Release a streaming compression state previously allocated with
/// `LZ4_createStream()`.
///
/// Returns 0; passing NULL is safe and treated as a no-op.
#[no_mangle]
pub unsafe extern "C" fn LZ4_freeStream(stream: *mut LZ4StreamEncode) -> c_int {
    if !stream.is_null() {
        drop(Box::from_raw(stream as *mut EncodeStreamCtx));
    }
    0
}

/// Deprecated wrapper for streaming compression; use
/// `LZ4_compress_fast_continue()` instead.
///
/// Compresses `src` into `dst` using data from previously compressed blocks
/// as dictionary, with default acceleration. Returns the size of the
/// compressed block, or 0 on error (typically, output does not fit into
/// `dst`).
#[no_mangle]
pub unsafe extern "C" fn LZ4_compress_continue(
    stream: *mut LZ4StreamEncode,
    src: *const c_char,
    dst: *mut c_char,
    srcSize: c_int,
    dstCapacity: c_int,
) -> c_int {
    if stream.is_null() || srcSize < 0 || dstCapacity <= 0 || src.is_null() || dst.is_null() {
        return 0;
    }
    let ctx = &mut *(stream as *mut EncodeStreamCtx);
    let src_slice = slice::from_raw_parts(src as *const u8, srcSize as usize);
    let dst_slice = slice::from_raw_parts_mut(dst as *mut u8, dstCapacity as usize);
    let written = if ctx.dictionary.is_empty() {
        compress_block(src_slice, dst_slice, 1)
    } else {
        compress_block_with_dict(src_slice, dst_slice, &ctx.dictionary, 1)
    }
    .map_or(0, |n| n as c_int);
    if written > 0 {
        if ctx.attached_dictionary {
            ctx.dictionary.clear();
            append_hc_dictionary(&mut ctx.dictionary, src_slice);
            ctx.attached_dictionary = false;
        } else {
            append_hc_dictionary(&mut ctx.dictionary, src_slice);
        }
    }
    written
}

/// Compress `src` content using data from previously compressed blocks, for
/// better compression ratio.
///
/// `dst` buffer must be already allocated. If `dstCapacity >=
/// LZ4_compressBound(srcSize)`, compression is guaranteed to succeed, and
/// runs faster.
///
/// Returns the size of the compressed block, or 0 if there is an error
/// (typically, cannot fit into `dst`).
///
/// Note 1: Each invocation generates a new block; each block has precise
/// boundaries and must be decompressed separately.
///
/// Note 2: The previous 64KB of source data is assumed to remain present,
/// unmodified, at the same address in memory.
///
/// Note 3: When input is structured as a double-buffer, each buffer can have
/// any size, including < 64 KB. Make sure buffers are separated by at least
/// one byte.
///
/// Note 4: If input buffer is a ring-buffer, it can have any size, including
/// < 64 KB.
///
/// Note 5: After an error, the stream status is undefined (invalid); it can
/// only be reset or freed.
#[no_mangle]
pub unsafe extern "C" fn LZ4_compress_fast_continue(
    stream: *mut LZ4StreamEncode,
    src: *const c_char,
    dst: *mut c_char,
    srcSize: c_int,
    dstCapacity: c_int,
    acceleration: c_int,
) -> c_int {
    if stream.is_null() || srcSize < 0 || dstCapacity <= 0 || src.is_null() || dst.is_null() {
        return 0;
    }
    let ctx = &mut *(stream as *mut EncodeStreamCtx);
    let src_slice = slice::from_raw_parts(src as *const u8, srcSize as usize);
    let dst_slice = slice::from_raw_parts_mut(dst as *mut u8, dstCapacity as usize);
    let acceleration = normalize_acceleration(acceleration);
    let written = if ctx.dictionary.is_empty() {
        compress_block(src_slice, dst_slice, acceleration)
    } else {
        compress_block_with_dict(src_slice, dst_slice, &ctx.dictionary, acceleration)
    }
    .map_or(0, |n| n as c_int);
    if written > 0 {
        if ctx.attached_dictionary {
            ctx.dictionary.clear();
            append_hc_dictionary(&mut ctx.dictionary, src_slice);
            ctx.attached_dictionary = false;
        } else {
            append_hc_dictionary(&mut ctx.dictionary, src_slice);
        }
    }
    written
}

/// Deprecated wrapper for streaming compression with output size limit; use
/// `LZ4_compress_fast_continue()` instead.
#[no_mangle]
pub unsafe extern "C" fn LZ4_compress_limitedOutput_continue(
    stream: *mut LZ4StreamEncode,
    src: *const c_char,
    dst: *mut c_char,
    srcSize: c_int,
    maxOutputSize: c_int,
) -> c_int {
    LZ4_compress_continue(stream, src, dst, srcSize, maxOutputSize)
}

/// Prepare an `LZ4_stream_t` for a new chain of dependent blocks
/// (e.g., `LZ4_compress_fast_continue()`).
///
/// An `LZ4_stream_t` must be initialized once before use. This is
/// automatically done when created by `LZ4_createStream()`. However, when
/// the structure is simply declared on stack, `LZ4_initStream()` must be
/// used first.
///
/// After init, start any new stream with `LZ4_resetStream_fast()`. The same
/// `LZ4_stream_t` can be re-used multiple times to compress multiple
/// streams, provided each new stream starts with `LZ4_resetStream_fast()`.
///
/// `LZ4_resetStream_fast()` is much faster than `LZ4_initStream()`, but is
/// not compatible with memory regions containing garbage data.
///
/// Note: it's only useful to call `LZ4_resetStream_fast()` in the context
/// of streaming compression. The `*extState*` functions perform their own
/// resets.
#[no_mangle]
pub unsafe extern "C" fn LZ4_resetStream_fast(stream: *mut LZ4StreamEncode) {
    if !stream.is_null() {
        let ctx = &mut *(stream as *mut EncodeStreamCtx);
        ctx.dictionary.clear();
        ctx.attached_dictionary = false;
    }
}

/// Initialize an `LZ4_stream_t` structure.
///
/// An `LZ4_stream_t` structure must be initialized at least once; this is
/// done with `LZ4_initStream()` or `LZ4_resetStream()`. Consider switching
/// to `LZ4_initStream()`; `LZ4_resetStream()` will trigger deprecation
/// warnings in a future version.
#[no_mangle]
pub unsafe extern "C" fn LZ4_resetStream(stream: *mut LZ4StreamEncode) {
    LZ4_resetStream_fast(stream)
}

/// Properly initialize a newly declared `LZ4_stream_t`.
///
/// An `LZ4_stream_t` structure must be initialized at least once. This is
/// automatically done when invoking `LZ4_createStream()`, but it's not done
/// when the structure is simply declared on stack.
///
/// `LZ4_initStream()` can also initialize any arbitrary buffer of sufficient
/// size, and will return a pointer of proper type upon initialization.
///
/// Initialization fails (returns NULL) if size and alignment conditions are
/// not respected. An `LZ4_stream_t` structure guarantees correct alignment
/// and size.
#[no_mangle]
pub unsafe extern "C" fn LZ4_initStream(
    stateBuffer: *mut c_void,
    size: size_t,
) -> *mut LZ4StreamEncode {
    if stateBuffer.is_null() {
        return ptr::null_mut();
    }
    if size < LZ4_sizeofStreamState() as usize {
        return ptr::null_mut();
    }
    if !(stateBuffer as usize).is_multiple_of(std::mem::align_of::<EncodeStreamCtx>()) {
        return ptr::null_mut();
    }
    ptr::write(
        stateBuffer as *mut EncodeStreamCtx,
        EncodeStreamCtx::default(),
    );
    stateBuffer as *mut LZ4StreamEncode
}

/// Deprecated obsolete streaming constructor; use `LZ4_createStream()`
/// instead.
///
/// Preserved for ABI compatibility. The `inputBuffer` argument is ignored;
/// history is no longer tracked through this entry point.
#[no_mangle]
pub unsafe extern "C" fn LZ4_create(_inputBuffer: *mut c_char) -> *mut c_void {
    LZ4_createStream() as *mut c_void
}

/// Deprecated: use `LZ4_createStream()` instead.
///
/// Returns the size in bytes of an `LZ4_stream_t` state buffer.
#[no_mangle]
pub extern "C" fn LZ4_sizeofStreamState() -> c_int {
    LZ4_sizeofState()
}

/// Deprecated: use `LZ4_resetStream()` instead.
///
/// Resets a user-provided state buffer; the `inputBuffer` argument is
/// ignored. Returns 0 on success, non-zero if `state` is NULL.
#[no_mangle]
pub unsafe extern "C" fn LZ4_resetStreamState(
    state: *mut c_void,
    _inputBuffer: *mut c_char,
) -> c_int {
    if state.is_null() {
        return 1;
    }
    ptr::write(state as *mut EncodeStreamCtx, EncodeStreamCtx::default());
    0
}

/// Deprecated: use `LZ4_saveDict()` instead.
///
/// Obsolete streaming helper preserved for ABI compatibility; returns a
/// pointer to the dictionary tail when present, NULL otherwise.
#[no_mangle]
pub unsafe extern "C" fn LZ4_slideInputBuffer(state: *mut c_void) -> *mut c_char {
    if state.is_null() {
        return ptr::null_mut();
    }
    let ctx = &mut *(state as *mut EncodeStreamCtx);
    if ctx.dictionary.is_empty() {
        ptr::null_mut()
    } else {
        ctx.dictionary.as_mut_ptr() as *mut c_char
    }
}

/// Attach a static dictionary stream to a working stream for efficient
/// re-use.
///
/// Rather than re-loading the dictionary buffer into a working context
/// before each compression, this function introduces a no-copy setup
/// mechanism in which the working stream references `dictionaryStream`
/// in-place.
///
/// Only states which have been prepared by `LZ4_loadDict()` or
/// `LZ4_loadDictSlow()` should be expected to work as the dictionary
/// stream. Alternatively, `dictionaryStream` may be NULL, in which case
/// any existing dictionary stream is unset.
///
/// If a dictionary is provided, it replaces any pre-existing stream
/// history. The dictionary contents are the only history that can be
/// referenced and logically immediately precede the data compressed in
/// the first subsequent compression call.
///
/// The dictionary will only remain attached through the first compression
/// call, at the end of which it is cleared. `dictionaryStream` (and its
/// source buffer) must remain in-place / accessible / unchanged through
/// the completion of the compression session.
#[no_mangle]
pub unsafe extern "C" fn LZ4_attach_dictionary(
    workingStream: *mut LZ4StreamEncode,
    dictionaryStream: *const LZ4StreamEncode,
) {
    if workingStream.is_null() {
        return;
    }
    let working = &mut *(workingStream as *mut EncodeStreamCtx);
    working.dictionary.clear();
    working.attached_dictionary = false;
    if !dictionaryStream.is_null() {
        let dictionary = &*(dictionaryStream as *const EncodeStreamCtx);
        working.dictionary.extend_from_slice(&dictionary.dictionary);
        working.attached_dictionary = !working.dictionary.is_empty();
    }
}

/// Reference a static dictionary into an `LZ4_stream_t`.
///
/// The dictionary must remain available during compression.
/// `LZ4_loadDict()` triggers a reset, so any previous data will be
/// forgotten. The same dictionary must be loaded on the decompression side
/// for successful decoding. Dictionaries are useful for better compression
/// of small data (KB range). Loading a size of 0 is allowed and is the
/// same as a reset.
///
/// Returns the loaded dictionary size, in bytes (only the last 64 KB are
/// loaded).
#[no_mangle]
pub unsafe extern "C" fn LZ4_loadDict(
    stream: *mut LZ4StreamEncode,
    dictionary: *const c_char,
    dictSize: c_int,
) -> c_int {
    if stream.is_null() || dictSize < 0 || (dictSize > 0 && dictionary.is_null()) {
        return 0;
    }
    let ctx = &mut *(stream as *mut EncodeStreamCtx);
    ctx.dictionary.clear();
    ctx.attached_dictionary = false;
    if dictSize as usize >= HASH_UNIT {
        let dict = slice::from_raw_parts(dictionary as *const u8, dictSize as usize);
        let keep = cmp::min(dict.len(), LZ4_DISTANCE_MAX);
        ctx.dictionary.extend_from_slice(&dict[dict.len() - keep..]);
    }
    ctx.dictionary.len() as c_int
}

/// Same as `LZ4_loadDict()`, but uses a bit more CPU to reference the
/// dictionary content more thoroughly.
///
/// This is expected to slightly improve compression ratio. The extra-CPU
/// cost is likely worth it if the dictionary is re-used across multiple
/// sessions.
///
/// Returns the loaded dictionary size, in bytes (only the last 64 KB are
/// loaded).
#[no_mangle]
pub unsafe extern "C" fn LZ4_loadDictSlow(
    stream: *mut LZ4StreamEncode,
    dictionary: *const c_char,
    dictSize: c_int,
) -> c_int {
    LZ4_loadDict(stream, dictionary, dictSize)
}

/// Save the last 64 KB of stream history into a safe buffer.
///
/// If the last 64 KB of data cannot be guaranteed to remain available at
/// its current memory location, save it into a safer place (`safeBuffer`).
/// This is schematically equivalent to a `memcpy()` followed by
/// `LZ4_loadDict()`, but is much faster because `LZ4_saveDict()` doesn't
/// need to rebuild tables.
///
/// Returns the saved dictionary size in bytes (necessarily <=
/// `maxDictSize`), or 0 on error.
#[no_mangle]
pub unsafe extern "C" fn LZ4_saveDict(
    stream: *mut LZ4StreamEncode,
    safeBuffer: *mut c_char,
    maxDictSize: c_int,
) -> c_int {
    if stream.is_null() || maxDictSize < 0 || (maxDictSize > 0 && safeBuffer.is_null()) {
        return 0;
    }
    let ctx = &mut *(stream as *mut EncodeStreamCtx);
    let keep = cmp::min(
        ctx.dictionary.len(),
        cmp::min(maxDictSize as usize, LZ4_DISTANCE_MAX),
    );
    if keep > 0 {
        ptr::copy_nonoverlapping(
            ctx.dictionary[ctx.dictionary.len() - keep..].as_ptr(),
            safeBuffer as *mut u8,
            keep,
        );
        ctx.dictionary = ctx.dictionary[ctx.dictionary.len() - keep..].to_vec();
        ctx.attached_dictionary = false;
    } else {
        ctx.dictionary.clear();
        ctx.attached_dictionary = false;
    }
    keep as c_int
}

/// Allocate memory for an LZ4 HC streaming state and initialize it.
///
/// Newly created states are automatically initialized. The same state can
/// be used multiple times consecutively, starting with
/// `LZ4_resetStreamHC_fast()` to start a new stream of blocks. Release with
/// `LZ4_freeStreamHC()`.
#[no_mangle]
pub unsafe extern "C" fn LZ4_createStreamHC() -> *mut LZ4StreamHC {
    Box::into_raw(Box::<HcStreamCtx>::default()) as *mut LZ4StreamHC
}

/// Release an LZ4 HC streaming state previously allocated with
/// `LZ4_createStreamHC()`.
///
/// Returns 0; passing NULL is safe and treated as a no-op.
#[no_mangle]
pub unsafe extern "C" fn LZ4_freeStreamHC(stream: *mut LZ4StreamHC) -> c_int {
    if !stream.is_null() {
        drop(Box::from_raw(stream as *mut HcStreamCtx));
    }
    0
}

/// Quickly prepare an `LZ4_streamHC_t` for a new compression.
///
/// When an `LZ4_streamHC_t` is known to be in an internally coherent state,
/// it can often be prepared for a new compression with almost no work,
/// only sometimes falling back to the full reset performed by
/// `LZ4_resetStreamHC()`.
///
/// `LZ4_streamHC_t`s are guaranteed to be in a valid state when returned
/// from `LZ4_createStreamHC()`, reset by `LZ4_resetStreamHC()`, after a
/// `memset` to zero, or after a successful compression call.
///
/// A stream that was last used in a compression call that returned an
/// error may be passed to this function; however, it will be fully reset,
/// which will clear any existing history and settings.
#[no_mangle]
pub unsafe extern "C" fn LZ4_resetStreamHC_fast(stream: *mut LZ4StreamHC, compressionLevel: c_int) {
    if !stream.is_null() {
        let ctx = &mut *(stream as *mut HcStreamCtx);
        ctx.compression_level = normalize_hc_level(compressionLevel);
        ctx.dictionary.clear();
        ctx.attached_dictionary = false;
    }
}

/// Reset an `LZ4_streamHC_t` to a clean state with the given compression
/// level.
///
/// Replaced by `LZ4_initStreamHC()`. The intention is to emphasize the
/// difference with `LZ4_resetStreamHC_fast()`, which is now the
/// recommended function to start a new stream of blocks but cannot be used
/// to initialize a memory segment containing arbitrary garbage data. It is
/// recommended to switch to `LZ4_initStreamHC()`; `LZ4_resetStreamHC()`
/// will generate deprecation warnings in a future version.
#[no_mangle]
pub unsafe extern "C" fn LZ4_resetStreamHC(stream: *mut LZ4StreamHC, compressionLevel: c_int) {
    if !stream.is_null() {
        let ctx = &mut *(stream as *mut HcStreamCtx);
        *ctx = HcStreamCtx::default();
        ctx.compression_level = normalize_hc_level(compressionLevel);
    }
}

/// Initialize an `LZ4_streamHC_t` placed in a user-provided buffer.
///
/// Required before first use of a statically allocated `LZ4_streamHC_t`.
/// Returns NULL if size or alignment requirements are not met. Before
/// v1.9.0, use `LZ4_resetStreamHC()` instead.
#[no_mangle]
pub unsafe extern "C" fn LZ4_initStreamHC(buffer: *mut c_void, size: size_t) -> *mut LZ4StreamHC {
    if buffer.is_null() {
        return ptr::null_mut();
    }
    if size < LZ4_sizeofStreamStateHC() as usize {
        return ptr::null_mut();
    }
    if !(buffer as usize).is_multiple_of(std::mem::align_of::<HcStreamCtx>()) {
        return ptr::null_mut();
    }
    ptr::write(buffer as *mut HcStreamCtx, HcStreamCtx::default());
    buffer as *mut LZ4StreamHC
}

/// Change compression level between successive invocations of
/// `LZ4_compress_HC_continue*()` for dynamic adaptation.
#[no_mangle]
pub unsafe extern "C" fn LZ4_setCompressionLevel(
    stream: *mut LZ4StreamHC,
    compressionLevel: c_int,
) {
    if !stream.is_null() {
        (*(stream as *mut HcStreamCtx)).compression_level = normalize_hc_level(compressionLevel);
    }
}

/// Make the optimal parser favor decompression speed over compression
/// ratio.
///
/// Only applicable to compression levels >= `LZ4HC_CLEVEL_OPT_MIN`.
#[no_mangle]
pub unsafe extern "C" fn LZ4_favorDecompressionSpeed(stream: *mut LZ4StreamHC, favor: c_int) {
    if !stream.is_null() {
        (*(stream as *mut HcStreamCtx)).favor_dec_speed = favor != 0;
    }
}

/// Attach a static HC dictionary stream to a working stream for efficient
/// re-use across many compressions.
///
/// Rather than re-loading the dictionary buffer into a working context
/// before each compression, this function introduces a no-copy setup
/// mechanism in which the working stream references the dictionary stream
/// in-place. Only streams which have been prepared by `LZ4_loadDictHC()`
/// should be expected to work as the dictionary stream.
///
/// Alternatively, `dictionary_stream` may be NULL, in which case any
/// existing dictionary stream is unset.
///
/// A dictionary should only be attached to a stream without any history
/// (i.e., a stream that has just been reset). The dictionary will remain
/// attached to the working stream only for the current stream session;
/// calls to `LZ4_resetStreamHC(_fast)` will remove the dictionary context
/// association. The dictionary stream (and source buffer) must remain
/// in-place / accessible / unchanged through the lifetime of the stream
/// session.
#[no_mangle]
pub unsafe extern "C" fn LZ4_attach_HC_dictionary(
    working_stream: *mut LZ4StreamHC,
    dictionary_stream: *const LZ4StreamHC,
) {
    if working_stream.is_null() {
        return;
    }
    let working = &mut *(working_stream as *mut HcStreamCtx);
    working.dictionary.clear();
    working.attached_dictionary = false;
    if !dictionary_stream.is_null() {
        let dictionary = &*(dictionary_stream as *const HcStreamCtx);
        working.dictionary.extend_from_slice(&dictionary.dictionary);
        working.attached_dictionary = !working.dictionary.is_empty();
    }
}

/// Load an initial "fictional block" as a dictionary into an HC stream.
///
/// Note: In order for `LZ4_loadDictHC()` to create the correct data
/// structures, it is essential to set the compression level _before_
/// loading the dictionary. Only the last 64 KB of the dictionary are kept.
#[no_mangle]
pub unsafe extern "C" fn LZ4_loadDictHC(
    stream: *mut LZ4StreamHC,
    dictionary: *const c_char,
    dictSize: c_int,
) -> c_int {
    if stream.is_null() || dictSize < 0 || (dictSize > 0 && dictionary.is_null()) {
        return 0;
    }
    let ctx = &mut *(stream as *mut HcStreamCtx);
    let keep = cmp::min(dictSize as usize, LZ4_DISTANCE_MAX);
    ctx.dictionary.clear();
    ctx.attached_dictionary = false;
    if keep > 0 {
        let dict = slice::from_raw_parts(dictionary as *const u8, dictSize as usize);
        ctx.dictionary.extend_from_slice(&dict[dict.len() - keep..]);
    }
    keep as c_int
}

/// Save HC stream history content (up to 64 KB) into a user-provided
/// buffer.
///
/// Returns the size of the dictionary effectively saved (<= MIN(maxDictSize,
/// 64 KB)). This function is always successful and expects its arguments to
/// be valid. Note that `(NULL, 0)` is valid but `(NULL, !0)` is not, and
/// will result in a segfault (or assertion failure).
#[no_mangle]
pub unsafe extern "C" fn LZ4_saveDictHC(
    stream: *mut LZ4StreamHC,
    safeBuffer: *mut c_char,
    maxDictSize: c_int,
) -> c_int {
    if stream.is_null() || maxDictSize < 0 || (maxDictSize > 0 && safeBuffer.is_null()) {
        return 0;
    }
    let ctx = &mut *(stream as *mut HcStreamCtx);
    if maxDictSize < 4 {
        ctx.dictionary.clear();
        ctx.attached_dictionary = false;
        return 0;
    }
    let keep = cmp::min(
        ctx.dictionary.len(),
        cmp::min(maxDictSize as usize, LZ4_DISTANCE_MAX),
    );
    if keep > 0 {
        ptr::copy_nonoverlapping(
            ctx.dictionary[ctx.dictionary.len() - keep..].as_ptr(),
            safeBuffer as *mut u8,
            keep,
        );
        ctx.dictionary = ctx.dictionary[ctx.dictionary.len() - keep..].to_vec();
        ctx.attached_dictionary = false;
    } else {
        ctx.dictionary.clear();
        ctx.attached_dictionary = false;
    }
    keep as c_int
}

/// Compress a block of data using LZ4-HC streaming, using previous blocks
/// as the dictionary.
///
/// Compresses successive blocks of any size; previous blocks (up to 64 KB)
/// are used as a dictionary to improve compression ratio. Previous input
/// blocks (and the initial dictionary, if any) must remain accessible and
/// unmodified during compression.
///
/// `dst` should be sized to handle worst-case scenarios (see
/// `LZ4_compressBound()`, which ensures compression success). On failure
/// the state must be reset; the API does not guarantee recovery.
/// To ensure success when `dst` cannot be sized to `LZ4_compressBound()`,
/// consider using `LZ4_compress_HC_continue_destSize()`.
#[no_mangle]
pub unsafe extern "C" fn LZ4_compress_HC_continue(
    stream: *mut LZ4StreamHC,
    src: *const c_char,
    dst: *mut c_char,
    srcSize: c_int,
    maxDstSize: c_int,
) -> c_int {
    if stream.is_null() {
        return 0;
    }
    let ctx = &mut *(stream as *mut HcStreamCtx);
    if srcSize < 0 || maxDstSize <= 0 || src.is_null() || dst.is_null() {
        return 0;
    }
    let src_slice = slice::from_raw_parts(src as *const u8, srcSize as usize);
    let dst_slice = slice::from_raw_parts_mut(dst as *mut u8, maxDstSize as usize);
    compress_hc_stream_block(
        ctx,
        src_slice,
        dst_slice,
        ctx.compression_level,
        ctx.favor_dec_speed,
    )
}

/// Internal helper: compress one block through an HC streaming context and
/// then append the just-compressed input to the context's dictionary
/// window. Shared by `LZ4_compress_HC_continue()` and the deprecated
/// `LZ4_compressHC2_*` entry points.
fn compress_hc_stream_block(
    ctx: &mut HcStreamCtx,
    src: &[u8],
    dst: &mut [u8],
    compression_level: c_int,
    favor_dec_speed: bool,
) -> c_int {
    let written = if ctx.dictionary.is_empty() {
        compress_block_hc(src, dst, compression_level, favor_dec_speed)
    } else {
        compress_block_hc_with_dict(
            src,
            dst,
            &ctx.dictionary,
            compression_level,
            favor_dec_speed,
        )
    }
    .map_or(0, |n| n as c_int);
    if written > 0 && !src.is_empty() {
        if ctx.attached_dictionary {
            ctx.dictionary.clear();
            append_hc_dictionary(&mut ctx.dictionary, src);
            ctx.attached_dictionary = false;
        } else {
            append_hc_dictionary(&mut ctx.dictionary, src);
        }
    }
    written
}

/// Similar to `LZ4_compress_HC_continue()`, but reads as much data as
/// possible from `src` to fit into the `targetDstSize` budget.
///
/// Returns the number of bytes written into `dst` (necessarily <=
/// `targetDstSize`), or 0 if compression fails. On success `*srcSizePtr` is
/// updated to indicate how many bytes were read from `src`. Note that this
/// function may not consume the entire input.
#[no_mangle]
pub unsafe extern "C" fn LZ4_compress_HC_continue_destSize(
    stream: *mut LZ4StreamHC,
    src: *const c_char,
    dst: *mut c_char,
    srcSizePtr: *mut c_int,
    targetDstSize: c_int,
) -> c_int {
    if stream.is_null() {
        return 0;
    }
    let ctx = &mut *(stream as *mut HcStreamCtx);
    let original = if !srcSizePtr.is_null() {
        *srcSizePtr
    } else {
        0
    };
    if src.is_null()
        || dst.is_null()
        || srcSizePtr.is_null()
        || *srcSizePtr < 0
        || targetDstSize <= 0
    {
        return 0;
    }
    let src_slice = slice::from_raw_parts(src as *const u8, *srcSizePtr as usize);
    let dst_slice = slice::from_raw_parts_mut(dst as *mut u8, targetDstSize as usize);
    let result = if ctx.dictionary.is_empty() {
        compress_hc_dest_size(
            src_slice,
            dst_slice,
            ctx.compression_level,
            ctx.favor_dec_speed,
        )
    } else {
        compress_hc_dest_size_with_dict(
            src_slice,
            dst_slice,
            &ctx.dictionary,
            ctx.compression_level,
            ctx.favor_dec_speed,
        )
    };
    let Some((consumed, written_usize)) = result else {
        return 0;
    };
    *srcSizePtr = consumed as c_int;
    let written = written_usize as c_int;
    if written > 0 && !src.is_null() && !srcSizePtr.is_null() && *srcSizePtr > 0 {
        let consumed = cmp::min(*srcSizePtr, original) as usize;
        let src_slice = slice::from_raw_parts(src as *const u8, consumed);
        if ctx.attached_dictionary {
            ctx.dictionary.clear();
            append_hc_dictionary(&mut ctx.dictionary, src_slice);
            ctx.attached_dictionary = false;
        } else {
            append_hc_dictionary(&mut ctx.dictionary, src_slice);
        }
    }
    written
}

/// Deprecated: use `LZ4_compress_HC_continue()` instead.
///
/// Compresses one block using HC streaming with `dst` capacity implicitly
/// set to `LZ4_compressBound(srcSize)`.
#[no_mangle]
pub unsafe extern "C" fn LZ4_compressHC_continue(
    stream: *mut LZ4StreamHC,
    src: *const c_char,
    dst: *mut c_char,
    srcSize: c_int,
) -> c_int {
    LZ4_compress_HC_continue(stream, src, dst, srcSize, LZ4_compressBound(srcSize))
}

/// Deprecated: use `LZ4_compress_HC_continue()` instead.
///
/// Compresses one block using HC streaming, with an explicit output size
/// limit.
#[no_mangle]
pub unsafe extern "C" fn LZ4_compressHC_limitedOutput_continue(
    stream: *mut LZ4StreamHC,
    src: *const c_char,
    dst: *mut c_char,
    srcSize: c_int,
    maxDstSize: c_int,
) -> c_int {
    LZ4_compress_HC_continue(stream, src, dst, srcSize, maxDstSize)
}

/// Deprecated: use `LZ4_compress_HC_continue()` instead.
///
/// Compresses one block using HC streaming with an explicit compression
/// level; `dst` capacity is implicitly set to `LZ4_compressBound(srcSize)`.
#[no_mangle]
pub unsafe extern "C" fn LZ4_compressHC2_continue(
    stream: *mut c_void,
    src: *const c_char,
    dst: *mut c_char,
    srcSize: c_int,
    cLevel: c_int,
) -> c_int {
    if stream.is_null() {
        return 0;
    }
    if srcSize < 0 || src.is_null() || dst.is_null() {
        return 0;
    }
    let bound = LZ4_compressBound(srcSize);
    if bound <= 0 {
        return 0;
    }
    let ctx = &mut *(stream as *mut HcStreamCtx);
    let src_slice = slice::from_raw_parts(src as *const u8, srcSize as usize);
    let dst_slice = slice::from_raw_parts_mut(dst as *mut u8, bound as usize);
    compress_hc_stream_block(
        ctx,
        src_slice,
        dst_slice,
        normalize_hc_level(cLevel),
        ctx.favor_dec_speed,
    )
}

/// Deprecated: use `LZ4_compress_HC_continue()` instead.
///
/// Compresses one block using HC streaming with an explicit compression
/// level and an output size limit.
#[no_mangle]
pub unsafe extern "C" fn LZ4_compressHC2_limitedOutput_continue(
    stream: *mut c_void,
    src: *const c_char,
    dst: *mut c_char,
    srcSize: c_int,
    maxDstSize: c_int,
    cLevel: c_int,
) -> c_int {
    if stream.is_null() {
        return 0;
    }
    if srcSize < 0 || maxDstSize <= 0 || src.is_null() || dst.is_null() {
        return 0;
    }
    let ctx = &mut *(stream as *mut HcStreamCtx);
    let src_slice = slice::from_raw_parts(src as *const u8, srcSize as usize);
    let dst_slice = slice::from_raw_parts_mut(dst as *mut u8, maxDstSize as usize);
    compress_hc_stream_block(
        ctx,
        src_slice,
        dst_slice,
        normalize_hc_level(cLevel),
        ctx.favor_dec_speed,
    )
}

/// Deprecated: use `LZ4_createStreamHC()` instead.
///
/// Returns the size in bytes of an `LZ4_streamHC_t` state buffer.
#[no_mangle]
pub extern "C" fn LZ4_sizeofStreamStateHC() -> c_int {
    LZ4_sizeofStateHC()
}

/// Deprecated: use `LZ4_createStreamHC()` instead.
///
/// Obsolete HC streaming constructor; the `inputBuffer` argument is
/// ignored and preserved only for ABI compatibility.
#[no_mangle]
pub unsafe extern "C" fn LZ4_createHC(_inputBuffer: *const c_char) -> *mut c_void {
    LZ4_createStreamHC() as *mut c_void
}

/// Deprecated: use `LZ4_freeStreamHC()` instead.
#[no_mangle]
pub unsafe extern "C" fn LZ4_freeHC(stream: *mut c_void) -> c_int {
    LZ4_freeStreamHC(stream as *mut LZ4StreamHC)
}

/// Deprecated: use `LZ4_saveDictHC()` instead.
///
/// Obsolete HC streaming helper preserved for ABI compatibility. As noted
/// in upstream, this function truncates the history of the stream rather
/// than preserving a window-sized chunk of history.
#[no_mangle]
pub unsafe extern "C" fn LZ4_slideInputBufferHC(stream: *mut c_void) -> *mut c_char {
    if stream.is_null() {
        return ptr::null_mut();
    }
    let ctx = &mut *(stream as *mut HcStreamCtx);
    if ctx.dictionary.is_empty() {
        ptr::null_mut()
    } else {
        let ptr = ctx.dictionary.as_mut_ptr() as *mut c_char;
        ctx.dictionary.clear();
        ctx.attached_dictionary = false;
        ptr
    }
}

/// Deprecated: use `LZ4_initStreamHC()` instead.
///
/// Resets a user-provided HC state buffer; the `inputBuffer` argument is
/// ignored. Returns 0 on success, non-zero if `state` is NULL.
#[no_mangle]
pub unsafe extern "C" fn LZ4_resetStreamStateHC(
    state: *mut c_void,
    _inputBuffer: *mut c_char,
) -> c_int {
    if state.is_null() {
        return 1;
    }
    ptr::write(state as *mut HcStreamCtx, HcStreamCtx::default());
    0
}

/// Allocate a streaming decompression tracking context.
///
/// A tracking context can be re-used multiple times. Release with
/// `LZ4_freeStreamDecode()`.
#[no_mangle]
pub unsafe extern "C" fn LZ4_createStreamDecode() -> *mut LZ4StreamDecode {
    Box::into_raw(Box::<DecodeStreamCtx>::default()) as *mut LZ4StreamDecode
}

/// Release a streaming decompression context previously allocated with
/// `LZ4_createStreamDecode()`.
///
/// Returns 0; passing NULL is safe and treated as a no-op.
#[no_mangle]
pub unsafe extern "C" fn LZ4_freeStreamDecode(stream: *mut LZ4StreamDecode) -> c_int {
    if !stream.is_null() {
        drop(Box::from_raw(stream as *mut DecodeStreamCtx));
    }
    0
}

/// Start decompression of a new stream of blocks on an
/// `LZ4_streamDecode_t` context.
///
/// An `LZ4_streamDecode_t` context can be allocated once and re-used
/// multiple times. A dictionary can optionally be set; use NULL or size 0
/// for a reset. The dictionary is presumed stable: it must remain
/// accessible and unmodified during the next decompression.
///
/// Returns 1 if OK, 0 if error.
#[no_mangle]
pub unsafe extern "C" fn LZ4_setStreamDecode(
    stream: *mut LZ4StreamDecode,
    dictionary: *const c_char,
    dictSize: c_int,
) -> c_int {
    if stream.is_null() || dictSize < 0 || (dictSize > 0 && dictionary.is_null()) {
        return 0;
    }
    let ctx = &mut *(stream as *mut DecodeStreamCtx);
    ctx.dictionary.clear();
    if dictSize > 0 {
        let dict = slice::from_raw_parts(dictionary as *const u8, dictSize as usize);
        let keep = cmp::min(dict.len(), LZ4_DISTANCE_MAX);
        ctx.dictionary.extend_from_slice(&dict[dict.len() - keep..]);
    }
    1
}

/// Decompress consecutive blocks in "streaming" mode.
///
/// The difference with the usual independent blocks is that new blocks are
/// allowed to find references into former blocks. A block is an
/// unsplittable entity and must be presented entirely to the
/// decompression function. `LZ4_decompress_safe_continue()` only accepts
/// one block at a time. It is modeled after `LZ4_decompress_safe()` and
/// behaves similarly.
///
/// Returns the number of bytes decompressed into the destination buffer
/// (necessarily <= `dstCapacity`). If the destination buffer is not large
/// enough, decoding stops and a negative value is returned. If the source
/// stream is detected malformed, the function stops decoding and returns
/// a negative result.
///
/// The last 64 KB of previously decoded data _must_ remain available and
/// unmodified at the memory position where they were previously decoded.
/// If less than 64 KB has been decoded so far, all of it must be present.
///
/// If a ring buffer is used on the decompression side, see upstream
/// `LZ4_decoderRingBufferSize()` documentation for the supported ring
/// buffer arrangements. Whenever these conditions cannot be met, save the
/// last 64 KB of decoded data into a safe buffer and pass it to
/// `LZ4_setStreamDecode()` before decompressing the next block.
#[no_mangle]
pub unsafe extern "C" fn LZ4_decompress_safe_continue(
    stream: *mut LZ4StreamDecode,
    src: *const c_char,
    dst: *mut c_char,
    srcSize: c_int,
    dstCapacity: c_int,
) -> c_int {
    if stream.is_null() || srcSize < 0 || dstCapacity < 0 || src.is_null() || dst.is_null() {
        return -1;
    }
    let ctx = &mut *(stream as *mut DecodeStreamCtx);
    let src = slice::from_raw_parts(src as *const u8, srcSize as usize);
    let dst = slice::from_raw_parts_mut(dst as *mut u8, dstCapacity as usize);
    match decompress_block_with_dict(src, dst, &ctx.dictionary) {
        Some(n) => {
            append_hc_dictionary(&mut ctx.dictionary, &dst[..n]);
            n as c_int
        }
        None => -1,
    }
}

/// Clamp the acceleration parameter to upstream's accepted range.
fn normalize_acceleration(acceleration: c_int) -> usize {
    acceleration.clamp(1, 65_537) as usize
}

trait FastHashTable {
    fn get(&self, h: usize) -> usize;
    fn set(&mut self, h: usize, pos: usize);
}

impl FastHashTable for [u32] {
    #[inline]
    fn get(&self, h: usize) -> usize {
        self[h] as usize
    }

    #[inline]
    fn set(&mut self, h: usize, pos: usize) {
        self[h] = pos as u32;
    }
}

impl FastHashTable for [u16] {
    #[inline]
    fn get(&self, h: usize) -> usize {
        self[h] as usize
    }

    #[inline]
    fn set(&mut self, h: usize, pos: usize) {
        self[h] = pos as u16;
    }
}

/// Single-pass fast LZ4 block compressor without a dictionary. Mirrors upstream
/// `LZ4_compress_generic_validated()` (lz4.c:926+) for the
/// `outputDirective == notLimited`, `dictDirective == noDict` configuration:
/// branches are decided at compile time and the function presumes valid input.
/// Returns the number of compressed bytes written, or `None` if encoding could
/// not fit in `dst`.
fn compress_block(src: &[u8], dst: &mut [u8], acceleration: usize) -> Option<usize> {
    if src.len() < LZ4_64K_LIMIT {
        let mut table = vec![0u16; 1 << LZ4_HASH_BITS_U16];
        compress_block_with_table::<true, _>(src, dst, acceleration, &mut table[..])
    } else {
        let mut table = vec![0u32; 1 << LZ4_HASH_BITS];
        compress_block_with_table::<false, _>(src, dst, acceleration, &mut table[..])
    }
}

fn compress_block_ext_state(
    state: *mut c_void,
    src: &[u8],
    dst: &mut [u8],
    acceleration: usize,
) -> Option<usize> {
    if src.len() < LZ4_64K_LIMIT {
        let table = unsafe { slice::from_raw_parts_mut(state as *mut u16, 1 << LZ4_HASH_BITS_U16) };
        table.fill(0);
        compress_block_with_table::<true, _>(src, dst, acceleration, table)
    } else {
        let table = unsafe { slice::from_raw_parts_mut(state as *mut u32, 1 << LZ4_HASH_BITS) };
        table.fill(0);
        compress_block_with_table::<false, _>(src, dst, acceleration, table)
    }
}

fn compress_block_with_table<const BY_U16: bool, T: FastHashTable + ?Sized>(
    src: &[u8],
    dst: &mut [u8],
    acceleration: usize,
    table: &mut T,
) -> Option<usize> {
    if src.is_empty() {
        return emit_last_literals(src, dst, 0, 0);
    }
    if src.len() < MFLIMIT + 1 {
        return emit_last_literals(src, dst, 0, 0);
    }
    let mut ip = 0usize;
    let mut anchor = 0usize;
    let mut op = 0usize;
    let mflimit_plus_one = src.len() - MFLIMIT + 1;
    let match_limit = src.len() - LAST_LITERALS;

    table.set(hash_fast_const::<BY_U16>(src, ip), ip);
    ip += 1;
    let mut forward_h = hash_fast_const::<BY_U16>(src, ip);

    let src_ptr = src.as_ptr();

    loop {
        let mut forward_ip = ip;
        let mut step = 1usize;
        let mut search_match_nb = acceleration << 6;
        let mut ref_pos;

        loop {
            let h = forward_h;
            ip = forward_ip;
            forward_ip += step;
            step = search_match_nb >> 6;
            search_match_nb += 1;

            if forward_ip > mflimit_plus_one {
                return emit_last_literals(src, dst, anchor, op);
            }

            ref_pos = table.get(h);
            forward_h = hash_fast_const::<BY_U16>(src, forward_ip);
            table.set(h, ip);

            // Mirrors upstream's `LZ4_read32(match) == LZ4_read32(ip)` —
            // a single 4-byte unaligned compare instead of a slice memcmp.
            if ip > ref_pos
                && ip - ref_pos <= LZ4_DISTANCE_MAX
                && unsafe { read_u32_ptr(src_ptr.add(ref_pos)) == read_u32_ptr(src_ptr.add(ip)) }
            {
                break;
            }
        }

        while ip > anchor && ref_pos > 0 && src[ip - 1] == src[ref_pos - 1] {
            ip -= 1;
            ref_pos -= 1;
        }

        loop {
            let match_len =
                MINMATCH + count_match(src, ip + MINMATCH, ref_pos + MINMATCH, match_limit);
            op = encode_sequence(src, dst, anchor, ip, match_len, ip - ref_pos, op)?;
            ip += match_len;
            anchor = ip;

            if ip >= mflimit_plus_one {
                return emit_last_literals(src, dst, anchor, op);
            }

            table.set(hash_fast_const::<BY_U16>(src, ip - 2), ip - 2);
            let h = hash_fast_const::<BY_U16>(src, ip);
            ref_pos = table.get(h);
            table.set(h, ip);
            if ip > ref_pos
                && ip - ref_pos <= LZ4_DISTANCE_MAX
                && unsafe { read_u32_ptr(src_ptr.add(ref_pos)) == read_u32_ptr(src_ptr.add(ip)) }
            {
                continue;
            }

            ip += 1;
            forward_h = hash_fast_const::<BY_U16>(src, ip);
            break;
        }
    }
}

/// Fast LZ4 block compressor under the `fillOutput` directive: writes as much
/// of `src` as can fit into `dst` and returns `(consumed, written)`. Mirrors
/// upstream `LZ4_compress_generic_validated(..., fillOutput, ...)` in lz4.c.
/// In contrast to `compress_block`, encoding never simply bails on overflow:
/// when the destination cannot hold the next sequence, the parser stops or
/// truncates the trailing literals run.
fn compress_dest_size(src: &[u8], dst: &mut [u8], acceleration: usize) -> Option<(usize, usize)> {
    // Single-pass fillOutput compressor, mirroring upstream
    // `LZ4_compress_generic(..., fillOutput, ...)` (lz4.c:931+). The
    // previous implementation binary-searched over input prefixes; this
    // version makes one pass and truncates when the destination fills.
    if dst.is_empty() {
        return None;
    }
    let olimit = dst.len();

    if src.len() < MFLIMIT + 1 {
        return Some(emit_truncated_last_literals(src, dst, 0, 0, olimit));
    }

    if src.len() < LZ4_64K_LIMIT {
        compress_dest_size_inner::<true>(src, dst, acceleration, olimit)
    } else {
        compress_dest_size_inner::<false>(src, dst, acceleration, olimit)
    }
}

fn compress_dest_size_inner<const BY_U16: bool>(
    src: &[u8],
    dst: &mut [u8],
    acceleration: usize,
    olimit: usize,
) -> Option<(usize, usize)> {
    // Tail spaces required by upstream's pre-checks. The "+ MFLIMIT - MINMATCH"
    // term reserves room so the parser can always fall through to a final
    // literal run that satisfies LZ4's end-of-block constraint.
    let tail = MFLIMIT - MINMATCH; // = 8
    let last_lit = LAST_LITERALS; // = 5
    let hash_bits = if BY_U16 {
        LZ4_HASH_BITS_U16
    } else {
        LZ4_HASH_BITS
    };
    // u32 hash table entries — see compress_block above for rationale.
    let mut table = vec![0u32; 1 << hash_bits];
    let mut ip = 0usize;
    let mut anchor = 0usize;
    let mut op = 0usize;
    let mflimit_plus_one = src.len() - MFLIMIT + 1;
    let match_limit = src.len() - LAST_LITERALS;

    table[hash_fast_const::<BY_U16>(src, ip)] = ip as u32;
    ip += 1;
    let mut forward_h = hash_fast_const::<BY_U16>(src, ip);

    'outer: loop {
        let mut forward_ip = ip;
        let mut step = 1usize;
        let mut search_match_nb = acceleration << 6;
        let mut ref_pos;

        loop {
            let h = forward_h;
            ip = forward_ip;
            forward_ip += step;
            step = search_match_nb >> 6;
            search_match_nb += 1;

            if forward_ip > mflimit_plus_one {
                break 'outer;
            }

            ref_pos = table[h] as usize;
            forward_h = hash_fast_const::<BY_U16>(src, forward_ip);
            table[h] = ip as u32;

            if ip > ref_pos
                && ip - ref_pos <= LZ4_DISTANCE_MAX
                && unsafe {
                    read_u32_ptr(src.as_ptr().add(ref_pos)) == read_u32_ptr(src.as_ptr().add(ip))
                }
            {
                break;
            }
        }

        while ip > anchor && ref_pos > 0 && src[ip - 1] == src[ref_pos - 1] {
            ip -= 1;
            ref_pos -= 1;
        }

        loop {
            let lit_len = ip - anchor;

            // Upstream's pre-token fillOutput check (lz4.c:1114-1118):
            //   op + (litLength+240)/255 + litLength + 2 + 1 + MFLIMIT - MINMATCH > olimit
            if op + (lit_len + 240) / 255 + lit_len + 2 + 1 + tail > olimit {
                break 'outer;
            }

            let token_pos = op;
            op += 1;
            if lit_len >= 15 {
                let mut extra = lit_len - 15;
                while extra >= 255 {
                    dst[op] = 255;
                    op += 1;
                    extra -= 255;
                }
                dst[op] = extra as u8;
                op += 1;
            }
            dst[op..op + lit_len].copy_from_slice(&src[anchor..ip]);
            op += lit_len;

            // Upstream's pre-offset fillOutput check (lz4.c:1143-1148): if the
            // match is too close to the end, rewind the token and bail.
            if op + 2 + 1 + tail > olimit {
                op = token_pos;
                break 'outer;
            }

            let offset = ip - ref_pos;
            dst[op..op + 2].copy_from_slice(&(offset as u16).to_le_bytes());
            op += 2;

            let mut match_code = count_match(src, ip + MINMATCH, ref_pos + MINMATCH, match_limit);
            ip += match_code + MINMATCH;

            // Upstream's match-code overflow path (lz4.c:1183-1208): in
            // fillOutput mode, shrink the match instead of bailing. The
            // formula computes the largest match_code whose length-extension
            // bytes still fit alongside the reserved last-literals room.
            if op + (1 + last_lit) + (match_code + 240) / 255 > olimit {
                let avail = olimit.saturating_sub(op + 1 + last_lit);
                let new_match_code = 14 + avail.saturating_mul(255);
                if new_match_code < match_code {
                    ip -= match_code - new_match_code;
                    match_code = new_match_code;
                } else {
                    // Shouldn't happen given the trigger condition, but stay
                    // defensive — leave match_code untouched.
                }
            }

            let token_lit_bits = (cmp::min(lit_len, 15) as u8) << 4;
            if match_code >= 15 {
                dst[token_pos] = token_lit_bits | 0x0F;
                let mut ml = match_code - 15;
                while ml >= 255 {
                    dst[op] = 255;
                    op += 1;
                    ml -= 255;
                }
                dst[op] = ml as u8;
                op += 1;
            } else {
                dst[token_pos] = token_lit_bits | (match_code as u8);
            }

            anchor = ip;

            if ip >= mflimit_plus_one {
                break 'outer;
            }

            table[hash_fast_const::<BY_U16>(src, ip - 2)] = (ip - 2) as u32;
            let h = hash_fast_const::<BY_U16>(src, ip);
            let next_ref = table[h] as usize;
            table[h] = ip as u32;
            if ip > next_ref
                && ip - next_ref <= LZ4_DISTANCE_MAX
                && unsafe {
                    read_u32_ptr(src.as_ptr().add(next_ref)) == read_u32_ptr(src.as_ptr().add(ip))
                }
            {
                ref_pos = next_ref;
                continue;
            }

            ip += 1;
            forward_h = hash_fast_const::<BY_U16>(src, ip);
            break;
        }
    }

    Some(emit_truncated_last_literals(src, dst, anchor, op, olimit))
}

/// Emit a final-literals run for the `fillOutput` path, truncating the run if
/// it would overflow the output buffer. Mirrors upstream's `_last_literals`
/// fallback block (lz4.c:1298-1325) under the `fillOutput` directive. Returns
/// `(consumed, written)`.
fn emit_truncated_last_literals(
    src: &[u8],
    dst: &mut [u8],
    anchor: usize,
    mut op: usize,
    olimit: usize,
) -> (usize, usize) {
    // Mirrors upstream's `_last_literals` block (lz4.c:1298-1325) under the
    // fillOutput directive. Returns (consumed, written).
    let mut last_run = src.len() - anchor;
    let needed = op + last_run + 1 + (last_run + 255 - 15) / 255;
    if needed > olimit {
        // Upstream:
        //   lastRun  = (size_t)(olimit-op) - 1;
        //   lastRun -= (lastRun + 256 - RUN_MASK) / 256;
        let avail = olimit.saturating_sub(op + 1);
        let extension_bytes = (avail + 256 - 15) / 256;
        last_run = avail.saturating_sub(extension_bytes);
    }
    if op >= olimit {
        // No room even for a token — return what we have.
        return (anchor, op);
    }
    if last_run >= 15 {
        dst[op] = 0xF0; // RUN_MASK << ML_BITS
        op += 1;
        let mut accum = last_run - 15;
        while accum >= 255 {
            dst[op] = 255;
            op += 1;
            accum -= 255;
        }
        dst[op] = accum as u8;
        op += 1;
    } else {
        dst[op] = (last_run as u8) << 4;
        op += 1;
    }
    dst[op..op + last_run].copy_from_slice(&src[anchor..anchor + last_run]);
    op += last_run;
    (anchor + last_run, op)
}

/// Fast LZ4 block compressor with a preceding dictionary. Concatenates the
/// (truncated to `LZ4_DISTANCE_MAX`) dictionary in front of `src` and runs the
/// same parser as `compress_block`, mirroring upstream
/// `LZ4_compress_generic_validated()` for the `dictDirective == withPrefix64k`
/// configuration. The dictionary tail is seeded into the hash table before the
/// main loop so backward matches can land inside it.
fn compress_block_with_dict(
    src: &[u8],
    dst: &mut [u8],
    dict: &[u8],
    acceleration: usize,
) -> Option<usize> {
    if src.is_empty() {
        return emit_last_literals(src, dst, 0, 0);
    }
    if src.len() < MFLIMIT + 1 {
        return emit_last_literals(src, dst, 0, 0);
    }
    let dict_keep = cmp::min(dict.len(), LZ4_DISTANCE_MAX);
    let dict = &dict[dict.len() - dict_keep..];
    if dict.is_empty() {
        return compress_block(src, dst, acceleration);
    }

    let mut full = Vec::with_capacity(dict.len() + src.len());
    full.extend_from_slice(dict);
    full.extend_from_slice(src);
    let base = dict.len();
    // u32 hash table entries — see compress_block above for rationale.
    let mut table = vec![0u32; 1 << LZ4_HASH_BITS];
    let seed_end = full.len().saturating_sub(MINMATCH - 1);
    for pos in 0..cmp::min(base, seed_end) {
        table[hash_fast(&full, pos, false)] = pos as u32;
    }

    let mut ip = base;
    let mut anchor = base;
    let mut op = 0usize;
    let mflimit_plus_one = base + src.len() - MFLIMIT + 1;
    let match_limit = base + src.len() - LAST_LITERALS;

    table[hash_fast(&full, ip, false)] = ip as u32;
    ip += 1;
    let mut forward_h = hash_fast(&full, ip, false);

    let full_ptr = full.as_ptr();

    loop {
        let mut forward_ip = ip;
        let mut step = 1usize;
        let mut search_match_nb = acceleration << 6;
        let mut ref_pos;

        loop {
            let h = forward_h;
            ip = forward_ip;
            forward_ip += step;
            step = search_match_nb >> 6;
            search_match_nb += 1;

            if forward_ip > mflimit_plus_one {
                return emit_last_literals_with_base(&full, dst, base, anchor, op);
            }

            ref_pos = table[h] as usize;
            forward_h = hash_fast(&full, forward_ip, false);
            table[h] = ip as u32;

            if ip > ref_pos
                && ip - ref_pos <= LZ4_DISTANCE_MAX
                && unsafe { read_u32_ptr(full_ptr.add(ref_pos)) == read_u32_ptr(full_ptr.add(ip)) }
            {
                break;
            }
        }

        while ip > anchor && ref_pos > 0 && full[ip - 1] == full[ref_pos - 1] {
            ip -= 1;
            ref_pos -= 1;
        }

        loop {
            let match_len =
                MINMATCH + count_match(&full, ip + MINMATCH, ref_pos + MINMATCH, match_limit);
            op = encode_sequence(&full, dst, anchor, ip, match_len, ip - ref_pos, op)?;
            ip += match_len;
            anchor = ip;

            if ip >= mflimit_plus_one {
                return emit_last_literals_with_base(&full, dst, base, anchor, op);
            }

            table[hash_fast(&full, ip - 2, false)] = (ip - 2) as u32;
            let h = hash_fast(&full, ip, false);
            ref_pos = table[h] as usize;
            table[h] = ip as u32;
            if ip > ref_pos
                && ip - ref_pos <= LZ4_DISTANCE_MAX
                && unsafe { read_u32_ptr(full_ptr.add(ref_pos)) == read_u32_ptr(full_ptr.add(ip)) }
            {
                continue;
            }

            ip += 1;
            forward_h = hash_fast(&full, ip, false);
            break;
        }
    }
}

#[derive(Clone, Copy, Debug)]
struct HcMatch {
    start: usize,
    len: usize,
    off: usize,
}

#[derive(Clone, Copy, Debug)]
#[repr(C)]
struct HcOptimal {
    // u32 instead of usize: `price`, `off`, `mlen`, `litlen` all stay well
    // under 2^32 (the maximum block size is `LZ4_OPT_NUM = 4096`, distances
    // are bounded by `LZ4_DISTANCE_MAX = 65535`, and prices are bounded by
    // a small multiple of `LZ4_OPT_NUM`). Halving the struct from 32 bytes
    // to 16 bytes cuts the `opt` table from 128 KiB to 64 KiB and is a
    // meaningful cache-traffic reduction in the inner optimal-parser loop.
    //
    // NOTE: Tried shrinking off/mlen/litlen to u16 (12-byte struct) — that
    // actually slowed HC10/11/12 by 30-40% because the awkward 12-byte
    // entry layout (5 per 64-byte cache line with 4 bytes of slack)
    // produces worse codegen and unaligned accesses. 16 bytes (4 entries
    // per cache line, all u32-aligned) is the sweet spot.
    price: u32,
    off: u32,
    mlen: u32,
    litlen: u32,
}

/// Starting offset added to every physical position before it is stored in
/// `HcTables::hash` or used for chain arithmetic. Mirrors upstream's
/// `LZ4HC_init_internal` which pushes `dictLimit` and `lowLimit` to at least
/// `64 KiB` so the `u16`-delta chain walk can never wrap a valid candidate
/// below zero: any logical position stored in the hash table is `>= 64 KiB`
/// and every chain delta is `<= 65535`, so `candidate_log -= delta` stays
/// positive and the `candidate_log >= lowest_log` exit is exact.
const HC_OFFSET: u32 = (LZ4_DISTANCE_MAX + 1) as u32;

/// Size of the chain table — fixed by the LZ4 format. Hoisted to a const
/// so the array types in `HcTables` can use it directly.
const HC_CHAIN_SIZE: usize = LZ4_DISTANCE_MAX + 1;

#[derive(Debug)]
struct HcTables {
    /// Head-of-chain per hash: logical positions (`physical + HC_OFFSET`).
    /// Initialized to `0` so an empty bucket yields a `candidate_log < HC_OFFSET`
    /// that fails the `candidate_log >= lowest_log` loop condition without any
    /// explicit sentinel check.
    ///
    /// Stored as `Box<[u32; LZ4HC_HASH_SIZE]>` rather than `Vec<u32>` so the
    /// length is compile-time known and LLVM can DCE per-access bounds
    /// checks in `insert_until`'s hot loop.
    hash: Box<[u32; LZ4HC_HASH_SIZE]>,
    /// Delta to the previous chain entry, clamped to `LZ4_DISTANCE_MAX`.
    /// Initial `0xFFFF` entries mirror upstream's `MEM_INIT(chainTable, 0xFF)`
    /// so first-ever walks step off the end of the search window immediately.
    /// Same `Box<[_; N]>` trick as `hash` above.
    chain: Box<[u16; HC_CHAIN_SIZE]>,
    next_to_update: usize,
    /// Offset inside the search buffer where the current prefix begins.
    /// For no-dict compression this is `0`; when a dictionary is prepended
    /// before the input, it is `dict.len()`. Equivalent to upstream's
    /// `prefixPtr` in that `prefixPtr == &full[base]`. Used by the HC
    /// pattern-analysis branch to replicate upstream's `protectDictEnd`
    /// guard so the repeated-pattern fast path is not entered when a
    /// dict-area candidate sits in the last 3 bytes before the prefix.
    base: usize,
}

impl HcTables {
    fn with_base(_src_len: usize, base: usize) -> Self {
        Self {
            hash: vec![0u32; LZ4HC_HASH_SIZE]
                .into_boxed_slice()
                .try_into()
                .unwrap(),
            chain: vec![LZ4_DISTANCE_MAX as u16; HC_CHAIN_SIZE]
                .into_boxed_slice()
                .try_into()
                .unwrap(),
            next_to_update: 0,
            base,
        }
    }

    /// Convert a physical buffer position to the logical position used for
    /// storage in `hash` and for chain arithmetic.
    #[inline(always)]
    fn to_log(pos: usize) -> u32 {
        (pos as u32).wrapping_add(HC_OFFSET)
    }

    /// Convert a logical position back to the physical buffer position. Only
    /// valid after a `>= lowest_log` check has ensured the logical position
    /// is at least `HC_OFFSET`.
    #[inline(always)]
    fn to_phys(log: u32) -> usize {
        log.wrapping_sub(HC_OFFSET) as usize
    }

    #[inline]
    fn insert_until(&mut self, src: &[u8], target: usize) {
        let end = cmp::min(target, src.len().saturating_sub(MINMATCH - 1));
        while self.next_to_update < end {
            let pos = self.next_to_update;
            let h = hash4_hc(src, pos);
            let log_pos = Self::to_log(pos);
            let prev_log = self.hash[h];
            // delta = log_pos - prev_log, clamped to LZ4_DISTANCE_MAX. When
            // `prev_log` is 0 (empty bucket) the computed delta always exceeds
            // 65535, so it clamps to the sentinel and a later chain walk
            // lands below `lowest_log` on the next step.
            let delta = cmp::min(log_pos - prev_log, HC_OFFSET - 1) as u16;
            self.chain[pos & LZ4_DISTANCE_MAX] = delta;
            self.hash[h] = log_pos;
            self.next_to_update += 1;
        }
    }

    /// Returns the physical position stored in the chain before `pos`, or
    /// `usize::MAX` if the chain step goes below the HC search window (the
    /// logical delta lands at or below `HC_OFFSET`).
    #[inline]
    fn previous(&self, pos: usize) -> usize {
        let log_pos = Self::to_log(pos);
        let delta = self.chain[pos & LZ4_DISTANCE_MAX] as u32;
        let prev_log = log_pos.wrapping_sub(delta);
        if prev_log < HC_OFFSET {
            usize::MAX
        } else {
            Self::to_phys(prev_log)
        }
    }
}

struct MidTables {
    hash4: Vec<usize>,
    hash8: Vec<usize>,
}

impl MidTables {
    fn new() -> Self {
        Self {
            hash4: vec![usize::MAX; LZ4MID_HASH_SIZE],
            hash8: vec![usize::MAX; LZ4MID_HASH_SIZE],
        }
    }

    fn add4(&mut self, src: &[u8], pos: usize) {
        self.add4_index(src, pos, pos);
    }

    fn add4_index(&mut self, src: &[u8], pos: usize, index: usize) {
        if pos + MINMATCH <= src.len() {
            self.hash4[hash4_mid(src, pos)] = index;
        }
    }

    fn add8(&mut self, src: &[u8], pos: usize) {
        self.add8_index(src, pos, pos);
    }

    fn add8_index(&mut self, src: &[u8], pos: usize, index: usize) {
        if pos + LZ4MID_HASHSIZE <= src.len() {
            self.hash8[hash8_mid(src, pos)] = index;
        }
    }
}

/// Fill the LZ4mid hash tables with references into the dictionary prefix.
/// Mirrors upstream `LZ4MID_fillHTable()` (lz4hc.c:514): "the resulting table
/// is only exploitable by LZ4MID (level 2)". The first pass strides by 3 and
/// updates both `hash4` and `hash8`; the second pass dense-updates `hash8`
/// over the most recent 32 KiB so short-distance matches near the prefix
/// boundary still hit.
fn fill_lz4mid_dict_table(table: &mut MidTables, full: &[u8], base: usize) {
    if base <= LZ4MID_HASHSIZE {
        return;
    }
    let target = base - LZ4MID_HASHSIZE;
    let mut idx = 0usize;
    while idx < target {
        table.add4_index(full, idx, idx);
        table.add8_index(full, idx + 1, idx + 1);
        idx += 3;
    }

    idx = if base > 32 * 1024 + LZ4MID_HASHSIZE {
        target - 32 * 1024
    } else {
        0
    };
    while idx < target {
        table.add8_index(full, idx, idx);
        idx += 1;
    }
}

/// LZ4mid (level 2) compressor without a dictionary. Trampolines into
/// `compress_block_lz4mid_with_base` with `base == 0`.
fn compress_block_lz4mid(src: &[u8], dst: &mut [u8]) -> Option<usize> {
    compress_block_lz4mid_with_base(src, dst, 0)
}

/// LZ4mid (level 2) block compressor. Mirrors upstream `LZ4MID_compress()`
/// (lz4hc.c:554+): a two-table (hash4 + hash8) parser that probes the longer
/// hash first, optionally peeks one position ahead, and adopts the better
/// match. `base` is the offset inside `full` where the input to be emitted
/// starts; `full[..base]` is retained dictionary prefix (or empty).
fn compress_block_lz4mid_with_base(full: &[u8], dst: &mut [u8], base: usize) -> Option<usize> {
    let src_len = full.len().checked_sub(base)?;
    if src_len == 0 {
        return emit_last_literals_with_base(full, dst, base, base, 0);
    }
    if src_len < MFLIMIT + 1 {
        return emit_last_literals_with_base(full, dst, base, base, 0);
    }

    let mut table = MidTables::new();
    if base > 0 {
        fill_lz4mid_dict_table(&mut table, full, base);
    }
    let mut anchor = base;
    let mut ip = base;
    let mut op = 0usize;
    let mflimit = full.len() - MFLIMIT;
    let match_limit = full.len() - LAST_LITERALS;

    while ip <= mflimit {
        let search_ip = ip;
        let mut match_len = 0usize;
        let mut match_distance = 0usize;

        let h8 = hash8_mid(full, ip);
        let pos8 = table.hash8[h8];
        table.hash8[h8] = ip;
        if pos8 != usize::MAX
            && ip - pos8 <= LZ4_DISTANCE_MAX
            && unsafe {
                read_u32_ptr(full.as_ptr().add(pos8)) == read_u32_ptr(full.as_ptr().add(ip))
            }
        {
            match_len = count_match(full, ip, pos8, match_limit);
            if match_len >= MINMATCH {
                match_distance = ip - pos8;
            }
        }

        if match_len < MINMATCH {
            let h4 = hash4_mid(full, ip);
            let pos4 = table.hash4[h4];
            table.hash4[h4] = ip;
            if pos4 != usize::MAX
                && ip - pos4 <= LZ4_DISTANCE_MAX
                && unsafe {
                    read_u32_ptr(full.as_ptr().add(pos4)) == read_u32_ptr(full.as_ptr().add(ip))
                }
            {
                match_len = count_match(full, ip, pos4, match_limit);
                if match_len >= MINMATCH {
                    match_distance = ip - pos4;

                    let ip1 = ip + 1;
                    if ip < mflimit {
                        let h8_next = hash8_mid(full, ip1);
                        let pos8_next = table.hash8[h8_next];
                        let dist2 = ip1.saturating_sub(pos8_next);
                        if pos8_next != usize::MAX
                            && dist2 <= LZ4_DISTANCE_MAX
                            && unsafe {
                                read_u32_ptr(full.as_ptr().add(pos8_next))
                                    == read_u32_ptr(full.as_ptr().add(ip1))
                            }
                        {
                            let len2 = count_match(full, ip1, pos8_next, match_limit);
                            if len2 > match_len {
                                table.hash8[h8_next] = ip1;
                                ip = ip1;
                                match_len = len2;
                                match_distance = dist2;
                            }
                        }
                    }
                }
            }
        }

        if match_len < MINMATCH {
            ip += 1 + ((ip - anchor) >> 9);
            continue;
        }

        while ip > anchor && ip > match_distance && full[ip - 1] == full[ip - match_distance - 1] {
            ip -= 1;
            match_len += 1;
        }

        table.add8_index(full, ip + 1, search_ip + 1);
        table.add8_index(full, ip + 2, search_ip + 2);
        table.add4_index(full, ip + 1, search_ip + 1);

        op = encode_sequence(full, dst, anchor, ip, match_len, match_distance, op)?;
        ip += match_len;
        anchor = ip;

        if ip >= 2 && ip - 2 < full.len().saturating_sub(LZ4MID_HASHSIZE) {
            if ip >= 5 {
                table.add8(full, ip - 5);
            }
            if ip >= 3 {
                table.add8(full, ip - 3);
            }
            table.add8(full, ip - 2);
            table.add4(full, ip - 2);
            table.add4(full, ip - 1);
        }
    }

    emit_last_literals_with_base(full, dst, base, anchor, op)
}

/// HC block compressor entry point without a dictionary. Mirrors upstream
/// `LZ4HC_compress_generic_internal()` (lz4hc.c:1419+): dispatches to the
/// LZ4mid strategy at levels 1-2, the optimal parser at levels 10-12, and the
/// hash-chain parser otherwise. `compression_level` is normalized via
/// `normalize_hc_level` so out-of-range values map to upstream defaults.
fn compress_block_hc(
    src: &[u8],
    dst: &mut [u8],
    compression_level: c_int,
    favor_dec_speed: bool,
) -> Option<usize> {
    if src.is_empty() || src.len() < MFLIMIT + 1 {
        return emit_last_literals(src, dst, 0, 0);
    }
    let level = normalize_hc_level(compression_level);
    if level <= 2 {
        return compress_block_lz4mid(src, dst);
    }
    if level >= 10 {
        return compress_block_hc_optimal(src, dst, 0, level, favor_dec_speed);
    }
    compress_block_hc_hashchain(src, dst, 0, level)
}

/// Upstream `LZ4HC_compress_hashChain()` port, shared between no-dict and
/// dict compression. `base` is the offset inside `full` where the input to be
/// emitted starts; `full[..base]` is retained history (either empty or the
/// concatenated dictionary).
fn compress_block_hc_hashchain(
    full: &[u8],
    dst: &mut [u8],
    base: usize,
    level: c_int,
) -> Option<usize> {
    match level {
        3 => compress_block_hc_hashchain_impl::<4, false>(full, dst, base),
        4 => compress_block_hc_hashchain_impl::<8, false>(full, dst, base),
        5 => compress_block_hc_hashchain_impl::<16, false>(full, dst, base),
        6 => compress_block_hc_hashchain_impl::<32, false>(full, dst, base),
        7 => compress_block_hc_hashchain_impl::<64, false>(full, dst, base),
        8 => compress_block_hc_hashchain_impl::<128, false>(full, dst, base),
        _ => compress_block_hc_hashchain_impl::<256, true>(full, dst, base),
    }
}

fn compress_block_hc_hashchain_impl<const ATTEMPTS: usize, const PATTERN_ANALYSIS: bool>(
    full: &[u8],
    dst: &mut [u8],
    base: usize,
) -> Option<usize> {
    let mut table = HcTables::with_base(full.len(), base);
    if base > 0 {
        table.insert_until(full, base);
    }

    let mut anchor = base;
    let mut op = 0usize;
    let mflimit = full.len() - MFLIMIT;
    let match_limit = full.len() - LAST_LITERALS;
    let nomatch = HcMatch {
        start: 0,
        len: 0,
        off: 0,
    };
    let mut ip = base;

    while ip <= mflimit {
        let mut m1 = find_hc_match::<PATTERN_ANALYSIS>(full, &mut table, ip, match_limit, ATTEMPTS);
        if m1.len < MINMATCH {
            ip += 1;
            continue;
        }
        let mut start0 = ip;
        let mut m0 = m1;

        'search2: loop {
            let mut start2;
            let mut m2;
            if ip + m1.len <= mflimit {
                start2 = ip + m1.len - 2;
                m2 = find_hc_wider_match::<PATTERN_ANALYSIS, false, false>(
                    full,
                    &mut table,
                    start2,
                    ip,
                    match_limit,
                    m1.len,
                    ATTEMPTS,
                );
                start2 = m2.start;
            } else {
                m2 = nomatch;
                start2 = 0;
            }

            if m2.len <= m1.len {
                op = encode_sequence(full, dst, anchor, ip, m1.len, m1.off, op)?;
                ip += m1.len;
                anchor = ip;
                break 'search2;
            }

            if start0 < ip && start2 < ip + m0.len {
                ip = start0;
                m1 = m0;
            }

            if start2 - ip < 3 {
                ip = start2;
                m1 = m2;
                continue 'search2;
            }

            'search3: loop {
                if start2 - ip < OPTIMAL_ML {
                    let mut new_len = cmp::min(m1.len, OPTIMAL_ML);
                    if ip + new_len > start2 + m2.len - MINMATCH {
                        new_len = start2 - ip + m2.len - MINMATCH;
                    }
                    let correction = new_len.saturating_sub(start2 - ip);
                    if correction > 0 {
                        start2 += correction;
                        m2.start = start2;
                        m2.len -= correction;
                    }
                }

                let mut start3;
                let m3;
                if start2 + m2.len <= mflimit {
                    start3 = start2 + m2.len - 3;
                    m3 = find_hc_wider_match::<PATTERN_ANALYSIS, false, false>(
                        full,
                        &mut table,
                        start3,
                        start2,
                        match_limit,
                        m2.len,
                        ATTEMPTS,
                    );
                    start3 = m3.start;
                } else {
                    m3 = nomatch;
                    start3 = 0;
                }

                if m3.len <= m2.len {
                    if start2 < ip + m1.len {
                        m1.len = start2 - ip;
                    }
                    op = encode_sequence(full, dst, anchor, ip, m1.len, m1.off, op)?;
                    ip += m1.len;
                    anchor = ip;

                    ip = start2;
                    op = encode_sequence(full, dst, anchor, ip, m2.len, m2.off, op)?;
                    ip += m2.len;
                    anchor = ip;
                    break 'search2;
                }

                if start3 < ip + m1.len + 3 {
                    if start3 >= ip + m1.len {
                        if start2 < ip + m1.len {
                            let correction = ip + m1.len - start2;
                            start2 += correction;
                            m2.start = start2;
                            m2.len = m2.len.saturating_sub(correction);
                            if m2.len < MINMATCH {
                                start2 = start3;
                                m2 = m3;
                            }
                        }
                        op = encode_sequence(full, dst, anchor, ip, m1.len, m1.off, op)?;
                        ip += m1.len;
                        anchor = ip;

                        ip = start3;
                        m1 = m3;
                        start0 = start2;
                        m0 = m2;
                        continue 'search2;
                    }

                    start2 = start3;
                    m2 = m3;
                    continue 'search3;
                }

                if start2 < ip + m1.len {
                    if start2 - ip < OPTIMAL_ML {
                        if m1.len > OPTIMAL_ML {
                            m1.len = OPTIMAL_ML;
                        }
                        if ip + m1.len > start2 + m2.len - MINMATCH {
                            m1.len = start2 - ip + m2.len - MINMATCH;
                        }
                        let correction = m1.len.saturating_sub(start2 - ip);
                        if correction > 0 {
                            start2 += correction;
                            m2.start = start2;
                            m2.len -= correction;
                        }
                    } else {
                        m1.len = start2 - ip;
                    }
                }

                op = encode_sequence(full, dst, anchor, ip, m1.len, m1.off, op)?;
                ip += m1.len;
                anchor = ip;

                ip = start2;
                m1 = m2;
                start2 = start3;
                m2 = m3;
                continue 'search3;
            }
        }
    }

    emit_last_literals_with_base(full, dst, base, anchor, op)
}

/// HC block compressor with a preceding dictionary. Concatenates the
/// (truncated to `LZ4_DISTANCE_MAX`) dictionary in front of `src` and
/// dispatches to the matching HC strategy (LZ4mid / hash-chain / optimal),
/// mirroring upstream `LZ4HC_compress_generic_internal()` with
/// `dictDirective == usingDictCtx`/`usingExtDict`.
fn compress_block_hc_with_dict(
    src: &[u8],
    dst: &mut [u8],
    dict: &[u8],
    compression_level: c_int,
    favor_dec_speed: bool,
) -> Option<usize> {
    if src.is_empty() {
        return emit_last_literals(src, dst, 0, 0);
    }
    let dict_keep = cmp::min(dict.len(), LZ4_DISTANCE_MAX);
    let dict = &dict[dict.len() - dict_keep..];
    if dict.is_empty() || src.len() < MFLIMIT + 1 {
        return compress_block_hc(src, dst, compression_level, favor_dec_speed);
    }

    let mut full = Vec::with_capacity(dict.len() + src.len());
    full.extend_from_slice(dict);
    full.extend_from_slice(src);
    let base = dict.len();
    let level = normalize_hc_level(compression_level);
    if level <= 2 {
        return compress_block_lz4mid_with_base(&full, dst, base);
    }
    if level >= 10 {
        return compress_block_hc_optimal(&full, dst, base, level, favor_dec_speed);
    }
    compress_block_hc_hashchain(&full, dst, base, level)
}

/// HC optimal parser (levels 10-12). Mirrors upstream `LZ4HC_compress_optimal`
/// (lz4hc.c:1879+): builds a forward-DP `opt[]` table of best-price
/// (literal, match) decisions over a sliding window of up to `LZ4_OPT_NUM`
/// positions, then traces back to emit the chosen sequences. `base` is the
/// offset inside `full` where the input to be emitted starts; `full[..base]`
/// is retained dictionary prefix (or empty). `favor_dec_speed` enables the
/// upstream `favorDecompressionSpeed` shortcut that biases matching towards
/// faster decode at a small ratio cost.
fn compress_block_hc_optimal(
    full: &[u8],
    dst: &mut [u8],
    base: usize,
    compression_level: c_int,
    favor_dec_speed: bool,
) -> Option<usize> {
    match (normalize_hc_level(compression_level), favor_dec_speed) {
        (10, false) => compress_block_hc_optimal_impl::<96, 64, false, false>(full, dst, base),
        (10, true) => compress_block_hc_optimal_impl::<96, 64, false, true>(full, dst, base),
        (11, false) => compress_block_hc_optimal_impl::<512, 128, false, false>(full, dst, base),
        (11, true) => compress_block_hc_optimal_impl::<512, 128, false, true>(full, dst, base),
        (_, false) => compress_block_hc_optimal_impl::<16_384, { LZ4_OPT_NUM - 1 }, true, false>(
            full, dst, base,
        ),
        (_, true) => compress_block_hc_optimal_impl::<16_384, { LZ4_OPT_NUM - 1 }, true, true>(
            full, dst, base,
        ),
    }
}

fn compress_block_hc_optimal_impl<
    const ATTEMPTS: usize,
    const SUFFICIENT_LEN: usize,
    const FULL_UPDATE: bool,
    const FAVOR_DEC_SPEED: bool,
>(
    full: &[u8],
    dst: &mut [u8],
    base: usize,
) -> Option<usize> {
    let src_len = full.len().checked_sub(base)?;
    if src_len == 0 {
        return emit_last_literals_with_base(full, dst, base, base, 0);
    }
    if src_len < MFLIMIT + 1 {
        return emit_last_literals_with_base(full, dst, base, base, 0);
    }

    let mut table = HcTables::with_base(full.len(), base);
    if base > 0 {
        table.insert_until(full, base);
    }

    // Allocate on the heap (Box<[_; N]>) instead of `Vec` so the
    // compiler knows the length is fixed at `LZ4_OPT_NUM + 3` and can
    // eliminate per-access bounds checks more aggressively. We keep it on
    // the heap rather than the stack because the array is 64 KiB
    // (4099 × 16 B), which is well above what's safe on the default 8 MiB
    // stack when we're already deep in the encoder call stack.
    let mut opt: Box<[HcOptimal; LZ4_OPT_NUM + 3]> = vec![
        HcOptimal {
            price: u32::MAX / 4,
            off: 0,
            mlen: 1,
            litlen: 0,
        };
        LZ4_OPT_NUM + 3
    ]
    .into_boxed_slice()
    .try_into()
    .unwrap();

    let mut ip = base;
    let mut anchor = base;
    let mut op = 0usize;
    let iend = full.len();
    let mflimit = iend - MFLIMIT;
    let match_limit = iend - LAST_LITERALS;
    // High-water mark of the largest opt[] index written by the previous
    // main-loop iteration. The next iteration only needs to reset the
    // entries it might read. On the first iteration we conservatively clear
    // the full table so pre-loop sentinel values are correct everywhere.
    let mut prev_max_touched: usize = LZ4_OPT_NUM + 2;

    while ip <= mflimit {
        let llen = ip - anchor;
        let first_match = find_hc_longer_match::<FAVOR_DEC_SPEED>(
            full,
            &mut table,
            ip,
            match_limit,
            MINMATCH - 1,
            ATTEMPTS,
        );
        if first_match.len == 0 {
            ip += 1;
            continue;
        }

        if first_match.len > SUFFICIENT_LEN {
            op = encode_sequence(full, dst, anchor, ip, first_match.len, first_match.off, op)?;
            ip += first_match.len;
            anchor = ip;
            continue;
        }

        // Reset only the prefix of opt[] that the previous iteration
        // touched. Profile showed the unconditional 65-KiB
        // `opt.fill(...)` was burning a huge chunk of HC10 time
        // (visible as many `movdqu %xmm0` writes in `perf annotate`).
        // The largest index any iteration writes is `last_match_pos + 3`
        // (the trailing add_lit loop), so resetting that range plus a
        // little slack is sufficient for the next iteration's reads to
        // see the sentinel everywhere they care about.
        let fill_end = (prev_max_touched + 1).min(LZ4_OPT_NUM + 3);
        opt[..fill_end].fill(HcOptimal {
            price: u32::MAX / 4,
            off: 0,
            mlen: 1,
            litlen: 0,
        });

        for rpos in 0..MINMATCH {
            opt[rpos] = HcOptimal {
                price: hc_literals_price(llen + rpos),
                off: 0,
                mlen: 1,
                litlen: (llen + rpos) as u32,
            };
        }

        let first_len = first_match.len.min(LZ4_OPT_NUM - 4);
        for mlen in MINMATCH..=first_len {
            opt[mlen] = HcOptimal {
                price: hc_sequence_price(llen, mlen),
                off: first_match.off as u32,
                mlen: mlen as u32,
                litlen: llen as u32,
            };
        }
        let mut last_match_pos = first_len;
        for add_lit in 1..=3 {
            let pos = last_match_pos + add_lit;
            opt[pos] = HcOptimal {
                price: opt[last_match_pos].price + hc_literals_price(add_lit),
                off: 0,
                mlen: 1,
                litlen: add_lit as u32,
            };
        }

        let mut best_mlen = opt[last_match_pos].mlen as usize;
        let mut best_off = opt[last_match_pos].off as usize;
        let mut cur = 1usize;
        let mut immediate = false;

        while cur < last_match_pos {
            let cur_ptr = ip + cur;
            if cur_ptr > mflimit {
                break;
            }

            if FULL_UPDATE {
                if opt[cur + 1].price <= opt[cur].price
                    && opt[cur + MINMATCH].price < opt[cur].price + 3
                {
                    cur += 1;
                    continue;
                }
            } else if opt[cur + 1].price <= opt[cur].price {
                cur += 1;
                continue;
            }

            let min_len = if FULL_UPDATE {
                MINMATCH - 1
            } else {
                last_match_pos - cur
            };
            let new_match = find_hc_longer_match::<FAVOR_DEC_SPEED>(
                full,
                &mut table,
                cur_ptr,
                match_limit,
                min_len,
                ATTEMPTS,
            );
            if new_match.len == 0 {
                cur += 1;
                continue;
            }

            if new_match.len > SUFFICIENT_LEN || new_match.len + cur >= LZ4_OPT_NUM {
                best_mlen = new_match.len;
                best_off = new_match.off;
                last_match_pos = cur + 1;
                immediate = true;
                break;
            }

            let base_litlen = opt[cur].litlen as usize;
            // Hoist `opt[cur].price` and `hc_literals_price(base_litlen)` out
            // of the 3-iter literals loop — both are loop-invariant.
            let lit_anchor_price = opt[cur]
                .price
                .saturating_sub(hc_literals_price(base_litlen));
            for litlen in 1..MINMATCH {
                let pos = cur + litlen;
                let price = lit_anchor_price + hc_literals_price(base_litlen + litlen);
                if price < opt[pos].price {
                    opt[pos] = HcOptimal {
                        price,
                        off: 0,
                        mlen: 1,
                        litlen: (base_litlen + litlen) as u32,
                    };
                }
            }

            let match_len = new_match.len.min(LZ4_OPT_NUM - cur - 1);
            // Hoist the loop-invariant `opt[cur].mlen == 1` decision out of
            // the ml loop. `base_ll` and `base_price` don't depend on ml, so
            // computing them once instead of on every inner iteration cuts
            // both the cache pressure on `opt[cur]` and the cmov/branch
            // overhead. Mirrors upstream's structure where `ll` and the
            // prefix lookup are read once before the price loop.
            let (base_ll, base_price) = if opt[cur].mlen == 1 {
                let ll = opt[cur].litlen as usize;
                let prefix = if cur > ll { opt[cur - ll].price } else { 0 };
                (ll, prefix)
            } else {
                (0usize, opt[cur].price)
            };
            let new_off_u32 = new_match.off as u32;
            let base_ll_u32 = base_ll as u32;
            let dec_speed_adj = u32::from(FAVOR_DEC_SPEED);
            // Hoist `hc_sequence_price`'s literals-dependent portion out of
            // the loop. Only the match-length extension term needs to be
            // recomputed per iteration, and only for `ml >= 19` (the common
            // short-match case skips this entirely).
            let base_seq_price = base_price + 3 + hc_literals_price(base_ll);
            // Split the inner ml loop. `last_match_pos` only changes when
            // `ml == match_len` in the LAST iteration, so for ml in
            // MINMATCH..match_len it is invariant — let the compiler see
            // that by lifting the `last_match_pos + 3` threshold out of the
            // body and removing the `ml == match_len` branch from the hot
            // loop entirely.
            let lmp_thresh = last_match_pos + 3;
            for ml in MINMATCH..match_len {
                let pos = cur + ml;
                let mut price = base_seq_price;
                if ml >= 15 + MINMATCH {
                    price += 1 + ((ml - (15 + MINMATCH)) / 255) as u32;
                }
                // Lift the `opt[pos].price` read out of the unconditional
                // path. When `pos > lmp_thresh` we always write, so the
                // existing price doesn't matter — and skipping the read
                // saves one cache hit per iteration in the typical case
                // (most ml iters land past the threshold for HC10/11).
                let do_write = if pos > lmp_thresh {
                    true
                } else {
                    let acceptable_price = opt[pos].price.saturating_sub(dec_speed_adj);
                    price <= acceptable_price
                };
                if do_write {
                    opt[pos] = HcOptimal {
                        price,
                        off: new_off_u32,
                        mlen: ml as u32,
                        litlen: base_ll_u32,
                    };
                }
            }
            // Handle the final iteration (ml == match_len) which also
            // potentially updates `last_match_pos`.
            if match_len >= MINMATCH {
                let ml = match_len;
                let pos = cur + ml;
                let mut price = base_seq_price;
                if ml >= 15 + MINMATCH {
                    price += 1 + ((ml - (15 + MINMATCH)) / 255) as u32;
                }
                let do_write = if pos > last_match_pos + 3 {
                    true
                } else {
                    let acceptable_price = opt[pos].price.saturating_sub(dec_speed_adj);
                    price <= acceptable_price
                };
                if do_write {
                    if last_match_pos < pos {
                        last_match_pos = pos;
                    }
                    opt[pos] = HcOptimal {
                        price,
                        off: new_off_u32,
                        mlen: ml as u32,
                        litlen: base_ll_u32,
                    };
                }
            }

            for add_lit in 1..=3 {
                let pos = last_match_pos + add_lit;
                opt[pos] = HcOptimal {
                    price: opt[last_match_pos].price + hc_literals_price(add_lit),
                    off: 0,
                    mlen: 1,
                    litlen: add_lit as u32,
                };
            }
            cur += 1;
        }

        if !immediate {
            best_mlen = opt[last_match_pos].mlen as usize;
            best_off = opt[last_match_pos].off as usize;
            cur = last_match_pos.saturating_sub(best_mlen);
        }

        let mut candidate_pos = cur;
        let mut selected_match_length = best_mlen as u32;
        let mut selected_offset = best_off as u32;
        loop {
            let next_match_length = opt[candidate_pos].mlen;
            let next_offset = opt[candidate_pos].off;
            opt[candidate_pos].mlen = selected_match_length;
            opt[candidate_pos].off = selected_offset;
            selected_match_length = next_match_length;
            selected_offset = next_offset;
            if next_match_length as usize > candidate_pos {
                break;
            }
            candidate_pos -= next_match_length as usize;
        }

        let mut rpos = 0usize;
        while rpos < last_match_pos {
            let ml = opt[rpos].mlen as usize;
            let offset = opt[rpos].off as usize;
            if ml == 1 {
                ip += 1;
                rpos += 1;
                continue;
            }
            rpos += ml;
            op = encode_sequence(full, dst, anchor, ip, ml, offset, op)?;
            ip += ml;
            anchor = ip;
        }
        // Track how much of opt[] we wrote to so the next iteration's
        // partial fill knows what to reset. The largest-index write is
        // the trailing `add_lit` loop at `last_match_pos + 3`.
        prev_max_touched = last_match_pos + 3;
    }

    emit_last_literals_with_base(full, dst, base, anchor, op)
}

/// Compress a single frame-format block under the given preferences. Selects
/// HC (with or without dictionary) when `prefs.compression_level` is at least
/// the frame HC minimum, and the fast LZ4 block compressor otherwise. Used by
/// the frame-format encoder.
fn compress_frame_block(
    src: &[u8],
    dst: &mut [u8],
    prefs: &FramePrefs,
    dict: &[u8],
) -> Option<usize> {
    if prefs.compression_level >= LZ4HC_CLEVEL_MIN && !dict.is_empty() {
        compress_block_hc_with_dict(
            src,
            dst,
            dict,
            prefs.compression_level,
            prefs.favor_dec_speed,
        )
    } else if prefs.compression_level >= LZ4HC_CLEVEL_MIN {
        compress_block_hc(src, dst, prefs.compression_level, prefs.favor_dec_speed)
    } else {
        compress_block(src, dst, 1)
    }
}

/// Clamp an HC compression level to `[1, LZ4HC_CLEVEL_MAX]`; non-positive
/// values map to `LZ4HC_CLEVEL_DEFAULT`. Mirrors upstream's `LZ4HC_CLEVEL_*`
/// validation in `LZ4HC_compress_generic_internal`.
fn normalize_hc_level(compression_level: c_int) -> c_int {
    if compression_level < 1 {
        LZ4HC_CLEVEL_DEFAULT
    } else {
        cmp::min(compression_level, LZ4HC_CLEVEL_MAX)
    }
}

/// Byte cost of a literals run of length `lit_len` in the LZ4 wire format.
/// Mirrors upstream `LZ4HC_literalsPrice` (lz4hc.c:1827): each literal byte
/// costs 1, plus one extra byte for entering the variable-length encoding at
/// `lit_len >= RUN_MASK` and one further byte per 255-byte chunk.
#[inline(always)]
fn hc_literals_price(lit_len: usize) -> u32 {
    let mut price = lit_len as u32;
    if lit_len >= 15 {
        price += 1 + ((lit_len - 15) / 255) as u32;
    }
    price
}

/// Byte cost of an encoded (literals, match) sequence. Mirrors upstream
/// `LZ4HC_sequencePrice` (lz4hc.c:1837): one token byte, two offset bytes,
/// the literals price, and any extension bytes for matches beyond
/// `ML_MASK + MINMATCH`.
#[inline(always)]
fn hc_sequence_price(lit_len: usize, match_len: usize) -> u32 {
    let mut price = 1 + 2 + hc_literals_price(lit_len);
    if match_len >= 15 + MINMATCH {
        price += 1 + ((match_len - (15 + MINMATCH)) / 255) as u32;
    }
    price
}

/// HC `fillOutput`-style compressor: returns the largest `(consumed, written)`
/// pair such that the HC encoder fits inside `dst`. Unlike the fast block path
/// (`compress_dest_size`), upstream HC does not have a single-pass fillOutput
/// implementation, so we binary-search over prefixes of `src` and keep the
/// best fit. Used by `LZ4F_compressFrame` / streaming HC when only a bounded
/// output buffer is available.
fn compress_hc_dest_size(
    src: &[u8],
    dst: &mut [u8],
    compression_level: c_int,
    favor_dec_speed: bool,
) -> Option<(usize, usize)> {
    if src.is_empty() {
        let written = compress_block_hc(src, dst, compression_level, favor_dec_speed)?;
        return Some((0, written));
    }

    let mut low = 0usize;
    let mut high = src.len();
    let mut best: Option<(usize, usize, Vec<u8>)> = None;
    while low <= high {
        let mid = low + (high - low) / 2;
        let mut candidate = vec![0u8; dst.len()];
        match compress_block_hc(
            &src[..mid],
            &mut candidate,
            compression_level,
            favor_dec_speed,
        ) {
            Some(written) if written <= dst.len() => {
                best = Some((mid, written, candidate));
                low = mid + 1;
            }
            _ => {
                if mid == 0 {
                    break;
                }
                high = mid - 1;
            }
        }
    }

    let (consumed, written, candidate) = best?;
    dst[..written].copy_from_slice(&candidate[..written]);
    Some((consumed, written))
}

/// HC `fillOutput`-style compressor with a preceding dictionary. Same prefix
/// binary search as `compress_hc_dest_size`, but each candidate call routes
/// through `compress_block_hc_with_dict` so the dictionary is in scope.
fn compress_hc_dest_size_with_dict(
    src: &[u8],
    dst: &mut [u8],
    dict: &[u8],
    compression_level: c_int,
    favor_dec_speed: bool,
) -> Option<(usize, usize)> {
    if src.is_empty() {
        let written =
            compress_block_hc_with_dict(src, dst, dict, compression_level, favor_dec_speed)?;
        return Some((0, written));
    }

    let mut low = 0usize;
    let mut high = src.len();
    let mut best: Option<(usize, usize, Vec<u8>)> = None;
    while low <= high {
        let mid = low + (high - low) / 2;
        let mut candidate = vec![0u8; dst.len()];
        match compress_block_hc_with_dict(
            &src[..mid],
            &mut candidate,
            dict,
            compression_level,
            favor_dec_speed,
        ) {
            Some(written) if written <= dst.len() => {
                best = Some((mid, written, candidate));
                low = mid + 1;
            }
            _ => {
                if mid == 0 {
                    break;
                }
                high = mid - 1;
            }
        }
    }

    let (consumed, written, candidate) = best?;
    dst[..written].copy_from_slice(&candidate[..written]);
    Some((consumed, written))
}

/// Append freshly-compressed input to the HC streaming dictionary, dropping
/// from the front so the retained tail never exceeds `LZ4_DISTANCE_MAX` —
/// matching upstream's sliding-window behavior in `LZ4_loadDictHC` /
/// `LZ4HC_setExternalDict`.
fn append_hc_dictionary(dictionary: &mut Vec<u8>, src: &[u8]) {
    dictionary.extend_from_slice(src);
    if dictionary.len() > LZ4_DISTANCE_MAX {
        let drop_len = dictionary.len() - LZ4_DISTANCE_MAX;
        dictionary.drain(..drop_len);
    }
}

/// Insert positions up to `ip` into the HC chain and return the best forward
/// match starting at `ip`. Mirrors upstream `LZ4HC_InsertAndFindBestMatch`
/// (lz4hc.c:1139): pins `iLowLimit == ip`, disables chain swapping, and
/// enables pattern analysis only when the search budget exceeds 128 (levels
/// 9+). Used by the plain HC hash-chain parser.
fn find_hc_match<const PATTERN_ANALYSIS: bool>(
    src: &[u8],
    table: &mut HcTables,
    ip: usize,
    match_limit: usize,
    max_attempts: usize,
) -> HcMatch {
    find_hc_wider_match::<PATTERN_ANALYSIS, false, false>(
        src,
        table,
        ip,
        ip,
        match_limit,
        MINMATCH - 1,
        max_attempts,
    )
}

/// Match-finder used by the HC optimal parser: returns the best forward match
/// at `ip` that strictly exceeds `min_len`, or `len == 0` if none was found.
/// Mirrors upstream `LZ4HC_FindLongerMatch` (lz4hc.c:1851): always enables
/// pattern analysis and chain-swap, and applies the `favorDecSpeed` shortcut
/// that clamps match lengths in the `(18, 36]` band down to 18.
#[inline(always)]
fn find_hc_longer_match<const FAVOR_DEC_SPEED: bool>(
    src: &[u8],
    table: &mut HcTables,
    ip: usize,
    match_limit: usize,
    min_len: usize,
    max_attempts: usize,
) -> HcMatch {
    let m = find_hc_wider_match::<true, true, FAVOR_DEC_SPEED>(
        src,
        table,
        ip,
        ip,
        match_limit,
        min_len,
        max_attempts,
    );
    if m.len <= min_len {
        HcMatch {
            start: ip,
            len: 0,
            off: 0,
        }
    } else {
        let len = if FAVOR_DEC_SPEED && m.len > 18 && m.len <= 36 {
            18
        } else {
            m.len
        };
        HcMatch { len, ..m }
    }
}

/// Core HC match finder. Mirrors upstream `LZ4HC_InsertAndGetWiderMatch`
/// (lz4hc.c:914+): walks the hash chain backwards from `ip` for up to
/// `max_attempts` steps, optionally allowing matches that start before `ip`
/// (i.e. `iLowLimit < ip`) so the parser can lengthen an earlier match. The
/// `flags` bitmask selects pattern analysis, chain swap, and the
/// `favorDecompressionSpeed` shortcut that skips matches with offset < 8.
#[inline(always)]
fn find_hc_wider_match<
    const PATTERN_ANALYSIS: bool,
    const CHAIN_SWAP: bool,
    const FAVOR_DEC_SPEED: bool,
>(
    src: &[u8],
    table: &mut HcTables,
    ip: usize,
    low_limit: usize,
    match_limit: usize,
    longest: usize,
    max_attempts: usize,
) -> HcMatch {
    table.insert_until(src, ip);
    if ip + MINMATCH > match_limit {
        return HcMatch {
            start: ip,
            len: 0,
            off: 0,
        };
    }

    let ip_log = HcTables::to_log(ip);
    // `ipIndex - LZ4_DISTANCE_MAX`, clamped at `HC_OFFSET`: below `HC_OFFSET`
    // means "before the start of valid data". Matches upstream's
    // `max(lowLimit, ipIndex - LZ4_DISTANCE_MAX)`.
    let lowest_log = cmp::max(HC_OFFSET, ip_log.wrapping_sub(LZ4_DISTANCE_MAX as u32));
    let mut candidate_log = table.hash[hash4_hc(src, ip)];
    let mut attempts = max_attempts;
    let mut best = HcMatch {
        start: ip,
        len: longest,
        off: 0,
    };
    let pattern = read_u32(&src[ip..]);
    let repeated_pattern = is_repeated_pattern(pattern);
    let mut src_pattern_len = 0usize;
    let mut match_chain_pos = 0usize;
    let src_ptr = src.as_ptr();
    let look_back = ip - low_limit;
    let prefix_base = table.base;
    // `HcTables::with_base` always allocates `LZ4_DISTANCE_MAX + 1` entries,
    // mirroring upstream's fixed-size `chainTable[LZ4HC_MAXD]`.
    let chain_ptr = table.chain.as_ptr();
    // Upstream loop condition is exactly this after the `+64 KiB` offset
    // trick: `while ((matchIndex >= lowestMatchIndex) && (nbAttempts > 0))`.
    // The `u16` delta chain + logical positions keep any wrap-around
    // impossible, so no extra `candidate < ip` or sentinel guards are needed.
    while candidate_log >= lowest_log && attempts > 0 {
        attempts -= 1;
        let candidate = HcTables::to_phys(candidate_log);
        let mut match_len = 0usize;
        // Combine the two `if !early_skip` blocks into a single guarded
        // region. With `#[inline(always)]` and `favor_dec_speed=false` (the
        // common HC10-12 case), the compiler will DCE the entire block
        // wrapper. Mirrors upstream's structure where the early-exit filter
        // and the 4-byte pattern compare share one guarded block.
        //
        // Bound checks `ref_end < src_len && cand_end < src_len` were
        // removed earlier — both are guaranteed by the loop preconditions
        // (`low_limit + best.len ≤ match_limit ≤ src_len - LAST_LITERALS`
        // and `candidate >= look_back`).
        let early_skip = FAVOR_DEC_SPEED && ip - candidate < 8;
        if !early_skip {
            let mut passes_filter = true;
            if best.len >= 1 && candidate >= look_back {
                let ref_end = low_limit + best.len;
                let cand_end = candidate - look_back + best.len;
                let a = read_u16_ptr(unsafe { src_ptr.add(ref_end - 1) });
                let b = read_u16_ptr(unsafe { src_ptr.add(cand_end - 1) });
                passes_filter = a == b;
            }
            if passes_filter && read_u32_ptr(unsafe { src_ptr.add(candidate) }) == pattern {
                let forward =
                    MINMATCH + count_match(src, ip + MINMATCH, candidate + MINMATCH, match_limit);
                let back = count_back(src, ip, candidate, low_limit);
                let len = forward + back;
                match_len = len;
                if len > best.len {
                    best = HcMatch {
                        start: ip - back,
                        len,
                        off: ip - candidate,
                    };
                }
            }
        }

        if CHAIN_SWAP && match_len == best.len && candidate + best.len <= ip {
            let mut distance_to_next: u32 = 1;
            let end = best.len.saturating_sub(MINMATCH - 1);
            let mut accel = 1usize << 4;
            let mut pos = 0usize;
            while pos < end {
                let probe = candidate + pos;
                // Chain stores deltas directly, mirroring upstream's
                // `DELTANEXTU16` return value. `0xFFFF` (init sentinel) is
                // strictly greater than anything useful, but it naturally
                // caps `distance_to_next`'s growth.
                let candidate_dist = unsafe { *chain_ptr.add(probe & LZ4_DISTANCE_MAX) } as u32;
                let step = accel >> 4;
                accel += 1;
                if candidate_dist > distance_to_next {
                    distance_to_next = candidate_dist;
                    match_chain_pos = pos;
                    accel = 1usize << 4;
                }
                pos += step;
            }
            if distance_to_next > 1 {
                candidate_log = candidate_log.wrapping_sub(distance_to_next);
                continue;
            }
        }

        let chain_probe = candidate + match_chain_pos;
        let dist_next_match = unsafe { *chain_ptr.add(chain_probe & LZ4_DISTANCE_MAX) } as u32;
        if PATTERN_ANALYSIS
            && dist_next_match == 1
            && repeated_pattern
            && candidate_log > lowest_log
            && match_chain_pos == 0
        {
            if src_pattern_len == 0 {
                src_pattern_len =
                    MINMATCH + count_pattern(src, ip + MINMATCH, match_limit, pattern);
            }
            let match_candidate = candidate - 1;
            // Upstream's `LZ4HC_protectDictEnd` guards the repeated-pattern
            // branch so a dict-area candidate that sits in the final 3 bytes
            // before the current prefix (i.e. would straddle the dict/prefix
            // boundary in ext-dict mode) is excluded. In our contiguous
            // buffer model this collapses to requiring
            // `match_candidate + 4 <= base` when the candidate is inside the
            // dict; candidates at or past `base` are always fine (upstream's
            // U32 wrap produces a value >= 3 in that case).
            let protect_dict_end = prefix_base == 0
                || match_candidate >= prefix_base
                || match_candidate + MINMATCH <= prefix_base;
            let lowest = HcTables::to_phys(lowest_log);
            if protect_dict_end
                && match_candidate >= lowest
                && match_candidate + MINMATCH <= src.len()
                && read_u32_ptr(unsafe { src.as_ptr().add(match_candidate) }) == pattern
            {
                let forward =
                    MINMATCH + count_pattern(src, match_candidate + MINMATCH, match_limit, pattern);
                // Upstream reverse-counts the pattern back to either
                // `prefixPtr` or `dictStart` depending on whether the
                // candidate is in the current prefix or external dictionary,
                // and then clamps the returned length so
                // `matchCandidateIdx - backLength >= lowestMatchIndex`. Our
                // contiguous-buffer model combines both bounds into the
                // single `0` floor for `reverseCountPattern`, so we just
                // apply the distance-based clamp afterwards.
                let back_raw = reverse_count_pattern(src, match_candidate, 0, pattern);
                let back = cmp::min(back_raw, match_candidate.saturating_sub(lowest));
                let current_segment_len = back + forward;
                let adjusted_to_segment_end =
                    current_segment_len >= src_pattern_len && forward <= src_pattern_len;
                let mut next_candidate = if adjusted_to_segment_end {
                    match_candidate + forward - src_pattern_len
                } else {
                    match_candidate.saturating_sub(back)
                };
                if next_candidate < lowest {
                    next_candidate = lowest;
                }
                if adjusted_to_segment_end {
                    if next_candidate < candidate {
                        candidate_log = HcTables::to_log(next_candidate);
                        continue;
                    }
                } else if low_limit == ip
                    && next_candidate < ip
                    && ip - next_candidate <= LZ4_DISTANCE_MAX
                {
                    let max_len = cmp::min(current_segment_len, src_pattern_len);
                    if max_len > best.len && !(FAVOR_DEC_SPEED && ip - next_candidate < 8) {
                        best = HcMatch {
                            start: ip,
                            len: max_len,
                            off: ip - next_candidate,
                        };
                    }
                    if next_candidate < candidate {
                        let after_pattern = table.previous(next_candidate);
                        candidate_log =
                            if after_pattern != usize::MAX && after_pattern < next_candidate {
                                HcTables::to_log(after_pattern)
                            } else {
                                HcTables::to_log(next_candidate)
                            };
                        continue;
                    }
                }

                if next_candidate < candidate {
                    candidate_log = HcTables::to_log(next_candidate);
                    continue;
                }
            }
        }

        // `candidate_log -= dist_next_match` can't wrap below `HC_OFFSET`
        // because `candidate_log >= lowest_log >= HC_OFFSET` (≥ 65536) and
        // `dist_next_match <= 65535`. If it drops below `lowest_log` the
        // outer loop condition exits on the next turn.
        candidate_log = candidate_log.wrapping_sub(dist_next_match);
    }

    best
}

/// Returns `true` if `pattern` (a 4-byte sample) is a repetition of a 1- or
/// 2-byte unit. Used by the HC parser to gate the pattern-analysis fast path,
/// matching upstream's `LZ4HC_countPattern` precondition that the pattern is
/// a length-1, length-2, or length-4 repeat (but not length-3).
#[inline(always)]
fn is_repeated_pattern(pattern: u32) -> bool {
    (pattern & 0xffff) == (pattern >> 16) && (pattern & 0xff) == (pattern >> 24)
}

/// Forward-count bytes in `src` starting at `pos` that continue a repeated
/// pattern. Mirrors upstream `LZ4HC_countPattern` (lz4hc.c:851): `pattern`
/// must be a length-1, length-2, or length-4 repeat. Returns the number of
/// matching bytes (capped at `limit - pos`).
#[inline]
fn count_pattern(src: &[u8], mut pos: usize, limit: usize, pattern: u32) -> usize {
    let byte = pattern as u8;
    let start = pos;
    while pos < limit && src[pos] == byte {
        pos += 1;
    }
    pos - start
}

/// Backward-count bytes preceding `pos` that continue a repeated pattern.
/// Mirrors upstream `LZ4HC_reverseCountPattern` (lz4hc.c:884): `pattern` must
/// be a length-1, length-2, or length-4 repeat, read using natural platform
/// endianness. The bulk loop reads 4 bytes at a time, which is correct for
/// length-4 repeats (e.g. `0xAABBCCDD`) where a per-byte walk would miss
/// matches that align on 4-byte boundaries.
fn reverse_count_pattern(src: &[u8], mut pos: usize, low_limit: usize, pattern: u32) -> usize {
    let start = pos;
    // Upstream takes `(BYTE*)(&pattern) + 3` then walks down — i.e. the byte
    // at the highest memory address of the u32, regardless of host endianness.
    // `to_ne_bytes()` preserves that memory order.
    let pattern_bytes = pattern.to_ne_bytes();
    while pos >= low_limit + 4 {
        let prev = read_u32_ptr(unsafe { src.as_ptr().add(pos - 4) });
        if prev != pattern {
            break;
        }
        pos -= 4;
    }
    let mut tail_idx = 3usize;
    while pos > low_limit {
        if src[pos - 1] != pattern_bytes[tail_idx] {
            break;
        }
        pos -= 1;
        if tail_idx == 0 {
            break;
        }
        tail_idx -= 1;
    }
    start - pos
}

/// Count the number of bytes matching immediately *before* `ip` and
/// `candidate`. Mirrors upstream `LZ4HC_countBack` (lz4hc.c:202) but returns a
/// positive count rather than the negative offset upstream produces. The
/// 8-byte SWAR step uses `leading_zeros / 8` to locate the first differing
/// byte from the high end of the loaded word.
#[inline(always)]
fn count_back(src: &[u8], ip: usize, candidate: usize, low_limit: usize) -> usize {
    let mut back = 0usize;
    let max_back = cmp::min(ip - low_limit, candidate);
    let src_ptr = src.as_ptr();
    unsafe {
        while back + 8 <= max_back {
            let a = read_u64_ptr(src_ptr.add(ip - back - 8));
            let b = read_u64_ptr(src_ptr.add(candidate - back - 8));
            let diff = a ^ b;
            if diff == 0 {
                back += 8;
            } else {
                back += diff.leading_zeros() as usize / 8;
                return back;
            }
        }
        while back < max_back && *src_ptr.add(ip - back - 1) == *src_ptr.add(candidate - back - 1) {
            back += 1;
        }
    }
    back
}

/// Count the number of bytes matching forward from `ip` and `match_pos`,
/// stopping at `limit`. Mirrors upstream `LZ4_count` (lz4.c:676): the bulk
/// loop reads 8 bytes at a time and locates the first differing byte via
/// `trailing_zeros / 8`, then a tail walk handles the final 0-7 bytes.
#[inline(always)]
fn count_match(src: &[u8], mut ip: usize, mut match_pos: usize, limit: usize) -> usize {
    let start = ip;
    let src_ptr = src.as_ptr();
    unsafe {
        while ip + 8 <= limit {
            let diff = read_u64_ptr(src_ptr.add(ip)) ^ read_u64_ptr(src_ptr.add(match_pos));
            if diff != 0 {
                return ip - start + (diff.trailing_zeros() as usize / 8);
            }
            ip += 8;
            match_pos += 8;
        }
        while ip < limit && *src_ptr.add(ip) == *src_ptr.add(match_pos) {
            ip += 1;
            match_pos += 1;
        }
    }
    ip - start
}

/// Emit one (literals, offset, match-length) sequence into `dst`. Mirrors
/// upstream `LZ4HC_encodeSequence` (lz4hc.c:292): writes the token byte, any
/// literal-length extension bytes, the literal payload, the 16-bit little-
/// endian offset, and any match-length extension bytes. Returns the new write
/// cursor, or `None` if the sequence would overflow `dst`.
#[inline(always)]
fn encode_sequence(
    src: &[u8],
    dst: &mut [u8],
    anchor: usize,
    ip: usize,
    match_len: usize,
    offset: usize,
    mut op: usize,
) -> Option<usize> {
    if offset == 0 || offset > LZ4_DISTANCE_MAX {
        return None;
    }
    let lit_len = ip - anchor;
    let token_pos = op;
    if op >= dst.len() {
        return None;
    }
    op += 1;
    op = emit_len(dst, op, lit_len, 15)?;
    if op + lit_len + 2 > dst.len() {
        return None;
    }
    dst[op..op + lit_len].copy_from_slice(&src[anchor..ip]);
    op += lit_len;
    dst[op..op + 2].copy_from_slice(&(offset as u16).to_le_bytes());
    op += 2;

    let ml_code = match_len - MINMATCH;
    dst[token_pos] = ((cmp::min(lit_len, 15) as u8) << 4) | cmp::min(ml_code, 15) as u8;
    emit_len(dst, op, ml_code, 15)
}

/// Emit the trailing literals run (token + variable-length literal-length
/// extension + payload) that terminates an LZ4 block. Mirrors upstream's
/// `_last_literals` exit block (lz4.c:1298+) under the `notLimited` directive.
/// Returns the final output cursor, or `None` if `dst` cannot fit the run.
fn emit_last_literals(src: &[u8], dst: &mut [u8], anchor: usize, mut op: usize) -> Option<usize> {
    let lit_len = src.len() - anchor;
    if op >= dst.len() {
        return None;
    }
    let token_pos = op;
    op += 1;
    dst[token_pos] = (cmp::min(lit_len, 15) as u8) << 4;
    op = emit_len(dst, op, lit_len, 15)?;
    if op + lit_len > dst.len() {
        return None;
    }
    dst[op..op + lit_len].copy_from_slice(&src[anchor..]);
    Some(op + lit_len)
}

/// Variant of `emit_last_literals` that accounts for a `base` offset inside
/// `full` (i.e. `full[..base]` is dictionary history that should not appear in
/// the literal payload). Used by the dict-aware compressors so the trailing
/// literals are read from the prefix-relative range, mirroring upstream's
/// pointer arithmetic when `dictDirective != noDict`.
fn emit_last_literals_with_base(
    full: &[u8],
    dst: &mut [u8],
    base: usize,
    anchor: usize,
    mut op: usize,
) -> Option<usize> {
    if anchor < base || anchor > full.len() {
        return None;
    }
    let lit_len = full.len() - anchor;
    if op >= dst.len() {
        return None;
    }
    let token_pos = op;
    op += 1;
    dst[token_pos] = (cmp::min(lit_len, 15) as u8) << 4;
    op = emit_len(dst, op, lit_len, 15)?;
    if op + lit_len > dst.len() {
        return None;
    }
    let literal_start = anchor - base;
    dst[op..op + lit_len]
        .copy_from_slice(&full[base + literal_start..base + literal_start + lit_len]);
    Some(op + lit_len)
}

/// Emit the variable-length extension bytes for a literals or match-length
/// run, mirroring the inline encoding upstream uses inside
/// `LZ4HC_encodeSequence` and `LZ4_compress_generic_validated`: while
/// `len >= base`, write `0xFF` bytes for each 255 chunk and then the residue
/// `(len - base) % 255`. `base` is the inline-token cap (`RUN_MASK = 15`).
fn emit_len(dst: &mut [u8], mut op: usize, len: usize, base: usize) -> Option<usize> {
    if len >= base {
        let mut extra = len - base;
        while extra >= 255 {
            if op >= dst.len() {
                return None;
            }
            dst[op] = 255;
            op += 1;
            extra -= 255;
        }
        if op >= dst.len() {
            return None;
        }
        dst[op] = extra as u8;
        op += 1;
    }
    Some(op)
}

// Mirrors upstream `FASTLOOP_SAFE_DISTANCE` (lz4.c:249). The fast decode loop
// requires this much headroom in both directions so it can wild-copy 32 bytes
// past the current cursor without checking on every token.
const FASTLOOP_SAFE_DISTANCE: usize = 64;

/// Wild copy 32 bytes at a time, advancing past `dst_end`. Caller must ensure
/// the destination buffer has at least 32 bytes of room past `dst_end`, that
/// `src_ptr..` has at least `dst_end - dst_ptr` bytes, and that source and
/// destination either don't overlap or have an offset of at least 32.
///
/// Mirrors upstream `LZ4_wildCopy32` (lz4.c:518).
#[inline(always)]
unsafe fn wild_copy_32(mut dst_ptr: *mut u8, mut src_ptr: *const u8, dst_end: *mut u8) {
    loop {
        ptr::copy_nonoverlapping(src_ptr, dst_ptr, 16);
        ptr::copy_nonoverlapping(src_ptr.add(16), dst_ptr.add(16), 16);
        dst_ptr = dst_ptr.add(32);
        src_ptr = src_ptr.add(32);
        if dst_ptr >= dst_end {
            break;
        }
    }
}

/// Variable-length read for the fast loop, only ever called with `base == 15`.
/// Same semantics as `read_len(src, ip, 15)` but lifted up here so the fast
/// loop can inline aggressively.
#[inline(always)]
fn read_len_fast(src: &[u8], ip: &mut usize) -> Option<usize> {
    let mut total: usize = 15;
    loop {
        if *ip >= src.len() {
            return None;
        }
        let b = src[*ip] as usize;
        *ip += 1;
        total = total.checked_add(b)?;
        if b != 255 {
            return Some(total);
        }
    }
}

/// Decompress a single LZ4 block (no dictionary). Returns the number of bytes
/// written, or `None` on malformed input.
///
/// Mirrors the fast-path of upstream `LZ4_decompress_generic` (lz4.c:2071+,
/// the `LZ4_FAST_DEC_LOOP` variant) — wild-copies 32 bytes at a time as long
/// as both input and output have enough headroom, falling through to the
/// safe tail loop (`decompress_block_safe`) when room runs out.
#[inline]
fn decompress_block(src: &[u8], dst: &mut [u8]) -> Option<usize> {
    let oend = dst.len();
    let iend = src.len();

    // Tiny outputs skip the fast loop and go straight to the safe loop.
    if oend < FASTLOOP_SAFE_DISTANCE {
        return decompress_block_safe(src, dst, 0, 0);
    }

    let dst_ptr = dst.as_mut_ptr();
    let src_ptr = src.as_ptr();
    let mut ip = 0usize;
    let mut op = 0usize;

    // Fast loop: while we have ≥ 64 bytes of output headroom and ≥ 17 bytes of
    // input headroom, we can wild-copy 32 bytes ahead without per-token checks.
    // Mirrors upstream `LZ4_FAST_DEC_LOOP` (lz4.c:2071+).
    while op + FASTLOOP_SAFE_DISTANCE <= oend && ip + 17 <= iend {
        let token = unsafe { *src_ptr.add(ip) } as usize;
        ip += 1;
        let lit_len_token = token >> 4;

        // ----- Literals -----
        let lit_len = if lit_len_token < 15 {
            // Short literal: blind 16-byte copy. The 17-byte input headroom
            // and 64-byte output headroom guarantee in-bounds. Up to 14 junk
            // bytes past the literal end get overwritten by subsequent
            // literal/match writes.
            unsafe {
                ptr::copy_nonoverlapping(src_ptr.add(ip), dst_ptr.add(op), 16);
            }
            lit_len_token
        } else {
            // Long literal: decode extension, then either wild-copy (if there
            // is room for a 32-byte overshoot) or do a bounded copy. Either
            // way we then continue inline with this same token's match part.
            let lit_len = read_len_fast(src, &mut ip)?;
            if ip + lit_len + 32 <= iend && op + lit_len + 32 <= oend {
                unsafe {
                    wild_copy_32(dst_ptr.add(op), src_ptr.add(ip), dst_ptr.add(op + lit_len));
                }
            } else {
                if ip + lit_len > iend || op + lit_len > oend {
                    return None;
                }
                unsafe {
                    ptr::copy_nonoverlapping(src_ptr.add(ip), dst_ptr.add(op), lit_len);
                }
            }
            lit_len
        };
        ip += lit_len;
        op += lit_len;

        // End-of-block: the last sequence in a block is literals only.
        if ip == iend {
            return Some(op);
        }

        // ----- Offset -----
        if ip + 2 > iend {
            return None;
        }
        let offset =
            unsafe { (*src_ptr.add(ip) as usize) | ((*src_ptr.add(ip + 1) as usize) << 8) };
        ip += 2;
        if offset == 0 || offset > op {
            return None;
        }

        // ----- Match length -----
        let match_len = if (token & 0x0F) == 15 {
            read_len_fast(src, &mut ip)? + MINMATCH
        } else {
            (token & 0x0F) + MINMATCH
        };
        if ip == iend {
            return None;
        }

        // ----- Match copy -----
        if op + match_len + 32 > oend {
            // Match lands in the tail — use the bounded helper. After this
            // we may or may not still be in fast-loop range; the loop
            // condition decides on the next iteration.
            copy_match_no_dict(dst, &mut op, offset, match_len)?;
            continue;
        }

        unsafe {
            let match_src = dst_ptr.add(op - offset);
            if offset >= 16 {
                // Non-overlapping (or far-enough): wild-copy 32-at-a-time.
                wild_copy_32(dst_ptr.add(op), match_src, dst_ptr.add(op + match_len));
                op += match_len;
            } else if offset >= 8 && match_len <= 18 {
                // Common short match: 8 + 8 + 2 = 18 unconditional bytes.
                // Mirrors upstream's fastpath at lz4.c:2150-2152.
                ptr::copy_nonoverlapping(match_src, dst_ptr.add(op), 8);
                ptr::copy_nonoverlapping(match_src.add(8), dst_ptr.add(op + 8), 8);
                ptr::copy_nonoverlapping(match_src.add(16), dst_ptr.add(op + 16), 2);
                op += match_len;
            } else {
                // Overlapping or short-with-small-offset match — drop to the
                // tested doubling-copy helper.
                copy_match_no_dict(dst, &mut op, offset, match_len)?;
            }
        }
    }

    decompress_block_safe(src, dst, ip, op)
}

/// Safe (bounds-checking) tail of single-block decompression. Called either
/// directly for tiny outputs or as the fallback when `decompress_block` runs
/// out of fast-loop headroom. `ip`/`op` are the input/output positions where
/// the fast loop left off.
///
/// Mirrors the safe-tail of upstream `LZ4_decompress_generic` (lz4.c).
#[inline]
fn decompress_block_safe(
    src: &[u8],
    dst: &mut [u8],
    mut ip: usize,
    mut op: usize,
) -> Option<usize> {
    while ip < src.len() {
        let token = src[ip];
        ip += 1;

        let lit_len = read_len(src, &mut ip, (token >> 4) as usize)?;
        if ip + lit_len > src.len() || op + lit_len > dst.len() {
            return None;
        }
        unsafe {
            ptr::copy_nonoverlapping(src.as_ptr().add(ip), dst.as_mut_ptr().add(op), lit_len);
        }
        ip += lit_len;
        op += lit_len;
        if ip == src.len() {
            return Some(op);
        }
        if ip + 2 > src.len() {
            return None;
        }
        let offset = read_u16(&src[ip..]) as usize;
        ip += 2;
        if offset == 0 || offset > op {
            return None;
        }
        let match_len = read_len(src, &mut ip, (token & 0x0f) as usize)? + MINMATCH;
        if ip == src.len() {
            return None;
        }
        if op + match_len > dst.len() {
            return None;
        }
        copy_match_no_dict(dst, &mut op, offset, match_len)?;
    }
    Some(op)
}

/// Decompress a single LZ4 block whose match offsets may reach back into an
/// external `dict` buffer (linked blocks / external dictionary mode).
///
/// Mirrors upstream `LZ4_decompress_generic` (lz4.c) with `dict == usingExtDict`.
#[inline]
fn decompress_block_with_dict(src: &[u8], dst: &mut [u8], dict: &[u8]) -> Option<usize> {
    let mut ip = 0usize;
    let mut op = 0usize;
    while ip < src.len() {
        let token = src[ip];
        ip += 1;

        let lit_len = read_len(src, &mut ip, (token >> 4) as usize)?;
        if ip + lit_len > src.len() || op + lit_len > dst.len() {
            return None;
        }
        dst[op..op + lit_len].copy_from_slice(&src[ip..ip + lit_len]);
        ip += lit_len;
        op += lit_len;
        if ip == src.len() {
            return Some(op);
        }
        if ip + 2 > src.len() {
            return None;
        }
        let offset = read_u16(&src[ip..]) as usize;
        ip += 2;
        if offset == 0 || offset > op + dict.len() {
            return None;
        }
        let match_len = read_len(src, &mut ip, (token & 0x0f) as usize)? + MINMATCH;
        if ip == src.len() {
            return None;
        }
        if op + match_len > dst.len() {
            return None;
        }
        copy_match(dst, dict, &mut op, offset, match_len)?;
    }
    Some(op)
}

/// Partial-decompression entry point: stop after producing exactly `target`
/// bytes of output (or earlier if the block ends).
///
/// Mirrors upstream `LZ4_decompress_safe_partial` (lz4.c) with no dictionary.
fn decompress_block_partial(src: &[u8], dst: &mut [u8], target: usize) -> Option<usize> {
    decompress_block_partial_with_dict(src, dst, target, &[])
}

/// Partial-decompression with external dictionary support. Stops once `target`
/// output bytes have been written; mid-sequence literals/matches are truncated
/// rather than failing.
///
/// Mirrors upstream `LZ4_decompress_safe_partial_usingDict` (lz4.c).
fn decompress_block_partial_with_dict(
    src: &[u8],
    dst: &mut [u8],
    target: usize,
    dict: &[u8],
) -> Option<usize> {
    if target == 0 {
        return Some(0);
    }
    let target = cmp::min(target, dst.len());

    let mut ip = 0usize;
    let mut op = 0usize;
    while ip < src.len() && op < target {
        let token = src[ip];
        ip += 1;

        let lit_len = read_len(src, &mut ip, (token >> 4) as usize)?;
        let lit_copy = cmp::min(lit_len, target - op);
        if ip + lit_copy > src.len() {
            return None;
        }
        dst[op..op + lit_copy].copy_from_slice(&src[ip..ip + lit_copy]);
        op += lit_copy;
        if op == target {
            return Some(op);
        }
        if ip + lit_len > src.len() {
            return None;
        }
        ip += lit_len;
        if ip == src.len() {
            return Some(op);
        }
        if ip + 2 > src.len() {
            return None;
        }
        let offset = read_u16(&src[ip..]) as usize;
        ip += 2;
        if offset == 0 || offset > op + dict.len() {
            return None;
        }
        let match_len = read_len(src, &mut ip, (token & 0x0f) as usize)? + MINMATCH;
        let match_copy = cmp::min(match_len, target - op);
        copy_match(dst, dict, &mut op, offset, match_copy)?;
    }
    Some(op)
}

/// Decompress until exactly `dst.len()` output bytes have been produced (i.e.
/// the caller knows the exact uncompressed size up front), reading from an
/// unbounded `*const u8` input. Returns the number of input bytes consumed.
///
/// Mirrors upstream `LZ4_decompress_fast` / `LZ4_decompress_fast_usingDict`
/// (lz4.c): the "exact output size" entry points that have no input length
/// limit and rely on the output size as the loop terminator.
fn decompress_block_exact_ptr(src: *const u8, dst: &mut [u8], dict: &[u8]) -> Option<usize> {
    let mut ip = 0usize;
    let mut op = 0usize;
    while op < dst.len() {
        let token = unsafe { *src.add(ip) };
        ip += 1;

        let lit_len = read_len_ptr(src, &mut ip, (token >> 4) as usize)?;
        if op + lit_len > dst.len() {
            return None;
        }
        unsafe {
            ptr::copy_nonoverlapping(src.add(ip), dst.as_mut_ptr().add(op), lit_len);
        }
        ip += lit_len;
        op += lit_len;
        if op == dst.len() {
            return Some(ip);
        }

        let offset = read_u16_ptr(unsafe { src.add(ip) }) as usize;
        ip += 2;
        if offset == 0 || offset > op + dict.len() {
            return None;
        }
        let match_len = read_len_ptr(src, &mut ip, (token & 0x0f) as usize)? + MINMATCH;
        if op + match_len > dst.len() {
            return None;
        }
        copy_match(dst, dict, &mut op, offset, match_len)?;
    }
    Some(ip)
}

/// Variable-length integer reader for the unbounded-input decode path: no
/// length check on `src` because the caller guarantees enough room.
///
/// Mirrors upstream `read_variable_length` (lz4.c:1975) without the
/// `ilimit` check, as used by `LZ4_decompress_fast`.
fn read_len_ptr(src: *const u8, ip: &mut usize, mut len: usize) -> Option<usize> {
    if len == 15 {
        loop {
            let b = unsafe { *src.add(*ip) } as usize;
            *ip += 1;
            len = len.checked_add(b)?;
            if b != 255 {
                break;
            }
        }
    }
    Some(len)
}

/// Copy a back-reference of `len` bytes ending at `*op` from `offset` bytes
/// behind, possibly reaching back into the external `dict`. Handles the
/// overlapping match case (offset < len) by doubling the copied prefix until
/// `len` bytes are written.
///
/// Mirrors upstream's match-copy path in `LZ4_decompress_generic` (lz4.c)
/// when `usingExtDict` is set.
#[inline]
fn copy_match(
    dst: &mut [u8],
    dict: &[u8],
    op: &mut usize,
    offset: usize,
    mut len: usize,
) -> Option<()> {
    if offset == 0 {
        return None;
    }
    if offset > *op {
        let dict_offset = offset - *op;
        if dict_offset > dict.len() {
            return None;
        }
        let dict_pos = dict.len() - dict_offset;
        let dict_len = cmp::min(len, dict.len() - dict_pos);
        if *op + dict_len > dst.len() {
            return None;
        }
        unsafe {
            ptr::copy_nonoverlapping(
                dict.as_ptr().add(dict_pos),
                dst.as_mut_ptr().add(*op),
                dict_len,
            );
        }
        *op += dict_len;
        len -= dict_len;
    }

    if len == 0 {
        return Some(());
    }
    if offset > *op {
        return None;
    }
    if *op + len > dst.len() {
        return None;
    }

    let first = cmp::min(offset, len);
    let src = *op - offset;
    if src + first > *op {
        return None;
    }
    unsafe {
        ptr::copy_nonoverlapping(dst.as_ptr().add(src), dst.as_mut_ptr().add(*op), first);
    }
    *op += first;
    len -= first;

    let mut copied = first;
    while len > 0 {
        let chunk = cmp::min(copied, len);
        let src = *op - copied;
        unsafe {
            ptr::copy_nonoverlapping(dst.as_ptr().add(src), dst.as_mut_ptr().add(*op), chunk);
        }
        *op += chunk;
        len -= chunk;
        copied += chunk;
    }
    Some(())
}

/// Copy a back-reference within `dst` (no external dictionary). Handles the
/// overlapping match case by doubling the copied prefix until `len` bytes
/// are written.
///
/// Mirrors the in-block match-copy path of upstream `LZ4_decompress_generic`
/// (lz4.c) when `dict == noDict`.
#[inline]
fn copy_match_no_dict(dst: &mut [u8], op: &mut usize, offset: usize, mut len: usize) -> Option<()> {
    if offset == 0 || offset > *op || *op + len > dst.len() {
        return None;
    }

    let first = cmp::min(offset, len);
    let src = *op - offset;
    unsafe {
        ptr::copy_nonoverlapping(dst.as_ptr().add(src), dst.as_mut_ptr().add(*op), first);
    }
    *op += first;
    len -= first;

    let mut copied = first;
    while len > 0 {
        let chunk = cmp::min(copied, len);
        let src = *op - copied;
        unsafe {
            ptr::copy_nonoverlapping(dst.as_ptr().add(src), dst.as_mut_ptr().add(*op), chunk);
        }
        *op += chunk;
        len -= chunk;
        copied += chunk;
    }
    Some(())
}

/// Variable-length integer reader: if the upper-nibble `len` token was the
/// max value (15), read additional 0xFF-terminated bytes from `src[*ip..]`
/// and accumulate. Returns `None` if input is truncated or the accumulator
/// would overflow.
///
/// Mirrors upstream `read_variable_length` (lz4.c:1975).
#[inline]
fn read_len(src: &[u8], ip: &mut usize, mut len: usize) -> Option<usize> {
    if len == 15 {
        loop {
            if *ip >= src.len() {
                return None;
            }
            let b = src[*ip] as usize;
            *ip += 1;
            len = len.checked_add(b)?;
            if b != 255 {
                break;
            }
        }
    }
    Some(len)
}

/// Compute the hash table index for the bytes at `src[pos..]`. On 64-bit
/// platforms uses the 5-byte hash; on 32-bit uses the 4-byte hash. `by_u16`
/// requests the `byU16` table type (extra bit of hash, smaller table).
///
/// Mirrors upstream `LZ4_hashPosition` (lz4.c:793).
fn hash_fast(src: &[u8], pos: usize, by_u16: bool) -> usize {
    if by_u16 {
        hash4_bits(src, pos, LZ4_HASH_BITS_U16)
    } else if usize::BITS == 64 {
        let v = read_u64(&src[pos..]);
        (((v << 24).wrapping_mul(889_523_592_379)) >> (64 - LZ4_HASH_BITS)) as usize
    } else {
        hash4_bits(src, pos, LZ4_HASH_BITS)
    }
}

#[inline(always)]
fn hash_fast_const<const BY_U16: bool>(src: &[u8], pos: usize) -> usize {
    if BY_U16 {
        hash4_bits(src, pos, LZ4_HASH_BITS_U16)
    } else if usize::BITS == 64 {
        let v = read_u64(&src[pos..]);
        (((v << 24).wrapping_mul(889_523_592_379)) >> (64 - LZ4_HASH_BITS)) as usize
    } else {
        hash4_bits(src, pos, LZ4_HASH_BITS)
    }
}

/// Knuth-multiplicative hash of the 4-byte window at `src[pos..]` into a
/// `bits`-bit table index.
///
/// Mirrors upstream `LZ4_hash4` (lz4.c:773).
fn hash4_bits(src: &[u8], pos: usize, bits: usize) -> usize {
    let v = read_u32(&src[pos..]);
    ((v.wrapping_mul(2_654_435_761)) >> (32 - bits)) as usize
}

/// 4-byte hash sized for the LZ4HC match-finder table.
///
/// Mirrors upstream `LZ4HC_hashPtr` (lz4hc.c) — same `2_654_435_761`
/// multiplier as `LZ4_hash4` but shifted to `LZ4HC_HASH_BITS`.
fn hash4_hc(src: &[u8], pos: usize) -> usize {
    let v = read_u32(&src[pos..]);
    ((v.wrapping_mul(2_654_435_761)) >> (32 - LZ4HC_HASH_BITS)) as usize
}

/// 4-byte hash sized for the LZ4MID (medium-compression) hash table.
fn hash4_mid(src: &[u8], pos: usize) -> usize {
    hash4_bits(src, pos, LZ4MID_HASH_BITS)
}

/// 8-byte hash sized for the LZ4MID secondary table, using a 64-bit prime
/// multiplier on the upper bits of the window.
///
/// Mirrors upstream `LZ4MID_hash8` (lz4.c).
fn hash8_mid(src: &[u8], pos: usize) -> usize {
    let v = read_u64(&src[pos..]);
    (((v << 8).wrapping_mul(58_295_818_150_454_627)) >> (64 - LZ4MID_HASH_BITS)) as usize
}

/// Convert a caller-supplied `LZ4F_preferences_t` C struct into our internal
/// `FramePrefs`. A null pointer yields default preferences (matches upstream
/// behavior, which accepts `NULL` as "use defaults").
fn preferences_from_ptr(ptr: *const LZ4FPreferences) -> FramePrefs {
    if ptr.is_null() {
        return FramePrefs::default();
    }
    unsafe {
        let prefs = &*ptr;
        let id = match prefs.frame_info.block_size_id {
            BlockSize::Default | BlockSize::Max64KB => 4,
            BlockSize::Max256KB => 5,
            BlockSize::Max1MB => 6,
            BlockSize::Max4MB => 7,
        };
        FramePrefs {
            block_size_id: id,
            block_independent: matches!(prefs.frame_info.block_mode, BlockMode::Independent),
            block_checksum: matches!(
                prefs.frame_info.block_checksum_flag,
                BlockChecksum::BlockChecksumEnabled
            ),
            content_checksum: matches!(
                prefs.frame_info.content_checksum_flag,
                ContentChecksum::ChecksumEnabled
            ),
            content_size: prefs.frame_info.content_size,
            dict_id: prefs.frame_info.dict_id,
            compression_level: prefs.compression_level as c_int,
            auto_flush: prefs.auto_flush != 0,
            favor_dec_speed: prefs.favor_dec_speed != 0,
        }
    }
}

/// Serialize the LZ4 frame header (magic + FLG/BD + optional content size +
/// optional dictID + header checksum byte) for the given `prefs`. The output
/// is between 7 and 19 bytes.
///
/// Mirrors the header-serialization portion of upstream `LZ4F_compressBegin`
/// (lz4frame.c).
fn frame_header(prefs: FramePrefs) -> Vec<u8> {
    let mut out = Vec::with_capacity(19);
    out.extend_from_slice(&LZ4F_MAGIC);
    let mut flg = 0x40;
    if prefs.block_independent {
        flg |= 0x20;
    }
    if prefs.block_checksum {
        flg |= 0x10;
    }
    if prefs.content_size != 0 {
        flg |= 0x08;
    }
    if prefs.content_checksum {
        flg |= 0x04;
    }
    if prefs.dict_id != 0 {
        flg |= 0x01;
    }
    out.push(flg);
    out.push(prefs.block_size_id << 4);
    if prefs.content_size != 0 {
        out.extend_from_slice(&prefs.content_size.to_le_bytes());
    }
    if prefs.dict_id != 0 {
        out.extend_from_slice(&prefs.dict_id.to_le_bytes());
    }
    let hc = (xxhash32(&out[4..], 0) >> 8) as u8;
    out.push(hc);
    out
}

/// Parse an LZ4 frame header. On success returns the decoded preferences and
/// the number of header bytes consumed. Returns an `LZ4F_errorCodes` value on
/// failure (bad magic, reserved flag set, invalid block size id, bad header
/// checksum, etc.).
///
/// Mirrors upstream `LZ4F_decodeHeader` (lz4frame.c).
fn parse_frame_header(src: &[u8]) -> Result<(FramePrefs, usize), usize> {
    if src.len() < 7 || src[..4] != LZ4F_MAGIC {
        return if src.len() >= 4 && src[..4] != LZ4F_MAGIC {
            Err(ERROR_FRAME_TYPE_UNKNOWN)
        } else {
            Err(ERROR_BAD_HEADER)
        };
    }
    let flg = src[4];
    if flg & 0xC0 != 0x40 {
        return Err(ERROR_HEADER_VERSION_WRONG);
    }
    if flg & 0x02 != 0 {
        return Err(ERROR_RESERVED_FLAG_SET);
    }
    let bd = src[5];
    let block_size_id = (bd >> 4) & 0x07;
    if bd & 0x8F != 0 {
        return Err(ERROR_RESERVED_FLAG_SET);
    }
    if !(4..=7).contains(&block_size_id) {
        return Err(ERROR_MAX_BLOCK_SIZE_INVALID);
    }
    let mut pos = 6;
    let mut content_size = 0u64;
    let mut dict_id = 0u32;
    if flg & 0x08 != 0 {
        if src.len() < pos + 8 + 1 {
            return Err(ERROR_BAD_HEADER);
        }
        content_size =
            u64::from_le_bytes(src[pos..pos + 8].try_into().map_err(|_| ERROR_BAD_HEADER)?);
        pos += 8;
    }
    if flg & 0x01 != 0 {
        if src.len() < pos + 4 + 1 {
            return Err(ERROR_BAD_HEADER);
        }
        dict_id = u32::from_le_bytes(src[pos..pos + 4].try_into().map_err(|_| ERROR_BAD_HEADER)?);
        pos += 4;
    }
    if src.len() < pos + 1 {
        return Err(ERROR_BAD_HEADER);
    }
    let expected_hc = (xxhash32(&src[4..pos], 0) >> 8) as u8;
    if src[pos] != expected_hc {
        return Err(ERROR_HEADER_CHECKSUM_INVALID);
    }
    pos += 1;
    Ok((
        FramePrefs {
            block_size_id,
            block_independent: flg & 0x20 != 0,
            block_checksum: flg & 0x10 != 0,
            content_checksum: flg & 0x04 != 0,
            content_size,
            dict_id,
            compression_level: 0,
            auto_flush: false,
            favor_dec_speed: false,
        },
        pos,
    ))
}

/// Returns true if the first 4 bytes of `src` are a skippable-frame magic
/// number (`0x184D2A50` .. `0x184D2A5F`).
///
/// Mirrors the skippable-frame detection in upstream `LZ4F_decompress`
/// (lz4frame.c).
fn is_skippable_magic_prefix(src: &[u8]) -> bool {
    if src.len() < 4 {
        return false;
    }
    let magic = u32::from_le_bytes(src[..4].try_into().unwrap());
    (LZ4F_SKIPPABLE_MAGIC_MIN..=LZ4F_SKIPPABLE_MAGIC_MAX).contains(&magic)
}

/// Total byte length (header + payload) of the skippable frame that starts
/// at `src`. Returns `None` if `src` does not begin with a skippable magic
/// or is too short to read the 32-bit length field.
fn parse_skippable_frame_len(src: &[u8]) -> Option<usize> {
    if src.len() < 8 || !is_skippable_magic_prefix(src) {
        return None;
    }
    let content_len = u32::from_le_bytes(src[4..8].try_into().ok()?) as usize;
    content_len.checked_add(8)
}

/// Try to consume a frame (or skippable) header from `ctx.input`. Returns
/// `Ok(true)` if a header was parsed (and `ctx.parsed_header` updated) or
/// the frame was a complete skippable, `Ok(false)` if more input is needed,
/// and an error code on malformed input.
///
/// Mirrors the header-parsing stage of upstream `LZ4F_decompress`
/// (lz4frame.c, `dstage_getFrameHeader` / `dstage_storeFrameHeader`).
fn parse_frame_header_if_available(ctx: &mut DecompressionCtx) -> Result<bool, usize> {
    if ctx.done || ctx.parsed_header {
        return Ok(true);
    }
    if ctx.input.len().saturating_sub(ctx.pos) >= 4
        && is_skippable_magic_prefix(&ctx.input[ctx.pos..])
    {
        if ctx.input.len().saturating_sub(ctx.pos) < 8 {
            return Ok(false);
        }
        let Some(skip_len) = parse_skippable_frame_len(&ctx.input[ctx.pos..]) else {
            return Err(ERROR_BAD_HEADER);
        };
        if ctx.input.len().saturating_sub(ctx.pos) < skip_len {
            compact_input(ctx);
            return Ok(false);
        }
        ctx.pos += skip_len;
        ctx.done = true;
        compact_input(ctx);
        return Ok(true);
    }
    if ctx.input.len().saturating_sub(ctx.pos) < 7 {
        return Ok(false);
    }
    if let Some(header_len) = expected_frame_header_len(&ctx.input[ctx.pos..]) {
        if ctx.input.len().saturating_sub(ctx.pos) < header_len {
            return Ok(false);
        }
    }
    let (prefs, header_len) = parse_frame_header(&ctx.input[ctx.pos..])?;
    ctx.pos += header_len;
    apply_frame_prefs(ctx, prefs);
    Ok(true)
}

/// Copy parsed frame preferences into the decompression context and reset
/// per-frame state (content checksum running total, block dictionary if no
/// external dictionary was set, etc.).
fn apply_frame_prefs(ctx: &mut DecompressionCtx, prefs: FramePrefs) {
    ctx.parsed_header = true;
    ctx.block_checksum = prefs.block_checksum;
    ctx.content_checksum = prefs.content_checksum;
    ctx.content_size = prefs.content_size;
    ctx.content_read = 0;
    ctx.dict_id = prefs.dict_id;
    ctx.block_independent = prefs.block_independent;
    ctx.block_max = block_max_size(prefs.block_size_id);
    if !ctx.external_dictionary {
        ctx.dictionary.clear();
    }
    ctx.external_dictionary = false;
    ctx.raw_block_remaining = 0;
    ctx.raw_block_checksum = XxHash32::new(0);
}

fn start_raw_block(ctx: &mut DecompressionCtx, block_len: usize) {
    ctx.raw_block_remaining = block_len;
    ctx.raw_block_checksum = XxHash32::new(0);
}

macro_rules! dispatch_frame_block_flags {
    ($ctx:expr, $skip_checksums:expr, $func:ident($($arg:expr),* $(,)?)) => {
        match (
            $ctx.block_checksum,
            $ctx.content_checksum,
            $ctx.block_independent,
            $skip_checksums,
        ) {
            (false, false, false, false) => $func::<false, false, false, false>($($arg),*),
            (false, false, false, true) => $func::<false, false, false, true>($($arg),*),
            (false, false, true, false) => $func::<false, false, true, false>($($arg),*),
            (false, false, true, true) => $func::<false, false, true, true>($($arg),*),
            (false, true, false, false) => $func::<false, true, false, false>($($arg),*),
            (false, true, false, true) => $func::<false, true, false, true>($($arg),*),
            (false, true, true, false) => $func::<false, true, true, false>($($arg),*),
            (false, true, true, true) => $func::<false, true, true, true>($($arg),*),
            (true, false, false, false) => $func::<true, false, false, false>($($arg),*),
            (true, false, false, true) => $func::<true, false, false, true>($($arg),*),
            (true, false, true, false) => $func::<true, false, true, false>($($arg),*),
            (true, false, true, true) => $func::<true, false, true, true>($($arg),*),
            (true, true, false, false) => $func::<true, true, false, false>($($arg),*),
            (true, true, false, true) => $func::<true, true, false, true>($($arg),*),
            (true, true, true, false) => $func::<true, true, true, false>($($arg),*),
            (true, true, true, true) => $func::<true, true, true, true>($($arg),*),
        }
    };
}

fn update_raw_block_output<
    const BLOCK_CHECKSUM: bool,
    const CONTENT_CHECKSUM: bool,
    const BLOCK_INDEPENDENT: bool,
    const SKIP_CHECKSUMS: bool,
>(
    ctx: &mut DecompressionCtx,
    bytes: &[u8],
) {
    if BLOCK_CHECKSUM && !SKIP_CHECKSUMS {
        ctx.raw_block_checksum.update(bytes);
    }
    if CONTENT_CHECKSUM {
        ctx.content_hasher.update(bytes);
    }
    ctx.content_read += bytes.len() as u64;
    if BLOCK_INDEPENDENT {
        ctx.dictionary.clear();
    } else {
        append_hc_dictionary(&mut ctx.dictionary, bytes);
    }
}

fn validate_content_size_after_block(ctx: &DecompressionCtx) -> Result<(), usize> {
    if ctx.content_size != 0 && ctx.content_read > ctx.content_size {
        Err(ERROR_FRAME_SIZE_WRONG)
    } else {
        Ok(())
    }
}

fn consume_frame_end_from_slice<
    const BLOCK_CHECKSUM: bool,
    const CONTENT_CHECKSUM: bool,
    const BLOCK_INDEPENDENT: bool,
    const SKIP_CHECKSUMS: bool,
>(
    ctx: &mut DecompressionCtx,
    src: &[u8],
    consumed: &mut usize,
) -> Option<Result<(), usize>> {
    if src.len().saturating_sub(*consumed) < 4 {
        return None;
    }
    let end_mark = u32::from_le_bytes(src[*consumed..*consumed + 4].try_into().unwrap());
    if end_mark != 0 {
        return Some(Ok(()));
    }
    let trailer = if CONTENT_CHECKSUM { 4 } else { 0 };
    if src.len().saturating_sub(*consumed) < 4 + trailer {
        return None;
    }
    *consumed += 4;
    if CONTENT_CHECKSUM {
        let stored = u32::from_le_bytes(src[*consumed..*consumed + 4].try_into().unwrap());
        *consumed += 4;
        if !SKIP_CHECKSUMS && stored != ctx.content_hasher.digest() {
            return Some(Err(ERROR_CHECKSUM_INVALID));
        }
    }
    if ctx.content_size != 0 && ctx.content_read != ctx.content_size {
        return Some(Err(ERROR_FRAME_SIZE_WRONG));
    }
    ctx.done = true;
    Some(Ok(()))
}

fn consume_frame_end_from_input<
    const BLOCK_CHECKSUM: bool,
    const CONTENT_CHECKSUM: bool,
    const BLOCK_INDEPENDENT: bool,
    const SKIP_CHECKSUMS: bool,
>(
    ctx: &mut DecompressionCtx,
) -> Option<Result<(), usize>> {
    if ctx.input.len().saturating_sub(ctx.pos) < 4 {
        return None;
    }
    let end_mark = u32::from_le_bytes(ctx.input[ctx.pos..ctx.pos + 4].try_into().unwrap());
    if end_mark != 0 {
        return Some(Ok(()));
    }
    let trailer = if CONTENT_CHECKSUM { 4 } else { 0 };
    if ctx.input.len().saturating_sub(ctx.pos) < 4 + trailer {
        return None;
    }
    ctx.pos += 4;
    if CONTENT_CHECKSUM {
        let stored = u32::from_le_bytes(ctx.input[ctx.pos..ctx.pos + 4].try_into().unwrap());
        ctx.pos += 4;
        if !SKIP_CHECKSUMS && stored != ctx.content_hasher.digest() {
            return Some(Err(ERROR_CHECKSUM_INVALID));
        }
    }
    if ctx.content_size != 0 && ctx.content_read != ctx.content_size {
        return Some(Err(ERROR_FRAME_SIZE_WRONG));
    }
    ctx.done = true;
    Some(Ok(()))
}

fn finish_raw_block_checksum_from_slice<
    const BLOCK_CHECKSUM: bool,
    const CONTENT_CHECKSUM: bool,
    const BLOCK_INDEPENDENT: bool,
    const SKIP_CHECKSUMS: bool,
>(
    ctx: &mut DecompressionCtx,
    src: &[u8],
    consumed: &mut usize,
) -> Option<Result<(), usize>> {
    if ctx.raw_block_remaining != 0 || !BLOCK_CHECKSUM {
        return Some(Ok(()));
    }
    if src.len().saturating_sub(*consumed) < 4 {
        return None;
    }
    let stored = u32::from_le_bytes(src[*consumed..*consumed + 4].try_into().unwrap());
    *consumed += 4;
    if !SKIP_CHECKSUMS && stored != ctx.raw_block_checksum.digest() {
        return Some(Err(ERROR_BLOCK_CHECKSUM_INVALID));
    }
    Some(Ok(()))
}

fn finish_raw_block_checksum_from_input<
    const BLOCK_CHECKSUM: bool,
    const CONTENT_CHECKSUM: bool,
    const BLOCK_INDEPENDENT: bool,
    const SKIP_CHECKSUMS: bool,
>(
    ctx: &mut DecompressionCtx,
) -> Option<Result<(), usize>> {
    if ctx.raw_block_remaining != 0 || !BLOCK_CHECKSUM {
        return Some(Ok(()));
    }
    if ctx.input.len().saturating_sub(ctx.pos) < 4 {
        compact_input(ctx);
        return None;
    }
    let stored = u32::from_le_bytes(ctx.input[ctx.pos..ctx.pos + 4].try_into().unwrap());
    ctx.pos += 4;
    if !SKIP_CHECKSUMS && stored != ctx.raw_block_checksum.digest() {
        return Some(Err(ERROR_BLOCK_CHECKSUM_INVALID));
    }
    Some(Ok(()))
}

fn try_copy_raw_block_slice_to_dst(
    ctx: &mut DecompressionCtx,
    src: &[u8],
    dst: &mut [u8],
    skip_checksums: bool,
) -> Option<Result<(usize, usize), usize>> {
    dispatch_frame_block_flags!(
        ctx,
        skip_checksums,
        try_copy_raw_block_slice_to_dst_spec(ctx, src, dst)
    )
}

fn try_copy_raw_block_slice_to_dst_spec<
    const BLOCK_CHECKSUM: bool,
    const CONTENT_CHECKSUM: bool,
    const BLOCK_INDEPENDENT: bool,
    const SKIP_CHECKSUMS: bool,
>(
    ctx: &mut DecompressionCtx,
    src: &[u8],
    dst: &mut [u8],
) -> Option<Result<(usize, usize), usize>> {
    if ctx.raw_block_remaining == 0 {
        return None;
    }
    let to_copy = cmp::min(ctx.raw_block_remaining, cmp::min(src.len(), dst.len()));
    if to_copy > 0 {
        unsafe {
            ptr::copy_nonoverlapping(src.as_ptr(), dst.as_mut_ptr(), to_copy);
        }
        update_raw_block_output::<
            BLOCK_CHECKSUM,
            CONTENT_CHECKSUM,
            BLOCK_INDEPENDENT,
            SKIP_CHECKSUMS,
        >(ctx, &dst[..to_copy]);
        ctx.raw_block_remaining -= to_copy;
    }
    let mut consumed = to_copy;
    if ctx.raw_block_remaining == 0 {
        match finish_raw_block_checksum_from_slice::<
            BLOCK_CHECKSUM,
            CONTENT_CHECKSUM,
            BLOCK_INDEPENDENT,
            SKIP_CHECKSUMS,
        >(ctx, src, &mut consumed)
        {
            Some(Ok(())) => {}
            Some(Err(code)) => return Some(Err(code)),
            None => {}
        }
        if let Err(code) = validate_content_size_after_block(ctx) {
            return Some(Err(code));
        }
        match consume_frame_end_from_slice::<
            BLOCK_CHECKSUM,
            CONTENT_CHECKSUM,
            BLOCK_INDEPENDENT,
            SKIP_CHECKSUMS,
        >(ctx, src, &mut consumed)
        {
            Some(Ok(())) | None => {}
            Some(Err(code)) => return Some(Err(code)),
        }
    }
    Some(Ok((consumed, to_copy)))
}

fn copy_raw_block_from_input_to_dst(
    ctx: &mut DecompressionCtx,
    dst: &mut [u8],
    skip_checksums: bool,
) -> Option<Result<usize, usize>> {
    dispatch_frame_block_flags!(
        ctx,
        skip_checksums,
        copy_raw_block_from_input_to_dst_spec(ctx, dst)
    )
}

fn copy_raw_block_from_input_to_dst_spec<
    const BLOCK_CHECKSUM: bool,
    const CONTENT_CHECKSUM: bool,
    const BLOCK_INDEPENDENT: bool,
    const SKIP_CHECKSUMS: bool,
>(
    ctx: &mut DecompressionCtx,
    dst: &mut [u8],
) -> Option<Result<usize, usize>> {
    if ctx.raw_block_remaining == 0 {
        return None;
    }
    let available = ctx.input.len().saturating_sub(ctx.pos);
    let to_copy = cmp::min(ctx.raw_block_remaining, cmp::min(available, dst.len()));
    if to_copy > 0 {
        unsafe {
            ptr::copy_nonoverlapping(ctx.input.as_ptr().add(ctx.pos), dst.as_mut_ptr(), to_copy);
        }
        ctx.pos += to_copy;
        update_raw_block_output::<
            BLOCK_CHECKSUM,
            CONTENT_CHECKSUM,
            BLOCK_INDEPENDENT,
            SKIP_CHECKSUMS,
        >(ctx, &dst[..to_copy]);
        ctx.raw_block_remaining -= to_copy;
    }
    if ctx.raw_block_remaining == 0 {
        match finish_raw_block_checksum_from_input::<
            BLOCK_CHECKSUM,
            CONTENT_CHECKSUM,
            BLOCK_INDEPENDENT,
            SKIP_CHECKSUMS,
        >(ctx)
        {
            Some(Ok(())) => {}
            Some(Err(code)) => return Some(Err(code)),
            None => {}
        }
        if let Err(code) = validate_content_size_after_block(ctx) {
            return Some(Err(code));
        }
        match consume_frame_end_from_input::<
            BLOCK_CHECKSUM,
            CONTENT_CHECKSUM,
            BLOCK_INDEPENDENT,
            SKIP_CHECKSUMS,
        >(ctx)
        {
            Some(Ok(())) | None => {}
            Some(Err(code)) => return Some(Err(code)),
        }
    }
    compact_input(ctx);
    Some(Ok(to_copy))
}

/// Reconstruct an `LZ4F_frameInfo_t` C struct from the current decompression
/// context state, for callers of `LZ4F_getFrameInfo`.
///
/// Mirrors upstream `LZ4F_getFrameInfo` (lz4frame.c).
fn frame_info_from_decompression_ctx(ctx: &DecompressionCtx) -> LZ4FFrameInfo {
    LZ4FFrameInfo {
        block_size_id: match ctx.block_max {
            n if n == 256 * 1024 => BlockSize::Max256KB,
            n if n == 1024 * 1024 => BlockSize::Max1MB,
            n if n == 4 * 1024 * 1024 => BlockSize::Max4MB,
            _ => BlockSize::Max64KB,
        },
        block_mode: if ctx.block_independent {
            BlockMode::Independent
        } else {
            BlockMode::Linked
        },
        content_checksum_flag: if ctx.content_checksum {
            ContentChecksum::ChecksumEnabled
        } else {
            ContentChecksum::NoChecksum
        },
        frame_type: FrameType::Frame,
        content_size: ctx.content_size,
        dict_id: ctx.dict_id,
        block_checksum_flag: if ctx.block_checksum {
            BlockChecksum::BlockChecksumEnabled
        } else {
            BlockChecksum::NoBlockChecksum
        },
    }
}

/// Decode the next frame block from `ctx.input` directly into `dst`,
/// avoiding the staging `ctx.pending` buffer. Returns:
/// - `None` when more input is needed, when `dst` is too small to receive a
///   worst-case block, or when there is pending output not yet consumed.
/// - `Some(Ok(written))` on a successful block decode (or end-of-frame, with
///   `written = 0`).
/// - `Some(Err(code))` on malformed input.
///
/// Mirrors the in-place fast path of upstream `LZ4F_decompress` (lz4frame.c).
fn try_decompress_frame_block_to_dst(
    ctx: &mut DecompressionCtx,
    dst: &mut [u8],
    skip_checksums: bool,
) -> Option<Result<usize, usize>> {
    dispatch_frame_block_flags!(
        ctx,
        skip_checksums,
        try_decompress_frame_block_to_dst_spec(ctx, dst)
    )
}

fn try_decompress_frame_block_to_dst_spec<
    const BLOCK_CHECKSUM: bool,
    const CONTENT_CHECKSUM: bool,
    const BLOCK_INDEPENDENT: bool,
    const SKIP_CHECKSUMS: bool,
>(
    ctx: &mut DecompressionCtx,
    dst: &mut [u8],
) -> Option<Result<usize, usize>> {
    if ctx.done || !ctx.parsed_header || !pending_is_empty(ctx) {
        return None;
    }
    if ctx.input.len().saturating_sub(ctx.pos) < 4 {
        compact_input(ctx);
        return None;
    }
    let block_header = u32::from_le_bytes(ctx.input[ctx.pos..ctx.pos + 4].try_into().unwrap());
    let raw = block_header & 0x8000_0000 != 0;
    let block_len = (block_header & 0x7FFF_FFFF) as usize;
    if block_len == 0 {
        return None;
    }
    if block_len > ctx.block_max {
        return Some(Err(ERROR_MAX_BLOCK_SIZE_INVALID));
    }
    let checksum_len = if BLOCK_CHECKSUM { 4 } else { 0 };
    if raw {
        ctx.pos += 4;
        start_raw_block(ctx, block_len);
        return copy_raw_block_from_input_to_dst_spec::<
            BLOCK_CHECKSUM,
            CONTENT_CHECKSUM,
            BLOCK_INDEPENDENT,
            SKIP_CHECKSUMS,
        >(ctx, dst);
    }
    if ctx.input.len().saturating_sub(ctx.pos) < 4 + block_len + checksum_len {
        compact_input(ctx);
        return None;
    }
    if dst.len() < ctx.block_max {
        return None;
    }

    ctx.pos += 4;
    let block_start = ctx.pos;
    let block_end = block_start + block_len;
    if BLOCK_CHECKSUM && !SKIP_CHECKSUMS {
        let stored = u32::from_le_bytes(
            ctx.input[block_end..block_end + checksum_len]
                .try_into()
                .unwrap(),
        );
        if stored != xxhash32(&ctx.input[block_start..block_end], 0) {
            return Some(Err(ERROR_BLOCK_CHECKSUM_INVALID));
        }
    }

    let n = if BLOCK_INDEPENDENT && ctx.dictionary.is_empty() {
        decompress_block(&ctx.input[block_start..block_end], dst)
    } else {
        decompress_block_with_dict(&ctx.input[block_start..block_end], dst, &ctx.dictionary)
    };
    let written = match n {
        Some(n) => n,
        None => return Some(Err(ERROR_DECOMPRESSION_FAILED)),
    };

    if CONTENT_CHECKSUM {
        ctx.content_hasher.update(&dst[..written]);
    }
    ctx.content_read += written as u64;
    if BLOCK_INDEPENDENT {
        ctx.dictionary.clear();
    } else {
        append_hc_dictionary(&mut ctx.dictionary, &dst[..written]);
    }
    ctx.pos = block_end + checksum_len;
    if ctx.content_size != 0 && ctx.content_read > ctx.content_size {
        return Some(Err(ERROR_FRAME_SIZE_WRONG));
    }
    if ctx.content_size != 0 {
        let trailer = if CONTENT_CHECKSUM { 4 } else { 0 };
        if ctx.input.len().saturating_sub(ctx.pos) >= 4 {
            let end_mark = u32::from_le_bytes(ctx.input[ctx.pos..ctx.pos + 4].try_into().unwrap());
            if end_mark != 0 {
                if ctx.content_read >= ctx.content_size {
                    return Some(Err(ERROR_FRAME_SIZE_WRONG));
                }
            } else if ctx.content_read != ctx.content_size {
                return Some(Err(ERROR_FRAME_SIZE_WRONG));
            } else if ctx.input.len().saturating_sub(ctx.pos) >= 4 + trailer {
                ctx.pos += 4;
                if CONTENT_CHECKSUM {
                    let stored =
                        u32::from_le_bytes(ctx.input[ctx.pos..ctx.pos + 4].try_into().unwrap());
                    if !SKIP_CHECKSUMS && stored != ctx.content_hasher.digest() {
                        return Some(Err(ERROR_CHECKSUM_INVALID));
                    }
                    ctx.pos += 4;
                }
                ctx.done = true;
            }
        }
    }
    compact_input(ctx);
    Some(Ok(written))
}

/// Variant of `try_decompress_frame_block_to_dst` that reads a single block
/// from the caller-provided `src` slice (rather than from `ctx.input`),
/// returning `(input_consumed, output_written)` on success. Used when the
/// caller wants to drive decompression block-at-a-time without accumulating
/// input inside the context.
///
/// Mirrors the in-place block-decompression path of upstream `LZ4F_decompress`
/// (lz4frame.c).
fn try_decompress_frame_block_slice_to_dst(
    ctx: &mut DecompressionCtx,
    src: &[u8],
    dst: &mut [u8],
    skip_checksums: bool,
) -> Option<Result<(usize, usize), usize>> {
    dispatch_frame_block_flags!(
        ctx,
        skip_checksums,
        try_decompress_frame_block_slice_to_dst_spec(ctx, src, dst)
    )
}

fn try_decompress_frame_block_slice_to_dst_spec<
    const BLOCK_CHECKSUM: bool,
    const CONTENT_CHECKSUM: bool,
    const BLOCK_INDEPENDENT: bool,
    const SKIP_CHECKSUMS: bool,
>(
    ctx: &mut DecompressionCtx,
    src: &[u8],
    dst: &mut [u8],
) -> Option<Result<(usize, usize), usize>> {
    if src.len() < 4 {
        return None;
    }
    let block_header = u32::from_le_bytes(src[..4].try_into().unwrap());
    let raw = block_header & 0x8000_0000 != 0;
    let block_len = (block_header & 0x7FFF_FFFF) as usize;
    if block_len == 0 {
        let trailer = if CONTENT_CHECKSUM { 4 } else { 0 };
        if src.len() < 4 + trailer {
            return None;
        }
        if CONTENT_CHECKSUM && !SKIP_CHECKSUMS {
            let stored = u32::from_le_bytes(src[4..8].try_into().unwrap());
            if stored != ctx.content_hasher.digest() {
                return Some(Err(ERROR_CHECKSUM_INVALID));
            }
        }
        if ctx.content_size != 0 && ctx.content_read != ctx.content_size {
            return Some(Err(ERROR_FRAME_SIZE_WRONG));
        }
        ctx.done = true;
        return Some(Ok((4 + trailer, 0)));
    }
    if block_len > ctx.block_max {
        return Some(Err(ERROR_MAX_BLOCK_SIZE_INVALID));
    }

    let checksum_len = if BLOCK_CHECKSUM { 4 } else { 0 };
    if raw {
        start_raw_block(ctx, block_len);
        return try_copy_raw_block_slice_to_dst_spec::<
            BLOCK_CHECKSUM,
            CONTENT_CHECKSUM,
            BLOCK_INDEPENDENT,
            SKIP_CHECKSUMS,
        >(ctx, &src[4..], dst)
        .map(|result| result.map(|(consumed, written)| (consumed + 4, written)));
    }
    if src.len() < 4 + block_len + checksum_len {
        return None;
    }
    if dst.len() < ctx.block_max {
        return None;
    }

    let block_start = 4;
    let block_end = block_start + block_len;
    if BLOCK_CHECKSUM && !SKIP_CHECKSUMS {
        let stored =
            u32::from_le_bytes(src[block_end..block_end + checksum_len].try_into().unwrap());
        if stored != xxhash32(&src[block_start..block_end], 0) {
            return Some(Err(ERROR_BLOCK_CHECKSUM_INVALID));
        }
    }

    let n = if BLOCK_INDEPENDENT && ctx.dictionary.is_empty() {
        decompress_block(&src[block_start..block_end], dst)
    } else {
        decompress_block_with_dict(&src[block_start..block_end], dst, &ctx.dictionary)
    };
    let written = match n {
        Some(n) => n,
        None => return Some(Err(ERROR_DECOMPRESSION_FAILED)),
    };

    if CONTENT_CHECKSUM {
        ctx.content_hasher.update(&dst[..written]);
    }
    ctx.content_read += written as u64;
    if BLOCK_INDEPENDENT {
        ctx.dictionary.clear();
    } else {
        append_hc_dictionary(&mut ctx.dictionary, &dst[..written]);
    }
    if ctx.content_size != 0 && ctx.content_read > ctx.content_size {
        return Some(Err(ERROR_FRAME_SIZE_WRONG));
    }
    Some(Ok((4 + block_len + checksum_len, written)))
}

/// Drain as much of `ctx.input` as possible into `ctx.pending`, parsing the
/// frame header if not yet done and then decoding whole blocks until either
/// input runs out, output is produced (and must be consumed by the caller
/// before more is generated), or the end-of-frame marker is reached.
///
/// Mirrors the staged decompression loop of upstream `LZ4F_decompress`
/// (lz4frame.c).
fn parse_available_frame(ctx: &mut DecompressionCtx, skip_checksums: bool) -> Result<(), usize> {
    dispatch_frame_block_flags!(ctx, skip_checksums, parse_available_frame_spec(ctx))
}

fn parse_available_frame_spec<
    const BLOCK_CHECKSUM: bool,
    const CONTENT_CHECKSUM: bool,
    const BLOCK_INDEPENDENT: bool,
    const SKIP_CHECKSUMS: bool,
>(
    ctx: &mut DecompressionCtx,
) -> Result<(), usize> {
    if ctx.done {
        return Ok(());
    }
    if !parse_frame_header_if_available(ctx)? || ctx.done {
        return Ok(());
    }

    loop {
        if ctx.input.len().saturating_sub(ctx.pos) < 4 {
            compact_input(ctx);
            return Ok(());
        }
        let block_header = u32::from_le_bytes(ctx.input[ctx.pos..ctx.pos + 4].try_into().unwrap());
        let raw = block_header & 0x8000_0000 != 0;
        let block_len = (block_header & 0x7FFF_FFFF) as usize;
        if block_len == 0 {
            let trailer = if CONTENT_CHECKSUM { 4 } else { 0 };
            if ctx.input.len().saturating_sub(ctx.pos) < 4 + trailer {
                compact_input(ctx);
                return Ok(());
            }
            ctx.pos += 4;
            if CONTENT_CHECKSUM {
                let stored =
                    u32::from_le_bytes(ctx.input[ctx.pos..ctx.pos + 4].try_into().unwrap());
                if !SKIP_CHECKSUMS && stored != ctx.content_hasher.digest() {
                    return Err(ERROR_CHECKSUM_INVALID);
                }
                ctx.pos += 4;
            }
            if ctx.content_size != 0 && ctx.content_read != ctx.content_size {
                return Err(ERROR_FRAME_SIZE_WRONG);
            }
            ctx.done = true;
            compact_input(ctx);
            return Ok(());
        }
        if block_len > ctx.block_max {
            return Err(ERROR_MAX_BLOCK_SIZE_INVALID);
        }
        let checksum_len = if BLOCK_CHECKSUM { 4 } else { 0 };
        ctx.pos += 4;
        let block_start = ctx.pos;
        if raw {
            start_raw_block(ctx, block_len);
            compact_input(ctx);
            return Ok(());
        }
        if ctx.input.len().saturating_sub(ctx.pos - 4) < 4 + block_len + checksum_len {
            ctx.pos -= 4;
            compact_input(ctx);
            return Ok(());
        }
        let block_end = block_start + block_len;
        if BLOCK_CHECKSUM && !SKIP_CHECKSUMS {
            let stored = u32::from_le_bytes(
                ctx.input[block_end..block_end + checksum_len]
                    .try_into()
                    .unwrap(),
            );
            if stored != xxhash32(&ctx.input[block_start..block_end], 0) {
                return Err(ERROR_BLOCK_CHECKSUM_INVALID);
            }
        }
        let mut out = vec![0u8; ctx.block_max];
        let n = if BLOCK_INDEPENDENT && ctx.dictionary.is_empty() {
            decompress_block(&ctx.input[block_start..block_end], &mut out)
        } else {
            decompress_block_with_dict(
                &ctx.input[block_start..block_end],
                &mut out,
                &ctx.dictionary,
            )
        }
        .ok_or(ERROR_DECOMPRESSION_FAILED)?;
        if CONTENT_CHECKSUM {
            ctx.content_hasher.update(&out[..n]);
        }
        ctx.content_read += n as u64;
        ctx.pending.extend_from_slice(&out[..n]);
        if BLOCK_INDEPENDENT {
            ctx.dictionary.clear();
        } else {
            append_hc_dictionary(&mut ctx.dictionary, &out[..n]);
        }
        ctx.pos = block_end + checksum_len;
        if ctx.content_size != 0 && ctx.content_read > ctx.content_size {
            return Err(ERROR_FRAME_SIZE_WRONG);
        }
        if !pending_is_empty(ctx) {
            compact_input(ctx);
            return Ok(());
        }
    }
}

/// Number of decoded bytes still queued in `ctx.pending` waiting to be
/// handed back to the caller.
fn pending_len(ctx: &DecompressionCtx) -> usize {
    ctx.pending.len().saturating_sub(ctx.pending_pos)
}

/// True if there is no decoded output queued in `ctx.pending`.
fn pending_is_empty(ctx: &DecompressionCtx) -> bool {
    pending_len(ctx) == 0
}

/// Drop the already-consumed prefix of `ctx.input`, shifting any remaining
/// buffered bytes to the front so the buffer doesn't grow unboundedly across
/// streaming calls.
fn compact_input(ctx: &mut DecompressionCtx) {
    if ctx.pos > 0 {
        if ctx.pos >= ctx.input.len() {
            ctx.input.clear();
        } else {
            ctx.input.drain(..ctx.pos);
        }
        ctx.pos = 0;
    }
}

/// Compute how many bytes of the current `LZ4F_decompress` call's input
/// have been consumed: all of it while still mid-frame, but only up to the
/// frame-end marker when `done` is set so callers can detect trailing data.
fn consumed_from_call(done: bool, src_size: usize, remaining_input_len: usize) -> usize {
    if !done {
        return src_size;
    }
    let remaining_from_call = cmp::min(remaining_input_len, src_size);
    src_size.saturating_sub(remaining_from_call)
}

/// Given the first few bytes of a frame, compute the full header length
/// (7 base bytes plus 8 if content-size is present plus 4 if dictID is
/// present). Returns `None` if the magic doesn't match or the FLG byte is
/// not yet available.
fn expected_frame_header_len(src: &[u8]) -> Option<usize> {
    if src.len() < 5 || src[..4] != LZ4F_MAGIC {
        return None;
    }
    let flg = src[4];
    let mut len = 7;
    if flg & 0x08 != 0 {
        len += 8;
    }
    if flg & 0x01 != 0 {
        len += 4;
    }
    Some(len)
}

/// The "size hint" returned by `LZ4F_decompress`: a lower bound on how much
/// more input the decoder needs to make progress (parse the rest of the
/// header, finish the current block, or read the next block header).
///
/// Mirrors the `nextSrcSizeHint` return value of upstream `LZ4F_decompress`
/// (lz4frame.c).
fn frame_hint(ctx: &DecompressionCtx) -> usize {
    if !ctx.parsed_header {
        let available = ctx.input.len().saturating_sub(ctx.pos);
        let expected = if available >= 5 {
            expected_frame_header_len(&ctx.input[ctx.pos..]).unwrap_or(7)
        } else {
            7
        };
        expected.saturating_sub(available)
    } else if ctx.raw_block_remaining > 0 {
        ctx.raw_block_remaining + if ctx.block_checksum { 4 } else { 0 } + 4
    } else if pending_is_empty(ctx) {
        let available = ctx.input.len().saturating_sub(ctx.pos);
        if available < 4 {
            return 4 - available;
        }
        let block_header = u32::from_le_bytes(ctx.input[ctx.pos..ctx.pos + 4].try_into().unwrap());
        let block_len = (block_header & 0x7FFF_FFFF) as usize;
        let needed = if block_len == 0 {
            4 + if ctx.content_checksum { 4 } else { 0 }
        } else {
            4 + block_len + if ctx.block_checksum { 4 } else { 0 }
        };
        cmp::max(needed.saturating_sub(available), 1)
    } else {
        1
    }
}

fn decompression_free_status(ctx: &DecompressionCtx) -> usize {
    if ctx.done || (!ctx.parsed_header && ctx.input.is_empty() && pending_is_empty(ctx)) {
        return 0;
    }
    if !ctx.parsed_header {
        return if ctx.input.is_empty() { 0 } else { 1 };
    }
    if !pending_is_empty(ctx) {
        return 9;
    }
    if ctx.raw_block_remaining > 0 {
        return 5;
    }
    3
}

/// Map the 4..=7 BD-byte block-size id to its `BlockSize` enum variant.
/// Unknown ids fall back to `Max64KB` to match upstream's permissive default.
fn block_size_enum(id: u8) -> BlockSize {
    match id {
        5 => BlockSize::Max256KB,
        6 => BlockSize::Max1MB,
        7 => BlockSize::Max4MB,
        _ => BlockSize::Max64KB,
    }
}

/// Maximum uncompressed block size in bytes for a given BD-byte block-size
/// id (4 → 64 KiB, 5 → 256 KiB, 6 → 1 MiB, 7 → 4 MiB).
fn block_max_size(id: u8) -> usize {
    match id {
        5 => 256 * 1024,
        6 => 1024 * 1024,
        7 => 4 * 1024 * 1024,
        _ => 64 * 1024,
    }
}

/// One-shot XXH32 hash of `input` with the given seed. Used for the frame
/// header checksum byte, the per-block checksum, and the content checksum.
///
/// Mirrors upstream `XXH32` (xxhash.c).
fn xxhash32(input: &[u8], seed: u32) -> u32 {
    let mut h = XxHash32::new(seed);
    h.update(input);
    h.digest()
}

#[derive(Clone, Copy, Debug)]
struct XxHash32 {
    total: usize,
    seed: u32,
    v1: u32,
    v2: u32,
    v3: u32,
    v4: u32,
    mem: [u8; 16],
    mem_len: usize,
}

impl XxHash32 {
    fn new(seed: u32) -> Self {
        Self {
            total: 0,
            seed,
            v1: seed.wrapping_add(0x9E37_79B1).wrapping_add(0x85EB_CA77),
            v2: seed.wrapping_add(0x85EB_CA77),
            v3: seed,
            v4: seed.wrapping_sub(0x9E37_79B1),
            mem: [0; 16],
            mem_len: 0,
        }
    }

    fn update(&mut self, mut input: &[u8]) {
        self.total += input.len();
        if self.mem_len + input.len() < 16 {
            self.mem[self.mem_len..self.mem_len + input.len()].copy_from_slice(input);
            self.mem_len += input.len();
            return;
        }
        if self.mem_len > 0 {
            let fill = 16 - self.mem_len;
            self.mem[self.mem_len..16].copy_from_slice(&input[..fill]);
            let block = self.mem;
            self.process(&block);
            input = &input[fill..];
            self.mem_len = 0;
        }
        let mut v1 = self.v1;
        let mut v2 = self.v2;
        let mut v3 = self.v3;
        let mut v4 = self.v4;
        let mut p = input.as_ptr();
        let end = unsafe { p.add(input.len() & !15) };
        while p < end {
            v1 = round(v1, read_u32_ptr(p));
            v2 = round(v2, read_u32_ptr(unsafe { p.add(4) }));
            v3 = round(v3, read_u32_ptr(unsafe { p.add(8) }));
            v4 = round(v4, read_u32_ptr(unsafe { p.add(12) }));
            p = unsafe { p.add(16) };
        }
        self.v1 = v1;
        self.v2 = v2;
        self.v3 = v3;
        self.v4 = v4;
        let consumed = input.len() & !15;
        input = &input[consumed..];
        self.mem[..input.len()].copy_from_slice(input);
        self.mem_len = input.len();
    }

    fn digest(&self) -> u32 {
        let mut h = if self.total >= 16 {
            self.v1
                .rotate_left(1)
                .wrapping_add(self.v2.rotate_left(7))
                .wrapping_add(self.v3.rotate_left(12))
                .wrapping_add(self.v4.rotate_left(18))
        } else {
            self.seed.wrapping_add(0x1656_67B1)
        };
        h = h.wrapping_add(self.total as u32);
        let mut p = &self.mem[..self.mem_len];
        while p.len() >= 4 {
            h = h
                .wrapping_add(read_u32(p).wrapping_mul(0xC2B2_AE3D))
                .rotate_left(17)
                .wrapping_mul(0x27D4_EB2F);
            p = &p[4..];
        }
        for &b in p {
            h = h
                .wrapping_add((b as u32).wrapping_mul(0x1656_67B1))
                .rotate_left(11)
                .wrapping_mul(0x9E37_79B1);
        }
        h ^= h >> 15;
        h = h.wrapping_mul(0x85EB_CA77);
        h ^= h >> 13;
        h = h.wrapping_mul(0xC2B2_AE3D);
        h ^ (h >> 16)
    }

    fn process(&mut self, block: &[u8]) {
        self.v1 = round(self.v1, read_u32(&block[0..]));
        self.v2 = round(self.v2, read_u32(&block[4..]));
        self.v3 = round(self.v3, read_u32(&block[8..]));
        self.v4 = round(self.v4, read_u32(&block[12..]));
    }
}

/// XXH32 mixing round: `acc = ROTL((acc + input*PRIME32_2), 13) * PRIME32_1`.
///
/// Mirrors upstream `XXH32_round` (xxhash.c:269).
fn round(acc: u32, input: u32) -> u32 {
    acc.wrapping_add(input.wrapping_mul(0x85EB_CA77))
        .rotate_left(13)
        .wrapping_mul(0x9E37_79B1)
}

/// Little-endian unaligned 32-bit load from the start of `input`.
///
/// Mirrors upstream `LZ4_read32` / `LZ4_readLE32` (lz4.c:380).
#[inline]
fn read_u32(input: &[u8]) -> u32 {
    unsafe { ptr::read_unaligned(input.as_ptr() as *const u32).to_le() }
}

/// Little-endian unaligned 16-bit load from the start of `input`.
///
/// Mirrors upstream `LZ4_read16` / `LZ4_readLE16` (lz4.c:379).
#[inline]
fn read_u16(input: &[u8]) -> u16 {
    unsafe { ptr::read_unaligned(input.as_ptr() as *const u16).to_le() }
}

/// Pointer-based variant of `read_u16` for callers operating on raw
/// `*const u8` (no slice length to check).
#[inline]
fn read_u16_ptr(input: *const u8) -> u16 {
    unsafe { ptr::read_unaligned(input as *const u16).to_le() }
}

/// Pointer-based variant of `read_u32` for callers operating on raw
/// `*const u8` (no slice length to check).
#[inline]
fn read_u32_ptr(input: *const u8) -> u32 {
    unsafe { ptr::read_unaligned(input as *const u32).to_le() }
}

/// Little-endian unaligned 64-bit load from the start of `input`.
///
/// Mirrors upstream `LZ4_read_ARCH` (lz4.c:381) on 64-bit targets.
#[inline]
fn read_u64(input: &[u8]) -> u64 {
    unsafe { ptr::read_unaligned(input.as_ptr() as *const u64).to_le() }
}

/// Pointer-based variant of `read_u64` for callers operating on raw
/// `*const u8` (no slice length to check).
#[inline]
fn read_u64_ptr(input: *const u8) -> u64 {
    unsafe { ptr::read_unaligned(input as *const u64).to_le() }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn frame_error_code_mapping_matches_upstream_numbers() {
        unsafe {
            assert_eq!(LZ4F_isError(0), 0);
            assert_eq!(LZ4F_getErrorCode(0), 0);
            assert_eq!(
                std::ffi::CStr::from_ptr(LZ4F_getErrorName(0)).to_bytes(),
                b"Unspecified error code"
            );

            let cases = [
                (ERROR_GENERIC, 1, b"ERROR_GENERIC".as_slice()),
                (
                    ERROR_MAX_BLOCK_SIZE_INVALID,
                    2,
                    b"ERROR_maxBlockSize_invalid".as_slice(),
                ),
                (
                    ERROR_BLOCK_MODE_INVALID,
                    3,
                    b"ERROR_blockMode_invalid".as_slice(),
                ),
                (
                    ERROR_PARAMETER_INVALID,
                    4,
                    b"ERROR_parameter_invalid".as_slice(),
                ),
                (
                    ERROR_COMPRESSION_LEVEL_INVALID,
                    5,
                    b"ERROR_compressionLevel_invalid".as_slice(),
                ),
                (
                    ERROR_HEADER_VERSION_WRONG,
                    6,
                    b"ERROR_headerVersion_wrong".as_slice(),
                ),
                (
                    ERROR_BLOCK_CHECKSUM_INVALID,
                    7,
                    b"ERROR_blockChecksum_invalid".as_slice(),
                ),
                (
                    ERROR_RESERVED_FLAG_SET,
                    8,
                    b"ERROR_reservedFlag_set".as_slice(),
                ),
                (
                    ERROR_ALLOCATION_FAILED,
                    9,
                    b"ERROR_allocation_failed".as_slice(),
                ),
                (
                    ERROR_SRC_SIZE_TOO_LARGE,
                    10,
                    b"ERROR_srcSize_tooLarge".as_slice(),
                ),
                (
                    ERROR_DST_TOO_SMALL,
                    11,
                    b"ERROR_dstMaxSize_tooSmall".as_slice(),
                ),
                (
                    ERROR_BAD_HEADER,
                    12,
                    b"ERROR_frameHeader_incomplete".as_slice(),
                ),
                (
                    ERROR_FRAME_SIZE_WRONG,
                    14,
                    b"ERROR_frameSize_wrong".as_slice(),
                ),
                (
                    ERROR_FRAME_TYPE_UNKNOWN,
                    13,
                    b"ERROR_frameType_unknown".as_slice(),
                ),
                (ERROR_SRC_PTR_WRONG, 15, b"ERROR_srcPtr_wrong".as_slice()),
                (
                    ERROR_DECOMPRESSION_FAILED,
                    16,
                    b"ERROR_decompressionFailed".as_slice(),
                ),
                (
                    ERROR_HEADER_CHECKSUM_INVALID,
                    17,
                    b"ERROR_headerChecksum_invalid".as_slice(),
                ),
                (
                    ERROR_CHECKSUM_INVALID,
                    18,
                    b"ERROR_contentChecksum_invalid".as_slice(),
                ),
                (
                    ERROR_FRAME_DECODING_ALREADY_STARTED,
                    19,
                    b"ERROR_frameDecoding_alreadyStarted".as_slice(),
                ),
                (
                    ERROR_COMPRESSION_STATE_UNINITIALIZED,
                    20,
                    b"ERROR_compressionState_uninitialized".as_slice(),
                ),
                (ERROR_PARAMETER_NULL, 21, b"ERROR_parameter_null".as_slice()),
                (ERROR_IO_WRITE, 22, b"ERROR_io_write".as_slice()),
                (ERROR_IO_READ, 23, b"ERROR_io_read".as_slice()),
            ];
            for (value, code, name) in cases {
                assert_eq!(LZ4F_isError(value), 1);
                assert_eq!(LZ4F_getErrorCode(value), code);
                assert_eq!(
                    std::ffi::CStr::from_ptr(LZ4F_getErrorName(value)).to_bytes(),
                    name
                );
            }
        }
    }

    #[test]
    fn frame_default_block_size_id_maps_to_64kb() {
        assert_eq!(LZ4F_getBlockSize(0), 64 * 1024);
        assert_eq!(LZ4F_getBlockSize(4), 64 * 1024);
        assert_eq!(LZ4F_getBlockSize(3), ERROR_MAX_BLOCK_SIZE_INVALID);
    }

    #[test]
    fn frame_compression_state_errors_match_upstream() {
        unsafe {
            let mut cctx = LZ4FCompressionContext(ptr::null_mut());
            assert_eq!(LZ4F_createCompressionContext(&mut cctx, LZ4F_VERSION), 0);
            let input = b"not started";
            let mut output = vec![0u8; 128];

            assert_eq!(
                LZ4F_compressUpdate(
                    cctx,
                    output.as_mut_ptr(),
                    output.len(),
                    input.as_ptr(),
                    input.len(),
                    ptr::null(),
                ),
                ERROR_COMPRESSION_STATE_UNINITIALIZED
            );
            assert_eq!(
                LZ4F_uncompressedUpdate(
                    cctx,
                    output.as_mut_ptr() as *mut c_void,
                    output.len(),
                    input.as_ptr() as *const c_void,
                    input.len(),
                    ptr::null(),
                ),
                ERROR_COMPRESSION_STATE_UNINITIALIZED
            );
            assert_eq!(
                LZ4F_flush(cctx, output.as_mut_ptr(), output.len(), ptr::null()),
                ERROR_COMPRESSION_STATE_UNINITIALIZED
            );
            assert_eq!(
                LZ4F_compressEnd(cctx, output.as_mut_ptr(), output.len(), ptr::null()),
                ERROR_COMPRESSION_STATE_UNINITIALIZED
            );

            let header_len =
                LZ4F_compressBegin(cctx, output.as_mut_ptr(), output.len(), ptr::null());
            assert_eq!(LZ4F_isError(header_len), 0);
            assert_eq!(
                LZ4F_compressEnd(
                    cctx,
                    output.as_mut_ptr().add(header_len),
                    output.len() - header_len,
                    ptr::null(),
                ),
                4
            );
            assert_eq!(
                LZ4F_compressEnd(cctx, output.as_mut_ptr(), output.len(), ptr::null()),
                ERROR_COMPRESSION_STATE_UNINITIALIZED
            );
            LZ4F_freeCompressionContext(cctx);
        }
    }

    #[test]
    fn block_round_trip_repeated() {
        let input = b"Some data Some data Some data Some data";
        let mut compressed = vec![0u8; unsafe { LZ4_compressBound(input.len() as c_int) } as usize];
        let clen = unsafe {
            LZ4_compress_default(
                input.as_ptr() as *const c_char,
                compressed.as_mut_ptr() as *mut c_char,
                input.len() as c_int,
                compressed.len() as c_int,
            )
        };
        assert!(clen > 0);
        let mut output = vec![0u8; input.len()];
        let olen = unsafe {
            LZ4_decompress_safe(
                compressed.as_ptr() as *const c_char,
                output.as_mut_ptr() as *mut c_char,
                clen,
                output.len() as c_int,
            )
        };
        assert_eq!(olen as usize, input.len());
        assert_eq!(&output, input);
    }

    #[test]
    fn block_fast_accepts_null_empty_source_and_rejects_oversize() {
        unsafe {
            let mut dst = [0u8; 16];
            let empty_len = LZ4_compress_fast(
                ptr::null(),
                dst.as_mut_ptr() as *mut c_char,
                0,
                dst.len() as c_int,
                1,
            );
            assert_eq!(empty_len, 1);
            assert_eq!(dst[0], 0);

            assert_eq!(
                LZ4_compress_fast(
                    ptr::null(),
                    dst.as_mut_ptr() as *mut c_char,
                    1,
                    dst.len() as c_int,
                    1,
                ),
                0
            );

            let src = [0u8; 1];
            assert_eq!(
                LZ4_compress_fast(
                    src.as_ptr() as *const c_char,
                    dst.as_mut_ptr() as *mut c_char,
                    LZ4_MAX_INPUT_SIZE + 1,
                    dst.len() as c_int,
                    1,
                ),
                0
            );
        }
    }

    #[test]
    fn acceleration_is_clamped_to_upstream_range() {
        assert_eq!(normalize_acceleration(c_int::MIN), 1);
        assert_eq!(normalize_acceleration(0), 1);
        assert_eq!(normalize_acceleration(4), 4);
        assert_eq!(normalize_acceleration(65_537), 65_537);
        assert_eq!(normalize_acceleration(65_538), 65_537);
        assert_eq!(normalize_acceleration(c_int::MAX), 65_537);
    }

    #[test]
    fn block_dest_size_and_ext_state_round_trip() {
        let input = b"dest-size-data-".repeat(2048);
        let bound = unsafe { LZ4_compressBound(input.len() as c_int) } as usize;
        let mut state = vec![0u8; LZ4_sizeofState() as usize];
        let mut compressed = vec![0u8; bound];
        let compressed_len = unsafe {
            LZ4_compress_fast_extState(
                state.as_mut_ptr() as *mut c_void,
                input.as_ptr() as *const c_char,
                compressed.as_mut_ptr() as *mut c_char,
                input.len() as c_int,
                compressed.len() as c_int,
                1,
            )
        };
        assert!(compressed_len > 0);
        assert!(state.iter().any(|&b| b != 0));

        let mut output = vec![0u8; input.len()];
        let output_len = unsafe {
            LZ4_decompress_safe(
                compressed.as_ptr() as *const c_char,
                output.as_mut_ptr() as *mut c_char,
                compressed_len,
                output.len() as c_int,
            )
        };
        assert_eq!(output_len as usize, input.len());
        assert_eq!(output, input);

        let mut src_size = input.len() as c_int;
        let mut tiny = vec![0u8; compressed_len as usize / 2];
        let tiny_len = unsafe {
            LZ4_compress_destSize(
                input.as_ptr() as *const c_char,
                tiny.as_mut_ptr() as *mut c_char,
                &mut src_size,
                tiny.len() as c_int,
            )
        };
        assert!(tiny_len > 0);
        assert!(src_size > 0);
        assert!(src_size < input.len() as c_int);

        let mut dest_state = vec![0u8; LZ4_sizeofState() as usize];
        src_size = input.len() as c_int;
        let null_state_len = unsafe {
            LZ4_compress_destSize_extState(
                std::ptr::null_mut(),
                input.as_ptr() as *const c_char,
                tiny.as_mut_ptr() as *mut c_char,
                &mut src_size,
                tiny.len() as c_int,
                1,
            )
        };
        assert_eq!(null_state_len, 0);

        let mut fast_accel4 = vec![0u8; bound];
        let fast_accel4_len = unsafe {
            LZ4_compress_fast(
                input.as_ptr() as *const c_char,
                fast_accel4.as_mut_ptr() as *mut c_char,
                input.len() as c_int,
                fast_accel4.len() as c_int,
                4,
            )
        };
        assert!(fast_accel4_len > 0);

        let mut dest_accel4 = vec![0u8; bound];
        src_size = input.len() as c_int;
        let dest_accel4_len = unsafe {
            LZ4_compress_destSize_extState(
                dest_state.as_mut_ptr() as *mut c_void,
                input.as_ptr() as *const c_char,
                dest_accel4.as_mut_ptr() as *mut c_char,
                &mut src_size,
                dest_accel4.len() as c_int,
                4,
            )
        };
        assert_eq!(src_size as usize, input.len());
        assert_eq!(dest_accel4_len, fast_accel4_len);
        assert!(dest_state.iter().any(|&b| b != 0));
        assert_eq!(
            &dest_accel4[..dest_accel4_len as usize],
            &fast_accel4[..fast_accel4_len as usize]
        );

        let mut fast_reset = vec![0u8; bound];
        let fast_reset_len = unsafe {
            LZ4_compress_fast_extState_fastReset(
                state.as_mut_ptr() as *mut c_void,
                input.as_ptr() as *const c_char,
                fast_reset.as_mut_ptr() as *mut c_char,
                input.len() as c_int,
                fast_reset.len() as c_int,
                4,
            )
        };
        assert_eq!(fast_reset_len, fast_accel4_len);
        assert_eq!(
            &fast_reset[..fast_reset_len as usize],
            &fast_accel4[..fast_accel4_len as usize]
        );

        let mut hc_state = vec![0u8; LZ4_sizeofStateHC() as usize];
        let hc_stream =
            unsafe { LZ4_initStreamHC(hc_state.as_mut_ptr() as *mut c_void, hc_state.len()) };
        assert!(!hc_stream.is_null());
        let mut hc_fast_reset = vec![0u8; bound];
        let hc_fast_reset_len = unsafe {
            LZ4_compress_HC_extStateHC_fastReset(
                hc_state.as_mut_ptr() as *mut c_void,
                input.as_ptr() as *const c_char,
                hc_fast_reset.as_mut_ptr() as *mut c_char,
                input.len() as c_int,
                hc_fast_reset.len() as c_int,
                9,
            )
        };
        assert!(hc_fast_reset_len > 0);
        output.fill(0);
        let hc_output_len = unsafe {
            LZ4_decompress_safe(
                hc_fast_reset.as_ptr() as *const c_char,
                output.as_mut_ptr() as *mut c_char,
                hc_fast_reset_len,
                output.len() as c_int,
            )
        };
        assert_eq!(hc_output_len as usize, input.len());
        assert_eq!(output, input);
    }

    #[test]
    fn fast_stream_compression_references_loaded_dictionary() {
        unsafe {
            let dict = b"abcdefghijklmnop";
            let input = b"abcdefghijklmnop";
            let stream = LZ4_createStream();
            assert!(!stream.is_null());
            assert_eq!(
                LZ4_loadDict(stream, dict.as_ptr() as *const c_char, dict.len() as c_int),
                dict.len() as c_int
            );
            let mut compressed = vec![0u8; LZ4_compressBound(input.len() as c_int) as usize];
            let compressed_len = LZ4_compress_continue(
                stream,
                input.as_ptr() as *const c_char,
                compressed.as_mut_ptr() as *mut c_char,
                input.len() as c_int,
                compressed.len() as c_int,
            );
            assert!(compressed_len > 0);
            assert!((compressed_len as usize) < input.len() + 1);

            let mut saved = vec![0u8; dict.len() + input.len()];
            let saved_len = LZ4_saveDict(
                stream,
                saved.as_mut_ptr() as *mut c_char,
                saved.len() as c_int,
            );
            assert!(saved_len >= input.len() as c_int);
            LZ4_freeStream(stream);

            let mut output = vec![0u8; input.len()];
            let output_len = LZ4_decompress_safe_usingDict(
                compressed.as_ptr() as *const c_char,
                output.as_mut_ptr() as *mut c_char,
                compressed_len,
                output.len() as c_int,
                dict.as_ptr() as *const c_char,
                dict.len() as c_int,
            );
            assert_eq!(output_len as usize, input.len());
            assert_eq!(output, input);
        }
    }

    #[test]
    fn fast_stream_init_and_tiny_load_dict_match_upstream() {
        unsafe {
            let mut stream_storage = vec![0u8; LZ4_sizeofStreamState() as usize];
            assert!(LZ4_initStream(ptr::null_mut(), stream_storage.len()).is_null());
            assert!(LZ4_initStream(stream_storage.as_mut_ptr() as *mut c_void, 1).is_null());
            let stream = LZ4_initStream(
                stream_storage.as_mut_ptr() as *mut c_void,
                stream_storage.len(),
            );
            assert!(!stream.is_null());

            let dict = b"abcdefghijklmnop";
            for len in 0..HASH_UNIT {
                assert_eq!(
                    LZ4_loadDict(stream, dict.as_ptr() as *const c_char, len as c_int),
                    0,
                    "{len}"
                );
                assert_eq!(
                    LZ4_loadDictSlow(stream, dict.as_ptr() as *const c_char, len as c_int),
                    0,
                    "{len}"
                );
            }
            assert_eq!(
                LZ4_loadDict(stream, dict.as_ptr() as *const c_char, HASH_UNIT as c_int),
                HASH_UNIT as c_int
            );

            let mut hc_storage = vec![0u8; LZ4_sizeofStreamStateHC() as usize];
            assert!(LZ4_initStreamHC(ptr::null_mut(), hc_storage.len()).is_null());
            assert!(LZ4_initStreamHC(hc_storage.as_mut_ptr() as *mut c_void, 1).is_null());
            let hc_stream =
                LZ4_initStreamHC(hc_storage.as_mut_ptr() as *mut c_void, hc_storage.len());
            assert!(!hc_stream.is_null());
            for len in 0..HASH_UNIT {
                assert_eq!(
                    LZ4_loadDictHC(hc_stream, dict.as_ptr() as *const c_char, len as c_int),
                    len as c_int,
                    "{len}"
                );
            }
        }
    }

    #[test]
    fn hc_save_dict_treats_tiny_requested_dictionary_as_empty() {
        unsafe {
            let dict = b"abcdefghijklmnop";
            let stream = LZ4_createStreamHC();
            assert!(!stream.is_null());
            assert_eq!(
                LZ4_loadDictHC(stream, dict.as_ptr() as *const c_char, dict.len() as c_int),
                dict.len() as c_int
            );

            let mut saved = [0u8; 16];
            assert_eq!(
                LZ4_saveDictHC(stream, saved.as_mut_ptr() as *mut c_char, 3),
                0
            );
            assert_eq!(
                LZ4_saveDictHC(stream, saved.as_mut_ptr() as *mut c_char, 4),
                0
            );

            assert_eq!(
                LZ4_loadDictHC(stream, dict.as_ptr() as *const c_char, dict.len() as c_int),
                dict.len() as c_int
            );
            assert_eq!(
                LZ4_saveDictHC(stream, saved.as_mut_ptr() as *mut c_char, 4),
                4
            );
            assert_eq!(&saved[..4], &dict[dict.len() - 4..]);
            LZ4_freeStreamHC(stream);
        }
    }

    #[test]
    fn decoder_ring_buffer_size_matches_upstream_boundaries() {
        let overhead = (LZ4_DISTANCE_MAX + 1 + 14) as c_int;
        assert_eq!(LZ4_decoderRingBufferSize(-1), 0);
        assert_eq!(LZ4_decoderRingBufferSize(0), overhead + 16);
        assert_eq!(LZ4_decoderRingBufferSize(15), overhead + 16);
        assert_eq!(LZ4_decoderRingBufferSize(16), overhead + 16);
        assert_eq!(LZ4_decoderRingBufferSize(64 * 1024), overhead + 64 * 1024);
        assert_eq!(
            LZ4_decoderRingBufferSize(LZ4_MAX_INPUT_SIZE),
            overhead + LZ4_MAX_INPUT_SIZE
        );
        assert_eq!(LZ4_decoderRingBufferSize(LZ4_MAX_INPUT_SIZE + 1), 0);
    }

    #[test]
    fn fast_attach_dictionary_is_cleared_after_first_compression() {
        unsafe {
            let dict = b"abcdefghijklmnop0123456789";
            let first = b"zzzzzzzzzzzzzzzz";
            let second = b"abcdefghijklmnop0123456789";

            let dict_stream = LZ4_createStream();
            let work_stream = LZ4_createStream();
            assert!(!dict_stream.is_null());
            assert!(!work_stream.is_null());
            assert_eq!(
                LZ4_loadDict(
                    dict_stream,
                    dict.as_ptr() as *const c_char,
                    dict.len() as c_int
                ),
                dict.len() as c_int
            );
            LZ4_attach_dictionary(work_stream, dict_stream);

            let mut first_compressed = vec![0u8; LZ4_compressBound(first.len() as c_int) as usize];
            let first_len = LZ4_compress_fast_continue(
                work_stream,
                first.as_ptr() as *const c_char,
                first_compressed.as_mut_ptr() as *mut c_char,
                first.len() as c_int,
                first_compressed.len() as c_int,
                1,
            );
            assert!(first_len > 0);

            let mut second_compressed =
                vec![0u8; LZ4_compressBound(second.len() as c_int) as usize];
            let second_len = LZ4_compress_fast_continue(
                work_stream,
                second.as_ptr() as *const c_char,
                second_compressed.as_mut_ptr() as *mut c_char,
                second.len() as c_int,
                second_compressed.len() as c_int,
                1,
            );
            assert!(second_len > 0);

            let mut output = vec![0u8; second.len()];
            let output_len = LZ4_decompress_safe(
                second_compressed.as_ptr() as *const c_char,
                output.as_mut_ptr() as *mut c_char,
                second_len,
                output.len() as c_int,
            );
            assert_eq!(output_len, second.len() as c_int);
            assert_eq!(output, second);

            LZ4_freeStream(dict_stream);
            LZ4_freeStream(work_stream);
        }
    }

    #[test]
    fn hc_attach_dictionary_is_cleared_after_first_compression() {
        unsafe {
            let dict = b"abcdefghijklmnop0123456789";
            let first = b"zzzzzzzzzzzzzzzz";
            let second = b"abcdefghijklmnop0123456789";

            let dict_stream = LZ4_createStreamHC();
            let work_stream = LZ4_createStreamHC();
            assert!(!dict_stream.is_null());
            assert!(!work_stream.is_null());
            assert_eq!(
                LZ4_loadDictHC(
                    dict_stream,
                    dict.as_ptr() as *const c_char,
                    dict.len() as c_int
                ),
                dict.len() as c_int
            );
            LZ4_attach_HC_dictionary(work_stream, dict_stream);

            let mut first_compressed = vec![0u8; LZ4_compressBound(first.len() as c_int) as usize];
            let first_len = LZ4_compress_HC_continue(
                work_stream,
                first.as_ptr() as *const c_char,
                first_compressed.as_mut_ptr() as *mut c_char,
                first.len() as c_int,
                first_compressed.len() as c_int,
            );
            assert!(first_len > 0);

            let mut second_compressed =
                vec![0u8; LZ4_compressBound(second.len() as c_int) as usize];
            let second_len = LZ4_compress_HC_continue(
                work_stream,
                second.as_ptr() as *const c_char,
                second_compressed.as_mut_ptr() as *mut c_char,
                second.len() as c_int,
                second_compressed.len() as c_int,
            );
            assert!(second_len > 0);

            let mut output = vec![0u8; second.len()];
            let output_len = LZ4_decompress_safe_usingDict(
                second_compressed.as_ptr() as *const c_char,
                output.as_mut_ptr() as *mut c_char,
                second_len,
                output.len() as c_int,
                first.as_ptr() as *const c_char,
                first.len() as c_int,
            );
            assert_eq!(output_len, second.len() as c_int);
            assert_eq!(output, second);

            LZ4_freeStreamHC(dict_stream);
            LZ4_freeStreamHC(work_stream);
        }
    }

    #[test]
    fn hc_deprecated_continue_uses_stream_dictionary_and_updates_history() {
        unsafe {
            let dict = b"abcdefghijklmnop0123456789";
            let input = b"abcdefghijklmnop0123456789";
            let stream = LZ4_createStreamHC();
            assert!(!stream.is_null());
            assert_eq!(
                LZ4_loadDictHC(stream, dict.as_ptr() as *const c_char, dict.len() as c_int),
                dict.len() as c_int
            );

            let mut compressed = vec![0u8; LZ4_compressBound(input.len() as c_int) as usize];
            let compressed_len = LZ4_compressHC2_continue(
                stream as *mut c_void,
                input.as_ptr() as *const c_char,
                compressed.as_mut_ptr() as *mut c_char,
                input.len() as c_int,
                9,
            );
            assert!(compressed_len > 0);
            assert!((compressed_len as usize) < input.len());

            let mut output = vec![0u8; input.len()];
            let output_len = LZ4_decompress_safe_usingDict(
                compressed.as_ptr() as *const c_char,
                output.as_mut_ptr() as *mut c_char,
                compressed_len,
                output.len() as c_int,
                dict.as_ptr() as *const c_char,
                dict.len() as c_int,
            );
            assert_eq!(output_len, input.len() as c_int);
            assert_eq!(output, input);

            let mut saved = [0u8; 64];
            let saved_len = LZ4_saveDictHC(
                stream,
                saved.as_mut_ptr() as *mut c_char,
                saved.len() as c_int,
            );
            assert!(saved_len >= input.len() as c_int);
            let saved_len = saved_len as usize;
            assert_eq!(&saved[saved_len - input.len()..saved_len], input);
            LZ4_freeStreamHC(stream);
        }
    }

    #[test]
    fn hc_favor_decompression_speed_skips_tiny_offsets() {
        unsafe {
            let input = vec![b'a'; 4096];
            let bound = LZ4_compressBound(input.len() as c_int);
            let stream = LZ4_createStreamHC();
            assert!(!stream.is_null());
            LZ4_setCompressionLevel(stream, 10);

            let mut normal = vec![0u8; bound as usize];
            let normal_len = LZ4_compress_HC_continue(
                stream,
                input.as_ptr() as *const c_char,
                normal.as_mut_ptr() as *mut c_char,
                input.len() as c_int,
                normal.len() as c_int,
            );
            assert!(normal_len > 0);
            assert!(block_has_offset_below(&normal[..normal_len as usize], 8));

            LZ4_resetStreamHC_fast(stream, 10);
            LZ4_favorDecompressionSpeed(stream, 1);
            let mut favored = vec![0u8; bound as usize];
            let favored_len = LZ4_compress_HC_continue(
                stream,
                input.as_ptr() as *const c_char,
                favored.as_mut_ptr() as *mut c_char,
                input.len() as c_int,
                favored.len() as c_int,
            );
            assert!(favored_len > 0);
            assert!(favored_len >= normal_len);
            assert!(!block_has_offset_below(&favored[..favored_len as usize], 8));

            LZ4_resetStreamHC(stream, 10);
            let mut reset = vec![0u8; bound as usize];
            let reset_len = LZ4_compress_HC_continue(
                stream,
                input.as_ptr() as *const c_char,
                reset.as_mut_ptr() as *mut c_char,
                input.len() as c_int,
                reset.len() as c_int,
            );
            LZ4_freeStreamHC(stream);

            assert_eq!(reset_len, normal_len);
            assert_eq!(&reset[..reset_len as usize], &normal[..normal_len as usize]);
            assert!(block_has_offset_below(&reset[..reset_len as usize], 8));

            let mut output = vec![0u8; input.len()];
            let output_len = LZ4_decompress_safe(
                favored.as_ptr() as *const c_char,
                output.as_mut_ptr() as *mut c_char,
                favored_len,
                output.len() as c_int,
            );
            assert_eq!(output_len as usize, input.len());
            assert_eq!(output, input);
        }
    }

    #[test]
    fn fast_obsolete_slide_input_buffer_reports_saved_dictionary() {
        unsafe {
            let input = b"slide-input-buffer-dictionary".repeat(4);
            let stream = LZ4_createStream();
            assert!(!stream.is_null());
            assert!(LZ4_slideInputBuffer(stream as *mut c_void).is_null());

            let mut compressed = vec![0u8; LZ4_compressBound(input.len() as c_int) as usize];
            let compressed_len = LZ4_compress_fast_continue(
                stream,
                input.as_ptr() as *const c_char,
                compressed.as_mut_ptr() as *mut c_char,
                input.len() as c_int,
                compressed.len() as c_int,
                1,
            );
            assert!(compressed_len > 0);

            let ptr = LZ4_slideInputBuffer(stream as *mut c_void);
            assert!(!ptr.is_null());
            let saved = slice::from_raw_parts(ptr as *const u8, input.len());
            assert_eq!(saved, input);
            LZ4_freeStream(stream);
        }
    }

    #[test]
    fn fast_deprecated_state_wrappers_round_trip_and_reset() {
        unsafe {
            let input = b"deprecated-fast-state-wrapper-".repeat(2048);
            let bound = LZ4_compressBound(input.len() as c_int) as usize;
            let state_size = LZ4_sizeofStreamState();
            assert!(state_size > 0);
            let mut state = vec![0u8; state_size as usize];

            assert_eq!(
                LZ4_resetStreamState(
                    state.as_mut_ptr() as *mut c_void,
                    input.as_ptr() as *mut c_char,
                ),
                0
            );
            assert!(LZ4_slideInputBuffer(state.as_mut_ptr() as *mut c_void).is_null());

            let mut compressed = vec![0u8; bound];
            let compressed_len = LZ4_compress_withState(
                state.as_mut_ptr() as *mut c_void,
                input.as_ptr() as *const c_char,
                compressed.as_mut_ptr() as *mut c_char,
                input.len() as c_int,
            );
            assert!(compressed_len > 0);

            let mut output = vec![0u8; input.len()];
            let output_len = LZ4_decompress_safe(
                compressed.as_ptr() as *const c_char,
                output.as_mut_ptr() as *mut c_char,
                compressed_len,
                output.len() as c_int,
            );
            assert_eq!(output_len as usize, input.len());
            assert_eq!(output, input);

            assert_eq!(
                LZ4_resetStreamState(state.as_mut_ptr() as *mut c_void, ptr::null_mut(),),
                0
            );
            let mut limited = vec![0u8; compressed_len as usize];
            let limited_len = LZ4_compress_limitedOutput_withState(
                state.as_mut_ptr() as *mut c_void,
                input.as_ptr() as *const c_char,
                limited.as_mut_ptr() as *mut c_char,
                input.len() as c_int,
                limited.len() as c_int,
            );
            assert!(limited_len > 0);

            output.fill(0);
            let output_len = LZ4_decompress_safe(
                limited.as_ptr() as *const c_char,
                output.as_mut_ptr() as *mut c_char,
                limited_len,
                output.len() as c_int,
            );
            assert_eq!(output_len as usize, input.len());
            assert_eq!(output, input);

            let obsolete = LZ4_create(ptr::null_mut());
            assert!(!obsolete.is_null());
            assert_eq!(LZ4_freeStream(obsolete as *mut LZ4StreamEncode), 0);
        }
    }

    #[test]
    fn hc_obsolete_slide_input_buffer_clears_history() {
        unsafe {
            let dict = b"abcdefghijklmnop0123456789";
            let stream = LZ4_createStreamHC();
            assert!(!stream.is_null());
            assert!(LZ4_slideInputBufferHC(stream as *mut c_void).is_null());
            assert_eq!(
                LZ4_loadDictHC(stream, dict.as_ptr() as *const c_char, dict.len() as c_int),
                dict.len() as c_int
            );

            let ptr = LZ4_slideInputBufferHC(stream as *mut c_void);
            assert!(!ptr.is_null());

            let mut compressed = vec![0u8; LZ4_compressBound(dict.len() as c_int) as usize];
            let compressed_len = LZ4_compress_HC_continue(
                stream,
                dict.as_ptr() as *const c_char,
                compressed.as_mut_ptr() as *mut c_char,
                dict.len() as c_int,
                compressed.len() as c_int,
            );
            assert!(compressed_len > 0);

            let mut output = vec![0u8; dict.len()];
            let output_len = LZ4_decompress_safe(
                compressed.as_ptr() as *const c_char,
                output.as_mut_ptr() as *mut c_char,
                compressed_len,
                output.len() as c_int,
            );
            assert_eq!(output_len, dict.len() as c_int);
            assert_eq!(output, dict);
            LZ4_freeStreamHC(stream);
        }
    }

    #[test]
    fn decompress_safe_partial_returns_prefix() {
        let input = b"partial output data ".repeat(1024);
        let bound = unsafe { LZ4_compressBound(input.len() as c_int) } as usize;
        let mut compressed = vec![0u8; bound];
        let compressed_len = unsafe {
            LZ4_compress_default(
                input.as_ptr() as *const c_char,
                compressed.as_mut_ptr() as *mut c_char,
                input.len() as c_int,
                compressed.len() as c_int,
            )
        };
        assert!(compressed_len > 0);
        let target = 1234usize;
        let mut output = vec![0u8; input.len()];
        let output_len = unsafe {
            LZ4_decompress_safe_partial(
                compressed.as_ptr() as *const c_char,
                output.as_mut_ptr() as *mut c_char,
                compressed_len,
                target as c_int,
                output.len() as c_int,
            )
        };
        assert_eq!(output_len as usize, target);
        assert_eq!(&output[..target], &input[..target]);
    }

    #[test]
    fn decompress_safe_rejects_block_ending_in_match() {
        let compressed = [0x15, b'a', 0x01, 0x00];
        let mut output = vec![0u8; 10];

        let output_len = unsafe {
            LZ4_decompress_safe(
                compressed.as_ptr() as *const c_char,
                output.as_mut_ptr() as *mut c_char,
                compressed.len() as c_int,
                output.len() as c_int,
            )
        };
        assert_eq!(output_len, -1);

        let dict_compressed = [0x02u8, 0x03, 0x00];
        let dict = b"abc";
        let mut dict_output = vec![0u8; 6];
        let dict_output_len = unsafe {
            LZ4_decompress_safe_usingDict(
                dict_compressed.as_ptr() as *const c_char,
                dict_output.as_mut_ptr() as *mut c_char,
                dict_compressed.len() as c_int,
                dict_output.len() as c_int,
                dict.as_ptr() as *const c_char,
                dict.len() as c_int,
            )
        };
        assert_eq!(dict_output_len, -1);
    }

    #[test]
    fn decompress_safe_partial_clamps_target_to_capacity() {
        let compressed = [
            0xa0, b'a', b'b', b'c', b'd', b'e', b'f', b'g', b'h', b'i', b'j',
        ];
        let mut output = vec![0u8; 5];

        let output_len = unsafe {
            LZ4_decompress_safe_partial(
                compressed.as_ptr() as *const c_char,
                output.as_mut_ptr() as *mut c_char,
                compressed.len() as c_int,
                10,
                output.len() as c_int,
            )
        };
        assert_eq!(output_len, output.len() as c_int);
        assert_eq!(&output, b"abcde");

        let dict_compressed = [0x02u8, 0x03, 0x00];
        let dict = b"abc";
        let mut dict_output = vec![0u8; 4];
        let dict_output_len = unsafe {
            LZ4_decompress_safe_partial_usingDict(
                dict_compressed.as_ptr() as *const c_char,
                dict_output.as_mut_ptr() as *mut c_char,
                dict_compressed.len() as c_int,
                9,
                dict_output.len() as c_int,
                dict.as_ptr() as *const c_char,
                dict.len() as c_int,
            )
        };
        assert_eq!(dict_output_len, dict_output.len() as c_int);
        assert_eq!(&dict_output, b"abca");
    }

    #[test]
    fn decompress_fast_returns_consumed_bytes() {
        let input = b"fast decode consumed bytes ".repeat(256);
        let bound = unsafe { LZ4_compressBound(input.len() as c_int) } as usize;
        let mut compressed = vec![0u8; bound];
        let compressed_len = unsafe {
            LZ4_compress_default(
                input.as_ptr() as *const c_char,
                compressed.as_mut_ptr() as *mut c_char,
                input.len() as c_int,
                compressed.len() as c_int,
            )
        };
        assert!(compressed_len > 0);
        let mut output = vec![0u8; input.len()];
        let consumed = unsafe {
            LZ4_decompress_fast(
                compressed.as_ptr() as *const c_char,
                output.as_mut_ptr() as *mut c_char,
                output.len() as c_int,
            )
        };
        assert!(consumed > 0);
        assert!(consumed <= compressed_len);
        assert_eq!(output, input);

        let dict = b"abc";
        let dict_compressed = [0x30, b'x', b'y', b'z'];
        let mut dict_output = vec![0u8; 3];
        let consumed = unsafe {
            LZ4_decompress_fast_usingDict(
                dict_compressed.as_ptr() as *const c_char,
                dict_output.as_mut_ptr() as *mut c_char,
                dict_output.len() as c_int,
                dict.as_ptr() as *const c_char,
                dict.len() as c_int,
            )
        };
        assert_eq!(consumed, dict_compressed.len() as c_int);
        assert_eq!(dict_output, b"xyz");
    }

    #[test]
    fn decodes_known_empty_block() {
        let compressed = [0u8];
        let mut output = [];
        let len = unsafe {
            LZ4_decompress_safe(
                compressed.as_ptr() as *const c_char,
                output.as_mut_ptr() as *mut c_char,
                compressed.len() as c_int,
                2,
            )
        };
        assert_eq!(len, 0);
    }

    #[test]
    fn streaming_decode_uses_dictionary() {
        unsafe {
            let compressed = [0x08, 0x03, 0x00, 0x50, b'a', b'b', b'c', b'd', b'e'];
            let expected = b"abcabcabcabcabcde";
            let mut direct = vec![0u8; expected.len()];
            assert_eq!(
                decompress_block_with_dict(&compressed, &mut direct, b"abc"),
                Some(expected.len())
            );
            let dict = b"abc";
            let mut using_dict = vec![0u8; expected.len()];
            let using_dict_len = LZ4_decompress_safe_usingDict(
                compressed.as_ptr() as *const c_char,
                using_dict.as_mut_ptr() as *mut c_char,
                compressed.len() as c_int,
                using_dict.len() as c_int,
                dict.as_ptr() as *const c_char,
                dict.len() as c_int,
            );
            assert_eq!(using_dict_len, using_dict.len() as c_int);
            assert_eq!(using_dict, expected);

            let stream = LZ4_createStreamDecode();
            assert!(!stream.is_null());
            assert_eq!(
                LZ4_setStreamDecode(stream, dict.as_ptr() as *const c_char, dict.len() as c_int),
                1
            );
            let mut output = vec![0u8; expected.len()];
            let len = LZ4_decompress_safe_continue(
                stream,
                compressed.as_ptr() as *const c_char,
                output.as_mut_ptr() as *mut c_char,
                compressed.len() as c_int,
                output.len() as c_int,
            );
            assert_eq!(len, output.len() as c_int);
            assert_eq!(output, expected);
            LZ4_freeStreamDecode(stream);
        }
    }

    #[test]
    fn decompress_match_copy_handles_small_overlap() {
        let compressed = [0x15, b'a', 0x01, 0x00, 0x50, b'b', b'c', b'd', b'e', b'f'];
        let mut output = vec![0u8; 15];

        assert_eq!(decompress_block(&compressed, &mut output), Some(15));
        assert_eq!(&output[..10], &[b'a'; 10]);
        assert_eq!(&output[10..], b"bcdef");

        let mut partial = vec![0u8; 10];
        assert_eq!(
            decompress_block_partial(&compressed, &mut partial, 7),
            Some(7)
        );
        assert_eq!(&partial[..7], b"aaaaaaa");
    }

    #[test]
    fn decompress_match_copy_spans_dictionary_and_prefix() {
        let compressed = [
            0x24, b'd', b'e', 0x04, 0x00, 0x50, b'f', b'g', b'h', b'i', b'j',
        ];
        let mut output = vec![0u8; 15];

        assert_eq!(
            decompress_block_with_dict(&compressed, &mut output, b"abc"),
            Some(15)
        );
        assert_eq!(output, b"debcdebcdefghij");

        let mut fast_output = vec![0u8; 15];
        let consumed = unsafe {
            LZ4_decompress_fast_usingDict(
                compressed.as_ptr() as *const c_char,
                fast_output.as_mut_ptr() as *mut c_char,
                fast_output.len() as c_int,
                b"abc".as_ptr() as *const c_char,
                3,
            )
        };
        assert_eq!(consumed, compressed.len() as c_int);
        assert_eq!(fast_output, b"debcdebcdefghij");
    }

    #[test]
    fn frame_round_trip_raw_blocks() {
        unsafe {
            let mut cctx = LZ4FCompressionContext(ptr::null_mut());
            assert_eq!(LZ4F_createCompressionContext(&mut cctx, LZ4F_VERSION), 0);
            let prefs = LZ4FPreferences {
                frame_info: LZ4FFrameInfo {
                    block_size_id: BlockSize::Max64KB,
                    block_mode: BlockMode::Independent,
                    content_checksum_flag: ContentChecksum::ChecksumEnabled,
                    frame_type: FrameType::Frame,
                    content_size: 0,
                    dict_id: 0,
                    block_checksum_flag: BlockChecksum::BlockChecksumEnabled,
                },
                compression_level: 0,
                auto_flush: 0,
                favor_dec_speed: 0,
                reserved: [0; 3],
            };
            let input = b"frame data";
            let mut encoded = vec![0u8; 128];
            let mut pos = LZ4F_compressBegin(cctx, encoded.as_mut_ptr(), encoded.len(), &prefs);
            pos += LZ4F_compressUpdate(
                cctx,
                encoded.as_mut_ptr().add(pos),
                encoded.len() - pos,
                input.as_ptr(),
                input.len(),
                ptr::null(),
            );
            pos += LZ4F_compressEnd(
                cctx,
                encoded.as_mut_ptr().add(pos),
                encoded.len() - pos,
                ptr::null(),
            );
            encoded.truncate(pos);
            LZ4F_freeCompressionContext(cctx);

            let mut dctx = LZ4FDecompressionContext(ptr::null_mut());
            assert_eq!(LZ4F_createDecompressionContext(&mut dctx, LZ4F_VERSION), 0);
            let mut out = vec![0u8; input.len()];
            let mut dst_size = out.len();
            let mut src_size = encoded.len();
            let code = LZ4F_decompress(
                dctx,
                out.as_mut_ptr(),
                &mut dst_size,
                encoded.as_ptr(),
                &mut src_size,
                ptr::null(),
            );
            assert!(!LZ4F_isError(code).eq(&1));
            assert_eq!(dst_size, input.len());
            assert_eq!(&out, input);
            LZ4F_freeDecompressionContext(dctx);
        }
    }

    #[test]
    fn frame_rejects_block_larger_than_declared_max_size() {
        unsafe {
            let prefs = LZ4FPreferences {
                frame_info: LZ4FFrameInfo {
                    block_size_id: BlockSize::Max64KB,
                    block_mode: BlockMode::Independent,
                    content_checksum_flag: ContentChecksum::NoChecksum,
                    frame_type: FrameType::Frame,
                    content_size: 0,
                    dict_id: 0,
                    block_checksum_flag: BlockChecksum::NoBlockChecksum,
                },
                compression_level: 0,
                auto_flush: 0,
                favor_dec_speed: 0,
                reserved: [0; 3],
            };
            let mut cctx = LZ4FCompressionContext(ptr::null_mut());
            assert_eq!(LZ4F_createCompressionContext(&mut cctx, LZ4F_VERSION), 0);
            let mut header = vec![0u8; 32];
            let header_len = LZ4F_compressBegin(cctx, header.as_mut_ptr(), header.len(), &prefs);
            assert_eq!(LZ4F_isError(header_len), 0);
            header.truncate(header_len);
            LZ4F_freeCompressionContext(cctx);

            let too_large_block_len = (64 * 1024 + 1u32).to_le_bytes();
            let mut encoded = header.clone();
            encoded.extend_from_slice(&too_large_block_len);

            let mut dctx = LZ4FDecompressionContext(ptr::null_mut());
            assert_eq!(LZ4F_createDecompressionContext(&mut dctx, LZ4F_VERSION), 0);
            let mut out = [0u8; 1];
            let mut dst_size = out.len();
            let mut src_size = encoded.len();
            let code = LZ4F_decompress(
                dctx,
                out.as_mut_ptr(),
                &mut dst_size,
                encoded.as_ptr(),
                &mut src_size,
                ptr::null(),
            );
            assert_eq!(code, ERROR_MAX_BLOCK_SIZE_INVALID);
            LZ4F_freeDecompressionContext(dctx);

            let mut dctx = LZ4FDecompressionContext(ptr::null_mut());
            assert_eq!(LZ4F_createDecompressionContext(&mut dctx, LZ4F_VERSION), 0);
            let mut empty_dst_size = 0usize;
            let mut header_src_size = header.len();
            let hint = LZ4F_decompress(
                dctx,
                ptr::null_mut(),
                &mut empty_dst_size,
                header.as_ptr(),
                &mut header_src_size,
                ptr::null(),
            );
            assert_eq!(LZ4F_isError(hint), 0);

            let mut dst_size = out.len();
            let mut src_size = too_large_block_len.len();
            let code = LZ4F_decompress(
                dctx,
                out.as_mut_ptr(),
                &mut dst_size,
                too_large_block_len.as_ptr(),
                &mut src_size,
                ptr::null(),
            );
            assert_eq!(code, ERROR_MAX_BLOCK_SIZE_INVALID);
            LZ4F_freeDecompressionContext(dctx);
        }
    }

    #[test]
    fn frame_uncompressed_update_splits_large_raw_blocks() {
        unsafe {
            let mut cctx = LZ4FCompressionContext(ptr::null_mut());
            assert_eq!(LZ4F_createCompressionContext(&mut cctx, LZ4F_VERSION), 0);
            let prefs = LZ4FPreferences {
                frame_info: LZ4FFrameInfo {
                    block_size_id: BlockSize::Max64KB,
                    block_mode: BlockMode::Independent,
                    content_checksum_flag: ContentChecksum::ChecksumEnabled,
                    frame_type: FrameType::Frame,
                    content_size: 0,
                    dict_id: 0,
                    block_checksum_flag: BlockChecksum::BlockChecksumEnabled,
                },
                compression_level: 0,
                auto_flush: 0,
                favor_dec_speed: 0,
                reserved: [0; 3],
            };
            let input = patterned_hc_input(150_000);
            let mut encoded = vec![0u8; LZ4F_compressBound(input.len(), &prefs) + 32];
            let mut pos = LZ4F_compressBegin(cctx, encoded.as_mut_ptr(), encoded.len(), &prefs);
            let update = LZ4F_uncompressedUpdate(
                cctx,
                encoded.as_mut_ptr().add(pos) as *mut c_void,
                encoded.len() - pos,
                input.as_ptr() as *const c_void,
                input.len(),
                ptr::null(),
            );
            assert_eq!(LZ4F_isError(update), 0);
            let first_header = u32::from_le_bytes(encoded[pos..pos + 4].try_into().unwrap());
            assert_eq!(first_header, 0x8000_0000 | (64 * 1024));
            let second_pos = pos + 4 + 64 * 1024 + 4;
            let second_header =
                u32::from_le_bytes(encoded[second_pos..second_pos + 4].try_into().unwrap());
            assert_eq!(second_header, 0x8000_0000 | (64 * 1024));
            pos += update;
            pos += LZ4F_compressEnd(
                cctx,
                encoded.as_mut_ptr().add(pos),
                encoded.len() - pos,
                ptr::null(),
            );
            encoded.truncate(pos);
            LZ4F_freeCompressionContext(cctx);

            let mut dctx = LZ4FDecompressionContext(ptr::null_mut());
            assert_eq!(LZ4F_createDecompressionContext(&mut dctx, LZ4F_VERSION), 0);
            let mut output = vec![0u8; input.len()];
            let mut src_offset = 0usize;
            let mut dst_offset = 0usize;
            loop {
                let mut src_size = encoded.len() - src_offset;
                let mut dst_size = output.len() - dst_offset;
                let code = LZ4F_decompress(
                    dctx,
                    output[dst_offset..].as_mut_ptr(),
                    &mut dst_size,
                    encoded.as_ptr().add(src_offset),
                    &mut src_size,
                    ptr::null(),
                );
                assert_eq!(LZ4F_isError(code), 0);
                src_offset += src_size;
                dst_offset += dst_size;
                if code == 0 {
                    break;
                }
            }
            assert_eq!(output, input);
            LZ4F_freeDecompressionContext(dctx);
        }
    }

    #[test]
    fn frame_single_call_compress_round_trip() {
        unsafe {
            assert_eq!(LZ4F_getVersion(), LZ4F_VERSION);
            assert_eq!(LZ4F_compressionLevel_max(), LZ4HC_CLEVEL_MAX);
            let prefs = LZ4FPreferences {
                frame_info: LZ4FFrameInfo {
                    block_size_id: BlockSize::Max64KB,
                    block_mode: BlockMode::Linked,
                    content_checksum_flag: ContentChecksum::ChecksumEnabled,
                    frame_type: FrameType::Frame,
                    content_size: 0,
                    dict_id: 0,
                    block_checksum_flag: BlockChecksum::BlockChecksumEnabled,
                },
                compression_level: 9,
                auto_flush: 0,
                favor_dec_speed: 0,
                reserved: [0; 3],
            };
            let input = b"single call frame compression ".repeat(512);
            let bound = LZ4F_compressFrameBound(input.len(), &prefs);
            let mut encoded = vec![0u8; bound];
            let encoded_len = LZ4F_compressFrame(
                encoded.as_mut_ptr() as *mut c_void,
                encoded.len(),
                input.as_ptr() as *const c_void,
                input.len(),
                &prefs,
            );
            assert_eq!(LZ4F_isError(encoded_len), 0);
            encoded.truncate(encoded_len);

            let mut dctx = LZ4FDecompressionContext(ptr::null_mut());
            assert_eq!(LZ4F_createDecompressionContext(&mut dctx, LZ4F_VERSION), 0);
            let mut output = vec![0u8; input.len()];
            let mut src_offset = 0usize;
            let mut dst_offset = 0usize;
            loop {
                let mut src_size = encoded.len() - src_offset;
                let mut dst_size = output.len() - dst_offset;
                let code = LZ4F_decompress(
                    dctx,
                    output[dst_offset..].as_mut_ptr(),
                    &mut dst_size,
                    encoded.as_ptr().add(src_offset),
                    &mut src_size,
                    ptr::null(),
                );
                assert_eq!(LZ4F_isError(code), 0);
                src_offset += src_size;
                dst_offset += dst_size;
                if code == 0 {
                    break;
                }
            }
            assert_eq!(dst_offset, output.len());
            assert_eq!(output, input);
            LZ4F_freeDecompressionContext(dctx);
        }
    }

    #[test]
    fn frame_header_size_reports_expected_lengths() {
        unsafe {
            let mut cctx = LZ4FCompressionContext(ptr::null_mut());
            assert_eq!(LZ4F_createCompressionContext(&mut cctx, LZ4F_VERSION), 0);
            let prefs = LZ4FPreferences {
                frame_info: LZ4FFrameInfo {
                    block_size_id: BlockSize::Max64KB,
                    block_mode: BlockMode::Independent,
                    content_checksum_flag: ContentChecksum::ChecksumEnabled,
                    frame_type: FrameType::Frame,
                    content_size: 123,
                    dict_id: 0,
                    block_checksum_flag: BlockChecksum::NoBlockChecksum,
                },
                compression_level: 0,
                auto_flush: 0,
                favor_dec_speed: 0,
                reserved: [0; 3],
            };
            let mut encoded = vec![0u8; 32];
            let header_len = LZ4F_compressBegin(cctx, encoded.as_mut_ptr(), encoded.len(), &prefs);
            assert_eq!(
                LZ4F_headerSize(encoded.as_ptr() as *const c_void, 5),
                header_len
            );
            assert_eq!(
                LZ4F_headerSize(encoded.as_ptr() as *const c_void, 4),
                ERROR_BAD_HEADER
            );
            assert_eq!(LZ4F_headerSize(ptr::null(), 5), ERROR_SRC_PTR_WRONG);
            let bad_magic = [0u8; 5];
            assert_eq!(
                LZ4F_headerSize(bad_magic.as_ptr() as *const c_void, bad_magic.len()),
                ERROR_FRAME_TYPE_UNKNOWN
            );
            LZ4F_freeCompressionContext(cctx);

            let dict_prefs = LZ4FPreferences {
                frame_info: LZ4FFrameInfo {
                    block_size_id: BlockSize::Max64KB,
                    block_mode: BlockMode::Independent,
                    content_checksum_flag: ContentChecksum::NoChecksum,
                    frame_type: FrameType::Frame,
                    content_size: 0,
                    dict_id: 0x11,
                    block_checksum_flag: BlockChecksum::NoBlockChecksum,
                },
                compression_level: 0,
                auto_flush: 0,
                favor_dec_speed: 0,
                reserved: [0; 3],
            };
            let mut cctx = LZ4FCompressionContext(ptr::null_mut());
            assert_eq!(LZ4F_createCompressionContext(&mut cctx, LZ4F_VERSION), 0);
            let header_len =
                LZ4F_compressBegin(cctx, encoded.as_mut_ptr(), encoded.len(), &dict_prefs);
            assert_eq!(header_len, 11);
            assert_eq!(
                LZ4F_headerSize(encoded.as_ptr() as *const c_void, 5),
                header_len
            );
            LZ4F_freeCompressionContext(cctx);

            let full_prefs = LZ4FPreferences {
                frame_info: LZ4FFrameInfo {
                    block_size_id: BlockSize::Max4MB,
                    block_mode: BlockMode::Linked,
                    content_checksum_flag: ContentChecksum::ChecksumEnabled,
                    frame_type: FrameType::Frame,
                    content_size: 123,
                    dict_id: 0x22,
                    block_checksum_flag: BlockChecksum::BlockChecksumEnabled,
                },
                compression_level: 0,
                auto_flush: 0,
                favor_dec_speed: 0,
                reserved: [0; 3],
            };
            let mut cctx = LZ4FCompressionContext(ptr::null_mut());
            assert_eq!(LZ4F_createCompressionContext(&mut cctx, LZ4F_VERSION), 0);
            let header_len =
                LZ4F_compressBegin(cctx, encoded.as_mut_ptr(), encoded.len(), &full_prefs);
            assert_eq!(header_len, 19);
            assert_eq!(
                LZ4F_headerSize(encoded.as_ptr() as *const c_void, 5),
                header_len
            );
            LZ4F_freeCompressionContext(cctx);

            let mut skippable = Vec::new();
            skippable.extend_from_slice(&LZ4F_SKIPPABLE_MAGIC_MIN.to_le_bytes());
            skippable.extend_from_slice(&0u32.to_le_bytes());
            assert_eq!(
                LZ4F_headerSize(skippable.as_ptr() as *const c_void, skippable.len()),
                8
            );
        }
    }

    #[test]
    fn frame_header_preserves_dict_id_and_rejects_reserved_bits() {
        unsafe {
            let mut cctx = LZ4FCompressionContext(ptr::null_mut());
            assert_eq!(LZ4F_createCompressionContext(&mut cctx, LZ4F_VERSION), 0);
            let prefs = LZ4FPreferences {
                frame_info: LZ4FFrameInfo {
                    block_size_id: BlockSize::Max256KB,
                    block_mode: BlockMode::Independent,
                    content_checksum_flag: ContentChecksum::NoChecksum,
                    frame_type: FrameType::Frame,
                    content_size: 0,
                    dict_id: 0x1234_abcd,
                    block_checksum_flag: BlockChecksum::NoBlockChecksum,
                },
                compression_level: 0,
                auto_flush: 0,
                favor_dec_speed: 0,
                reserved: [0; 3],
            };
            let mut encoded = vec![0u8; 32];
            let header_len = LZ4F_compressBegin(cctx, encoded.as_mut_ptr(), encoded.len(), &prefs);
            assert_eq!(header_len, 11);
            assert_eq!(encoded[4] & 0x01, 0x01);

            let mut dctx = LZ4FDecompressionContext(ptr::null_mut());
            assert_eq!(LZ4F_createDecompressionContext(&mut dctx, LZ4F_VERSION), 0);
            let mut info = LZ4FFrameInfo {
                block_size_id: BlockSize::Default,
                block_mode: BlockMode::Linked,
                content_checksum_flag: ContentChecksum::ChecksumEnabled,
                frame_type: FrameType::SkippableFrame,
                content_size: 1,
                dict_id: 0,
                block_checksum_flag: BlockChecksum::BlockChecksumEnabled,
            };
            let mut src_size = header_len;
            assert_eq!(
                LZ4F_getFrameInfo(dctx, &mut info, encoded.as_ptr(), &mut src_size),
                0
            );
            assert_eq!(src_size, header_len);
            assert_eq!(info.dict_id, 0x1234_abcd);
            assert!(matches!(info.block_size_id, BlockSize::Max256KB));
            LZ4F_freeDecompressionContext(dctx);

            let mut bad_flg = encoded[..header_len].to_vec();
            bad_flg[4] |= 0x02;
            let hc = (xxhash32(&bad_flg[4..header_len - 1], 0) >> 8) as u8;
            bad_flg[header_len - 1] = hc;
            let mut bad_size = bad_flg.len();
            assert_eq!(
                LZ4F_getFrameInfo(
                    LZ4FDecompressionContext(ptr::null_mut()),
                    ptr::null_mut(),
                    ptr::null(),
                    ptr::null_mut(),
                ),
                ERROR_PARAMETER_NULL
            );
            let mut dctx_bad = LZ4FDecompressionContext(ptr::null_mut());
            assert_eq!(
                LZ4F_createDecompressionContext(&mut dctx_bad, LZ4F_VERSION),
                0
            );
            assert_eq!(
                LZ4F_getFrameInfo(dctx_bad, &mut info, bad_flg.as_ptr(), &mut bad_size),
                ERROR_RESERVED_FLAG_SET
            );

            let mut bad_bd = encoded[..header_len].to_vec();
            bad_bd[5] |= 0x01;
            let hc = (xxhash32(&bad_bd[4..header_len - 1], 0) >> 8) as u8;
            bad_bd[header_len - 1] = hc;
            bad_size = bad_bd.len();
            assert_eq!(
                LZ4F_getFrameInfo(dctx_bad, &mut info, bad_bd.as_ptr(), &mut bad_size),
                ERROR_RESERVED_FLAG_SET
            );

            let mut bad_version = encoded[..header_len].to_vec();
            bad_version[4] = (bad_version[4] & !0xC0) | 0x80;
            let hc = (xxhash32(&bad_version[4..header_len - 1], 0) >> 8) as u8;
            bad_version[header_len - 1] = hc;
            bad_size = bad_version.len();
            assert_eq!(
                LZ4F_getFrameInfo(dctx_bad, &mut info, bad_version.as_ptr(), &mut bad_size),
                ERROR_HEADER_VERSION_WRONG
            );
            let mut dst = [0u8; 1];
            let mut dst_size = dst.len();
            let mut src_size = bad_version.len();
            assert_eq!(
                LZ4F_decompress(
                    dctx_bad,
                    dst.as_mut_ptr(),
                    &mut dst_size,
                    bad_version.as_ptr(),
                    &mut src_size,
                    ptr::null(),
                ),
                ERROR_HEADER_VERSION_WRONG
            );

            LZ4F_resetDecompressionContext(dctx_bad);
            let mut bad_block_size = encoded[..header_len].to_vec();
            bad_block_size[5] = (bad_block_size[5] & 0x0f) | (3 << 4);
            let hc = (xxhash32(&bad_block_size[4..header_len - 1], 0) >> 8) as u8;
            bad_block_size[header_len - 1] = hc;
            bad_size = bad_block_size.len();
            assert_eq!(
                LZ4F_getFrameInfo(dctx_bad, &mut info, bad_block_size.as_ptr(), &mut bad_size),
                ERROR_MAX_BLOCK_SIZE_INVALID
            );
            let mut dst_size = dst.len();
            let mut src_size = bad_block_size.len();
            assert_eq!(
                LZ4F_decompress(
                    dctx_bad,
                    dst.as_mut_ptr(),
                    &mut dst_size,
                    bad_block_size.as_ptr(),
                    &mut src_size,
                    ptr::null(),
                ),
                ERROR_MAX_BLOCK_SIZE_INVALID
            );

            LZ4F_resetDecompressionContext(dctx_bad);
            let mut bad_magic = encoded[..header_len].to_vec();
            bad_magic[..4].copy_from_slice(b"bad!");
            bad_size = bad_magic.len();
            assert_eq!(
                LZ4F_getFrameInfo(dctx_bad, &mut info, bad_magic.as_ptr(), &mut bad_size),
                ERROR_FRAME_TYPE_UNKNOWN
            );
            assert_eq!(bad_size, 0);
            let mut dst_size = dst.len();
            let mut src_size = bad_magic.len();
            assert_eq!(
                LZ4F_decompress(
                    dctx_bad,
                    dst.as_mut_ptr(),
                    &mut dst_size,
                    bad_magic.as_ptr(),
                    &mut src_size,
                    ptr::null(),
                ),
                ERROR_FRAME_TYPE_UNKNOWN
            );
            LZ4F_freeDecompressionContext(dctx_bad);
            LZ4F_freeCompressionContext(cctx);
        }
    }

    #[test]
    fn frame_info_errors_zero_consumed_and_preserve_context() {
        unsafe {
            let input = b"context survives bad frame info";
            let prefs = LZ4FPreferences {
                frame_info: LZ4FFrameInfo {
                    block_size_id: BlockSize::Max64KB,
                    block_mode: BlockMode::Independent,
                    content_checksum_flag: ContentChecksum::NoChecksum,
                    frame_type: FrameType::Frame,
                    content_size: input.len() as u64,
                    dict_id: 0,
                    block_checksum_flag: BlockChecksum::NoBlockChecksum,
                },
                compression_level: 0,
                auto_flush: 0,
                favor_dec_speed: 0,
                reserved: [0; 3],
            };
            let mut encoded = vec![0u8; LZ4F_compressBound(input.len(), &prefs) + 32];
            let encoded_len = LZ4F_compressFrame(
                encoded.as_mut_ptr() as *mut c_void,
                encoded.len(),
                input.as_ptr() as *const c_void,
                input.len(),
                &prefs,
            );
            assert_eq!(LZ4F_isError(encoded_len), 0);
            encoded.truncate(encoded_len);

            let mut dctx = LZ4FDecompressionContext(ptr::null_mut());
            assert_eq!(LZ4F_createDecompressionContext(&mut dctx, LZ4F_VERSION), 0);
            let mut info = LZ4FFrameInfo {
                block_size_id: BlockSize::Default,
                block_mode: BlockMode::Linked,
                content_checksum_flag: ContentChecksum::ChecksumEnabled,
                frame_type: FrameType::SkippableFrame,
                content_size: 99,
                dict_id: 99,
                block_checksum_flag: BlockChecksum::BlockChecksumEnabled,
            };
            let mut short_size = 6usize;
            assert_eq!(
                LZ4F_getFrameInfo(dctx, &mut info, encoded.as_ptr(), &mut short_size),
                ERROR_BAD_HEADER
            );
            assert_eq!(short_size, 0);
            assert!(matches!(info.frame_type, FrameType::SkippableFrame));

            let mut consumed = encoded.len();
            assert_eq!(
                LZ4F_getFrameInfo(dctx, &mut info, encoded.as_ptr(), &mut consumed),
                0
            );
            assert_eq!(consumed, 15);

            let mut output = vec![0u8; input.len()];
            let mut src_size = encoded.len() - consumed;
            let mut dst_size = output.len();
            let code = LZ4F_decompress(
                dctx,
                output.as_mut_ptr(),
                &mut dst_size,
                encoded.as_ptr().add(consumed),
                &mut src_size,
                ptr::null(),
            );
            assert_eq!(LZ4F_isError(code), 0);
            assert_eq!(output, input);
            LZ4F_freeDecompressionContext(dctx);
        }
    }

    #[test]
    fn frame_info_rejects_context_after_partial_header_decode_started() {
        unsafe {
            let input = b"partial header get frame info";
            let prefs = LZ4FPreferences {
                frame_info: LZ4FFrameInfo {
                    block_size_id: BlockSize::Max64KB,
                    block_mode: BlockMode::Independent,
                    content_checksum_flag: ContentChecksum::NoChecksum,
                    frame_type: FrameType::Frame,
                    content_size: input.len() as u64,
                    dict_id: 0,
                    block_checksum_flag: BlockChecksum::NoBlockChecksum,
                },
                compression_level: 0,
                auto_flush: 0,
                favor_dec_speed: 0,
                reserved: [0; 3],
            };
            let mut encoded = vec![0u8; LZ4F_compressBound(input.len(), &prefs) + 32];
            let encoded_len = LZ4F_compressFrame(
                encoded.as_mut_ptr() as *mut c_void,
                encoded.len(),
                input.as_ptr() as *const c_void,
                input.len(),
                &prefs,
            );
            assert_eq!(LZ4F_isError(encoded_len), 0);
            encoded.truncate(encoded_len);

            let mut dctx = LZ4FDecompressionContext(ptr::null_mut());
            assert_eq!(LZ4F_createDecompressionContext(&mut dctx, LZ4F_VERSION), 0);
            let mut output = [0u8; 1];
            let mut src_size = 5usize;
            let mut dst_size = output.len();
            let hint = LZ4F_decompress(
                dctx,
                output.as_mut_ptr(),
                &mut dst_size,
                encoded.as_ptr(),
                &mut src_size,
                ptr::null(),
            );
            assert_eq!(LZ4F_isError(hint), 0);
            assert_eq!(src_size, 5);
            assert_eq!(dst_size, 0);

            let mut info = LZ4FFrameInfo {
                block_size_id: BlockSize::Default,
                block_mode: BlockMode::Linked,
                content_checksum_flag: ContentChecksum::ChecksumEnabled,
                frame_type: FrameType::SkippableFrame,
                content_size: 99,
                dict_id: 99,
                block_checksum_flag: BlockChecksum::BlockChecksumEnabled,
            };
            let mut consumed = encoded.len();
            assert_eq!(
                LZ4F_getFrameInfo(dctx, &mut info, encoded.as_ptr(), &mut consumed),
                ERROR_FRAME_DECODING_ALREADY_STARTED
            );
            assert_eq!(consumed, 0);
            assert!(matches!(info.frame_type, FrameType::SkippableFrame));
            LZ4F_freeDecompressionContext(dctx);
        }
    }

    #[test]
    fn frame_using_dict_round_trip_first_independent_block() {
        unsafe {
            let dict = b"abcdefghijklmnop";
            let input = b"abcdefghijklmnop";
            let prefs = LZ4FPreferences {
                frame_info: LZ4FFrameInfo {
                    block_size_id: BlockSize::Max64KB,
                    block_mode: BlockMode::Independent,
                    content_checksum_flag: ContentChecksum::NoChecksum,
                    frame_type: FrameType::Frame,
                    content_size: input.len() as u64,
                    dict_id: 0,
                    block_checksum_flag: BlockChecksum::NoBlockChecksum,
                },
                compression_level: 9,
                auto_flush: 0,
                favor_dec_speed: 0,
                reserved: [0; 3],
            };

            let mut cctx = LZ4FCompressionContext(ptr::null_mut());
            assert_eq!(LZ4F_createCompressionContext(&mut cctx, LZ4F_VERSION), 0);
            let mut encoded = vec![0u8; 256];
            let mut pos = LZ4F_compressBegin_usingDict(
                cctx,
                encoded.as_mut_ptr() as *mut c_void,
                encoded.len(),
                dict.as_ptr() as *const c_void,
                dict.len(),
                &prefs,
            );
            assert_eq!(LZ4F_isError(pos), 0);
            let update_len = LZ4F_compressUpdate(
                cctx,
                encoded.as_mut_ptr().add(pos),
                encoded.len() - pos,
                input.as_ptr(),
                input.len(),
                ptr::null(),
            );
            assert_eq!(LZ4F_isError(update_len), 0);
            let block_header = u32::from_le_bytes(encoded[pos..pos + 4].try_into().unwrap());
            assert_eq!(block_header & 0x8000_0000, 0);
            assert!((block_header as usize) < input.len());
            pos += update_len;
            pos += LZ4F_compressEnd(
                cctx,
                encoded.as_mut_ptr().add(pos),
                encoded.len() - pos,
                ptr::null(),
            );
            encoded.truncate(pos);
            LZ4F_freeCompressionContext(cctx);

            let mut dctx = LZ4FDecompressionContext(ptr::null_mut());
            assert_eq!(LZ4F_createDecompressionContext(&mut dctx, LZ4F_VERSION), 0);
            let mut output = vec![0u8; input.len()];
            let mut dst_size = output.len();
            let mut src_size = encoded.len();
            let code = LZ4F_decompress_usingDict(
                dctx,
                output.as_mut_ptr() as *mut c_void,
                &mut dst_size,
                encoded.as_ptr() as *const c_void,
                &mut src_size,
                dict.as_ptr() as *const c_void,
                dict.len(),
                ptr::null(),
            );
            assert_eq!(LZ4F_isError(code), 0);
            assert_eq!(dst_size, input.len());
            assert_eq!(output, input);
            LZ4F_freeDecompressionContext(dctx);
        }
    }

    #[test]
    fn frame_cdict_round_trip() {
        unsafe {
            let dict = b"abcdefghijklmnop";
            let input = b"abcdefghijklmnop";
            let cdict = LZ4F_createCDict(dict.as_ptr() as *const c_void, dict.len());
            assert!(!cdict.is_null());
            let prefs = LZ4FPreferences {
                frame_info: LZ4FFrameInfo {
                    block_size_id: BlockSize::Max64KB,
                    block_mode: BlockMode::Independent,
                    content_checksum_flag: ContentChecksum::NoChecksum,
                    frame_type: FrameType::Frame,
                    content_size: input.len() as u64,
                    dict_id: 0,
                    block_checksum_flag: BlockChecksum::NoBlockChecksum,
                },
                compression_level: 9,
                auto_flush: 0,
                favor_dec_speed: 0,
                reserved: [0; 3],
            };

            let mut cctx = LZ4FCompressionContext(ptr::null_mut());
            assert_eq!(LZ4F_createCompressionContext(&mut cctx, LZ4F_VERSION), 0);
            let mut encoded = vec![0u8; 256];
            let encoded_len = LZ4F_compressFrame_usingCDict(
                cctx,
                encoded.as_mut_ptr() as *mut c_void,
                encoded.len(),
                input.as_ptr() as *const c_void,
                input.len(),
                cdict,
                &prefs,
            );
            assert_eq!(LZ4F_isError(encoded_len), 0);
            encoded.truncate(encoded_len);
            LZ4F_freeCompressionContext(cctx);
            LZ4F_freeCDict(cdict);

            let mut dctx = LZ4FDecompressionContext(ptr::null_mut());
            assert_eq!(LZ4F_createDecompressionContext(&mut dctx, LZ4F_VERSION), 0);
            let mut output = vec![0u8; input.len()];
            let mut dst_size = output.len();
            let mut src_size = encoded.len();
            let code = LZ4F_decompress_usingDict(
                dctx,
                output.as_mut_ptr() as *mut c_void,
                &mut dst_size,
                encoded.as_ptr() as *const c_void,
                &mut src_size,
                dict.as_ptr() as *const c_void,
                dict.len(),
                ptr::null(),
            );
            assert_eq!(LZ4F_isError(code), 0);
            assert_eq!(dst_size, input.len());
            assert_eq!(output, input);
            LZ4F_freeDecompressionContext(dctx);
        }
    }

    #[test]
    fn frame_skippable_frame_is_skipped() {
        unsafe {
            let mut skippable = Vec::new();
            skippable.extend_from_slice(&LZ4F_SKIPPABLE_MAGIC_MIN.to_le_bytes());
            skippable.extend_from_slice(&5u32.to_le_bytes());
            skippable.extend_from_slice(b"abcde");

            let mut dctx_info = LZ4FDecompressionContext(ptr::null_mut());
            assert_eq!(
                LZ4F_createDecompressionContext(&mut dctx_info, LZ4F_VERSION),
                0
            );
            let mut info = LZ4FFrameInfo {
                block_size_id: BlockSize::Default,
                block_mode: BlockMode::Independent,
                content_checksum_flag: ContentChecksum::NoChecksum,
                frame_type: FrameType::Frame,
                content_size: 0,
                dict_id: 0,
                block_checksum_flag: BlockChecksum::NoBlockChecksum,
            };
            let mut info_src_size = skippable.len();
            assert_eq!(
                LZ4F_getFrameInfo(dctx_info, &mut info, skippable.as_ptr(), &mut info_src_size),
                0
            );
            assert!(matches!(info.frame_type, FrameType::SkippableFrame));
            assert_eq!(info_src_size, skippable.len());
            LZ4F_freeDecompressionContext(dctx_info);

            let mut dctx = LZ4FDecompressionContext(ptr::null_mut());
            assert_eq!(LZ4F_createDecompressionContext(&mut dctx, LZ4F_VERSION), 0);
            let mut output = [0u8; 1];
            let mut dst_size = output.len();
            let mut src_size = skippable.len();
            let code = LZ4F_decompress(
                dctx,
                output.as_mut_ptr(),
                &mut dst_size,
                skippable.as_ptr(),
                &mut src_size,
                ptr::null(),
            );
            assert_eq!(code, 0);
            assert_eq!(dst_size, 0);
            assert_eq!(src_size, skippable.len());
            LZ4F_freeDecompressionContext(dctx);
        }
    }

    #[test]
    fn frame_info_consumes_header_for_subsequent_decompress() {
        unsafe {
            let input = patterned_hc_input(96 * 1024);
            let prefs = LZ4FPreferences {
                frame_info: LZ4FFrameInfo {
                    block_size_id: BlockSize::Max64KB,
                    block_mode: BlockMode::Independent,
                    content_checksum_flag: ContentChecksum::ChecksumEnabled,
                    frame_type: FrameType::Frame,
                    content_size: input.len() as u64,
                    dict_id: 0xfeed_beef,
                    block_checksum_flag: BlockChecksum::NoBlockChecksum,
                },
                compression_level: 0,
                auto_flush: 0,
                favor_dec_speed: 0,
                reserved: [0; 3],
            };
            let mut encoded = vec![0u8; LZ4F_compressBound(input.len(), &prefs) + 32];
            let encoded_len = LZ4F_compressFrame(
                encoded.as_mut_ptr() as *mut c_void,
                encoded.len(),
                input.as_ptr() as *const c_void,
                input.len(),
                &prefs,
            );
            assert_eq!(LZ4F_isError(encoded_len), 0);
            encoded.truncate(encoded_len);

            let mut dctx = LZ4FDecompressionContext(ptr::null_mut());
            assert_eq!(LZ4F_createDecompressionContext(&mut dctx, LZ4F_VERSION), 0);
            let mut info = LZ4FFrameInfo {
                block_size_id: BlockSize::Default,
                block_mode: BlockMode::Linked,
                content_checksum_flag: ContentChecksum::NoChecksum,
                frame_type: FrameType::SkippableFrame,
                content_size: 1,
                dict_id: 123,
                block_checksum_flag: BlockChecksum::BlockChecksumEnabled,
            };
            let mut consumed = encoded.len();
            assert_eq!(
                LZ4F_getFrameInfo(dctx, &mut info, encoded.as_ptr(), &mut consumed),
                0
            );
            assert_eq!(consumed, 19);
            assert!(matches!(info.frame_type, FrameType::Frame));
            assert!(matches!(info.block_size_id, BlockSize::Max64KB));
            assert_eq!(info.content_size, input.len() as u64);
            assert_eq!(info.dict_id, 0xfeed_beef);

            let mut second_consumed = 123usize;
            let second_hint = LZ4F_getFrameInfo(dctx, &mut info, ptr::null(), &mut second_consumed);
            assert_eq!(LZ4F_isError(second_hint), 0);
            assert_eq!(second_consumed, 0);
            assert_eq!(second_hint, 4);
            assert_eq!(info.content_size, input.len() as u64);
            assert_eq!(info.dict_id, 0xfeed_beef);

            let mut output = vec![0u8; input.len()];
            let mut src_offset = consumed;
            let mut dst_offset = 0usize;
            loop {
                let mut src_size = encoded.len() - src_offset;
                let mut dst_size = output.len() - dst_offset;
                let code = LZ4F_decompress(
                    dctx,
                    output[dst_offset..].as_mut_ptr(),
                    &mut dst_size,
                    encoded.as_ptr().add(src_offset),
                    &mut src_size,
                    ptr::null(),
                );
                assert_eq!(LZ4F_isError(code), 0);
                src_offset += src_size;
                dst_offset += dst_size;
                if code == 0 {
                    break;
                }
            }
            assert_eq!(src_offset, encoded.len());
            assert_eq!(output, input);
            LZ4F_freeDecompressionContext(dctx);
        }
    }

    #[test]
    fn frame_info_reports_state_after_partial_decode_and_reset() {
        unsafe {
            let input = patterned_hc_input(80 * 1024);
            let prefs = LZ4FPreferences {
                frame_info: LZ4FFrameInfo {
                    block_size_id: BlockSize::Max64KB,
                    block_mode: BlockMode::Linked,
                    content_checksum_flag: ContentChecksum::ChecksumEnabled,
                    frame_type: FrameType::Frame,
                    content_size: input.len() as u64,
                    dict_id: 0x0102_0304,
                    block_checksum_flag: BlockChecksum::NoBlockChecksum,
                },
                compression_level: 0,
                auto_flush: 0,
                favor_dec_speed: 0,
                reserved: [0; 3],
            };
            let mut encoded = vec![0u8; LZ4F_compressBound(input.len(), &prefs) + 32];
            let encoded_len = LZ4F_compressFrame(
                encoded.as_mut_ptr() as *mut c_void,
                encoded.len(),
                input.as_ptr() as *const c_void,
                input.len(),
                &prefs,
            );
            assert_eq!(LZ4F_isError(encoded_len), 0);
            encoded.truncate(encoded_len);

            let mut dctx = LZ4FDecompressionContext(ptr::null_mut());
            assert_eq!(LZ4F_createDecompressionContext(&mut dctx, LZ4F_VERSION), 0);
            let mut info = LZ4FFrameInfo {
                block_size_id: BlockSize::Default,
                block_mode: BlockMode::Independent,
                content_checksum_flag: ContentChecksum::NoChecksum,
                frame_type: FrameType::SkippableFrame,
                content_size: 0,
                dict_id: 0,
                block_checksum_flag: BlockChecksum::NoBlockChecksum,
            };
            let mut consumed = encoded.len();
            assert_eq!(
                LZ4F_getFrameInfo(dctx, &mut info, encoded.as_ptr(), &mut consumed),
                0
            );
            assert_eq!(consumed, 19);
            assert!(matches!(info.block_mode, BlockMode::Linked));
            assert_eq!(info.content_size, input.len() as u64);
            assert_eq!(info.dict_id, 0x0102_0304);

            let options = LZ4FDecompressOptions {
                stable_dst: 1,
                skipChecksums: 0,
                reserved: [0; 2],
            };
            let mut output = [0u8; 37];
            let mut src_size = encoded.len() - consumed;
            let mut dst_size = output.len();
            let hint = LZ4F_decompress(
                dctx,
                output.as_mut_ptr(),
                &mut dst_size,
                encoded.as_ptr().add(consumed),
                &mut src_size,
                &options,
            );
            assert_eq!(LZ4F_isError(hint), 0);
            assert_eq!(dst_size, output.len());

            let mut second_consumed = usize::MAX;
            let second_hint = LZ4F_getFrameInfo(dctx, &mut info, ptr::null(), &mut second_consumed);
            assert_eq!(LZ4F_isError(second_hint), 0);
            assert_eq!(second_consumed, 0);
            assert!(matches!(info.block_mode, BlockMode::Linked));
            assert_eq!(info.content_size, input.len() as u64);
            assert_eq!(info.dict_id, 0x0102_0304);

            LZ4F_resetDecompressionContext(dctx);
            second_consumed = usize::MAX;
            assert_eq!(
                LZ4F_getFrameInfo(dctx, &mut info, ptr::null(), &mut second_consumed),
                ERROR_SRC_PTR_WRONG
            );
            assert_eq!(second_consumed, 0);
            LZ4F_freeDecompressionContext(dctx);
        }
    }

    #[test]
    fn frame_dict_id_decodes_from_upstream_generated_fixture() {
        unsafe {
            let encoded = decode_hex(
                "04224d186d401b00000000000000adfbcadeba1b0000806672616d65207769746820757073747265616d206469637420696400000000af334300",
            );
            let expected = b"frame with upstream dict id";
            let mut dctx = LZ4FDecompressionContext(ptr::null_mut());
            assert_eq!(LZ4F_createDecompressionContext(&mut dctx, LZ4F_VERSION), 0);
            let mut info = LZ4FFrameInfo {
                block_size_id: BlockSize::Default,
                block_mode: BlockMode::Linked,
                content_checksum_flag: ContentChecksum::NoChecksum,
                frame_type: FrameType::SkippableFrame,
                content_size: 0,
                dict_id: 0,
                block_checksum_flag: BlockChecksum::BlockChecksumEnabled,
            };
            let mut consumed = encoded.len();
            assert_eq!(
                LZ4F_getFrameInfo(dctx, &mut info, encoded.as_ptr(), &mut consumed),
                0
            );
            assert_eq!(consumed, 19);
            assert!(matches!(info.block_size_id, BlockSize::Max64KB));
            assert!(matches!(info.block_mode, BlockMode::Independent));
            assert!(matches!(
                info.content_checksum_flag,
                ContentChecksum::ChecksumEnabled
            ));
            assert_eq!(info.content_size, expected.len() as u64);
            assert_eq!(info.dict_id, 0xdecafbad);

            let mut output = vec![0u8; expected.len()];
            let mut src_offset = consumed;
            let mut dst_offset = 0usize;
            loop {
                let mut src_size = encoded.len() - src_offset;
                let mut dst_size = output.len() - dst_offset;
                let code = LZ4F_decompress(
                    dctx,
                    output[dst_offset..].as_mut_ptr(),
                    &mut dst_size,
                    encoded.as_ptr().add(src_offset),
                    &mut src_size,
                    ptr::null(),
                );
                assert_eq!(LZ4F_isError(code), 0);
                src_offset += src_size;
                dst_offset += dst_size;
                if code == 0 {
                    break;
                }
            }
            assert_eq!(src_offset, encoded.len());
            assert_eq!(dst_offset, expected.len());
            assert_eq!(output, expected);
            LZ4F_freeDecompressionContext(dctx);
        }
    }

    #[test]
    fn frame_decompress_resets_context_after_complete_frame() {
        unsafe {
            let first = b"first complete frame";
            let second = b"second complete frame";
            let prefs = LZ4FPreferences {
                frame_info: LZ4FFrameInfo {
                    block_size_id: BlockSize::Max64KB,
                    block_mode: BlockMode::Independent,
                    content_checksum_flag: ContentChecksum::NoChecksum,
                    frame_type: FrameType::Frame,
                    content_size: 0,
                    dict_id: 0,
                    block_checksum_flag: BlockChecksum::NoBlockChecksum,
                },
                compression_level: 0,
                auto_flush: 0,
                favor_dec_speed: 0,
                reserved: [0; 3],
            };
            let mut first_frame = vec![0u8; LZ4F_compressBound(first.len(), &prefs) + 32];
            let first_len = LZ4F_compressFrame(
                first_frame.as_mut_ptr() as *mut c_void,
                first_frame.len(),
                first.as_ptr() as *const c_void,
                first.len(),
                &prefs,
            );
            assert_eq!(LZ4F_isError(first_len), 0);
            first_frame.truncate(first_len);

            let mut second_frame = vec![0u8; LZ4F_compressBound(second.len(), &prefs) + 32];
            let second_len = LZ4F_compressFrame(
                second_frame.as_mut_ptr() as *mut c_void,
                second_frame.len(),
                second.as_ptr() as *const c_void,
                second.len(),
                &prefs,
            );
            assert_eq!(LZ4F_isError(second_len), 0);
            second_frame.truncate(second_len);

            let mut concatenated = first_frame.clone();
            concatenated.extend_from_slice(&second_frame);

            let mut dctx = LZ4FDecompressionContext(ptr::null_mut());
            assert_eq!(LZ4F_createDecompressionContext(&mut dctx, LZ4F_VERSION), 0);
            let mut output = vec![0u8; first.len()];
            let mut src_offset = 0usize;
            let mut dst_offset = 0usize;
            loop {
                let mut src_size = first_frame.len() - src_offset;
                let mut dst_size = output.len() - dst_offset;
                let code = LZ4F_decompress(
                    dctx,
                    output[dst_offset..].as_mut_ptr(),
                    &mut dst_size,
                    concatenated.as_ptr().add(src_offset),
                    &mut src_size,
                    ptr::null(),
                );
                assert_eq!(LZ4F_isError(code), 0);
                src_offset += src_size;
                dst_offset += dst_size;
                if code == 0 {
                    break;
                }
            }
            assert_eq!(src_offset, first_frame.len());
            assert_eq!(output, first);

            let mut info = LZ4FFrameInfo {
                block_size_id: BlockSize::Default,
                block_mode: BlockMode::Linked,
                content_checksum_flag: ContentChecksum::ChecksumEnabled,
                frame_type: FrameType::SkippableFrame,
                content_size: 1,
                dict_id: 1,
                block_checksum_flag: BlockChecksum::BlockChecksumEnabled,
            };
            let mut consumed = usize::MAX;
            assert_eq!(
                LZ4F_getFrameInfo(dctx, &mut info, ptr::null(), &mut consumed),
                ERROR_SRC_PTR_WRONG
            );
            assert_eq!(consumed, 0);

            let mut output = vec![0u8; second.len()];
            src_offset = first_frame.len();
            let mut dst_offset = 0usize;
            loop {
                let mut src_size = concatenated.len() - src_offset;
                let mut dst_size = output.len() - dst_offset;
                let code = LZ4F_decompress(
                    dctx,
                    output[dst_offset..].as_mut_ptr(),
                    &mut dst_size,
                    concatenated.as_ptr().add(src_offset),
                    &mut src_size,
                    ptr::null(),
                );
                assert_eq!(LZ4F_isError(code), 0);
                src_offset += src_size;
                dst_offset += dst_size;
                if code == 0 {
                    break;
                }
            }
            assert_eq!(src_offset, concatenated.len());
            assert_eq!(output, second);
            LZ4F_freeDecompressionContext(dctx);
        }
    }

    #[test]
    fn frame_free_decompression_context_reports_incomplete_frame() {
        unsafe {
            let input = b"incomplete frame free status";
            let prefs = LZ4FPreferences {
                frame_info: LZ4FFrameInfo {
                    block_size_id: BlockSize::Max64KB,
                    block_mode: BlockMode::Independent,
                    content_checksum_flag: ContentChecksum::NoChecksum,
                    frame_type: FrameType::Frame,
                    content_size: 0,
                    dict_id: 0,
                    block_checksum_flag: BlockChecksum::NoBlockChecksum,
                },
                compression_level: 0,
                auto_flush: 0,
                favor_dec_speed: 0,
                reserved: [0; 3],
            };
            let mut frame = vec![0u8; LZ4F_compressBound(input.len(), &prefs)];
            let frame_len = LZ4F_compressFrame(
                frame.as_mut_ptr() as *mut c_void,
                frame.len(),
                input.as_ptr() as *const c_void,
                input.len(),
                &prefs,
            );
            assert_eq!(LZ4F_isError(frame_len), 0);
            frame.truncate(frame_len);

            let mut dctx = LZ4FDecompressionContext(ptr::null_mut());
            assert_eq!(LZ4F_createDecompressionContext(&mut dctx, LZ4F_VERSION), 0);
            assert_eq!(LZ4F_freeDecompressionContext(dctx), 0);

            assert_eq!(LZ4F_createDecompressionContext(&mut dctx, LZ4F_VERSION), 0);
            let mut info = LZ4FFrameInfo {
                block_size_id: BlockSize::Default,
                block_mode: BlockMode::Linked,
                content_checksum_flag: ContentChecksum::NoChecksum,
                frame_type: FrameType::Frame,
                content_size: 0,
                dict_id: 0,
                block_checksum_flag: BlockChecksum::NoBlockChecksum,
            };
            let mut consumed = frame.len();
            let info_code = LZ4F_getFrameInfo(dctx, &mut info, frame.as_ptr(), &mut consumed);
            assert_eq!(LZ4F_isError(info_code), 0);
            assert!(consumed > 0);
            assert_ne!(LZ4F_freeDecompressionContext(dctx), 0);

            assert_eq!(LZ4F_createDecompressionContext(&mut dctx, LZ4F_VERSION), 0);
            let mut output = vec![0u8; input.len()];
            let mut src_size = frame.len();
            let mut dst_size = output.len();
            let code = LZ4F_decompress(
                dctx,
                output.as_mut_ptr(),
                &mut dst_size,
                frame.as_ptr(),
                &mut src_size,
                ptr::null(),
            );
            assert_eq!(code, 0);
            assert_eq!(output, input);
            assert_eq!(LZ4F_freeDecompressionContext(dctx), 0);
        }
    }

    #[test]
    fn frame_update_compresses_blocks_when_level_is_set() {
        unsafe {
            let mut cctx = LZ4FCompressionContext(ptr::null_mut());
            assert_eq!(LZ4F_createCompressionContext(&mut cctx, LZ4F_VERSION), 0);
            let prefs = LZ4FPreferences {
                frame_info: LZ4FFrameInfo {
                    block_size_id: BlockSize::Max64KB,
                    block_mode: BlockMode::Independent,
                    content_checksum_flag: ContentChecksum::NoChecksum,
                    frame_type: FrameType::Frame,
                    content_size: 0,
                    dict_id: 0,
                    block_checksum_flag: BlockChecksum::NoBlockChecksum,
                },
                compression_level: 9,
                auto_flush: 0,
                favor_dec_speed: 0,
                reserved: [0; 3],
            };
            let input = vec![b'a'; 16 * 1024];
            let mut encoded = vec![0u8; LZ4F_compressBound(input.len(), &prefs) + 32];
            let header_len = LZ4F_compressBegin(cctx, encoded.as_mut_ptr(), encoded.len(), &prefs);
            assert!(!LZ4F_isError(header_len).eq(&1));
            let update_len = LZ4F_compressUpdate(
                cctx,
                encoded.as_mut_ptr().add(header_len),
                encoded.len() - header_len,
                input.as_ptr(),
                input.len(),
                ptr::null(),
            );
            assert!(!LZ4F_isError(update_len).eq(&1));
            let block_header =
                u32::from_le_bytes(encoded[header_len..header_len + 4].try_into().unwrap());
            assert_eq!(block_header & 0x8000_0000, 0);
            assert!((block_header as usize) < input.len());

            let end_len = LZ4F_compressEnd(
                cctx,
                encoded.as_mut_ptr().add(header_len + update_len),
                encoded.len() - header_len - update_len,
                ptr::null(),
            );
            assert!(!LZ4F_isError(end_len).eq(&1));
            encoded.truncate(header_len + update_len + end_len);
            LZ4F_freeCompressionContext(cctx);

            let mut dctx = LZ4FDecompressionContext(ptr::null_mut());
            assert_eq!(LZ4F_createDecompressionContext(&mut dctx, LZ4F_VERSION), 0);
            let mut output = vec![0u8; input.len()];
            let mut src_size = encoded.len();
            let mut dst_size = output.len();
            let code = LZ4F_decompress(
                dctx,
                output.as_mut_ptr(),
                &mut dst_size,
                encoded.as_ptr(),
                &mut src_size,
                ptr::null(),
            );
            assert!(!LZ4F_isError(code).eq(&1));
            assert_eq!(dst_size, input.len());
            assert_eq!(output, input);
            LZ4F_freeDecompressionContext(dctx);
        }
    }

    #[test]
    fn frame_update_multiblock_dst_too_small_returns_error() {
        unsafe {
            let mut cctx = LZ4FCompressionContext(ptr::null_mut());
            assert_eq!(LZ4F_createCompressionContext(&mut cctx, LZ4F_VERSION), 0);
            let prefs = LZ4FPreferences {
                frame_info: LZ4FFrameInfo {
                    block_size_id: BlockSize::Max64KB,
                    block_mode: BlockMode::Independent,
                    content_checksum_flag: ContentChecksum::NoChecksum,
                    frame_type: FrameType::Frame,
                    content_size: 0,
                    dict_id: 0,
                    block_checksum_flag: BlockChecksum::NoBlockChecksum,
                },
                compression_level: 0,
                auto_flush: 0,
                favor_dec_speed: 0,
                reserved: [0; 3],
            };
            let input = vec![0x5au8; 128 * 1024];
            let mut output = vec![0u8; 16];
            assert_eq!(
                LZ4F_compressBegin(cctx, output.as_mut_ptr(), output.len(), &prefs),
                7
            );
            let code = LZ4F_compressUpdate(
                cctx,
                output.as_mut_ptr(),
                output.len(),
                input.as_ptr(),
                input.len(),
                ptr::null(),
            );
            assert_eq!(code, ERROR_DST_TOO_SMALL);
            LZ4F_freeCompressionContext(cctx);
        }
    }

    #[test]
    fn frame_update_buffers_partial_block_until_flush_or_end() {
        unsafe {
            let mut cctx = LZ4FCompressionContext(ptr::null_mut());
            assert_eq!(LZ4F_createCompressionContext(&mut cctx, LZ4F_VERSION), 0);
            let prefs = LZ4FPreferences {
                frame_info: LZ4FFrameInfo {
                    block_size_id: BlockSize::Max64KB,
                    block_mode: BlockMode::Independent,
                    content_checksum_flag: ContentChecksum::NoChecksum,
                    frame_type: FrameType::Frame,
                    content_size: 0,
                    dict_id: 0,
                    block_checksum_flag: BlockChecksum::NoBlockChecksum,
                },
                compression_level: 0,
                auto_flush: 0,
                favor_dec_speed: 0,
                reserved: [0; 3],
            };
            let input = b"buffered partial frame block";
            let mut encoded = vec![0u8; LZ4F_compressBound(input.len(), &prefs) + 32];
            let mut pos = LZ4F_compressBegin(cctx, encoded.as_mut_ptr(), encoded.len(), &prefs);
            let update_len = LZ4F_compressUpdate(
                cctx,
                encoded.as_mut_ptr().add(pos),
                encoded.len() - pos,
                input.as_ptr(),
                input.len(),
                ptr::null(),
            );
            assert_eq!(update_len, 0);
            let flush_len = LZ4F_flush(
                cctx,
                encoded.as_mut_ptr().add(pos),
                encoded.len() - pos,
                ptr::null(),
            );
            assert_eq!(LZ4F_isError(flush_len), 0);
            assert!(flush_len > 4);
            pos += flush_len;
            let end_len = LZ4F_compressEnd(
                cctx,
                encoded.as_mut_ptr().add(pos),
                encoded.len() - pos,
                ptr::null(),
            );
            assert_eq!(end_len, 4);
            pos += end_len;
            encoded.truncate(pos);
            LZ4F_freeCompressionContext(cctx);

            let decoded = decode_frame_once(&encoded, input.len());
            assert_eq!(decoded, input);
        }
    }

    #[test]
    fn frame_compress_end_flushes_buffered_partial_block() {
        unsafe {
            let mut cctx = LZ4FCompressionContext(ptr::null_mut());
            assert_eq!(LZ4F_createCompressionContext(&mut cctx, LZ4F_VERSION), 0);
            let prefs = LZ4FPreferences {
                frame_info: LZ4FFrameInfo {
                    block_size_id: BlockSize::Max64KB,
                    block_mode: BlockMode::Independent,
                    content_checksum_flag: ContentChecksum::NoChecksum,
                    frame_type: FrameType::Frame,
                    content_size: 0,
                    dict_id: 0,
                    block_checksum_flag: BlockChecksum::NoBlockChecksum,
                },
                compression_level: 0,
                auto_flush: 0,
                favor_dec_speed: 0,
                reserved: [0; 3],
            };
            let input = b"finish flushes this tail";
            let mut encoded = vec![0u8; LZ4F_compressBound(input.len(), &prefs) + 32];
            let mut pos = LZ4F_compressBegin(cctx, encoded.as_mut_ptr(), encoded.len(), &prefs);
            assert_eq!(
                LZ4F_compressUpdate(
                    cctx,
                    encoded.as_mut_ptr().add(pos),
                    encoded.len() - pos,
                    input.as_ptr(),
                    input.len(),
                    ptr::null(),
                ),
                0
            );
            let end_len = LZ4F_compressEnd(
                cctx,
                encoded.as_mut_ptr().add(pos),
                encoded.len() - pos,
                ptr::null(),
            );
            assert_eq!(LZ4F_isError(end_len), 0);
            assert!(end_len > 4);
            pos += end_len;
            encoded.truncate(pos);
            LZ4F_freeCompressionContext(cctx);

            let decoded = decode_frame_once(&encoded, input.len());
            assert_eq!(decoded, input);
        }
    }

    #[test]
    fn frame_compress_end_rejects_declared_content_size_mismatch() {
        unsafe {
            let mut cctx = LZ4FCompressionContext(ptr::null_mut());
            assert_eq!(LZ4F_createCompressionContext(&mut cctx, LZ4F_VERSION), 0);
            let input = b"short";
            let prefs = LZ4FPreferences {
                frame_info: LZ4FFrameInfo {
                    block_size_id: BlockSize::Max64KB,
                    block_mode: BlockMode::Independent,
                    content_checksum_flag: ContentChecksum::NoChecksum,
                    frame_type: FrameType::Frame,
                    content_size: input.len() as u64 + 1,
                    dict_id: 0,
                    block_checksum_flag: BlockChecksum::NoBlockChecksum,
                },
                compression_level: 0,
                auto_flush: 0,
                favor_dec_speed: 0,
                reserved: [0; 3],
            };
            let mut output = vec![0u8; LZ4F_compressBound(input.len(), &prefs) + 32];
            let mut pos = LZ4F_compressBegin(cctx, output.as_mut_ptr(), output.len(), &prefs);
            assert_eq!(LZ4F_isError(pos), 0);
            let update_len = LZ4F_compressUpdate(
                cctx,
                output.as_mut_ptr().add(pos),
                output.len() - pos,
                input.as_ptr(),
                input.len(),
                ptr::null(),
            );
            assert_eq!(update_len, 0);
            pos += update_len;
            assert_eq!(
                LZ4F_compressEnd(
                    cctx,
                    output.as_mut_ptr().add(pos),
                    output.len() - pos,
                    ptr::null(),
                ),
                ERROR_FRAME_SIZE_WRONG
            );
            LZ4F_freeCompressionContext(cctx);
        }
    }

    #[test]
    fn frame_compress_frame_corrects_nonzero_declared_content_size() {
        unsafe {
            let input = b"actual content size";
            let mut prefs = LZ4FPreferences {
                frame_info: LZ4FFrameInfo {
                    block_size_id: BlockSize::Max64KB,
                    block_mode: BlockMode::Independent,
                    content_checksum_flag: ContentChecksum::NoChecksum,
                    frame_type: FrameType::Frame,
                    content_size: input.len() as u64 + 100,
                    dict_id: 0,
                    block_checksum_flag: BlockChecksum::NoBlockChecksum,
                },
                compression_level: 0,
                auto_flush: 0,
                favor_dec_speed: 0,
                reserved: [0; 3],
            };
            let mut encoded = vec![0u8; LZ4F_compressFrameBound(input.len(), &prefs)];
            let encoded_len = LZ4F_compressFrame(
                encoded.as_mut_ptr() as *mut c_void,
                encoded.len(),
                input.as_ptr() as *const c_void,
                input.len(),
                &prefs,
            );
            assert_eq!(LZ4F_isError(encoded_len), 0);
            encoded.truncate(encoded_len);
            assert_eq!(decode_frame_once(&encoded, input.len()), input);

            let mut dctx = LZ4FDecompressionContext(ptr::null_mut());
            assert_eq!(LZ4F_createDecompressionContext(&mut dctx, LZ4F_VERSION), 0);
            prefs.frame_info.content_size = 0;
            let mut info = prefs.frame_info;
            let mut src_size = encoded.len();
            assert_eq!(
                LZ4F_getFrameInfo(dctx, &mut info, encoded.as_ptr(), &mut src_size),
                0
            );
            assert_eq!(info.content_size, input.len() as u64);
            LZ4F_freeDecompressionContext(dctx);
        }
    }

    #[test]
    fn frame_linked_blocks_use_previous_block_history() {
        unsafe {
            let mut cctx = LZ4FCompressionContext(ptr::null_mut());
            assert_eq!(LZ4F_createCompressionContext(&mut cctx, LZ4F_VERSION), 0);
            let prefs = LZ4FPreferences {
                frame_info: LZ4FFrameInfo {
                    block_size_id: BlockSize::Max64KB,
                    block_mode: BlockMode::Linked,
                    content_checksum_flag: ContentChecksum::NoChecksum,
                    frame_type: FrameType::Frame,
                    content_size: 0,
                    dict_id: 0,
                    block_checksum_flag: BlockChecksum::NoBlockChecksum,
                },
                compression_level: 9,
                auto_flush: 0,
                favor_dec_speed: 0,
                reserved: [0; 3],
            };
            let first = b"abcdefghijklmnop";
            let second = b"abcdefghijklmnop";
            let mut encoded = vec![0u8; 256];
            let mut pos = LZ4F_compressBegin(cctx, encoded.as_mut_ptr(), encoded.len(), &prefs);

            let mut dctx_info = LZ4FDecompressionContext(ptr::null_mut());
            assert_eq!(
                LZ4F_createDecompressionContext(&mut dctx_info, LZ4F_VERSION),
                0
            );
            let mut info = LZ4FFrameInfo {
                block_size_id: BlockSize::Default,
                block_mode: BlockMode::Independent,
                content_checksum_flag: ContentChecksum::NoChecksum,
                frame_type: FrameType::Frame,
                content_size: 0,
                dict_id: 0,
                block_checksum_flag: BlockChecksum::NoBlockChecksum,
            };
            let mut header_size = pos;
            assert_eq!(
                LZ4F_getFrameInfo(dctx_info, &mut info, encoded.as_ptr(), &mut header_size),
                0
            );
            assert!(matches!(info.block_mode, BlockMode::Linked));
            LZ4F_freeDecompressionContext(dctx_info);

            pos += LZ4F_compressUpdate(
                cctx,
                encoded.as_mut_ptr().add(pos),
                encoded.len() - pos,
                first.as_ptr(),
                first.len(),
                ptr::null(),
            );
            let second_block_at = pos;
            let second_len = LZ4F_compressUpdate(
                cctx,
                encoded.as_mut_ptr().add(pos),
                encoded.len() - pos,
                second.as_ptr(),
                second.len(),
                ptr::null(),
            );
            pos += second_len;
            let second_header = u32::from_le_bytes(
                encoded[second_block_at..second_block_at + 4]
                    .try_into()
                    .unwrap(),
            );
            assert_eq!(second_header & 0x8000_0000, 0);
            assert!((second_header as usize) < second.len() + 1);
            pos += LZ4F_compressEnd(
                cctx,
                encoded.as_mut_ptr().add(pos),
                encoded.len() - pos,
                ptr::null(),
            );
            encoded.truncate(pos);
            LZ4F_freeCompressionContext(cctx);

            let mut dctx = LZ4FDecompressionContext(ptr::null_mut());
            assert_eq!(LZ4F_createDecompressionContext(&mut dctx, LZ4F_VERSION), 0);
            let mut output = vec![0u8; first.len() + second.len()];
            let mut src_offset = 0usize;
            let mut dst_offset = 0usize;
            loop {
                let mut src_size = encoded.len() - src_offset;
                let mut dst_size = output.len() - dst_offset;
                let code = LZ4F_decompress(
                    dctx,
                    output[dst_offset..].as_mut_ptr(),
                    &mut dst_size,
                    encoded.as_ptr().add(src_offset),
                    &mut src_size,
                    ptr::null(),
                );
                assert_eq!(LZ4F_isError(code), 0);
                src_offset += src_size;
                dst_offset += dst_size;
                if code == 0 {
                    break;
                }
            }
            assert_eq!(dst_offset, output.len());
            assert_eq!(&output[..first.len()], first);
            assert_eq!(&output[first.len()..], second);
            LZ4F_freeDecompressionContext(dctx);
        }
    }

    #[test]
    fn frame_decompress_rejects_bad_checksums() {
        unsafe {
            let mut cctx = LZ4FCompressionContext(ptr::null_mut());
            assert_eq!(LZ4F_createCompressionContext(&mut cctx, LZ4F_VERSION), 0);
            let prefs = LZ4FPreferences {
                frame_info: LZ4FFrameInfo {
                    block_size_id: BlockSize::Max64KB,
                    block_mode: BlockMode::Independent,
                    content_checksum_flag: ContentChecksum::ChecksumEnabled,
                    frame_type: FrameType::Frame,
                    content_size: 0,
                    dict_id: 0,
                    block_checksum_flag: BlockChecksum::BlockChecksumEnabled,
                },
                compression_level: 9,
                auto_flush: 0,
                favor_dec_speed: 0,
                reserved: [0; 3],
            };
            let input = b"checksum data ".repeat(1024);
            let mut encoded = vec![0u8; LZ4F_compressBound(input.len(), &prefs) + 32];
            let header_len = LZ4F_compressBegin(cctx, encoded.as_mut_ptr(), encoded.len(), &prefs);
            let update_len = LZ4F_compressUpdate(
                cctx,
                encoded.as_mut_ptr().add(header_len),
                encoded.len() - header_len,
                input.as_ptr(),
                input.len(),
                ptr::null(),
            );
            let end_len = LZ4F_compressEnd(
                cctx,
                encoded.as_mut_ptr().add(header_len + update_len),
                encoded.len() - header_len - update_len,
                ptr::null(),
            );
            encoded.truncate(header_len + update_len + end_len);
            LZ4F_freeCompressionContext(cctx);

            let mut bad_block = encoded.clone();
            let block_len =
                (u32::from_le_bytes(bad_block[header_len..header_len + 4].try_into().unwrap())
                    & 0x7FFF_FFFF) as usize;
            bad_block[header_len + 4 + block_len] ^= 0x80;
            assert_corrupt_frame_fails("block checksum", &bad_block, input.len());
            assert_corrupt_frame_decodes_with_skip_checksums("block checksum", &bad_block, &input);
            assert_corrupt_frame_decodes_with_sticky_skip_checksums(
                "block checksum",
                &bad_block,
                &input,
                header_len,
            );

            let mut bad_content = encoded;
            let last = bad_content.len() - 1;
            bad_content[last] ^= 0x80;
            assert_corrupt_frame_fails("content checksum", &bad_content, input.len());
            assert_corrupt_frame_decodes_with_skip_checksums(
                "content checksum",
                &bad_content,
                &input,
            );
            assert_corrupt_frame_decodes_with_sticky_skip_checksums(
                "content checksum",
                &bad_content,
                &input,
                header_len,
            );
        }
    }

    #[test]
    fn frame_decompress_raw_block_consumes_only_output_capacity() {
        unsafe {
            let input = b"raw block incremental payload";
            let mut frame = frame_header_for_test(
                ContentChecksum::NoChecksum,
                BlockChecksum::NoBlockChecksum,
                0,
            );
            frame.extend_from_slice(&((input.len() as u32) | 0x8000_0000).to_le_bytes());
            frame.extend_from_slice(input);
            frame.extend_from_slice(&0u32.to_le_bytes());

            let mut dctx = LZ4FDecompressionContext(ptr::null_mut());
            assert_eq!(LZ4F_createDecompressionContext(&mut dctx, LZ4F_VERSION), 0);
            let mut info = LZ4FFrameInfo {
                block_size_id: BlockSize::Default,
                block_mode: BlockMode::Linked,
                content_checksum_flag: ContentChecksum::NoChecksum,
                frame_type: FrameType::Frame,
                content_size: 0,
                dict_id: 0,
                block_checksum_flag: BlockChecksum::NoBlockChecksum,
            };
            let mut header_size = frame.len();
            assert_eq!(
                LZ4F_getFrameInfo(dctx, &mut info, frame.as_ptr(), &mut header_size),
                0
            );

            let payload = &frame[header_size..];
            let mut first = [0u8; 5];
            let mut src_size = payload.len();
            let mut dst_size = first.len();
            let hint = LZ4F_decompress(
                dctx,
                first.as_mut_ptr(),
                &mut dst_size,
                payload.as_ptr(),
                &mut src_size,
                ptr::null(),
            );
            assert_eq!(LZ4F_isError(hint), 0);
            assert_eq!(dst_size, first.len());
            assert_eq!(src_size, 4 + first.len());
            assert_eq!(&first, &input[..first.len()]);

            let rest_payload = &payload[src_size..];
            let mut rest = vec![0u8; input.len() - first.len()];
            let mut rest_src_size = rest_payload.len();
            let mut rest_dst_size = rest.len();
            let code = LZ4F_decompress(
                dctx,
                rest.as_mut_ptr(),
                &mut rest_dst_size,
                rest_payload.as_ptr(),
                &mut rest_src_size,
                ptr::null(),
            );
            assert_eq!(code, 0);
            assert_eq!(rest_src_size, rest_payload.len());
            assert_eq!(rest_dst_size, rest.len());
            assert_eq!(&rest, &input[first.len()..]);
            LZ4F_freeDecompressionContext(dctx);
        }
    }

    #[test]
    fn frame_decompress_rejects_bad_header_checksum() {
        unsafe {
            let mut cctx = LZ4FCompressionContext(ptr::null_mut());
            assert_eq!(LZ4F_createCompressionContext(&mut cctx, LZ4F_VERSION), 0);
            let prefs = LZ4FPreferences {
                frame_info: LZ4FFrameInfo {
                    block_size_id: BlockSize::Max64KB,
                    block_mode: BlockMode::Independent,
                    content_checksum_flag: ContentChecksum::NoChecksum,
                    frame_type: FrameType::Frame,
                    content_size: 0,
                    dict_id: 0,
                    block_checksum_flag: BlockChecksum::NoBlockChecksum,
                },
                compression_level: 0,
                auto_flush: 0,
                favor_dec_speed: 0,
                reserved: [0; 3],
            };
            let input = b"header checksum";
            let mut encoded = vec![0u8; 128];
            let mut pos = LZ4F_compressBegin(cctx, encoded.as_mut_ptr(), encoded.len(), &prefs);
            encoded[pos - 1] ^= 0x80;
            pos += LZ4F_compressUpdate(
                cctx,
                encoded.as_mut_ptr().add(pos),
                encoded.len() - pos,
                input.as_ptr(),
                input.len(),
                ptr::null(),
            );
            pos += LZ4F_compressEnd(
                cctx,
                encoded.as_mut_ptr().add(pos),
                encoded.len() - pos,
                ptr::null(),
            );
            encoded.truncate(pos);
            LZ4F_freeCompressionContext(cctx);

            let mut dctx = LZ4FDecompressionContext(ptr::null_mut());
            assert_eq!(LZ4F_createDecompressionContext(&mut dctx, LZ4F_VERSION), 0);
            let mut output = vec![0u8; input.len()];
            let mut src_size = encoded.len();
            let mut dst_size = output.len();
            let code = LZ4F_decompress(
                dctx,
                output.as_mut_ptr(),
                &mut dst_size,
                encoded.as_ptr(),
                &mut src_size,
                ptr::null(),
            );
            assert_eq!(code, ERROR_HEADER_CHECKSUM_INVALID);
            LZ4F_freeDecompressionContext(dctx);
        }
    }

    #[test]
    fn frame_decompress_rejects_malformed_compressed_block() {
        unsafe {
            let mut cctx = LZ4FCompressionContext(ptr::null_mut());
            assert_eq!(LZ4F_createCompressionContext(&mut cctx, LZ4F_VERSION), 0);
            let prefs = LZ4FPreferences {
                frame_info: LZ4FFrameInfo {
                    block_size_id: BlockSize::Max64KB,
                    block_mode: BlockMode::Independent,
                    content_checksum_flag: ContentChecksum::NoChecksum,
                    frame_type: FrameType::Frame,
                    content_size: 0,
                    dict_id: 0,
                    block_checksum_flag: BlockChecksum::NoBlockChecksum,
                },
                compression_level: 0,
                auto_flush: 0,
                favor_dec_speed: 0,
                reserved: [0; 3],
            };
            let mut encoded = vec![0u8; 32];
            let header_len = LZ4F_compressBegin(cctx, encoded.as_mut_ptr(), encoded.len(), &prefs);
            assert_eq!(LZ4F_isError(header_len), 0);
            encoded.truncate(header_len);
            LZ4F_freeCompressionContext(cctx);

            let cases = [
                ("offset past output", [0x00, 0x01, 0x00]),
                ("zero offset", [0x00, 0x00, 0x00]),
            ];
            for (case, payload) in cases {
                let mut frame = encoded.clone();
                frame.extend_from_slice(&(payload.len() as u32).to_le_bytes());
                frame.extend_from_slice(&payload);

                let mut dctx = LZ4FDecompressionContext(ptr::null_mut());
                assert_eq!(LZ4F_createDecompressionContext(&mut dctx, LZ4F_VERSION), 0);
                let mut output = vec![0u8; 64 * 1024];
                let mut src_size = frame.len();
                let mut dst_size = output.len();
                let code = LZ4F_decompress(
                    dctx,
                    output.as_mut_ptr(),
                    &mut dst_size,
                    frame.as_ptr(),
                    &mut src_size,
                    ptr::null(),
                );
                assert_eq!(code, ERROR_DECOMPRESSION_FAILED, "{case}");
                LZ4F_freeDecompressionContext(dctx);
            }
        }
    }

    #[test]
    fn frame_decompress_reports_hints_for_truncated_frame_parts() {
        unsafe {
            let no_checksum = frame_header_for_test(
                ContentChecksum::NoChecksum,
                BlockChecksum::NoBlockChecksum,
                0,
            );
            assert_incomplete_frame_hint(
                "partial block header",
                {
                    let mut frame = no_checksum.clone();
                    frame.extend_from_slice(&[0x05, 0x00]);
                    frame
                },
                2,
                0,
            );
            assert_incomplete_frame_hint(
                "partial raw block payload",
                {
                    let mut frame = no_checksum.clone();
                    frame.extend_from_slice(&(0x8000_0000u32 | 5).to_le_bytes());
                    frame.extend_from_slice(b"ab");
                    frame
                },
                7,
                2,
            );

            let with_block_checksum = frame_header_for_test(
                ContentChecksum::NoChecksum,
                BlockChecksum::BlockChecksumEnabled,
                0,
            );
            assert_incomplete_frame_hint(
                "missing block checksum",
                {
                    let mut frame = with_block_checksum;
                    frame.extend_from_slice(&(0x8000_0000u32 | 3).to_le_bytes());
                    frame.extend_from_slice(b"abc");
                    frame
                },
                4,
                3,
            );

            let with_content_checksum = frame_header_for_test(
                ContentChecksum::ChecksumEnabled,
                BlockChecksum::NoBlockChecksum,
                0,
            );
            assert_incomplete_frame_hint(
                "missing content checksum trailer",
                {
                    let mut frame = with_content_checksum;
                    frame.extend_from_slice(&(0x8000_0000u32 | 3).to_le_bytes());
                    frame.extend_from_slice(b"abc");
                    frame.extend_from_slice(&0u32.to_le_bytes());
                    frame
                },
                4,
                3,
            );
        }
    }

    #[test]
    fn frame_decompress_rejects_content_size_mismatch() {
        unsafe {
            let mut cctx = LZ4FCompressionContext(ptr::null_mut());
            assert_eq!(LZ4F_createCompressionContext(&mut cctx, LZ4F_VERSION), 0);
            let input = b"wrong content size";
            let prefs = LZ4FPreferences {
                frame_info: LZ4FFrameInfo {
                    block_size_id: BlockSize::Max64KB,
                    block_mode: BlockMode::Independent,
                    content_checksum_flag: ContentChecksum::NoChecksum,
                    frame_type: FrameType::Frame,
                    content_size: input.len() as u64 + 1,
                    dict_id: 0,
                    block_checksum_flag: BlockChecksum::NoBlockChecksum,
                },
                compression_level: 0,
                auto_flush: 0,
                favor_dec_speed: 0,
                reserved: [0; 3],
            };
            let mut encoded = vec![0u8; 128];
            let mut pos = LZ4F_compressBegin(cctx, encoded.as_mut_ptr(), encoded.len(), &prefs);
            assert_eq!(LZ4F_isError(pos), 0);
            encoded[pos..pos + 4]
                .copy_from_slice(&((input.len() as u32) | 0x8000_0000).to_le_bytes());
            pos += 4;
            encoded[pos..pos + input.len()].copy_from_slice(input);
            pos += input.len();
            encoded[pos..pos + 4].copy_from_slice(&0u32.to_le_bytes());
            pos += 4;
            encoded.truncate(pos);
            LZ4F_freeCompressionContext(cctx);

            let mut dctx = LZ4FDecompressionContext(ptr::null_mut());
            assert_eq!(LZ4F_createDecompressionContext(&mut dctx, LZ4F_VERSION), 0);
            let mut output = vec![0u8; input.len()];
            let mut src_size = encoded.len();
            let mut dst_size = output.len();
            let code = LZ4F_decompress(
                dctx,
                output.as_mut_ptr(),
                &mut dst_size,
                encoded.as_ptr(),
                &mut src_size,
                ptr::null(),
            );
            assert_eq!(code, ERROR_FRAME_SIZE_WRONG);
            LZ4F_freeDecompressionContext(dctx);
        }
    }

    fn assert_corrupt_frame_fails(kind: &str, encoded: &[u8], output_len: usize) {
        unsafe {
            let mut dctx = LZ4FDecompressionContext(ptr::null_mut());
            assert_eq!(LZ4F_createDecompressionContext(&mut dctx, LZ4F_VERSION), 0);
            let mut output = vec![0u8; output_len];
            let mut offset = 0usize;
            for _ in 0..8 {
                let mut src_size = encoded.len() - offset;
                let src_ptr = if src_size == 0 {
                    ptr::null()
                } else {
                    encoded.as_ptr().add(offset)
                };
                let mut dst_size = output.len();
                let code = LZ4F_decompress(
                    dctx,
                    output.as_mut_ptr(),
                    &mut dst_size,
                    src_ptr,
                    &mut src_size,
                    ptr::null(),
                );
                if code == ERROR_BLOCK_CHECKSUM_INVALID || code == ERROR_CHECKSUM_INVALID {
                    LZ4F_freeDecompressionContext(dctx);
                    return;
                }
                assert_eq!(LZ4F_isError(code), 0);
                assert_ne!(code, 0, "{kind} corrupt frame decoded successfully");
                offset += src_size;
            }
            panic!("{kind} corrupt frame did not report checksum failure");
        }
    }

    fn assert_corrupt_frame_decodes_with_skip_checksums(kind: &str, encoded: &[u8], input: &[u8]) {
        unsafe {
            let mut dctx = LZ4FDecompressionContext(ptr::null_mut());
            assert_eq!(LZ4F_createDecompressionContext(&mut dctx, LZ4F_VERSION), 0);
            let options = LZ4FDecompressOptions {
                stable_dst: 0,
                skipChecksums: 1,
                reserved: [0; 2],
            };
            let mut output = vec![0u8; input.len()];
            let mut src_size = encoded.len();
            let mut dst_size = output.len();
            let code = LZ4F_decompress(
                dctx,
                output.as_mut_ptr(),
                &mut dst_size,
                encoded.as_ptr(),
                &mut src_size,
                &options,
            );
            assert_eq!(code, 0, "{kind}");
            assert_eq!(src_size, encoded.len(), "{kind}");
            assert_eq!(dst_size, input.len(), "{kind}");
            assert_eq!(output, input, "{kind}");
            LZ4F_freeDecompressionContext(dctx);
        }
    }

    fn assert_corrupt_frame_decodes_with_sticky_skip_checksums(
        kind: &str,
        encoded: &[u8],
        input: &[u8],
        header_len: usize,
    ) {
        unsafe {
            let mut dctx = LZ4FDecompressionContext(ptr::null_mut());
            assert_eq!(LZ4F_createDecompressionContext(&mut dctx, LZ4F_VERSION), 0);
            let options = LZ4FDecompressOptions {
                stable_dst: 0,
                skipChecksums: 1,
                reserved: [0; 2],
            };
            let mut src_size = header_len;
            let mut dst_size = 0usize;
            let code = LZ4F_decompress(
                dctx,
                ptr::null_mut(),
                &mut dst_size,
                encoded.as_ptr(),
                &mut src_size,
                &options,
            );
            assert_eq!(LZ4F_isError(code), 0, "{kind}");
            assert_eq!(src_size, header_len, "{kind}");
            assert_eq!(dst_size, 0, "{kind}");

            let mut output = vec![0u8; input.len()];
            src_size = encoded.len() - header_len;
            dst_size = output.len();
            let code = LZ4F_decompress(
                dctx,
                output.as_mut_ptr(),
                &mut dst_size,
                encoded.as_ptr().add(header_len),
                &mut src_size,
                ptr::null(),
            );
            assert_eq!(code, 0, "{kind}");
            assert_eq!(src_size, encoded.len() - header_len, "{kind}");
            assert_eq!(dst_size, input.len(), "{kind}");
            assert_eq!(output, input, "{kind}");
            LZ4F_freeDecompressionContext(dctx);
        }
    }

    unsafe fn frame_header_for_test(
        content_checksum: ContentChecksum,
        block_checksum: BlockChecksum,
        content_size: u64,
    ) -> Vec<u8> {
        let mut cctx = LZ4FCompressionContext(ptr::null_mut());
        assert_eq!(LZ4F_createCompressionContext(&mut cctx, LZ4F_VERSION), 0);
        let prefs = LZ4FPreferences {
            frame_info: LZ4FFrameInfo {
                block_size_id: BlockSize::Max64KB,
                block_mode: BlockMode::Independent,
                content_checksum_flag: content_checksum,
                frame_type: FrameType::Frame,
                content_size,
                dict_id: 0,
                block_checksum_flag: block_checksum,
            },
            compression_level: 0,
            auto_flush: 0,
            favor_dec_speed: 0,
            reserved: [0; 3],
        };
        let mut header = vec![0u8; 32];
        let header_len = LZ4F_compressBegin(cctx, header.as_mut_ptr(), header.len(), &prefs);
        assert_eq!(LZ4F_isError(header_len), 0);
        LZ4F_freeCompressionContext(cctx);
        header.truncate(header_len);
        header
    }

    unsafe fn assert_incomplete_frame_hint(
        case: &str,
        frame: Vec<u8>,
        expected_hint: usize,
        expected_output: usize,
    ) {
        let mut dctx = LZ4FDecompressionContext(ptr::null_mut());
        assert_eq!(LZ4F_createDecompressionContext(&mut dctx, LZ4F_VERSION), 0);
        let mut output = vec![0u8; 64 * 1024];
        let mut src_size = frame.len();
        let mut dst_size = output.len();
        let code = LZ4F_decompress(
            dctx,
            output.as_mut_ptr(),
            &mut dst_size,
            frame.as_ptr(),
            &mut src_size,
            ptr::null(),
        );
        assert_eq!(LZ4F_isError(code), 0, "{case}");
        assert_eq!(code, expected_hint, "{case}");
        assert_eq!(dst_size, expected_output, "{case}");
        assert_eq!(src_size, frame.len(), "{case}");
        LZ4F_freeDecompressionContext(dctx);
    }

    unsafe fn decode_frame_once(frame: &[u8], output_len: usize) -> Vec<u8> {
        let mut dctx = LZ4FDecompressionContext(ptr::null_mut());
        assert_eq!(LZ4F_createDecompressionContext(&mut dctx, LZ4F_VERSION), 0);
        let mut output = vec![0u8; output_len + 16];
        let mut src_offset = 0usize;
        let mut dst_offset = 0usize;
        loop {
            let mut src_size = frame.len() - src_offset;
            let mut dst_size = output.len() - dst_offset;
            let code = LZ4F_decompress(
                dctx,
                output.as_mut_ptr().add(dst_offset),
                &mut dst_size,
                frame.as_ptr().add(src_offset),
                &mut src_size,
                ptr::null(),
            );
            assert_eq!(LZ4F_isError(code), 0);
            src_offset += src_size;
            dst_offset += dst_size;
            if code == 0 {
                break;
            }
        }
        assert_eq!(src_offset, frame.len());
        output.truncate(dst_offset);
        LZ4F_freeDecompressionContext(dctx);
        output
    }

    #[test]
    fn hc_round_trip_and_improves_repetitive_block() {
        let mut input = Vec::new();
        for _ in 0..4096 {
            input.extend_from_slice(b"the quick brown fox jumps over the lazy dog. ");
        }

        let bound = unsafe { LZ4_compressBound(input.len() as c_int) } as usize;
        let mut fast = vec![0u8; bound];
        let fast_len = unsafe {
            LZ4_compress_default(
                input.as_ptr() as *const c_char,
                fast.as_mut_ptr() as *mut c_char,
                input.len() as c_int,
                fast.len() as c_int,
            )
        };
        assert!(fast_len > 0);

        let mut hc = vec![0u8; bound];
        let hc_len = unsafe {
            LZ4_compress_HC(
                input.as_ptr() as *const c_char,
                hc.as_mut_ptr() as *mut c_char,
                input.len() as c_int,
                hc.len() as c_int,
                9,
            )
        };
        assert!(hc_len > 0);
        assert!(hc_len <= fast_len);

        let mut output = vec![0u8; input.len()];
        let output_len = unsafe {
            LZ4_decompress_safe(
                hc.as_ptr() as *const c_char,
                output.as_mut_ptr() as *mut c_char,
                hc_len,
                output.len() as c_int,
            )
        };
        assert_eq!(output_len as usize, input.len());
        assert_eq!(output, input);
    }

    #[test]
    fn hc_levels_round_trip_varied_inputs() {
        let mut inputs = Vec::new();
        inputs.push((0..4096).map(|n| (n & 0xff) as u8).collect::<Vec<_>>());
        inputs.push(vec![b'a'; 128 * 1024]);
        let mut patterned = Vec::new();
        for n in 0..32 * 1024 {
            patterned.push(if n % 97 < 64 {
                b"ACGT"[(n / 3) % 4]
            } else {
                (n & 0xff) as u8
            });
        }
        inputs.push(patterned);

        for input in inputs {
            let bound = unsafe { LZ4_compressBound(input.len() as c_int) } as usize;
            for level in 1..=12 {
                let mut compressed = vec![0u8; bound];
                let compressed_len = unsafe {
                    LZ4_compress_HC(
                        input.as_ptr() as *const c_char,
                        compressed.as_mut_ptr() as *mut c_char,
                        input.len() as c_int,
                        compressed.len() as c_int,
                        level,
                    )
                };
                assert!(compressed_len > 0, "level {level}");

                let mut output = vec![0u8; input.len()];
                let output_len = unsafe {
                    LZ4_decompress_safe(
                        compressed.as_ptr() as *const c_char,
                        output.as_mut_ptr() as *mut c_char,
                        compressed_len,
                        output.len() as c_int,
                    )
                };
                assert_eq!(output_len as usize, input.len(), "level {level}");
                assert_eq!(output, input, "level {level}");
            }
        }
    }

    #[test]
    fn hc_matches_upstream_bytes_for_representative_levels() {
        let cases = [
            (
                1,
                patterned_hc_input(128),
                "ff144142434445464741426a6b6c6d6e6f70303132333435363738396162636465666768691a002b144762000d4e00503334353637",
            ),
            (
                2,
                patterned_hc_input(1024),
                "ff144142434445464741426a6b6c6d6e6f70303132333435363738396162636465666768691a002b144762000f4e00320f9c0000144662000d1a000fd00034144562000f4e00320f520100144462000d1a000f86013403e3012f43444e00320f86010003e3012d42431a000f860134144162000f4e00320f860100144762000d1a000f860134144662000f4e00320f86010003e3012d45461a000f86010450666768696a",
            ),
            (
                12,
                b"the quick brown fox jumps over the lazy dog. "
                    .iter()
                    .copied()
                    .cycle()
                    .take(4096)
                    .collect::<Vec<_>>(),
                "f01074686520717569636b2062726f776e20666f78206a756d7073206f766572201f00af6c617a7920646f672e202d00ffffffffffffffffffffffffffffffca506f672e2074",
            ),
            (
                9,
                patterned_hc_input(128),
                "ff144142434445464741426a6b6c6d6e6f70303132333435363738396162636465666768691a002b144762000d1a00503334353637",
            ),
            (
                10,
                patterned_hc_input(1024),
                "ff144142434445464741426a6b6c6d6e6f70303132333435363738396162636465666768691a002b144762000f4e00320f1a0000144662000fb60039081a00144562000f1e0140011a00144462000f1e0140011a00144362000f1e0140011a00144262000f1e0140011a0005a7020fa4024235333435a7020fa40242356d6e6fa7020fa4024235666768a7020f34001550666768696a",
            ),
        ];

        for (level, input, expected_hex) in cases {
            let expected = decode_hex(expected_hex);
            let mut compressed =
                vec![0u8; unsafe { LZ4_compressBound(input.len() as c_int) } as usize];
            let compressed_len = unsafe {
                LZ4_compress_HC(
                    input.as_ptr() as *const c_char,
                    compressed.as_mut_ptr() as *mut c_char,
                    input.len() as c_int,
                    compressed.len() as c_int,
                    level,
                )
            };
            assert_eq!(compressed_len as usize, expected.len(), "level {level}");
            assert_eq!(
                &compressed[..compressed_len as usize],
                &expected,
                "level {level}"
            );
        }
    }

    #[test]
    fn fast_matches_upstream_bytes_for_representative_blocks() {
        let cases = [
            (
                1,
                b"the quick brown fox jumps over the lazy dog. "
                    .iter()
                    .copied()
                    .cycle()
                    .take(4096)
                    .collect::<Vec<_>>(),
                "f01074686520717569636b2062726f776e20666f78206a756d7073206f766572201f00916c617a7920646f672e0e000f2d00ffffffffffffffffffffffffffffffc6506f672e2074",
            ),
            (
                1,
                patterned_hc_input(512),
                "ff144142434445464741426a6b6c6d6e6f70303132333435363738396162636465666768691a002b144762000f4e00320f9c000000bd0001c4000fb60039086800011f010062000f1e01400168000281013f4344456c012d014e000fba010000bd0001880109d401506e6f703031",
            ),
            (
                4,
                patterned_hc_input(512),
                "ff2e4142434445464741426a6b6c6d6e6f70303132333435363738396162636465666768696a6b6c6d6e6f7030313233343536373839616263646566676869340011144762000f3400180f68001a144662000fb60039088200144562000f1e0140016800144462000f6c012d014e000fa0010003e301294344d401506e6f703031",
            ),
        ];

        for (acceleration, input, expected_hex) in cases {
            let expected = decode_hex(expected_hex);
            let mut compressed =
                vec![0u8; unsafe { LZ4_compressBound(input.len() as c_int) } as usize];
            let compressed_len = unsafe {
                LZ4_compress_fast(
                    input.as_ptr() as *const c_char,
                    compressed.as_mut_ptr() as *mut c_char,
                    input.len() as c_int,
                    compressed.len() as c_int,
                    acceleration,
                )
            };
            assert_eq!(compressed_len as usize, expected.len(), "{acceleration}");
            assert_eq!(
                &compressed[..compressed_len as usize],
                &expected,
                "{acceleration}"
            );
        }
    }

    #[test]
    fn fast_continue_matches_upstream_bytes_with_dictionary() {
        unsafe {
            let dict = b"abcdefghijklmnop0123456789abcdefghijklmnop0123456789";
            let input = b"abcdefghijklmnop0123456789ZZabcdefghijklmnop0123456789";
            for acceleration in [1, 4] {
                let expected = decode_hex("0f1a00072f5a5a1c0002503536373839");
                let stream = LZ4_createStream();
                assert!(!stream.is_null());
                assert_eq!(
                    LZ4_loadDict(stream, dict.as_ptr() as *const c_char, dict.len() as c_int),
                    dict.len() as c_int
                );

                let mut compressed = vec![0u8; LZ4_compressBound(input.len() as c_int) as usize];
                let compressed_len = LZ4_compress_fast_continue(
                    stream,
                    input.as_ptr() as *const c_char,
                    compressed.as_mut_ptr() as *mut c_char,
                    input.len() as c_int,
                    compressed.len() as c_int,
                    acceleration,
                );
                LZ4_freeStream(stream);

                assert_eq!(compressed_len as usize, expected.len(), "{acceleration}");
                assert_eq!(
                    &compressed[..compressed_len as usize],
                    &expected,
                    "{acceleration}"
                );
            }
        }
    }

    #[test]
    fn hc_frame_matches_upstream_bytes_for_representative_input() {
        unsafe {
            let input = patterned_hc_input(1024);
            let cases = [
                (
                    9,
                    "04224d186440a78f000000ff144142434445464741426a6b6c6d6e6f70303132333435363738396162636465666768691a002b144762000e4e000f680033144662000eb6000f680033144562000f1e0140011a00144462002f6869860143144362002f61628601430445023f43333486014305a7022f6d6e86014305a7022f666786014305a7022f383986014305a7020f34001550666768696a00000000e112173a",
                ),
                (
                    10,
                    "04224d186440a796000000ff144142434445464741426a6b6c6d6e6f70303132333435363738396162636465666768691a002b144762000f4e00320f1a0000144662000fb60039081a00144562000f1e0140011a00144462000f1e0140011a00144362000f1e0140011a00144262000f1e0140011a0005a7020fa4024235333435a7020fa40242356d6e6fa7020fa4024235666768a7020f34001550666768696a00000000e112173a",
                ),
                (
                    12,
                    "04224d186440a78f000000ff144142434445464741426a6b6c6d6e6f70303132333435363738396162636465666768691a002b144762000e4e000f680033144662000fb60039081a00144562000f1e0140011a00144462002f6869860143144362002f6162860143144262002f333486014305a7022f6d6e86014305a7022f666786014305a7022f383986014305a7020f34001550666768696a00000000e112173a",
                ),
            ];

            for (level, expected_hex) in cases {
                let expected = decode_hex(expected_hex);
                let prefs = hc_frame_fixture_prefs(level);
                let bound = LZ4F_compressFrameBound(input.len(), &prefs);
                let mut encoded = vec![0u8; bound];
                let encoded_len = LZ4F_compressFrame(
                    encoded.as_mut_ptr() as *mut c_void,
                    encoded.len(),
                    input.as_ptr() as *const c_void,
                    input.len(),
                    &prefs,
                );

                assert_eq!(LZ4F_isError(encoded_len), 0, "level {level}");
                assert_eq!(encoded_len, expected.len(), "level {level}");
                assert_eq!(&encoded[..encoded_len], &expected, "level {level}");
            }
        }
    }

    #[test]
    fn frame_levels_one_and_two_use_fast_path() {
        unsafe {
            let input = patterned_hc_input(32 * 1024);
            let mut expected = Vec::new();
            for level in [0, 1, 2] {
                let prefs = hc_frame_fixture_prefs(level);
                let mut encoded = vec![0u8; LZ4F_compressFrameBound(input.len(), &prefs)];
                let encoded_len = LZ4F_compressFrame(
                    encoded.as_mut_ptr() as *mut c_void,
                    encoded.len(),
                    input.as_ptr() as *const c_void,
                    input.len(),
                    &prefs,
                );
                assert_eq!(LZ4F_isError(encoded_len), 0, "level {level}");
                encoded.truncate(encoded_len);
                if level == 0 {
                    expected = encoded;
                } else {
                    assert_eq!(encoded, expected, "level {level}");
                }
            }
        }
    }

    #[test]
    fn hc_frame_cdict_matches_upstream_bytes() {
        unsafe {
            let dict = b"abcdefghijklmnop0123456789abcdefghijklmnop0123456789";
            let input = b"abcdefghijklmnop0123456789ZZabcdefghijklmnop0123456789";
            let expected = decode_hex(
                "04224d186440a7100000000f1a00072f5a5a1c000250353637383900000000af554433",
            );
            let prefs = hc_frame_fixture_prefs(9);
            let cdict = LZ4F_createCDict(dict.as_ptr() as *const c_void, dict.len());
            assert!(!cdict.is_null());
            let mut cctx = LZ4FCompressionContext(ptr::null_mut());
            assert_eq!(LZ4F_createCompressionContext(&mut cctx, LZ4F_VERSION), 0);
            let mut encoded = vec![0u8; LZ4F_compressFrameBound(input.len(), &prefs)];
            let encoded_len = LZ4F_compressFrame_usingCDict(
                cctx,
                encoded.as_mut_ptr() as *mut c_void,
                encoded.len(),
                input.as_ptr() as *const c_void,
                input.len(),
                cdict,
                &prefs,
            );
            LZ4F_freeCompressionContext(cctx);
            LZ4F_freeCDict(cdict);

            assert_eq!(LZ4F_isError(encoded_len), 0);
            assert_eq!(encoded_len, expected.len());
            assert_eq!(&encoded[..encoded_len], &expected);
        }
    }

    #[test]
    fn hc_multiblock_frame_matches_upstream_hashes() {
        unsafe {
            let input = patterned_hc_input(150_000);
            let cases = [
                (9, 4504usize, 0x859b_76b8u32),
                (12, 4504usize, 0x8eb7_3b33u32),
            ];

            for (level, expected_len, expected_hash) in cases {
                let prefs = hc_frame_fixture_prefs(level);
                let mut encoded = vec![0u8; LZ4F_compressFrameBound(input.len(), &prefs)];
                let encoded_len = LZ4F_compressFrame(
                    encoded.as_mut_ptr() as *mut c_void,
                    encoded.len(),
                    input.as_ptr() as *const c_void,
                    input.len(),
                    &prefs,
                );

                assert_eq!(LZ4F_isError(encoded_len), 0, "level {level}");
                assert_eq!(encoded_len, expected_len, "level {level}");
                assert_eq!(
                    xxhash32(&encoded[..encoded_len], 0),
                    expected_hash,
                    "level {level}"
                );
            }
        }
    }

    #[test]
    fn hc_large_frame_matches_upstream_hash() {
        unsafe {
            let input = patterned_hc_input(8 * 1024 * 1024);
            let prefs = hc_frame_fixture_prefs(9);
            let mut encoded = vec![0u8; LZ4F_compressFrameBound(input.len(), &prefs)];
            let encoded_len = LZ4F_compressFrame(
                encoded.as_mut_ptr() as *mut c_void,
                encoded.len(),
                input.as_ptr() as *const c_void,
                input.len(),
                &prefs,
            );

            assert_eq!(LZ4F_isError(encoded_len), 0);
            assert_eq!(encoded_len, 199_444);
            assert_eq!(xxhash32(&encoded[..encoded_len], 0), 0x6f9f_bc8e);
        }
    }

    #[test]
    fn hc_large_frame_with_cli_block_size_matches_upstream_hash() {
        unsafe {
            let input = patterned_hc_input(8 * 1024 * 1024);
            let mut prefs = hc_frame_fixture_prefs(9);
            prefs.frame_info.block_size_id = BlockSize::Max4MB;
            let mut encoded = vec![0u8; LZ4F_compressFrameBound(input.len(), &prefs)];
            let encoded_len = LZ4F_compressFrame(
                encoded.as_mut_ptr() as *mut c_void,
                encoded.len(),
                input.as_ptr() as *const c_void,
                input.len(),
                &prefs,
            );

            assert_eq!(LZ4F_isError(encoded_len), 0);
            assert_eq!(encoded_len, 35_508);
            assert_eq!(xxhash32(&encoded[..encoded_len], 0), 0x5af1_b15f);
        }
    }

    fn hc_frame_fixture_prefs(level: u32) -> LZ4FPreferences {
        LZ4FPreferences {
            frame_info: LZ4FFrameInfo {
                block_size_id: BlockSize::Max64KB,
                block_mode: BlockMode::Independent,
                content_checksum_flag: ContentChecksum::ChecksumEnabled,
                frame_type: FrameType::Frame,
                content_size: 0,
                dict_id: 0,
                block_checksum_flag: BlockChecksum::NoBlockChecksum,
            },
            compression_level: level,
            auto_flush: 0,
            favor_dec_speed: 0,
            reserved: [0; 3],
        }
    }

    fn patterned_hc_input(len: usize) -> Vec<u8> {
        let pattern = b"abcdefghijklmnop0123456789";
        let mut input = vec![0u8; len];
        for i in 0..len {
            input[i] = pattern[i % pattern.len()];
            if (i % 97) < 9 {
                input[i] = b'A' + (i % 7) as u8;
            }
        }
        input
    }

    fn decode_hex(hex: &str) -> Vec<u8> {
        assert_eq!(hex.len() % 2, 0);
        (0..hex.len())
            .step_by(2)
            .map(|i| u8::from_str_radix(&hex[i..i + 2], 16).unwrap())
            .collect()
    }

    fn block_has_offset_below(block: &[u8], threshold: usize) -> bool {
        let mut pos = 0usize;
        while pos < block.len() {
            let token = block[pos];
            pos += 1;
            let mut lit_len = (token >> 4) as usize;
            if lit_len == 15 {
                loop {
                    if pos >= block.len() {
                        return false;
                    }
                    let value = block[pos] as usize;
                    pos += 1;
                    lit_len += value;
                    if value != 255 {
                        break;
                    }
                }
            }
            pos += lit_len;
            if pos >= block.len() {
                return false;
            }
            if pos + 2 > block.len() {
                return false;
            }
            let offset = u16::from_le_bytes([block[pos], block[pos + 1]]) as usize;
            if offset < threshold {
                return true;
            }
            pos += 2;
            if token & 0x0f == 15 {
                loop {
                    if pos >= block.len() {
                        return false;
                    }
                    let value = block[pos] as usize;
                    pos += 1;
                    if value != 255 {
                        break;
                    }
                }
            }
        }
        false
    }

    #[test]
    fn hc_ext_state_dest_size_and_stream_wrappers_round_trip() {
        let input = b"abcdefabcdefabcdefabcdef-".repeat(4096);
        let bound = unsafe { LZ4_compressBound(input.len() as c_int) } as usize;

        let state_size = LZ4_sizeofStateHC();
        assert!(state_size > 0);
        let mut state = vec![0u8; state_size as usize];
        let mut compressed = vec![0u8; bound];
        let compressed_len = unsafe {
            LZ4_compress_HC_extStateHC(
                state.as_mut_ptr() as *mut c_void,
                input.as_ptr() as *const c_char,
                compressed.as_mut_ptr() as *mut c_char,
                input.len() as c_int,
                compressed.len() as c_int,
                9,
            )
        };
        assert!(compressed_len > 0);

        let mut output = vec![0u8; input.len()];
        let output_len = unsafe {
            LZ4_decompress_safe(
                compressed.as_ptr() as *const c_char,
                output.as_mut_ptr() as *mut c_char,
                compressed_len,
                output.len() as c_int,
            )
        };
        assert_eq!(output_len as usize, input.len());
        assert_eq!(output, input);

        let mut source_size = input.len() as c_int;
        let mut tiny = vec![0u8; compressed_len as usize / 2];
        let partial_len = unsafe {
            LZ4_compress_HC_destSize(
                state.as_mut_ptr() as *mut c_void,
                input.as_ptr() as *const c_char,
                tiny.as_mut_ptr() as *mut c_char,
                &mut source_size,
                tiny.len() as c_int,
                9,
            )
        };
        assert!(partial_len > 0);
        assert!(source_size > 0);
        assert!(source_size < input.len() as c_int);

        let stream = unsafe { LZ4_createStreamHC() };
        assert!(!stream.is_null());
        unsafe { LZ4_resetStreamHC_fast(stream, 9) };
        let mut streamed = vec![0u8; bound];
        let streamed_len = unsafe {
            LZ4_compress_HC_continue(
                stream,
                input.as_ptr() as *const c_char,
                streamed.as_mut_ptr() as *mut c_char,
                input.len() as c_int,
                streamed.len() as c_int,
            )
        };
        assert!(streamed_len > 0);
        unsafe { LZ4_freeStreamHC(stream) };

        output.fill(0);
        let output_len = unsafe {
            LZ4_decompress_safe(
                streamed.as_ptr() as *const c_char,
                output.as_mut_ptr() as *mut c_char,
                streamed_len,
                output.len() as c_int,
            )
        };
        assert_eq!(output_len as usize, input.len());
        assert_eq!(output, input);
    }

    #[test]
    fn hc_deprecated_state_wrappers_round_trip_and_reset() {
        let input = b"deprecated-state-hc-wrapper-".repeat(2048);
        let bound = unsafe { LZ4_compressBound(input.len() as c_int) } as usize;
        let state_size = LZ4_sizeofStreamStateHC();
        assert!(state_size > 0);
        let mut state = vec![0u8; state_size as usize];

        let reset = unsafe {
            LZ4_resetStreamStateHC(
                state.as_mut_ptr() as *mut c_void,
                input.as_ptr() as *mut c_char,
            )
        };
        assert_eq!(reset, 0);
        assert_eq!(
            unsafe { LZ4_resetStreamStateHC(ptr::null_mut(), ptr::null_mut()) },
            1
        );

        let mut compressed = vec![0u8; bound];
        let compressed_len = unsafe {
            LZ4_compressHC2_withStateHC(
                state.as_mut_ptr() as *mut c_void,
                input.as_ptr() as *const c_char,
                compressed.as_mut_ptr() as *mut c_char,
                input.len() as c_int,
                9,
            )
        };
        assert!(compressed_len > 0);

        let mut output = vec![0u8; input.len()];
        let output_len = unsafe {
            LZ4_decompress_safe(
                compressed.as_ptr() as *const c_char,
                output.as_mut_ptr() as *mut c_char,
                compressed_len,
                output.len() as c_int,
            )
        };
        assert_eq!(output_len as usize, input.len());
        assert_eq!(output, input);

        let mut limited = vec![0u8; compressed_len as usize];
        let limited_len = unsafe {
            LZ4_compressHC_limitedOutput_withStateHC(
                state.as_mut_ptr() as *mut c_void,
                input.as_ptr() as *const c_char,
                limited.as_mut_ptr() as *mut c_char,
                input.len() as c_int,
                limited.len() as c_int,
            )
        };
        assert!(limited_len > 0);

        output.fill(0);
        let output_len = unsafe {
            LZ4_decompress_safe(
                limited.as_ptr() as *const c_char,
                output.as_mut_ptr() as *mut c_char,
                limited_len,
                output.len() as c_int,
            )
        };
        assert_eq!(output_len as usize, input.len());
        assert_eq!(output, input);
    }

    #[test]
    fn hc_stream_compression_references_loaded_dictionary() {
        unsafe {
            let dict = b"abcdefghijklmnop";
            let input = b"abcdefghijklmnop";
            let stream = LZ4_createStreamHC();
            assert!(!stream.is_null());
            assert_eq!(
                LZ4_loadDictHC(stream, dict.as_ptr() as *const c_char, dict.len() as c_int),
                dict.len() as c_int
            );

            let mut compressed = vec![0u8; LZ4_compressBound(input.len() as c_int) as usize];
            let compressed_len = LZ4_compress_HC_continue(
                stream,
                input.as_ptr() as *const c_char,
                compressed.as_mut_ptr() as *mut c_char,
                input.len() as c_int,
                compressed.len() as c_int,
            );
            assert!(compressed_len > 0);
            assert!((compressed_len as usize) < input.len() + 1);
            LZ4_freeStreamHC(stream);

            let mut output = vec![0u8; input.len()];
            let output_len = LZ4_decompress_safe_usingDict(
                compressed.as_ptr() as *const c_char,
                output.as_mut_ptr() as *mut c_char,
                compressed_len,
                output.len() as c_int,
                dict.as_ptr() as *const c_char,
                dict.len() as c_int,
            );
            assert_eq!(output_len as usize, input.len());
            assert_eq!(output, input);
        }
    }

    #[test]
    fn hc_mid_levels_continue_match_upstream_bytes_with_dictionary() {
        unsafe {
            let dict = b"abcdefghijklmnop0123456789abcdefghijklmnop0123456789";
            let input = b"abcdefghijklmnop0123456789ZZabcdefghijklmnop0123456789";
            let expected = decode_hex("0f1a00072f5a5a1c0002503536373839");

            for level in [1, 2] {
                let stream = LZ4_createStreamHC();
                assert!(!stream.is_null());
                LZ4_setCompressionLevel(stream, level);
                assert_eq!(
                    LZ4_loadDictHC(stream, dict.as_ptr() as *const c_char, dict.len() as c_int),
                    dict.len() as c_int
                );

                let mut compressed = vec![0u8; LZ4_compressBound(input.len() as c_int) as usize];
                let compressed_len = LZ4_compress_HC_continue(
                    stream,
                    input.as_ptr() as *const c_char,
                    compressed.as_mut_ptr() as *mut c_char,
                    input.len() as c_int,
                    compressed.len() as c_int,
                );
                LZ4_freeStreamHC(stream);

                assert_eq!(compressed_len as usize, expected.len(), "level {level}");
                assert_eq!(
                    &compressed[..compressed_len as usize],
                    &expected,
                    "level {level}"
                );
            }
        }
    }

    /// Targeted byte-level parity check for HC pattern-analysis across the
    /// dictionary/prefix boundary. The dictionary ends in a 200-byte run of
    /// `'A'`, and the input also contains a 200-byte run of `'A'` partway
    /// through, so the HC pattern-analysis branch can extend its pattern
    /// reverse-count into the dict area only as far as upstream allows.
    #[test]
    fn hc_pattern_analysis_across_dict_boundary_matches_upstream_bytes() {
        let mut dict = vec![b'A'; 200];
        for i in 0..56 {
            dict.push(b'a' + ((i % 26) as u8));
        }
        assert_eq!(dict.len(), 256);

        let mut input = Vec::with_capacity(512);
        for i in 0..64 {
            input.push(b'b' + ((i % 13) as u8));
        }
        input.extend(std::iter::repeat_n(b'A', 200));
        for i in 0..(512 - 264) {
            input.push(b'c' + ((i % 13) as u8));
        }
        assert_eq!(input.len(), 512);

        let cases: &[(c_int, &str)] = &[
            (3, "091d000f0d00201f410100b408e0001f6f0d00d3506c6d6e6f63"),
            (4, "091d000f0d00201f410100b40924010f0d00d3506c6d6e6f63"),
            (5, "091d000f0d00201f410100b40924010f0d00d3506c6d6e6f63"),
            (6, "091d000f0d00201f410100b40924010f0d00d3506c6d6e6f63"),
            (7, "091d000f0d00201f410100b40924010f0d00d3506c6d6e6f63"),
            (8, "091d000f0d00201f410100b40924010f0d00d3506c6d6e6f63"),
            (9, "091d000f0d00200f4001b50924010f0d00d3506c6d6e6f63"),
            (10, "091d000f0d00200f4001b50924010f0d00d3506c6d6e6f63"),
            (11, "091d000f0d00200f4001b50924010f0d00d3506c6d6e6f63"),
            (12, "091d000f0d00200f4001b50924010f0d00d3506c6d6e6f63"),
        ];

        for (level, expected_hex) in cases {
            let expected = decode_hex(expected_hex);
            unsafe {
                let stream = LZ4_createStreamHC();
                assert!(!stream.is_null());
                LZ4_resetStreamHC_fast(stream, *level);
                assert_eq!(
                    LZ4_loadDictHC(stream, dict.as_ptr() as *const c_char, dict.len() as c_int),
                    dict.len() as c_int
                );

                let mut compressed = vec![0u8; LZ4_compressBound(input.len() as c_int) as usize];
                let compressed_len = LZ4_compress_HC_continue(
                    stream,
                    input.as_ptr() as *const c_char,
                    compressed.as_mut_ptr() as *mut c_char,
                    input.len() as c_int,
                    compressed.len() as c_int,
                );
                LZ4_freeStreamHC(stream);

                assert_eq!(compressed_len as usize, expected.len(), "level {level}");
                assert_eq!(
                    &compressed[..compressed_len as usize],
                    &expected,
                    "level {level}"
                );
            }
        }
    }

    /// Byte-level parity check for `LZ4_compress_HC_continue()` on the
    /// optimal HC levels (10..=12) with a 256-byte loaded dictionary and a
    /// 1024-byte input. Mirrors the hash-chain version below but covers
    /// `compress_block_hc_optimal()` with a non-zero `base`.
    #[test]
    fn hc_optimal_levels_continue_match_upstream_bytes_with_dictionary() {
        let dict = patterned_hc_input(256);
        let mut input = patterned_hc_input(1024);
        for (i, byte) in input.iter_mut().enumerate() {
            *byte ^= ((i >> 7) & 1) as u8;
        }
        let cases: &[(c_int, &str)] = &[
            (10, "0f00016dff0b39386063626564676669686b6a6d6c6f6e7131303332353437361a00159e47464043424544474634000f4e00100fd00010144562010f1e014010339c00234544c4000e04010f1e012e011a00144262000e34000fd000330445021f434e001e0fd00014234043c4000f1e013d049c0005a7020fa40342356d6e6fa7030a1a000fd00037144409030f34001550676669686b"),
            (11, "0f00016dff0b39386063626564676669686b6a6d6c6f6e7131303332353437361a00159e47464043424544474634000f4e00100fd00010144562010f1e014010339c00234544c4000f0401260f1a000c144262000e34000fd000330445021f434e001e0fd00014234043c4000f1e013d049c0005a7020ea4030fee013305a7030a1a000fd00037144409030f34001550676669686b"),
            (12, "0f00016dff0b39386063626564676669686b6a6d6c6f6e7131303332353437361a00159f474640434245444746340018061a000fd00010144562010f1e014010339c00234544c4000f0401260f1a000c144262000e34000fd000330445021f434e001e0fd00014234043c4000f1e013d049c0005a7020fa40341001a0005a7030a1a000fd00037144409030f34001550676669686b"),
        ];

        for (level, expected_hex) in cases {
            let expected = decode_hex(expected_hex);
            unsafe {
                let stream = LZ4_createStreamHC();
                assert!(!stream.is_null());
                LZ4_resetStreamHC_fast(stream, *level);
                assert_eq!(
                    LZ4_loadDictHC(stream, dict.as_ptr() as *const c_char, dict.len() as c_int),
                    dict.len() as c_int
                );

                let mut compressed = vec![0u8; LZ4_compressBound(input.len() as c_int) as usize];
                let compressed_len = LZ4_compress_HC_continue(
                    stream,
                    input.as_ptr() as *const c_char,
                    compressed.as_mut_ptr() as *mut c_char,
                    input.len() as c_int,
                    compressed.len() as c_int,
                );
                LZ4_freeStreamHC(stream);

                assert_eq!(compressed_len as usize, expected.len(), "level {level}");
                assert_eq!(
                    &compressed[..compressed_len as usize],
                    &expected,
                    "level {level}"
                );
            }
        }
    }

    /// Byte-level parity check for `LZ4_compress_HC_continue()` across the
    /// hash-chain HC levels (3..=9) with a 256-byte loaded dictionary and a
    /// 1024-byte input. Fixtures were produced by the upstream C library
    /// using the same `patterned_hc_input()` helper the Rust tests use.
    #[test]
    fn hc_hashchain_levels_continue_match_upstream_bytes_with_dictionary() {
        let dict = patterned_hc_input(256);
        let mut input = patterned_hc_input(1024);
        for (i, byte) in input.iter_mut().enumerate() {
            *byte ^= ((i >> 7) & 1) as u8;
        }
        let cases: &[(c_int, &str)] = &[
            (3, "0f00016dff0b39386063626564676669686b6a6d6c6f6e7131303332353437361a00159e47464043424544474634000f4e00100fd00010144562010fea00070f1a0027009c00234544c4000fb600070f1a002b144262000e34000fd000330445021f434e001e0fd0001403e3012f40431e013d049c0005a7020fb600070f1a002b05a7030a1a000fd000370445021f4734001550676669686b"),
            (4, "0f00016dff0b39386063626564676669686b6a6d6c6f6e7131303332353437361a00159e47464043424544474634000f4e00100fd00010144562010f1e014010339c00234544c4000e04010f1e012e011a00144262000e34000fd000330445021f434e001e0fd0001403e3012f40431e013d049c0005a7020ed4010fee013305a7030a1a000fd000370445021f4734001550676669686b"),
            (5, "0f00016dff0b39386063626564676669686b6a6d6c6f6e7131303332353437361a00159e47464043424544474634000f4e00100fd00010144562010f1e014010339c00234544c4000e04010f1e012e011a00144262000e34000fd000330445021f434e001e0fd0001403e3012f40431e013d049c0005a7020ed4010f0c033305a7030a1a000fd000370445021f4734001550676669686b"),
            (6, "0f00016dff0b39386063626564676669686b6a6d6c6f6e7131303332353437361a00159e47464043424544474634000f4e00100fd00010144562010f1e014010339c00234544c4000e04010f1e012e011a00144262000e34000fd000330445021f434e001e0fd0001403e3012f40431e013d049c0005a7020fa40342356d6e6fa7030a1a000fd000370445021f4734001550676669686b"),
            (7, "0f00016dff0b39386063626564676669686b6a6d6c6f6e7131303332353437361a00159e47464043424544474634000f4e00100fd00010144562010f1e014010339c00234544c4000e04010f1e012e011a00144262000e34000fd000330445021f434e001e0fd0001403e3012f40431e013d049c0005a7020fa40342356d6e6fa7030a1a000fd000370445021f4734001550676669686b"),
            (8, "0f00016dff0b39386063626564676669686b6a6d6c6f6e7131303332353437361a00159e47464043424544474634000f4e00100fd00010144562010f1e014010339c00234544c4000e04010f1e012e011a00144262000e34000fd000330445021f434e001e0fd0001403e3012f40431e013d049c0005a7020fa40342356d6e6fa7030a1a000fd000370445021f4734001550676669686b"),
            (9, "0f00016dff0b39386063626564676669686b6a6d6c6f6e7131303332353437361a00159e47464043424544474634000f4e00100fd00010144562010f1e014010339c00234544c4000e04010f1e012e011a00144262000e34000fd000330445021f434e001e0fd0001403e3012f40431e013d049c0005a7020fa40342356d6e6fa7030a1a000fd000370445021f4734001550676669686b"),
        ];

        for (level, expected_hex) in cases {
            let expected = decode_hex(expected_hex);
            unsafe {
                let stream = LZ4_createStreamHC();
                assert!(!stream.is_null());
                LZ4_resetStreamHC_fast(stream, *level);
                assert_eq!(
                    LZ4_loadDictHC(stream, dict.as_ptr() as *const c_char, dict.len() as c_int),
                    dict.len() as c_int
                );

                let mut compressed = vec![0u8; LZ4_compressBound(input.len() as c_int) as usize];
                let compressed_len = LZ4_compress_HC_continue(
                    stream,
                    input.as_ptr() as *const c_char,
                    compressed.as_mut_ptr() as *mut c_char,
                    input.len() as c_int,
                    compressed.len() as c_int,
                );
                LZ4_freeStreamHC(stream);

                assert_eq!(compressed_len as usize, expected.len(), "level {level}");
                assert_eq!(
                    &compressed[..compressed_len as usize],
                    &expected,
                    "level {level}"
                );
            }
        }
    }
}