From e7536103b074f5d38b90df3369a9b1b4ee462c8e Mon Sep 17 00:00:00 2001
From: Dominik Loidolt <dominik.loidolt@univie.ac.at>
Date: Wed, 17 Apr 2024 16:01:07 +0200
Subject: [PATCH] Remove unused CMP_MODE_STUFF compression mode
---
lib/common/cmp_support.c | 19 +---
lib/common/cmp_support.h | 4 +-
lib/decompress/decmp.c | 24 ----
lib/icu_compress/cmp_icu.c | 47 ++------
test/cmp_decmp/test_cmp_decmp.c | 19 ----
test/cmp_entity/test_cmp_entity.c | 4 +-
test/cmp_icu/test_cmp_icu.c | 153 +++-----------------------
test/cmp_rdcu_cfg/test_cmp_rdcu_cfg.c | 6 +-
8 files changed, 28 insertions(+), 248 deletions(-)
diff --git a/lib/common/cmp_support.c b/lib/common/cmp_support.c
index a211c3c..b3abb67 100644
--- a/lib/common/cmp_support.c
+++ b/lib/common/cmp_support.c
@@ -128,7 +128,6 @@ int rdcu_supported_cmp_mode_is_used(enum cmp_mode cmp_mode)
case CMP_MODE_MODEL_MULTI:
case CMP_MODE_DIFF_MULTI:
return 1;
- case CMP_MODE_STUFF:
default:
return 0;
}
@@ -169,16 +168,7 @@ int rdcu_supported_data_type_is_used(enum cmp_data_type data_type)
int cmp_mode_is_supported(enum cmp_mode cmp_mode)
{
- switch (cmp_mode) {
- case CMP_MODE_RAW:
- case CMP_MODE_MODEL_ZERO:
- case CMP_MODE_DIFF_ZERO:
- case CMP_MODE_MODEL_MULTI:
- case CMP_MODE_DIFF_MULTI:
- case CMP_MODE_STUFF:
- return 1;
- }
- return 0;
+ return rdcu_supported_cmp_mode_is_used(cmp_mode);
}
@@ -665,13 +655,6 @@ static int cmp_pars_are_invalid(uint32_t cmp_par, uint32_t spill, enum cmp_mode
cfg_invalid++;
}
- break;
- case CMP_MODE_STUFF:
- if (cmp_par > MAX_STUFF_CMP_PAR) {
- debug_print("Error: The selected %s stuff mode compression parameter: %" PRIu32 " is too large. The largest possible value in the selected compression mode is: %u.",
- par_name, cmp_par, MAX_STUFF_CMP_PAR);
- cfg_invalid++;
- }
break;
default:
debug_print("Error: The compression mode is not supported.");
diff --git a/lib/common/cmp_support.h b/lib/common/cmp_support.h
index 693d7c6..3c4d37f 100644
--- a/lib/common/cmp_support.h
+++ b/lib/common/cmp_support.h
@@ -53,7 +53,6 @@
#define MIN_NON_IMA_SPILL 2U
/* for maximum spill value look at cmp_icu_max_spill function */
#define MAX_ICU_ROUND 3U
-#define MAX_STUFF_CMP_PAR 32U
/* default imagette RDCU compression parameters for model compression */
@@ -145,8 +144,7 @@ enum cmp_mode {
CMP_MODE_MODEL_ZERO,
CMP_MODE_DIFF_ZERO,
CMP_MODE_MODEL_MULTI,
- CMP_MODE_DIFF_MULTI,
- CMP_MODE_STUFF
+ CMP_MODE_DIFF_MULTI
};
diff --git a/lib/decompress/decmp.c b/lib/decompress/decmp.c
index 6d7cf06..8215037 100644
--- a/lib/decompress/decmp.c
+++ b/lib/decompress/decmp.c
@@ -274,24 +274,6 @@ static int decode_multi(const struct decoder_setup *setup, uint32_t *decoded_val
}
-/**
- * @brief get the value unencoded with setup->cmp_par_1 bits without any
- * additional changes from the bitstream
- *
- * @param setup pointer to the decoder setup
- * @param decoded_value points to the location where the decoded value is stored
- *
- * @returns 0 on success; otherwise error
- */
-
-static int decode_none(const struct decoder_setup *setup, uint32_t *decoded_value)
-{
- *decoded_value = bit_read_bits32(setup->dec, setup->encoder_par1);
-
- return bit_refill(setup->dec) == BIT_OVERFLOW;
-}
-
-
/**
* @brief remap an unsigned value back to a signed value
* @note this is the reverse function of map_to_pos()
@@ -331,10 +313,6 @@ static int decode_value(const struct decoder_setup *setup, uint32_t *decoded_val
/* decode the next value from the bitstream */
int err = setup->decode_method_f(setup, decoded_value);
- if (setup->decode_method_f == decode_none)
- /* we are done here in stuff mode */
- return err;
-
/* map the unsigned decode value back to a signed value */
*decoded_value = re_map_to_pos(*decoded_value);
@@ -377,8 +355,6 @@ static void configure_decoder_setup(struct decoder_setup *setup, struct bit_deco
setup->decode_method_f = &decode_multi;
else if (zero_escape_mech_is_used(cmp_mode))
setup->decode_method_f = &decode_zero;
- else if (cmp_mode == CMP_MODE_STUFF)
- setup->decode_method_f = &decode_none;
else {
debug_print("Error: Compression mode not supported.");
assert(0);
diff --git a/lib/icu_compress/cmp_icu.c b/lib/icu_compress/cmp_icu.c
index 45554bf..d08aaa2 100644
--- a/lib/icu_compress/cmp_icu.c
+++ b/lib/icu_compress/cmp_icu.c
@@ -681,32 +681,6 @@ static uint32_t encode_value_multi(uint32_t data, uint32_t model, uint32_t strea
}
-/**
- * @brief put the value unencoded with setup->cmp_par_1 bits without any changes
- * in the bitstream
- *
- * @param value value to put unchanged in the bitstream
- * (setup->cmp_par_1 how many bits of the value are used)
- * @param unused this parameter is ignored
- * @param stream_len length of the bitstream in bits
- * @param setup pointer to the encoder setup
- *
- * @returns the bit length of the bitstream with the added unencoded value on
- * success; negative on error, CMP_ERROR_SMALL_BUF if the bitstream buffer
- * is too small to put the value in the bitstream
- *
- */
-
-static uint32_t encode_value_none(uint32_t value, uint32_t unused, uint32_t stream_len,
- const struct encoder_setup *setup)
-{
- (void)(unused);
-
- return put_n_bits32(value, setup->encoder_par1, stream_len,
- setup->bitstream_adr, setup->max_stream_len);
-}
-
-
/**
* @brief encodes the data with the model and the given setup and put it into
* the bitstream
@@ -778,17 +752,14 @@ static void configure_encoder_setup(struct encoder_setup *setup,
setup->lossy_par = lossy_par;
setup->bitstream_adr = cfg->icu_output_buf;
setup->max_stream_len = cmp_buffer_length_to_bits(cfg->buffer_length);
+ setup->encoder_par2 = ilog_2(cmp_par);
+ setup->spillover_par = spillover;
- if (cfg->cmp_mode != CMP_MODE_STUFF) {
- setup->encoder_par2 = ilog_2(cmp_par);
- setup->spillover_par = spillover;
-
- /* for encoder_par1 which are a power of two we can use the faster rice_encoder */
- if (is_a_pow_of_2(setup->encoder_par1))
- setup->generate_cw_f = &rice_encoder;
- else
- setup->generate_cw_f = &golomb_encoder;
- }
+ /* for encoder_par1 which are a power of two we can use the faster rice_encoder */
+ if (is_a_pow_of_2(setup->encoder_par1))
+ setup->generate_cw_f = &rice_encoder;
+ else
+ setup->generate_cw_f = &golomb_encoder;
switch (cfg->cmp_mode) {
case CMP_MODE_MODEL_ZERO:
@@ -799,10 +770,6 @@ static void configure_encoder_setup(struct encoder_setup *setup,
case CMP_MODE_DIFF_MULTI:
setup->encode_method_f = &encode_value_multi;
break;
- case CMP_MODE_STUFF:
- setup->encode_method_f = &encode_value_none;
- setup->max_data_bits = cmp_par;
- break;
/* LCOV_EXCL_START */
case CMP_MODE_RAW:
/* CMP_MODE_RAW is already handled before; nothing to do here */
diff --git a/test/cmp_decmp/test_cmp_decmp.c b/test/cmp_decmp/test_cmp_decmp.c
index b1363a0..a436121 100644
--- a/test/cmp_decmp/test_cmp_decmp.c
+++ b/test/cmp_decmp/test_cmp_decmp.c
@@ -586,25 +586,6 @@ void generate_random_cmp_cfg(struct cmp_cfg *cfg)
cfg->spill_par_5 = cmp_rand_between(MIN_NON_IMA_SPILL, cmp_icu_max_spill(cfg->cmp_par_ecob));
cfg->spill_par_6 = cmp_rand_between(MIN_NON_IMA_SPILL, cmp_icu_max_spill(cfg->cmp_par_fx_cob_variance));
}
-
-#if 0
- if (cfg->cmp_mode == CMP_MODE_STUFF) {
- /* cfg->golomb_par = cmp_rand_between(16, MAX_STUFF_CMP_PAR); */
- cfg->golomb_par = 16;
- cfg->ap1_golomb_par = cmp_rand_between(0, MAX_STUFF_CMP_PAR);
- cfg->ap2_golomb_par = cmp_rand_between(0, MAX_STUFF_CMP_PAR);
- cfg->cmp_par_exp_flags = cmp_rand_between(0, MAX_STUFF_CMP_PAR);
- cfg->cmp_par_fx = cmp_rand_between(0, MAX_STUFF_CMP_PAR);
- cfg->cmp_par_ncob = cmp_rand_between(0, MAX_STUFF_CMP_PAR);
- cfg->cmp_par_efx = cmp_rand_between(0, MAX_STUFF_CMP_PAR);
- cfg->cmp_par_ecob = cmp_rand_between(0, MAX_STUFF_CMP_PAR);
- cfg->cmp_par_fx_cob_variance = cmp_rand_between(0, MAX_STUFF_CMP_PAR);
- cfg->cmp_par_mean = cmp_rand_between(0, MAX_STUFF_CMP_PAR);
- cfg->cmp_par_variance = cmp_rand_between(0, MAX_STUFF_CMP_PAR);
- cfg->cmp_par_pixels_error = cmp_rand_between(0, MAX_STUFF_CMP_PAR);
- return;
- }
-#endif
}
diff --git a/test/cmp_entity/test_cmp_entity.c b/test/cmp_entity/test_cmp_entity.c
index 5bd6b1e..d68b83c 100644
--- a/test/cmp_entity/test_cmp_entity.c
+++ b/test/cmp_entity/test_cmp_entity.c
@@ -488,7 +488,7 @@ void test_ent_cmp_mode(void)
enum cmp_mode cmp_mode, cmp_mode_read;
uint8_t *entity_p = (uint8_t *)&ent;
- cmp_mode = 0x12;
+ cmp_mode = (enum cmp_mode)0x12;
error = cmp_ent_set_cmp_mode(&ent, cmp_mode);
TEST_ASSERT_FALSE(error);
@@ -499,7 +499,7 @@ void test_ent_cmp_mode(void)
TEST_ASSERT_EQUAL_HEX(0x12, entity_p[24]);
/* error cases */
- cmp_mode = 0x100;
+ cmp_mode = (enum cmp_mode)0x100;
error = cmp_ent_set_cmp_mode(&ent, cmp_mode);
TEST_ASSERT_TRUE(error);
error = cmp_ent_set_cmp_mode(NULL, cmp_mode);
diff --git a/test/cmp_icu/test_cmp_icu.c b/test/cmp_icu/test_cmp_icu.c
index adc12f0..0555b99 100644
--- a/test/cmp_icu/test_cmp_icu.c
+++ b/test/cmp_icu/test_cmp_icu.c
@@ -36,6 +36,9 @@
#include "../../lib/icu_compress/cmp_icu.c" /* this is a hack to test static functions */
+#define MAX_CMP_MODE CMP_MODE_DIFF_MULTI
+
+
/**
* @brief Seeds the pseudo-random number generator used by rand()
*/
@@ -105,7 +108,7 @@ void test_cmp_cfg_icu_create(void)
memset(&cfg, 0, sizeof(cfg));
/* wrong compression mode tests */
- cmp_mode = CMP_MODE_STUFF + 1;
+ cmp_mode = (enum cmp_mode)(MAX_CMP_MODE + 1);
cfg = cmp_cfg_icu_create(data_type, cmp_mode, model_value, lossy_par);
TEST_ASSERT_EQUAL_INT(DATA_TYPE_UNKNOWN, cfg.data_type);
memset(&cfg, 0, sizeof(cfg));
@@ -116,10 +119,10 @@ void test_cmp_cfg_icu_create(void)
memset(&cfg, 0, sizeof(cfg));
/* this should work */
- cmp_mode = CMP_MODE_STUFF;
+ cmp_mode = MAX_CMP_MODE;
cfg = cmp_cfg_icu_create(data_type, cmp_mode, model_value, lossy_par);
TEST_ASSERT_EQUAL_INT(DATA_TYPE_IMAGETTE, cfg.data_type);
- TEST_ASSERT_EQUAL_INT(CMP_MODE_STUFF, cfg.cmp_mode);
+ TEST_ASSERT_EQUAL_INT(MAX_CMP_MODE, cfg.cmp_mode);
TEST_ASSERT_EQUAL_INT(0, cfg.model_value);
TEST_ASSERT_EQUAL_INT(0, cfg.round);
TEST_ASSERT_EQUAL(&MAX_USED_BITS_SAFE, cfg.max_used_bits);
@@ -145,11 +148,11 @@ void test_cmp_cfg_icu_create(void)
TEST_ASSERT_EQUAL(&MAX_USED_BITS_SAFE, cfg.max_used_bits);
/* no checks for model mode -> no model cmp_mode */
- cmp_mode = CMP_MODE_STUFF;
+ cmp_mode = CMP_MODE_RAW;
model_value = MAX_MODEL_VALUE + 1;
cfg = cmp_cfg_icu_create(data_type, cmp_mode, model_value, lossy_par);
TEST_ASSERT_EQUAL_INT(DATA_TYPE_IMAGETTE, cfg.data_type);
- TEST_ASSERT_EQUAL_INT(CMP_MODE_STUFF, cfg.cmp_mode);
+ TEST_ASSERT_EQUAL_INT(CMP_MODE_RAW, cfg.cmp_mode);
TEST_ASSERT_EQUAL_INT(MAX_MODEL_VALUE + 1, cfg.model_value);
TEST_ASSERT_EQUAL_INT(0, cfg.round);
TEST_ASSERT_EQUAL(&MAX_USED_BITS_SAFE, cfg.max_used_bits);
@@ -168,14 +171,14 @@ void test_cmp_cfg_icu_create(void)
lossy_par = MAX_ICU_ROUND;
cfg = cmp_cfg_icu_create(data_type, cmp_mode, model_value, lossy_par);
TEST_ASSERT_EQUAL_INT(DATA_TYPE_IMAGETTE, cfg.data_type);
- TEST_ASSERT_EQUAL_INT(CMP_MODE_STUFF, cfg.cmp_mode);
+ TEST_ASSERT_EQUAL_INT(CMP_MODE_RAW, cfg.cmp_mode);
TEST_ASSERT_EQUAL_INT(16, cfg.model_value);
TEST_ASSERT_EQUAL_INT(3, cfg.round);
TEST_ASSERT_EQUAL(&MAX_USED_BITS_SAFE, cfg.max_used_bits);
/* random test */
data_type = cmp_rand_between(DATA_TYPE_IMAGETTE, biggest_data_type);
- cmp_mode = cmp_rand_between(CMP_MODE_RAW, CMP_MODE_STUFF);
+ cmp_mode = cmp_rand_between(CMP_MODE_RAW, MAX_CMP_MODE);
model_value = cmp_rand_between(0, MAX_MODEL_VALUE);
lossy_par = cmp_rand_between(CMP_LOSSLESS, MAX_ICU_ROUND);
cfg = cmp_cfg_icu_create(data_type, cmp_mode, model_value, lossy_par);
@@ -570,38 +573,9 @@ void test_cmp_cfg_icu_imagette(void)
error = cmp_cfg_icu_imagette(&cfg, cmp_par, spillover_par);
TEST_ASSERT_FALSE(error);
- /* CMP_MODE_STUFF tests */
- spillover_par = ~0U; /* is ignored */
-
- /* highest values STUFF MODE */
- cfg = cmp_cfg_icu_create(DATA_TYPE_IMAGETTE, CMP_MODE_STUFF, ~0U, CMP_LOSSLESS);
- cmp_par = MAX_STUFF_CMP_PAR;
- error = cmp_cfg_icu_imagette(&cfg, cmp_par, spillover_par);
- TEST_ASSERT_FALSE(error);
- TEST_ASSERT_EQUAL_INT(cfg.golomb_par, 32);
-
- /* lowest values STUFF MODE */
- cfg = cmp_cfg_icu_create(DATA_TYPE_IMAGETTE, CMP_MODE_STUFF, ~0U, CMP_LOSSLESS);
- cmp_par = 0;
- error = cmp_cfg_icu_imagette(&cfg, cmp_par, spillover_par);
- TEST_ASSERT_FALSE(error);
- TEST_ASSERT_EQUAL_INT(cfg.golomb_par, 0);
-
- /* cmp_par to big */
- cfg = cmp_cfg_icu_create(DATA_TYPE_SAT_IMAGETTE, CMP_MODE_STUFF, ~0U, CMP_LOSSLESS);
- cmp_par = MAX_STUFF_CMP_PAR+1;
- error = cmp_cfg_icu_imagette(&cfg, cmp_par, spillover_par);
- TEST_ASSERT_TRUE(error);
-
/* cfg = NULL test*/
error = cmp_cfg_icu_imagette(NULL, cmp_par, spillover_par);
TEST_ASSERT_TRUE(error);
-
- /* invalid compression mode test*/
- cfg = cmp_cfg_icu_create(DATA_TYPE_SAT_IMAGETTE, CMP_MODE_STUFF+1, ~0U, CMP_LOSSLESS);
- cmp_par = MAX_STUFF_CMP_PAR+1;
- error = cmp_cfg_icu_imagette(&cfg, cmp_par, spillover_par);
- TEST_ASSERT_TRUE(error);
}
@@ -2417,51 +2391,8 @@ void test_compress_imagette_model(void)
/* error case: model mode without model data */
cfg.model_buf = NULL; /* this is the error */
cmp_size = icu_compress_data(&cfg);
- TEST_ASSERT_EQUAL(-1, cmp_size);
-}
-
-
-/**
- * @test compress_imagette
- */
-
-void test_compress_imagette_stuff(void)
-{
- uint16_t data[] = {0x0, 0x1, 0x23, 0x42, 0x8000, 0x7FFF, 0xFFFF};
- uint32_t output_buf[4] = {0};
- struct cmp_cfg cfg = {0};
-
- int cmp_size, error;
- uint8_t output_buf_exp[] = {
- 0x00, 0x00, 0x00, 0x01,
- 0x00, 0x23, 0x00, 0x42,
- 0x80, 0x00, 0x7F, 0xFF,
- 0xFF, 0xFF, 0x00, 0x00};
- uint32_t *output_buf_exp_32;
-
- uint32_t samples = 7;
- uint32_t buffer_length = 8;
- uint32_t cmp_par = 16; /* how many used bits has the maximum data value */
- uint32_t output_buf_size;
-
-
- cfg = cmp_cfg_icu_create(DATA_TYPE_IMAGETTE, CMP_MODE_STUFF,
- CMP_PAR_UNUSED, CMP_LOSSLESS);
- TEST_ASSERT(cfg.data_type != DATA_TYPE_UNKNOWN);
- output_buf_size = cmp_cfg_icu_buffers(&cfg, data, samples, NULL, NULL,
- output_buf, buffer_length);
- TEST_ASSERT_EQUAL_INT(buffer_length*sizeof(uint16_t), output_buf_size);
- error = cmp_cfg_icu_imagette(&cfg, cmp_par, CMP_PAR_UNUSED);
- TEST_ASSERT_FALSE(error);
-
- cmp_size = icu_compress_data(&cfg);
-
- output_buf_exp_32 = (uint32_t *)output_buf_exp;
- TEST_ASSERT_EQUAL_INT(7*16, cmp_size);
- TEST_ASSERT_EQUAL_HEX16(output_buf_exp_32[0], output_buf[0]);
- TEST_ASSERT_EQUAL_HEX16(output_buf_exp_32[1], output_buf[1]);
- TEST_ASSERT_EQUAL_HEX16(output_buf_exp_32[2], output_buf[2]);
- TEST_ASSERT_EQUAL_HEX16(output_buf_exp_32[3], output_buf[3]);
+ TEST_ASSERT_TRUE(cmp_is_error(cmp_size));
+ TEST_ASSERT_EQUAL(CMP_ERROR_PAR_BUFFERS, cmp_get_error_code(cmp_size));
}
@@ -2664,7 +2595,7 @@ void test_compress_imagette_error_cases(void)
/* test unknown cmp_mode */
cfg.max_used_bits = &MAX_USED_BITS_SAFE;
cfg.data_type = DATA_TYPE_F_CAM_IMAGETTE;
- cfg.cmp_mode = CMP_MODE_STUFF+1;
+ cfg.cmp_mode = (enum cmp_mode)(MAX_CMP_MODE+1);
cfg.input_buf = data;
cfg.samples = 2;
cfg.golomb_par = 1;
@@ -2831,62 +2762,6 @@ void test_compress_s_fx_raw(void)
}
-void test_compress_s_fx_staff(void)
-{
- struct s_fx data[5];
- struct cmp_cfg cfg = {0};
- int cmp_size, cmp_size_exp;
- struct collection_hdr *hdr;
- uint32_t *cmp_data;
-
- /* setup configuration */
- cfg.data_type = DATA_TYPE_S_FX;
- cfg.cmp_mode = CMP_MODE_STUFF;
- cfg.samples = 5;
- cfg.input_buf = malloc(cmp_cal_size_of_data(cfg.samples, cfg.data_type));
- TEST_ASSERT_NOT_NULL(cfg.input_buf);
- cfg.buffer_length = 5;
- cfg.icu_output_buf = malloc(cmp_cal_size_of_data(cfg.buffer_length, cfg.data_type));
- TEST_ASSERT_NOT_NULL(cfg.icu_output_buf);
- cfg.cmp_par_exp_flags = 2;
- cfg.cmp_par_fx = 21;
- cfg.max_used_bits = &MAX_USED_BITS_V1;
-
- /* generate input data */
- hdr = cfg.input_buf;
- /* use dummy data for the header */
- memset(hdr, 0x42, sizeof(struct collection_hdr));
- data[0].exp_flags = 0x0;
- data[0].fx = 0x0;
- data[1].exp_flags = 0x1;
- data[1].fx = 0x1;
- data[2].exp_flags = 0x2;
- data[2].fx = 0x23;
- data[3].exp_flags = 0x3;
- data[3].fx = 0x42;
- data[4].exp_flags = 0x0;
- data[4].fx = 0x001FFFFF;
- memcpy(hdr->entry, data, sizeof(data));
-
- cmp_size = icu_compress_data(&cfg);
-
- cmp_size_exp = 5 * (2 + 21) + COLLECTION_HDR_SIZE * CHAR_BIT;
- TEST_ASSERT_EQUAL_INT(cmp_size_exp, cmp_size);
- TEST_ASSERT_FALSE(memcmp(cfg.input_buf, cfg.icu_output_buf, COLLECTION_HDR_SIZE));
- hdr = (void *)cfg.icu_output_buf;
- cmp_data = calloc(4, sizeof(*cmp_data));
- memcpy(cmp_data, hdr->entry, 4 * sizeof(*cmp_data));
- TEST_ASSERT_EQUAL_HEX(0x00000080, be32_to_cpu(cmp_data[0]));
- TEST_ASSERT_EQUAL_HEX(0x00060001, be32_to_cpu(cmp_data[1]));
- TEST_ASSERT_EQUAL_HEX(0x1E000423, be32_to_cpu(cmp_data[2]));
- TEST_ASSERT_EQUAL_HEX(0xFFFFE000, be32_to_cpu(cmp_data[3]));
-
- free(cmp_data);
- free(cfg.input_buf);
- free(cfg.icu_output_buf);
-}
-
-
void test_compress_s_fx_model_multi(void)
{
struct s_fx data[6], model[6];
@@ -4737,7 +4612,7 @@ void test_zero_escape_mech_is_used(void)
{
enum cmp_mode cmp_mode;
- for (cmp_mode = 0; cmp_mode <= CMP_MODE_STUFF; cmp_mode++) {
+ for (cmp_mode = 0; cmp_mode <= MAX_CMP_MODE; cmp_mode++) {
int res = zero_escape_mech_is_used(cmp_mode);
if (cmp_mode == CMP_MODE_DIFF_ZERO ||
diff --git a/test/cmp_rdcu_cfg/test_cmp_rdcu_cfg.c b/test/cmp_rdcu_cfg/test_cmp_rdcu_cfg.c
index 36645f3..89ab07d 100644
--- a/test/cmp_rdcu_cfg/test_cmp_rdcu_cfg.c
+++ b/test/cmp_rdcu_cfg/test_cmp_rdcu_cfg.c
@@ -61,16 +61,16 @@ void test_rdcu_cfg_create(void)
/* wrong compression mode tests */
- cmp_mode = CMP_MODE_STUFF; /* not a RDCU compression mode */
+ cmp_mode = (enum cmp_mode)(CMP_MODE_DIFF_MULTI+1); /* not a RDCU compression mode */
cfg = rdcu_cfg_create(data_type, cmp_mode, model_value, lossy_par);
TEST_ASSERT_EQUAL(DATA_TYPE_UNKNOWN, cfg.data_type);
- cmp_mode = -1U;
+ cmp_mode = (enum cmp_mode)-1U;
cfg = rdcu_cfg_create(data_type, cmp_mode, model_value, lossy_par);
TEST_ASSERT_EQUAL(DATA_TYPE_UNKNOWN, cfg.data_type);
/* this should work */
- cmp_mode = 4;
+ cmp_mode = (enum cmp_mode)4;
cfg = rdcu_cfg_create(data_type, cmp_mode, model_value, lossy_par);
TEST_ASSERT_EQUAL(data_type, cfg.data_type);
TEST_ASSERT_EQUAL(cmp_mode, cfg.cmp_mode);
--
GitLab