3 files changed, 117 insertions, 100 deletions
diff --git a/gr-digital/lib/header_payload_demux_impl.cc b/gr-digital/lib/header_payload_demux_impl.cc
index 15308c0be1..160f54036d 100644
--- a/gr-digital/lib/header_payload_demux_impl.cc
+++ b/gr-digital/lib/header_payload_demux_impl.cc
@@ -1,5 +1,5 @@
 /* -*- c++ -*- */
-/* Copyright 2012,2013 Free Software Foundation, Inc.
+/* Copyright 2012-2014 Free Software Foundation, Inc.
  * 
  * This file is part of GNU Radio
  * 
@@ -300,20 +300,19 @@ namespace gr {
 	}
       }
       if (d_uses_trigger_tag) {
-	std::vector<tag_t> tags;
-	get_tags_in_range(tags, 0, nitems_read(0), nitems_read(0)+noutput_items, d_trigger_tag_key);
-	uint64_t min_offset = ULLONG_MAX;
-	int tag_index = -1;
-	for (unsigned i = 0; i < tags.size(); i++) {
-	  if (tags[i].offset < min_offset) {
-	    tag_index = (int) i;
-	    min_offset = tags[i].offset;
-	  }
-	}
-	if (tag_index != -1) {
-	  remove_item_tag(0, tags[tag_index]);
-	  return min_offset - nitems_read(0);
-	}
+        std::vector<tag_t> tags;
+        get_tags_in_range(tags, 0, nitems_read(0), nitems_read(0)+noutput_items, d_trigger_tag_key);
+        uint64_t min_offset = ULLONG_MAX;
+        int tag_index = -1;
+        for (unsigned i = 0; i < tags.size(); i++) {
+          if (tags[i].offset < min_offset) {
+            tag_index = (int) i;
+            min_offset = tags[i].offset;
+          }
+        }
+        if (tag_index != -1) {
+          return min_offset - nitems_read(0);
+        }
       }
       return -1;
     } /* find_trigger_signal() */
@@ -388,26 +387,30 @@ namespace gr {
       // Copy tags
       std::vector<tag_t> tags;
       get_tags_in_range(
-	  tags, 0,
-	  nitems_read(0),
-	  nitems_read(0) + n_symbols * (d_items_per_symbol + d_gi)
+          tags, 0,
+          nitems_read(0),
+          nitems_read(0) + n_symbols * (d_items_per_symbol + d_gi)
       );
-      for (unsigned t = 0; t < tags.size(); t++) {
-	int new_offset = tags[t].offset - nitems_read(0);
-	if (d_output_symbols) {
-	  new_offset /= (d_items_per_symbol + d_gi);
-	} else if (d_gi) {
-	  int pos_on_symbol = (new_offset % (d_items_per_symbol + d_gi)) - d_gi;
-	  if (pos_on_symbol < 0) {
-	    pos_on_symbol = 0;
-	  }
-	  new_offset = (new_offset / (d_items_per_symbol + d_gi)) + pos_on_symbol;
-	}
-	add_item_tag(port,
-	    nitems_written(port) + new_offset,
-	    tags[t].key,
-	    tags[t].value
-	);
+      for (size_t t = 0; t < tags.size(); t++) {
+        // The trigger tag is *not* propagated
+        if (tags[t].key == d_trigger_tag_key) {
+          continue;
+        }
+        int new_offset = tags[t].offset - nitems_read(0);
+        if (d_output_symbols) {
+          new_offset /= (d_items_per_symbol + d_gi);
+        } else if (d_gi) {
+          int pos_on_symbol = (new_offset % (d_items_per_symbol + d_gi)) - d_gi;
+          if (pos_on_symbol < 0) {
+            pos_on_symbol = 0;
+          }
+          new_offset = (new_offset / (d_items_per_symbol + d_gi)) + pos_on_symbol;
+        }
+        add_item_tag(port,
+            nitems_written(port) + new_offset,
+            tags[t].key,
+            tags[t].value
+        );
       }
     } /* copy_n_symbols() */
 
diff --git a/gr-digital/lib/ofdm_frame_equalizer_vcvc_impl.cc b/gr-digital/lib/ofdm_frame_equalizer_vcvc_impl.cc
index 4446306a8b..70e840d778 100644
--- a/gr-digital/lib/ofdm_frame_equalizer_vcvc_impl.cc
+++ b/gr-digital/lib/ofdm_frame_equalizer_vcvc_impl.cc
@@ -29,6 +29,9 @@
 
 #define M_TWOPI (2*M_PI)
 
+static const pmt::pmt_t CARR_OFFSET_KEY = pmt::mp("ofdm_sync_carr_offset");
+static const pmt::pmt_t CHAN_TAPS_KEY = pmt::mp("ofdm_sync_chan_taps");
+
 namespace gr {
   namespace digital {
 
@@ -36,14 +39,14 @@ namespace gr {
     ofdm_frame_equalizer_vcvc::make(
 	ofdm_equalizer_base::sptr equalizer,
 	int cp_len,
-	const std::string &len_tag_key,
+	const std::string &tsb_key,
 	bool propagate_channel_state,
 	int fixed_frame_len
     )
     {
       return gnuradio::get_initial_sptr (
 	  new ofdm_frame_equalizer_vcvc_impl(
-	    equalizer, cp_len, len_tag_key, propagate_channel_state, fixed_frame_len
+	    equalizer, cp_len, tsb_key, propagate_channel_state, fixed_frame_len
 	  )
       );
     }
@@ -51,13 +54,13 @@ namespace gr {
     ofdm_frame_equalizer_vcvc_impl::ofdm_frame_equalizer_vcvc_impl(
 	ofdm_equalizer_base::sptr equalizer,
 	int cp_len,
-	const std::string &len_tag_key,
+	const std::string &tsb_key,
 	bool propagate_channel_state,
 	int fixed_frame_len
     ) : tagged_stream_block("ofdm_frame_equalizer_vcvc",
 	  io_signature::make(1, 1, sizeof (gr_complex) * equalizer->fft_len()),
 	  io_signature::make(1, 1, sizeof (gr_complex) * equalizer->fft_len()),
-	  len_tag_key),
+	  tsb_key),
       d_fft_len(equalizer->fft_len()),
       d_cp_len(cp_len),
       d_eq(equalizer),
@@ -65,16 +68,18 @@ namespace gr {
       d_fixed_frame_len(fixed_frame_len),
       d_channel_state(equalizer->fft_len(), gr_complex(1, 0))
     {
-      if (len_tag_key.empty() && fixed_frame_len == 0) {
-	throw std::invalid_argument("Either specify a length tag or a frame length!");
+      if (tsb_key.empty() && fixed_frame_len == 0) {
+        throw std::invalid_argument("Either specify a TSB tag or a fixed frame length!");
       }
       if (d_fixed_frame_len < 0) {
-	throw std::invalid_argument("Invalid frame length!");
+        throw std::invalid_argument("Invalid frame length!");
       }
       if (d_fixed_frame_len) {
-	set_output_multiple(d_fixed_frame_len);
+        set_output_multiple(d_fixed_frame_len);
       }
       set_relative_rate(1.0);
+      // Really, we have TPP_ONE_TO_ONE, but the channel state is not propagated
+      set_tag_propagation_policy(TPP_DONT);
     }
 
     ofdm_frame_equalizer_vcvc_impl::~ofdm_frame_equalizer_vcvc_impl()
@@ -83,18 +88,17 @@ namespace gr {
 
     void
     ofdm_frame_equalizer_vcvc_impl::parse_length_tags(
-	const std::vector<std::vector<tag_t> > &tags,
-	gr_vector_int &n_input_items_reqd
-    ){
+        const std::vector<std::vector<tag_t> > &tags,
+        gr_vector_int &n_input_items_reqd
+    ) {
       if (d_fixed_frame_len) {
-	n_input_items_reqd[0] = d_fixed_frame_len;
+        n_input_items_reqd[0] = d_fixed_frame_len;
       } else {
-	for (unsigned k = 0; k < tags[0].size(); k++) {
-	  if (tags[0][k].key == pmt::string_to_symbol(d_length_tag_key_str)) {
-	    n_input_items_reqd[0] = pmt::to_long(tags[0][k].value);
-	    remove_item_tag(0, tags[0][k]);
-	  }
-	}
+        for (unsigned k = 0; k < tags[0].size(); k++) {
+          if (tags[0][k].key == pmt::string_to_symbol(d_length_tag_key_str)) {
+            n_input_items_reqd[0] = pmt::to_long(tags[0][k].value);
+          }
+        }
       }
     }
 
@@ -114,15 +118,14 @@ namespace gr {
       }
 
       std::vector<tag_t> tags;
-      get_tags_in_range(tags, 0, nitems_read(0), nitems_read(0)+1);
+      get_tags_in_window(tags, 0, 0, 1);
       for (unsigned i = 0; i < tags.size(); i++) {
-	if (pmt::symbol_to_string(tags[i].key) == "ofdm_sync_chan_taps") {
-	  d_channel_state = pmt::c32vector_elements(tags[i].value);
-	  remove_item_tag(0, tags[i]);
-	}
-	if (pmt::symbol_to_string(tags[i].key) == "ofdm_sync_carr_offset") {
-	  carrier_offset = pmt::to_long(tags[i].value);
-	}
+        if (pmt::symbol_to_string(tags[i].key) == "ofdm_sync_chan_taps") {
+          d_channel_state = pmt::c32vector_elements(tags[i].value);
+        }
+        if (pmt::symbol_to_string(tags[i].key) == "ofdm_sync_carr_offset") {
+          carrier_offset = pmt::to_long(tags[i].value);
+        }
       }
 
       // Copy the frame and the channel state vector such that the symbols are shifted to the correct position
@@ -157,7 +160,16 @@ namespace gr {
       // Update the channel state regarding the frequency offset
       phase_correction = gr_expj(M_TWOPI * carrier_offset * d_cp_len / d_fft_len * frame_len);
       for (int k = 0; k < d_fft_len; k++) {
-	d_channel_state[k] *= phase_correction;
+        d_channel_state[k] *= phase_correction;
+      }
+
+      // Propagate tags (except for the channel state and the TSB tag)
+      get_tags_in_window(tags, 0, 0, frame_len);
+      for (size_t i = 0; i < tags.size(); i++) {
+        if (tags[i].key != CHAN_TAPS_KEY
+            and tags[i].key != pmt::mp(d_length_tag_key_str)) {
+          add_item_tag(0, tags[i]);
+        }
       }
 
       // Housekeeping
diff --git a/gr-digital/lib/ofdm_serializer_vcc_impl.cc b/gr-digital/lib/ofdm_serializer_vcc_impl.cc
index f6c796d3c5..1398dcd2a1 100644
--- a/gr-digital/lib/ofdm_serializer_vcc_impl.cc
+++ b/gr-digital/lib/ofdm_serializer_vcc_impl.cc
@@ -1,5 +1,5 @@
 /* -*- c++ -*- */
-/* Copyright 2012 Free Software Foundation, Inc.
+/* Copyright 2012,2014 Free Software Foundation, Inc.
  * 
  * This file is part of GNU Radio
  * 
@@ -157,55 +157,57 @@ namespace gr {
       std::vector<tag_t> tags;
       // Packet mode
       if (!d_length_tag_key_str.empty()) {
-	get_tags_in_range(tags, 0, nitems_read(0), nitems_read(0)+1);
-	for (unsigned i = 0; i < tags.size(); i++) {
-	  if (tags[i].key == d_carr_offset_key) {
-	    carr_offset = pmt::to_long(tags[i].value);
-	  }
-	  if (tags[i].key == d_packet_len_tag_key) {
-	    packet_length = pmt::to_long(tags[i].value);
-	    remove_item_tag(0, tags[i]);
-	  }
-	}
+        get_tags_in_range(tags, 0, nitems_read(0), nitems_read(0)+1);
+        for (unsigned i = 0; i < tags.size(); i++) {
+          if (tags[i].key == d_carr_offset_key) {
+            carr_offset = pmt::to_long(tags[i].value);
+          }
+          if (tags[i].key == d_packet_len_tag_key) {
+            packet_length = pmt::to_long(tags[i].value);
+          }
+        }
       } else {
-	// recalc frame length from noutput_items
-	frame_length = 0;
-	int sym_per_frame = 0;
-	while ((sym_per_frame + d_occupied_carriers[(frame_length + 1) % d_occupied_carriers.size()].size()) < (size_t)noutput_items) {
-	  frame_length++;
-	  sym_per_frame += d_occupied_carriers[(frame_length + 1) % d_occupied_carriers.size()].size();
-	}
+        // recalc frame length from noutput_items
+        frame_length = 0;
+        int sym_per_frame = 0;
+        while ((sym_per_frame + d_occupied_carriers[(frame_length + 1) % d_occupied_carriers.size()].size()) < (size_t)noutput_items) {
+          frame_length++;
+          sym_per_frame += d_occupied_carriers[(frame_length + 1) % d_occupied_carriers.size()].size();
+        }
       }
 
       // Copy symbols
       int n_out_symbols = 0;
       for (int i = 0; i < frame_length; i++) {
-	// Copy all tags associated with this input OFDM symbol onto the first output symbol
-	get_tags_in_range(tags, 0,
-	  nitems_read(0)+i,
-	  nitems_read(0)+i+1
-	);
-	for (unsigned t = 0; t < tags.size(); t++) {
-	  add_item_tag(0, nitems_written(0)+n_out_symbols,
-	    tags[t].key,
-	    tags[t].value
-	  );
-	}
-	for (unsigned k = 0; k < d_occupied_carriers[d_curr_set].size(); k++) {
-	  out[n_out_symbols++] = in[i * d_fft_len + d_occupied_carriers[d_curr_set][k] + carr_offset];
-	}
-	if (packet_length && n_out_symbols > packet_length) {
-	  n_out_symbols = packet_length;
-	  break;
-	}
-	d_curr_set = (d_curr_set + 1) % d_occupied_carriers.size();
+        // Copy all tags associated with this input OFDM symbol onto the first output symbol
+        get_tags_in_range(tags, 0,
+            nitems_read(0)+i,
+            nitems_read(0)+i+1
+        );
+        for (size_t t = 0; t < tags.size(); t++) {
+          // The packet length tag is not propagated
+          if (tags[t].key != d_packet_len_tag_key) {
+            add_item_tag(0, nitems_written(0)+n_out_symbols,
+                tags[t].key,
+                tags[t].value
+            );
+          }
+        }
+        for (unsigned k = 0; k < d_occupied_carriers[d_curr_set].size(); k++) {
+          out[n_out_symbols++] = in[i * d_fft_len + d_occupied_carriers[d_curr_set][k] + carr_offset];
+        }
+        if (packet_length && n_out_symbols > packet_length) {
+          n_out_symbols = packet_length;
+          break;
+        }
+        d_curr_set = (d_curr_set + 1) % d_occupied_carriers.size();
       }
 
       // Housekeeping
       if (d_length_tag_key_str.empty()) {
-	consume_each(frame_length);
+        consume_each(frame_length);
       } else {
-	d_curr_set = d_symbols_skipped;
+        d_curr_set = d_symbols_skipped;
       }
 
       return n_out_symbols;