diff --git a/include/cmp_support.h b/include/cmp_support.h index d9146077b315e9d696d8aae7b6e5711e1f678700..2ea2a3e3e85ca1fdb015f77ab7e2c455a1b23d2d 100644 --- a/include/cmp_support.h +++ b/include/cmp_support.h @@ -91,7 +91,7 @@ #define CMP_DEF_IMA_DIFF_RDCU_UP_MODEL_ADR 0x000000 /* not needed for 1d-differencing cmp_mode */ #define CMP_DEF_IMA_DIFF_RDCU_BUFFER_ADR 0x600000 -enum {ICU_CHECK, RDCU_CHECK}; /* option for the cmp_cfg_imagette_is_invalid() function */ +enum check_opt {ICU_CHECK, RDCU_CHECK}; /* options for configuration check functions */ /* defined compression data product types */ @@ -249,10 +249,10 @@ int ilog_2(uint32_t x); unsigned int cmp_bit_to_4byte(unsigned int cmp_size_bit); -int cmp_cfg_is_invalid(const struct cmp_cfg *cfg); -int cmp_cfg_icu_gen_par_is_invalid(const struct cmp_cfg *cfg); +int cmp_cfg_icu_is_invalid(const struct cmp_cfg *cfg); +int cmp_cfg_gen_par_is_invalid(const struct cmp_cfg *cfg, enum check_opt opt); int cmp_cfg_icu_buffers_is_invalid(const struct cmp_cfg *cfg); -int cmp_cfg_imagette_is_invalid(const struct cmp_cfg *cfg, int rdcu_check); +int cmp_cfg_imagette_is_invalid(const struct cmp_cfg *cfg, enum check_opt opt); int cmp_cfg_fx_cob_is_invalid(const struct cmp_cfg *cfg); int cmp_cfg_aux_is_invalid(const struct cmp_cfg *cfg); uint32_t cmp_ima_max_spill(unsigned int golomb_par); diff --git a/lib/cmp_icu.c b/lib/cmp_icu.c index 5995afb13f27b09cc7cd652c5ec87a9dc9a781c7..c98d0f1ffb94114f2218db41251bfd040bb65c37 100644 --- a/lib/cmp_icu.c +++ b/lib/cmp_icu.c @@ -88,7 +88,7 @@ struct cmp_cfg cmp_cfg_icu_create(enum cmp_data_type data_type, enum cmp_mode cm cfg.model_value = model_value; cfg.round = lossy_par; - if (cmp_cfg_icu_gen_par_is_invalid(&cfg)) + if (cmp_cfg_gen_par_is_invalid(&cfg, ICU_CHECK)) cfg.data_type = DATA_TYPE_UNKNOWN; return cfg; @@ -171,10 +171,7 @@ int cmp_cfg_icu_imagette(struct cmp_cfg *cfg, uint32_t cmp_par, cfg->golomb_par = cmp_par; cfg->spill = spillover_par; - if (cmp_cfg_imagette_is_invalid(cfg, ICU_CHECK)) - return -1; - - return 0; + return cmp_cfg_imagette_is_invalid(cfg, ICU_CHECK); } @@ -225,10 +222,7 @@ int cmp_cfg_fx_cob(struct cmp_cfg *cfg, cfg->spill_ecob = spillover_ecob; cfg->spill_fx_cob_variance = spillover_fx_cob_variance; - if (cmp_cfg_fx_cob_is_invalid(cfg)) - return -1; - - return 0; + return cmp_cfg_fx_cob_is_invalid(cfg); } @@ -266,10 +260,7 @@ int cmp_cfg_aux(struct cmp_cfg *cfg, cfg->spill_variance = spillover_variance; cfg->spill_pixels_error = spillover_pixels_error; - if (cmp_cfg_aux_is_invalid(cfg)) - return -1; - - return 0; + return cmp_cfg_aux_is_invalid(cfg); } @@ -2347,7 +2338,7 @@ int icu_compress_data(const struct cmp_cfg *cfg) if (cfg->samples > cfg->buffer_length) return CMP_ERROR_SMALL_BUF; - if (cmp_cfg_is_invalid(cfg)) + if (cmp_cfg_icu_is_invalid(cfg)) return -1; if (raw_mode_is_used(cfg->cmp_mode)) { diff --git a/lib/cmp_rdcu.c b/lib/cmp_rdcu.c index b7893397b4a87ca4b950b1c37368bb1d7336160c..40b52a73ba8c231dd61998518e911c84403f2401 100644 --- a/lib/cmp_rdcu.c +++ b/lib/cmp_rdcu.c @@ -81,56 +81,6 @@ static void sync(void) } -/** - * @brief check if the compression data product type, compression mode, model - * value and the lossy rounding parameters are valid for an RDCU compression - * - * @param cfg pointer to a compression configuration containing the compression - * data product type, compression mode, model value and the rounding parameters - * - * @returns 0 if the compression data type, compression mode, model value and - * the lossy rounding parameters are valid for an RDCU compression, non-zero - * if parameters are invalid - */ - -static int rdcu_cfg_gen_par_is_invalid(const struct cmp_cfg *cfg) -{ - int cfg_invalid = 0; - - if (!cfg) - return -1; - - if (!cmp_imagette_data_type_is_used(cfg->data_type)) { - debug_print("Error: The selected compression data type is not supported for RDCU compression"); - cfg_invalid++; - } - - if (cfg->cmp_mode > MAX_RDCU_CMP_MODE) { - debug_print("Error: selected cmp_mode: %u is not supported. Largest supported mode is: %u.\n", - cfg->cmp_mode, MAX_RDCU_CMP_MODE); - cfg_invalid++; - } - - if (cfg->model_value > MAX_MODEL_VALUE) { - debug_print("Error: selected model_value: %" PRIu32 " is invalid. Largest supported value is: %u.\n", - cfg->model_value, MAX_MODEL_VALUE); - cfg_invalid++; - } - - if (cfg->round > MAX_RDCU_ROUND) { - debug_print("Error: selected round parameter: %" PRIu32 " is not supported. Largest supported value is: %u.\n", - cfg->round, MAX_RDCU_ROUND); - cfg_invalid++; - } - -#ifdef SKIP_CMP_PAR_CHECK - return 0; -#endif - - return -cfg_invalid; -} - - /** * @brief create an RDCU compression configuration * @@ -155,7 +105,7 @@ struct cmp_cfg rdcu_cfg_create(enum cmp_data_type data_type, enum cmp_mode cmp_m cfg.model_value = model_value; cfg.round = lossy_par; - if (rdcu_cfg_gen_par_is_invalid(&cfg)) + if (cmp_cfg_gen_par_is_invalid(&cfg, RDCU_CHECK)) cfg.data_type = DATA_TYPE_UNKNOWN; return cfg; @@ -163,26 +113,26 @@ struct cmp_cfg rdcu_cfg_create(enum cmp_data_type data_type, enum cmp_mode cmp_m /** - * @brief check if a buffer is in inside the RDCU SRAM + * @brief check if a buffer is in outside the RDCU SRAM * * @param addr start address of the buffer * @param size length of the buffer in bytes * - * @returns 1 if buffer in inside the RDCU SRAM, 0 when the buffer is outside + * @returns 0 if buffer in inside the RDCU SRAM, 1 when the buffer is outside */ -static int in_sram_range(uint32_t addr, uint32_t size) +static int outside_sram_range(uint32_t addr, uint32_t size) { + if (addr + size > RDCU_SRAM_END) + return 1; + if (addr > RDCU_SRAM_END) - return 0; + return 1; if (size > RDCU_SRAM_SIZE) - return 0; - - if (addr + size > RDCU_SRAM_END) - return 0; + return 1; - return 1; + return 0; } @@ -224,7 +174,7 @@ static int rdcu_cfg_buffers_is_invalid(const struct cmp_cfg *cfg) if (cfg->cmp_mode == CMP_MODE_RAW) { if (cfg->buffer_length < cfg->samples) { - debug_print("rdcu_buffer_length is smaller than samples parameter. There is not enough space to copy the data in RAW mode.\n"); + debug_print("rdcu_buffer_length is smaller than the samples parameter. There is not enough space to copy the data in RAW mode.\n"); cfg_invalid++; } } @@ -239,12 +189,12 @@ static int rdcu_cfg_buffers_is_invalid(const struct cmp_cfg *cfg) cfg_invalid++; } - if (!in_sram_range(cfg->rdcu_data_adr, cfg->samples * IMA_SAM2BYT)) { + if (outside_sram_range(cfg->rdcu_data_adr, cfg->samples * IMA_SAM2BYT)) { debug_print("Error: The RDCU data to compress buffer is outside the RDCU SRAM address space.\n"); cfg_invalid++; } - if (!in_sram_range(cfg->rdcu_buffer_adr, cfg->buffer_length * IMA_SAM2BYT)) { + if (outside_sram_range(cfg->rdcu_buffer_adr, cfg->buffer_length * IMA_SAM2BYT)) { debug_print("Error: The RDCU compressed data buffer is outside the RDCU SRAM address space.\n"); cfg_invalid++; } @@ -259,7 +209,7 @@ static int rdcu_cfg_buffers_is_invalid(const struct cmp_cfg *cfg) if (model_mode_is_used(cfg->cmp_mode)) { if (cfg->model_buf && cfg->model_buf == cfg->input_buf) { - debug_print("Error: The model buffer (model_buf) and the data to be compressed (input_buf) are equal."); + debug_print("Error: The model buffer (model_buf) and the data to be compressed (input_buf) are equal.\n"); cfg_invalid++; } @@ -268,7 +218,7 @@ static int rdcu_cfg_buffers_is_invalid(const struct cmp_cfg *cfg) cfg_invalid++; } - if (!in_sram_range(cfg->rdcu_model_adr, cfg->samples * IMA_SAM2BYT)) { + if (outside_sram_range(cfg->rdcu_model_adr, cfg->samples * IMA_SAM2BYT)) { debug_print("Error: The RDCU model buffer is outside the RDCU SRAM address space.\n"); cfg_invalid++; } @@ -298,7 +248,7 @@ static int rdcu_cfg_buffers_is_invalid(const struct cmp_cfg *cfg) cfg_invalid++; } - if (!in_sram_range(cfg->rdcu_new_model_adr, + if (outside_sram_range(cfg->rdcu_new_model_adr, cfg->samples * IMA_SAM2BYT)) { debug_print("Error: The RDCU updated model buffer is outside the RDCU SRAM address space.\n"); cfg_invalid++; @@ -335,16 +285,10 @@ static int rdcu_cfg_buffers_is_invalid(const struct cmp_cfg *cfg) } } - if (cfg->icu_new_model_buf) - debug_print("Warning: ICU updated model buffer is set. This buffer is not used for an RDCU compression.\n"); - - if (cfg->icu_output_buf) - debug_print("Warning: ICU compressed data buffer is set. This buffer is not used for an RDCU compression.\n"); - #ifdef SKIP_CMP_PAR_CHECK return 0; #endif - return -cfg_invalid; + return cfg_invalid; } @@ -392,90 +336,7 @@ int rdcu_cfg_buffers(struct cmp_cfg *cfg, uint16_t *data_to_compress, cfg->rdcu_buffer_adr = rdcu_buffer_adr; cfg->buffer_length = rdcu_buffer_lenght; - if (rdcu_cfg_buffers_is_invalid(cfg)) - return -1; - - return 0; -} - - -/** - * @brief check if the Golomb and spillover threshold parameter combination is - * invalid for an RDCU compression - * @note also checked the adaptive Golomb and spillover threshold parameter combinations - * - * @param cfg a pointer to a compression configuration - * - * @returns 0 if (adaptive) Golomb spill threshold parameter combinations are - * valid, otherwise the configuration is invalid - */ - -static int rdcu_cfg_imagette_is_invalid(const struct cmp_cfg *cfg) -{ - int cfg_invalid = 0; - - if (cfg->golomb_par < MIN_IMA_GOLOMB_PAR || - cfg->golomb_par > MAX_IMA_GOLOMB_PAR) { - debug_print("Error: The selected Golomb parameter: %" PRIu32 " is not supported. The Golomb parameter has to be between [%u, %u].\n", - cfg->golomb_par, MIN_IMA_GOLOMB_PAR, MAX_IMA_GOLOMB_PAR); - cfg_invalid++; - } - - if (cfg->ap1_golomb_par < MIN_IMA_GOLOMB_PAR || - cfg->ap1_golomb_par > MAX_IMA_GOLOMB_PAR) { - debug_print("Error: The selected adaptive 1 Golomb parameter: %" PRIu32 " is not supported. The Golomb parameter has to be between [%u, %u].\n", - cfg->ap1_golomb_par, MIN_IMA_GOLOMB_PAR, MAX_IMA_GOLOMB_PAR); - cfg_invalid++; - } - - if (cfg->ap2_golomb_par < MIN_IMA_GOLOMB_PAR || - cfg->ap2_golomb_par > MAX_IMA_GOLOMB_PAR) { - debug_print("Error: The selected adaptive 2 Golomb parameter: %" PRIu32 " is not supported. The Golomb parameter has to be between [%u, %u].\n", - cfg->ap2_golomb_par, MIN_IMA_GOLOMB_PAR, MAX_IMA_GOLOMB_PAR); - cfg_invalid++; - } - - if (cfg->spill < MIN_IMA_SPILL) { - debug_print("Error: The selected spillover threshold value: %" PRIu32 " is too small. Smallest possible spillover value is: %u.\n", - cfg->spill, MIN_IMA_SPILL); - cfg_invalid++; - } - - if (cfg->spill > cmp_ima_max_spill(cfg->golomb_par)) { - debug_print("Error: The selected spillover threshold value: %" PRIu32 " is too large for the selected Golomb parameter: %" PRIu32 ", the largest possible spillover value is: %" PRIu32 ".\n", - cfg->spill, cfg->golomb_par, cmp_ima_max_spill(cfg->golomb_par)); - cfg_invalid++; - } - - if (cfg->ap1_spill < MIN_IMA_SPILL) { - debug_print("Error: The selected adaptive 1 spillover threshold value: %" PRIu32 " is too small. Smallest possible spillover value is: %u.\n", - cfg->ap1_spill, MIN_IMA_SPILL); - cfg_invalid++; - } - - if (cfg->ap1_spill > cmp_ima_max_spill(cfg->ap1_golomb_par)) { - debug_print("Error: The selected adaptive 1 spillover threshold value: %" PRIu32 " is too large for the selected adaptive 1 Golomb parameter: %" PRIu32 ", the largest possible adaptive 1 spillover value is: %" PRIu32 ".\n", - cfg->ap1_spill, cfg->ap1_golomb_par, cmp_ima_max_spill(cfg->ap1_golomb_par)); - cfg_invalid++; - } - - if (cfg->ap2_spill < MIN_IMA_SPILL) { - debug_print("Error: The selected adaptive 2 spillover threshold value: %" PRIu32 " is too small. Smallest possible spillover value is: %u.\n", - cfg->ap2_spill, MIN_IMA_SPILL); - cfg_invalid++; - } - - if (cfg->ap2_spill > cmp_ima_max_spill(cfg->ap2_golomb_par)) { - debug_print("Error: The selected adaptive 2 spillover threshold value: %" PRIu32 " is too large for the selected adaptive 2 Golomb parameter: %" PRIu32 ", the largest possible adaptive 2 spillover value is: %" PRIu32 ".\n", - cfg->ap2_spill, cfg->ap2_golomb_par, cmp_ima_max_spill(cfg->ap2_golomb_par)); - cfg_invalid++; - } - -#ifdef SKIP_CMP_PAR_CHECK - return 0; -#endif - - return -cfg_invalid; + return rdcu_cfg_buffers_is_invalid(cfg); } @@ -511,10 +372,7 @@ int rdcu_cfg_imagette(struct cmp_cfg *cfg, cfg->ap2_golomb_par = ap2_golomb_par; cfg->ap2_spill = ap2_spillover_par; - if (rdcu_cfg_imagette_is_invalid(cfg)) - return -1; - - return 0; + return cmp_cfg_imagette_is_invalid(cfg, RDCU_CHECK); } @@ -538,29 +396,32 @@ int rdcu_cmp_cfg_is_invalid(const struct cmp_cfg *cfg) } if (!cfg->input_buf) - debug_print("Warning: The data to compress buffer is set to NULL. No data will be transferred to the rdcu_data_adr in the RDCU-SRAM.\n"); + debug_print("Warning: The data to compress buffer is set to NULL. No data will be transferred to the rdcu_data_adr in the RDCU SRAM.\n"); if (model_mode_is_used(cfg->cmp_mode)) { if (!cfg->model_buf) - debug_print("Warning: The model buffer is set to NULL. No model data will be transferred to the rdcu_model_adr in the RDCU-SRAM.\n"); + debug_print("Warning: The model buffer is set to NULL. No model data will be transferred to the rdcu_model_adr in the RDCU SRAM.\n"); } - if (cfg->input_buf && cfg->samples == 0) + if (cfg->samples == 0) debug_print("Warning: The samples parameter is set to 0. No data will be compressed.\n"); + if (cfg->icu_new_model_buf) + debug_print("Warning: ICU updated model buffer is set. This buffer is not used for an RDCU compression.\n"); + + if (cfg->icu_output_buf) + debug_print("Warning: ICU compressed data buffer is set. This buffer is not used for an RDCU compression.\n"); + if (cfg->buffer_length == 0) { debug_print("Error: The buffer_length is set to 0. There is no place to store the compressed data.\n"); cfg_invalid++; } - if (rdcu_cfg_gen_par_is_invalid(cfg)) - cfg_invalid++; - if (rdcu_cfg_buffers_is_invalid(cfg)) - cfg_invalid++; - if (rdcu_cfg_imagette_is_invalid(cfg)) - cfg_invalid++; + cfg_invalid += cmp_cfg_gen_par_is_invalid(cfg, RDCU_CHECK); + cfg_invalid += rdcu_cfg_buffers_is_invalid(cfg); + cfg_invalid += cmp_cfg_imagette_is_invalid(cfg, RDCU_CHECK); - return -cfg_invalid; + return cfg_invalid; } @@ -975,7 +836,7 @@ int rdcu_compress_data_parallel(const struct cmp_cfg *cfg, cmp_size_4byte = ((last_info->cmp_size >> 3) + 3) & ~0x3U; /* parallel read compressed data and write input data from sram - * to mirror*/ + * to mirror */ if (rdcu_sync_sram_mirror_parallel(last_info->rdcu_cmp_adr_used, cmp_size_4byte, cfg->rdcu_data_adr, samples_4byte, rdcu_get_data_mtu())) diff --git a/lib/cmp_support.c b/lib/cmp_support.c index 4a90564d4fb21a449081c4a26b2c4e8d3567f9bf..eb1c730e6ba31cf3558094341574d75702e756ca 100644 --- a/lib/cmp_support.c +++ b/lib/cmp_support.c @@ -441,44 +441,77 @@ unsigned int cmp_bit_to_4byte(unsigned int cmp_size_bit) /** * @brief check if the compression data type, compression mode, model value and - * the lossy rounding parameters are invalid for a ICU compression + * the lossy rounding parameters are invalid for a RDCU or ICU compression * - * @param cfg pointer to the compressor configuration + * @param cfg pointer to a compression configuration containing the compression + * data product type, compression mode, model value and the rounding parameters + * @param opt check options: + * RDCU_CHECK for RDCU compression check + * ICU_CHECK for ICU compression check * - * @returns 0 if generic compression parameters are valid, otherwise invalid + * @returns 0 if the compression data type, compression mode, model value and + * the lossy rounding parameters are valid for an RDCU or ICU compression, + * non-zero if parameters are invalid */ -int cmp_cfg_icu_gen_par_is_invalid(const struct cmp_cfg *cfg) +int cmp_cfg_gen_par_is_invalid(const struct cmp_cfg *cfg, enum check_opt opt) { int cfg_invalid = 0; + int invalid_data_type; + int unsupported_cmp_mode; + int check_model_value; + uint32_t max_round_value; + char *str = ""; if (!cfg) - return 0; + return 1; - if (cmp_data_type_is_invalid(cfg->data_type)) { - debug_print("Error: selected compression data type is not supported.\n"); + switch (opt) { + case RDCU_CHECK: + /* the RDCU can only compress imagette data */ + invalid_data_type = !cmp_imagette_data_type_is_used(cfg->data_type); + unsupported_cmp_mode = !rdcu_supported_cmp_mode_is_used(cfg->cmp_mode); + max_round_value = MAX_RDCU_ROUND; + /* for the RDCU the model vale has to be always in the allowed range */ + check_model_value = 1; + str = " for a RDCU compression"; + break; + case ICU_CHECK: + invalid_data_type = cmp_data_type_is_invalid(cfg->data_type); + unsupported_cmp_mode = !cmp_mode_is_supported(cfg->cmp_mode); + max_round_value = MAX_ICU_ROUND; + check_model_value = model_mode_is_used(cfg->cmp_mode); + break; + } + + if (invalid_data_type) { + debug_print("Error: selected compression data type is not supported%s.\n", str); cfg_invalid++; } - if (cfg->cmp_mode > CMP_MODE_STUFF) { - debug_print("Error: selected cmp_mode: %i is not supported.\n", cfg->cmp_mode); + if (unsupported_cmp_mode) { + debug_print("Error: selected cmp_mode: %i is not supported%s.\n", cfg->cmp_mode, str); cfg_invalid++; } - if (model_mode_is_used(cfg->cmp_mode)) { + if (check_model_value) { if (cfg->model_value > MAX_MODEL_VALUE) { - debug_print("Error: selected model_value: %" PRIu32 " is invalid. Largest supported value is: %u.\n", + debug_print("Error: selected model_value: %" PRIu32 " is invalid. The largest supported value is: %u.\n", cfg->model_value, MAX_MODEL_VALUE); cfg_invalid++; } } - if (cfg->round > MAX_ICU_ROUND) { - debug_print("Error: selected lossy parameter: %" PRIu32 " is not supported. Largest supported value is: %u.\n", - cfg->round, MAX_ICU_ROUND); + if (cfg->round > max_round_value) { + debug_print("Error: selected lossy parameter: %" PRIu32 " is not supported%s. The largest supported value is: %u.\n", + cfg->round, str, max_round_value); cfg_invalid++; } +#ifdef SKIP_CMP_PAR_CHECK + return 0; +#endif + return cfg_invalid; } @@ -496,7 +529,7 @@ int cmp_cfg_icu_buffers_is_invalid(const struct cmp_cfg *cfg) int cfg_invalid = 0; if (!cfg) - return 0; + return 1; if (cfg->input_buf == NULL) { debug_print("Error: The data_to_compress buffer for the data to be compressed is NULL.\n"); @@ -578,9 +611,6 @@ static int cmp_pars_are_invalid(uint32_t cmp_par, uint32_t spill, enum cmp_mode uint32_t min_spill; uint32_t max_spill; - if (!par_name) - par_name = ""; - /* The maximum compression parameter for imagette data are smaller to * fit into the imagette compression entity header */ if (cmp_imagette_data_type_is_used(data_type)) { @@ -605,17 +635,17 @@ static int cmp_pars_are_invalid(uint32_t cmp_par, uint32_t spill, enum cmp_mode case CMP_MODE_MODEL_ZERO: case CMP_MODE_MODEL_MULTI: if (cmp_par < min_golomb_par || cmp_par > max_golomb_par) { - debug_print("Error: The selected %s compression parameter: %" PRIu32 " is not supported. The compression parameter has to be between [%" PRIu32 ", %" PRIu32 "].\n", + debug_print("Error: The selected %s compression parameter: %" PRIu32 " is not supported in the selected compression mode. The compression parameter has to be between [%" PRIu32 ", %" PRIu32 "] in this mode.\n", par_name, cmp_par, min_golomb_par, max_golomb_par); cfg_invalid++; } if (spill < min_spill) { - debug_print("Error: The selected %s spillover threshold value: %" PRIu32 " is too small. Smallest possible spillover value is: %" PRIu32 ".\n", + debug_print("Error: The selected %s spillover threshold value: %" PRIu32 " is too small. The smallest possible spillover value is: %" PRIu32 ".\n", par_name, spill, min_spill); cfg_invalid++; } if (spill > max_spill) { - debug_print("Error: The selected %s spillover threshold value: %" PRIu32 " is too large for the selected %s compression parameter: %" PRIu32 ", the largest possible spillover value in the selected compression mode is: %" PRIu32 ".\n", + debug_print("Error: The selected %s spillover threshold value: %" PRIu32 " is too large for the selected %s compression parameter: %" PRIu32 ". The largest possible spillover value in the selected compression mode is: %" PRIu32 ".\n", par_name, spill, par_name, cmp_par, max_spill); cfg_invalid++; } @@ -623,7 +653,7 @@ static int cmp_pars_are_invalid(uint32_t cmp_par, uint32_t spill, enum cmp_mode 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.\n", + 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.\n", par_name, cmp_par, MAX_STUFF_CMP_PAR); cfg_invalid++; } @@ -642,19 +672,20 @@ static int cmp_pars_are_invalid(uint32_t cmp_par, uint32_t spill, enum cmp_mode * @brief check if the imagette specific compression parameters are invalid * * @param cfg pointer to the compressor configuration - * @param rdcu_check set to non-zero if a check for a imagette RDCU compression - * should be done; zero for imagette ICU compression + * @param opt check options: + * RDCU_CHECK for a imagette RDCU compression check + * ICU_CHECK for a imagette ICU compression check * * @returns 0 if the imagette specific parameters are valid, otherwise invalid */ -int cmp_cfg_imagette_is_invalid(const struct cmp_cfg *cfg, int rdcu_check) +int cmp_cfg_imagette_is_invalid(const struct cmp_cfg *cfg, enum check_opt opt) { int cfg_invalid = 0; enum cmp_mode cmp_mode; if (!cfg) - return 0; + return 1; if (!cmp_imagette_data_type_is_used(cfg->data_type)) { debug_print("Error: The compression data type is not an imagette compression data type.\n"); @@ -662,7 +693,7 @@ int cmp_cfg_imagette_is_invalid(const struct cmp_cfg *cfg, int rdcu_check) } /* The RDCU needs valid compression parameters also in RAW_MODE */ - if (rdcu_check && cfg->cmp_mode == CMP_MODE_RAW) + if (opt == RDCU_CHECK && cfg->cmp_mode == CMP_MODE_RAW) cmp_mode = CMP_MODE_MODEL_ZERO; else cmp_mode = cfg->cmp_mode; @@ -671,7 +702,7 @@ int cmp_cfg_imagette_is_invalid(const struct cmp_cfg *cfg, int rdcu_check) cfg->data_type, "imagette"); /* for the RDCU the adaptive parameters have to be always valid */ - if (rdcu_check || cmp_ap_imagette_data_type_is_used(cfg->data_type)) { + if (opt == RDCU_CHECK || cmp_ap_imagette_data_type_is_used(cfg->data_type)) { cfg_invalid += cmp_pars_are_invalid(cfg->ap1_golomb_par, cfg->ap1_spill, cmp_mode, cfg->data_type, "adaptive 1 imagette"); cfg_invalid += cmp_pars_are_invalid(cfg->ap2_golomb_par, cfg->ap2_spill, @@ -783,7 +814,7 @@ int cmp_cfg_fx_cob_is_invalid(const struct cmp_cfg *cfg) struct fx_cob_par needed_pars; if (!cfg) - return 0; + return 1; if (!cmp_fx_cob_data_type_is_used(cfg->data_type)) { debug_print("Error: The compression data type is not a flux/center of brightness compression data type.\n"); @@ -792,7 +823,7 @@ int cmp_cfg_fx_cob_is_invalid(const struct cmp_cfg *cfg) cmp_cfg_fx_cob_get_need_pars(cfg->data_type, &needed_pars); - if (needed_pars.fx) + if (needed_pars.fx) /* this is always true because every flux/center of brightness data type contains a flux parameter */ cfg_invalid += cmp_pars_are_invalid(cfg->cmp_par_fx, cfg->spill_fx, cfg->cmp_mode, cfg->data_type, "flux"); if (needed_pars.exp_flags) @@ -830,7 +861,7 @@ int cmp_cfg_aux_is_invalid(const struct cmp_cfg *cfg) int cfg_invalid = 0; if (!cfg) - return 0; + return 1; if (!cmp_aux_data_type_is_used(cfg->data_type)) { debug_print("Error: The compression data type is not an auxiliary science compression data type.\n"); @@ -852,21 +883,21 @@ int cmp_cfg_aux_is_invalid(const struct cmp_cfg *cfg) /** - * @brief check if a compression configuration is invalid + * @brief check if a compression configuration is invalid for ICU compression * * @param cfg pointer to the compressor configuration * * @returns 0 if the compression configuration is valid, otherwise invalid */ -int cmp_cfg_is_invalid(const struct cmp_cfg *cfg) +int cmp_cfg_icu_is_invalid(const struct cmp_cfg *cfg) { int cfg_invalid = 0; if (!cfg) - return 0; + return 1; - cfg_invalid += cmp_cfg_icu_gen_par_is_invalid(cfg); + cfg_invalid += cmp_cfg_gen_par_is_invalid(cfg, ICU_CHECK); cfg_invalid += cmp_cfg_icu_buffers_is_invalid(cfg); diff --git a/test/cmp_icu/test_cmp_icu.c b/test/cmp_icu/test_cmp_icu.c index 6126542fd1ac859bd1501db1e4b04a20f07a6cac..09c0720009713c3f7439490ec793541b913c3e5b 100644 --- a/test/cmp_icu/test_cmp_icu.c +++ b/test/cmp_icu/test_cmp_icu.c @@ -4418,7 +4418,7 @@ void test_support_function_call_NULL(void) TEST_ASSERT_TRUE(cmp_cfg_imagette_is_invalid(NULL, ICU_CHECK)); TEST_ASSERT_TRUE(cmp_cfg_fx_cob_is_invalid(NULL)); TEST_ASSERT_TRUE(cmp_cfg_aux_is_invalid(NULL)); - TEST_ASSERT_TRUE(cmp_cfg_is_invalid(NULL)); + TEST_ASSERT_TRUE(cmp_cfg_icu_is_invalid(NULL)); TEST_ASSERT_TRUE(cmp_cfg_fx_cob_get_need_pars(DATA_TYPE_S_FX, NULL)); } diff --git a/test/cmp_rdcu/meson.build b/test/cmp_rdcu/meson.build new file mode 100644 index 0000000000000000000000000000000000000000..9c51877aabb3fdeca82b456ec8626ad0bf1c9aeb --- /dev/null +++ b/test/cmp_rdcu/meson.build @@ -0,0 +1,12 @@ +test_case = files('test_cmp_rdcu.c') +test_runner = test_runner_generator.process(test_case) + +test_cmp_rdcu = executable('test_cmp_rdcu', + test_case, test_runner, + include_directories : incdir, + link_with : cmp_lib, + dependencies : unity_dep, + build_by_default : false +) + +test('Hardware Compressor Control Library Tests', test_cmp_rdcu) diff --git a/test/cmp_rdcu/test_cmp_rdcu.c b/test/cmp_rdcu/test_cmp_rdcu.c new file mode 100644 index 0000000000000000000000000000000000000000..c4b3b7dde1515580992b8b3d5f007646f70f51d7 --- /dev/null +++ b/test/cmp_rdcu/test_cmp_rdcu.c @@ -0,0 +1,752 @@ +/** + * @file test_cmp_rdcu.c + * @author Dominik Loidolt (dominik.loidolt@univie.ac.at), + * @date 2022 + * + * @copyright GPLv2 + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * @brief hardware compressor control library tests + */ + +#include <stdint.h> + +#include <unity.h> +#include <cmp_rdcu.h> +#include <rdcu_cmd.h> + + +/** + * @test rdcu_cfg_create + */ + +void test_rdcu_cfg_create(void) +{ + struct cmp_cfg cfg; + enum cmp_data_type data_type; + enum cmp_mode cmp_mode; + uint32_t model_value, lossy_par; + + /* wrong data type tests */ + data_type = DATA_TYPE_UNKNOWN; /* not valid data type */ + cmp_mode = CMP_MODE_RAW; + model_value = 0; + lossy_par = CMP_LOSSLESS; + cfg = rdcu_cfg_create(data_type, cmp_mode, model_value, lossy_par); + TEST_ASSERT_EQUAL(DATA_TYPE_UNKNOWN, cfg.data_type); + + /* data_type not supported by RDCU */ + data_type = DATA_TYPE_OFFSET; + cfg = rdcu_cfg_create(data_type, cmp_mode, model_value, lossy_par); + TEST_ASSERT_EQUAL(DATA_TYPE_UNKNOWN, cfg.data_type); + + data_type = -1; /* not valid data type */ + cfg = rdcu_cfg_create(data_type, cmp_mode, model_value, lossy_par); + TEST_ASSERT_EQUAL(DATA_TYPE_UNKNOWN, cfg.data_type); + + /*now it should work */ + data_type = DATA_TYPE_F_CAM_IMAGETTE_ADAPTIVE; + 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); + TEST_ASSERT_EQUAL(model_value, cfg.model_value); + TEST_ASSERT_EQUAL(lossy_par, cfg.round); + + + /* wrong compression mode tests */ + cmp_mode = CMP_MODE_STUFF; /* 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 = -1; + 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; + 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); + TEST_ASSERT_EQUAL(model_value, cfg.model_value); + TEST_ASSERT_EQUAL(lossy_par, cfg.round); + + + /* wrong model_value tests */ + cmp_mode = CMP_MODE_DIFF_ZERO; + model_value = MAX_MODEL_VALUE + 1; + cfg = rdcu_cfg_create(data_type, cmp_mode, model_value, lossy_par); + TEST_ASSERT_EQUAL(DATA_TYPE_UNKNOWN, cfg.data_type); + + cmp_mode = CMP_MODE_RAW; + model_value = -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 */ + model_value = MAX_MODEL_VALUE; + 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); + TEST_ASSERT_EQUAL(model_value, cfg.model_value); + TEST_ASSERT_EQUAL(lossy_par, cfg.round); + + + /* wrong lossy_par tests */ + lossy_par = MAX_RDCU_ROUND + 1; + cfg = rdcu_cfg_create(data_type, cmp_mode, model_value, lossy_par); + TEST_ASSERT_EQUAL(DATA_TYPE_UNKNOWN, cfg.data_type); + + lossy_par = -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 */ + lossy_par = MAX_RDCU_ROUND; + 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); + TEST_ASSERT_EQUAL(model_value, cfg.model_value); + TEST_ASSERT_EQUAL(lossy_par, cfg.round); + + + /* wrong data type test */ + for (data_type = 0; data_type <= DATA_TYPE_F_CAM_BACKGROUND; data_type++) { + cfg = rdcu_cfg_create(data_type, CMP_MODE_DIFF_MULTI, MAX_MODEL_VALUE, CMP_LOSSLESS); + if (data_type == DATA_TYPE_IMAGETTE || + data_type == DATA_TYPE_IMAGETTE_ADAPTIVE || + data_type == DATA_TYPE_SAT_IMAGETTE || + data_type == DATA_TYPE_SAT_IMAGETTE_ADAPTIVE || + data_type == DATA_TYPE_F_CAM_IMAGETTE || + data_type == DATA_TYPE_F_CAM_IMAGETTE_ADAPTIVE) { + TEST_ASSERT_EQUAL(data_type, cfg.data_type); + TEST_ASSERT_EQUAL(CMP_MODE_DIFF_MULTI, cfg.cmp_mode); + TEST_ASSERT_EQUAL(MAX_MODEL_VALUE, cfg.model_value); + TEST_ASSERT_EQUAL(CMP_LOSSLESS, cfg.round); + } else { + TEST_ASSERT_EQUAL(DATA_TYPE_UNKNOWN, cfg.data_type); + } + } +} + + +/** + * @test rdcu_cfg_buffers + */ + +void test_rdcu_cfg_buffers_raw_diff(void) +{ + int error; + struct cmp_cfg cfg; + uint16_t data_to_compress[4] = {0x23, 0x42, 0xFF, 0x32}; + uint32_t data_samples = 4; + uint32_t rdcu_data_adr, rdcu_model_adr, rdcu_new_model_adr; + uint32_t rdcu_buffer_adr, rdcu_buffer_lenght; + + + /* test a RAW mode buffer configuration */ + cfg = rdcu_cfg_create(DATA_TYPE_IMAGETTE_ADAPTIVE, CMP_MODE_RAW, + MAX_MODEL_VALUE, CMP_LOSSLESS); + + rdcu_model_adr = 0x0; + rdcu_new_model_adr = 0x0; + rdcu_data_adr = 0x0; + rdcu_buffer_adr = 0x8; + rdcu_buffer_lenght = 4; + error = rdcu_cfg_buffers(&cfg, data_to_compress, data_samples, NULL, + rdcu_data_adr, rdcu_model_adr, rdcu_new_model_adr, + rdcu_buffer_adr, rdcu_buffer_lenght); + TEST_ASSERT_FALSE(error); + TEST_ASSERT_EQUAL(data_to_compress, cfg.input_buf); + TEST_ASSERT_EQUAL(data_samples, cfg.samples); + TEST_ASSERT_EQUAL(NULL, cfg.model_buf); + TEST_ASSERT_EQUAL(rdcu_data_adr, cfg.rdcu_data_adr); + TEST_ASSERT_EQUAL(rdcu_model_adr, cfg.rdcu_model_adr); + TEST_ASSERT_EQUAL(rdcu_new_model_adr, cfg.rdcu_new_model_adr); + TEST_ASSERT_EQUAL(rdcu_buffer_adr, cfg.rdcu_buffer_adr); + TEST_ASSERT_EQUAL(rdcu_buffer_lenght, cfg.buffer_length); + + /* set input buffer to NULL */ + error = rdcu_cfg_buffers(&cfg, NULL, data_samples, NULL, + rdcu_data_adr, rdcu_model_adr, rdcu_new_model_adr, + rdcu_buffer_adr, rdcu_buffer_lenght); + TEST_ASSERT_FALSE(error); + + /* error: destination buffer to small */ + rdcu_data_adr = 0x0; + rdcu_buffer_adr = 0x8; + rdcu_buffer_lenght = 3; + error = rdcu_cfg_buffers(&cfg, data_to_compress, data_samples, NULL, + rdcu_data_adr, rdcu_model_adr, rdcu_new_model_adr, + rdcu_buffer_adr, rdcu_buffer_lenght); + TEST_ASSERT_EQUAL(1, error); + + /* error: data and compressed buffer overlap */ + rdcu_data_adr = 0x0; + rdcu_buffer_adr = 0x4; + rdcu_buffer_lenght = 4; + error = rdcu_cfg_buffers(&cfg, data_to_compress, data_samples, NULL, + rdcu_data_adr, rdcu_model_adr, rdcu_new_model_adr, + rdcu_buffer_adr, rdcu_buffer_lenght); + TEST_ASSERT_EQUAL(1, error); + + /* get a diff config */ + cfg = rdcu_cfg_create(DATA_TYPE_IMAGETTE, CMP_MODE_DIFF_MULTI, + MAX_MODEL_VALUE, CMP_LOSSLESS); + rdcu_data_adr = 0x4; + rdcu_buffer_adr = 0x0; + rdcu_buffer_lenght = 4; + error = rdcu_cfg_buffers(&cfg, data_to_compress, data_samples, NULL, + rdcu_data_adr, rdcu_model_adr, rdcu_new_model_adr, + rdcu_buffer_adr, rdcu_buffer_lenght); + TEST_ASSERT_EQUAL(1, error); + + /* error: data or SRAM addresses out of allowed range */ + rdcu_data_adr = RDCU_SRAM_END & ~0x3UL; + rdcu_buffer_adr = 0x8; + rdcu_buffer_lenght = 4; + error = rdcu_cfg_buffers(&cfg, data_to_compress, data_samples, NULL, + rdcu_data_adr, rdcu_model_adr, rdcu_new_model_adr, + rdcu_buffer_adr, rdcu_buffer_lenght); + TEST_ASSERT_EQUAL(1, error); + + rdcu_data_adr = 0x0; + rdcu_buffer_adr = 0x8; + rdcu_buffer_lenght = RDCU_SRAM_SIZE; + error = rdcu_cfg_buffers(&cfg, data_to_compress, data_samples, NULL, + rdcu_data_adr, rdcu_model_adr, rdcu_new_model_adr, + rdcu_buffer_adr, rdcu_buffer_lenght); + TEST_ASSERT_EQUAL(1, error); + + rdcu_data_adr = 0xFFFFFFFC; + rdcu_buffer_adr = 0x8; + rdcu_buffer_lenght = 4; + error = rdcu_cfg_buffers(&cfg, data_to_compress, data_samples, NULL, + rdcu_data_adr, rdcu_model_adr, rdcu_new_model_adr, + rdcu_buffer_adr, rdcu_buffer_lenght); + TEST_ASSERT_EQUAL(1, error); + + rdcu_data_adr = 0x0; + rdcu_buffer_adr = 0x8; + rdcu_buffer_lenght = UINT32_MAX; + error = rdcu_cfg_buffers(&cfg, data_to_compress, data_samples, NULL, + rdcu_data_adr, rdcu_model_adr, rdcu_new_model_adr, + rdcu_buffer_adr, rdcu_buffer_lenght); + TEST_ASSERT_EQUAL(1, error); + + /* error: data and buffer addresses are not 4 byte aligned */ + rdcu_data_adr = 0x2; + rdcu_buffer_adr = 0x10; + rdcu_buffer_lenght = 4; + error = rdcu_cfg_buffers(&cfg, data_to_compress, data_samples, NULL, + rdcu_data_adr, rdcu_model_adr, rdcu_new_model_adr, + rdcu_buffer_adr, rdcu_buffer_lenght); + TEST_ASSERT_EQUAL(1, error); + + rdcu_data_adr = 0x0; + rdcu_buffer_adr = 0x9; + rdcu_buffer_lenght = 4; + error = rdcu_cfg_buffers(&cfg, data_to_compress, data_samples, NULL, + rdcu_data_adr, rdcu_model_adr, rdcu_new_model_adr, + rdcu_buffer_adr, rdcu_buffer_lenght); + TEST_ASSERT_EQUAL(1, error); + + /* error: cfg = NULL */ + error = rdcu_cfg_buffers(NULL, data_to_compress, data_samples, NULL, + rdcu_data_adr, rdcu_model_adr, rdcu_new_model_adr, + rdcu_buffer_adr, rdcu_buffer_lenght); + TEST_ASSERT_EQUAL(-1, error); +} + + +/** + * @test rdcu_cfg_buffers + */ + +void test_rdcu_cfg_buffers_model(void) +{ + int error; + struct cmp_cfg cfg; + uint16_t data_to_compress[4] = {0x23, 0x42, 0xFF, 0x32}; + uint16_t model_of_data[4] = {0xFF, 0x12, 0x34, 0xAB}; + uint32_t data_samples = 4; + uint32_t rdcu_data_adr, rdcu_model_adr, rdcu_new_model_adr; + uint32_t rdcu_buffer_adr, rdcu_buffer_lenght; + + + /* test a RAW mode buffer configuration */ + cfg = rdcu_cfg_create(DATA_TYPE_IMAGETTE, CMP_MODE_MODEL_MULTI, + MAX_MODEL_VALUE, CMP_LOSSLESS); + + rdcu_data_adr = 0x0; + rdcu_model_adr = 0x8; + rdcu_new_model_adr = 0x10; + rdcu_buffer_adr = 0x18; + rdcu_buffer_lenght = 4; + error = rdcu_cfg_buffers(&cfg, data_to_compress, data_samples, model_of_data, + rdcu_data_adr, rdcu_model_adr, rdcu_new_model_adr, + rdcu_buffer_adr, rdcu_buffer_lenght); + TEST_ASSERT_FALSE(error); + TEST_ASSERT_EQUAL(data_to_compress, cfg.input_buf); + TEST_ASSERT_EQUAL(data_samples, cfg.samples); + TEST_ASSERT_EQUAL(model_of_data, cfg.model_buf); + TEST_ASSERT_EQUAL(rdcu_data_adr, cfg.rdcu_data_adr); + TEST_ASSERT_EQUAL(rdcu_model_adr, cfg.rdcu_model_adr); + TEST_ASSERT_EQUAL(rdcu_new_model_adr, cfg.rdcu_new_model_adr); + TEST_ASSERT_EQUAL(rdcu_buffer_adr, cfg.rdcu_buffer_adr); + TEST_ASSERT_EQUAL(rdcu_buffer_lenght, cfg.buffer_length); + + /* data and model buffers are NULL */ + rdcu_new_model_adr = rdcu_model_adr; + error = rdcu_cfg_buffers(&cfg, NULL, data_samples, NULL, + rdcu_data_adr, rdcu_model_adr, rdcu_new_model_adr, + rdcu_buffer_adr, rdcu_buffer_lenght); + TEST_ASSERT_FALSE(error); + + /* error: data and model buffer are the same */ + error = rdcu_cfg_buffers(&cfg, data_to_compress, data_samples, data_to_compress, + rdcu_data_adr, rdcu_model_adr, rdcu_new_model_adr, + rdcu_buffer_adr, rdcu_buffer_lenght); + TEST_ASSERT_EQUAL(1, error); + + /* error: model address not 4 byte aligned */ + rdcu_data_adr = 0x0; + rdcu_model_adr = 0xA; /* not 4 byte aligned */ + rdcu_new_model_adr = rdcu_model_adr; + rdcu_buffer_adr = 0x14; + rdcu_buffer_lenght = 4; + error = rdcu_cfg_buffers(&cfg, data_to_compress, data_samples, model_of_data, + rdcu_data_adr, rdcu_model_adr, rdcu_new_model_adr, + rdcu_buffer_adr, rdcu_buffer_lenght); + TEST_ASSERT_EQUAL(1, error); + + /* error: model address not in SRAM range */ + rdcu_data_adr = 0x0; + rdcu_model_adr = 0xFFFFFFFC; /* not in SRAM range */ + rdcu_new_model_adr = rdcu_model_adr; + rdcu_buffer_adr = 0x10; + rdcu_buffer_lenght = 4; + error = rdcu_cfg_buffers(&cfg, data_to_compress, data_samples, model_of_data, + rdcu_data_adr, rdcu_model_adr, rdcu_new_model_adr, + rdcu_buffer_adr, rdcu_buffer_lenght); + TEST_ASSERT_EQUAL(1, error); + + /* error: data and model rdcu buffers overlaps */ + rdcu_data_adr = 0x0; + rdcu_model_adr = 0x4; /* overlaps with data buffer */ + rdcu_new_model_adr = rdcu_model_adr; + rdcu_buffer_adr = 0x10; + rdcu_buffer_lenght = 4; + error = rdcu_cfg_buffers(&cfg, data_to_compress, data_samples, model_of_data, + rdcu_data_adr, rdcu_model_adr, rdcu_new_model_adr, + rdcu_buffer_adr, rdcu_buffer_lenght); + TEST_ASSERT_EQUAL(1, error); + + /* error: compressed buffer and model rdcu buffers overlaps */ + rdcu_data_adr = 0x0; + rdcu_model_adr = 0xC; /* overlaps with compressed data buffer */ + rdcu_new_model_adr = rdcu_model_adr; + rdcu_buffer_adr = 0x10; + rdcu_buffer_lenght = 4; + error = rdcu_cfg_buffers(&cfg, data_to_compress, data_samples, model_of_data, + rdcu_data_adr, rdcu_model_adr, rdcu_new_model_adr, + rdcu_buffer_adr, rdcu_buffer_lenght); + TEST_ASSERT_EQUAL(1, error); + + /** test with the updated_model buffer **/ + + /* error: updated_model address not 4 byte aligned */ + rdcu_data_adr = 0x0; + rdcu_model_adr = 0x8; + rdcu_new_model_adr = 0x11; /* not 4 byte aligned */ + rdcu_buffer_adr = 0x1C; + rdcu_buffer_lenght = 4; + error = rdcu_cfg_buffers(&cfg, data_to_compress, data_samples, model_of_data, + rdcu_data_adr, rdcu_model_adr, rdcu_new_model_adr, + rdcu_buffer_adr, rdcu_buffer_lenght); + TEST_ASSERT_EQUAL(1, error); + + /* error: updated_model address not in SRAM range */ + rdcu_data_adr = 0x0; + rdcu_model_adr = 0x8; + rdcu_new_model_adr = 0xFFFFFFFC; /* not in SRAM range */ + rdcu_buffer_adr = 0x18; + rdcu_buffer_lenght = 4; + error = rdcu_cfg_buffers(&cfg, data_to_compress, data_samples, model_of_data, + rdcu_data_adr, rdcu_model_adr, rdcu_new_model_adr, + rdcu_buffer_adr, rdcu_buffer_lenght); + TEST_ASSERT_EQUAL(1, error); + + /* error: data and updated model rdcu buffers overlaps */ + rdcu_data_adr = 0x8; + rdcu_model_adr = 0x0; + rdcu_new_model_adr = 0xC; /* overlaps with data buffer */ + rdcu_buffer_adr = 0x18; + rdcu_buffer_lenght = 4; + error = rdcu_cfg_buffers(&cfg, data_to_compress, data_samples, model_of_data, + rdcu_data_adr, rdcu_model_adr, rdcu_new_model_adr, + rdcu_buffer_adr, rdcu_buffer_lenght); + TEST_ASSERT_EQUAL(1, error); + + /* error: compressed buffer and updated_model rdcu buffers overlaps */ + rdcu_data_adr = 0x0; + rdcu_model_adr = 0x8; + rdcu_new_model_adr = 0x14; /* overlaps with compressed data buffer */ + rdcu_buffer_adr = 0x18; + rdcu_buffer_lenght = 4; + error = rdcu_cfg_buffers(&cfg, data_to_compress, data_samples, model_of_data, + rdcu_data_adr, rdcu_model_adr, rdcu_new_model_adr, + rdcu_buffer_adr, rdcu_buffer_lenght); + TEST_ASSERT_EQUAL(1, error); + + /* error: model and updated_model rdcu buffers overlaps */ + rdcu_data_adr = 0x0; + rdcu_model_adr = 0x8; + rdcu_new_model_adr = 0xC; /* overlaps with model buffer */ + rdcu_buffer_adr = 0x18; + rdcu_buffer_lenght = 4; + error = rdcu_cfg_buffers(&cfg, data_to_compress, data_samples, model_of_data, + rdcu_data_adr, rdcu_model_adr, rdcu_new_model_adr, + rdcu_buffer_adr, rdcu_buffer_lenght); + TEST_ASSERT_EQUAL(1, error); + +} + + +/** + * @test rdcu_cfg_imagette + */ + +void test_rdcu_cfg_imagette(void) +{ + int error; + struct cmp_cfg cfg = rdcu_cfg_create(DATA_TYPE_IMAGETTE, CMP_MODE_RAW, + 10, CMP_LOSSLESS); + uint32_t golomb_par, spillover_par, ap1_golomb_par, ap1_spillover_par, + ap2_golomb_par, ap2_spillover_par; + + golomb_par = MIN_IMA_GOLOMB_PAR; + spillover_par = MIN_IMA_SPILL; + ap1_golomb_par = MIN_IMA_GOLOMB_PAR; + ap1_spillover_par = MIN_IMA_SPILL; + ap2_golomb_par = MIN_IMA_GOLOMB_PAR; + ap2_spillover_par = MIN_IMA_SPILL; + + error = rdcu_cfg_imagette(&cfg, golomb_par, spillover_par, + ap1_golomb_par, ap1_spillover_par, + ap2_golomb_par, ap2_spillover_par); + TEST_ASSERT_FALSE(error); + TEST_ASSERT_EQUAL(golomb_par, cfg.golomb_par); + TEST_ASSERT_EQUAL(spillover_par, cfg.spill); + TEST_ASSERT_EQUAL(ap1_golomb_par, cfg.ap1_golomb_par); + TEST_ASSERT_EQUAL(ap1_spillover_par, cfg.ap1_spill); + TEST_ASSERT_EQUAL(ap2_golomb_par, cfg.ap2_golomb_par); + TEST_ASSERT_EQUAL(ap2_spillover_par, cfg.ap2_spill); + + + /* wrong golomb_par */ + golomb_par = MIN_IMA_GOLOMB_PAR - 1; + error = rdcu_cfg_imagette(&cfg, golomb_par, spillover_par, + ap1_golomb_par, ap1_spillover_par, + ap2_golomb_par, ap2_spillover_par); + TEST_ASSERT_TRUE(error); + + golomb_par = MAX_IMA_GOLOMB_PAR + 1; + error = rdcu_cfg_imagette(&cfg, golomb_par, spillover_par, + ap1_golomb_par, ap1_spillover_par, + ap2_golomb_par, ap2_spillover_par); + TEST_ASSERT_TRUE(error); + + /* this should work */ + golomb_par = MAX_IMA_GOLOMB_PAR; + error = rdcu_cfg_imagette(&cfg, golomb_par, spillover_par, + ap1_golomb_par, ap1_spillover_par, + ap2_golomb_par, ap2_spillover_par); + TEST_ASSERT_FALSE(error); + TEST_ASSERT_EQUAL(golomb_par, cfg.golomb_par); + TEST_ASSERT_EQUAL(spillover_par, cfg.spill); + TEST_ASSERT_EQUAL(ap1_golomb_par, cfg.ap1_golomb_par); + TEST_ASSERT_EQUAL(ap1_spillover_par, cfg.ap1_spill); + TEST_ASSERT_EQUAL(ap2_golomb_par, cfg.ap2_golomb_par); + TEST_ASSERT_EQUAL(ap2_spillover_par, cfg.ap2_spill); + + + /* wrong ap1_golomb_par */ + ap1_golomb_par = MIN_IMA_GOLOMB_PAR - 1; + error = rdcu_cfg_imagette(&cfg, golomb_par, spillover_par, + ap1_golomb_par, ap1_spillover_par, + ap2_golomb_par, ap2_spillover_par); + TEST_ASSERT_TRUE(error); + + ap1_golomb_par = MAX_IMA_GOLOMB_PAR + 1; + error = rdcu_cfg_imagette(&cfg, golomb_par, spillover_par, + ap1_golomb_par, ap1_spillover_par, + ap2_golomb_par, ap2_spillover_par); + TEST_ASSERT_TRUE(error); + + /* this should work */ + ap1_golomb_par = MAX_IMA_GOLOMB_PAR; + error = rdcu_cfg_imagette(&cfg, golomb_par, spillover_par, + ap1_golomb_par, ap1_spillover_par, + ap2_golomb_par, ap2_spillover_par); + TEST_ASSERT_FALSE(error); + TEST_ASSERT_EQUAL(golomb_par, cfg.golomb_par); + TEST_ASSERT_EQUAL(spillover_par, cfg.spill); + TEST_ASSERT_EQUAL(ap1_golomb_par, cfg.ap1_golomb_par); + TEST_ASSERT_EQUAL(ap1_spillover_par, cfg.ap1_spill); + TEST_ASSERT_EQUAL(ap2_golomb_par, cfg.ap2_golomb_par); + TEST_ASSERT_EQUAL(ap2_spillover_par, cfg.ap2_spill); + + + /* wrong ap2_golomb_par */ + cfg.cmp_mode = CMP_MODE_DIFF_ZERO; + ap2_golomb_par = MIN_IMA_GOLOMB_PAR - 1; + error = rdcu_cfg_imagette(&cfg, golomb_par, spillover_par, + ap1_golomb_par, ap1_spillover_par, + ap2_golomb_par, ap2_spillover_par); + TEST_ASSERT_TRUE(error); + + ap2_golomb_par = MAX_IMA_GOLOMB_PAR + 1; + error = rdcu_cfg_imagette(&cfg, golomb_par, spillover_par, + ap1_golomb_par, ap1_spillover_par, + ap2_golomb_par, ap2_spillover_par); + TEST_ASSERT_TRUE(error); + + /* this should work */ + ap2_golomb_par = MAX_IMA_GOLOMB_PAR; + error = rdcu_cfg_imagette(&cfg, golomb_par, spillover_par, + ap1_golomb_par, ap1_spillover_par, + ap2_golomb_par, ap2_spillover_par); + TEST_ASSERT_FALSE(error); + TEST_ASSERT_EQUAL(golomb_par, cfg.golomb_par); + TEST_ASSERT_EQUAL(spillover_par, cfg.spill); + TEST_ASSERT_EQUAL(ap1_golomb_par, cfg.ap1_golomb_par); + TEST_ASSERT_EQUAL(ap1_spillover_par, cfg.ap1_spill); + TEST_ASSERT_EQUAL(ap2_golomb_par, cfg.ap2_golomb_par); + TEST_ASSERT_EQUAL(ap2_spillover_par, cfg.ap2_spill); + + + /* wrong spillover_par */ + golomb_par = MIN_IMA_GOLOMB_PAR; + spillover_par = cmp_ima_max_spill(golomb_par)+1; + error = rdcu_cfg_imagette(&cfg, golomb_par, spillover_par, + ap1_golomb_par, ap1_spillover_par, + ap2_golomb_par, ap2_spillover_par); + golomb_par = MAX_IMA_GOLOMB_PAR; + spillover_par = cmp_ima_max_spill(golomb_par)+1; + error = rdcu_cfg_imagette(&cfg, golomb_par, spillover_par, + ap1_golomb_par, ap1_spillover_par, + ap2_golomb_par, ap2_spillover_par); + + golomb_par = MIN_IMA_GOLOMB_PAR; + spillover_par = MIN_IMA_SPILL - 1; + error = rdcu_cfg_imagette(&cfg, golomb_par, spillover_par, + ap1_golomb_par, ap1_spillover_par, + ap2_golomb_par, ap2_spillover_par); + TEST_ASSERT_EQUAL(1, error); + + /* this should work */ + golomb_par = MAX_IMA_GOLOMB_PAR; + spillover_par = cmp_ima_max_spill(golomb_par); + error = rdcu_cfg_imagette(&cfg, golomb_par, spillover_par, + ap1_golomb_par, ap1_spillover_par, + ap2_golomb_par, ap2_spillover_par); + TEST_ASSERT_FALSE(error); + TEST_ASSERT_EQUAL(golomb_par, cfg.golomb_par); + TEST_ASSERT_EQUAL(spillover_par, cfg.spill); + TEST_ASSERT_EQUAL(ap1_golomb_par, cfg.ap1_golomb_par); + TEST_ASSERT_EQUAL(ap1_spillover_par, cfg.ap1_spill); + TEST_ASSERT_EQUAL(ap2_golomb_par, cfg.ap2_golomb_par); + TEST_ASSERT_EQUAL(ap2_spillover_par, cfg.ap2_spill); + + + /* wrong ap1_spillover_par */ + ap1_golomb_par = MIN_IMA_GOLOMB_PAR; + ap1_spillover_par = cmp_ima_max_spill(golomb_par)+1; + error = rdcu_cfg_imagette(&cfg, golomb_par, spillover_par, + ap1_golomb_par, ap1_spillover_par, + ap2_golomb_par, ap2_spillover_par); + ap1_golomb_par = MAX_IMA_GOLOMB_PAR; + ap1_spillover_par = cmp_ima_max_spill(golomb_par)+1; + error = rdcu_cfg_imagette(&cfg, golomb_par, spillover_par, + ap1_golomb_par, ap1_spillover_par, + ap2_golomb_par, ap2_spillover_par); + + ap1_golomb_par = MIN_IMA_GOLOMB_PAR; + ap1_spillover_par = MIN_IMA_SPILL - 1; + error = rdcu_cfg_imagette(&cfg, golomb_par, spillover_par, + ap1_golomb_par, ap1_spillover_par, + ap2_golomb_par, ap2_spillover_par); + TEST_ASSERT_EQUAL(1, error); + + /* this should work */ + ap1_golomb_par = MAX_IMA_GOLOMB_PAR; + ap1_spillover_par = cmp_ima_max_spill(golomb_par); + error = rdcu_cfg_imagette(&cfg, golomb_par, spillover_par, + ap1_golomb_par, ap1_spillover_par, + ap2_golomb_par, ap2_spillover_par); + TEST_ASSERT_FALSE(error); + TEST_ASSERT_EQUAL(golomb_par, cfg.golomb_par); + TEST_ASSERT_EQUAL(spillover_par, cfg.spill); + TEST_ASSERT_EQUAL(ap1_golomb_par, cfg.ap1_golomb_par); + TEST_ASSERT_EQUAL(ap1_spillover_par, cfg.ap1_spill); + TEST_ASSERT_EQUAL(ap2_golomb_par, cfg.ap2_golomb_par); + TEST_ASSERT_EQUAL(ap2_spillover_par, cfg.ap2_spill); + + + /* wrong ap2_spillover_par */ + ap2_golomb_par = MIN_IMA_GOLOMB_PAR; + ap2_spillover_par = cmp_ima_max_spill(golomb_par)+1; + error = rdcu_cfg_imagette(&cfg, golomb_par, spillover_par, + ap1_golomb_par, ap1_spillover_par, + ap2_golomb_par, ap2_spillover_par); + ap2_golomb_par = MAX_IMA_GOLOMB_PAR; + ap2_spillover_par = cmp_ima_max_spill(golomb_par)+1; + error = rdcu_cfg_imagette(&cfg, golomb_par, spillover_par, + ap1_golomb_par, ap1_spillover_par, + ap2_golomb_par, ap2_spillover_par); + + ap2_golomb_par = MIN_IMA_GOLOMB_PAR; + ap2_spillover_par = MIN_IMA_SPILL - 1; + error = rdcu_cfg_imagette(&cfg, golomb_par, spillover_par, + ap1_golomb_par, ap1_spillover_par, + ap2_golomb_par, ap2_spillover_par); + TEST_ASSERT_EQUAL(1, error); + + /* this should work */ + ap2_golomb_par = MAX_IMA_GOLOMB_PAR; + ap2_spillover_par = cmp_ima_max_spill(golomb_par); + error = rdcu_cfg_imagette(&cfg, golomb_par, spillover_par, + ap1_golomb_par, ap1_spillover_par, + ap2_golomb_par, ap2_spillover_par); + TEST_ASSERT_FALSE(error); + TEST_ASSERT_EQUAL(golomb_par, cfg.golomb_par); + TEST_ASSERT_EQUAL(spillover_par, cfg.spill); + TEST_ASSERT_EQUAL(ap1_golomb_par, cfg.ap1_golomb_par); + TEST_ASSERT_EQUAL(ap1_spillover_par, cfg.ap1_spill); + TEST_ASSERT_EQUAL(ap2_golomb_par, cfg.ap2_golomb_par); + TEST_ASSERT_EQUAL(ap2_spillover_par, cfg.ap2_spill); /* cfg = NULL test */ error = rdcu_cfg_imagette(NULL, golomb_par, spillover_par, + ap1_golomb_par, ap1_spillover_par, ap2_golomb_par, ap2_spillover_par); + TEST_ASSERT_EQUAL(-1, error); +} + + +/** + * @test rdcu_cmp_cfg_is_invalid + */ + +void test_rdcu_cmp_cfg_is_invalid(void) +{ + int error; + struct cmp_cfg cfg; + uint16_t data[1] = {1}; + uint16_t model[1] = {2}; + + /* diff test */ + cfg = rdcu_cfg_create(DATA_TYPE_IMAGETTE, CMP_DEF_IMA_DIFF_CMP_MODE, + CMP_DEF_IMA_DIFF_MODEL_VALUE, CMP_DEF_IMA_DIFF_LOSSY_PAR); + error = rdcu_cfg_buffers(&cfg, data, 1, NULL, CMP_DEF_IMA_DIFF_RDCU_DATA_ADR, + CMP_DEF_IMA_DIFF_RDCU_MODEL_ADR, CMP_DEF_IMA_DIFF_RDCU_UP_MODEL_ADR, + CMP_DEF_IMA_DIFF_RDCU_BUFFER_ADR, 1); + TEST_ASSERT_FALSE(error); + error = rdcu_cfg_imagette(&cfg, + CMP_DEF_IMA_DIFF_GOLOMB_PAR, CMP_DEF_IMA_DIFF_SPILL_PAR, + CMP_DEF_IMA_DIFF_AP1_GOLOMB_PAR, CMP_DEF_IMA_DIFF_AP1_SPILL_PAR, + CMP_DEF_IMA_DIFF_AP2_GOLOMB_PAR, CMP_DEF_IMA_DIFF_AP2_SPILL_PAR); + TEST_ASSERT_FALSE(error); + error = rdcu_cmp_cfg_is_invalid(&cfg); + TEST_ASSERT_FALSE(error); + + /* model test */ + cfg = rdcu_cfg_create(DATA_TYPE_IMAGETTE, CMP_DEF_IMA_MODEL_CMP_MODE, + CMP_DEF_IMA_MODEL_MODEL_VALUE, CMP_DEF_IMA_MODEL_LOSSY_PAR); + error = rdcu_cfg_buffers(&cfg, data, 1, model, CMP_DEF_IMA_MODEL_RDCU_DATA_ADR, + CMP_DEF_IMA_MODEL_RDCU_MODEL_ADR, CMP_DEF_IMA_MODEL_RDCU_UP_MODEL_ADR, + CMP_DEF_IMA_MODEL_RDCU_BUFFER_ADR, 1); + TEST_ASSERT_FALSE(error); + error = rdcu_cfg_imagette(&cfg, + CMP_DEF_IMA_MODEL_GOLOMB_PAR, CMP_DEF_IMA_MODEL_SPILL_PAR, + CMP_DEF_IMA_MODEL_AP1_GOLOMB_PAR, CMP_DEF_IMA_MODEL_AP1_SPILL_PAR, + CMP_DEF_IMA_MODEL_AP2_GOLOMB_PAR, CMP_DEF_IMA_MODEL_AP2_SPILL_PAR); + TEST_ASSERT_FALSE(error); + error = rdcu_cmp_cfg_is_invalid(&cfg); + TEST_ASSERT_FALSE(error); + + /* test warnings */ + cfg = rdcu_cfg_create(DATA_TYPE_IMAGETTE, CMP_DEF_IMA_MODEL_CMP_MODE, + CMP_DEF_IMA_MODEL_MODEL_VALUE, CMP_DEF_IMA_MODEL_LOSSY_PAR); + error = rdcu_cfg_buffers(&cfg, NULL, 0, NULL, CMP_DEF_IMA_MODEL_RDCU_DATA_ADR, + CMP_DEF_IMA_MODEL_RDCU_MODEL_ADR, CMP_DEF_IMA_MODEL_RDCU_UP_MODEL_ADR, + CMP_DEF_IMA_MODEL_RDCU_BUFFER_ADR, 1); + error = rdcu_cfg_imagette(&cfg, + CMP_DEF_IMA_MODEL_GOLOMB_PAR, CMP_DEF_IMA_MODEL_SPILL_PAR, + CMP_DEF_IMA_MODEL_AP1_GOLOMB_PAR, CMP_DEF_IMA_MODEL_AP1_SPILL_PAR, + CMP_DEF_IMA_MODEL_AP2_GOLOMB_PAR, CMP_DEF_IMA_MODEL_AP2_SPILL_PAR); + cfg.icu_new_model_buf = data; + cfg.icu_output_buf = (void *)model; + error = rdcu_cmp_cfg_is_invalid(&cfg); + TEST_ASSERT_FALSE(error); + + /* error: cfg is NULL */ + error = rdcu_cmp_cfg_is_invalid(NULL); + TEST_ASSERT_TRUE(error); + + /* error: buffer length = 0 */ + cfg = rdcu_cfg_create(DATA_TYPE_IMAGETTE, CMP_DEF_IMA_MODEL_CMP_MODE, + CMP_DEF_IMA_MODEL_MODEL_VALUE, CMP_DEF_IMA_MODEL_LOSSY_PAR); + error = rdcu_cfg_buffers(&cfg, data, 1, model, CMP_DEF_IMA_MODEL_RDCU_DATA_ADR, + CMP_DEF_IMA_MODEL_RDCU_MODEL_ADR, CMP_DEF_IMA_MODEL_RDCU_UP_MODEL_ADR, + CMP_DEF_IMA_MODEL_RDCU_BUFFER_ADR, 0); + error = rdcu_cfg_imagette(&cfg, + CMP_DEF_IMA_MODEL_GOLOMB_PAR, CMP_DEF_IMA_MODEL_SPILL_PAR, + CMP_DEF_IMA_MODEL_AP1_GOLOMB_PAR, CMP_DEF_IMA_MODEL_AP1_SPILL_PAR, + CMP_DEF_IMA_MODEL_AP2_GOLOMB_PAR, CMP_DEF_IMA_MODEL_AP2_SPILL_PAR); + error = rdcu_cmp_cfg_is_invalid(&cfg); + TEST_ASSERT_TRUE(error); + + /* error: wrong gen par */ + cfg = rdcu_cfg_create(DATA_TYPE_IMAGETTE, CMP_DEF_IMA_DIFF_CMP_MODE, + MAX_MODEL_VALUE+1, CMP_DEF_IMA_DIFF_LOSSY_PAR); + cfg.data_type = DATA_TYPE_IMAGETTE; + error = rdcu_cfg_buffers(&cfg, data, 1, NULL, CMP_DEF_IMA_DIFF_RDCU_DATA_ADR, + CMP_DEF_IMA_DIFF_RDCU_MODEL_ADR, CMP_DEF_IMA_DIFF_RDCU_UP_MODEL_ADR, + CMP_DEF_IMA_DIFF_RDCU_BUFFER_ADR, 1); + error = rdcu_cfg_imagette(&cfg, + CMP_DEF_IMA_DIFF_GOLOMB_PAR, CMP_DEF_IMA_DIFF_SPILL_PAR, + CMP_DEF_IMA_DIFF_AP1_GOLOMB_PAR, CMP_DEF_IMA_DIFF_AP1_SPILL_PAR, + CMP_DEF_IMA_DIFF_AP2_GOLOMB_PAR, CMP_DEF_IMA_DIFF_AP2_SPILL_PAR); + error = rdcu_cmp_cfg_is_invalid(&cfg); + TEST_ASSERT_TRUE(error); + + /* error: wrong buffers config */ + cfg = rdcu_cfg_create(DATA_TYPE_IMAGETTE, CMP_DEF_IMA_DIFF_CMP_MODE, + CMP_DEF_IMA_DIFF_MODEL_VALUE, CMP_DEF_IMA_DIFF_LOSSY_PAR); + error = rdcu_cfg_buffers(&cfg, data, 1, NULL, RDCU_SRAM_END+4, + CMP_DEF_IMA_DIFF_RDCU_MODEL_ADR, CMP_DEF_IMA_DIFF_RDCU_UP_MODEL_ADR, + CMP_DEF_IMA_DIFF_RDCU_BUFFER_ADR, 1); + error = rdcu_cfg_imagette(&cfg, + CMP_DEF_IMA_DIFF_GOLOMB_PAR, CMP_DEF_IMA_DIFF_SPILL_PAR, + CMP_DEF_IMA_DIFF_AP1_GOLOMB_PAR, CMP_DEF_IMA_DIFF_AP1_SPILL_PAR, + CMP_DEF_IMA_DIFF_AP2_GOLOMB_PAR, CMP_DEF_IMA_DIFF_AP2_SPILL_PAR); + error = rdcu_cmp_cfg_is_invalid(&cfg); + TEST_ASSERT_TRUE(error); + + /* error: wrong compression parameter test */ + cfg = rdcu_cfg_create(DATA_TYPE_IMAGETTE, CMP_DEF_IMA_DIFF_CMP_MODE, + CMP_DEF_IMA_DIFF_MODEL_VALUE, CMP_DEF_IMA_DIFF_LOSSY_PAR); + error = rdcu_cfg_buffers(&cfg, data, 1, NULL, CMP_DEF_IMA_DIFF_RDCU_DATA_ADR, + CMP_DEF_IMA_DIFF_RDCU_MODEL_ADR, CMP_DEF_IMA_DIFF_RDCU_UP_MODEL_ADR, + CMP_DEF_IMA_DIFF_RDCU_BUFFER_ADR, 1); + error = rdcu_cfg_imagette(&cfg, + MAX_IMA_GOLOMB_PAR+1, CMP_DEF_IMA_DIFF_SPILL_PAR, + CMP_DEF_IMA_DIFF_AP1_GOLOMB_PAR, CMP_DEF_IMA_DIFF_AP1_SPILL_PAR, + CMP_DEF_IMA_DIFF_AP2_GOLOMB_PAR, CMP_DEF_IMA_DIFF_AP2_SPILL_PAR); + error = rdcu_cmp_cfg_is_invalid(&cfg); + TEST_ASSERT_TRUE(error); +} diff --git a/test/meson.build b/test/meson.build index 36fee6ce08454a4e3db2b9cf0092bbdb9274a460..ff30bdfab4896c831abe21b220acb66b32308409 100644 --- a/test/meson.build +++ b/test/meson.build @@ -39,3 +39,4 @@ unity_dep = dependency('unity', fallback : ['unity', 'unity_dep']) subdir('cmp_icu') subdir('cmp_data_types') subdir('cmp_entity') +subdir('cmp_rdcu')