bitbuffer.c

Go to the documentation of this file.

 
#include "ccsds124.h"
#include <string.h>
 
void bitbuffer_init(bitbuffer_t *bb) {
    if (bb != NULL) {
        bb->num_bits = 0U;
        bb->acc = 0U;
        bb->acc_len = 0U;
        (void)memset(bb->data, 0, CCSDS124_MAX_OUTPUT_BYTES);
    }
}
 
 
void bitbuffer_clear(bitbuffer_t *bb) {
    bitbuffer_init(bb);
}
 
 
static void bitbuffer_flush_acc(bitbuffer_t *bb) {
    while (bb->acc_len >= 8U) {
        /* Extract top 8 bits */
        bb->acc_len -= 8U;
        size_t byte_index = (bb->num_bits - bb->acc_len - 8U) / 8U;
        bb->data[byte_index] = (uint8_t)(bb->acc >> bb->acc_len);
        bb->acc &= ((1U << bb->acc_len) - 1U);  /* Clear extracted bits */
    }
}
 
 
int bitbuffer_append_bit(bitbuffer_t *bb, int bit) {
    int result = CCSDS124_ERROR_INVALID_ARG;
 
    if (bb != NULL) {
        /* Check for overflow - CCSDS124_MAX_OUTPUT_BYTES * 8 bits */
        size_t max_bits = CCSDS124_MAX_OUTPUT_BYTES * 8U;
        if (bb->num_bits >= max_bits) {
            result = CCSDS124_ERROR_OVERFLOW;
        } else {
            /* Accumulate bit in MSB-first order */
            uint32_t bit_val = ((uint32_t)bit) & 1U;
            bb->acc = (bb->acc << 1U) | bit_val;
            bb->acc_len++;
            bb->num_bits++;
 
            /* Flush when accumulator has 8+ bits */
            if (bb->acc_len >= 8U) {
                bitbuffer_flush_acc(bb);
            }
 
            result = CCSDS124_OK;
        }
    }
 
    return result;
}
 
 
int bitbuffer_append_bits(bitbuffer_t *bb, const uint8_t *data, size_t num_bits) {
    int result = CCSDS124_ERROR_INVALID_ARG;
 
    if ((bb != NULL) && (data != NULL)) {
        /* Check for overflow - CCSDS124_MAX_OUTPUT_BYTES * 8 bits */
        size_t max_bits = CCSDS124_MAX_OUTPUT_BYTES * 8U;
        if ((bb->num_bits + num_bits) > max_bits) {
            result = CCSDS124_ERROR_OVERFLOW;
        } else {
            result = CCSDS124_OK;
 
            /* Append each bit MSB-first */
            for (size_t i = 0U; (i < num_bits) && (result == CCSDS124_OK); i++) {
                size_t byte_index = i / 8U;
                size_t bit_index = i % 8U;
 
                /* Extract bits MSB-first (bit 7, 6, 5, ..., 0) */
                uint32_t shift_amount = 7U - (uint32_t)bit_index;
                uint32_t shifted = (uint32_t)data[byte_index] >> shift_amount;
                uint32_t masked = shifted & 1U;
                int bit = (int)masked;
 
                result = bitbuffer_append_bit(bb, bit);
            }
        }
    }
 
    return result;
}
 
 
int bitbuffer_append_value(bitbuffer_t *bb, uint32_t value, size_t num_bits) {
    int result = CCSDS124_ERROR_INVALID_ARG;
 
    if ((bb != NULL) && (num_bits > 0U) && (num_bits <= 24U)) {
        /* Check for overflow */
        size_t max_bits = CCSDS124_MAX_OUTPUT_BYTES * 8U;
        if ((bb->num_bits + num_bits) > max_bits) {
            result = CCSDS124_ERROR_OVERFLOW;
        } else {
            /* Add bits directly to accumulator.
             * Value is right-justified: the bottom 'num_bits' bits are the data.
             * Mask to ensure only the relevant bits are used. */
            uint32_t mask = (1U << (uint32_t)num_bits) - 1U;
            uint32_t masked_value = value & mask;
 
            bb->acc = (bb->acc << (uint32_t)num_bits) | masked_value;
            bb->acc_len += num_bits;
            bb->num_bits += num_bits;
 
            /* Flush complete bytes */
            bitbuffer_flush_acc(bb);
 
            result = CCSDS124_OK;
        }
    }
 
    return result;
}
 
 
int bitbuffer_append_bitvector(bitbuffer_t *bb, const bitvector_t *bv) {
    int result = CCSDS124_ERROR_INVALID_ARG;
 
    if ((bb != NULL) && (bv != NULL)) {
        result = CCSDS124_OK;
 
        /* Calculate number of bytes from bit length */
        size_t num_bytes = (bv->length + 7U) / 8U;
 
        /* CCSDS MSB-first: bytes in order, but bits within each byte from MSB to LSB */
        for (size_t byte_idx = 0U; (byte_idx < num_bytes) && (result == CCSDS124_OK); byte_idx++) {
            size_t bits_in_this_byte = 8U;
 
            /* Last byte may have fewer than 8 bits */
            if (byte_idx == (num_bytes - 1U)) {
                size_t remainder = bv->length % 8U;
                if (remainder != 0U) {
                    bits_in_this_byte = remainder;
                }
            }
 
            /* With MSB-first bitvector indexing: bit 0 is MSB, bit 7 is LSB
             * We want to append bits in order: MSB first, LSB last
             * So we iterate through positions 0, 1, 2, ..., bits_in_this_byte-1 */
            size_t start_bit = byte_idx * 8U;
            for (size_t bit_offset = 0U; (bit_offset < bits_in_this_byte) && (result == CCSDS124_OK); bit_offset++) {
                size_t pos = start_bit + bit_offset;
                int bit = bitvector_get_bit(bv, pos);
 
                result = bitbuffer_append_bit(bb, bit);
            }
        }
    }
 
    return result;
}
 
 
size_t bitbuffer_size(const bitbuffer_t *bb) {
    size_t size = 0U;
 
    if (bb != NULL) {
        size = bb->num_bits;
    }
 
    return size;
}
 
 
size_t bitbuffer_to_bytes(const bitbuffer_t *bb, uint8_t *data, size_t max_bytes) {
    size_t num_bytes = 0U;
 
    if ((bb != NULL) && (data != NULL)) {
        /* Calculate number of bytes needed (ceiling division) */
        num_bytes = (bb->num_bits + 7U) / 8U;
 
        if (num_bytes > max_bytes) {
            num_bytes = max_bytes;
        }
 
        /* Copy flushed bytes from data buffer */
        size_t flushed_bytes = (bb->num_bits - bb->acc_len) / 8U;
        if (flushed_bytes > num_bytes) {
            flushed_bytes = num_bytes;
        }
        if (flushed_bytes > 0U) {
            (void)memcpy(data, bb->data, flushed_bytes);
        }
 
        /* Handle remaining bits in accumulator */
        if ((bb->acc_len > 0U) && (flushed_bytes < num_bytes)) {
            /* Shift accumulator bits to MSB position */
            uint8_t last_byte = (uint8_t)(bb->acc << (8U - bb->acc_len));
            data[flushed_bytes] = last_byte;
        }
    }
 
    return num_bytes;
}