From bbda6c46e5c322a32c2267da32b0150669174c12 Mon Sep 17 00:00:00 2001 From: "Matthias P. Braendli" Date: Sat, 23 Dec 2017 07:50:54 +0100 Subject: Rework OFDM windowing for data symbols --- src/GuardIntervalInserter.cpp | 85 +++++++++++++++++++++++++++---------------- src/GuardIntervalInserter.h | 2 +- 2 files changed, 55 insertions(+), 32 deletions(-) (limited to 'src') diff --git a/src/GuardIntervalInserter.cpp b/src/GuardIntervalInserter.cpp index 1381a3c..14027d3 100644 --- a/src/GuardIntervalInserter.cpp +++ b/src/GuardIntervalInserter.cpp @@ -167,57 +167,80 @@ int GuardIntervalInserter::process(Buffer* const dataIn, Buffer* dataOut) // Data symbols for (size_t sym_ix = 0; sym_ix < d_nbSymbols; sym_ix++) { - // end = spacing - const size_t prefix_start_ix = 2*d_spacing - d_symSize - d_windowOverlap; - - // From out[-d_windowOverlap] to out[d_windowOverlap], we need to - // apply the window from 0 to 0.5, with our additional - // prefix, and add it to existing data. - for (size_t i = 0; i < 2*d_windowOverlap; i++) { - out[-i] += in[prefix_start_ix + i] * d_window[i]; + /* _ix variables are indices into in[], _ox variables are + * indices for out[] */ + const ssize_t start_rise_ox = -d_windowOverlap; + const size_t start_rise_ix = 2 * d_spacing - d_symSize - d_windowOverlap; + /* + const size_t start_real_symbol_ox = 0; + const size_t start_real_symbol_ix = 2 * d_spacing - d_symSize; + */ + const ssize_t end_rise_ox = d_windowOverlap; + const size_t end_rise_ix = 2 * d_spacing - d_symSize + d_windowOverlap; + const ssize_t end_cyclic_prefix_ox = d_symSize - d_spacing; + /* end_cyclic_prefix_ix = end of symbol + const size_t begin_fall_ox = d_symSize - d_windowOverlap; + const size_t begin_fall_ix = d_spacing - d_windowOverlap; + const size_t end_real_symbol_ox = d_symSize; + end_real_symbol_ix = end of symbol + const size_t end_fall_ox = d_symSize + d_windowOverlap; + const size_t end_fall_ix = d_spacing + d_windowOverlap; + */ + + ssize_t ox = start_rise_ox; + size_t ix = start_rise_ix; + + for (size_t i = 0; ix < end_rise_ix; i++) { + out[ox] += in[ix] * d_window.at(i); + ix++; + ox++; } + assert(ox == end_rise_ox); - const size_t remaining_prefix_length = d_symSize - d_spacing - d_windowOverlap; - - // After out[d_windowOverlap], no need to accumulate, we can copy. - memcpy( &out[d_windowOverlap], - &in[prefix_start_ix + 2*d_windowOverlap], + const size_t remaining_prefix_length = end_cyclic_prefix_ox - end_rise_ox; + memcpy( &out[ox], &in[ix], remaining_prefix_length * sizeof(complexf)); + ox += remaining_prefix_length; + assert(ox = end_cyclic_prefix_ox); + ix = 0; - const size_t prefixlength = d_symSize - d_spacing + d_windowOverlap; - - const bool last_symbol = (sym_ix + 1 < d_nbSymbols); + const bool last_symbol = (sym_ix + 1 >= d_nbSymbols); if (last_symbol) { // No windowing at all at end - memcpy(&out[prefixlength], in, d_spacing * sizeof(complexf)); + memcpy(&out[ox], &in[ix], d_spacing * sizeof(complexf)); + ox += d_spacing; } else { // Copy the middle part of the symbol, d_windowOverlap samples // short of the end. - memcpy( &out[prefixlength], - in, + memcpy( &out[ox], + &in[ix], (d_spacing - d_windowOverlap) * sizeof(complexf)); - - const size_t out_start = prefixlength + d_spacing - d_windowOverlap; - const size_t in_start = d_spacing - d_windowOverlap; + ox += d_spacing - d_windowOverlap; + ix += d_spacing - d_windowOverlap; + assert(ox == (ssize_t)(d_symSize - d_windowOverlap)); // Apply window from 1 to 0.5 for the end of the symbol - for (size_t i = 0; i < d_windowOverlap; i++) { - out[out_start + i] = - in[in_start + i] * d_window[2*d_windowOverlap - (i+1)]; + for (size_t i = 0; ox < (ssize_t)d_symSize; i++) { + out[ox] = in[ix] * d_window[2*d_windowOverlap - (i+1)]; + ox++; + ix++; } + assert(ix == d_spacing); - const size_t out_start_suffix = prefixlength + d_spacing; - + ix = 0; // Cyclic suffix, with window from 0.5 to 0 - for (size_t i = 0; i < d_windowOverlap; i++) { - out[out_start_suffix + i] = - in[i] * d_window[d_windowOverlap - (i+1)]; + for (size_t i = 0; ox < (ssize_t)(d_symSize + d_windowOverlap); i++) { + out[ox] = in[ix] * d_window[d_windowOverlap - (i+1)]; + ox++; + ix++; } + + assert(ix == d_windowOverlap); } - in += d_spacing; out += d_symSize; + in += d_spacing; // out is now pointing to the proper end of symbol. There are // d_windowOverlap samples ahead that were already written. } diff --git a/src/GuardIntervalInserter.h b/src/GuardIntervalInserter.h index b2ac782..7714c1a 100644 --- a/src/GuardIntervalInserter.h +++ b/src/GuardIntervalInserter.h @@ -42,7 +42,7 @@ * that length, enlarge the cyclic prefix too, and make symbols * overlap using a raised cosine window. * */ -class GuardIntervalInserter : public ModCodec , public RemoteControllable +class GuardIntervalInserter : public ModCodec, public RemoteControllable { public: GuardIntervalInserter( -- cgit v1.2.3