// modulate header
void ofdmflexframegen_modulate_header(ofdmflexframegen _q)
{
// repack 8-bit header bytes into 'bps'-bit payload symbols
unsigned int bps = modulation_types[OFDMFLEXFRAME_H_MOD].bps;
unsigned int num_written;
liquid_repack_bytes(_q->header_enc, 8, OFDMFLEXFRAME_H_ENC,
_q->header_mod, bps, OFDMFLEXFRAME_H_SYM,
&num_written);
}
// decode payload
void flexframesync_decode_payload(flexframesync _q)
{
// pack (8-bit) bytes from (bps_payload-bit) symbols
unsigned int num_written;
liquid_repack_bytes(_q->payload_mod, _q->bps_payload, _q->payload_mod_len,
_q->payload_enc, 8, _q->payload_enc_len+8,
&num_written);
// unscramble
unscramble_data(_q->payload_enc, _q->payload_enc_len);
// decode payload
_q->payload_valid = packetizer_decode(_q->p_payload,
_q->payload_enc,
_q->payload_dec);
}
// assemble a frame from an array of data
// _q : OFDM frame generator object
// _header : frame header
// _payload : payload data [size: _payload_len x 1]
// _payload_len : payload data length
void ofdmflexframegen_assemble(ofdmflexframegen _q,
unsigned char * _header,
unsigned char * _payload,
unsigned int _payload_len)
{
// check payload length and reconfigure if necessary
if (_payload_len != _q->payload_dec_len) {
_q->payload_dec_len = _payload_len;
ofdmflexframegen_reconfigure(_q);
}
// set assembled flag
_q->frame_assembled = 1;
// copy user-defined header data
memmove(_q->header, _header, OFDMFLEXFRAME_H_USER*sizeof(unsigned char));
// encode full header
ofdmflexframegen_encode_header(_q);
// modulate header
ofdmflexframegen_modulate_header(_q);
// encode payload
packetizer_encode(_q->p_payload, _payload, _q->payload_enc);
//
// pack modem symbols
//
// clear payload
memset(_q->payload_mod, 0x00, _q->payload_mod_len);
// repack 8-bit payload bytes into 'bps'-bit payload symbols
unsigned int bps = modulation_types[_q->props.mod_scheme].bps;
unsigned int num_written;
liquid_repack_bytes(_q->payload_enc, 8, _q->payload_enc_len,
_q->payload_mod, bps, _q->payload_mod_len,
&num_written);
#if DEBUG_OFDMFLEXFRAMEGEN
printf("wrote %u symbols (expected %u)\n", num_written, _q->payload_mod_len);
#endif
}
// decode header
void ofdmflexframesync_decode_header(ofdmflexframesync _q)
{
#if OFDMFLEXFRAME_H_SOFT
# if 0
unsigned int i;
// copy soft bits
for (i=0; i<8*OFDMFLEXFRAME_H_ENC; i++)
_q->header_enc[i] = _q->header_mod[i];
# else
// TODO: ensure lengths are the same
memmove(_q->header_enc, _q->header_mod, 8*OFDMFLEXFRAME_H_ENC);
# endif
// unscramble header using soft bits
unscramble_data_soft(_q->header_enc, OFDMFLEXFRAME_H_ENC);
// run packet decoder
_q->header_valid = packetizer_decode_soft(_q->p_header, _q->header_enc, _q->header);
#else
// pack 1-bit header symbols into 8-bit bytes
unsigned int num_written;
liquid_repack_bytes(_q->header_mod, OFDMFLEXFRAME_H_BPS, OFDMFLEXFRAME_H_SYM,
_q->header_enc, 8, OFDMFLEXFRAME_H_ENC,
&num_written);
assert(num_written==OFDMFLEXFRAME_H_ENC);
// unscramble header
unscramble_data(_q->header_enc, OFDMFLEXFRAME_H_ENC);
// run packet decoder
_q->header_valid = packetizer_decode(_q->p_header, _q->header_enc, _q->header);
#endif
#if 0
// print header
printf("header rx (enc) : ");
for (i=0; i<OFDMFLEXFRAME_H_ENC; i++)
printf("%.2X ", _q->header_enc[i]);
printf("\n");
// print header
printf("header rx (dec) : ");
for (i=0; i<OFDMFLEXFRAME_H_DEC; i++)
printf("%.2X ", _q->header[i]);
printf("\n");
#endif
#if DEBUG_OFDMFLEXFRAMESYNC
printf("****** header extracted [%s]\n", _q->header_valid ? "valid" : "INVALID!");
#endif
if (!_q->header_valid)
return;
unsigned int n = OFDMFLEXFRAME_H_USER;
// first byte is for expansion/version validation
if (_q->header[n+0] != OFDMFLEXFRAME_PROTOCOL) {
fprintf(stderr,"warning: ofdmflexframesync_decode_header(), invalid framing version\n");
_q->header_valid = 0;
}
// strip off payload length
unsigned int payload_len = (_q->header[n+1] << 8) | (_q->header[n+2]);
// strip off modulation scheme/depth
unsigned int mod_scheme = _q->header[n+3];
if (mod_scheme == 0 || mod_scheme >= LIQUID_MODEM_NUM_SCHEMES) {
fprintf(stderr,"warning: ofdmflexframesync_decode_header(), invalid modulation scheme\n");
_q->header_valid = 0;
return;
}
// strip off CRC, forward error-correction schemes
// CRC : most-significant 3 bits of [n+4]
// fec0 : least-significant 5 bits of [n+4]
// fec1 : least-significant 5 bits of [n+5]
unsigned int check = (_q->header[n+4] >> 5 ) & 0x07;
unsigned int fec0 = (_q->header[n+4] ) & 0x1f;
unsigned int fec1 = (_q->header[n+5] ) & 0x1f;
// validate properties
if (check >= LIQUID_CRC_NUM_SCHEMES) {
fprintf(stderr,"warning: ofdmflexframesync_decode_header(), decoded CRC exceeds available\n");
check = LIQUID_CRC_UNKNOWN;
_q->header_valid = 0;
}
if (fec0 >= LIQUID_FEC_NUM_SCHEMES) {
fprintf(stderr,"warning: ofdmflexframesync_decode_header(), decoded FEC (inner) exceeds available\n");
fec0 = LIQUID_FEC_UNKNOWN;
_q->header_valid = 0;
}
if (fec1 >= LIQUID_FEC_NUM_SCHEMES) {
fprintf(stderr,"warning: ofdmflexframesync_decode_header(), decoded FEC (outer) exceeds available\n");
fec1 = LIQUID_FEC_UNKNOWN;
_q->header_valid = 0;
}
// print results
#if DEBUG_OFDMFLEXFRAMESYNC
printf(" properties:\n");
printf(" * mod scheme : %s\n", modulation_types[mod_scheme].fullname);
printf(" * fec (inner) : %s\n", fec_scheme_str[fec0][1]);
printf(" * fec (outer) : %s\n", fec_scheme_str[fec1][1]);
printf(" * CRC scheme : %s\n", crc_scheme_str[check][1]);
printf(" * payload length : %u bytes\n", payload_len);
#endif
// configure payload receiver
if (_q->header_valid) {
// configure modem
if (mod_scheme != _q->ms_payload) {
// set new properties
_q->ms_payload = mod_scheme;
_q->bps_payload = modulation_types[mod_scheme].bps;
// recreate modem (destroy/create)
_q->mod_payload = modem_recreate(_q->mod_payload, _q->ms_payload);
}
// set new packetizer properties
_q->payload_len = payload_len;
_q->check = check;
_q->fec0 = fec0;
_q->fec1 = fec1;
// recreate packetizer object
_q->p_payload = packetizer_recreate(_q->p_payload,
_q->payload_len,
_q->check,
_q->fec0,
_q->fec1);
// re-compute payload encoded message length
_q->payload_enc_len = packetizer_get_enc_msg_len(_q->p_payload);
#if DEBUG_OFDMFLEXFRAMESYNC
printf(" * payload encoded : %u bytes\n", _q->payload_enc_len);
#endif
// re-allocate buffers accordingly
_q->payload_enc = (unsigned char*) realloc(_q->payload_enc, _q->payload_enc_len*sizeof(unsigned char));
_q->payload_dec = (unsigned char*) realloc(_q->payload_dec, _q->payload_len*sizeof(unsigned char));
// re-compute number of modulated payload symbols
div_t d = div(8*_q->payload_enc_len, _q->bps_payload);
_q->payload_mod_len = d.quot + (d.rem ? 1 : 0);
#if DEBUG_OFDMFLEXFRAMESYNC
printf(" * payload mod syms: %u symbols\n", _q->payload_mod_len);
#endif
}
}
