14 files changed, 184 insertions, 65 deletions
diff --git a/gr-digital/lib/header_payload_demux_impl.cc b/gr-digital/lib/header_payload_demux_impl.cc
index 79e2d3770d..affbc92125 100644
--- a/gr-digital/lib/header_payload_demux_impl.cc
+++ b/gr-digital/lib/header_payload_demux_impl.cc
@@ -123,7 +123,8 @@ namespace gr {
       int produced_hdr = 0;
       int produced_payload = 0;
 
-      while (nread < noutput_items && !exit_loop) {
+      // FIXME ninput_items[1] does not have to be defined O_o
+      while (nread < noutput_items && nread < ninput_items[0] && nread < ninput_items[1] && !exit_loop) {
 	switch (d_state) {
 	      case STATE_IDLE:
 		// 1) Search for a trigger signal on input 1 (if present)
@@ -154,6 +155,7 @@ namespace gr {
 		// 4) fall through to next state
 		d_remaining_symbols = -1;
 		if (!parse_header_data_msg()) {
+		  d_state = STATE_IDLE;
 		  exit_loop = true;
 		  break;
 		}
@@ -241,6 +243,8 @@ namespace gr {
 	}
       } else if (pmt::is_null(msg)) { // Blocking call was interrupted
 	return false;
+      } else if (msg == pmt::PMT_F) { // Header was invalid
+	return false;
       } else {
 	throw std::runtime_error("Received illegal header data");
       }
diff --git a/gr-digital/lib/ofdm_chanest_vcvc_impl.cc b/gr-digital/lib/ofdm_chanest_vcvc_impl.cc
index a4025cc381..f8aebec60d 100644
--- a/gr-digital/lib/ofdm_chanest_vcvc_impl.cc
+++ b/gr-digital/lib/ofdm_chanest_vcvc_impl.cc
@@ -45,10 +45,16 @@ namespace gr {
       );
     }
 
-    ofdm_chanest_vcvc_impl::ofdm_chanest_vcvc_impl(const std::vector<gr_complex> &sync_symbol1, const std::vector<gr_complex> &sync_symbol2, int n_data_symbols, int eq_noise_red_len, int max_carr_offset, bool force_one_sync_symbol)
-      : block("ofdm_chanest_vcvc",
-		       io_signature::make(1, 1, sizeof (gr_complex) * sync_symbol1.size()),
-		       io_signature::make(1, 1, sizeof (gr_complex) * sync_symbol1.size())),
+    ofdm_chanest_vcvc_impl::ofdm_chanest_vcvc_impl(
+	    const std::vector<gr_complex> &sync_symbol1,
+	    const std::vector<gr_complex> &sync_symbol2,
+	    int n_data_symbols,
+	    int eq_noise_red_len,
+	    int max_carr_offset,
+	    bool force_one_sync_symbol
+    ) : block("ofdm_chanest_vcvc",
+	      io_signature::make(1, 1, sizeof (gr_complex) * sync_symbol1.size()),
+	      io_signature::make(1, 2, sizeof (gr_complex) * sync_symbol1.size())),
       d_fft_len(sync_symbol1.size()),
       d_n_data_syms(n_data_symbols),
       d_n_sync_syms(1),
@@ -197,13 +203,13 @@ namespace gr {
       }
       for (int i = loop_start; i < loop_end; i++) {
 	if ((d_ref_sym[i-carr_offset] != gr_complex(0, 0))) {
-	  taps[i] = sym[i] / d_ref_sym[i-carr_offset];
+	  taps[i-carr_offset] = sym[i] / d_ref_sym[i-carr_offset];
 	}
       }
 
       if (d_interpolate) {
 	for (int i = d_first_active_carrier + 1; i < d_last_active_carrier; i += 2) {
-	  taps[i] = (taps[i-1] + taps[i+1]) / gr_complex(2.0, 0);
+	  taps[i] = taps[i-1];
 	}
 	taps[d_last_active_carrier] = taps[d_last_active_carrier-1];
       }
@@ -217,6 +223,13 @@ namespace gr {
     }
 
 
+    // 1) Go through all the frames available on the input buffer
+    // 2) Estimate the coarse freq. offset and the eq. taps from the
+    //    input symbol(s)
+    // 3) Copy the data symbols to the output
+    // 4) Copy all other tags onto the output. A tag that was on
+    //    a sync symbol is copied onto the first data symbol.
+    // 5) Add the new tags for carrier offset and eq. taps
     int
     ofdm_chanest_vcvc_impl::general_work (int noutput_items,
                        gr_vector_int &ninput_items,
@@ -235,6 +248,12 @@ namespace gr {
 	std::vector<gr_complex> chan_taps(d_fft_len, 0);
 	get_chan_taps(in, in+d_fft_len, carr_offset, chan_taps);
 
+	if (output_items.size() == 2) {
+	  gr_complex *out_chantaps = ((gr_complex *) output_items[1]) + i * d_fft_len;
+	  memcpy((void *) out_chantaps, (void *) &chan_taps[0], sizeof(gr_complex) * d_fft_len);
+	  produce(1, 1);
+	}
+
 	memcpy((void *) out,
 	       (void *) &in[d_n_sync_syms * d_fft_len],
 	       sizeof(gr_complex) * d_fft_len * d_n_data_syms);
@@ -242,30 +261,32 @@ namespace gr {
 	out += d_n_data_syms * d_fft_len;
 
 	std::vector<tag_t> tags;
-	this->get_tags_in_range(tags, 0,
-	    this->nitems_read(0)+i*framesize,
-	    this->nitems_read(0)+(i+1)*framesize);
+	get_tags_in_range(tags, 0,
+	    nitems_read(0)+i*framesize,
+	    nitems_read(0)+(i+1)*framesize);
+
 	for (unsigned t = 0; t < tags.size(); t++) {
-	  int offset = tags[t].offset - (this->nitems_read(0) + i*framesize);
+	  int offset = tags[t].offset - (nitems_read(0) + i*framesize);
 	  if (offset < d_n_sync_syms) {
 	    offset = 0;
 	  } else {
 	    offset -= d_n_sync_syms;
 	  }
-	  tags[t].offset = offset + this->nitems_written(0) + i*d_n_data_syms;
-	  this->add_item_tag(0, tags[t]);
+	  tags[t].offset = offset + nitems_written(0) + i*d_n_data_syms;
+	  add_item_tag(0, tags[t]);
 	}
 
-	this->add_item_tag(0, this->nitems_written(0) + i*d_n_data_syms,
+	add_item_tag(0, nitems_written(0) + i*d_n_data_syms,
 	    pmt::string_to_symbol("ofdm_sync_carr_offset"),
 	    pmt::from_long(carr_offset));
-	this->add_item_tag(0, this->nitems_written(0) + i*d_n_data_syms,
+	add_item_tag(0, nitems_written(0) + i*d_n_data_syms,
 	    pmt::string_to_symbol("ofdm_sync_chan_taps"),
 	    pmt::init_c32vector(d_fft_len, chan_taps));
       }
-
+      produce(0, n_frames * d_n_data_syms);
       consume_each(n_frames * framesize);
-      return n_frames * d_n_data_syms;
+
+      return WORK_CALLED_PRODUCE;
     }
 
   } /* namespace digital */
diff --git a/gr-digital/lib/ofdm_equalizer_base.cc b/gr-digital/lib/ofdm_equalizer_base.cc
index 7e69b07634..27ba9e99e9 100644
--- a/gr-digital/lib/ofdm_equalizer_base.cc
+++ b/gr-digital/lib/ofdm_equalizer_base.cc
@@ -30,8 +30,7 @@ namespace gr {
 
     // *** Base class ****************************************************
     ofdm_equalizer_base::ofdm_equalizer_base(int fft_len) :
-	    d_fft_len(fft_len),
-	    d_carr_offset(0)
+	    d_fft_len(fft_len)
     {
     }
 
@@ -54,7 +53,7 @@ namespace gr {
 	  d_pilot_carriers(pilot_carriers.size(), std::vector<bool>(fft_len, false)),
 	  d_pilot_symbols(pilot_symbols.size(), std::vector<gr_complex>(fft_len, gr_complex(0, 0))),
 	  d_symbols_skipped(symbols_skipped),
-	  d_pilot_carr_set(symbols_skipped),
+	  d_pilot_carr_set(pilot_carriers.empty() ? 0 : symbols_skipped % pilot_carriers.size()),
 	  d_channel_state(fft_len, gr_complex(1, 0))
     {
       int fft_shift_width = 0;
@@ -107,7 +106,7 @@ namespace gr {
     ofdm_equalizer_1d_pilots::reset()
     {
       std::fill(d_channel_state.begin(), d_channel_state.end(), gr_complex(1, 0));
-      d_pilot_carr_set = d_symbols_skipped;
+      d_pilot_carr_set = d_pilot_carriers.empty() ? 0 : d_symbols_skipped % d_pilot_carriers.size();
     }
 
 
diff --git a/gr-digital/lib/ofdm_equalizer_simpledfe.cc b/gr-digital/lib/ofdm_equalizer_simpledfe.cc
index 8f518aa454..9483683a25 100644
--- a/gr-digital/lib/ofdm_equalizer_simpledfe.cc
+++ b/gr-digital/lib/ofdm_equalizer_simpledfe.cc
@@ -90,10 +90,10 @@ namespace gr {
 	  if (!d_occupied_carriers[k]) {
 	    continue;
 	  }
-	  if (d_pilot_carriers.size() && d_pilot_carriers[d_pilot_carr_set][k-d_carr_offset]) {
+	  if (!d_pilot_carriers.empty() && d_pilot_carriers[d_pilot_carr_set][k]) {
 	    d_channel_state[k] = d_alpha * d_channel_state[k]
-			       + (1-d_alpha) * frame[i*d_fft_len + k] / d_pilot_symbols[d_pilot_carr_set][k-d_carr_offset];
-	    frame[i*d_fft_len+k] = d_pilot_symbols[d_pilot_carr_set][k-d_carr_offset];
+			       + (1-d_alpha) * frame[i*d_fft_len + k] / d_pilot_symbols[d_pilot_carr_set][k];
+	    frame[i*d_fft_len+k] = d_pilot_symbols[d_pilot_carr_set][k];
 	  } else {
 	    sym_eq = frame[i*d_fft_len+k] / d_channel_state[k];
 	    d_constellation->map_to_points(d_constellation->decision_maker(&sym_eq), &sym_est);
@@ -101,7 +101,9 @@ namespace gr {
 	    frame[i*d_fft_len+k] = sym_est;
 	  }
 	}
-	d_pilot_carr_set = (d_pilot_carr_set + 1) % d_pilot_carriers.size();
+	if (!d_pilot_carriers.empty()) {
+	  d_pilot_carr_set = (d_pilot_carr_set + 1) % d_pilot_carriers.size();
+	}
       }
     }
 
diff --git a/gr-digital/lib/ofdm_equalizer_static.cc b/gr-digital/lib/ofdm_equalizer_static.cc
index ed24f1fe26..a407fe9413 100644
--- a/gr-digital/lib/ofdm_equalizer_static.cc
+++ b/gr-digital/lib/ofdm_equalizer_static.cc
@@ -79,9 +79,9 @@ namespace gr {
 	  if (!d_occupied_carriers[k]) {
 	    continue;
 	  }
-	  if (d_pilot_carriers.size() && d_pilot_carriers[d_pilot_carr_set][k-d_carr_offset]) {
-	    d_channel_state[k] = frame[i*d_fft_len + k] / d_pilot_symbols[d_pilot_carr_set][k-d_carr_offset];
-	    frame[i*d_fft_len+k] = d_pilot_symbols[d_pilot_carr_set][k-d_carr_offset];
+	  if (!d_pilot_carriers.empty() && d_pilot_carriers[d_pilot_carr_set][k]) {
+	    d_channel_state[k] = frame[i*d_fft_len + k] / d_pilot_symbols[d_pilot_carr_set][k];
+	    frame[i*d_fft_len+k] = d_pilot_symbols[d_pilot_carr_set][k];
 	  } else {
 	    frame[i*d_fft_len+k] /= d_channel_state[k];
 	  }
diff --git a/gr-digital/lib/ofdm_frame_equalizer_vcvc_impl.cc b/gr-digital/lib/ofdm_frame_equalizer_vcvc_impl.cc
index 8546eb119b..4446306a8b 100644
--- a/gr-digital/lib/ofdm_frame_equalizer_vcvc_impl.cc
+++ b/gr-digital/lib/ofdm_frame_equalizer_vcvc_impl.cc
@@ -23,15 +23,19 @@
 #include "config.h"
 #endif
 
+#include <gnuradio/expj.h>
 #include <gnuradio/io_signature.h>
 #include "ofdm_frame_equalizer_vcvc_impl.h"
 
+#define M_TWOPI (2*M_PI)
+
 namespace gr {
   namespace digital {
 
     ofdm_frame_equalizer_vcvc::sptr
     ofdm_frame_equalizer_vcvc::make(
 	ofdm_equalizer_base::sptr equalizer,
+	int cp_len,
 	const std::string &len_tag_key,
 	bool propagate_channel_state,
 	int fixed_frame_len
@@ -39,13 +43,14 @@ namespace gr {
     {
       return gnuradio::get_initial_sptr (
 	  new ofdm_frame_equalizer_vcvc_impl(
-	    equalizer, len_tag_key, propagate_channel_state, fixed_frame_len
+	    equalizer, cp_len, len_tag_key, propagate_channel_state, fixed_frame_len
 	  )
       );
     }
 
     ofdm_frame_equalizer_vcvc_impl::ofdm_frame_equalizer_vcvc_impl(
 	ofdm_equalizer_base::sptr equalizer,
+	int cp_len,
 	const std::string &len_tag_key,
 	bool propagate_channel_state,
 	int fixed_frame_len
@@ -54,26 +59,49 @@ namespace gr {
 	  io_signature::make(1, 1, sizeof (gr_complex) * equalizer->fft_len()),
 	  len_tag_key),
       d_fft_len(equalizer->fft_len()),
+      d_cp_len(cp_len),
       d_eq(equalizer),
       d_propagate_channel_state(propagate_channel_state),
-      d_fixed_frame_len(len_tag_key.empty() ? fixed_frame_len : 0),
+      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 (d_fixed_frame_len < 0) {
+	throw std::invalid_argument("Invalid frame length!");
+      }
       if (d_fixed_frame_len) {
 	set_output_multiple(d_fixed_frame_len);
       }
+      set_relative_rate(1.0);
     }
 
     ofdm_frame_equalizer_vcvc_impl::~ofdm_frame_equalizer_vcvc_impl()
     {
     }
 
+    void
+    ofdm_frame_equalizer_vcvc_impl::parse_length_tags(
+	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;
+      } 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]);
+	  }
+	}
+      }
+    }
+
 
     int
     ofdm_frame_equalizer_vcvc_impl::work(int noutput_items,
-	  gr_vector_int &ninput_items,
-	  gr_vector_const_void_star &input_items,
-	  gr_vector_void_star &output_items)
+	  gr_vector_int &ninput_items, gr_vector_const_void_star &input_items, gr_vector_void_star &output_items)
     {
       const gr_complex *in = (const gr_complex *) input_items[0];
       gr_complex *out = (gr_complex *) output_items[0];
@@ -92,20 +120,54 @@ namespace gr {
 	  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);
+	}
       }
 
-      memcpy((void *) out, (void *) in, sizeof(gr_complex) * d_fft_len * frame_len);
+      // Copy the frame and the channel state vector such that the symbols are shifted to the correct position
+      if (carrier_offset < 0) {
+	memset((void *) out, 0x00, sizeof(gr_complex) * (-carrier_offset));
+	memcpy(
+	    (void *) &out[-carrier_offset], (void *) in,
+	    sizeof(gr_complex) * (d_fft_len * frame_len + carrier_offset)
+	);
+      } else {
+	memset((void *) (out + d_fft_len * frame_len - carrier_offset), 0x00, sizeof(gr_complex) * carrier_offset);
+	memcpy(
+	    (void *) out, (void *) (in+carrier_offset),
+	    sizeof(gr_complex) * (d_fft_len * frame_len - carrier_offset)
+	);
+      }
+
+      // Correct the frequency shift on the symbols
+      gr_complex phase_correction;
+      for (int i = 0; i < frame_len; i++) {
+	phase_correction = gr_expj(-M_TWOPI * carrier_offset * d_cp_len / d_fft_len * (i+1));
+	for (int k = 0; k < d_fft_len; k++) {
+	  out[i*d_fft_len+k] *= phase_correction;
+	}
+      }
+
+      // Do the equalizing
       d_eq->reset();
-      d_eq->set_carrier_offset(carrier_offset);
       d_eq->equalize(out, frame_len, d_channel_state);
       d_eq->get_channel_state(d_channel_state);
+
+      // 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;
+      }
+
+      // Housekeeping
       if (d_propagate_channel_state) {
 	add_item_tag(0, nitems_written(0),
 	    pmt::string_to_symbol("ofdm_sync_chan_taps"),
 	    pmt::init_c32vector(d_fft_len, d_channel_state));
       }
 
-      if (d_fixed_frame_len) {
+      if (d_fixed_frame_len && d_length_tag_key_str.empty()) {
 	consume_each(frame_len);
       }
 
diff --git a/gr-digital/lib/ofdm_frame_equalizer_vcvc_impl.h b/gr-digital/lib/ofdm_frame_equalizer_vcvc_impl.h
index c5f039d1a6..77dae39e1b 100644
--- a/gr-digital/lib/ofdm_frame_equalizer_vcvc_impl.h
+++ b/gr-digital/lib/ofdm_frame_equalizer_vcvc_impl.h
@@ -31,19 +31,22 @@ namespace gr {
     {
      private:
       const int d_fft_len;
+      const int d_cp_len;
       ofdm_equalizer_base::sptr d_eq;
       bool d_propagate_channel_state;
       const int d_fixed_frame_len;
       std::vector<gr_complex> d_channel_state;
 
      protected:
-      // These aren't really necessary, so let's override them with nuthin'
-      void remove_length_tags(const std::vector<std::vector<tag_t> > &tags) {};
-      void update_length_tags(int n_produced, int n_ports) {};
+      void parse_length_tags(
+	  const std::vector<std::vector<tag_t> > &tags,
+	  gr_vector_int &n_input_items_reqd
+      );
 
      public:
       ofdm_frame_equalizer_vcvc_impl(
 	  ofdm_equalizer_base::sptr equalizer,
+	  int cp_len,
 	  const std::string &len_tag_key,
 	  bool propagate_channel_state,
 	  int fixed_frame_len
diff --git a/gr-digital/lib/ofdm_serializer_vcc_impl.cc b/gr-digital/lib/ofdm_serializer_vcc_impl.cc
index 9ca6d59ec9..261111f22a 100644
--- a/gr-digital/lib/ofdm_serializer_vcc_impl.cc
+++ b/gr-digital/lib/ofdm_serializer_vcc_impl.cc
@@ -36,6 +36,7 @@ namespace gr {
 	const std::string &len_tag_key,
 	const std::string &packet_len_tag_key,
 	int symbols_skipped,
+	const std::string &carr_offset_key,
 	bool input_is_shifted
     )
     {
@@ -43,7 +44,9 @@ namespace gr {
 	  new ofdm_serializer_vcc_impl(
 		      fft_len, occupied_carriers,
 		      len_tag_key, packet_len_tag_key,
-		      symbols_skipped, input_is_shifted
+		      symbols_skipped,
+		      carr_offset_key,
+		      input_is_shifted
 	  )
       );
     }
@@ -53,6 +56,7 @@ namespace gr {
 		const gr::digital::ofdm_carrier_allocator_cvc::sptr &allocator,
 		const std::string &packet_len_tag_key,
 		int symbols_skipped,
+		const std::string &carr_offset_key,
 		bool input_is_shifted
     )
     {
@@ -63,7 +67,8 @@ namespace gr {
 	    allocator->len_tag_key(),
 	    packet_len_tag_key,
 	    symbols_skipped,
-	    input_is_shifted
+	    carr_offset_key,
+	    !input_is_shifted
 	  )
       );
     }
@@ -74,6 +79,7 @@ namespace gr {
 		    const std::string &len_tag_key,
 		    const std::string &packet_len_tag_key,
 		    int symbols_skipped,
+		    const std::string &carr_offset_key,
 		    bool input_is_shifted)
       : tagged_stream_block ("ofdm_serializer_vcc",
 		       io_signature::make(1, 1, sizeof (gr_complex) * fft_len),
@@ -84,20 +90,25 @@ namespace gr {
 	    d_packet_len_tag_key(pmt::string_to_symbol(packet_len_tag_key)),
 	    d_out_len_tag_key(pmt::string_to_symbol((packet_len_tag_key.empty() ? len_tag_key : packet_len_tag_key))),
 	    d_symbols_skipped(symbols_skipped % occupied_carriers.size()),
+	    d_carr_offset_key(pmt::string_to_symbol(carr_offset_key)),
 	    d_curr_set(symbols_skipped % occupied_carriers.size()),
 	    d_symbols_per_set(0)
     {
       for (unsigned i = 0; i < d_occupied_carriers.size(); i++) {
 	for (unsigned k = 0; k < d_occupied_carriers[i].size(); k++) {
-	  if (d_occupied_carriers[i][k] < 0) {
-	    d_occupied_carriers[i][k] += fft_len;
+	  if (input_is_shifted) {
+	    d_occupied_carriers[i][k] += fft_len/2;
+	    if (d_occupied_carriers[i][k] > fft_len) {
+	      d_occupied_carriers[i][k] -= fft_len;
+	    }
+	  } else {
+	    if (d_occupied_carriers[i][k] < 0) {
+	      d_occupied_carriers[i][k] += fft_len;
+	    }
 	  }
 	  if (d_occupied_carriers[i][k] >= fft_len || d_occupied_carriers[i][k] < 0) {
 	    throw std::invalid_argument("ofdm_serializer_vcc: trying to occupy a carrier outside the fft length.");
 	  }
-	  if (input_is_shifted) {
-	    d_occupied_carriers[i][k] = (d_occupied_carriers[i][k] + fft_len) % fft_len;
-	  }
 	}
       }
 
@@ -148,7 +159,7 @@ namespace gr {
       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 (pmt::symbol_to_string(tags[i].key) == "ofdm_sync_carr_offset") {
+	  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) {
@@ -176,8 +187,8 @@ namespace gr {
 	);
 	for (unsigned t = 0; t < tags.size(); t++) {
 	  add_item_tag(0, nitems_written(0)+n_out_symbols,
-	    tags[i].key,
-	    tags[i].value
+	    tags[t].key,
+	    tags[t].value
 	  );
 	}
 	for (unsigned k = 0; k < d_occupied_carriers[d_curr_set].size(); k++) {
diff --git a/gr-digital/lib/ofdm_serializer_vcc_impl.h b/gr-digital/lib/ofdm_serializer_vcc_impl.h
index 0ec0ec3505..b61c6596d5 100644
--- a/gr-digital/lib/ofdm_serializer_vcc_impl.h
+++ b/gr-digital/lib/ofdm_serializer_vcc_impl.h
@@ -35,6 +35,7 @@ namespace gr {
       pmt::pmt_t d_packet_len_tag_key; //!< Key of the length tag
       pmt::pmt_t d_out_len_tag_key; //!< Key of the length tag
       const int d_symbols_skipped; //!< Start position in d_occupied_carriers
+      pmt::pmt_t d_carr_offset_key; //!< Key of the carrier offset tag
       int d_curr_set; //!< Current position in d_occupied_carriers
       int d_symbols_per_set;
 
@@ -53,6 +54,7 @@ namespace gr {
 	  const std::string &len_tag_key,
 	  const std::string &packet_len_tag_key,
 	  int symbols_skipped,
+	  const std::string &carr_offset_key,
 	  bool input_is_shifted
       );
       ~ofdm_serializer_vcc_impl();
diff --git a/gr-digital/lib/ofdm_sync_sc_cfb_impl.cc b/gr-digital/lib/ofdm_sync_sc_cfb_impl.cc
index 1a75883de7..9b3e9687bc 100644
--- a/gr-digital/lib/ofdm_sync_sc_cfb_impl.cc
+++ b/gr-digital/lib/ofdm_sync_sc_cfb_impl.cc
@@ -43,14 +43,14 @@ namespace gr {
   namespace digital {
 
     ofdm_sync_sc_cfb::sptr
-    ofdm_sync_sc_cfb::make(int fft_len, int cp_len)
+    ofdm_sync_sc_cfb::make(int fft_len, int cp_len, bool use_even_carriers)
     {
-      return gnuradio::get_initial_sptr (new ofdm_sync_sc_cfb_impl(fft_len, cp_len));
+      return gnuradio::get_initial_sptr (new ofdm_sync_sc_cfb_impl(fft_len, cp_len, use_even_carriers));
     }
 
-    ofdm_sync_sc_cfb_impl::ofdm_sync_sc_cfb_impl(int fft_len, int cp_len)
+    ofdm_sync_sc_cfb_impl::ofdm_sync_sc_cfb_impl(int fft_len, int cp_len, bool use_even_carriers)
 	: hier_block2 ("ofdm_sync_sc_cfb",
-		   io_signature::make(1, 1, sizeof (gr_complex)),
+		       io_signature::make(1, 1, sizeof (gr_complex)),
 #ifndef SYNC_ADD_DEBUG_OUTPUT
 		   io_signature::make2(2, 2, sizeof (float), sizeof (unsigned char)))
 #else
@@ -61,7 +61,7 @@ namespace gr {
       gr::blocks::delay::sptr          delay(gr::blocks::delay::make(sizeof(gr_complex), fft_len/2));
       gr::blocks::conjugate_cc::sptr   delay_conjugate(gr::blocks::conjugate_cc::make());
       gr::blocks::multiply_cc::sptr    delay_corr(gr::blocks::multiply_cc::make());
-      gr::filter::fir_filter_ccf::sptr delay_ma(gr::filter::fir_filter_ccf::make(1, std::vector<float>(fft_len/2, 1.0)));
+      gr::filter::fir_filter_ccf::sptr delay_ma(gr::filter::fir_filter_ccf::make(1, std::vector<float>(fft_len/2, use_even_carriers ? 1.0 : -1.0)));
       gr::blocks::complex_to_mag_squared::sptr delay_magsquare(gr::blocks::complex_to_mag_squared::make());
       gr::blocks::divide_ff::sptr      delay_normalize(gr::blocks::divide_ff::make());
 
diff --git a/gr-digital/lib/ofdm_sync_sc_cfb_impl.h b/gr-digital/lib/ofdm_sync_sc_cfb_impl.h
index b217002038..af767e2a2b 100644
--- a/gr-digital/lib/ofdm_sync_sc_cfb_impl.h
+++ b/gr-digital/lib/ofdm_sync_sc_cfb_impl.h
@@ -31,7 +31,7 @@ namespace gr {
     class ofdm_sync_sc_cfb_impl : public ofdm_sync_sc_cfb
     {
      public:
-      ofdm_sync_sc_cfb_impl(int fft_len, int cp_len);
+      ofdm_sync_sc_cfb_impl(int fft_len, int cp_len, bool use_even_carriers);
       ~ofdm_sync_sc_cfb_impl();
     };
 
diff --git a/gr-digital/lib/packet_header_default.cc b/gr-digital/lib/packet_header_default.cc
index eb639260c6..ef5f39dc97 100644
--- a/gr-digital/lib/packet_header_default.cc
+++ b/gr-digital/lib/packet_header_default.cc
@@ -47,7 +47,7 @@ namespace gr {
 		    int bits_per_byte)
       : d_header_len(header_len),
       d_len_tag_key(pmt::string_to_symbol(len_tag_key)),
-      d_num_tag_key(pmt::string_to_symbol(num_tag_key)),
+      d_num_tag_key(num_tag_key.empty() ? pmt::PMT_NIL : pmt::string_to_symbol(num_tag_key)),
       d_bits_per_byte(bits_per_byte),
       d_header_number(0)
     {
@@ -64,8 +64,9 @@ namespace gr {
     bool packet_header_default::header_formatter(
 	long packet_len,
         unsigned char *out,
+
 	const std::vector<tag_t> &tags
-	)
+    )
     {
       packet_len &= 0x0FFF;
 
@@ -107,12 +108,17 @@ namespace gr {
       if (k >= d_header_len) {
 	return true;
       }
-      for (int i = 0; i < 16 && k < d_header_len; i += d_bits_per_byte, k++) {
-	header_num |= (((int) in[k]) & d_mask) << i;
+      if (d_num_tag_key == pmt::PMT_NIL) {
+	k += 16;
+      } else {
+	for (int i = 0; i < 16 && k < d_header_len; i += d_bits_per_byte, k++) {
+	  header_num |= (((int) in[k]) & d_mask) << i;
+	}
+	tag.key = d_num_tag_key;
+	tag.value = pmt::from_long(header_num);
+	tags.push_back(tag);
       }
-      tag.key = d_num_tag_key;
-      tag.value = pmt::from_long(header_num);
-      tags.push_back(tag);
+
       if (k >= d_header_len) {
 	return true;
       }
diff --git a/gr-digital/lib/packet_header_ofdm.cc b/gr-digital/lib/packet_header_ofdm.cc
index 03a9581a6c..f163657bab 100644
--- a/gr-digital/lib/packet_header_ofdm.cc
+++ b/gr-digital/lib/packet_header_ofdm.cc
@@ -93,12 +93,15 @@ namespace gr {
       int packet_len = 0; // # of bytes in this frame
       for (unsigned i = 0; i < tags.size(); i++) {
 	if (pmt::equal(tags[i].key, d_len_tag_key)) {
-	  packet_len = pmt::to_long(tags[i].value);
+	  // Convert bytes to complex symbols:
+	  packet_len = pmt::to_long(tags[i].value) * 8 / d_bits_per_payload_sym;
+	  if (pmt::to_long(tags[i].value) * 8 % d_bits_per_payload_sym) {
+	    packet_len++;
+	  }
+	  tags[i].value = pmt::from_long(packet_len);
 	  break;
 	}
       }
-      // Convert bytes to complex symbols:
-      packet_len = packet_len * 8 / d_bits_per_payload_sym;
 
       // frame_len == # of OFDM symbols in this frame
       int frame_len = packet_len / d_syms_per_set;
diff --git a/gr-digital/lib/packet_headerparser_b_impl.cc b/gr-digital/lib/packet_headerparser_b_impl.cc
index d55a3bd303..f7593d5fb2 100644
--- a/gr-digital/lib/packet_headerparser_b_impl.cc
+++ b/gr-digital/lib/packet_headerparser_b_impl.cc
@@ -73,6 +73,12 @@ namespace gr {
       }
 
       std::vector<tag_t> tags;
+      get_tags_in_range(
+	  tags, 0,
+	  nitems_read(0),
+	  nitems_read(0)+d_header_formatter->header_len()
+      );
+
       if (!d_header_formatter->header_parser(in, tags)) {
 	GR_LOG_INFO(d_logger, boost::format("Detected an invalid packet at item %1%") % nitems_read(0));
 	message_port_pub(msg_port_id, pmt::PMT_F);