[Discuss-gnuradio] The power of N log N

[Eric Blossom]

Matt and I had quite the hack-a-thon over the past few days.

Here is partial list of bugs fixed and features added:

* FFT based FIR filtering.  We've currently coded gr.fft_filter_ccc,
  but it handles the float taps case too.  For ntaps = 64 with
  decimation = 1, it's more than 9 times faster than our best
  hand-coded SSE assembler on the Pentium M.  The break-even point is
  somewhere in neighborhood of 8 - 16 taps.  The speed-up you'll see
  depends on your machine architecuture and microarchitecture, as well
  as the configure options you use to build FFTW.

  See gnuradio-core/src/python/gnuradio/gr/benchmark_filters.py for
  code to compare gr.fir_filter_ccc to gr.fft_filter_ccc.

* Support for large FFT's

* The FFT sink display is now normalized by the number of bins, so
  that changing the number of bins doesn't change the displayed result.

* Support for fir filters with lots of taps (more than you should be
  using in a single stage).

* All the examples were examined and all calls to fftsink were
  changed to use the new prefered keywork argument form.  This makes
  available additional functionality not accessible through the legacy
  interface.  Details of the new interface are in fftsink.py

* Uniformly modulated polyphase DFT filter banks: analysis and
  synthesis.  This allows us to very efficiently separate out a bunch
  of evenly spaced channels on Rx or generate a bunch of uniformly
  spaced channels on Tx.  We've still got a bit of tuning to do on
  this, as well as shuffling the channels around so that they occur in
  left to right order (they've currently got the raw fft ordering,
  which most folks don't find intuitive ;-))
  
  See gnuradio-core/src/python/gnuradio/blksimpl/filterbank.py

* 6 new "plumbing" blocks:

  - gr.stream_to_streams(item_size, nstreams)
  - gr.streams_to_stream(item_size, nstreams)
  - gr.streams_to_vector(item_size, nstreams)
  - gr.vector_to_streams(item_size, nstream)
  - gr.stream_to_vector(item_size, vector_size)
  - gr.vector_to_stream(item_size, vector_size)

  (The last two were previously know as "serial_to_parallel" and
  "parallel_to_serial" respectively.)

  I'll draw some diagrams and send them to the list later on.

  * gr.stream_to_streams takes a single stream in, and produces nstreams
    out.  It effectively commutates the input items across the output
    streams.  The output streams are running at the input rate/nstreams

  * gr.streams_to_stream is the inverse of gr.stream_to_streams.

  * gr.streams_to_vector takes N streams in and produces a single
    stream of vectors out.  vector_element[0] comes from stream[0],
    vector_element[1] comes from stream[1], ...

  * gr.vector_to_streams is the inverse  of gr.streams_to_vector.

  * gr.stream_to_vector "reshapes" the input stream from N single
    items into a single output stream of vectors, each of which has N
    items.

  * gr.vector_to_stream is the inverse of gr.stream_to_vector.


Those are the highlights.  I'm sure I forgot something.

Eric