git.gag.com Git - debian/gnuradio/blob - gnuradio-core/src/lib/filter/gr_pfb_channelizer_ccf.cc

   1 /* -*- c++ -*- */
   2 /*
   3  * Copyright 2009,2010 Free Software Foundation, Inc.
   4  *
   5  * This file is part of GNU Radio
   6  *
   7  * GNU Radio is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 3, or (at your option)
  10  * any later version.
  11  *
  12  * GNU Radio is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with GNU Radio; see the file COPYING.  If not, write to
  19  * the Free Software Foundation, Inc., 51 Franklin Street,
  20  * Boston, MA 02110-1301, USA.
  21  */
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include "config.h"
  25 #endif
  26
  27 #include <gr_pfb_channelizer_ccf.h>
  28 #include <gr_fir_ccf.h>
  29 #include <gr_fir_util.h>
  30 #include <gri_fft.h>
  31 #include <gr_io_signature.h>
  32 #include <cstdio>
  33 #include <cstring>
  34
  35 gr_pfb_channelizer_ccf_sptr gr_make_pfb_channelizer_ccf (unsigned int numchans,
  36                                                          const std::vector<float> &taps,
  37                                                          float oversample_rate)
  38 {
  39   return gnuradio::get_initial_sptr(new gr_pfb_channelizer_ccf (numchans, taps,
  40                                                                   oversample_rate));
  41 }
  42
  43
  44 gr_pfb_channelizer_ccf::gr_pfb_channelizer_ccf (unsigned int numchans,
  45                                                 const std::vector<float> &taps,
  46                                                 float oversample_rate)
  47   : gr_block ("pfb_channelizer_ccf",
  48               gr_make_io_signature (numchans, numchans, sizeof(gr_complex)),
  49               gr_make_io_signature (1, 1, numchans*sizeof(gr_complex))),
  50     d_updated (false), d_numchans(numchans), d_oversample_rate(oversample_rate)
  51 {
  52   // The over sampling rate must be rationally related to the number of channels
  53   // in that it must be N/i for i in [1,N], which gives an outputsample rate
  54   // of [fs/N, fs] where fs is the input sample rate.
  55   // This tests the specified input sample rate to see if it conforms to this
  56   // requirement within a few significant figures.
  57   double intp = 0;
  58   double fltp = modf(numchans / oversample_rate, &intp);
  59   if(fltp != 0.0)
  60     throw std::invalid_argument("gr_pfb_channelizer: oversample rate must be N/i for i in [1, N]");
  61
  62   set_relative_rate(1.0/intp);
  63
  64   d_filters = std::vector<gr_fir_ccf*>(d_numchans);
  65
  66   // Create an FIR filter for each channel and zero out the taps
  67   std::vector<float> vtaps(0, d_numchans);
  68   for(unsigned int i = 0; i < d_numchans; i++) {
  69     d_filters[i] = gr_fir_util::create_gr_fir_ccf(vtaps);
  70   }
  71
  72   // Now, actually set the filters' taps
  73   set_taps(taps);
  74
  75   // Create the FFT to handle the output de-spinning of the channels
  76   d_fft = new gri_fft_complex (d_numchans, false);
  77
  78   // Although the filters change, we use this look up table
  79   // to set the index of the FFT input buffer, which equivalently
  80   // performs the FFT shift operation on every other turn.
  81   d_rate_ratio = (int)rintf(d_numchans / d_oversample_rate);
  82   d_idxlut = new int[d_numchans];
  83   for(unsigned int i = 0; i < d_numchans; i++) {
  84     d_idxlut[i] = d_numchans - ((i + d_rate_ratio) % d_numchans) - 1;
  85   }
  86
  87   // Calculate the number of filtering rounds to do to evenly
  88   // align the input vectors with the output channels
  89   d_output_multiple = 1;
  90   while((d_output_multiple * d_rate_ratio) % d_numchans != 0)
  91     d_output_multiple++;
  92   set_output_multiple(d_output_multiple);
  93 }
  94
  95 gr_pfb_channelizer_ccf::~gr_pfb_channelizer_ccf ()
  96 {
  97   delete [] d_idxlut;
  98
  99   for(unsigned int i = 0; i < d_numchans; i++) {
 100     delete d_filters[i];
 101   }
 102 }
 103
 104 void
 105 gr_pfb_channelizer_ccf::set_taps (const std::vector<float> &taps)
 106 {
 107   unsigned int i,j;
 108
 109   unsigned int ntaps = taps.size();
 110   d_taps_per_filter = (unsigned int)ceil((double)ntaps/(double)d_numchans);
 111
 112   // Create d_numchan vectors to store each channel's taps
 113   d_taps.resize(d_numchans);
 114
 115   // Make a vector of the taps plus fill it out with 0's to fill
 116   // each polyphase filter with exactly d_taps_per_filter
 117   std::vector<float> tmp_taps;
 118   tmp_taps = taps;
 119   while((float)(tmp_taps.size()) < d_numchans*d_taps_per_filter) {
 120     tmp_taps.push_back(0.0);
 121   }
 122
 123   // Partition the filter
 124   for(i = 0; i < d_numchans; i++) {
 125     // Each channel uses all d_taps_per_filter with 0's if not enough taps to fill out
 126     d_taps[i] = std::vector<float>(d_taps_per_filter, 0);
 127     for(j = 0; j < d_taps_per_filter; j++) {
 128       d_taps[i][j] = tmp_taps[i + j*d_numchans];  // add taps to channels in reverse order
 129     }
 130
 131     // Build a filter for each channel and add it's taps to it
 132     d_filters[i]->set_taps(d_taps[i]);
 133   }
 134
 135   // Set the history to ensure enough input items for each filter
 136   set_history (d_taps_per_filter+1);
 137
 138   d_updated = true;
 139 }
 140
 141 void
 142 gr_pfb_channelizer_ccf::print_taps()
 143 {
 144   unsigned int i, j;
 145   for(i = 0; i < d_numchans; i++) {
 146     printf("filter[%d]: [", i);
 147     for(j = 0; j < d_taps_per_filter; j++) {
 148       printf(" %.4e", d_taps[i][j]);
 149     }
 150     printf("]\n\n");
 151   }
 152 }
 153
 154
 155 int
 156 gr_pfb_channelizer_ccf::general_work (int noutput_items,
 157                                       gr_vector_int &ninput_items,
 158                                       gr_vector_const_void_star &input_items,
 159                                       gr_vector_void_star &output_items)
 160 {
 161   gr_complex *in = (gr_complex *) input_items[0];
 162   gr_complex *out = (gr_complex *) output_items[0];
 163
 164   if (d_updated) {
 165     d_updated = false;
 166     return 0;                // history requirements may have changed.
 167   }
 168
 169   int n=1, i=-1, j=0, last;
 170   int toconsume = (int)rintf(noutput_items/d_oversample_rate);
 171   while(n <= toconsume) {
 172     j = 0;
 173     i = (i + d_rate_ratio) % d_numchans;
 174     last = i;
 175     while(i >= 0) {
 176       in = (gr_complex*)input_items[j];
 177       d_fft->get_inbuf()[d_idxlut[j]] = d_filters[i]->filter(&in[n]);
 178       j++;
 179       i--;
 180     }
 181
 182     i = d_numchans-1;
 183     while(i > last) {
 184       in = (gr_complex*)input_items[j];
 185       d_fft->get_inbuf()[d_idxlut[j]] = d_filters[i]->filter(&in[n-1]);
 186       j++;
 187       i--;
 188     }
 189
 190     n += (i+d_rate_ratio) >= (int)d_numchans;
 191
 192     // despin through FFT
 193     d_fft->execute();
 194     memcpy(out, d_fft->get_outbuf(), d_numchans*sizeof(gr_complex));
 195     out += d_numchans;
 196   }
 197
 198   consume_each(toconsume);
 199   return noutput_items;
 200 }