diff --git a/lib/common/cmp_entity.c b/lib/common/cmp_entity.c index 46df7e957266a35fa69606ac94a8969527455ec0..73f91679fff990a72c93aa0b34da6c586c8ffac3 100644 --- a/lib/common/cmp_entity.c +++ b/lib/common/cmp_entity.c @@ -1863,23 +1863,7 @@ int cmp_ent_write_cmp_pars(struct cmp_entity *ent, const struct cmp_cfg *cfg, if (cmp_ent_set_ima_golomb_par(ent, cfg->golomb_par)) return -1; break; - case DATA_TYPE_OFFSET: - case DATA_TYPE_F_CAM_OFFSET: - case DATA_TYPE_BACKGROUND: - case DATA_TYPE_F_CAM_BACKGROUND: - case DATA_TYPE_SMEARING: - case DATA_TYPE_S_FX: - case DATA_TYPE_S_FX_EFX: - case DATA_TYPE_S_FX_NCOB: - case DATA_TYPE_S_FX_EFX_NCOB_ECOB: - case DATA_TYPE_L_FX: - case DATA_TYPE_L_FX_EFX: - case DATA_TYPE_L_FX_NCOB: - case DATA_TYPE_L_FX_EFX_NCOB_ECOB: - case DATA_TYPE_F_FX: - case DATA_TYPE_F_FX_EFX: - case DATA_TYPE_F_FX_NCOB: - case DATA_TYPE_F_FX_EFX_NCOB_ECOB: + case DATA_TYPE_CHUNK: if (cmp_ent_set_non_ima_cmp_par1(ent, cfg->cmp_par_1)) return -1; if (cmp_ent_set_non_ima_spill1(ent, cfg->spill_par_1)) @@ -1911,6 +1895,24 @@ int cmp_ent_write_cmp_pars(struct cmp_entity *ent, const struct cmp_cfg *cfg, return -1; break; + /* the compression entity data type field only supports imagette or chunk data types*/ + case DATA_TYPE_OFFSET: + case DATA_TYPE_F_CAM_OFFSET: + case DATA_TYPE_BACKGROUND: + case DATA_TYPE_F_CAM_BACKGROUND: + case DATA_TYPE_SMEARING: + case DATA_TYPE_S_FX: + case DATA_TYPE_S_FX_EFX: + case DATA_TYPE_S_FX_NCOB: + case DATA_TYPE_S_FX_EFX_NCOB_ECOB: + case DATA_TYPE_L_FX: + case DATA_TYPE_L_FX_EFX: + case DATA_TYPE_L_FX_NCOB: + case DATA_TYPE_L_FX_EFX_NCOB_ECOB: + case DATA_TYPE_F_FX: + case DATA_TYPE_F_FX_EFX: + case DATA_TYPE_F_FX_NCOB: + case DATA_TYPE_F_FX_EFX_NCOB_ECOB: case DATA_TYPE_UNKNOWN: default: return -1; diff --git a/lib/decompress/decmp.c b/lib/decompress/decmp.c index 3c26fbd4ad400e7ebf4641edf3985e5eaa3979f3..e21235043179574e2846210806fee839ba7f486e 100644 --- a/lib/decompress/decmp.c +++ b/lib/decompress/decmp.c @@ -1990,8 +1990,9 @@ static int cmp_ent_read_header(struct cmp_entity *ent, struct cmp_cfg *cfg) return -1; cfg->data_type = cmp_ent_get_data_type(ent); - if (cmp_data_type_is_invalid(cfg->data_type)) { - debug_print("Error: Compression data type not supported."); + /* the compression entity data type field only supports imagette or chunk data types */ + if (cfg->data_type != DATA_TYPE_CHUNK && !rdcu_supported_data_type_is_used(cfg->data_type)) { + debug_print("Error: Compression entity data type not supported."); return -1; } diff --git a/test/decmp/test_decmp.c b/test/decmp/test_decmp.c index 8e9fb8720c4d666388e219fe08932d618951d5c2..a1627cb52a17b78e1917b468744c23dff2a55e66 100644 --- a/test/decmp/test_decmp.c +++ b/test/decmp/test_decmp.c @@ -24,12 +24,20 @@ #include <compiler.h> #include <cmp_entity.h> +#include <cmp_data_types.h> #include "../../lib/icu_compress/cmp_icu.c" /* .c file included to test static functions */ #include "../../lib/decompress/decmp.c" /* .c file included to test static functions */ #define MAX_VALID_CW_LEM 32 +/** + * @test bit_init_decoder + * @test bit_read_bits32 + * @test bit_read_bits + * @test bit_refill + */ + void test_bitstream(void) { uint8_t i, data[12]; @@ -68,7 +76,7 @@ void test_bitstream(void) TEST_ASSERT_EQUAL_INT(32, dec.bits_consumed); status = bit_refill(&dec); TEST_ASSERT_EQUAL_INT(BIT_END_OF_BUFFER, status); - TEST_ASSERT_EQUAL_INT(32,dec.bits_consumed); + TEST_ASSERT_EQUAL_INT(32, dec.bits_consumed); TEST_ASSERT_FALSE(bit_end_of_stream(&dec)); read_bits = bit_read_bits32(&dec, 32); @@ -95,8 +103,6 @@ void test_bitstream(void) bit_read_bits(&dec, 57); TEST_ASSERT_EQUAL_INT(BIT_OVERFLOW, status); - - { uint8_t k, j; uint8_t buf[9]; @@ -197,8 +203,8 @@ void test_unary_decoder(void) TEST_ASSERT_EQUAL_INT(32, leading_ones); TEST_ASSERT_EQUAL_INT(BIT_OVERFLOW, bit_refill(&dec)); - { - uint64_t value64 = ~0ULL; + { uint64_t value64 = ~0ULL; + ret = bit_init_decoder(&dec, &value64, sizeof(value64)); TEST_ASSERT_EQUAL_size_t(sizeof(value64), ret); leading_ones = unary_decoder(&dec, unused_1, unused_2); @@ -790,8 +796,7 @@ void test_decode_multi(void) TEST_ASSERT_EQUAL_INT(-1, err); - /* 0xFA -> 16 = spill(8)+8 -> unencoded_len = 17 bits -> larger than - * 16 bit max_used_bits*/ + /* 0xFA -> 16 = spill(8)+8 -> unencoded_len = 17 bits -> larger than 16 bit max_used_bits */ cmp_data[0] = cpu_to_be32(0xFA000000); cmp_data[1] = cpu_to_be32(0x00000000); bit_init_decoder(&dec, cmp_data, sizeof(cmp_data)); @@ -888,6 +893,7 @@ void test_multi_refill_needed(void) TEST_ASSERT_EQUAL_INT(CORRUPTION_DETECTED, err); } + /** * @test re_map_to_pos */ @@ -920,6 +926,7 @@ void test_re_map_to_pos(void) for (j = -16; j < 15; j++) { uint32_t map_val = map_to_pos((uint32_t)j, 16) & 0x3F; + result = re_map_to_pos(map_val); TEST_ASSERT_EQUAL_INT32(j, result); } @@ -980,7 +987,8 @@ size_t icu_compress_data_entity(struct cmp_entity *ent, const struct cmp_cfg *cf return 0; /* XXX overwrite the size of the compression entity with the size of the actual - * size of the compressed data; not all allocated memory is normally used */ + * size of the compressed data; not all allocated memory is normally used + */ s = cmp_ent_create(ent, cfg->data_type, cfg->cmp_mode == CMP_MODE_RAW, cmp_bit_to_byte((unsigned int)cmp_size_bits)); @@ -1065,8 +1073,7 @@ void test_decompress_imagette_model(void) bit_init_decoder(&dec, cfg.icu_output_buf, cfg.buffer_length); - err = decompress_imagette(&cfg, &dec); - /* TEST_ASSERT_EQUAL_INT(15, stream_pos); */ + err = decompress_imagette(&cfg, &dec, RDCU_DECOMPRESSION); TEST_ASSERT_FALSE(err); TEST_ASSERT_EQUAL_HEX(1, data[0]); TEST_ASSERT_EQUAL_HEX(2, data[1]); @@ -1082,189 +1089,6 @@ void test_decompress_imagette_model(void) } -#define DATA_SAMPLES 5 -void test_cmp_decmp_s_fx_diff(void) -{ - size_t s; - int err, decmp_size; - - struct cmp_entity *ent; - const uint32_t MAX_VALUE = ~(~0U << MAX_USED_BITS_V1.s_fx); - struct s_fx data_entry[DATA_SAMPLES]; - uint8_t data_to_compress[COLLECTION_HDR_SIZE + sizeof(data_entry)]; - struct s_fx *decompressed_data = NULL; - uint32_t compressed_data_len_samples = DATA_SAMPLES; - struct cmp_cfg cfg; - - data_entry[0].exp_flags = 0; - data_entry[0].fx = 0; - data_entry[1].exp_flags = 1; - data_entry[1].fx = 23; - data_entry[2].exp_flags = 2; - data_entry[2].fx = 42; - data_entry[3].exp_flags = 3; - data_entry[3].fx = MAX_VALUE; - data_entry[4].exp_flags = 3; - data_entry[4].fx = MAX_VALUE>>1; - - for (s = 0; s < COLLECTION_HDR_SIZE; s++) - data_to_compress[s] = (uint8_t)s; - memcpy(&data_to_compress[COLLECTION_HDR_SIZE], data_entry, sizeof(data_entry)); - - cfg = cmp_cfg_icu_create(DATA_TYPE_S_FX, CMP_MODE_DIFF_MULTI, - CMP_PAR_UNUSED, CMP_LOSSLESS); - TEST_ASSERT(cfg.data_type != DATA_TYPE_UNKNOWN); - - s = cmp_cfg_icu_buffers(&cfg, data_to_compress, DATA_SAMPLES, NULL, NULL, - NULL, compressed_data_len_samples); - TEST_ASSERT_TRUE(s); - - err = cmp_cfg_fx_cob(&cfg, 2, 6, 4, 14, CMP_PAR_UNUSED, CMP_PAR_UNUSED, - CMP_PAR_UNUSED, CMP_PAR_UNUSED, CMP_PAR_UNUSED, - CMP_PAR_UNUSED, CMP_PAR_UNUSED, CMP_PAR_UNUSED); - TEST_ASSERT_FALSE(err); - - s = icu_compress_data_entity(NULL, &cfg); - TEST_ASSERT_TRUE(s); - ent = malloc(s); TEST_ASSERT_TRUE(ent); - s = icu_compress_data_entity(ent, &cfg); - TEST_ASSERT_TRUE(s); - - /* now decompress the data */ - decmp_size = decompress_cmp_entiy(ent, NULL, NULL, decompressed_data); - TEST_ASSERT_EQUAL_INT(cmp_cal_size_of_data(cfg.samples, cfg.data_type), decmp_size); - decompressed_data = malloc((size_t)decmp_size); TEST_ASSERT_TRUE(decompressed_data); - decmp_size = decompress_cmp_entiy(ent, NULL, NULL, decompressed_data); - TEST_ASSERT_EQUAL_INT(cmp_cal_size_of_data(cfg.samples, cfg.data_type), decmp_size); - - TEST_ASSERT_EQUAL_HEX8_ARRAY(data_to_compress, decompressed_data, decmp_size); - /* TEST_ASSERT_FALSE(memcmp(data_to_compress, decompressed_data, (size_t)decmp_size)); */ - /* for (i = 0; i < samples; ++i) { */ - /* printf("%u == %u (round: %u)\n", data[i], decompressed_data[i], round); */ - /* uint32_t mask = ~0U << round; */ - /* if ((data[i]&mask) != (decompressed_data[i]&mask)) */ - /* TEST_ASSERT(0); */ - /* if (model_mode_is_used(cmp_mode)) */ - /* if (up_model[i] != de_up_model[i]) */ - /* TEST_ASSERT(0); */ - /* } */ - free(ent); - free(decompressed_data); -} -#undef DATA_SAMPLES - - -void test_s_fx_diff(void) -{ - size_t i; - int s; - uint8_t cmp_entity[88] = { - 0x80, 0x00, 0x00, 0x09, 0x00, 0x00, 0x58, 0x00, 0x00, 0x20, 0x04, 0xEE, 0x21, 0xBD, 0xB0, 0x1C, 0x04, 0xEE, 0x21, 0xBD, 0xB0, 0x41, 0x00, 0x08, 0x02, 0x08, 0xD0, 0x10, 0x00, 0x01, 0x00, 0x00, - 0x00, 0x00, 0x0A, 0x00, 0x01, 0x00, 0x00, 0x0A, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0xAE, 0xDE, 0x00, 0x00, 0x00, 0x73, 0xFF, 0xFF, 0xF8, 0x00, 0x00, 0x00, - }; - - uint8_t result_data[32] = {0}; - struct collection_hdr *hdr = (struct collection_hdr *)result_data; - struct s_fx *data = (struct s_fx *)hdr->entry; - uint8_t *decompressed_data; - - /* put some dummy data in the header*/ - for (i = 0; i < sizeof(*hdr); i++) - result_data[i] = (uint8_t)i; - data[0].exp_flags = 0; - data[0].fx = 0; - data[1].exp_flags = 1; - data[1].fx = 0xFFFFFF; - data[2].exp_flags = 3; - data[2].fx = 0x7FFFFF; - data[3].exp_flags = 0; - data[3].fx = 0; - - s = decompress_cmp_entiy((void *)cmp_entity, NULL, NULL, NULL); - TEST_ASSERT_EQUAL_INT(sizeof(result_data), s); - decompressed_data = malloc((size_t)s); - TEST_ASSERT_TRUE(decompressed_data); - s = decompress_cmp_entiy((void *)cmp_entity, NULL, NULL, decompressed_data); - TEST_ASSERT_EQUAL_INT(sizeof(result_data), s); - for (i = 0; i < (size_t)s; ++i) { - TEST_ASSERT_EQUAL(result_data[i], decompressed_data[i]); - } - free(decompressed_data); -} - - -void test_s_fx_model(void) -{ - size_t i; - int s; - uint8_t compressed_data_buf[92] = { - 0x80, 0x00, 0x00, 0x09, 0x00, 0x00, 0x5C, 0x00, 0x00, 0x20, 0x04, 0xF0, 0xC2, 0xD3, 0x47, 0xE4, 0x04, 0xF0, 0xC2, 0xD3, 0x48, 0x16, 0x00, 0x08, 0x03, 0x08, 0xD0, 0x10, 0x01, 0x01, 0x00, 0x00, - 0x00, 0x00, 0x0A, 0x00, 0x01, 0x00, 0x00, 0x0A, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x3B, 0xFF, 0xFF, 0xEF, 0xFF, 0xFF, 0x5B, 0xFF, 0xFF, 0xEF, 0xFF, 0xFF, 0x5D, 0x80, 0x00, 0x00, - }; - struct cmp_entity *cmp_entity = (struct cmp_entity *)compressed_data_buf; - - uint8_t model_buf[32]; - uint8_t decompressed_data[32]; - uint8_t up_model_buf[32]; - uint8_t exp_data_buf[32] = {0}; /* expected uncompressed data */ - uint8_t exp_up_model_buf[32] = {0}; - - struct collection_hdr *model_collection = (struct collection_hdr *)model_buf; - struct s_fx *model_data = (struct s_fx *)model_collection->entry; - - struct collection_hdr *exp_data_collection; - struct s_fx *exp_data; - struct collection_hdr *exp_up_model_collection; - struct s_fx *exp_updated_model_data; - - memset(model_collection, 0xFF, sizeof(*model_collection)); - model_data[0].exp_flags = 0; - model_data[0].fx = 0; - model_data[1].exp_flags = 3; - model_data[1].fx = 0x7FFFFF; - model_data[2].exp_flags = 0; - model_data[2].fx = 0xFFFFFF; - model_data[3].exp_flags = 3; - model_data[3].fx = 0xFFFFFF; - - exp_data_collection = (struct collection_hdr *)exp_data_buf; - exp_data = (struct s_fx *)exp_data_collection->entry; - /* put some dummy data in the header */ - for (i = 0; i < sizeof(*exp_data_collection); i++) - exp_data_buf[i] = (uint8_t)i; - exp_data[0].exp_flags = 0; - exp_data[0].fx = 0; - exp_data[1].exp_flags = 1; - exp_data[1].fx = 0xFFFFFF; - exp_data[2].exp_flags = 3; - exp_data[2].fx = 0x7FFFFF; - exp_data[3].exp_flags = 0; - exp_data[3].fx = 0; - - exp_up_model_collection = (struct collection_hdr *)exp_up_model_buf; - exp_updated_model_data = (struct s_fx *)exp_up_model_collection->entry; - /* put some dummy data in the header*/ - for (i = 0; i < sizeof(*exp_up_model_collection); i++) - exp_up_model_buf[i] = (uint8_t)i; - exp_updated_model_data[0].exp_flags = 0; - exp_updated_model_data[0].fx = 0; - exp_updated_model_data[1].exp_flags = 2; - exp_updated_model_data[1].fx = 0xBFFFFF; - exp_updated_model_data[2].exp_flags = 1; - exp_updated_model_data[2].fx = 0xBFFFFF; - exp_updated_model_data[3].exp_flags = 1; - exp_updated_model_data[3].fx = 0x7FFFFF; - - s = decompress_cmp_entiy(cmp_entity, model_buf, up_model_buf, decompressed_data); - TEST_ASSERT_EQUAL_INT(sizeof(exp_data_buf), s); - - TEST_ASSERT_FALSE(memcmp(exp_data_buf, decompressed_data, sizeof(exp_data_buf))); - TEST_ASSERT_FALSE(memcmp(exp_up_model_buf, up_model_buf, sizeof(exp_up_model_buf))); -} - - /** * @test cmp_ent_write_cmp_pars * @test cmp_ent_read_header @@ -1421,130 +1245,6 @@ void test_cmp_ent_write_cmp_pars(void) memset(&cfg, 0, sizeof(struct cmp_cfg)); memset(&cfg_read, 0, sizeof(struct cmp_cfg)); - /** flux cob data type test **/ - /* create configuration */ - cfg.data_type = DATA_TYPE_S_FX_EFX_NCOB_ECOB; - cfg.cmp_mode = CMP_MODE_MODEL_ZERO; - cfg.model_value = 11; - cfg.round = 2; - cfg.samples = 9; - cfg.spill_exp_flags = 1; - cfg.spill_fx = 2; - cfg.spill_ncob = 3; - cfg.spill_efx = 4; - cfg.spill_ecob = 5; - cfg.spill_fx_cob_variance = 6; - cfg.cmp_par_exp_flags = 7; - cfg.cmp_par_fx = 8; - cfg.cmp_par_ncob = 9; - cfg.cmp_par_efx = 10; - cfg.cmp_par_ecob = 11; - cfg.cmp_par_fx_cob_variance = 12; - cfg.max_used_bits = cmp_max_used_bits_list_get(42); - - /* create a compression entity */ - size = cmp_ent_create(NULL, cfg.data_type, cfg.cmp_mode == CMP_MODE_RAW, 12); - TEST_ASSERT_NOT_EQUAL_INT(0, size); - ent = malloc(size); TEST_ASSERT_NOT_NULL(ent); - size = cmp_ent_create(ent, cfg.data_type, cfg.cmp_mode == CMP_MODE_RAW, 12); - TEST_ASSERT_NOT_EQUAL_INT(0, size); - - error = cmp_ent_write_cmp_pars(ent, &cfg, cmp_size_bits); - TEST_ASSERT_FALSE(error); - - TEST_ASSERT_EQUAL_INT(cfg.data_type, cmp_ent_get_data_type(ent)); - TEST_ASSERT_EQUAL_INT(0, cmp_ent_get_data_type_raw_bit(ent)); - TEST_ASSERT_EQUAL_INT(12, cmp_ent_get_cmp_data_size(ent)); - - TEST_ASSERT_EQUAL_INT(cmp_cal_size_of_data(cfg.samples, cfg.data_type), cmp_ent_get_original_size(ent)); - TEST_ASSERT_EQUAL_INT(cfg.cmp_mode, cmp_ent_get_cmp_mode(ent)); - TEST_ASSERT_EQUAL_INT(cfg.model_value, cmp_ent_get_model_value(ent)); - TEST_ASSERT_EQUAL_INT(max_used_bits.version, cmp_ent_get_max_used_bits_version(ent)); - TEST_ASSERT_EQUAL_INT(cfg.round, cmp_ent_get_lossy_cmp_par(ent)); - - - TEST_ASSERT_EQUAL_INT(cfg.spill_exp_flags, cmp_ent_get_non_ima_spill1(ent)); - TEST_ASSERT_EQUAL_INT(cfg.spill_fx, cmp_ent_get_non_ima_spill2(ent)); - TEST_ASSERT_EQUAL_INT(cfg.spill_ncob, cmp_ent_get_non_ima_spill3(ent)); - TEST_ASSERT_EQUAL_INT(cfg.spill_efx, cmp_ent_get_non_ima_spill4(ent)); - TEST_ASSERT_EQUAL_INT(cfg.spill_ecob, cmp_ent_get_non_ima_spill5(ent)); - TEST_ASSERT_EQUAL_INT(cfg.spill_fx_cob_variance, cmp_ent_get_non_ima_spill6(ent)); - TEST_ASSERT_EQUAL_INT(cfg.cmp_par_exp_flags, cmp_ent_get_non_ima_cmp_par1(ent)); - TEST_ASSERT_EQUAL_INT(cfg.cmp_par_fx, cmp_ent_get_non_ima_cmp_par2(ent)); - TEST_ASSERT_EQUAL_INT(cfg.cmp_par_ncob, cmp_ent_get_non_ima_cmp_par3(ent)); - TEST_ASSERT_EQUAL_INT(cfg.cmp_par_efx, cmp_ent_get_non_ima_cmp_par4(ent)); - TEST_ASSERT_EQUAL_INT(cfg.cmp_par_ecob, cmp_ent_get_non_ima_cmp_par5(ent)); - TEST_ASSERT_EQUAL_INT(cfg.cmp_par_fx_cob_variance, cmp_ent_get_non_ima_cmp_par6(ent)); - - error = cmp_ent_read_header(ent, &cfg_read); - TEST_ASSERT_FALSE(error); - cfg.icu_output_buf = cmp_ent_get_data_buf(ent); /* quick fix that both cfg are equal */ - cfg.buffer_length = 12; /* quick fix that both cfg are equal */ - TEST_ASSERT_EQUAL_MEMORY(&cfg, &cfg_read, sizeof(struct cmp_cfg)); - - free(ent); - memset(&cfg, 0, sizeof(struct cmp_cfg)); - memset(&cfg_read, 0, sizeof(struct cmp_cfg)); - - /** auxiliary data data_type test **/ - /* create configuration */ - cfg.data_type = DATA_TYPE_SMEARING; - cfg.cmp_mode = CMP_MODE_MODEL_ZERO; - cfg.model_value = 11; - cfg.round = 2; - cfg.samples = 9; - cfg.spill_smearing_mean = 1; - cfg.spill_smearing_variance = 2; - cfg.spill_smearing_pixels_error = 3; - cfg.cmp_par_smearing_mean = 7; - cfg.cmp_par_smearing_variance = 8; - cfg.cmp_par_smearing_pixels_error = 9; - cfg.max_used_bits = cmp_max_used_bits_list_get(42); - - /* create a compression entity */ - size = cmp_ent_create(NULL, cfg.data_type, cfg.cmp_mode == CMP_MODE_RAW, 12); - TEST_ASSERT_NOT_EQUAL_INT(0, size); - ent = malloc(size); TEST_ASSERT_NOT_NULL(ent); - size = cmp_ent_create(ent, cfg.data_type, cfg.cmp_mode == CMP_MODE_RAW, 12); - TEST_ASSERT_NOT_EQUAL_INT(0, size); - - error = cmp_ent_write_cmp_pars(ent, &cfg, cmp_size_bits); - TEST_ASSERT_FALSE(error); - - TEST_ASSERT_EQUAL_INT(cfg.data_type, cmp_ent_get_data_type(ent)); - TEST_ASSERT_EQUAL_INT(0, cmp_ent_get_data_type_raw_bit(ent)); - TEST_ASSERT_EQUAL_INT(12, cmp_ent_get_cmp_data_size(ent)); - - TEST_ASSERT_EQUAL_INT(cmp_cal_size_of_data(cfg.samples, cfg.data_type), cmp_ent_get_original_size(ent)); - TEST_ASSERT_EQUAL_INT(cfg.cmp_mode, cmp_ent_get_cmp_mode(ent)); - TEST_ASSERT_EQUAL_INT(cfg.model_value, cmp_ent_get_model_value(ent)); - TEST_ASSERT_EQUAL_INT(max_used_bits.version, cmp_ent_get_max_used_bits_version(ent)); - TEST_ASSERT_EQUAL_INT(cfg.round, cmp_ent_get_lossy_cmp_par(ent)); - - - TEST_ASSERT_EQUAL_INT(0, cmp_ent_get_non_ima_spill1(ent)); - TEST_ASSERT_EQUAL_INT(0, cmp_ent_get_non_ima_spill2(ent)); - TEST_ASSERT_EQUAL_INT(0, cmp_ent_get_non_ima_spill3(ent)); - TEST_ASSERT_EQUAL_INT(cfg.spill_smearing_mean, cmp_ent_get_non_ima_spill4(ent)); - TEST_ASSERT_EQUAL_INT(cfg.spill_smearing_variance, cmp_ent_get_non_ima_spill5(ent)); - TEST_ASSERT_EQUAL_INT(cfg.spill_smearing_pixels_error, cmp_ent_get_non_ima_spill6(ent)); - TEST_ASSERT_EQUAL_INT(0, cmp_ent_get_non_ima_cmp_par1(ent)); - TEST_ASSERT_EQUAL_INT(0, cmp_ent_get_non_ima_cmp_par2(ent)); - TEST_ASSERT_EQUAL_INT(0, cmp_ent_get_non_ima_cmp_par3(ent)); - TEST_ASSERT_EQUAL_INT(cfg.cmp_par_smearing_mean, cmp_ent_get_non_ima_cmp_par4(ent)); - TEST_ASSERT_EQUAL_INT(cfg.cmp_par_smearing_variance, cmp_ent_get_non_ima_cmp_par5(ent)); - TEST_ASSERT_EQUAL_INT(cfg.cmp_par_smearing_pixels_error, cmp_ent_get_non_ima_cmp_par6(ent)); - - error = cmp_ent_read_header(ent, &cfg_read); - TEST_ASSERT_FALSE(error); - cfg.icu_output_buf = cmp_ent_get_data_buf(ent); /* quick fix that both cfg are equal */ - cfg.buffer_length = 12; /* quick fix that both cfg are equal */ - TEST_ASSERT_EQUAL_MEMORY(&cfg, &cfg_read, sizeof(struct cmp_cfg)); - - free(ent); - memset(&cfg, 0, sizeof(struct cmp_cfg)); - memset(&cfg_read, 0, sizeof(struct cmp_cfg)); - /** Error Cases **/ /* create imagette raw mode configuration */ cfg.data_type = DATA_TYPE_IMAGETTE; @@ -1796,8 +1496,8 @@ void test_cmp_ent_write_cmp_pars(void) TEST_ASSERT_TRUE(error); /* test data type = DATA_TYPE_F_CAM_BACKGROUND +1 */ - cmp_ent_set_data_type(ent, DATA_TYPE_F_CAM_BACKGROUND + 1, 0); - cfg.data_type = DATA_TYPE_F_CAM_BACKGROUND + 1; + cmp_ent_set_data_type(ent, DATA_TYPE_F_CAM_BACKGROUND + 10, 0); + cfg.data_type = DATA_TYPE_F_CAM_BACKGROUND + 10; error = cmp_ent_write_cmp_pars(ent, &cfg, cmp_size_bits); TEST_ASSERT_TRUE(error); free(ent); @@ -2032,6 +1732,56 @@ void test_cmp_ent_read_header_error_cases(void) } +/** + * @test decompress_cmp_entiy + */ + +void test_decompress_imagette_chunk_raw(void) +{ + int decmp_size; + size_t i; + uint16_t data[] = {0, 1, 2, 0x42, (uint16_t)INT16_MIN, INT16_MAX, UINT16_MAX}; + uint8_t *decompressed_data; + struct cmp_entity *ent; + uint32_t ent_size; + uint32_t chunk_size = 2*(COLLECTION_HDR_SIZE + sizeof(data)); + uint8_t *chunk = calloc(1, chunk_size); TEST_ASSERT_TRUE(chunk); + + for (i = 0; i < 2; i++) { + struct collection_hdr *col = (struct collection_hdr *)(chunk+chunk_size/2*i); + + TEST_ASSERT_FALSE(cmp_col_set_subservice(col, SST_NCxx_S_SCIENCE_IMAGETTE)); + TEST_ASSERT_FALSE(cmp_col_set_data_length(col, sizeof(data))); + TEST_ASSERT_FALSE(cmp_col_set_timestamp(col, 0x0102030400607)); + memcpy(col->entry, data, sizeof(data)); + } + + ent_size = cmp_ent_create(NULL, DATA_TYPE_CHUNK, 1, chunk_size); + TEST_ASSERT_EQUAL_INT(GENERIC_HEADER_SIZE+chunk_size, ent_size); + ent = malloc(ent_size); TEST_ASSERT_TRUE(ent); + ent_size = cmp_ent_create(ent, DATA_TYPE_CHUNK, 1, chunk_size); + TEST_ASSERT_EQUAL_INT(GENERIC_HEADER_SIZE+chunk_size, ent_size); + TEST_ASSERT_FALSE(cmp_ent_set_original_size(ent, chunk_size)); + memcpy(cmp_ent_get_data_buf(ent), chunk, chunk_size); + TEST_ASSERT_FALSE(cpu_to_be_chunk(cmp_ent_get_data_buf(ent), chunk_size)); + + decmp_size = decompress_cmp_entiy(ent, NULL, NULL, NULL); + TEST_ASSERT_EQUAL_INT(chunk_size, decmp_size); + decompressed_data = malloc((size_t)decmp_size); + TEST_ASSERT_TRUE(decompressed_data); + decmp_size = decompress_cmp_entiy(ent, NULL, NULL, decompressed_data); + TEST_ASSERT_EQUAL_INT(chunk_size, decmp_size); + + for (i = 0; i < chunk_size; ++i) + TEST_ASSERT_EQUAL_INT(chunk[i], decompressed_data[i]); + + + free(chunk); + free(ent); + free(decompressed_data); +} + + void test_decompression_error_cases(void) { /* TODO: error cases model decompression without a model Buffer */