feat(compress): move stream initialization policy into Rust

Move the transparent ZSTD_CCtx_init_compressStream2 initialization policy into Rust. Rust now owns the ordered local-dictionary, prefix, parameter-resolution, pledged-size, worker-selection, and ordinary-buffering decisions through a scalar projection and explicit callbacks. Keep the private CCtx and parameter layouts, allocator and trace state, MT context lifecycle, codec operations, reset behavior, and mutation details in C. The C shim therefore remains the ABI and private-state boundary while the high-level stream setup flow is testable in Rust without duplicating those layouts. Test Plan: - cargo test --manifest-path rust/Cargo.toml --all-targets -- --test-threads=1 - cargo test --manifest-path rust/cli/Cargo.toml --all-targets -- --test-threads=1 - run the legacy Rust feature matrix and all six library/CLI clippy gates with -D warnings - run lib and program native rebuilds plus test-cli-tests, test-rust-lib-smoke, and test-zstd with make -j1 - run fuzzer, zstream, and decode-corpus stress gates serially with ulimit -v 41943040 Commit is intentionally unsigned because GPG pinentry hangs in this non-interactive environment.
2026-07-19 09:43:03 +02:00
parent 492c6292c9
commit a9589d2d7d
2 changed files with 1134 additions and 87 deletions
@@ -272,6 +272,131 @@ typedef char ZSTD_rust_compress_stream_state_layout[
         && sizeof(ZSTD_rust_compressStreamState)
                == 15 * sizeof(void*) + 2 * sizeof(int) + 2 * sizeof(size_t))
        ? 1 : -1];
+
+/* Rust owns only the high-level transparent initialization policy.  The
+ * parameter object, dictionary/context layouts, allocator, trace state, and
+ * codec entry points stay behind these scalar/opaque callbacks. */
+typedef struct {
+    const void* prefixDict;
+    size_t prefixDictSize;
+    int prefixDictContentType;
+    const void* cdict;
+    int cdictIsLocal;
+    int cdictCompressionLevel;
+    size_t cdictDictContentSize;
+} ZSTD_rust_compressStreamInitDictionaryState;
+typedef size_t (*ZSTD_rust_compressStreamInitLocalDict_f)(void* context);
+typedef void (*ZSTD_rust_compressStreamInitRefreshCDict_f)(
+        void* context, ZSTD_rust_compressStreamInitDictionaryState* state);
+typedef void (*ZSTD_rust_compressStreamInitClearPrefix_f)(void* context);
+typedef void (*ZSTD_rust_compressStreamInitAssertDictionaries_f)(
+        void* context, const void* prefixDict);
+typedef void (*ZSTD_rust_compressStreamInitSetLevel_f)(void* params, int level);
+typedef void (*ZSTD_rust_compressStreamInitDebug_f)(void* context);
+typedef U64 (*ZSTD_rust_compressStreamInitGetPledged_f)(void* context);
+typedef void (*ZSTD_rust_compressStreamInitSetPledged_f)(void* context, size_t inSize);
+typedef int (*ZSTD_rust_compressStreamInitGetCParamMode_f)(
+        void* params, const void* cdict, U64 pledgedSrcSize);
+typedef void (*ZSTD_rust_compressStreamInitBuildCParams_f)(
+        void* params, U64 pledgedSrcSize, size_t dictSize, int mode);
+typedef void (*ZSTD_rust_compressStreamInitResolveParams_f)(
+        void* params, int operation);
+typedef unsigned (*ZSTD_rust_compressStreamInitGetNbWorkers_f)(void* params);
+typedef void (*ZSTD_rust_compressStreamInitSetNbWorkers_f)(
+        void* params, unsigned nbWorkers);
+typedef int (*ZSTD_rust_compressStreamInitHasExtSeqProd_f)(void* params);
+typedef void (*ZSTD_rust_compressStreamInitTrace_f)(void* context);
+typedef void* (*ZSTD_rust_compressStreamInitGetMTContext_f)(void* context);
+typedef size_t (*ZSTD_rust_compressStreamInitCreateMTContext_f)(
+        void* context, unsigned nbWorkers);
+typedef size_t (*ZSTD_rust_compressStreamInitMT_f)(
+        void* context, void* mtctx,
+        const ZSTD_rust_compressStreamInitDictionaryState* dictionaries,
+        void* params, U64 pledgedSrcSize);
+typedef void (*ZSTD_rust_compressStreamInitCommitMT_f)(
+        void* context,
+        const ZSTD_rust_compressStreamInitDictionaryState* dictionaries,
+        void* params);
+typedef void (*ZSTD_rust_compressStreamInitCheckCParams_f)(void* params);
+typedef size_t (*ZSTD_rust_compressStreamInitBegin_f)(
+        void* context,
+        const ZSTD_rust_compressStreamInitDictionaryState* dictionaries,
+        void* params, U64 pledgedSrcSize);
+typedef void (*ZSTD_rust_compressStreamInitAssertOrdinary_f)(void* context);
+typedef int (*ZSTD_rust_compressStreamInitGetBufferMode_f)(void* context);
+typedef size_t (*ZSTD_rust_compressStreamInitGetBlockSize_f)(void* context);
+typedef void (*ZSTD_rust_compressStreamInitCommitOrdinary_f)(
+        void* context, size_t inBuffTarget);
+typedef struct {
+    void* callbackContext;
+    void* params;
+    ZSTD_rust_compressStreamInitDictionaryState* dictionaries;
+    int endOp;
+    size_t inSize;
+    int multithreaded;
+    size_t mtJobSizeMin;
+    ZSTD_rust_compressStreamInitLocalDict_f initLocalDict;
+    ZSTD_rust_compressStreamInitRefreshCDict_f refreshCDict;
+    ZSTD_rust_compressStreamInitClearPrefix_f clearPrefix;
+    ZSTD_rust_compressStreamInitAssertDictionaries_f assertDictionaries;
+    ZSTD_rust_compressStreamInitSetLevel_f setCompressionLevel;
+    ZSTD_rust_compressStreamInitDebug_f debugInit;
+    ZSTD_rust_compressStreamInitGetPledged_f getPledgedSrcSizePlusOne;
+    ZSTD_rust_compressStreamInitSetPledged_f setPledgedSrcSize;
+    ZSTD_rust_compressStreamInitGetCParamMode_f getCParamMode;
+    ZSTD_rust_compressStreamInitBuildCParams_f buildCParams;
+    ZSTD_rust_compressStreamInitResolveParams_f resolveParams;
+    ZSTD_rust_compressStreamInitGetNbWorkers_f getNbWorkers;
+    ZSTD_rust_compressStreamInitSetNbWorkers_f setNbWorkers;
+    ZSTD_rust_compressStreamInitHasExtSeqProd_f hasExtSeqProd;
+    ZSTD_rust_compressStreamInitTrace_f traceBegin;
+    ZSTD_rust_compressStreamInitGetMTContext_f getMTContext;
+    ZSTD_rust_compressStreamInitCreateMTContext_f createMTContext;
+    ZSTD_rust_compressStreamInitMT_f initMT;
+    ZSTD_rust_compressStreamInitCommitMT_f commitMT;
+    ZSTD_rust_compressStreamInitCheckCParams_f checkCParams;
+    ZSTD_rust_compressStreamInitBegin_f compressBegin;
+    ZSTD_rust_compressStreamInitAssertOrdinary_f assertOrdinary;
+    ZSTD_rust_compressStreamInitGetBufferMode_f getBufferMode;
+    ZSTD_rust_compressStreamInitGetBlockSize_f getBlockSize;
+    ZSTD_rust_compressStreamInitCommitOrdinary_f commitOrdinary;
+} ZSTD_rust_compressStreamInitState;
+typedef char ZSTD_rust_compress_stream_init_dictionary_layout[
+        (offsetof(ZSTD_rust_compressStreamInitDictionaryState, prefixDict) == 0
+         && offsetof(ZSTD_rust_compressStreamInitDictionaryState, prefixDictSize)
+                == sizeof(void*)
+         && offsetof(ZSTD_rust_compressStreamInitDictionaryState, prefixDictContentType)
+                == 2 * sizeof(void*)
+         && offsetof(ZSTD_rust_compressStreamInitDictionaryState, cdict)
+                == 3 * sizeof(void*)
+         && offsetof(ZSTD_rust_compressStreamInitDictionaryState, cdictIsLocal)
+                == 4 * sizeof(void*)
+         && offsetof(ZSTD_rust_compressStreamInitDictionaryState, cdictCompressionLevel)
+                == 4 * sizeof(void*) + sizeof(int)
+         && offsetof(ZSTD_rust_compressStreamInitDictionaryState, cdictDictContentSize)
+                == 4 * sizeof(void*) + 2 * sizeof(int)
+         && sizeof(ZSTD_rust_compressStreamInitDictionaryState)
+                == (sizeof(void*) == 8 ? 48 : 28))
+        ? 1 : -1];
+typedef char ZSTD_rust_compress_stream_init_state_layout[
+        (offsetof(ZSTD_rust_compressStreamInitState, callbackContext) == 0
+         && offsetof(ZSTD_rust_compressStreamInitState, params) == sizeof(void*)
+         && offsetof(ZSTD_rust_compressStreamInitState, dictionaries)
+                == 2 * sizeof(void*)
+         && offsetof(ZSTD_rust_compressStreamInitState, endOp)
+                == 3 * sizeof(void*)
+         && offsetof(ZSTD_rust_compressStreamInitState, inSize)
+                == 4 * sizeof(void*)
+         && offsetof(ZSTD_rust_compressStreamInitState, multithreaded)
+                == 4 * sizeof(void*) + sizeof(size_t)
+         && offsetof(ZSTD_rust_compressStreamInitState, mtJobSizeMin)
+                == 5 * sizeof(void*) + sizeof(size_t)
+         && sizeof(ZSTD_rust_compressStreamInitState)
+                == (sizeof(void*) == 8 ? 256 : 128))
+        ? 1 : -1];
+size_t ZSTD_rust_compressStreamInit(
+        const ZSTD_rust_compressStreamInitState* state);
+
 /* The target-sized block body only needs this narrow projection of ZSTD_CCtx.
 * Matchfinder/window state, sequence-store construction, and outer repeat-mode
 * cleanup remain in C. */
@@ -4740,100 +4865,317 @@ static size_t ZSTD_checkBufferStability(ZSTD_CCtx const* cctx,
 * Otherwise, it's ignored.
 * @return: 0 on success, or a ZSTD_error code otherwise.
 */
+enum {
+    ZSTD_RUST_INIT_RESOLVE_BLOCK_SPLITTER = 0,
+    ZSTD_RUST_INIT_RESOLVE_LDM = 1,
+    ZSTD_RUST_INIT_RESOLVE_ROW_MATCH_FINDER = 2,
+    ZSTD_RUST_INIT_RESOLVE_VALIDATE_SEQUENCES = 3,
+    ZSTD_RUST_INIT_RESOLVE_MAX_BLOCK_SIZE = 4,
+    ZSTD_RUST_INIT_RESOLVE_EXTERNAL_REPCODE_SEARCH = 5
+};
+
+static size_t ZSTD_rust_compressStreamInit_localDict(void* context)
+{
+    return ZSTD_initLocalDict((ZSTD_CCtx*)context);
+}
+
+static void ZSTD_rust_compressStreamInit_refreshCDict(
+        void* context, ZSTD_rust_compressStreamInitDictionaryState* state)
+{
+    ZSTD_CCtx const* const cctx = (ZSTD_CCtx const*)context;
+    state->cdict = cctx->cdict;
+    state->cdictIsLocal = cctx->localDict.cdict != NULL;
+    state->cdictCompressionLevel = cctx->cdict ? cctx->cdict->compressionLevel : 0;
+    state->cdictDictContentSize = cctx->cdict ? cctx->cdict->dictContentSize : 0;
+}
+
+static void ZSTD_rust_compressStreamInit_clearPrefix(void* context)
+{
+    ZSTD_CCtx* const cctx = (ZSTD_CCtx*)context;
+    ZSTD_memset(&cctx->prefixDict, 0, sizeof(cctx->prefixDict));
+}
+
+static void ZSTD_rust_compressStreamInit_assertDictionaries(
+        void* context, const void* prefixDict)
+{
+    ZSTD_CCtx const* const cctx = (ZSTD_CCtx const*)context;
+    (void)cctx;
+    (void)prefixDict;
+    assert(prefixDict == NULL || cctx->cdict == NULL);
+}
+
+static void ZSTD_rust_compressStreamInit_setLevel(void* params, int level)
+{
+    ((ZSTD_CCtx_params*)params)->compressionLevel = level;
+}
+
+static void ZSTD_rust_compressStreamInit_debug(void* context)
+{
+    (void)context;
+    DEBUGLOG(4, "ZSTD_CCtx_init_compressStream2 : transparent init stage");
+}
+
+static U64 ZSTD_rust_compressStreamInit_getPledged(void* context)
+{
+    return ((ZSTD_CCtx const*)context)->pledgedSrcSizePlusOne;
+}
+
+static void ZSTD_rust_compressStreamInit_setPledged(void* context, size_t inSize)
+{
+    ((ZSTD_CCtx*)context)->pledgedSrcSizePlusOne = inSize + 1;
+}
+
+static int ZSTD_rust_compressStreamInit_getCParamMode(
+        void* params, const void* cdict, U64 pledgedSrcSize)
+{
+    return (int)ZSTD_getCParamMode(
+            (const ZSTD_CDict*)cdict, (const ZSTD_CCtx_params*)params, pledgedSrcSize);
+}
+
+static void ZSTD_rust_compressStreamInit_buildCParams(
+        void* params, U64 pledgedSrcSize, size_t dictSize, int mode)
+{
+    ZSTD_CCtx_params* const cctxParams = (ZSTD_CCtx_params*)params;
+    cctxParams->cParams = ZSTD_getCParamsFromCCtxParams(
+            cctxParams, pledgedSrcSize, dictSize, (ZSTD_CParamMode_e)mode);
+}
+
+static void ZSTD_rust_compressStreamInit_resolveParams(void* params, int operation)
+{
+    ZSTD_CCtx_params* const cctxParams = (ZSTD_CCtx_params*)params;
+    switch (operation) {
+        case ZSTD_RUST_INIT_RESOLVE_BLOCK_SPLITTER:
+            cctxParams->postBlockSplitter = ZSTD_resolveBlockSplitterMode(
+                    cctxParams->postBlockSplitter, &cctxParams->cParams);
+            break;
+        case ZSTD_RUST_INIT_RESOLVE_LDM:
+            cctxParams->ldmParams.enableLdm = ZSTD_resolveEnableLdm(
+                    cctxParams->ldmParams.enableLdm, &cctxParams->cParams);
+            break;
+        case ZSTD_RUST_INIT_RESOLVE_ROW_MATCH_FINDER:
+            cctxParams->useRowMatchFinder = ZSTD_resolveRowMatchFinderMode(
+                    cctxParams->useRowMatchFinder, &cctxParams->cParams);
+            break;
+        case ZSTD_RUST_INIT_RESOLVE_VALIDATE_SEQUENCES:
+            cctxParams->validateSequences = ZSTD_resolveExternalSequenceValidation(
+                    cctxParams->validateSequences);
+            break;
+        case ZSTD_RUST_INIT_RESOLVE_MAX_BLOCK_SIZE:
+            cctxParams->maxBlockSize = ZSTD_resolveMaxBlockSize(cctxParams->maxBlockSize);
+            break;
+        case ZSTD_RUST_INIT_RESOLVE_EXTERNAL_REPCODE_SEARCH:
+            cctxParams->searchForExternalRepcodes = ZSTD_resolveExternalRepcodeSearch(
+                    cctxParams->searchForExternalRepcodes, cctxParams->compressionLevel);
+            break;
+        default:
+            assert(0);
+            break;
+    }
+}
+
+static unsigned ZSTD_rust_compressStreamInit_getNbWorkers(void* params)
+{
+    return ((ZSTD_CCtx_params const*)params)->nbWorkers;
+}
+
+static void ZSTD_rust_compressStreamInit_setNbWorkers(void* params, unsigned nbWorkers)
+{
+    ((ZSTD_CCtx_params*)params)->nbWorkers = nbWorkers;
+}
+
+static int ZSTD_rust_compressStreamInit_hasExtSeqProd(void* params)
+{
+    return ZSTD_hasExtSeqProd((ZSTD_CCtx_params const*)params);
+}
+
+static void ZSTD_rust_compressStreamInit_trace(void* context)
+{
+#if ZSTD_TRACE
+    ZSTD_CCtx* const cctx = (ZSTD_CCtx*)context;
+    cctx->traceCtx = (ZSTD_trace_compress_begin != NULL)
+            ? ZSTD_trace_compress_begin(cctx) : 0;
+#else
+    (void)context;
+#endif
+}
+
+static void* ZSTD_rust_compressStreamInit_getMTContext(void* context)
+{
+#ifdef ZSTD_MULTITHREAD
+    return ((ZSTD_CCtx*)context)->mtctx;
+#else
+    (void)context;
+    return NULL;
+#endif
+}
+
+static size_t ZSTD_rust_compressStreamInit_createMTContext(
+        void* context, unsigned nbWorkers)
+{
+#ifdef ZSTD_MULTITHREAD
+    ZSTD_CCtx* const cctx = (ZSTD_CCtx*)context;
+    DEBUGLOG(4, "ZSTD_compressStream2: creating new mtctx for nbWorkers=%u", nbWorkers);
+    cctx->mtctx = ZSTDMT_createCCtx_advanced(
+            (U32)nbWorkers, cctx->customMem, cctx->pool);
+    RETURN_ERROR_IF(cctx->mtctx == NULL, memory_allocation, "NULL pointer!");
+    return 0;
+#else
+    (void)context;
+    (void)nbWorkers;
+    return ERROR(memory_allocation);
+#endif
+}
+
+static size_t ZSTD_rust_compressStreamInit_mt(
+        void* context, void* mtctx,
+        const ZSTD_rust_compressStreamInitDictionaryState* dictionaries,
+        void* params, U64 pledgedSrcSize)
+{
+#ifdef ZSTD_MULTITHREAD
+    (void)context;
+    DEBUGLOG(4, "call ZSTDMT_initCStream_internal as nbWorkers=%u",
+             ((ZSTD_CCtx_params const*)params)->nbWorkers);
+    return ZSTDMT_initCStream_internal(
+            (ZSTDMT_CCtx*)mtctx,
+            dictionaries->prefixDict, dictionaries->prefixDictSize,
+            (ZSTD_dictContentType_e)dictionaries->prefixDictContentType,
+            (const ZSTD_CDict*)dictionaries->cdict,
+            *(const ZSTD_CCtx_params*)params, pledgedSrcSize);
+#else
+    (void)context;
+    (void)mtctx;
+    (void)dictionaries;
+    (void)params;
+    (void)pledgedSrcSize;
+    return ERROR(memory_allocation);
+#endif
+}
+
+static void ZSTD_rust_compressStreamInit_commitMT(
+        void* context,
+        const ZSTD_rust_compressStreamInitDictionaryState* dictionaries,
+        void* params)
+{
+#ifdef ZSTD_MULTITHREAD
+    ZSTD_CCtx* const cctx = (ZSTD_CCtx*)context;
+    cctx->dictID = cctx->cdict ? cctx->cdict->dictID : 0;
+    cctx->dictContentSize = cctx->cdict
+            ? cctx->cdict->dictContentSize : dictionaries->prefixDictSize;
+    cctx->consumedSrcSize = 0;
+    cctx->producedCSize = 0;
+    cctx->streamStage = zcss_load;
+    cctx->appliedParams = *(const ZSTD_CCtx_params*)params;
+#else
+    (void)context;
+    (void)dictionaries;
+    (void)params;
+#endif
+}
+
+static void ZSTD_rust_compressStreamInit_checkCParams(void* params)
+{
+    (void)params;
+    assert(!ZSTD_isError(ZSTD_checkCParams(
+            ((ZSTD_CCtx_params const*)params)->cParams)));
+}
+
+static size_t ZSTD_rust_compressStreamInit_begin(
+        void* context,
+        const ZSTD_rust_compressStreamInitDictionaryState* dictionaries,
+        void* params, U64 pledgedSrcSize)
+{
+    ZSTD_CCtx* const cctx = (ZSTD_CCtx*)context;
+    return ZSTD_compressBegin_internal(
+            cctx,
+            dictionaries->prefixDict, dictionaries->prefixDictSize,
+            (ZSTD_dictContentType_e)dictionaries->prefixDictContentType, ZSTD_dtlm_fast,
+            (const ZSTD_CDict*)dictionaries->cdict,
+            (const ZSTD_CCtx_params*)params, pledgedSrcSize, ZSTDb_buffered);
+}
+
+static void ZSTD_rust_compressStreamInit_assertOrdinary(void* context)
+{
+    (void)context;
+    assert(((ZSTD_CCtx const*)context)->appliedParams.nbWorkers == 0);
+}
+
+static int ZSTD_rust_compressStreamInit_getBufferMode(void* context)
+{
+    return (int)((ZSTD_CCtx const*)context)->appliedParams.inBufferMode;
+}
+
+static size_t ZSTD_rust_compressStreamInit_getBlockSize(void* context)
+{
+    return ((ZSTD_CCtx const*)context)->blockSizeMax;
+}
+
+static void ZSTD_rust_compressStreamInit_commitOrdinary(
+        void* context, size_t inBuffTarget)
+{
+    ZSTD_CCtx* const cctx = (ZSTD_CCtx*)context;
+    cctx->inToCompress = 0;
+    cctx->inBuffPos = 0;
+    cctx->inBuffTarget = inBuffTarget;
+    cctx->outBuffContentSize = cctx->outBuffFlushedSize = 0;
+    cctx->streamStage = zcss_load;
+    cctx->frameEnded = 0;
+}
+
 static size_t ZSTD_CCtx_init_compressStream2(ZSTD_CCtx* cctx,
                                             ZSTD_EndDirective endOp,
                                             size_t inSize)
 {
    ZSTD_CCtx_params params = cctx->requestedParams;
    ZSTD_prefixDict const prefixDict = cctx->prefixDict;
-    FORWARD_IF_ERROR( ZSTD_initLocalDict(cctx) , ""); /* Init the local dict if present. */
-    ZSTD_memset(&cctx->prefixDict, 0, sizeof(cctx->prefixDict));   /* single usage */
-    assert(prefixDict.dict==NULL || cctx->cdict==NULL);    /* only one can be set */
-    if (cctx->cdict && !cctx->localDict.cdict) {
-        /* Let the cdict's compression level take priority over the requested params.
-         * But do not take the cdict's compression level if the "cdict" is actually a localDict
-         * generated from ZSTD_initLocalDict().
-         */
-        params.compressionLevel = cctx->cdict->compressionLevel;
-    }
-    DEBUGLOG(4, "ZSTD_CCtx_init_compressStream2 : transparent init stage");
-    if (endOp == ZSTD_e_end) cctx->pledgedSrcSizePlusOne = inSize + 1;  /* auto-determine pledgedSrcSize */
-
-    {   size_t const dictSize = prefixDict.dict
-                ? prefixDict.dictSize
-                : (cctx->cdict ? cctx->cdict->dictContentSize : 0);
-        ZSTD_CParamMode_e const mode = ZSTD_getCParamMode(cctx->cdict, &params, cctx->pledgedSrcSizePlusOne - 1);
-        params.cParams = ZSTD_getCParamsFromCCtxParams(
-                &params, cctx->pledgedSrcSizePlusOne-1,
-                dictSize, mode);
-    }
-
-    params.postBlockSplitter = ZSTD_resolveBlockSplitterMode(params.postBlockSplitter, &params.cParams);
-    params.ldmParams.enableLdm = ZSTD_resolveEnableLdm(params.ldmParams.enableLdm, &params.cParams);
-    params.useRowMatchFinder = ZSTD_resolveRowMatchFinderMode(params.useRowMatchFinder, &params.cParams);
-    params.validateSequences = ZSTD_resolveExternalSequenceValidation(params.validateSequences);
-    params.maxBlockSize = ZSTD_resolveMaxBlockSize(params.maxBlockSize);
-    params.searchForExternalRepcodes = ZSTD_resolveExternalRepcodeSearch(params.searchForExternalRepcodes, params.compressionLevel);
-
+    ZSTD_rust_compressStreamInitDictionaryState dictionaries = {
+        prefixDict.dict,
+        prefixDict.dictSize,
+        (int)prefixDict.dictContentType,
+        NULL,
+        0,
+        0,
+        0
+    };
+    ZSTD_rust_compressStreamInitState state = {
+        cctx,
+        &params,
+        &dictionaries,
+        (int)endOp,
+        inSize,
 #ifdef ZSTD_MULTITHREAD
-    /* If external matchfinder is enabled, make sure to fail before checking job size (for consistency) */
-    RETURN_ERROR_IF(
-        ZSTD_hasExtSeqProd(&params) && params.nbWorkers >= 1,
-        parameter_combination_unsupported,
-        "External sequence producer isn't supported with nbWorkers >= 1"
-    );
-
-    if ((cctx->pledgedSrcSizePlusOne-1) <= ZSTDMT_JOBSIZE_MIN) {
-        params.nbWorkers = 0; /* do not invoke multi-threading when src size is too small */
-    }
-    if (params.nbWorkers > 0) {
-# if ZSTD_TRACE
-        cctx->traceCtx = (ZSTD_trace_compress_begin != NULL) ? ZSTD_trace_compress_begin(cctx) : 0;
-# endif
-        /* mt context creation */
-        if (cctx->mtctx == NULL) {
-            DEBUGLOG(4, "ZSTD_compressStream2: creating new mtctx for nbWorkers=%u",
-                        params.nbWorkers);
-            cctx->mtctx = ZSTDMT_createCCtx_advanced((U32)params.nbWorkers, cctx->customMem, cctx->pool);
-            RETURN_ERROR_IF(cctx->mtctx == NULL, memory_allocation, "NULL pointer!");
-        }
-        /* mt compression */
-        DEBUGLOG(4, "call ZSTDMT_initCStream_internal as nbWorkers=%u", params.nbWorkers);
-        FORWARD_IF_ERROR( ZSTDMT_initCStream_internal(
-                    cctx->mtctx,
-                    prefixDict.dict, prefixDict.dictSize, prefixDict.dictContentType,
-                    cctx->cdict, params, cctx->pledgedSrcSizePlusOne-1) , "");
-        cctx->dictID = cctx->cdict ? cctx->cdict->dictID : 0;
-        cctx->dictContentSize = cctx->cdict ? cctx->cdict->dictContentSize : prefixDict.dictSize;
-        cctx->consumedSrcSize = 0;
-        cctx->producedCSize = 0;
-        cctx->streamStage = zcss_load;
-        cctx->appliedParams = params;
-    } else
-#endif  /* ZSTD_MULTITHREAD */
-    {   U64 const pledgedSrcSize = cctx->pledgedSrcSizePlusOne - 1;
-        assert(!ZSTD_isError(ZSTD_checkCParams(params.cParams)));
-        FORWARD_IF_ERROR( ZSTD_compressBegin_internal(cctx,
-                prefixDict.dict, prefixDict.dictSize, prefixDict.dictContentType, ZSTD_dtlm_fast,
-                cctx->cdict,
-                &params, pledgedSrcSize,
-                ZSTDb_buffered) , "");
-        assert(cctx->appliedParams.nbWorkers == 0);
-        cctx->inToCompress = 0;
-        cctx->inBuffPos = 0;
-        if (cctx->appliedParams.inBufferMode == ZSTD_bm_buffered) {
-            /* for small input: avoid automatic flush on reaching end of block, since
-            * it would require to add a 3-bytes null block to end frame
-            */
-            cctx->inBuffTarget = cctx->blockSizeMax + (cctx->blockSizeMax == pledgedSrcSize);
-        } else {
-            cctx->inBuffTarget = 0;
-        }
-        cctx->outBuffContentSize = cctx->outBuffFlushedSize = 0;
-        cctx->streamStage = zcss_load;
-        cctx->frameEnded = 0;
-    }
-    return 0;
+        1,
+        ZSTDMT_JOBSIZE_MIN,
+#else
+        0,
+        0,
+#endif
+        ZSTD_rust_compressStreamInit_localDict,
+        ZSTD_rust_compressStreamInit_refreshCDict,
+        ZSTD_rust_compressStreamInit_clearPrefix,
+        ZSTD_rust_compressStreamInit_assertDictionaries,
+        ZSTD_rust_compressStreamInit_setLevel,
+        ZSTD_rust_compressStreamInit_debug,
+        ZSTD_rust_compressStreamInit_getPledged,
+        ZSTD_rust_compressStreamInit_setPledged,
+        ZSTD_rust_compressStreamInit_getCParamMode,
+        ZSTD_rust_compressStreamInit_buildCParams,
+        ZSTD_rust_compressStreamInit_resolveParams,
+        ZSTD_rust_compressStreamInit_getNbWorkers,
+        ZSTD_rust_compressStreamInit_setNbWorkers,
+        ZSTD_rust_compressStreamInit_hasExtSeqProd,
+        ZSTD_rust_compressStreamInit_trace,
+        ZSTD_rust_compressStreamInit_getMTContext,
+        ZSTD_rust_compressStreamInit_createMTContext,
+        ZSTD_rust_compressStreamInit_mt,
+        ZSTD_rust_compressStreamInit_commitMT,
+        ZSTD_rust_compressStreamInit_checkCParams,
+        ZSTD_rust_compressStreamInit_begin,
+        ZSTD_rust_compressStreamInit_assertOrdinary,
+        ZSTD_rust_compressStreamInit_getBufferMode,
+        ZSTD_rust_compressStreamInit_getBlockSize,
+        ZSTD_rust_compressStreamInit_commitOrdinary
+    };
+    return ZSTD_rust_compressStreamInit(&state);
 }

 /* @return provides a minimum amount of data remaining to be flushed from internal buffers