[pcsx_rearmed.git] / deps / libchdr / deps / zstd-1.5.5 / tests / regression / config.c

/*
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 * All rights reserved.
 *
 * This source code is licensed under both the BSD-style license (found in the
 * LICENSE file in the root directory of this source tree) and the GPLv2 (found
 * in the COPYING file in the root directory of this source tree).
 * You may select, at your option, one of the above-listed licenses.
 */

#include "config.h"

/* Define a config for each fast level we want to test with. */
#define FAST_LEVEL(x)                                               \
    param_value_t const level_fast##x##_param_values[] = {          \
        {.param = ZSTD_c_compressionLevel, .value = -x},            \
    };                                                              \
    config_t const level_fast##x = {                                \
        .name = "level -" #x,                                       \
        .cli_args = "--fast=" #x,                                   \
        .param_values = PARAM_VALUES(level_fast##x##_param_values), \
    };                                                              \
    config_t const level_fast##x##_dict = {                         \
        .name = "level -" #x " with dict",                          \
        .cli_args = "--fast=" #x,                                   \
        .param_values = PARAM_VALUES(level_fast##x##_param_values), \
        .use_dictionary = 1,                                        \
    };

/* Define a config for each level we want to test with. */
#define LEVEL(x)                                                                  \
    param_value_t const level_##x##_param_values[] = {                            \
        {.param = ZSTD_c_compressionLevel, .value = x},                           \
    };                                                                            \
    param_value_t const level_##x##_param_values_dms[] = {                        \
        {.param = ZSTD_c_compressionLevel, .value = x},                           \
        {.param = ZSTD_c_enableDedicatedDictSearch, .value = 0},                  \
        {.param = ZSTD_c_forceAttachDict, .value = ZSTD_dictForceAttach},         \
    };                                                                            \
    param_value_t const level_##x##_param_values_dds[] = {                        \
        {.param = ZSTD_c_compressionLevel, .value = x},                           \
        {.param = ZSTD_c_enableDedicatedDictSearch, .value = 1},                  \
        {.param = ZSTD_c_forceAttachDict, .value = ZSTD_dictForceAttach},         \
    };                                                                            \
    param_value_t const level_##x##_param_values_dictcopy[] = {                   \
        {.param = ZSTD_c_compressionLevel, .value = x},                           \
        {.param = ZSTD_c_enableDedicatedDictSearch, .value = 0},                  \
        {.param = ZSTD_c_forceAttachDict, .value = ZSTD_dictForceCopy},           \
    };                                                                            \
    param_value_t const level_##x##_param_values_dictload[] = {                   \
        {.param = ZSTD_c_compressionLevel, .value = x},                           \
        {.param = ZSTD_c_enableDedicatedDictSearch, .value = 0},                  \
        {.param = ZSTD_c_forceAttachDict, .value = ZSTD_dictForceLoad},           \
    };                                                                            \
    config_t const level_##x = {                                                  \
        .name = "level " #x,                                                      \
        .cli_args = "-" #x,                                                       \
        .param_values = PARAM_VALUES(level_##x##_param_values),                   \
    };                                                                            \
    config_t const level_##x##_dict = {                                           \
        .name = "level " #x " with dict",                                         \
        .cli_args = "-" #x,                                                       \
        .param_values = PARAM_VALUES(level_##x##_param_values),                   \
        .use_dictionary = 1,                                                      \
    };                                                                            \
    config_t const level_##x##_dict_dms = {                                       \
        .name = "level " #x " with dict dms",                                     \
        .cli_args = "-" #x,                                                       \
        .param_values = PARAM_VALUES(level_##x##_param_values_dms),               \
        .use_dictionary = 1,                                                      \
        .advanced_api_only = 1,                                                   \
    };                                                                            \
    config_t const level_##x##_dict_dds = {                                       \
        .name = "level " #x " with dict dds",                                     \
        .cli_args = "-" #x,                                                       \
        .param_values = PARAM_VALUES(level_##x##_param_values_dds),               \
        .use_dictionary = 1,                                                      \
        .advanced_api_only = 1,                                                   \
    };                                                                            \
    config_t const level_##x##_dict_copy = {                                      \
        .name = "level " #x " with dict copy",                                    \
        .cli_args = "-" #x,                                                       \
        .param_values = PARAM_VALUES(level_##x##_param_values_dictcopy),          \
        .use_dictionary = 1,                                                      \
        .advanced_api_only = 1,                                                   \
    };                                                                            \
    config_t const level_##x##_dict_load = {                                      \
        .name = "level " #x " with dict load",                                    \
        .cli_args = "-" #x,                                                       \
        .param_values = PARAM_VALUES(level_##x##_param_values_dictload),          \
        .use_dictionary = 1,                                                      \
        .advanced_api_only = 1,                                                   \
    };

/* Define a config specifically to test row hash based levels and settings.
 */
#define ROW_LEVEL(x, y)                                                            \
    param_value_t const row_##y##_level_##x##_param_values[] = {                   \
        {.param = ZSTD_c_useRowMatchFinder, .value = y},                           \
        {.param = ZSTD_c_compressionLevel, .value = x},                            \
    };                                                                             \
    param_value_t const row_##y##_level_##x##_param_values_dms[] = {               \
        {.param = ZSTD_c_useRowMatchFinder, .value = y},                           \
        {.param = ZSTD_c_compressionLevel, .value = x},                            \
        {.param = ZSTD_c_enableDedicatedDictSearch, .value = 0},                   \
        {.param = ZSTD_c_forceAttachDict, .value = ZSTD_dictForceAttach},          \
    };                                                                             \
    param_value_t const row_##y##_level_##x##_param_values_dds[] = {               \
        {.param = ZSTD_c_useRowMatchFinder, .value = y},                           \
        {.param = ZSTD_c_compressionLevel, .value = x},                            \
        {.param = ZSTD_c_enableDedicatedDictSearch, .value = 1},                   \
        {.param = ZSTD_c_forceAttachDict, .value = ZSTD_dictForceAttach},          \
    };                                                                             \
    param_value_t const row_##y##_level_##x##_param_values_dictcopy[] = {          \
        {.param = ZSTD_c_useRowMatchFinder, .value = y},                           \
        {.param = ZSTD_c_compressionLevel, .value = x},                            \
        {.param = ZSTD_c_enableDedicatedDictSearch, .value = 0},                   \
        {.param = ZSTD_c_forceAttachDict, .value = ZSTD_dictForceCopy},            \
    };                                                                             \
    param_value_t const row_##y##_level_##x##_param_values_dictload[] = {          \
        {.param = ZSTD_c_useRowMatchFinder, .value = y},                           \
        {.param = ZSTD_c_compressionLevel, .value = x},                            \
        {.param = ZSTD_c_enableDedicatedDictSearch, .value = 0},                   \
        {.param = ZSTD_c_forceAttachDict, .value = ZSTD_dictForceLoad},            \
    };                                                                             \
    config_t const row_##y##_level_##x = {                                         \
        .name = "level " #x " row " #y,                                            \
        .cli_args = "-" #x,                                                        \
        .param_values = PARAM_VALUES(row_##y##_level_##x##_param_values),          \
        .advanced_api_only = 1,                                                    \
    };                                                                             \
    config_t const row_##y##_level_##x##_dict_dms = {                              \
        .name = "level " #x " row " #y " with dict dms",                           \
        .cli_args = "-" #x,                                                        \
        .param_values = PARAM_VALUES(row_##y##_level_##x##_param_values_dms),      \
        .use_dictionary = 1,                                                       \
        .advanced_api_only = 1,                                                    \
    };                                                                             \
    config_t const row_##y##_level_##x##_dict_dds = {                              \
        .name = "level " #x " row " #y " with dict dds",                           \
        .cli_args = "-" #x,                                                        \
        .param_values = PARAM_VALUES(row_##y##_level_##x##_param_values_dds),      \
        .use_dictionary = 1,                                                       \
        .advanced_api_only = 1,                                                    \
    };                                                                             \
    config_t const row_##y##_level_##x##_dict_copy = {                             \
        .name = "level " #x " row " #y" with dict copy",                          \
        .cli_args = "-" #x,                                                        \
        .param_values = PARAM_VALUES(row_##y##_level_##x##_param_values_dictcopy), \
        .use_dictionary = 1,                                                       \
        .advanced_api_only = 1,                                                    \
    };                                                                             \
    config_t const row_##y##_level_##x##_dict_load = {                             \
        .name = "level " #x " row " #y " with dict load",                          \
        .cli_args = "-" #x,                                                        \
        .param_values = PARAM_VALUES(row_##y##_level_##x##_param_values_dictload), \
        .use_dictionary = 1,                                                       \
        .advanced_api_only = 1,                                                    \
    };

#define PARAM_VALUES(pv) \
    { .data = pv, .size = sizeof(pv) / sizeof((pv)[0]) }

#include "levels.h"

#undef LEVEL
#undef FAST_LEVEL
#undef ROW_LEVEL

static config_t no_pledged_src_size = {
    .name = "no source size",
    .cli_args = "",
    .param_values = PARAM_VALUES(level_0_param_values),
    .no_pledged_src_size = 1,
};

static config_t no_pledged_src_size_with_dict = {
    .name = "no source size with dict",
    .cli_args = "",
    .param_values = PARAM_VALUES(level_0_param_values),
    .no_pledged_src_size = 1,
    .use_dictionary = 1,
};

static param_value_t const ldm_param_values[] = {
    {.param = ZSTD_c_enableLongDistanceMatching, .value = ZSTD_ps_enable},
};

static config_t ldm = {
    .name = "long distance mode",
    .cli_args = "--long",
    .param_values = PARAM_VALUES(ldm_param_values),
};

static param_value_t const mt_param_values[] = {
    {.param = ZSTD_c_nbWorkers, .value = 2},
};

static config_t mt = {
    .name = "multithreaded",
    .cli_args = "-T2",
    .param_values = PARAM_VALUES(mt_param_values),
};

static param_value_t const mt_ldm_param_values[] = {
    {.param = ZSTD_c_nbWorkers, .value = 2},
    {.param = ZSTD_c_enableLongDistanceMatching, .value = ZSTD_ps_enable},
};

static config_t mt_ldm = {
    .name = "multithreaded long distance mode",
    .cli_args = "-T2 --long",
    .param_values = PARAM_VALUES(mt_ldm_param_values),
};

static param_value_t mt_advanced_param_values[] = {
    {.param = ZSTD_c_nbWorkers, .value = 2},
    {.param = ZSTD_c_literalCompressionMode, .value = ZSTD_ps_disable},
};

static config_t mt_advanced = {
    .name = "multithreaded with advanced params",
    .cli_args = "-T2 --no-compress-literals",
    .param_values = PARAM_VALUES(mt_advanced_param_values),
};

static param_value_t const small_wlog_param_values[] = {
    {.param = ZSTD_c_windowLog, .value = 10},
};

static config_t small_wlog = {
    .name = "small window log",
    .cli_args = "--zstd=wlog=10",
    .param_values = PARAM_VALUES(small_wlog_param_values),
};

static param_value_t const small_hlog_param_values[] = {
    {.param = ZSTD_c_hashLog, .value = 6},
    {.param = ZSTD_c_strategy, .value = (int)ZSTD_btopt},
};

static config_t small_hlog = {
    .name = "small hash log",
    .cli_args = "--zstd=hlog=6,strat=7",
    .param_values = PARAM_VALUES(small_hlog_param_values),
};

static param_value_t const small_clog_param_values[] = {
    {.param = ZSTD_c_chainLog, .value = 6},
    {.param = ZSTD_c_strategy, .value = (int)ZSTD_btopt},
};

static config_t small_clog = {
    .name = "small chain log",
    .cli_args = "--zstd=clog=6,strat=7",
    .param_values = PARAM_VALUES(small_clog_param_values),
};

static param_value_t const uncompressed_literals_param_values[] = {
    {.param = ZSTD_c_compressionLevel, .value = 3},
    {.param = ZSTD_c_literalCompressionMode, .value = ZSTD_ps_disable},
};

static config_t uncompressed_literals = {
    .name = "uncompressed literals",
    .cli_args = "-3 --no-compress-literals",
    .param_values = PARAM_VALUES(uncompressed_literals_param_values),
};

static param_value_t const uncompressed_literals_opt_param_values[] = {
    {.param = ZSTD_c_compressionLevel, .value = 19},
    {.param = ZSTD_c_literalCompressionMode, .value = ZSTD_ps_disable},
};

static config_t uncompressed_literals_opt = {
    .name = "uncompressed literals optimal",
    .cli_args = "-19 --no-compress-literals",
    .param_values = PARAM_VALUES(uncompressed_literals_opt_param_values),
};

static param_value_t const huffman_literals_param_values[] = {
    {.param = ZSTD_c_compressionLevel, .value = -1},
    {.param = ZSTD_c_literalCompressionMode, .value = ZSTD_ps_enable},
};

static config_t huffman_literals = {
    .name = "huffman literals",
    .cli_args = "--fast=1 --compress-literals",
    .param_values = PARAM_VALUES(huffman_literals_param_values),
};

static param_value_t const explicit_params_param_values[] = {
    {.param = ZSTD_c_checksumFlag, .value = 1},
    {.param = ZSTD_c_contentSizeFlag, .value = 0},
    {.param = ZSTD_c_dictIDFlag, .value = 0},
    {.param = ZSTD_c_strategy, .value = (int)ZSTD_greedy},
    {.param = ZSTD_c_windowLog, .value = 18},
    {.param = ZSTD_c_hashLog, .value = 21},
    {.param = ZSTD_c_chainLog, .value = 21},
    {.param = ZSTD_c_targetLength, .value = 100},
};

static config_t explicit_params = {
    .name = "explicit params",
    .cli_args = "--no-check --no-dictID --zstd=strategy=3,wlog=18,hlog=21,clog=21,tlen=100",
    .param_values = PARAM_VALUES(explicit_params_param_values),
};

static config_t const* g_configs[] = {

#define FAST_LEVEL(x) &level_fast##x, &level_fast##x##_dict,
#define LEVEL(x) &level_##x, &level_##x##_dict, &level_##x##_dict_dms, &level_##x##_dict_dds, &level_##x##_dict_copy, &level_##x##_dict_load,
#define ROW_LEVEL(x, y) &row_##y##_level_##x, &row_##y##_level_##x##_dict_dms, &row_##y##_level_##x##_dict_dds, &row_##y##_level_##x##_dict_copy, &row_##y##_level_##x##_dict_load,
#include "levels.h"
#undef ROW_LEVEL
#undef LEVEL
#undef FAST_LEVEL

    &no_pledged_src_size,
    &no_pledged_src_size_with_dict,
    &ldm,
    &mt,
    &mt_ldm,
    &small_wlog,
    &small_hlog,
    &small_clog,
    &explicit_params,
    &uncompressed_literals,
    &uncompressed_literals_opt,
    &huffman_literals,
    &mt_advanced,
    NULL,
};

config_t const* const* configs = g_configs;

int config_skip_data(config_t const* config, data_t const* data) {
    return config->use_dictionary && !data_has_dict(data);
}

int config_get_level(config_t const* config)
{
    param_values_t const params = config->param_values;
    size_t i;
    for (i = 0; i < params.size; ++i) {
        if (params.data[i].param == ZSTD_c_compressionLevel)
            return (int)params.data[i].value;
    }
    return CONFIG_NO_LEVEL;
}

ZSTD_parameters config_get_zstd_params(
    config_t const* config,
    uint64_t srcSize,
    size_t dictSize)
{
    ZSTD_parameters zparams = {};
    param_values_t const params = config->param_values;
    int level = config_get_level(config);
    if (level == CONFIG_NO_LEVEL)
        level = 3;
    zparams = ZSTD_getParams(
        level,
        config->no_pledged_src_size ? ZSTD_CONTENTSIZE_UNKNOWN : srcSize,
        dictSize);
    for (size_t i = 0; i < params.size; ++i) {
        unsigned const value = params.data[i].value;
        switch (params.data[i].param) {
            case ZSTD_c_contentSizeFlag:
                zparams.fParams.contentSizeFlag = value;
                break;
            case ZSTD_c_checksumFlag:
                zparams.fParams.checksumFlag = value;
                break;
            case ZSTD_c_dictIDFlag:
                zparams.fParams.noDictIDFlag = !value;
                break;
            case ZSTD_c_windowLog:
                zparams.cParams.windowLog = value;
                break;
            case ZSTD_c_chainLog:
                zparams.cParams.chainLog = value;
                break;
            case ZSTD_c_hashLog:
                zparams.cParams.hashLog = value;
                break;
            case ZSTD_c_searchLog:
                zparams.cParams.searchLog = value;
                break;
            case ZSTD_c_minMatch:
                zparams.cParams.minMatch = value;
                break;
            case ZSTD_c_targetLength:
                zparams.cParams.targetLength = value;
                break;
            case ZSTD_c_strategy:
                zparams.cParams.strategy = (ZSTD_strategy)value;
                break;
            default:
                break;
        }
    }
    return zparams;
}
Commit	Line	Data
648db22b	1	/*
	2	* Copyright (c) Meta Platforms, Inc. and affiliates.
	3	* All rights reserved.
	4	*
	5	* This source code is licensed under both the BSD-style license (found in the
	6	* LICENSE file in the root directory of this source tree) and the GPLv2 (found
	7	* in the COPYING file in the root directory of this source tree).
	8	* You may select, at your option, one of the above-listed licenses.
	9	*/
	10
	11	#include "config.h"
	12
	13	/* Define a config for each fast level we want to test with. */
	14	#define FAST_LEVEL(x) \
	15	param_value_t const level_fast##x##_param_values[] = { \
	16	{.param = ZSTD_c_compressionLevel, .value = -x}, \
	17	}; \
	18	config_t const level_fast##x = { \
	19	.name = "level -" #x, \
	20	.cli_args = "--fast=" #x, \
	21	.param_values = PARAM_VALUES(level_fast##x##_param_values), \
	22	}; \
	23	config_t const level_fast##x##_dict = { \
	24	.name = "level -" #x " with dict", \
	25	.cli_args = "--fast=" #x, \
	26	.param_values = PARAM_VALUES(level_fast##x##_param_values), \
	27	.use_dictionary = 1, \
	28	};
	29
	30	/* Define a config for each level we want to test with. */
	31	#define LEVEL(x) \
	32	param_value_t const level_##x##_param_values[] = { \
	33	{.param = ZSTD_c_compressionLevel, .value = x}, \
	34	}; \
	35	param_value_t const level_##x##_param_values_dms[] = { \
	36	{.param = ZSTD_c_compressionLevel, .value = x}, \
	37	{.param = ZSTD_c_enableDedicatedDictSearch, .value = 0}, \
	38	{.param = ZSTD_c_forceAttachDict, .value = ZSTD_dictForceAttach}, \
	39	}; \
	40	param_value_t const level_##x##_param_values_dds[] = { \
	41	{.param = ZSTD_c_compressionLevel, .value = x}, \
	42	{.param = ZSTD_c_enableDedicatedDictSearch, .value = 1}, \
	43	{.param = ZSTD_c_forceAttachDict, .value = ZSTD_dictForceAttach}, \
	44	}; \
	45	param_value_t const level_##x##_param_values_dictcopy[] = { \
	46	{.param = ZSTD_c_compressionLevel, .value = x}, \
	47	{.param = ZSTD_c_enableDedicatedDictSearch, .value = 0}, \
	48	{.param = ZSTD_c_forceAttachDict, .value = ZSTD_dictForceCopy}, \
	49	}; \
	50	param_value_t const level_##x##_param_values_dictload[] = { \
	51	{.param = ZSTD_c_compressionLevel, .value = x}, \
	52	{.param = ZSTD_c_enableDedicatedDictSearch, .value = 0}, \
	53	{.param = ZSTD_c_forceAttachDict, .value = ZSTD_dictForceLoad}, \
	54	}; \
	55	config_t const level_##x = { \
	56	.name = "level " #x, \
	57	.cli_args = "-" #x, \
	58	.param_values = PARAM_VALUES(level_##x##_param_values), \
	59	}; \
	60	config_t const level_##x##_dict = { \
	61	.name = "level " #x " with dict", \
	62	.cli_args = "-" #x, \
	63	.param_values = PARAM_VALUES(level_##x##_param_values), \
	64	.use_dictionary = 1, \
65	}; \
66	config_t const level_##x##_dict_dms = { \
67	.name = "level " #x " with dict dms", \
68	.cli_args = "-" #x, \
69	.param_values = PARAM_VALUES(level_##x##_param_values_dms), \
70	.use_dictionary = 1, \
71	.advanced_api_only = 1, \
72	}; \
73	config_t const level_##x##_dict_dds = { \
74	.name = "level " #x " with dict dds", \
75	.cli_args = "-" #x, \
76	.param_values = PARAM_VALUES(level_##x##_param_values_dds), \
77	.use_dictionary = 1, \
78	.advanced_api_only = 1, \
79	}; \
80	config_t const level_##x##_dict_copy = { \
81	.name = "level " #x " with dict copy", \
82	.cli_args = "-" #x, \
83	.param_values = PARAM_VALUES(level_##x##_param_values_dictcopy), \
84	.use_dictionary = 1, \
85	.advanced_api_only = 1, \
86	}; \
87	config_t const level_##x##_dict_load = { \
88	.name = "level " #x " with dict load", \
89	.cli_args = "-" #x, \
90	.param_values = PARAM_VALUES(level_##x##_param_values_dictload), \
91	.use_dictionary = 1, \
92	.advanced_api_only = 1, \
93	};
94
95	/* Define a config specifically to test row hash based levels and settings.
96	*/
97	#define ROW_LEVEL(x, y) \
98	param_value_t const row_##y##_level_##x##_param_values[] = { \
99	{.param = ZSTD_c_useRowMatchFinder, .value = y}, \
100	{.param = ZSTD_c_compressionLevel, .value = x}, \
101	}; \
102	param_value_t const row_##y##_level_##x##_param_values_dms[] = { \
103	{.param = ZSTD_c_useRowMatchFinder, .value = y}, \
104	{.param = ZSTD_c_compressionLevel, .value = x}, \
105	{.param = ZSTD_c_enableDedicatedDictSearch, .value = 0}, \
106	{.param = ZSTD_c_forceAttachDict, .value = ZSTD_dictForceAttach}, \
107	}; \
108	param_value_t const row_##y##_level_##x##_param_values_dds[] = { \
109	{.param = ZSTD_c_useRowMatchFinder, .value = y}, \
110	{.param = ZSTD_c_compressionLevel, .value = x}, \
111	{.param = ZSTD_c_enableDedicatedDictSearch, .value = 1}, \
112	{.param = ZSTD_c_forceAttachDict, .value = ZSTD_dictForceAttach}, \
113	}; \
114	param_value_t const row_##y##_level_##x##_param_values_dictcopy[] = { \
115	{.param = ZSTD_c_useRowMatchFinder, .value = y}, \
116	{.param = ZSTD_c_compressionLevel, .value = x}, \
117	{.param = ZSTD_c_enableDedicatedDictSearch, .value = 0}, \
118	{.param = ZSTD_c_forceAttachDict, .value = ZSTD_dictForceCopy}, \
119	}; \
120	param_value_t const row_##y##_level_##x##_param_values_dictload[] = { \
121	{.param = ZSTD_c_useRowMatchFinder, .value = y}, \
122	{.param = ZSTD_c_compressionLevel, .value = x}, \
123	{.param = ZSTD_c_enableDedicatedDictSearch, .value = 0}, \
124	{.param = ZSTD_c_forceAttachDict, .value = ZSTD_dictForceLoad}, \
125	}; \
126	config_t const row_##y##_level_##x = { \
127	.name = "level " #x " row " #y, \
128	.cli_args = "-" #x, \
129	.param_values = PARAM_VALUES(row_##y##_level_##x##_param_values), \
130	.advanced_api_only = 1, \
131	}; \
132	config_t const row_##y##_level_##x##_dict_dms = { \
133	.name = "level " #x " row " #y " with dict dms", \
134	.cli_args = "-" #x, \
135	.param_values = PARAM_VALUES(row_##y##_level_##x##_param_values_dms), \
136	.use_dictionary = 1, \
137	.advanced_api_only = 1, \
138	}; \
139	config_t const row_##y##_level_##x##_dict_dds = { \
140	.name = "level " #x " row " #y " with dict dds", \
141	.cli_args = "-" #x, \
142	.param_values = PARAM_VALUES(row_##y##_level_##x##_param_values_dds), \
143	.use_dictionary = 1, \
144	.advanced_api_only = 1, \
145	}; \
146	config_t const row_##y##_level_##x##_dict_copy = { \
147	.name = "level " #x " row " #y" with dict copy", \
148	.cli_args = "-" #x, \
149	.param_values = PARAM_VALUES(row_##y##_level_##x##_param_values_dictcopy), \
150	.use_dictionary = 1, \
151	.advanced_api_only = 1, \
152	}; \
153	config_t const row_##y##_level_##x##_dict_load = { \
154	.name = "level " #x " row " #y " with dict load", \
155	.cli_args = "-" #x, \
156	.param_values = PARAM_VALUES(row_##y##_level_##x##_param_values_dictload), \
157	.use_dictionary = 1, \
158	.advanced_api_only = 1, \
159	};
160
161	#define PARAM_VALUES(pv) \
162	{ .data = pv, .size = sizeof(pv) / sizeof((pv)[0]) }
163
164	#include "levels.h"
165
166	#undef LEVEL
167	#undef FAST_LEVEL
168	#undef ROW_LEVEL
169
170	static config_t no_pledged_src_size = {
171	.name = "no source size",
172	.cli_args = "",
173	.param_values = PARAM_VALUES(level_0_param_values),
174	.no_pledged_src_size = 1,
175	};
176
177	static config_t no_pledged_src_size_with_dict = {
178	.name = "no source size with dict",
179	.cli_args = "",
180	.param_values = PARAM_VALUES(level_0_param_values),
181	.no_pledged_src_size = 1,
182	.use_dictionary = 1,
183	};
184
185	static param_value_t const ldm_param_values[] = {
186	{.param = ZSTD_c_enableLongDistanceMatching, .value = ZSTD_ps_enable},
187	};
188
189	static config_t ldm = {
190	.name = "long distance mode",
191	.cli_args = "--long",
192	.param_values = PARAM_VALUES(ldm_param_values),
193	};
194
195	static param_value_t const mt_param_values[] = {
196	{.param = ZSTD_c_nbWorkers, .value = 2},
197	};
198
199	static config_t mt = {
200	.name = "multithreaded",
201	.cli_args = "-T2",
202	.param_values = PARAM_VALUES(mt_param_values),
203	};
204
205	static param_value_t const mt_ldm_param_values[] = {
206	{.param = ZSTD_c_nbWorkers, .value = 2},
207	{.param = ZSTD_c_enableLongDistanceMatching, .value = ZSTD_ps_enable},
208	};
209
210	static config_t mt_ldm = {
211	.name = "multithreaded long distance mode",
212	.cli_args = "-T2 --long",
213	.param_values = PARAM_VALUES(mt_ldm_param_values),
214	};
215
216	static param_value_t mt_advanced_param_values[] = {
217	{.param = ZSTD_c_nbWorkers, .value = 2},
218	{.param = ZSTD_c_literalCompressionMode, .value = ZSTD_ps_disable},
219	};
220
221	static config_t mt_advanced = {
222	.name = "multithreaded with advanced params",
223	.cli_args = "-T2 --no-compress-literals",
224	.param_values = PARAM_VALUES(mt_advanced_param_values),
225	};
226
227	static param_value_t const small_wlog_param_values[] = {
228	{.param = ZSTD_c_windowLog, .value = 10},
229	};
230
231	static config_t small_wlog = {
232	.name = "small window log",
233	.cli_args = "--zstd=wlog=10",
234	.param_values = PARAM_VALUES(small_wlog_param_values),
235	};
236
237	static param_value_t const small_hlog_param_values[] = {
238	{.param = ZSTD_c_hashLog, .value = 6},
239	{.param = ZSTD_c_strategy, .value = (int)ZSTD_btopt},
240	};
241
242	static config_t small_hlog = {
243	.name = "small hash log",
244	.cli_args = "--zstd=hlog=6,strat=7",
245	.param_values = PARAM_VALUES(small_hlog_param_values),
246	};
247
248	static param_value_t const small_clog_param_values[] = {
249	{.param = ZSTD_c_chainLog, .value = 6},
250	{.param = ZSTD_c_strategy, .value = (int)ZSTD_btopt},
251	};
252
253	static config_t small_clog = {
254	.name = "small chain log",
255	.cli_args = "--zstd=clog=6,strat=7",
256	.param_values = PARAM_VALUES(small_clog_param_values),
257	};
258
259	static param_value_t const uncompressed_literals_param_values[] = {
260	{.param = ZSTD_c_compressionLevel, .value = 3},
261	{.param = ZSTD_c_literalCompressionMode, .value = ZSTD_ps_disable},
262	};
263
264	static config_t uncompressed_literals = {
265	.name = "uncompressed literals",
266	.cli_args = "-3 --no-compress-literals",
267	.param_values = PARAM_VALUES(uncompressed_literals_param_values),
268	};
269
270	static param_value_t const uncompressed_literals_opt_param_values[] = {
271	{.param = ZSTD_c_compressionLevel, .value = 19},
272	{.param = ZSTD_c_literalCompressionMode, .value = ZSTD_ps_disable},
273	};
274
275	static config_t uncompressed_literals_opt = {
276	.name = "uncompressed literals optimal",
277	.cli_args = "-19 --no-compress-literals",
278	.param_values = PARAM_VALUES(uncompressed_literals_opt_param_values),
279	};
280
281	static param_value_t const huffman_literals_param_values[] = {
282	{.param = ZSTD_c_compressionLevel, .value = -1},
283	{.param = ZSTD_c_literalCompressionMode, .value = ZSTD_ps_enable},
284	};
285
286	static config_t huffman_literals = {
287	.name = "huffman literals",
288	.cli_args = "--fast=1 --compress-literals",
289	.param_values = PARAM_VALUES(huffman_literals_param_values),
290	};
291
292	static param_value_t const explicit_params_param_values[] = {
293	{.param = ZSTD_c_checksumFlag, .value = 1},
294	{.param = ZSTD_c_contentSizeFlag, .value = 0},
295	{.param = ZSTD_c_dictIDFlag, .value = 0},
296	{.param = ZSTD_c_strategy, .value = (int)ZSTD_greedy},
297	{.param = ZSTD_c_windowLog, .value = 18},
298	{.param = ZSTD_c_hashLog, .value = 21},
299	{.param = ZSTD_c_chainLog, .value = 21},
300	{.param = ZSTD_c_targetLength, .value = 100},
301	};
302
303	static config_t explicit_params = {
304	.name = "explicit params",
305	.cli_args = "--no-check --no-dictID --zstd=strategy=3,wlog=18,hlog=21,clog=21,tlen=100",
306	.param_values = PARAM_VALUES(explicit_params_param_values),
307	};
308
309	static config_t const* g_configs[] = {
310
311	#define FAST_LEVEL(x) &level_fast##x, &level_fast##x##_dict,
312	#define LEVEL(x) &level_##x, &level_##x##_dict, &level_##x##_dict_dms, &level_##x##_dict_dds, &level_##x##_dict_copy, &level_##x##_dict_load,
313	#define ROW_LEVEL(x, y) &row_##y##_level_##x, &row_##y##_level_##x##_dict_dms, &row_##y##_level_##x##_dict_dds, &row_##y##_level_##x##_dict_copy, &row_##y##_level_##x##_dict_load,
314	#include "levels.h"
315	#undef ROW_LEVEL
316	#undef LEVEL
317	#undef FAST_LEVEL
318
319	&no_pledged_src_size,
320	&no_pledged_src_size_with_dict,
321	&ldm,
322	&mt,
323	&mt_ldm,
324	&small_wlog,
325	&small_hlog,
326	&small_clog,
327	&explicit_params,
328	&uncompressed_literals,
329	&uncompressed_literals_opt,
330	&huffman_literals,
331	&mt_advanced,
332	NULL,
333	};
334
335	config_t const* const* configs = g_configs;
336
337	int config_skip_data(config_t const* config, data_t const* data) {
338	return config->use_dictionary && !data_has_dict(data);
339	}
340
341	int config_get_level(config_t const* config)
342	{
343	param_values_t const params = config->param_values;
344	size_t i;
345	for (i = 0; i < params.size; ++i) {
346	if (params.data[i].param == ZSTD_c_compressionLevel)
347	return (int)params.data[i].value;
348	}
349	return CONFIG_NO_LEVEL;
350	}
351
352	ZSTD_parameters config_get_zstd_params(
353	config_t const* config,
354	uint64_t srcSize,
355	size_t dictSize)
356	{
357	ZSTD_parameters zparams = {};
358	param_values_t const params = config->param_values;
359	int level = config_get_level(config);
360	if (level == CONFIG_NO_LEVEL)
361	level = 3;
362	zparams = ZSTD_getParams(
363	level,
364	config->no_pledged_src_size ? ZSTD_CONTENTSIZE_UNKNOWN : srcSize,
365	dictSize);
366	for (size_t i = 0; i < params.size; ++i) {
367	unsigned const value = params.data[i].value;
368	switch (params.data[i].param) {
369	case ZSTD_c_contentSizeFlag:
370	zparams.fParams.contentSizeFlag = value;
371	break;
372	case ZSTD_c_checksumFlag:
373	zparams.fParams.checksumFlag = value;
374	break;
375	case ZSTD_c_dictIDFlag:
376	zparams.fParams.noDictIDFlag = !value;
377	break;
378	case ZSTD_c_windowLog:
379	zparams.cParams.windowLog = value;
380	break;
381	case ZSTD_c_chainLog:
382	zparams.cParams.chainLog = value;
383	break;
384	case ZSTD_c_hashLog:
385	zparams.cParams.hashLog = value;
386	break;
387	case ZSTD_c_searchLog:
388	zparams.cParams.searchLog = value;
389	break;
390	case ZSTD_c_minMatch:
391	zparams.cParams.minMatch = value;
392	break;
393	case ZSTD_c_targetLength:
394	zparams.cParams.targetLength = value;
395	break;
396	case ZSTD_c_strategy:
397	zparams.cParams.strategy = (ZSTD_strategy)value;
398	break;
399	default:
400	break;
401	}
402	}
403	return zparams;
404	}