ccsds124.h

Go to the documentation of this file.

 
#ifndef CCSDS124_H
#define CCSDS124_H
 
#include <stdint.h>
#include <stddef.h>
 
#define CCSDS124_VERSION_MAJOR 1  
#define CCSDS124_VERSION_MINOR 0  
#define CCSDS124_VERSION_PATCH 0  
#define CCSDS124_OK                0   
#define CCSDS124_ERROR_INVALID_ARG -1  
#define CCSDS124_ERROR_OVERFLOW    -2  
#define CCSDS124_ERROR_UNDERFLOW   -3  
#define CCSDS124_STATUS_UNGUARANTEED 1  
#define CCSDS124_STATUS_TRUNCATED_LENGTH 2 
#ifndef CCSDS124_MAX_PACKET_LENGTH
#define CCSDS124_MAX_PACKET_LENGTH 65535U  
#endif
 
#define CCSDS124_MAX_PACKET_BYTES (((CCSDS124_MAX_PACKET_LENGTH) + 7U) / 8U)  
#define CCSDS124_MAX_ROBUSTNESS 7U     
#define CCSDS124_MAX_HISTORY 16U       
#define CCSDS124_MAX_VT_HISTORY 16U    
#ifndef CCSDS124_MAX_OUTPUT_BYTES
#define CCSDS124_MAX_OUTPUT_BYTES ((CCSDS124_MAX_PACKET_BYTES) * 12U) 
#endif
typedef struct bitvector bitvector_t;           
typedef struct bitbuffer bitbuffer_t;           
typedef struct ccsds124_compressor ccsds124_compressor_t;     
typedef struct ccsds124_decompressor ccsds124_decompressor_t; 
typedef struct {
    uint8_t min_robustness;    
    uint8_t new_mask_flag;     
    uint8_t send_mask_flag;    
    uint8_t uncompressed_flag; 
} ccsds124_params_t;
 
typedef struct {
    uint8_t status;  
    uint8_t Vt;      
    uint8_t ft;      
    uint8_t rt;      
} ccsds124_decompress_result_t;
struct bitvector {
    uint32_t data[((CCSDS124_MAX_PACKET_BYTES) + 3U) / 4U];  
    size_t length;    
    size_t num_words; 
};
 
int bitvector_init(bitvector_t *bv, size_t num_bits);
 
void bitvector_zero(bitvector_t *bv);
 
void bitvector_copy(bitvector_t *dest, const bitvector_t *src);
 
static inline int bitvector_get_bit(const bitvector_t *bv, size_t pos) {
    int result = 0;
    if ((bv != NULL) && (pos < bv->length)) {
        size_t word_index = pos >> 5U;
        size_t bit_in_word = 31U - (pos & 31U);
        uint32_t shifted = bv->data[word_index] >> bit_in_word;
        if ((shifted & 1U) != 0U) {
            result = 1;
        }
    }
    return result;
}
 
static inline void bitvector_set_bit(bitvector_t *bv, size_t pos, int value) {
    if ((bv != NULL) && (pos < bv->length)) {
        size_t word_index = pos >> 5U;
        size_t bit_in_word = 31U - (pos & 31U);
        if (value != 0) {
            bv->data[word_index] |= (1U << bit_in_word);
        } else {
            bv->data[word_index] &= ~(1U << bit_in_word);
        }
    }
}
 
void bitvector_xor(bitvector_t *result, const bitvector_t *a, const bitvector_t *b);
 
void bitvector_or(bitvector_t *result, const bitvector_t *a, const bitvector_t *b);
 
void bitvector_and(bitvector_t *result, const bitvector_t *a, const bitvector_t *b);
 
void bitvector_not(bitvector_t *result, const bitvector_t *a);
 
void bitvector_left_shift(bitvector_t *result, const bitvector_t *a);
 
void bitvector_reverse(bitvector_t *result, const bitvector_t *a);
 
size_t bitvector_hamming_weight(const bitvector_t *bv);
 
int bitvector_equals(const bitvector_t *a, const bitvector_t *b);
 
int bitvector_from_bytes(bitvector_t *bv, const uint8_t *data, size_t num_bytes);
 
int bitvector_to_bytes(const bitvector_t *bv, uint8_t *data, size_t num_bytes);
 
 
struct bitbuffer {
    uint8_t data[CCSDS124_MAX_OUTPUT_BYTES]; 
    size_t num_bits;                       
    uint32_t acc;                          
    size_t acc_len;                        
};
 
void bitbuffer_init(bitbuffer_t *bb);
 
void bitbuffer_clear(bitbuffer_t *bb);
 
int bitbuffer_append_bit(bitbuffer_t *bb, int bit);
 
int bitbuffer_append_bits(bitbuffer_t *bb, const uint8_t *data, size_t num_bits);
 
int bitbuffer_append_value(bitbuffer_t *bb, uint32_t value, size_t num_bits);
 
int bitbuffer_append_bitvector(bitbuffer_t *bb, const bitvector_t *bv);
 
size_t bitbuffer_size(const bitbuffer_t *bb);
 
size_t bitbuffer_to_bytes(const bitbuffer_t *bb, uint8_t *data, size_t max_bytes);
 
 
void ccsds124_update_build(
    bitvector_t *build,
    const bitvector_t *input,
    const bitvector_t *prev_input,
    int new_mask_flag,
    size_t t
);
 
void ccsds124_update_mask(
    bitvector_t *mask,
    const bitvector_t *input,
    const bitvector_t *prev_input,
    const bitvector_t *build_prev,
    int new_mask_flag
);
 
void ccsds124_compute_change(
    bitvector_t *change,
    const bitvector_t *mask,
    const bitvector_t *prev_mask,
    size_t t
);
 
 
int ccsds124_count_encode(bitbuffer_t *output, uint32_t A);
 
int ccsds124_rle_encode(bitbuffer_t *output, const bitvector_t *input);
 
int ccsds124_bit_extract(
    bitbuffer_t *output,
    const bitvector_t *data,
    const bitvector_t *mask
);
 
int ccsds124_bit_extract_forward(
    bitbuffer_t *output,
    const bitvector_t *data,
    const bitvector_t *mask
);
 
 
struct ccsds124_compressor {
    size_t F;                   
    bitvector_t initial_mask;   
    uint8_t robustness;         
    bitvector_t mask;           
    bitvector_t prev_mask;      
    bitvector_t build;          
    bitvector_t prev_input;     
    bitvector_t change_history[CCSDS124_MAX_HISTORY]; 
    size_t history_index;       
    uint8_t new_mask_flag_history[CCSDS124_MAX_VT_HISTORY]; 
    size_t flag_history_index;  
    size_t t;                   
    int pt_limit;   
    int ft_limit;   
    int rt_limit;   
    int pt_counter; 
    int ft_counter; 
    int rt_counter; 
    bitvector_t work_prev_build;   
    bitvector_t work_change;       
    bitvector_t work_Xt;           
    bitvector_t work_inverted;     
    bitvector_t work_shifted;      
    bitvector_t work_diff;         
};
 
int ccsds124_compressor_init(
    ccsds124_compressor_t *comp,
    size_t F,
    const bitvector_t *initial_mask,
    uint8_t robustness,
    int pt_limit,
    int ft_limit,
    int rt_limit
);
 
void ccsds124_compressor_reset(ccsds124_compressor_t *comp);
 
int ccsds124_compress_packet(
    ccsds124_compressor_t *comp,
    const bitvector_t *input,
    bitbuffer_t *output,
    const ccsds124_params_t *params
);
 
int ccsds124_compress(
    ccsds124_compressor_t *comp,
    const uint8_t *input_data,
    size_t input_size,
    uint8_t *output_buffer,
    size_t output_buffer_size,
    size_t *output_size
);
 
void ccsds124_compute_robustness_window(
    bitvector_t *Xt,
    const ccsds124_compressor_t *comp,
    const bitvector_t *current_change
);
 
uint8_t ccsds124_compute_effective_robustness(
    const ccsds124_compressor_t *comp,
    const bitvector_t *current_change
);
 
int ccsds124_has_positive_updates(
    const bitvector_t *Xt,
    const bitvector_t *mask
);
 
int ccsds124_compute_ct_flag(
    const ccsds124_compressor_t *comp,
    uint8_t Vt,
    int current_new_mask_flag
);
 
 
typedef struct {
    const uint8_t *data;  
    size_t num_bits;      
    size_t bit_pos;       
} bitreader_t;
 
void bitreader_init(bitreader_t *reader, const uint8_t *data, size_t num_bits);
 
int bitreader_read_bit(bitreader_t *reader);
 
uint32_t bitreader_read_bits(bitreader_t *reader, size_t num_bits);
 
size_t bitreader_position(const bitreader_t *reader);
 
size_t bitreader_remaining(const bitreader_t *reader);
 
void bitreader_align_byte(bitreader_t *reader);
 
 
int ccsds124_count_decode(bitreader_t *reader, uint32_t *value);
 
int ccsds124_rle_decode(bitreader_t *reader, bitvector_t *result, size_t length);
 
int ccsds124_bit_insert(bitreader_t *reader, bitvector_t *data, const bitvector_t *mask);
 
 
struct ccsds124_decompressor {
    size_t F;                   
    bitvector_t initial_mask;   
    uint8_t robustness;         
    bitvector_t mask;           
    bitvector_t prev_output;    
    bitvector_t Xt;             
    size_t t;                   
    uint8_t mask_inconsistent;  
    uint8_t count_f_mismatch;   
    uint8_t mask_synced;        
    uint8_t received_status_ring[CCSDS124_MAX_VT_HISTORY]; 
    uint8_t received_status_count;  
    uint8_t received_status_index;  
};
 
int ccsds124_decompressor_init(
    ccsds124_decompressor_t *decomp,
    size_t F,
    const bitvector_t *initial_mask,
    uint8_t robustness
);
 
void ccsds124_decompressor_reset(ccsds124_decompressor_t *decomp);
 
int ccsds124_decompressor_notify_packet_loss(
    ccsds124_decompressor_t *decomp,
    uint32_t lost_count
);
 
int ccsds124_decompress_packet(
    ccsds124_decompressor_t *decomp,
    bitreader_t *reader,
    bitvector_t *output
);
 
int ccsds124_decompress_packet_checked(
    ccsds124_decompressor_t *decomp,
    const uint8_t *data,
    size_t num_bits,
    bitvector_t *output,
    ccsds124_decompress_result_t *result
);
 
int ccsds124_discover_packet_length(
    const uint8_t *data,
    size_t num_bits,
    uint32_t *packet_length
);
 
int ccsds124_decompress(
    ccsds124_decompressor_t *decomp,
    const uint8_t *input_data,
    size_t input_size,
    uint8_t *output_buffer,
    size_t output_buffer_size,
    size_t *output_size
);
 
 
const char* ccsds124_version_string(void);
 
const char* ccsds124_error_string(int error_code);
 
 
#endif /* CCSDS124_H */