aboutsummaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
authorMatthias P. Braendli <matthias.braendli@mpb.li>2017-12-23 07:50:54 +0100
committerMatthias P. Braendli <matthias.braendli@mpb.li>2017-12-23 07:50:54 +0100
commitbbda6c46e5c322a32c2267da32b0150669174c12 (patch)
tree60398aa71cfe4c8ca80f6bbec561267bed08f890 /src
parentce490c8c25bdbb1fc40fc43d8631a807f6effa6a (diff)
downloaddabmod-bbda6c46e5c322a32c2267da32b0150669174c12.tar.gz
dabmod-bbda6c46e5c322a32c2267da32b0150669174c12.tar.bz2
dabmod-bbda6c46e5c322a32c2267da32b0150669174c12.zip
Rework OFDM windowing for data symbols
Diffstat (limited to 'src')
-rw-r--r--src/GuardIntervalInserter.cpp85
-rw-r--r--src/GuardIntervalInserter.h2
2 files changed, 55 insertions, 32 deletions
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(