#![cfg_attr(not(feature = "std"), no_std)]
#![allow(clippy::not_unsafe_ptr_arg_deref)]
#[cfg(not(feature = "std"))]
extern crate alloc;
#[cfg(feature = "zephyr")]
mod zephyr_support {
use core::alloc::{GlobalAlloc, Layout};
extern "C" {
fn k_aligned_alloc(align: usize, size: usize) -> *mut u8;
fn k_free(ptr: *mut u8);
}
struct ZephyrAllocator;
unsafe impl GlobalAlloc for ZephyrAllocator {
unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
unsafe { k_aligned_alloc(layout.align(), layout.size()) }
}
unsafe fn dealloc(&self, ptr: *mut u8, _layout: Layout) {
unsafe { k_free(ptr) }
}
}
#[global_allocator]
static ALLOCATOR: ZephyrAllocator = ZephyrAllocator;
#[no_mangle]
pub extern "C" fn alec_heap_init() {
}
#[panic_handler]
fn panic(_: &core::panic::PanicInfo) -> ! {
loop {}
}
}
#[cfg(feature = "bare-metal")]
mod bare_metal_support {
use embedded_alloc::LlffHeap as Heap;
#[global_allocator]
static HEAP: Heap = Heap::empty();
#[no_mangle]
pub unsafe extern "C" fn alec_heap_init() {
const HEAP_SIZE: usize = 8192;
static mut HEAP_MEM: [u8; HEAP_SIZE] = [0; HEAP_SIZE];
unsafe {
HEAP.init(&raw mut HEAP_MEM as usize, HEAP_SIZE);
}
}
#[no_mangle]
pub unsafe extern "C" fn alec_heap_init_with_buffer(buf: *mut u8, len: usize) {
if buf.is_null() || len == 0 {
return;
}
unsafe {
HEAP.init(buf as usize, len);
}
}
#[panic_handler]
fn panic(_info: &core::panic::PanicInfo) -> ! {
loop {}
}
}
#[cfg(not(feature = "std"))]
use alloc::{boxed::Box, vec::Vec};
use core::ffi::{c_char, CStr};
use core::slice;
#[cfg(feature = "std")]
use std::path::Path;
use alec::classifier::Classifier;
use alec::context::{Context, ContextConfig};
use alec::protocol::{ChannelInput, RawData};
#[cfg(feature = "decoder")]
use alec::Decoder;
use alec::Encoder;
#[inline]
fn fixed_channel_source_id(i: usize) -> u32 {
(i as u32) + 1
}
pub const ALEC_DEFAULT_HISTORY_SIZE: u32 = 20;
pub const ALEC_DEFAULT_MAX_PATTERNS: u32 = 256;
pub const ALEC_DEFAULT_MAX_MEMORY_BYTES: u32 = 2048;
pub const ALEC_DEFAULT_KEYFRAME_INTERVAL: u32 = 50;
pub const ALEC_DEFAULT_SMART_RESYNC: bool = true;
pub const ALEC_DEFAULT_NUM_CHANNELS: u32 = 0;
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct AlecEncoderConfig {
pub history_size: u32,
pub max_patterns: u32,
pub max_memory_bytes: u32,
pub keyframe_interval: u32,
pub smart_resync: bool,
pub num_channels: u32,
}
impl AlecEncoderConfig {
pub fn defaults() -> Self {
Self {
history_size: ALEC_DEFAULT_HISTORY_SIZE,
max_patterns: ALEC_DEFAULT_MAX_PATTERNS,
max_memory_bytes: ALEC_DEFAULT_MAX_MEMORY_BYTES,
keyframe_interval: ALEC_DEFAULT_KEYFRAME_INTERVAL,
smart_resync: ALEC_DEFAULT_SMART_RESYNC,
num_channels: ALEC_DEFAULT_NUM_CHANNELS,
}
}
fn resolved(self) -> Self {
let d = Self::defaults();
Self {
history_size: if self.history_size == 0 {
d.history_size
} else {
self.history_size
},
max_patterns: if self.max_patterns == 0 {
d.max_patterns
} else {
self.max_patterns
},
max_memory_bytes: if self.max_memory_bytes == 0 {
d.max_memory_bytes
} else {
self.max_memory_bytes
},
keyframe_interval: self.keyframe_interval,
smart_resync: self.smart_resync,
num_channels: if self.num_channels > 64 {
0
} else {
self.num_channels
},
}
}
fn to_context_config(self) -> ContextConfig {
let r = self.resolved();
ContextConfig {
history_size: r.history_size as usize,
max_patterns: r.max_patterns as usize,
max_memory: r.max_memory_bytes as usize,
..ContextConfig::default()
}
}
}
fn hash_source_id(source_id: *const c_char) -> u32 {
if source_id.is_null() {
return 0;
}
let bytes = unsafe { CStr::from_ptr(source_id) }.to_bytes();
(xxhash_rust::xxh64::xxh64(bytes, 0) % 127 + 1) as u32
}
#[repr(C)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AlecResult {
Ok = 0,
ErrorInvalidInput = 1,
ErrorBufferTooSmall = 2,
ErrorEncodingFailed = 3,
ErrorDecodingFailed = 4,
ErrorNullPointer = 5,
ErrorInvalidUtf8 = 6,
ErrorFileIo = 7,
ErrorVersionMismatch = 8,
ErrorCorruptData = 9,
}
pub struct AlecEncoder {
encoder: Encoder,
classifier: Classifier,
context: Context,
force_keyframe_pending: bool,
#[allow(dead_code)] messages_since_keyframe: u32,
#[allow(dead_code)] keyframe_interval: u32,
smart_resync: bool,
}
#[cfg(feature = "decoder")]
pub struct AlecDecoder {
decoder: Decoder,
context: Context,
last_header_sequence: Option<u16>,
last_gap_size: u8,
}
#[no_mangle]
pub extern "C" fn alec_version() -> *const c_char {
static VERSION: &[u8] = b"1.3.10\0";
VERSION.as_ptr() as *const c_char
}
#[no_mangle]
pub extern "C" fn alec_result_to_string(result: AlecResult) -> *const c_char {
let msg: &'static [u8] = match result {
AlecResult::Ok => b"Success\0",
AlecResult::ErrorInvalidInput => b"Invalid input data\0",
AlecResult::ErrorBufferTooSmall => b"Output buffer too small\0",
AlecResult::ErrorEncodingFailed => b"Encoding failed\0",
AlecResult::ErrorDecodingFailed => b"Decoding failed\0",
AlecResult::ErrorNullPointer => b"Null pointer provided\0",
AlecResult::ErrorInvalidUtf8 => b"Invalid UTF-8 string\0",
AlecResult::ErrorFileIo => b"File I/O error\0",
AlecResult::ErrorVersionMismatch => b"Context version mismatch\0",
AlecResult::ErrorCorruptData => b"Corrupt or malformed context state\0",
};
msg.as_ptr() as *const c_char
}
#[no_mangle]
pub extern "C" fn alec_encoder_new() -> *mut AlecEncoder {
let defaults = AlecEncoderConfig::defaults();
let encoder = Box::new(AlecEncoder {
encoder: Encoder::new(),
classifier: Classifier::default(),
context: Context::new(),
force_keyframe_pending: false,
messages_since_keyframe: 0,
keyframe_interval: defaults.keyframe_interval,
smart_resync: defaults.smart_resync,
});
Box::into_raw(encoder)
}
#[no_mangle]
pub extern "C" fn alec_encoder_new_with_checksum() -> *mut AlecEncoder {
let defaults = AlecEncoderConfig::defaults();
let encoder = Box::new(AlecEncoder {
encoder: Encoder::with_checksum(),
classifier: Classifier::default(),
context: Context::new(),
force_keyframe_pending: false,
messages_since_keyframe: 0,
keyframe_interval: defaults.keyframe_interval,
smart_resync: defaults.smart_resync,
});
Box::into_raw(encoder)
}
#[no_mangle]
pub extern "C" fn alec_encoder_new_with_config(
config: *const AlecEncoderConfig,
) -> *mut AlecEncoder {
let cfg = if config.is_null() {
AlecEncoderConfig::defaults()
} else {
unsafe { *config }.resolved()
};
let mut context = Context::with_config(cfg.to_context_config());
for i in 0..cfg.num_channels {
context.ensure_source_stats(i + 1);
}
let encoder = Box::new(AlecEncoder {
encoder: Encoder::new(),
classifier: Classifier::default(),
context,
force_keyframe_pending: false,
messages_since_keyframe: 0,
keyframe_interval: cfg.keyframe_interval,
smart_resync: cfg.smart_resync,
});
Box::into_raw(encoder)
}
#[no_mangle]
pub extern "C" fn alec_force_keyframe(encoder: *mut AlecEncoder) {
if encoder.is_null() {
return;
}
let enc = unsafe { &mut *encoder };
if !enc.smart_resync {
return;
}
enc.force_keyframe_pending = true;
}
#[no_mangle]
pub extern "C" fn alec_downlink_handler(
encoder: *mut AlecEncoder,
data: *const u8,
len: usize,
) -> AlecResult {
if encoder.is_null() || data.is_null() {
return AlecResult::ErrorNullPointer;
}
if len == 0 {
return AlecResult::ErrorInvalidInput;
}
let cmd = unsafe { *data };
match cmd {
0xFF => {
alec_force_keyframe(encoder);
AlecResult::Ok
}
other => {
log::warn!(
"ALEC downlink: unknown command byte 0x{:02X} ({} byte payload, ignored)",
other,
len
);
AlecResult::ErrorInvalidInput
}
}
}
#[no_mangle]
pub extern "C" fn alec_encoder_free(encoder: *mut AlecEncoder) {
if !encoder.is_null() {
unsafe {
drop(Box::from_raw(encoder));
}
}
}
#[no_mangle]
pub extern "C" fn alec_encode_value(
encoder: *mut AlecEncoder,
value: f64,
timestamp: u64,
source_id: *const c_char,
output: *mut u8,
output_capacity: usize,
output_len: *mut usize,
) -> AlecResult {
if encoder.is_null() || output.is_null() || output_len.is_null() {
return AlecResult::ErrorNullPointer;
}
let enc = unsafe { &mut *encoder };
let sid = hash_source_id(source_id);
let raw_data = RawData::with_source(sid, value, timestamp);
let classification = enc.classifier.classify(&raw_data, &enc.context);
let message = enc.encoder.encode(&raw_data, &classification, &enc.context);
let encoded = message.to_bytes();
if encoded.len() > output_capacity {
return AlecResult::ErrorBufferTooSmall;
}
let output_slice = unsafe { slice::from_raw_parts_mut(output, output_capacity) };
output_slice[..encoded.len()].copy_from_slice(&encoded);
unsafe {
*output_len = encoded.len();
}
enc.context.observe(&raw_data);
AlecResult::Ok
}
#[no_mangle]
pub extern "C" fn alec_encode_multi(
encoder: *mut AlecEncoder,
values: *const f64,
value_count: usize,
timestamps: *const u64,
source_ids: *const *const c_char,
priorities: *const u8,
output: *mut u8,
output_capacity: usize,
output_len: *mut usize,
) -> AlecResult {
if encoder.is_null() || values.is_null() || output.is_null() || output_len.is_null() {
return AlecResult::ErrorNullPointer;
}
if value_count == 0 {
return AlecResult::ErrorInvalidInput;
}
let enc = unsafe { &mut *encoder };
let values_slice = unsafe { slice::from_raw_parts(values, value_count) };
let channels: Vec<ChannelInput> = (0..value_count)
.map(|i| {
let sid = if source_ids.is_null() {
(i as u32) + 1
} else {
let ptr = unsafe { *source_ids.add(i) };
hash_source_id(ptr)
};
ChannelInput {
name_id: i as u8,
source_id: sid,
value: values_slice[i],
}
})
.collect();
let timestamp = if timestamps.is_null() {
0u64
} else {
unsafe { *timestamps }
};
let (message, classifications) =
enc.encoder
.encode_multi_adaptive(&channels, timestamp, &enc.context, &enc.classifier);
let _ = priorities; let _ = classifications;
let encoded = message.to_bytes();
if encoded.len() > output_capacity {
return AlecResult::ErrorBufferTooSmall;
}
let output_slice = unsafe { slice::from_raw_parts_mut(output, output_capacity) };
output_slice[..encoded.len()].copy_from_slice(&encoded);
unsafe {
*output_len = encoded.len();
}
for ch in &channels {
let rd = RawData::with_source(ch.name_id as u32, ch.value, timestamp);
enc.context.observe(&rd);
}
AlecResult::Ok
}
#[cfg(feature = "std")]
#[no_mangle]
pub extern "C" fn alec_encoder_save_context(
encoder: *mut AlecEncoder,
path: *const c_char,
sensor_type: *const c_char,
) -> AlecResult {
if encoder.is_null() || path.is_null() || sensor_type.is_null() {
return AlecResult::ErrorNullPointer;
}
let enc = unsafe { &*encoder };
let path_str = match unsafe { CStr::from_ptr(path) }.to_str() {
Ok(s) => s,
Err(_) => return AlecResult::ErrorInvalidUtf8,
};
let sensor_type_str = match unsafe { CStr::from_ptr(sensor_type) }.to_str() {
Ok(s) => s,
Err(_) => return AlecResult::ErrorInvalidUtf8,
};
match enc
.context
.save_to_file(Path::new(path_str), sensor_type_str)
{
Ok(()) => AlecResult::Ok,
Err(_) => AlecResult::ErrorFileIo,
}
}
#[cfg(feature = "std")]
#[no_mangle]
pub extern "C" fn alec_encoder_load_context(
encoder: *mut AlecEncoder,
path: *const c_char,
) -> AlecResult {
if encoder.is_null() || path.is_null() {
return AlecResult::ErrorNullPointer;
}
let enc = unsafe { &mut *encoder };
let path_str = match unsafe { CStr::from_ptr(path) }.to_str() {
Ok(s) => s,
Err(_) => return AlecResult::ErrorInvalidUtf8,
};
match Context::load_from_file(Path::new(path_str)) {
Ok(ctx) => {
enc.context = ctx;
AlecResult::Ok
}
Err(_) => AlecResult::ErrorFileIo,
}
}
#[no_mangle]
pub extern "C" fn alec_encoder_context_version(encoder: *const AlecEncoder) -> u32 {
if encoder.is_null() {
return 0;
}
let enc = unsafe { &*encoder };
enc.context.context_version()
}
const ENC_STATE_MAGIC: [u8; 4] = *b"ALEE";
const ENC_STATE_VERSION: u8 = 1;
const ENC_STATE_HEADER_SIZE: usize = 24;
const ENC_STATE_CTX_TAG: &str = "ffi";
const ENC_FLAG_FORCE_KEYFRAME: u8 = 0b0000_0001;
#[no_mangle]
pub extern "C" fn alec_encoder_context_save(
enc: *const AlecEncoder,
buf: *mut u8,
buf_cap: usize,
written: *mut usize,
) -> AlecResult {
if enc.is_null() || buf.is_null() || written.is_null() {
return AlecResult::ErrorNullPointer;
}
let e = unsafe { &*enc };
let alcs_needed = match e.context.preload_bytes_len(ENC_STATE_CTX_TAG) {
Ok(n) => n,
Err(_) => return AlecResult::ErrorEncodingFailed,
};
let total = ENC_STATE_HEADER_SIZE + alcs_needed;
if total > buf_cap {
unsafe { *written = total };
return AlecResult::ErrorBufferTooSmall;
}
let out = unsafe { slice::from_raw_parts_mut(buf, buf_cap) };
out[0..4].copy_from_slice(&ENC_STATE_MAGIC);
out[4] = ENC_STATE_VERSION;
out[5] = if e.force_keyframe_pending {
ENC_FLAG_FORCE_KEYFRAME
} else {
0
};
out[6..8].copy_from_slice(&e.encoder.sequence().to_be_bytes());
out[8..12].copy_from_slice(&e.messages_since_keyframe.to_be_bytes());
out[12..16].copy_from_slice(&(alcs_needed as u32).to_be_bytes());
let hdr_hash = xxhash_rust::xxh64::xxh64(&out[0..16], 0);
out[16..24].copy_from_slice(&hdr_hash.to_be_bytes());
let alcs_slice = &mut out[ENC_STATE_HEADER_SIZE..ENC_STATE_HEADER_SIZE + alcs_needed];
let alcs_written = match e.context.write_preload_bytes(ENC_STATE_CTX_TAG, alcs_slice) {
Ok(n) => n,
Err(_) => return AlecResult::ErrorEncodingFailed,
};
debug_assert_eq!(alcs_written, alcs_needed);
unsafe { *written = total };
AlecResult::Ok
}
#[no_mangle]
pub extern "C" fn alec_encoder_context_load(
enc: *mut AlecEncoder,
buf: *const u8,
buf_len: usize,
) -> AlecResult {
if enc.is_null() || buf.is_null() {
return AlecResult::ErrorNullPointer;
}
if buf_len < ENC_STATE_HEADER_SIZE {
return AlecResult::ErrorCorruptData;
}
let data = unsafe { slice::from_raw_parts(buf, buf_len) };
if data[0..4] != ENC_STATE_MAGIC {
return AlecResult::ErrorCorruptData;
}
if data[4] != ENC_STATE_VERSION {
return AlecResult::ErrorCorruptData;
}
let stored_hash = u64::from_be_bytes([
data[16], data[17], data[18], data[19], data[20], data[21], data[22], data[23],
]);
let computed_hash = xxhash_rust::xxh64::xxh64(&data[0..16], 0);
if stored_hash != computed_hash {
return AlecResult::ErrorCorruptData;
}
let alcs_len = u32::from_be_bytes([data[12], data[13], data[14], data[15]]) as usize;
if alcs_len != buf_len.saturating_sub(ENC_STATE_HEADER_SIZE) {
return AlecResult::ErrorCorruptData;
}
let alcs = &data[ENC_STATE_HEADER_SIZE..ENC_STATE_HEADER_SIZE + alcs_len];
if !Context::validate_preload_header(alcs) {
return AlecResult::ErrorCorruptData;
}
let flags = data[5];
let sequence = u16::from_be_bytes([data[6], data[7]]);
let msk = u32::from_be_bytes([data[8], data[9], data[10], data[11]]);
let e = unsafe { &mut *enc };
e.context = Context::new();
match Context::from_preload_bytes(alcs) {
Ok(ctx) => {
e.context = ctx;
e.encoder.restore_sequence(sequence);
e.messages_since_keyframe = msk;
e.force_keyframe_pending = (flags & ENC_FLAG_FORCE_KEYFRAME) != 0;
AlecResult::Ok
}
Err(_) => {
AlecResult::ErrorCorruptData
}
}
}
#[cfg(feature = "decoder")]
#[no_mangle]
pub extern "C" fn alec_decoder_new() -> *mut AlecDecoder {
let decoder = Box::new(AlecDecoder {
decoder: Decoder::new(),
context: Context::new(),
last_header_sequence: None,
last_gap_size: 0,
});
Box::into_raw(decoder)
}
#[cfg(feature = "decoder")]
#[no_mangle]
pub extern "C" fn alec_decoder_new_with_checksum() -> *mut AlecDecoder {
let decoder = Box::new(AlecDecoder {
decoder: Decoder::with_checksum_verification(),
context: Context::new(),
last_header_sequence: None,
last_gap_size: 0,
});
Box::into_raw(decoder)
}
#[cfg(feature = "decoder")]
#[no_mangle]
pub extern "C" fn alec_decoder_new_with_config(
config: *const AlecEncoderConfig,
) -> *mut AlecDecoder {
let cfg = if config.is_null() {
AlecEncoderConfig::defaults()
} else {
unsafe { *config }.resolved()
};
let context = Context::with_config(cfg.to_context_config());
let decoder = Box::new(AlecDecoder {
decoder: Decoder::new(),
context,
last_header_sequence: None,
last_gap_size: 0,
});
Box::into_raw(decoder)
}
#[cfg(feature = "decoder")]
#[no_mangle]
pub extern "C" fn alec_decoder_reset(dec: *mut AlecDecoder) {
if dec.is_null() {
return;
}
let d = unsafe { &mut *dec };
d.decoder.reset();
d.context.reset_to_baseline();
d.last_header_sequence = None;
d.last_gap_size = 0;
}
#[cfg(feature = "decoder")]
#[no_mangle]
pub extern "C" fn alec_decoder_gap_detected(
decoder: *const AlecDecoder,
out_gap_size: *mut u8,
) -> bool {
if decoder.is_null() {
if !out_gap_size.is_null() {
unsafe { *out_gap_size = 0 };
}
return false;
}
let dec = unsafe { &*decoder };
if !out_gap_size.is_null() {
unsafe { *out_gap_size = dec.last_gap_size };
}
dec.last_gap_size > 0
}
#[cfg(feature = "decoder")]
#[no_mangle]
pub extern "C" fn alec_decoder_free(decoder: *mut AlecDecoder) {
if !decoder.is_null() {
unsafe {
drop(Box::from_raw(decoder));
}
}
}
#[cfg(feature = "decoder")]
#[no_mangle]
pub extern "C" fn alec_decode_value(
decoder: *mut AlecDecoder,
input: *const u8,
input_len: usize,
value: *mut f64,
timestamp: *mut u64,
) -> AlecResult {
if decoder.is_null() || input.is_null() || value.is_null() {
return AlecResult::ErrorNullPointer;
}
let dec = unsafe { &mut *decoder };
let input_slice = unsafe { slice::from_raw_parts(input, input_len) };
match dec.decoder.decode_bytes(input_slice, &dec.context) {
Ok(decoded_data) => {
unsafe {
*value = decoded_data.value;
if !timestamp.is_null() {
*timestamp = decoded_data.timestamp;
}
}
AlecResult::Ok
}
Err(_) => AlecResult::ErrorDecodingFailed,
}
}
#[cfg(feature = "decoder")]
#[no_mangle]
pub extern "C" fn alec_decode_multi(
decoder: *mut AlecDecoder,
input: *const u8,
input_len: usize,
values: *mut f64,
values_capacity: usize,
values_count: *mut usize,
) -> AlecResult {
if decoder.is_null() || input.is_null() || values.is_null() || values_count.is_null() {
return AlecResult::ErrorNullPointer;
}
let dec = unsafe { &mut *decoder };
let input_slice = unsafe { slice::from_raw_parts(input, input_len) };
let message = match alec::protocol::EncodedMessage::from_bytes(input_slice) {
Some(msg) => msg,
None => return AlecResult::ErrorDecodingFailed,
};
let cur_seq = message.header.sequence;
dec.last_gap_size = match dec.last_header_sequence {
Some(prev) => {
let diff = cur_seq.wrapping_sub(prev);
if diff == 0 {
0 } else {
let missing = diff.saturating_sub(1);
missing.min(u8::MAX as u16) as u8
}
}
None => 0,
};
dec.last_header_sequence = Some(cur_seq);
match dec.decoder.decode_multi(&message, &dec.context) {
Ok(value_pairs) => {
if value_pairs.len() > values_capacity {
return AlecResult::ErrorBufferTooSmall;
}
let values_slice = unsafe { slice::from_raw_parts_mut(values, values_capacity) };
for (i, (_, val)) in value_pairs.iter().enumerate() {
values_slice[i] = *val;
}
unsafe {
*values_count = value_pairs.len();
}
AlecResult::Ok
}
Err(_) => AlecResult::ErrorDecodingFailed,
}
}
#[cfg(all(feature = "decoder", feature = "std"))]
#[no_mangle]
pub extern "C" fn alec_decoder_load_context(
decoder: *mut AlecDecoder,
path: *const c_char,
) -> AlecResult {
if decoder.is_null() || path.is_null() {
return AlecResult::ErrorNullPointer;
}
let dec = unsafe { &mut *decoder };
let path_str = match unsafe { CStr::from_ptr(path) }.to_str() {
Ok(s) => s,
Err(_) => return AlecResult::ErrorInvalidUtf8,
};
match Context::load_from_file(Path::new(path_str)) {
Ok(ctx) => {
dec.context = ctx;
AlecResult::Ok
}
Err(_) => AlecResult::ErrorFileIo,
}
}
#[cfg(feature = "decoder")]
#[no_mangle]
pub extern "C" fn alec_decoder_context_version(decoder: *const AlecDecoder) -> u32 {
if decoder.is_null() {
return 0;
}
let dec = unsafe { &*decoder };
dec.context.context_version()
}
#[no_mangle]
pub extern "C" fn alec_encode_multi_fixed(
encoder: *mut AlecEncoder,
values: *const f64,
channel_count: usize,
output: *mut u8,
output_capacity: usize,
out_len: *mut usize,
) -> AlecResult {
if encoder.is_null() || values.is_null() || output.is_null() || out_len.is_null() {
return AlecResult::ErrorNullPointer;
}
if channel_count == 0 {
return AlecResult::ErrorInvalidInput;
}
let enc = unsafe { &mut *encoder };
let values_slice = unsafe { slice::from_raw_parts(values, channel_count) };
let output_slice = unsafe { slice::from_raw_parts_mut(output, output_capacity) };
let periodic_due =
enc.keyframe_interval > 0 && enc.messages_since_keyframe >= enc.keyframe_interval;
let downlink_forced = enc.force_keyframe_pending && enc.smart_resync;
let keyframe = periodic_due || downlink_forced;
match enc
.encoder
.encode_multi_fixed(values_slice, &enc.context, keyframe, output_slice)
{
Ok(n) => {
unsafe {
*out_len = n;
}
if keyframe {
enc.messages_since_keyframe = 1;
enc.force_keyframe_pending = false;
} else {
enc.messages_since_keyframe = enc.messages_since_keyframe.saturating_add(1);
}
for (i, &v) in values_slice.iter().enumerate() {
let rd = RawData::with_source(fixed_channel_source_id(i), v, 0);
enc.context.observe(&rd);
}
AlecResult::Ok
}
Err(alec::error::AlecError::Encode(alec::error::EncodeError::BufferTooSmall {
..
})) => AlecResult::ErrorBufferTooSmall,
Err(alec::error::AlecError::Encode(alec::error::EncodeError::PayloadTooLarge {
..
})) => AlecResult::ErrorInvalidInput,
Err(_) => AlecResult::ErrorEncodingFailed,
}
}
#[cfg(feature = "decoder")]
#[no_mangle]
pub extern "C" fn alec_decode_multi_fixed(
dec: *mut AlecDecoder,
frame_data: *const u8,
frame_len: usize,
values_out: *mut f64,
max_channels: usize,
num_channels_out: *mut usize,
sequence_out: *mut u16,
is_keyframe_out: *mut bool,
) -> AlecResult {
if dec.is_null() || frame_data.is_null() || values_out.is_null() {
return AlecResult::ErrorNullPointer;
}
if max_channels == 0 {
return AlecResult::ErrorInvalidInput;
}
let d = unsafe { &mut *dec };
let input_slice = unsafe { slice::from_raw_parts(frame_data, frame_len) };
let output_slice = unsafe { slice::from_raw_parts_mut(values_out, max_channels) };
let channel_count = max_channels;
match d
.decoder
.decode_multi_fixed(input_slice, channel_count, &d.context, output_slice)
{
Ok(info) => {
d.last_header_sequence = Some(info.sequence);
d.last_gap_size = info.gap_size;
if !info.keyframe {
if info.gap_size > 0 {
log::warn!(
"ALEC gap detected on fixed-channel decode: {} frame(s) missing \
(seq={}), context reset to baseline",
info.gap_size,
info.sequence
);
d.context.reset_to_baseline();
} else if info.context_mismatch {
let wire_ver = info.context_version as u32;
let _result = d.context.check_version(wire_ver);
log::warn!(
"ALEC ctx_ver mismatch on fixed-channel decode: \
wire={}, context reset to baseline",
info.context_version
);
d.context.reset_to_baseline();
}
}
for (i, &value) in output_slice.iter().take(channel_count).enumerate() {
let rd = RawData::with_source(fixed_channel_source_id(i), value, 0);
d.context.observe(&rd);
}
if !num_channels_out.is_null() {
unsafe { *num_channels_out = channel_count };
}
if !sequence_out.is_null() {
unsafe { *sequence_out = info.sequence };
}
if !is_keyframe_out.is_null() {
unsafe { *is_keyframe_out = info.keyframe };
}
AlecResult::Ok
}
Err(alec::error::AlecError::Decode(alec::error::DecodeError::BufferTooShort {
..
})) => AlecResult::ErrorBufferTooSmall,
Err(alec::error::AlecError::Decode(alec::error::DecodeError::MalformedMessage {
reason,
..
})) if reason.contains("not a fixed-channel ALEC frame") => AlecResult::ErrorInvalidInput,
Err(_) => AlecResult::ErrorDecodingFailed,
}
}
#[cfg(feature = "decoder")]
#[no_mangle]
pub extern "C" fn alec_decoder_feed_values(
dec: *mut AlecDecoder,
values: *const f64,
num_values: usize,
) -> AlecResult {
if dec.is_null() || values.is_null() {
return AlecResult::ErrorNullPointer;
}
if num_values == 0 || num_values > 64 {
return AlecResult::ErrorInvalidInput;
}
let d = unsafe { &mut *dec };
let values_slice = unsafe { slice::from_raw_parts(values, num_values) };
let wire_ctx_ver = (d.context.context_version() & 0xFFFF) as u16;
let wire_seq = d
.decoder
.last_fixed_sequence()
.unwrap_or(u16::MAX)
.wrapping_add(1);
d.decoder.record_fixed_frame(wire_seq, wire_ctx_ver);
d.last_header_sequence = Some(wire_seq);
d.last_gap_size = 0;
for (i, &v) in values_slice.iter().enumerate() {
let rd = RawData::with_source(fixed_channel_source_id(i), v, 0);
d.context.observe(&rd);
}
AlecResult::Ok
}
#[cfg(feature = "decoder")]
#[no_mangle]
pub extern "C" fn alec_decoder_export_state_size(
decoder: *const AlecDecoder,
sensor_type: *const c_char,
out_size: *mut usize,
) -> AlecResult {
if decoder.is_null() || sensor_type.is_null() || out_size.is_null() {
return AlecResult::ErrorNullPointer;
}
let dec = unsafe { &*decoder };
let sens_str = match unsafe { CStr::from_ptr(sensor_type) }.to_str() {
Ok(s) => s,
Err(_) => return AlecResult::ErrorInvalidUtf8,
};
match dec.context.to_preload_bytes(sens_str) {
Ok(bytes) => {
unsafe { *out_size = bytes.len() };
AlecResult::Ok
}
Err(_) => AlecResult::ErrorInvalidInput,
}
}
#[cfg(feature = "decoder")]
#[no_mangle]
pub extern "C" fn alec_decoder_export_state(
decoder: *const AlecDecoder,
sensor_type: *const c_char,
out_buf: *mut u8,
out_capacity: usize,
out_len: *mut usize,
) -> AlecResult {
if decoder.is_null() || sensor_type.is_null() || out_buf.is_null() || out_len.is_null() {
return AlecResult::ErrorNullPointer;
}
let dec = unsafe { &*decoder };
let sens_str = match unsafe { CStr::from_ptr(sensor_type) }.to_str() {
Ok(s) => s,
Err(_) => return AlecResult::ErrorInvalidUtf8,
};
let bytes = match dec.context.to_preload_bytes(sens_str) {
Ok(b) => b,
Err(_) => return AlecResult::ErrorInvalidInput,
};
if bytes.len() > out_capacity {
unsafe { *out_len = bytes.len() };
return AlecResult::ErrorBufferTooSmall;
}
let out_slice = unsafe { slice::from_raw_parts_mut(out_buf, out_capacity) };
out_slice[..bytes.len()].copy_from_slice(&bytes);
unsafe { *out_len = bytes.len() };
AlecResult::Ok
}
#[cfg(feature = "decoder")]
#[no_mangle]
pub extern "C" fn alec_decoder_import_state(
decoder: *mut AlecDecoder,
data: *const u8,
data_len: usize,
) -> AlecResult {
if decoder.is_null() || data.is_null() {
return AlecResult::ErrorNullPointer;
}
let data_slice = unsafe { slice::from_raw_parts(data, data_len) };
match Context::from_preload_bytes(data_slice) {
Ok(ctx) => {
let dec = unsafe { &mut *decoder };
dec.context = ctx;
AlecResult::Ok
}
Err(_) => AlecResult::ErrorCorruptData,
}
}
#[cfg(feature = "decoder")]
const FFI_CONTEXT_TAG: &str = "ffi";
#[cfg(feature = "decoder")]
#[no_mangle]
pub extern "C" fn alec_decoder_context_save(
dec: *const AlecDecoder,
buf: *mut u8,
buf_cap: usize,
written: *mut usize,
) -> AlecResult {
if dec.is_null() || buf.is_null() || written.is_null() {
return AlecResult::ErrorNullPointer;
}
let d = unsafe { &*dec };
let bytes = match d.context.to_preload_bytes(FFI_CONTEXT_TAG) {
Ok(b) => b,
Err(_) => return AlecResult::ErrorEncodingFailed,
};
if bytes.len() > buf_cap {
unsafe { *written = bytes.len() };
return AlecResult::ErrorBufferTooSmall;
}
let out_slice = unsafe { slice::from_raw_parts_mut(buf, buf_cap) };
out_slice[..bytes.len()].copy_from_slice(&bytes);
unsafe { *written = bytes.len() };
AlecResult::Ok
}
#[cfg(feature = "decoder")]
#[no_mangle]
pub extern "C" fn alec_decoder_context_load(
dec: *mut AlecDecoder,
buf: *const u8,
buf_len: usize,
) -> AlecResult {
if dec.is_null() || buf.is_null() {
return AlecResult::ErrorNullPointer;
}
let data_slice = unsafe { slice::from_raw_parts(buf, buf_len) };
match Context::from_preload_bytes(data_slice) {
Ok(ctx) => {
let d = unsafe { &mut *dec };
d.context = ctx;
AlecResult::Ok
}
Err(_) => AlecResult::ErrorCorruptData,
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::ptr;
#[test]
fn test_version() {
let version = alec_version();
assert!(!version.is_null());
let version_str = unsafe { CStr::from_ptr(version) }.to_str().unwrap();
assert_eq!(version_str, "1.3.10");
}
#[test]
fn test_result_to_string() {
let ok_str = alec_result_to_string(AlecResult::Ok);
assert!(!ok_str.is_null());
let ok = unsafe { CStr::from_ptr(ok_str) }.to_str().unwrap();
assert_eq!(ok, "Success");
}
#[test]
fn test_encoder_lifecycle() {
let enc = alec_encoder_new();
assert!(!enc.is_null());
alec_encoder_free(enc);
}
#[test]
fn test_encoder_free_null() {
alec_encoder_free(ptr::null_mut());
}
#[test]
fn test_decoder_lifecycle() {
let dec = alec_decoder_new();
assert!(!dec.is_null());
alec_decoder_free(dec);
}
#[test]
fn test_encode_value() {
let enc = alec_encoder_new();
assert!(!enc.is_null());
let mut output = [0u8; 256];
let mut output_len: usize = 0;
let result = alec_encode_value(
enc,
22.5,
1234567890,
ptr::null(),
output.as_mut_ptr(),
output.len(),
&mut output_len,
);
assert_eq!(result, AlecResult::Ok);
assert!(output_len > 0);
alec_encoder_free(enc);
}
#[test]
fn test_encode_null_pointer() {
let mut output = [0u8; 256];
let mut output_len: usize = 0;
let result = alec_encode_value(
ptr::null_mut(),
22.5,
0,
ptr::null(),
output.as_mut_ptr(),
output.len(),
&mut output_len,
);
assert_eq!(result, AlecResult::ErrorNullPointer);
}
#[test]
fn test_encode_multi() {
let enc = alec_encoder_new();
let values: [f64; 4] = [22.0, 22.5, 23.0, 22.8];
let mut output = [0u8; 256];
let mut output_len: usize = 0;
let result = alec_encode_multi(
enc,
values.as_ptr(),
values.len(),
ptr::null(), ptr::null(), ptr::null(), output.as_mut_ptr(),
output.len(),
&mut output_len,
);
assert_eq!(result, AlecResult::Ok);
assert!(output_len > 0);
alec_encoder_free(enc);
}
#[test]
fn test_context_version() {
let enc = alec_encoder_new();
let version = alec_encoder_context_version(enc);
assert_eq!(version, 0);
let mut output = [0u8; 256];
let mut output_len: usize = 0;
alec_encode_value(
enc,
22.5,
0,
ptr::null(),
output.as_mut_ptr(),
output.len(),
&mut output_len,
);
let new_version = alec_encoder_context_version(enc);
assert!(new_version > version);
alec_encoder_free(enc);
}
#[test]
fn test_encoder_with_checksum() {
let enc = alec_encoder_new_with_checksum();
assert!(!enc.is_null());
let mut output = [0u8; 256];
let mut output_len: usize = 0;
let result = alec_encode_value(
enc,
22.5,
0,
ptr::null(),
output.as_mut_ptr(),
output.len(),
&mut output_len,
);
assert_eq!(result, AlecResult::Ok);
alec_encoder_free(enc);
}
#[test]
fn test_encode_value_with_source_id() {
let enc = alec_encoder_new();
let mut output = [0u8; 256];
let mut output_len: usize = 0;
let source = b"temperature\0";
let result = alec_encode_value(
enc,
22.5,
0,
source.as_ptr() as *const c_char,
output.as_mut_ptr(),
output.len(),
&mut output_len,
);
assert_eq!(result, AlecResult::Ok);
assert!(output_len > 0);
let result2 = alec_encode_value(
enc,
22.5,
1,
ptr::null(),
output.as_mut_ptr(),
output.len(),
&mut output_len,
);
assert_eq!(result2, AlecResult::Ok);
alec_encoder_free(enc);
}
#[test]
fn test_hash_source_id() {
assert_eq!(hash_source_id(ptr::null()), 0);
let a = b"temperature\0";
let b = b"pressure\0";
let ha = hash_source_id(a.as_ptr() as *const c_char);
let hb = hash_source_id(b.as_ptr() as *const c_char);
assert!(
ha >= 1 && ha <= 127,
"hash out of 1-byte varint range: {}",
ha
);
assert!(
hb >= 1 && hb <= 127,
"hash out of 1-byte varint range: {}",
hb
);
assert_ne!(ha, hb);
let ha2 = hash_source_id(a.as_ptr() as *const c_char);
assert_eq!(ha, ha2);
}
#[test]
fn test_encode_decode_roundtrip() {
let enc = alec_encoder_new();
let dec = alec_decoder_new();
let original_value = 22.5;
let mut encoded = [0u8; 256];
let mut encoded_len: usize = 0;
let result = alec_encode_value(
enc,
original_value,
12345,
ptr::null(),
encoded.as_mut_ptr(),
encoded.len(),
&mut encoded_len,
);
assert_eq!(result, AlecResult::Ok);
let mut decoded_value: f64 = 0.0;
let mut decoded_timestamp: u64 = 0;
let result = alec_decode_value(
dec,
encoded.as_ptr(),
encoded_len,
&mut decoded_value,
&mut decoded_timestamp,
);
assert_eq!(result, AlecResult::Ok);
assert!((decoded_value - original_value).abs() < 0.01);
alec_encoder_free(enc);
alec_decoder_free(dec);
}
#[test]
fn test_encoder_config_defaults_constants() {
assert_eq!(ALEC_DEFAULT_HISTORY_SIZE, 20);
assert_eq!(ALEC_DEFAULT_MAX_PATTERNS, 256);
assert_eq!(ALEC_DEFAULT_MAX_MEMORY_BYTES, 2048);
assert_eq!(ALEC_DEFAULT_KEYFRAME_INTERVAL, 50);
assert!(ALEC_DEFAULT_SMART_RESYNC);
let d = AlecEncoderConfig::defaults();
assert_eq!(d.history_size, ALEC_DEFAULT_HISTORY_SIZE);
assert_eq!(d.max_patterns, ALEC_DEFAULT_MAX_PATTERNS);
assert_eq!(d.max_memory_bytes, ALEC_DEFAULT_MAX_MEMORY_BYTES);
assert_eq!(d.keyframe_interval, ALEC_DEFAULT_KEYFRAME_INTERVAL);
assert!(d.smart_resync);
}
#[test]
fn test_encoder_new_with_config_null_uses_defaults() {
let enc = alec_encoder_new_with_config(ptr::null());
assert!(!enc.is_null());
let e = unsafe { &*enc };
assert_eq!(e.keyframe_interval, ALEC_DEFAULT_KEYFRAME_INTERVAL);
assert!(e.smart_resync);
assert!(!e.force_keyframe_pending);
assert_eq!(e.messages_since_keyframe, 0);
alec_encoder_free(enc);
}
#[test]
fn test_encoder_new_with_config_custom() {
let cfg = AlecEncoderConfig {
history_size: 10,
max_patterns: 128,
max_memory_bytes: 1024,
keyframe_interval: 25,
smart_resync: false,
num_channels: 0,
};
let enc = alec_encoder_new_with_config(&cfg);
assert!(!enc.is_null());
let e = unsafe { &*enc };
assert_eq!(e.keyframe_interval, 25);
assert!(!e.smart_resync);
alec_encoder_free(enc);
}
#[test]
fn test_encoder_new_with_config_zero_uses_defaults() {
let cfg = AlecEncoderConfig {
history_size: 0,
max_patterns: 0,
max_memory_bytes: 0,
keyframe_interval: 0, smart_resync: true,
num_channels: 0,
};
let enc = alec_encoder_new_with_config(&cfg);
assert!(!enc.is_null());
let e = unsafe { &*enc };
assert_eq!(e.keyframe_interval, 0);
let mut output = [0u8; 256];
let mut output_len: usize = 0;
let result = alec_encode_value(
enc,
22.5,
0,
ptr::null(),
output.as_mut_ptr(),
output.len(),
&mut output_len,
);
assert_eq!(result, AlecResult::Ok);
alec_encoder_free(enc);
}
#[test]
fn test_force_keyframe_sets_flag() {
let enc = alec_encoder_new();
assert!(!enc.is_null());
assert!(!unsafe { &*enc }.force_keyframe_pending);
alec_force_keyframe(enc);
assert!(unsafe { &*enc }.force_keyframe_pending);
alec_encoder_free(enc);
}
#[test]
fn test_force_keyframe_null_is_noop() {
alec_force_keyframe(ptr::null_mut());
}
#[test]
fn test_force_keyframe_respects_smart_resync_disabled() {
let cfg = AlecEncoderConfig {
history_size: 0,
max_patterns: 0,
max_memory_bytes: 0,
keyframe_interval: 50,
smart_resync: false,
num_channels: 0,
};
let enc = alec_encoder_new_with_config(&cfg);
alec_force_keyframe(enc);
assert!(!unsafe { &*enc }.force_keyframe_pending);
alec_encoder_free(enc);
}
#[test]
fn test_gap_detected_null_decoder() {
let mut gap: u8 = 42;
let detected = alec_decoder_gap_detected(ptr::null(), &mut gap);
assert!(!detected);
assert_eq!(gap, 0);
let detected2 = alec_decoder_gap_detected(ptr::null(), ptr::null_mut());
assert!(!detected2);
}
#[test]
fn test_gap_detected_fresh_decoder() {
let dec = alec_decoder_new();
let mut gap: u8 = 99;
let detected = alec_decoder_gap_detected(dec, &mut gap);
assert!(!detected);
assert_eq!(gap, 0);
alec_decoder_free(dec);
}
#[test]
fn test_gap_detected_after_dropped_frames() {
let enc = alec_encoder_new();
let dec = alec_decoder_new();
let values: [f64; 4] = [22.0, 22.5, 23.0, 22.8];
let mut frames: Vec<Vec<u8>> = Vec::new();
for _ in 0..5 {
let mut out = [0u8; 128];
let mut out_len = 0usize;
let res = alec_encode_multi(
enc,
values.as_ptr(),
values.len(),
ptr::null(),
ptr::null(),
ptr::null(),
out.as_mut_ptr(),
out.len(),
&mut out_len,
);
assert_eq!(res, AlecResult::Ok);
frames.push(out[..out_len].to_vec());
}
let mut vals = [0f64; 4];
let mut vcount: usize = 0;
let r0 = alec_decode_multi(
dec,
frames[0].as_ptr(),
frames[0].len(),
vals.as_mut_ptr(),
vals.len(),
&mut vcount,
);
assert_eq!(r0, AlecResult::Ok);
let mut gap: u8 = 0;
assert!(!alec_decoder_gap_detected(dec, &mut gap));
assert_eq!(gap, 0);
let r3 = alec_decode_multi(
dec,
frames[3].as_ptr(),
frames[3].len(),
vals.as_mut_ptr(),
vals.len(),
&mut vcount,
);
assert_eq!(r3, AlecResult::Ok);
let mut gap: u8 = 0;
assert!(alec_decoder_gap_detected(dec, &mut gap));
assert_eq!(gap, 2);
let r4 = alec_decode_multi(
dec,
frames[4].as_ptr(),
frames[4].len(),
vals.as_mut_ptr(),
vals.len(),
&mut vcount,
);
assert_eq!(r4, AlecResult::Ok);
let mut gap: u8 = 99;
assert!(!alec_decoder_gap_detected(dec, &mut gap));
assert_eq!(gap, 0);
alec_encoder_free(enc);
alec_decoder_free(dec);
}
#[test]
fn test_ffi_symbols_exist() {
let _new: extern "C" fn(*const AlecEncoderConfig) -> *mut AlecEncoder =
alec_encoder_new_with_config;
let _force: extern "C" fn(*mut AlecEncoder) = alec_force_keyframe;
let _gap: extern "C" fn(*const AlecDecoder, *mut u8) -> bool = alec_decoder_gap_detected;
let _enc_fixed: extern "C" fn(
*mut AlecEncoder,
*const f64,
usize,
*mut u8,
usize,
*mut usize,
) -> AlecResult = alec_encode_multi_fixed;
let _dec_fixed: extern "C" fn(
*mut AlecDecoder,
*const u8,
usize,
*mut f64,
usize,
*mut usize,
*mut u16,
*mut bool,
) -> AlecResult = alec_decode_multi_fixed;
let _dec_new_cfg: extern "C" fn(*const AlecEncoderConfig) -> *mut AlecDecoder =
alec_decoder_new_with_config;
let _dec_reset: extern "C" fn(*mut AlecDecoder) = alec_decoder_reset;
let _ctx_save: extern "C" fn(*const AlecDecoder, *mut u8, usize, *mut usize) -> AlecResult =
alec_decoder_context_save;
let _ctx_load: extern "C" fn(*mut AlecDecoder, *const u8, usize) -> AlecResult =
alec_decoder_context_load;
}
fn em500_co2_dataset() -> Vec<[f64; 5]> {
const N: usize = 99;
let mut out = Vec::with_capacity(N);
for i in 0..N {
let battery = 3.60 - 0.01 * ((i / 33) as f64);
let temp_step = if i % 8 < 4 { 0.01 } else { 0.00 };
let temperature = 22.50 + temp_step;
let humidity = 45.0 + 0.1 * ((i / 7) % 3) as f64;
let co2 = 420.0 + (i / 3) as f64;
let pressure = 1013.25 + 0.01 * ((i / 11) % 3) as f64;
out.push([battery, temperature, humidity, co2, pressure]);
}
out
}
fn encode_decode_dataset(
data: &[[f64; 5]],
cfg: Option<AlecEncoderConfig>,
) -> (Vec<Vec<u8>>, Vec<[f64; 5]>) {
let enc = match cfg {
Some(c) => alec_encoder_new_with_config(&c),
None => alec_encoder_new(),
};
let dec = alec_decoder_new();
let mut frames = Vec::with_capacity(data.len());
let mut decoded = Vec::with_capacity(data.len());
let mut out = [0u8; 128];
let mut out_len: usize = 0;
let mut values = [0f64; 5];
for row in data {
let r = alec_encode_multi_fixed(
enc,
row.as_ptr(),
row.len(),
out.as_mut_ptr(),
out.len(),
&mut out_len,
);
assert_eq!(r, AlecResult::Ok);
let frame = out[..out_len].to_vec();
let r2 = alec_decode_multi_fixed(
dec,
frame.as_ptr(),
frame.len(),
values.as_mut_ptr(),
values.len(),
ptr::null_mut(),
ptr::null_mut(),
ptr::null_mut(),
);
assert_eq!(
r2,
AlecResult::Ok,
"decode failed at frame {}",
frames.len()
);
frames.push(frame);
decoded.push(values);
}
alec_encoder_free(enc);
alec_decoder_free(dec);
(frames, decoded)
}
#[test]
fn test_encode_decode_fixed_roundtrip_5ch() {
let data = em500_co2_dataset();
let (_frames, decoded) = encode_decode_dataset(&data, None);
assert_eq!(decoded.len(), data.len());
let max_drift = [0.01_f64, 0.01, 0.1, 1.0, 0.01];
for (i, (src, dst)) in data.iter().zip(decoded.iter()).enumerate() {
for ch in 0..5 {
let diff = (src[ch] - dst[ch]).abs();
assert!(
diff <= max_drift[ch] + 1e-9,
"frame {} ch {}: expected {}, got {}, diff {} (max {})",
i,
ch,
src[ch],
dst[ch],
diff,
max_drift[ch]
);
}
}
}
#[test]
fn test_fixed_header_11b_ceiling() {
let data = em500_co2_dataset();
let cfg = AlecEncoderConfig {
history_size: 0,
max_patterns: 0,
max_memory_bytes: 0,
keyframe_interval: 10_000,
smart_resync: false,
num_channels: 0,
};
let (frames, _decoded) = encode_decode_dataset(&data, Some(cfg));
let warmup = 8;
for (i, frame) in frames.iter().enumerate().skip(warmup) {
assert!(
frame.len() <= 11,
"frame #{} was {} bytes > 11B ceiling",
i,
frame.len()
);
}
}
#[test]
fn test_cold_start_first_frame() {
let data = em500_co2_dataset();
let enc = alec_encoder_new();
let mut out = [0u8; 64];
let mut out_len: usize = 0;
let r = alec_encode_multi_fixed(
enc,
data[0].as_ptr(),
data[0].len(),
out.as_mut_ptr(),
out.len(),
&mut out_len,
);
assert_eq!(r, AlecResult::Ok);
assert_eq!(out_len, 27, "cold-start frame should be 27B");
assert!(out_len > 11, "cold-start frame must exceed 11B ceiling");
assert_eq!(out[0], 0xA1);
alec_encoder_free(enc);
}
#[test]
fn test_ctx_ver_wraparound() {
let enc = alec_encoder_new();
let dec = alec_decoder_new();
unsafe {
(*enc).context.set_version(65530);
(*dec).context.set_version(65530);
}
let row = [3.6, 22.5, 45.0, 420.0, 1013.25];
let mut out = [0u8; 64];
let mut out_len: usize = 0;
let mut values = [0f64; 5];
let mut seen_pre_wrap = false;
let mut seen_post_wrap = false;
for i in 0..10 {
let r = alec_encode_multi_fixed(
enc,
row.as_ptr(),
row.len(),
out.as_mut_ptr(),
out.len(),
&mut out_len,
);
assert_eq!(r, AlecResult::Ok);
let cv = u16::from_be_bytes([out[3], out[4]]);
if cv > 60_000 {
seen_pre_wrap = true;
}
if cv < 1_000 {
seen_post_wrap = true;
}
let r2 = alec_decode_multi_fixed(
dec,
out.as_ptr(),
out_len,
values.as_mut_ptr(),
values.len(),
ptr::null_mut(),
ptr::null_mut(),
ptr::null_mut(),
);
assert_eq!(
r2,
AlecResult::Ok,
"decode failed at wrap boundary, frame {}",
i
);
}
assert!(seen_pre_wrap, "never observed a ctx_ver near the wrap edge");
assert!(seen_post_wrap, "ctx_ver never wrapped to a low value");
alec_encoder_free(enc);
alec_decoder_free(dec);
}
#[test]
fn test_marker_byte_dispatch() {
let data = em500_co2_dataset();
let enc = alec_encoder_new();
let dec = alec_decoder_new();
let mut out = [0u8; 64];
let mut out_len: usize = 0;
let r = alec_encode_multi_fixed(
enc,
data[0].as_ptr(),
data[0].len(),
out.as_mut_ptr(),
out.len(),
&mut out_len,
);
assert_eq!(r, AlecResult::Ok);
assert_eq!(out[0], 0xA1);
let mut values = [0f64; 5];
let r_ok = alec_decode_multi_fixed(
dec,
out.as_ptr(),
out_len,
values.as_mut_ptr(),
values.len(),
ptr::null_mut(),
ptr::null_mut(),
ptr::null_mut(),
);
assert_eq!(r_ok, AlecResult::Ok);
let mut corrupt = out[..out_len].to_vec();
corrupt[0] = 0x5A;
let r_err = alec_decode_multi_fixed(
alec_decoder_new(), corrupt.as_ptr(),
corrupt.len(),
values.as_mut_ptr(),
values.len(),
ptr::null_mut(),
ptr::null_mut(),
ptr::null_mut(),
);
assert_eq!(r_err, AlecResult::ErrorInvalidInput);
alec_encoder_free(enc);
alec_decoder_free(dec);
}
#[test]
fn test_keyframe_forced_at_interval() {
let cfg = AlecEncoderConfig {
history_size: 0,
max_patterns: 0,
max_memory_bytes: 0,
keyframe_interval: 10,
smart_resync: true,
num_channels: 0,
};
let enc = alec_encoder_new_with_config(&cfg);
let row = [3.6, 22.5, 45.0, 420.0, 1013.25];
let mut out = [0u8; 64];
let mut out_len: usize = 0;
let mut frames: Vec<(usize, u8)> = Vec::new();
for _ in 0..25 {
let r = alec_encode_multi_fixed(
enc,
row.as_ptr(),
row.len(),
out.as_mut_ptr(),
out.len(),
&mut out_len,
);
assert_eq!(r, AlecResult::Ok);
frames.push((out_len, out[0]));
}
let keyframe_indices: Vec<usize> = frames
.iter()
.enumerate()
.filter(|(_, (_, m))| *m == 0xA2)
.map(|(i, _)| i)
.collect();
assert_eq!(keyframe_indices, vec![10, 20]);
for (i, (len, marker)) in frames.iter().enumerate() {
if *marker == 0xA2 {
assert_eq!(*len, 27, "keyframe at #{} should be 27B, got {}", i, *len);
} else {
assert_eq!(*marker, 0xA1);
if i == 0 {
assert_eq!(*len, 27);
} else {
assert!(*len <= 11, "data frame at #{} is {} bytes > 11B", i, *len);
}
}
}
alec_encoder_free(enc);
}
#[test]
#[ignore]
fn diag_fixed_sizes() {
let data = em500_co2_dataset();
let cfg = AlecEncoderConfig {
history_size: 0,
max_patterns: 0,
max_memory_bytes: 0,
keyframe_interval: 10_000,
smart_resync: false,
num_channels: 0,
};
let (frames, _) = encode_decode_dataset(&data, Some(cfg));
let mut counts = [0u32; 4]; for frame in &frames {
let b0 = frame[5];
let b1 = frame[6];
for i in 0..5 {
let bits = if i < 4 { (b0 >> (i * 2)) & 3 } else { b1 & 3 };
counts[bits as usize] += 1;
}
}
let total_ch = 99 * 5;
println!("\n=== FIXED-CHANNEL DIAGNOSTIC ===");
let sizes: Vec<usize> = frames.iter().map(|f| f.len()).collect();
let total: usize = sizes.iter().sum();
println!(
"99 frames: total={} avg={:.2} B/frame min={} max={}",
total,
total as f64 / 99.0,
sizes.iter().min().unwrap(),
sizes.iter().max().unwrap()
);
let warm = 8;
let steady: Vec<usize> = sizes[warm..].to_vec();
let stotal: usize = steady.iter().sum();
println!(
"steady (frame>={}): total={} avg={:.2} B/frame max={}",
warm,
stotal,
stotal as f64 / steady.len() as f64,
steady.iter().max().unwrap()
);
let labels = ["Repeated", "Delta8", "Delta16", "Raw32"];
println!("encoding distribution across {} channels:", total_ch);
for i in 0..4 {
println!(
" {:10}: {:4} ({:.1}%)",
labels[i],
counts[i],
100.0 * counts[i] as f64 / total_ch as f64
);
}
let idx = 30;
println!(
"Frame #{}: {} bytes = {:02X?}",
idx,
frames[idx].len(),
&frames[idx][..]
);
}
#[test]
fn test_force_keyframe_ffi() {
let cfg = AlecEncoderConfig {
history_size: 0,
max_patterns: 0,
max_memory_bytes: 0,
keyframe_interval: 10_000, smart_resync: true,
num_channels: 0,
};
let enc = alec_encoder_new_with_config(&cfg);
let row = [3.6, 22.5, 45.0, 420.0, 1013.25];
let mut out = [0u8; 64];
let mut out_len: usize = 0;
for _ in 0..5 {
let r = alec_encode_multi_fixed(
enc,
row.as_ptr(),
row.len(),
out.as_mut_ptr(),
out.len(),
&mut out_len,
);
assert_eq!(r, AlecResult::Ok);
}
assert_eq!(out[0], 0xA1);
let warm_len = out_len;
assert!(
warm_len <= 11,
"warm frame should be <=11B, got {}",
warm_len
);
alec_force_keyframe(enc);
let r = alec_encode_multi_fixed(
enc,
row.as_ptr(),
row.len(),
out.as_mut_ptr(),
out.len(),
&mut out_len,
);
assert_eq!(r, AlecResult::Ok);
assert_eq!(out[0], 0xA2, "forced frame must carry the keyframe marker");
assert_eq!(
out_len, 27,
"forced keyframe must be Raw32 for all channels"
);
let r = alec_encode_multi_fixed(
enc,
row.as_ptr(),
row.len(),
out.as_mut_ptr(),
out.len(),
&mut out_len,
);
assert_eq!(r, AlecResult::Ok);
assert_eq!(out[0], 0xA1, "post-keyframe frame must be a data frame");
assert!(
out_len <= 11,
"post-keyframe frame should be <=11B, got {}",
out_len
);
alec_encoder_free(enc);
}
fn new_pair(keyframe_interval: u32) -> (*mut AlecEncoder, *mut AlecDecoder) {
let cfg = AlecEncoderConfig {
history_size: 0,
max_patterns: 0,
max_memory_bytes: 0,
keyframe_interval,
smart_resync: true,
num_channels: 0,
};
(alec_encoder_new_with_config(&cfg), alec_decoder_new())
}
fn do_encode(enc: *mut AlecEncoder, row: &[f64; 5], out: &mut [u8; 64]) -> usize {
let mut n: usize = 0;
let r = alec_encode_multi_fixed(
enc,
row.as_ptr(),
row.len(),
out.as_mut_ptr(),
out.len(),
&mut n,
);
assert_eq!(r, AlecResult::Ok);
n
}
fn do_decode(dec: *mut AlecDecoder, frame: &[u8]) -> [f64; 5] {
let mut values = [0f64; 5];
let r = alec_decode_multi_fixed(
dec,
frame.as_ptr(),
frame.len(),
values.as_mut_ptr(),
values.len(),
ptr::null_mut(),
ptr::null_mut(),
ptr::null_mut(),
);
assert_eq!(r, AlecResult::Ok);
values
}
#[test]
fn test_reset_to_baseline_wipes_stats() {
let (enc, _dec) = new_pair(10_000); let row = [3.60, 22.50, 45.0, 420.0, 1013.25];
let mut out = [0u8; 64];
for _ in 0..20 {
do_encode(enc, &row, &mut out);
}
let e = unsafe { &*enc };
assert!(e.context.last_value(1).is_some());
assert!(e.context.last_value(5).is_some());
let pre_version = e.context.version();
unsafe { &mut *enc }.context.reset_to_baseline();
let e = unsafe { &*enc };
assert!(e.context.last_value(1).is_none());
assert!(e.context.last_value(5).is_none());
assert_eq!(e.context.version(), pre_version);
let n = do_encode(enc, &row, &mut out);
assert_eq!(n, 27, "post-reset frame must be Raw32-all-channels (27 B)");
assert_eq!(out[0], 0xA1);
let b0 = out[5];
let b1 = out[6];
assert_eq!(b0, 0b1111_1111);
assert_eq!(b1 & 0b11, 0b11);
alec_encoder_free(enc);
}
#[test]
fn test_packet_loss_recovery_at_keyframe() {
let (enc, dec) = new_pair(10);
let row = [3.60, 22.50, 45.0, 420.0, 1013.25];
let mut out = [0u8; 64];
let mut frames: Vec<Vec<u8>> = Vec::new();
for _ in 0..=20 {
let n = do_encode(enc, &row, &mut out);
frames.push(out[..n].to_vec());
}
assert_eq!(frames[10][0], 0xA2, "frame 10 must be a keyframe");
assert_eq!(frames[20][0], 0xA2, "frame 20 must be a keyframe");
for f in &frames[0..=14] {
do_decode(dec, f);
}
do_decode(dec, &frames[19]);
let mut gap: u8 = 0;
assert!(alec_decoder_gap_detected(dec, &mut gap));
assert_eq!(gap, 4, "decoder must report 4-frame gap");
let values_20 = do_decode(dec, &frames[20]);
for (ch, &v) in row.iter().enumerate() {
let tol = [0.01_f64, 0.01, 0.1, 1.0, 0.01][ch];
assert!(
(v - values_20[ch]).abs() <= tol,
"ch {}: expected {}, got {}",
ch,
v,
values_20[ch]
);
}
alec_encoder_free(enc);
alec_decoder_free(dec);
}
#[test]
fn test_no_silent_corruption() {
let (enc, dec) = new_pair(50);
let mut out = [0u8; 64];
let mut frames: Vec<Vec<u8>> = Vec::new();
let rows: Vec<[f64; 5]> = (0..100)
.map(|i| [3.60, 22.50, 45.0, 420.0 + (i / 3) as f64, 1013.25])
.collect();
for row in &rows {
let n = do_encode(enc, row, &mut out);
frames.push(out[..n].to_vec());
}
for f in &frames[0..=19] {
do_decode(dec, f);
}
for f in &frames[21..50] {
let mut v = [0f64; 5];
let _ = alec_decode_multi_fixed(
dec,
f.as_ptr(),
f.len(),
v.as_mut_ptr(),
v.len(),
ptr::null_mut(),
ptr::null_mut(),
ptr::null_mut(),
);
}
let values_50 = do_decode(dec, &frames[50]);
assert_eq!(frames[50][0], 0xA2);
let expected = rows[50];
let tols = [0.01_f64, 0.01, 0.1, 1.0, 0.01];
for ch in 0..5 {
assert!(
(expected[ch] - values_50[ch]).abs() <= tols[ch] + 1e-9,
"ch {} at frame 50: expected {}, got {}",
ch,
expected[ch],
values_50[ch]
);
}
for i in 51..=60 {
let values = do_decode(dec, &frames[i]);
for ch in 0..5 {
assert!(
(rows[i][ch] - values[ch]).abs() <= tols[ch] + 1e-9,
"ch {} at frame {}: expected {}, got {}",
ch,
i,
rows[i][ch],
values[ch]
);
}
}
alec_encoder_free(enc);
alec_decoder_free(dec);
}
#[test]
fn test_smart_resync_downlink() {
let (enc, dec) = new_pair(10_000); let row = [3.60, 22.50, 45.0, 420.0, 1013.25];
let mut out = [0u8; 64];
let mut frames: Vec<Vec<u8>> = Vec::new();
for _ in 0..10 {
let n = do_encode(enc, &row, &mut out);
frames.push(out[..n].to_vec());
}
for f in &frames[0..=4] {
do_decode(dec, f);
}
for f in &frames[6..=9] {
let mut v = [0f64; 5];
let _ = alec_decode_multi_fixed(
dec,
f.as_ptr(),
f.len(),
v.as_mut_ptr(),
v.len(),
ptr::null_mut(),
ptr::null_mut(),
ptr::null_mut(),
);
}
let cmd = [0xFF_u8];
let r = alec_downlink_handler(enc, cmd.as_ptr(), cmd.len());
assert_eq!(r, AlecResult::Ok);
assert!(
unsafe { &*enc }.force_keyframe_pending,
"downlink 0xFF must arm the force-keyframe flag"
);
let n = do_encode(enc, &row, &mut out);
assert_eq!(out[0], 0xA2, "post-downlink frame must be a keyframe");
assert_eq!(n, 27);
let values = do_decode(dec, &out[..n]);
let tols = [0.01_f64, 0.01, 0.1, 1.0, 0.01];
for ch in 0..5 {
assert!(
(row[ch] - values[ch]).abs() <= tols[ch] + 1e-9,
"ch {}: expected {}, got {}",
ch,
row[ch],
values[ch]
);
}
alec_encoder_free(enc);
alec_decoder_free(dec);
}
#[test]
fn test_downlink_handler_invalid_command() {
let enc = alec_encoder_new();
assert!(!unsafe { &*enc }.force_keyframe_pending);
let cmd = [0x00_u8];
let r = alec_downlink_handler(enc, cmd.as_ptr(), cmd.len());
assert_eq!(r, AlecResult::ErrorInvalidInput);
assert!(
!unsafe { &*enc }.force_keyframe_pending,
"unknown downlink must NOT arm the force-keyframe flag"
);
let cmd = [0x7E_u8, 0xFF, 0xAA];
let r = alec_downlink_handler(enc, cmd.as_ptr(), cmd.len());
assert_eq!(r, AlecResult::ErrorInvalidInput);
assert!(!unsafe { &*enc }.force_keyframe_pending);
assert_eq!(
alec_downlink_handler(ptr::null_mut(), cmd.as_ptr(), cmd.len()),
AlecResult::ErrorNullPointer
);
assert_eq!(
alec_downlink_handler(enc, ptr::null(), 1),
AlecResult::ErrorNullPointer
);
assert_eq!(
alec_downlink_handler(enc, cmd.as_ptr(), 0),
AlecResult::ErrorInvalidInput
);
alec_encoder_free(enc);
}
#[test]
fn test_context_mismatch_triggers_reset() {
let (enc, dec) = new_pair(10);
let row = [3.60, 22.50, 45.0, 420.0, 1013.25];
let mut out = [0u8; 64];
let mut frames: Vec<Vec<u8>> = Vec::new();
for _ in 0..=11 {
let n = do_encode(enc, &row, &mut out);
frames.push(out[..n].to_vec());
}
for f in &frames[0..=8] {
do_decode(dec, f);
}
unsafe { &mut *dec }.decoder.reset();
do_decode(dec, &frames[8]);
let mut tampered = frames[9].clone();
tampered[3] = 0x12;
tampered[4] = 0x34;
use alec::context::PredictionModel;
let model_before = unsafe { &*dec }.context.predict(1).unwrap().model_type;
assert_eq!(model_before, PredictionModel::MovingAverage);
let mut v = [0f64; 5];
let _ = alec_decode_multi_fixed(
dec,
tampered.as_ptr(),
tampered.len(),
v.as_mut_ptr(),
v.len(),
ptr::null_mut(),
ptr::null_mut(),
ptr::null_mut(),
);
let model_after = unsafe { &*dec }.context.predict(1).unwrap().model_type;
assert_eq!(
model_after,
PredictionModel::LastValue,
"reset_to_baseline should have dropped source_stats count below the \
MovingAverage threshold (count < 3)"
);
let values_10 = do_decode(dec, &frames[10]);
assert_eq!(frames[10][0], 0xA2);
let tols = [0.01_f64, 0.01, 0.1, 1.0, 0.01];
for ch in 0..5 {
assert!(
(row[ch] - values_10[ch]).abs() <= tols[ch] + 1e-9,
"ch {}: expected {}, got {}",
ch,
row[ch],
values_10[ch]
);
}
alec_encoder_free(enc);
alec_decoder_free(dec);
}
const SENSOR_TYPE: &[u8] = b"em500-co2\0";
fn drive_pair(enc: *mut AlecEncoder, dec: *mut AlecDecoder, rows: &[[f64; 5]]) -> Vec<Vec<u8>> {
let mut out = [0u8; 64];
let mut out_len: usize = 0;
let mut values = [0f64; 5];
let mut frames = Vec::with_capacity(rows.len());
for row in rows {
let r = alec_encode_multi_fixed(
enc,
row.as_ptr(),
row.len(),
out.as_mut_ptr(),
out.len(),
&mut out_len,
);
assert_eq!(r, AlecResult::Ok);
let frame = out[..out_len].to_vec();
let r2 = alec_decode_multi_fixed(
dec,
frame.as_ptr(),
frame.len(),
values.as_mut_ptr(),
values.len(),
ptr::null_mut(),
ptr::null_mut(),
ptr::null_mut(),
);
assert_eq!(r2, AlecResult::Ok);
frames.push(frame);
}
frames
}
#[test]
fn test_context_roundtrip_in_memory() {
let rows: Vec<[f64; 5]> = (0..30)
.map(|i| [3.60, 22.50, 45.0, 420.0 + (i / 3) as f64, 1013.25])
.collect();
let cfg = AlecEncoderConfig {
history_size: 0,
max_patterns: 0,
max_memory_bytes: 0,
keyframe_interval: 10_000, smart_resync: false,
num_channels: 0,
};
let enc = alec_encoder_new_with_config(&cfg);
let dec_orig = alec_decoder_new();
let _ = drive_pair(enc, dec_orig, &rows);
let mut size: usize = 0;
let r = alec_decoder_export_state_size(
dec_orig,
SENSOR_TYPE.as_ptr() as *const c_char,
&mut size,
);
assert_eq!(r, AlecResult::Ok);
assert!(size > 0 && size < 3072, "export size {} out of range", size);
let mut buf = vec![0u8; size];
let mut written: usize = 0;
let r = alec_decoder_export_state(
dec_orig,
SENSOR_TYPE.as_ptr() as *const c_char,
buf.as_mut_ptr(),
buf.len(),
&mut written,
);
assert_eq!(r, AlecResult::Ok);
assert_eq!(written, size);
let dec_new = alec_decoder_new();
let r = alec_decoder_import_state(dec_new, buf.as_ptr(), buf.len());
assert_eq!(r, AlecResult::Ok);
let more: Vec<[f64; 5]> = (30..40)
.map(|i| [3.60, 22.50, 45.0, 420.0 + (i / 3) as f64, 1013.25])
.collect();
let mut out = [0u8; 64];
let mut out_len: usize = 0;
for row in &more {
let r = alec_encode_multi_fixed(
enc,
row.as_ptr(),
row.len(),
out.as_mut_ptr(),
out.len(),
&mut out_len,
);
assert_eq!(r, AlecResult::Ok);
let frame = &out[..out_len];
let mut v_orig = [0f64; 5];
let mut v_new = [0f64; 5];
assert_eq!(
alec_decode_multi_fixed(
dec_orig,
frame.as_ptr(),
frame.len(),
v_orig.as_mut_ptr(),
v_orig.len(),
ptr::null_mut(),
ptr::null_mut(),
ptr::null_mut(),
),
AlecResult::Ok
);
assert_eq!(
alec_decode_multi_fixed(
dec_new,
frame.as_ptr(),
frame.len(),
v_new.as_mut_ptr(),
v_new.len(),
ptr::null_mut(),
ptr::null_mut(),
ptr::null_mut(),
),
AlecResult::Ok
);
for ch in 0..5 {
assert_eq!(
v_orig[ch].to_bits(),
v_new[ch].to_bits(),
"ch {} diverged between original and restored decoder",
ch
);
}
}
alec_encoder_free(enc);
alec_decoder_free(dec_orig);
alec_decoder_free(dec_new);
}
#[test]
fn test_export_state_size_matches_export() {
let enc = alec_encoder_new();
let dec = alec_decoder_new();
let rows: Vec<[f64; 5]> = (0..12)
.map(|_| [3.60, 22.50, 45.0, 420.0, 1013.25])
.collect();
let _ = drive_pair(enc, dec, &rows);
let mut size: usize = 0;
let r =
alec_decoder_export_state_size(dec, SENSOR_TYPE.as_ptr() as *const c_char, &mut size);
assert_eq!(r, AlecResult::Ok);
let mut buf = vec![0u8; size];
let mut written: usize = 0;
let r = alec_decoder_export_state(
dec,
SENSOR_TYPE.as_ptr() as *const c_char,
buf.as_mut_ptr(),
buf.len(),
&mut written,
);
assert_eq!(r, AlecResult::Ok);
assert_eq!(written, size);
alec_encoder_free(enc);
alec_decoder_free(dec);
}
#[test]
fn test_export_buffer_too_small() {
let enc = alec_encoder_new();
let dec = alec_decoder_new();
let rows: Vec<[f64; 5]> = (0..8)
.map(|_| [3.60, 22.50, 45.0, 420.0, 1013.25])
.collect();
let _ = drive_pair(enc, dec, &rows);
let mut buf = [0xAAu8; 10];
let mut written: usize = 0;
let r = alec_decoder_export_state(
dec,
SENSOR_TYPE.as_ptr() as *const c_char,
buf.as_mut_ptr(),
buf.len(),
&mut written,
);
assert_eq!(r, AlecResult::ErrorBufferTooSmall);
assert!(
written > buf.len(),
"expected *out_len to report required size, got {}",
written
);
for (i, &b) in buf.iter().enumerate() {
assert_eq!(b, 0xAA, "buf[{}] was written despite error", i);
}
alec_encoder_free(enc);
alec_decoder_free(dec);
}
#[test]
fn test_import_corrupt_data() {
let enc = alec_encoder_new();
let dec = alec_decoder_new();
let rows: Vec<[f64; 5]> = (0..8)
.map(|_| [3.60, 22.50, 45.0, 420.0, 1013.25])
.collect();
let _ = drive_pair(enc, dec, &rows);
let mut snap = vec![0u8; 4096];
let mut snap_len: usize = 0;
assert_eq!(
alec_decoder_export_state(
dec,
SENSOR_TYPE.as_ptr() as *const c_char,
snap.as_mut_ptr(),
snap.len(),
&mut snap_len,
),
AlecResult::Ok
);
let snap_pre = snap[..snap_len].to_vec();
let garbage = [0x00u8, 0x11, 0x22, 0x33, 0x44, 0x55];
let r = alec_decoder_import_state(dec, garbage.as_ptr(), garbage.len());
assert_eq!(r, AlecResult::ErrorCorruptData);
let mut tampered = snap_pre.clone();
let mid = tampered.len() / 2;
tampered[mid] ^= 0xFF;
let r = alec_decoder_import_state(dec, tampered.as_ptr(), tampered.len());
assert_eq!(r, AlecResult::ErrorCorruptData);
let mut snap2 = vec![0u8; 4096];
let mut snap2_len: usize = 0;
assert_eq!(
alec_decoder_export_state(
dec,
SENSOR_TYPE.as_ptr() as *const c_char,
snap2.as_mut_ptr(),
snap2.len(),
&mut snap2_len,
),
AlecResult::Ok
);
assert_eq!(snap2_len, snap_len);
assert_eq!(&snap2[..snap2_len], &snap_pre[..]);
alec_encoder_free(enc);
alec_decoder_free(dec);
}
#[test]
fn test_session_state_preserved_on_import() {
let enc = alec_encoder_new();
let dec = alec_decoder_new();
let rows: Vec<[f64; 5]> = (0..5)
.map(|_| [3.60, 22.50, 45.0, 420.0, 1013.25])
.collect();
let _ = drive_pair(enc, dec, &rows);
unsafe {
(*dec).last_header_sequence = Some(42);
(*dec).last_gap_size = 2;
}
let mut buf = vec![0u8; 4096];
let mut n: usize = 0;
assert_eq!(
alec_decoder_export_state(
dec,
SENSOR_TYPE.as_ptr() as *const c_char,
buf.as_mut_ptr(),
buf.len(),
&mut n,
),
AlecResult::Ok
);
assert_eq!(
alec_decoder_import_state(dec, buf.as_ptr(), n),
AlecResult::Ok
);
let dec_ref = unsafe { &*dec };
assert_eq!(dec_ref.last_header_sequence, Some(42));
assert_eq!(dec_ref.last_gap_size, 2);
alec_encoder_free(enc);
alec_decoder_free(dec);
}
#[test]
fn test_export_after_reset_to_baseline() {
let enc = alec_encoder_new();
let dec = alec_decoder_new();
let rows: Vec<[f64; 5]> = (0..30)
.map(|_| [3.60, 22.50, 45.0, 420.0, 1013.25])
.collect();
let _ = drive_pair(enc, dec, &rows);
use alec::context::Pattern;
let code = unsafe { &mut *dec }
.context
.register_pattern(Pattern::new(vec![0x11, 0x22, 0x33]))
.unwrap();
unsafe { &mut *dec }.context.reset_to_baseline();
let mut buf = vec![0u8; 4096];
let mut n: usize = 0;
assert_eq!(
alec_decoder_export_state(
dec,
SENSOR_TYPE.as_ptr() as *const c_char,
buf.as_mut_ptr(),
buf.len(),
&mut n,
),
AlecResult::Ok
);
let dec_fresh = alec_decoder_new();
assert_eq!(
alec_decoder_import_state(dec_fresh, buf.as_ptr(), n),
AlecResult::Ok
);
let d = unsafe { &*dec_fresh };
assert!(d.context.predict(1).is_none());
assert!(d.context.predict(5).is_none());
assert!(d.context.get_pattern(code).is_some());
alec_encoder_free(enc);
alec_decoder_free(dec);
alec_decoder_free(dec_fresh);
}
#[test]
fn test_persistence_ffi_null_safety() {
use std::ptr;
let dec = alec_decoder_new();
let mut n: usize = 0;
let mut buf = [0u8; 4];
assert_eq!(
alec_decoder_export_state_size(
ptr::null(),
SENSOR_TYPE.as_ptr() as *const c_char,
&mut n
),
AlecResult::ErrorNullPointer
);
assert_eq!(
alec_decoder_export_state_size(dec, ptr::null(), &mut n),
AlecResult::ErrorNullPointer
);
assert_eq!(
alec_decoder_export_state_size(
dec,
SENSOR_TYPE.as_ptr() as *const c_char,
ptr::null_mut()
),
AlecResult::ErrorNullPointer
);
assert_eq!(
alec_decoder_export_state(
ptr::null(),
SENSOR_TYPE.as_ptr() as *const c_char,
buf.as_mut_ptr(),
buf.len(),
&mut n,
),
AlecResult::ErrorNullPointer
);
assert_eq!(
alec_decoder_import_state(ptr::null_mut(), buf.as_ptr(), buf.len()),
AlecResult::ErrorNullPointer
);
assert_eq!(
alec_decoder_import_state(dec, ptr::null(), buf.len()),
AlecResult::ErrorNullPointer
);
alec_decoder_free(dec);
}
}